litex/migen/actorlib/sim.py

from migen.fhdl.std import *
from migen.flow.actor import *
from migen.flow.transactions import *
from migen.util.misc import xdir

def _sim_multiread(sim, obj):
	if isinstance(obj, Signal):
		return sim.rd(obj)
	else:
		r = {}
		for k, v in xdir(obj, True):
			rd = _sim_multiread(sim, v)
			if isinstance(rd, int) or rd:
				r[k] = rd
		return r

def _sim_multiwrite(sim, obj, value):
	if isinstance(obj, Signal):
		sim.wr(obj, value)
	else:
		for k, v in value.items():
			_sim_multiwrite(sim, getattr(obj, k), v)

# Generators yield None or a tuple of Tokens.
# Tokens for Sink endpoints are pulled and the "value" field filled in.
# Tokens for Source endpoints are pushed according to their "value" field.
#
# NB: the possibility to push several tokens at once is important to interact
# with actors that only accept a group of tokens when all of them are available.
class TokenExchanger(Module):
	def __init__(self, generator, actor):
		self.generator = generator
		self.actor = actor
		self.active = set()
		self.busy = True
		self.done = False

	def _process_transactions(self, selfp):
		completed = set()
		for token in self.active:
			ep = getattr(self.actor, token.endpoint)
			if isinstance(ep, Sink):
				if selfp.simulator.rd(ep.ack) and selfp.simulator.rd(ep.stb):
					token.value = _sim_multiread(selfp.simulator, ep.payload)
					completed.add(token)
					selfp.simulator.wr(ep.ack, 0)
			elif isinstance(ep, Source):
				if selfp.simulator.rd(ep.ack) and selfp.simulator.rd(ep.stb):
					completed.add(token)
					selfp.simulator.wr(ep.stb, 0)
			else:
				raise TypeError
		self.active -= completed
		if not self.active:
			self.busy = True

	def _update_control_signals(self, selfp):
		for token in self.active:
			ep = getattr(self.actor, token.endpoint)
			if isinstance(ep, Sink):
				selfp.simulator.wr(ep.ack, 1)
			elif isinstance(ep, Source):
				_sim_multiwrite(selfp.simulator, ep.payload, token.value)
				selfp.simulator.wr(ep.stb, 1)
			else:
				raise TypeError

	def _next_transactions(self):
		try:
			transactions = next(self.generator)
		except StopIteration:
			self.busy = False
			self.done = True
			raise StopSimulation
		if isinstance(transactions, Token):
			self.active = {transactions}
		elif isinstance(transactions, (tuple, list, set)):
			self.active = set(transactions)
		elif transactions is None:
			self.active = set()
		else:
			raise TypeError
		if self.active and all(transaction.idle_wait for transaction in self.active):
			self.busy = False

	def do_simulation(self, selfp):
		if self.active:
			self._process_transactions(selfp)
		if not self.active:
			self._next_transactions()
			self._update_control_signals(selfp)
	do_simulation.passive = True

class SimActor(Module):
	def __init__(self, generator):
		self.busy = Signal()
		self.submodules.token_exchanger = TokenExchanger(generator, self)

	def do_simulation(self, selfp):
		selfp.busy = self.token_exchanger.busy
	do_simulation.passive = True

def _dumper_gen(prefix):
	while True:
		t = Token("result")
		yield t
		if len(t.value) > 1:
			s = str(t.value)
		else:
			s = str(list(t.value.values())[0])
		print(prefix + s)

class Dumper(SimActor):
	def __init__(self, layout, prefix=""):
		self.result = Sink(layout)
		SimActor.__init__(self, _dumper_gen(prefix))