def completeConnectivity(self, board: Graph,
processAggregator: AbstractProcessAggregator):
"""
Creates all channels and attaches them to embedded snip
:param board: Configured board
:param processAggregator: Aggregator process which holds the mapping of process to embedded snip
:returns: self
"""
snipIdx = 0
for idx, process in enumerate(self.processes):
key = process.getProcessKey()
snip = processAggregator.getEmbeddedSnipForProcessKey(key)
dataChannel = board.createChannel(
'dataChannel_{}_{}'.format(process.chipId, process.lmtId),
messageSize=self.packetSize,
numElements=self.queueSize * self._packetPerSnip[idx])
self._dataChannels.append(dataChannel)
# Incrementing the snip idx
snipIdx += 1
infoChannel = board.createChannel('infoChannel_{}_{}'.format(
process.chipId, process.lmtId),
messageSize=4,
numElements=1)
infoChannel.connect(None, snip)
self._infoChannels.append(infoChannel)
dataSizeChannel = board.createChannel(
'dataSizeChannel_{}_{}'.format(process.chipId, process.lmtId),
messageSize=4,
numElements=1)
dataSizeChannel.connect(None, snip)
self._logger.debug("Created Channel : {}".format(dataSizeChannel))
self._dataSizeChannels.append(dataSizeChannel)
metaDataChannel = board.createChannel(
'metaDataChannel_{}_{}'.format(process.chipId, process.lmtId),
messageSize=4,
numElements=16384)
metaDataChannel.connect(None, snip)
self._logger.debug("Created Channel : {}".format(metaDataChannel))
self._metaDataChannels.append(metaDataChannel)
# Connecting the channel
dataChannel.connect(None, snip)
infoChannel.connect(None, snip)
dataSizeChannel.connect(None, snip)
metaDataChannel.connect(None, snip)
return self
def _createReadoutChannel(self, board: Graph, processAggregator: AbstractProcessAggregator):
"""Create a readout channel to read the classification values from spike counters"""
readout_process = self.processes.readout
processKey = readout_process.getProcessKey()
snip_readout = processAggregator.getEmbeddedSnipForProcessKey(processKey)
self.readout_channel = board.createChannel(bytes('readout', 'utf-8'), "int", numElements=100000)
self.readout_channel.connect(snip_readout, None)
def _createInitializationChannel(self, board: Graph, processAggregator: AbstractProcessAggregator):
"""Creates a channel and connects it to init snip"""
for chip_id in range(board.numChips):
init_process = self.processes['init' + str(chip_id)]
processKey = init_process.getProcessKey()
snip_init_1 = processAggregator.getEmbeddedSnipForProcessKey(processKey)
name = 'channel_init_ch{}_lmt0'.format(chip_id)
setattr(self,
name,
board.createChannel(bytes(name, 'utf-8'), "int", 3))
getattr(self, name).connect(None, snip_init_1)
def completeConnectivity(
self, board: Graph, processAggregator: AbstractProcessAggregator
) -> 'AbstractComposable':
snipIdx = 0
for idx, process in enumerate(self.processes):
key = process.getProcessKey()
snip = processAggregator.getEmbeddedSnipForProcessKey(key)
dataChannel = board.createChannel(
'dataChannel_{}_{}'.format(process.chipId, process.lmtId),
messageSize=self.packetSize * 4,
numElements=self.queueSize * self.packetSize)
self._dataChannels.append(dataChannel)
# Incrementing the snip idx
snipIdx += 1
# Connecting the channel
dataChannel.connect(None, snip)
return self