def __init__(self, config, fifos):
addresslayout = config.addresslayout
nodeidsize = addresslayout.nodeidsize
num_pe = addresslayout.num_pe
# output
self.apply_interface = ApplyInterface(**addresslayout.get_params())
# input override for injecting the message starting the computation
self.start_message = ApplyInterface(**addresslayout.get_params())
self.start_message.select = Signal()
self.fifos = fifos
self.submodules.roundrobin = RoundRobin(num_pe, switch_policy=SP_CE)
# arrays for choosing incoming fifo to use
array_data = Array(fifo.dout.raw_bits() for fifo in fifos)
array_re = Array(fifo.re for fifo in fifos)
array_readable = Array(fifo.readable for fifo in fifos)
array_barrier = Array(fifo.dout.barrier for fifo in fifos)
barrier_reached = Signal()
self.comb += barrier_reached.eq(
reduce(and_, array_barrier) & reduce(and_, array_readable))
self.submodules.outfifo = RecordFIFO(
layout=Message(**addresslayout.get_params()).layout, depth=8)
self.comb += If(
self.start_message.select, # override
self.outfifo.din.raw_bits().eq(self.start_message.msg.raw_bits()),
self.outfifo.we.eq(self.start_message.valid),
self.start_message.ack.eq(self.outfifo.writable),
self.roundrobin.ce.eq(0)
).Elif(
barrier_reached, self.outfifo.din.barrier.eq(1),
self.outfifo.we.eq(1),
[array_re[i].eq(self.outfifo.writable)
for i in range(len(fifos))]).Else( # normal roundrobin
self.outfifo.din.raw_bits().eq(
array_data[self.roundrobin.grant]),
self.outfifo.we.eq(array_readable[self.roundrobin.grant]
& ~array_barrier[self.roundrobin.grant]),
array_re[self.roundrobin.grant].eq(
self.outfifo.writable
& ~array_barrier[self.roundrobin.grant]), [
self.roundrobin.request[i].eq(array_readable[i]
& ~array_barrier[i])
for i in range(len(fifos))
], self.roundrobin.ce.eq(self.outfifo.writable))
self.comb += [
self.apply_interface.msg.raw_bits().eq(
self.outfifo.dout.raw_bits()),
self.apply_interface.valid.eq(self.outfifo.readable),
self.outfifo.re.eq(self.apply_interface.ack)
]
def __init__(self, pe_id, config):
self.network_interface_in = NetworkInterface(
name="left_in", **config.addresslayout.get_params())
self.network_interface_out = NetworkInterface(
name="right_out", **config.addresslayout.get_params())
self.local_interface_in = NetworkInterface(
name="local_in", **config.addresslayout.get_params())
local_interface_out = NetworkInterface(
name="local_out", **config.addresslayout.get_params())
self.apply_interface_out = ApplyInterface(
**config.addresslayout.get_params())
self.start_message = ApplyInterface(
**config.addresslayout.get_params())
self.start_message.select = Signal()
self.network_round = Signal(config.addresslayout.channel_bits)
self.round_accepting = Signal(config.addresslayout.channel_bits)
mux_interface = NetworkInterface(**config.addresslayout.get_params())
inject = Signal()
self.comb += [
inject.eq(
self.local_interface_in.msg.roundpar == self.network_round),
If(
self.network_interface_in.valid &
(self.network_interface_in.msg.roundpar == self.network_round),
self.network_interface_in.connect(mux_interface)).Elif(
inject, self.local_interface_in.connect(mux_interface))
]
self.comb += [
If(mux_interface.dest_pe == pe_id,
mux_interface.connect(local_interface_out)).Else(
mux_interface.connect(self.network_interface_out))
]
self.submodules.barriercounter = Barriercounter(config)
self.comb += [
local_interface_out.msg.connect(
self.barriercounter.apply_interface_in.msg),
self.barriercounter.apply_interface_in.valid.eq(
local_interface_out.valid),
local_interface_out.ack.eq(
self.barriercounter.apply_interface_in.ack),
If(self.start_message.select,
self.start_message.connect(self.apply_interface_out)).Else(
self.barriercounter.apply_interface_out.connect(
self.apply_interface_out)),
self.round_accepting.eq(self.barriercounter.round_accepting)
]
def __init__(self, config):
num_pe = config.addresslayout.num_pe
num_nodes_per_pe = config.addresslayout.num_nodes_per_pe
self.apply_interface = [
ApplyInterface(name="network_out",
**config.addresslayout.get_params())
for _ in range(num_pe)
]
self.network_interface = [
NetworkInterface(name="network_in",
**config.addresslayout.get_params())
for _ in range(num_pe)
]
fifos = [
InterfaceFIFO(layout=set_layout_parameters(
_network_layout, **config.addresslayout.get_params()),
depth=8) for i in range(num_pe)
]
self.submodules.fifos = fifos
self.submodules.arbiter = [
Arbiter(sink, config) for sink in range(num_pe)
]
for i in range(num_pe):
j = (i + 1) % num_pe
self.comb += [
self.arbiter[i].network_interface_out.connect(fifos[i].din),
fifos[i].dout.connect(self.arbiter[j].network_interface_in),
self.network_interface[i].connect(
self.arbiter[i].local_interface_in),
self.arbiter[i].apply_interface_out.connect(
self.apply_interface[i])
]
network_round = Signal(config.addresslayout.channel_bits)
next_round = Signal(config.addresslayout.channel_bits)
proceed = Signal()
self.comb += [
proceed.eq(
reduce(and_,
[a.round_accepting == next_round
for a in self.arbiter])),
If(network_round < config.addresslayout.num_channels - 1,
next_round.eq(network_round + 1)).Else(next_round.eq(0)),
[
self.arbiter[i].network_round.eq(network_round)
for i in range(num_pe)
]
]
self.sync += If(proceed, network_round.eq(next_round))
def __init__(self, pe_id, config):
addresslayout = config.addresslayout
nodeidsize = addresslayout.nodeidsize
num_pe = addresslayout.num_pe
self.pe_id = pe_id
# input (n channels)
self.apply_interface_in = ApplyInterface(name="arbiter_in",
**addresslayout.get_params())
# output
self.apply_interface_out = ApplyInterface(name="arbiter_out",
**addresslayout.get_params())
# input override for injecting the message starting the computation
self.start_message = ApplyInterface(name="start_message",
**addresslayout.get_params())
self.start_message.select = Signal()
self.submodules.barriercounter = Barriercounter(config)
self.current_round = Signal(config.addresslayout.channel_bits)
self.comb += [
self.barriercounter.apply_interface_in.msg.raw_bits().eq(
self.apply_interface_in.msg.raw_bits()),
self.barriercounter.apply_interface_in.valid.eq(
self.apply_interface_in.valid),
self.apply_interface_in.ack.eq(
self.barriercounter.apply_interface_in.ack),
self.current_round.eq(self.barriercounter.round_accepting)
]
# choose between init and regular message channel
self.comb += \
If(self.start_message.select,
self.start_message.connect(self.apply_interface_out)
).Else(
self.barriercounter.apply_interface_out.connect(self.apply_interface_out)
)
def __init__(self, config):
num_pe = config.addresslayout.num_pe
num_nodes_per_pe = config.addresslayout.num_nodes_per_pe
self.apply_interface = [
ApplyInterface(name="network_out",
**config.addresslayout.get_params())
for _ in range(num_pe)
]
self.network_interface = [
NetworkInterface(name="network_in",
**config.addresslayout.get_params())
for _ in range(num_pe)
]
self.submodules.arbiter = [
Arbiter(sink, config) for sink in range(num_pe)
]
self.comb += [
a.apply_interface_out.connect(self.apply_interface[i])
for i, a in enumerate(self.arbiter)
]
def __init__(self, config):
self.apply_interface_in = ApplyInterface(
name="barriercounter_in", **config.addresslayout.get_params())
self.apply_interface_out = ApplyInterface(
name="barriercounter_out", **config.addresslayout.get_params())
self.round_accepting = Signal(config.addresslayout.channel_bits)
apply_interface_in_fifo = InterfaceFIFO(
layout=self.apply_interface_in.layout, depth=2)
self.submodules += apply_interface_in_fifo
self.comb += self.apply_interface_in.connect(
apply_interface_in_fifo.din)
num_pe = config.addresslayout.num_pe
self.barrier_from_pe = Array(Signal() for _ in range(num_pe))
self.num_from_pe = Array(
Signal(config.addresslayout.nodeidsize) for _ in range(num_pe))
self.num_expected_from_pe = Array(
Signal(config.addresslayout.nodeidsize) for _ in range(num_pe))
self.all_from_pe = Array(Signal() for _ in range(num_pe))
self.all_messages_recvd = Signal()
self.all_barriers_recvd = Signal()
self.comb += [
self.all_barriers_recvd.eq(reduce(and_, self.barrier_from_pe)),
self.all_messages_recvd.eq(reduce(and_, self.all_from_pe)),
]
self.comb += [
self.all_from_pe[i].eq(
self.num_from_pe[i] == self.num_expected_from_pe[i])
for i in range(num_pe)
]
halt = Signal()
sender_pe = config.addresslayout.pe_adr(
apply_interface_in_fifo.dout.msg.sender)
self.waiting_for_stragglers = Signal()
self.submodules.fsm = FSM()
self.fsm.act(
"DEFAULT",
If(
self.apply_interface_out.ack,
apply_interface_in_fifo.dout.ack.eq(1),
NextValue(self.apply_interface_out.msg.raw_bits(),
apply_interface_in_fifo.dout.msg.raw_bits()),
NextValue(
self.apply_interface_out.valid,
apply_interface_in_fifo.dout.valid
& ~apply_interface_in_fifo.dout.msg.barrier),
If(
apply_interface_in_fifo.dout.valid,
If(
apply_interface_in_fifo.dout.msg.barrier,
NextValue(self.barrier_from_pe[sender_pe], 1),
NextValue(self.num_expected_from_pe[sender_pe],
apply_interface_in_fifo.dout.msg.dest_id),
If(~apply_interface_in_fifo.dout.msg.halt,
NextValue(halt, 0)), NextState("CHK_BARRIER")).Else(
NextValue(self.num_from_pe[sender_pe],
self.num_from_pe[sender_pe] + 1)))))
self.fsm.act(
"CHK_BARRIER", apply_interface_in_fifo.dout.ack.eq(0),
If(
self.apply_interface_out.ack,
NextValue(self.apply_interface_out.valid, 0),
If(self.all_barriers_recvd,
NextState("PASS_BARRIER")).Else(NextState("DEFAULT"))))
self.fsm.act(
"PASS_BARRIER", apply_interface_in_fifo.dout.ack.eq(0),
If(
self.apply_interface_out.ack,
If(
self.all_messages_recvd,
If(
self.round_accepting <
config.addresslayout.num_channels - 1,
NextValue(self.round_accepting,
self.round_accepting + 1)).Else(
NextValue(self.round_accepting, 0)),
NextValue(halt, 1),
NextValue(self.apply_interface_out.msg.halt, halt),
NextValue(self.apply_interface_out.msg.barrier, 1),
NextValue(self.apply_interface_out.valid, 1), [
NextValue(self.barrier_from_pe[i], 0)
for i in range(num_pe)
],
[NextValue(self.num_from_pe[i], 0) for i in range(num_pe)],
NextState("DEFAULT")).Else(
NextValue(self.apply_interface_out.valid, 0),
NextState("WAIT_FOR_STRAGGLER"))))
self.fsm.act(
"WAIT_FOR_STRAGGLER",
self.waiting_for_stragglers.eq(1),
If(
self.apply_interface_out.ack,
apply_interface_in_fifo.dout.ack.eq(1),
NextValue(self.apply_interface_out.msg.raw_bits(),
apply_interface_in_fifo.dout.msg.raw_bits()),
NextValue(self.apply_interface_out.valid,
apply_interface_in_fifo.dout.valid),
If(
apply_interface_in_fifo.dout.valid,
NextValue(self.num_from_pe[sender_pe],
self.num_from_pe[sender_pe] + 1),
NextState(
"CHK_BARRIER"
) #this gratuitously checks all_barriers_recvd again, but we need to wait an extra cycle for all_messages_recvd to be updated
)))
def __init__(self, config):
self.config = config
assert config.addresslayout.num_fpga == 1
fpga_id = 0
self.pe_start = pe_start = fpga_id * config.addresslayout.num_pe_per_fpga
self.pe_end = pe_end = min(
(fpga_id + 1) * config.addresslayout.num_pe_per_fpga,
config.addresslayout.num_pe)
num_local_pe = pe_end - pe_start
if config.memtype != "BRAM" and config.has_edgedata:
raise NotImplementedError()
self.submodules.portsharer = DDRPortSharer(config=config,
num_ports=num_local_pe)
if config.inverted:
from inverted_apply import Apply
from inverted_scatter import Scatter
from inverted_network import UpdateNetwork
self.submodules.network = UpdateNetwork(config)
else:
from fifo_network import Network
from core_apply import Apply
from core_scatter import Scatter
self.submodules.network = Network(config)
self.submodules.apply = [
Apply(config, i) for i in range(pe_start, pe_end)
]
self.submodules.scatter = [
Scatter(i, config, port=self.portsharer.get_port(i - pe_start))
for i in range(pe_start, pe_end)
]
if config.inverted:
# connect among PEs
for i in range(num_local_pe):
self.comb += [
self.apply[i].scatter_interface.connect(
self.network.apply_interface_in[i]),
self.network.scatter_interface_out[i].connect(
self.scatter[i].scatter_interface)
]
# connection within PEs is done at start_message
else:
# connect within PEs
self.comb += [
self.apply[i].scatter_interface.connect(
self.scatter[i].scatter_interface)
for i in range(num_local_pe)
]
# connect to network
self.comb += [
self.network.apply_interface[i].connect(
self.apply[i].apply_interface) for i in range(num_local_pe)
]
self.comb += [
self.scatter[i].network_interface.connect(
self.network.network_interface[i])
for i in range(num_local_pe)
]
# state of calculation
self.global_inactive = Signal()
if config.inverted:
self.comb += self.global_inactive.eq(self.network.inactive)
else:
self.comb += self.global_inactive.eq(
reduce(and_, [pe.inactive for pe in self.apply]))
self.kernel_error = Signal()
self.comb += self.kernel_error.eq(
reduce(or_,
(a.gatherapplykernel.kernel_error for a in self.apply)))
self.deadlock = Signal()
self.comb += self.deadlock.eq(
reduce(or_, [pe.deadlock for pe in self.apply]))
self.total_num_messages = Signal(32)
self.comb += [
self.total_num_messages.eq(
sum(scatter.total_num_messages for scatter in self.scatter))
]
if config.inverted:
start_message = [
ApplyInterface(name="start_message",
**config.addresslayout.get_params())
for i in range(num_local_pe)
]
for i in range(num_local_pe):
start_message[i].select = Signal()
self.comb += [
If(start_message[i].select, start_message[i].connect(
self.apply[i].apply_interface)).Else(
self.scatter[i].apply_interface.connect(
self.apply[i].apply_interface))
]
else:
start_message = [a.start_message for a in self.network.arbiter]
assert len(start_message) == num_local_pe
injected = [Signal() for i in range(num_local_pe)]
self.start = Signal()
init = Signal()
self.done = Signal()
self.cycle_count = Signal(32)
self.sync += [init.eq(self.start & ~reduce(and_, injected))]
self.comb += [self.done.eq(~init & self.global_inactive)]
for i in range(num_local_pe):
self.comb += [
start_message[i].select.eq(init),
start_message[i].msg.barrier.eq(1),
start_message[i].msg.roundpar.eq(
config.addresslayout.num_channels - 1),
start_message[i].valid.eq(~injected[i])
]
self.sync += [[
If(start_message[i].ack, injected[i].eq(1))
for i in range(num_local_pe)
],
If(~reduce(and_, injected), self.cycle_count.eq(0)).Elif(
~self.global_inactive,
self.cycle_count.eq(self.cycle_count + 1))]
def __init__(self, config):
self.apply_interface_in = ApplyInterface(
name="barriercounter_in", **config.addresslayout.get_params())
self.apply_interface_out = ApplyInterface(
name="barriercounter_out", **config.addresslayout.get_params())
self.round_accepting = Signal(config.addresslayout.channel_bits)
def __init__(self, config):
num_pe = config.addresslayout.num_pe
num_nodes_per_pe = config.addresslayout.num_nodes_per_pe
self.apply_interface = [
ApplyInterface(**config.addresslayout.get_params())
for _ in range(num_pe)
]
self.network_interface = [
NetworkInterface(**config.addresslayout.get_params())
for _ in range(num_pe)
]
fifos = [[
RecordFIFO(
layout=Message(**config.addresslayout.get_params()).layout,
depth=8) for i in range(num_pe)
] for j in range(num_pe)]
self.submodules.fifos = fifos
self.submodules.arbiter = [
Arbiter(config, fifos[sink]) for sink in range(num_pe)
]
self.comb += [
self.arbiter[i].apply_interface.connect(self.apply_interface[i])
for i in range(num_pe)
]
# connect fifos across PEs
for source in range(num_pe):
array_dest_id = Array(
fifo.din.dest_id
for fifo in [fifos[sink][source] for sink in range(num_pe)])
array_sender = Array(
fifo.din.sender
for fifo in [fifos[sink][source] for sink in range(num_pe)])
array_payload = Array(
fifo.din.payload
for fifo in [fifos[sink][source] for sink in range(num_pe)])
array_roundpar = Array(
fifo.din.roundpar
for fifo in [fifos[sink][source] for sink in range(num_pe)])
array_barrier = Array(
fifo.din.barrier
for fifo in [fifos[sink][source] for sink in range(num_pe)])
array_we = Array(
fifo.we
for fifo in [fifos[sink][source] for sink in range(num_pe)])
array_writable = Array(
fifo.writable
for fifo in [fifos[sink][source] for sink in range(num_pe)])
have_barrier = Signal()
barrier_ack = Array(Signal() for _ in range(num_pe))
barrier_done = Signal()
self.comb += barrier_done.eq(reduce(
and_, barrier_ack)), have_barrier.eq(
self.network_interface[source].msg.barrier
& self.network_interface[source].valid)
self.sync += If(have_barrier & ~barrier_done, [
barrier_ack[i].eq(barrier_ack[i] | array_writable[i])
for i in range(num_pe)
]).Else([barrier_ack[i].eq(0) for i in range(num_pe)])
sink = Signal(config.addresslayout.peidsize)
self.comb += If(
have_barrier, [array_barrier[i].eq(1) for i in range(num_pe)],
[
array_roundpar[i].eq(
self.network_interface[source].msg.roundpar)
for i in range(num_pe)
], [array_we[i].eq(~barrier_ack[i]) for i in range(num_pe)],
self.network_interface[source].ack.eq(barrier_done)).Else(
sink.eq(self.network_interface[source].dest_pe),
array_dest_id[sink].eq(
self.network_interface[source].msg.dest_id),
array_sender[sink].eq(
self.network_interface[source].msg.sender),
array_payload[sink].eq(
self.network_interface[source].msg.payload),
array_roundpar[sink].eq(
self.network_interface[source].msg.roundpar),
array_we[sink].eq(self.network_interface[source].valid),
self.network_interface[source].ack.eq(
array_writable[sink]))
def __init__(self, config, pe_id):
self.config = config
self.pe_id = pe_id
addresslayout = config.addresslayout
nodeidsize = addresslayout.nodeidsize
num_nodes_per_pe = addresslayout.num_nodes_per_pe
num_valid_nodes = max(2, len(config.adj_idx[pe_id])+1)
# input Q interface
self.apply_interface = ApplyInterface(name="apply_in", **addresslayout.get_params())
# scatter interface
# send self.update message to all neighbors
# message format (sending_node_id) (normally would be (sending_node_id, weight), but for PR weight = sending_node_id)
self.scatter_interface = ScatterInterface(name="apply_out", **addresslayout.get_params())
self.deadlock = Signal()
####
apply_interface_in_fifo = InterfaceFIFO(layout=self.apply_interface.layout, depth=8, name="apply_in_fifo")
self.submodules += apply_interface_in_fifo
self.comb += self.apply_interface.connect(apply_interface_in_fifo.din)
# local node data storage
self.specials.mem = Memory(layout_len(addresslayout.node_storage_layout), num_valid_nodes, init=config.init_nodedata[pe_id] if config.init_nodedata else None, name="vertex_data_{}".format(self.pe_id))
rd_port = self.specials.rd_port = self.mem.get_port(has_re=True)
wr_port = self.specials.wr_port = self.mem.get_port(write_capable=True)
local_wr_port = Record(layout=get_mem_port_layout(wr_port))
self.external_wr_port = Record(layout=get_mem_port_layout(wr_port) + [("select", 1)])
self.comb += [
If(self.external_wr_port.select,
self.external_wr_port.connect(wr_port, omit={"select"})
).Else(
local_wr_port.connect(wr_port)
)
]
# detect termination (now done by collating votes to halt in barriercounter - if barrier is passed on with halt bit set, don't propagate)
self.inactive = Signal()
self.sync += If(apply_interface_in_fifo.dout.valid & apply_interface_in_fifo.dout.ack & apply_interface_in_fifo.dout.msg.barrier & apply_interface_in_fifo.dout.msg.halt,
self.inactive.eq(1)
)
# should pipeline advance?
upstream_ack = Signal()
collision_re = Signal()
collision_en = Signal()
# count levels
self.level = Signal(32)
## Stage 1
# rename some signals for easier reading, separate barrier and normal valid (for writing to state mem)
dest_node_id = Signal(nodeidsize)
sender = Signal(nodeidsize)
payload = Signal(addresslayout.messagepayloadsize)
roundpar = Signal(config.addresslayout.channel_bits)
valid = Signal()
barrier = Signal()
self.comb += [
dest_node_id.eq(apply_interface_in_fifo.dout.msg.dest_id),
sender.eq(apply_interface_in_fifo.dout.msg.sender),
payload.eq(apply_interface_in_fifo.dout.msg.payload),
roundpar.eq(apply_interface_in_fifo.dout.msg.roundpar),
valid.eq(apply_interface_in_fifo.dout.valid & ~apply_interface_in_fifo.dout.msg.barrier),
barrier.eq(apply_interface_in_fifo.dout.valid & apply_interface_in_fifo.dout.msg.barrier & ~apply_interface_in_fifo.dout.msg.halt),
]
## Stage 2
dest_node_id2 = Signal(nodeidsize)
sender2 = Signal(nodeidsize)
payload2 = Signal(addresslayout.messagepayloadsize)
roundpar2 = Signal(config.addresslayout.channel_bits)
barrier2 = Signal()
valid2 = Signal()
ready = Signal()
msgvalid2 = Signal()
statevalid2 = Signal()
state_barrier = Signal()
node_idx = Signal(nodeidsize)
gather_done = Signal()
next_roundpar = Signal(config.addresslayout.channel_bits)
self.comb += If(roundpar==config.addresslayout.num_channels-1, next_roundpar.eq(0)).Else(next_roundpar.eq(roundpar+1))
self.submodules.fsm = FSM()
self.fsm.act("GATHER",
rd_port.re.eq(upstream_ack),
apply_interface_in_fifo.dout.ack.eq(upstream_ack),
rd_port.adr.eq(addresslayout.local_adr(dest_node_id)),
NextValue(collision_en, 1),
If(~collision_re,
NextValue(valid2, 0) # insert bubble if collision
).Elif(upstream_ack,
NextValue(valid2, valid),
NextValue(dest_node_id2, dest_node_id),
NextValue(sender2, sender),
NextValue(payload2, payload),
NextValue(roundpar2, next_roundpar),
NextValue(statevalid2, 1),
NextValue(msgvalid2, ~barrier),
If(barrier,
NextValue(collision_en, 0),
NextValue(valid2, 0),
NextState("FLUSH")
)
)
)
self.fsm.act("FLUSH",
rd_port.re.eq(0),
NextValue(node_idx, pe_id << log2_int(num_nodes_per_pe)),
apply_interface_in_fifo.dout.ack.eq(0),
rd_port.adr.eq(addresslayout.local_adr(dest_node_id)),
If(gather_done,
NextState("APPLY")
)
)
self.fsm.act("APPLY",
rd_port.re.eq(ready),
apply_interface_in_fifo.dout.ack.eq(0),
rd_port.adr.eq(addresslayout.local_adr(node_idx)),
If(ready,
NextValue(valid2, 1),
NextValue(dest_node_id2, node_idx),
NextValue(node_idx, node_idx+1),
If(node_idx==(len(config.adj_idx[pe_id]) + (pe_id << log2_int(num_nodes_per_pe))),
NextValue(statevalid2, 0),
NextValue(barrier2, 1),
NextValue(valid2, 1),
NextState("BARRIER_SEND")
)
)
)
self.fsm.act("BARRIER_SEND",
apply_interface_in_fifo.dout.ack.eq(0),
rd_port.adr.eq(addresslayout.local_adr(node_idx)),
If(ready,
NextValue(barrier2, 0),
NextValue(valid2, 0),
If(state_barrier,
NextValue(self.level, self.level+1),
NextState("GATHER")
).Else(
NextState("BARRIER_WAIT")
)
)
)
self.fsm.act("BARRIER_WAIT",
If(state_barrier,
NextValue(self.level, self.level+1),
NextState("GATHER")
)
)
# collision handling (combinatorial)
self.submodules.collisiondetector = CollisionDetector(addresslayout)
self.comb += [
self.collisiondetector.read_adr.eq(addresslayout.local_adr(dest_node_id)),
self.collisiondetector.read_adr_valid.eq(ready & valid & collision_en), # can't be rd_port.re because that uses collisiondetector.re -> comb loop
self.collisiondetector.write_adr.eq(local_wr_port.adr),
self.collisiondetector.write_adr_valid.eq(local_wr_port.we),
collision_re.eq(self.collisiondetector.re),
gather_done.eq(self.collisiondetector.all_clear)
]
# User code
if hasattr(config, "gatherapplykernel"):
self.submodules.gatherapplykernel = config.gatherapplykernel(config)
else:
self.submodules.gatherapplykernel = GatherApplyWrapper(config.gatherkernel(config), config.applykernel(config))
self.comb += [
self.gatherapplykernel.level_in.eq(self.level),
self.gatherapplykernel.nodeid_in.eq(dest_node_id2),
self.gatherapplykernel.sender_in.eq(sender2),
self.gatherapplykernel.message_in.raw_bits().eq(payload2),
self.gatherapplykernel.message_in_valid.eq(msgvalid2),
self.gatherapplykernel.state_in.raw_bits().eq(rd_port.dat_r),
self.gatherapplykernel.state_in_valid.eq(statevalid2),
self.gatherapplykernel.round_in.eq(roundpar2),
self.gatherapplykernel.barrier_in.eq(barrier2),
self.gatherapplykernel.valid_in.eq(valid2),
ready.eq(self.gatherapplykernel.ready),
upstream_ack.eq((self.gatherapplykernel.ready | ~valid2) & collision_re)
]
# write state updates
self.comb += [
local_wr_port.adr.eq(addresslayout.local_adr(self.gatherapplykernel.nodeid_out)),
local_wr_port.dat_w.eq(self.gatherapplykernel.state_out.raw_bits()),
state_barrier.eq(self.gatherapplykernel.state_barrier),
local_wr_port.we.eq(self.gatherapplykernel.state_valid),
self.gatherapplykernel.state_ack.eq(1)
]
# output handling
_layout = [
( "barrier", 1, DIR_M_TO_S ),
( "roundpar", config.addresslayout.channel_bits, DIR_M_TO_S ),
( "sender", "nodeidsize", DIR_M_TO_S ),
( "msg" , addresslayout.updatepayloadsize, DIR_M_TO_S )
]
outfifo_in = Record(set_layout_parameters(_layout, **addresslayout.get_params()))
outfifo_out = Record(set_layout_parameters(_layout, **addresslayout.get_params()))
if config.updates_in_hmc:
fpga_id = pe_id//config.addresslayout.num_pe_per_fpga
local_pe_id = pe_id % config.addresslayout.num_pe_per_fpga
self.submodules.outfifo = HMCBackedFIFO(width=len(outfifo_in), start_addr=local_pe_id*(1<<config.hmc_fifo_bits), end_addr=(local_pe_id + 1)*(1<<config.hmc_fifo_bits), port=config.platform[fpga_id].getHMCPort(local_pe_id))
self.sync += [
If(self.outfifo.full, self.deadlock.eq(1))
]
else:
self.submodules.outfifo = SyncFIFO(width=len(outfifo_in), depth=num_valid_nodes)
self.comb += self.deadlock.eq(~self.outfifo.writable)
self.comb += [
self.outfifo.din.eq(outfifo_in.raw_bits()),
outfifo_out.raw_bits().eq(self.outfifo.dout)
]
self.comb += [
outfifo_in.msg.eq(self.gatherapplykernel.update_out.raw_bits()),
If(self.gatherapplykernel.barrier_out, outfifo_in.sender.eq(pe_id << log2_int(num_nodes_per_pe))
).Else(outfifo_in.sender.eq(self.gatherapplykernel.update_sender)),
self.outfifo.we.eq(self.gatherapplykernel.update_valid),
outfifo_in.roundpar.eq(self.gatherapplykernel.update_round),
outfifo_in.barrier.eq(self.gatherapplykernel.barrier_out),
self.gatherapplykernel.update_ack.eq(self.outfifo.writable)
]
payload4 = Signal(addresslayout.updatepayloadsize)
sender4 = Signal(addresslayout.nodeidsize)
roundpar4 = Signal(config.addresslayout.channel_bits)
barrier4 = Signal()
valid4 = Signal()
self.sync += If(self.scatter_interface.ack,
payload4.eq(outfifo_out.msg),
sender4.eq(outfifo_out.sender),
roundpar4.eq(outfifo_out.roundpar),
barrier4.eq(outfifo_out.barrier),
valid4.eq(self.outfifo.readable)
)
self.comb += [
self.scatter_interface.payload.eq(payload4),
self.scatter_interface.sender.eq(sender4),
self.scatter_interface.roundpar.eq(roundpar4),
self.scatter_interface.barrier.eq(barrier4),
self.scatter_interface.valid.eq(valid4)
]
# send from fifo when receiver ready
self.comb += self.outfifo.re.eq(self.scatter_interface.ack)