def __init__(self, MACHINE_IP, parent=None): super(mainWidget, self).__init__(parent) self.setGeometry(0, 0, 640, 480) self.setWindowTitle("SpiNNaker Chips Visualizer") # get info from rig: mc = MachineController(MACHINE_IP) mc.boot() mInfo = mc.get_system_info() w = mInfo.width h = mInfo.height chipList = mInfo.keys() self.vis = visWidget(w, h, chipList, self) self.vis.setGeometry(0, 0, self.width(), self.height())
class MainWindow(QtGui.QMainWindow, QtMainWindow.Ui_qtMainWindow): def __init__(self, parent=None): super(MainWindow, self).__init__(parent) self.setupUi(self) self.setCentralWidget(self.mdiArea) self.statusTxt = QtGui.QLabel("") self.dagFile = QtGui.QLabel("") self.statusBar().addWidget(self.dagFile) self.statusBar().addWidget(self.statusTxt) self.vis = visWidget(self.mdiArea) self.vis.setGeometry(0, 0, 1024, 1024) #self.vis.scale(0.5,0.5) # put in half size self.vis.hide() self.action_Visualiser.setCheckable(True) #self.action_Visualiser.setChecked(False) self.connect(self.action_Quit, QtCore.SIGNAL("triggered()"), QtCore.SLOT("Quit()")) self.connect(self.action_Load_XML, QtCore.SIGNAL("triggered()"), QtCore.SLOT("loadXML()")) self.connect(self.action_Visualiser, QtCore.SIGNAL("triggered()"), QtCore.SLOT("showVisualiser()")) self.connect(self.action_Send_and_Init, QtCore.SIGNAL("triggered()"), QtCore.SLOT("sendAndInit()")) self.connect(self.actionInspect_SpinConf, QtCore.SIGNAL("triggered()"), QtCore.SLOT("testSpin1()")) self.connect(self.actionSet_Tick, QtCore.SIGNAL("triggered()"), QtCore.SLOT("getSimulationTick()")) self.connect(self.actionStart, QtCore.SIGNAL("triggered()"), QtCore.SLOT("startSim()")) self.connect(self.actionStop, QtCore.SIGNAL("triggered()"), QtCore.SLOT("stopSim()")) self.simTick = 1000000 # default value that yield 1second resolution self.output = None # this is a list of list of dict that contains target dependency data """ self.srcTarget = dict() # this similar to self.output, but just contains target for SOURCE node # (as a dict of a list), e.g: from dag0020, srcTarget = {0: [4,3,2]} """ self.srcTarget = list( ) # now scrTarget becomes simpler, because we don't send the trigger's payload self.sdp = sdpComm() self.sdp.histUpdate.connect(self.vis.updateHist) self.mc = MachineController(DEF_HOST) if BOOT_MACHINE is True: if self.mc.boot() is True: print "Machine is now booted..." else: print "Machine is already booted..." self.machineInfo = self.mc.get_system_info() """ self.mc.iptag_set(0,'192.168.240.2',17892,0,0) # prepare iptag for myTub, because boot in rig doesn't provide this if DEF_HOST=='192.168.240.1': self.statusTxt.setText("Using SpiNN-5 board at {}".format(DEF_HOST)) else: self.statusTxt.setText("Using SpiNN-3 board at {}".format(DEF_HOST)) """ self.setGeometry(0, 0, 1024, 1024) @QtCore.pyqtSlot() def Quit(self): # TODO: clean up... self.close() @QtCore.pyqtSlot() def showVisualiser(self): if self.action_Visualiser.isChecked() is True: #self.vis = visWidget(self.mdiArea) # cuman buat sejarah kalau dulu aku letakkan di sini! #self.vis.setGeometry(0,0,1024,1024) self.vis.sceneTimer.start(500) self.vis.show() else: self.vis.hide() self.vis.sceneTimer.stop() @QtCore.pyqtSlot() def loadXML(self): print "Loading XML..." fullPathFileName = QtGui.QFileDialog.getOpenFileName( self, "Open XML file", "./", "*.xml") if not fullPathFileName: print "Cancelled!" else: # Then ask for the appropriate map cbItem = tg2spinMap.keys() # simTick, ok = QtGui.QInputDialog.getInt(self, "Simulation Tick", "Enter Simulation Tick in microsecond", self.simTick, DEF_MIN_TIMER_TICK, 10000000, 1) mapItem, ok = QtGui.QInputDialog.getItem( self, "Select Map", "Which map will be used?", cbItem, 0, False) if ok is True: print "Will use", mapItem # self.initMap(mapItem) self.TGmap = tg2spinMap[str(mapItem)] else: print "Cancelled!" return fi = QtCore.QFileInfo() fi.setFile(fullPathFileName) fn = fi.fileName() self.dagFile.setText("Using {}".format(fn)) print "Processing ", fullPathFileName parser = xml.sax.make_parser() # turn off namespace parser.setFeature(xml.sax.handler.feature_namespaces, 0) # override the default ContextHandler Handler = tgxmlHandler() parser.setContentHandler(Handler) parser.parse(str(fullPathFileName)) if SHOW_PARSING_RESULT: showParsingResult(Handler) """ Let's put the c-like struct as a list: Let's create a variable cfg, which is a list of a dict. Then, let's create a variable dag, which is a list of cfg. Hence, dag is a list of a list of a dict. """ dag = list() for nodes in Handler.Nodes: cfg = list() srcPayload = list() srcFound = False for target in nodes.Target: dct = dict() dct['nodeID'] = nodes.Id dct['destID'] = target.destId dct['nPkt'] = target.nPkt dct['nDependant'] = target.nDependant for d in range(target.nDependant): srcIDkey = "dep{}_srcID".format(d) nTriggerPktkey = "dep{}_nTriggerPkt".format(d) dct[srcIDkey] = target.Dep[d].srcId dct[nTriggerPktkey] = target.Dep[d].nTriggerPkt # also search for SOURCE dependant if target.Dep[d].srcId == DEF_SOURCE_ID: srcFound = True srcPayload.append(target.Dep[d].nTriggerPkt) cfg.append(dct) # and put the payload to the current word in the dict if srcFound: self.srcTarget.append(nodes.Id) # self.srcTarget[nodes.Id] = srcPayload --> ini yang lama sebelum aku REVISI dag.append(cfg) self.output = dag #self.output = experiment_dag0020() # for debugging: print "SpiNNaker usage :", self.TGmap print "TG configuration :", self.output print "Source Target :", self.srcTarget @QtCore.pyqtSlot() def testSpin1(self): """ send a request to dump tgsdp configuration data sendSDP(self, flags, tag, dp, dc, dax, day, cmd, seq, arg1, arg2, arg3, bArray): """ f = NO_REPLY t = DEF_SEND_IPTAG p = DEF_SDP_CONF_PORT c = DEF_SDP_CORE m = TGPKT_HOST_ASK_REPORT for item in self.TGmap: if item != -1 and item != DEF_SOURCE_ID: x, y = getChipXYfromID(self.TGmap, item) #print "Sending a request to <{},{}:{}>".format(x,y,c) self.sdp.sendSDP(f, t, p, c, x, y, m, 0, 0, 0, 0, None) time.sleep(DEF_SDP_TIMEOUT) @QtCore.pyqtSlot() def sendAndInit(self): """ will send aplx to corresponding chip and initialize/configure the chip Assuming that the board has been booted? """ if self.output == None: QtGui.QMessageBox.information(self, "Information", "No valid network structure yet!") return # First, need to translate from node-ID to chip position <x,y>, including the SOURCE and SINK node # use self.TGmap print "Do translation from node to chip..." self.xSrc, self.ySrc = getChipXYfromID(self.TGmap, DEF_SOURCE_ID) appCores = dict() for item in self.TGmap: if item != -1 and item != DEF_SOURCE_ID: x, y = getChipXYfromID(self.TGmap, item) appCores[(x, y)] = [DEF_APP_CORE] print "Application cores :", appCores allChips = dict() for item in CHIP_LIST_48: allChips[(item[0], item[1])] = [DEF_MON_CORE] print "Monitor cores :", allChips # Second, send the aplx (tgsdp.aplx and srcsink.aplx) to the corresponding chip # example: mc.load_application("bla_bla_bla.aplx", {(0,0):[1,2,10,17]}, app_id=16) # so, the chip is a tupple and cores is in a list!!! # Do you want something nice? Use QFileDialog print "Send iptag...", self.mc.iptag_set( DEF_TUBO_IPTAG, '192.168.240.2', DEF_TUBO_PORT, 0, 0 ) # prepare iptag for myTub, because boot in rig doesn't provide this self.mc.iptag_set(DEF_REPORT_IPTAG, '192.168.240.2', DEF_REPORT_PORT, 0, 0) if DEF_HOST == '192.168.240.1': self.statusTxt.setText( "Using SpiNN-5 board at {}".format(DEF_HOST)) else: self.statusTxt.setText( "Using SpiNN-3 board at {}".format(DEF_HOST)) print "done!" print "Send the aplxs to the corresponding chips...", srcsinkaplx = "/local/new_home/indi/Projects/P/Graceful_TG_SDP_virtualenv/src/aplx/srcsink.aplx" tgsdpaplx = "/local/new_home/indi/Projects/P/Graceful_TG_SDP_virtualenv/src/aplx/tgsdp.aplx" monaplx = "/local/new_home/indi/Projects/P/Graceful_TG_SDP_virtualenv/src/aplx/monitor.aplx" self.mc.load_application(srcsinkaplx, {(self.xSrc, self.ySrc): [DEF_APP_CORE]}, app_id=APPID_SRCSINK) self.mc.load_application(tgsdpaplx, appCores, app_id=APPID_TGSDP) self.mc.load_application(monaplx, allChips, app_id=APPID_MONITOR) print "done!" # Debugging: why some chips generate WDOG? self.sdp.sendPing(self.TGmap) # Third, send the configuration to the corresponding node print "Sending the configuration data to the corresponding chip...", for node in self.output: # self.output should be a list of a list of a dict #print "Node =",node time.sleep( DEF_SDP_TIMEOUT ) # WEIRD!!!! If I remove this, then node-0 will be corrupted!!! self.sdp.sendConfig(self.TGmap, node) print "done!" print "Sending special configuration to SOURCE/SINK node...", # TODO: send the source target list!!! self.sdp.sendSourceTarget( self.TGmap, self.srcTarget) # butuh TGmap karena butuh xSrc dan ySrc print "done! ---------- WAIT, Abaikan nilai payload-nya!!!! ------------" # NOTE: di bagian sdp.sendSourceTarget() tidak aku ubah untuk akomodasi hal tersebut!!!!!!!!! # Jadi, sangat tergantung srcsink.c untuk betulin-nya!!!! print "Sending network map...", self.sdp.sendChipMap(self.TGmap) print "done! SpiNNaker is ready for TGSDP simulation (set tick if necessary)!" # TODO: 1. Baca P2P table # 2. Petakan dan kirim ke tgsdpvis.py. Nanti tgsdpvis.py akan memberi warna apasihini = self.mc.get_system_info() p2p_tables = {(x, y): self.mc.get_p2p_routing_table(x, y) for x, y in self.mc.get_system_info()} #for c in apasihini.chips(): # print c @QtCore.pyqtSlot() def getSimulationTick(self): simTick, ok = QtGui.QInputDialog.getInt( self, "Simulation Tick", "Enter Simulation Tick in microsecond", self.simTick, DEF_MIN_TIMER_TICK, 10000000, 1) if ok is True: print "Sending tick {} microseconds".format(simTick) self.simTick = simTick self.sdp.sendSimTick(self.xSrc, self.ySrc, simTick) @QtCore.pyqtSlot() def startSim(self): self.actionStop.setEnabled(True) self.actionStart.setEnabled(False) self.sdp.sendStartCmd(self.xSrc, self.ySrc) @QtCore.pyqtSlot() def stopSim(self): self.actionStop.setEnabled(False) self.actionStart.setEnabled(True) # self.sdp.sendStopCmd(self.xSrc, self.ySrc) #-> only to SOURCE/SINK node self.sdp.sendStopCmd(self.xSrc, self.ySrc, self.TGmap) #-> to all nodes
class MainWindow(QtGui.QMainWindow, QtMainWindow.Ui_qtMainWindow): def __init__(self, cli_param, parent=None): super(MainWindow, self).__init__(parent) self.setupUi(self) self.setCentralWidget(self.mdiArea) self.statusTxt = QtGui.QLabel("") self.dagFile = QtGui.QLabel("") self.statusBar().addWidget(self.dagFile) self.statusBar().addWidget(self.statusTxt) # connect to the machine if len(cli_param) > 1: ip = cli_param[1] if len(cli_param) > 2: self.myPC = cli_param[2] else: self.myPC = DEF_MYPC else: ip, ok = QtGui.QInputDialog.getText(None, "Connect to SpiNNaker", "Please specify machine IP", QtGui.QLineEdit.Normal, DEF_HOST) if ok is False: ip = '' print "Using machine at", ip self.mc = MachineController(ip) if BOOT_MACHINE is True: if self.mc.boot() is True: print "Machine is now booted..." else: print "Machine is already booted..." # then use machineInfo to build the map self.mInfo = self.mc.get_system_info() wMachine = self.mInfo.width hMachine = self.mInfo.height self.chipList = self.mInfo.keys() print "Found", len(self.chipList), "active chips:" """ self.mc.iptag_set(0,'192.168.240.2',17892,0,0) # prepare iptag for myTub, because boot in rig doesn't provide this if DEF_HOST=='192.168.240.1': self.statusTxt.setText("Using SpiNN-5 board at {}".format(DEF_HOST)) else: self.statusTxt.setText("Using SpiNN-3 board at {}".format(DEF_HOST)) """ #self.vis = visWidget(wMachine, hMachine, self.chipList, self.mdiArea) # for known dead chips on certain boards knownDeadChips = [] if (len(self.chipList) % 48) != 0: # dead chip is detected lst = QtGui.QInputDialog.getText( self, "Dead chip is detected", "Please provide chip coordinate in () separated by space", QtGui.QLineEdit.Normal, "(0,2)") knownDeadChips = getDeadChipList(lst) self.tgvisWidget = visWidget(wMachine, hMachine, self.chipList, knownDeadChips) self.vis = tgViever(self.tgvisWidget) #self.vis.setGeometry(0,0,1024,1024) #self.vis.scale(0.5,0.5) # put in half size self.vis.hide() self.action_Visualiser.setCheckable(True) #self.action_Visualiser.setChecked(False) self.connect(self.action_Quit, QtCore.SIGNAL("triggered()"), QtCore.SLOT("Quit()")) self.connect(self.action_Load_XML, QtCore.SIGNAL("triggered()"), QtCore.SLOT("loadXML()")) self.connect(self.action_Visualiser, QtCore.SIGNAL("triggered()"), QtCore.SLOT("showVisualiser()")) self.connect(self.action_Send_and_Init, QtCore.SIGNAL("triggered()"), QtCore.SLOT("sendAndInit()")) self.connect(self.actionInspect_SpinConf, QtCore.SIGNAL("triggered()"), QtCore.SLOT("testSpin1()")) self.connect(self.actionSet_Tick, QtCore.SIGNAL("triggered()"), QtCore.SLOT("getSimulationTick()")) self.connect(self.actionStart, QtCore.SIGNAL("triggered()"), QtCore.SLOT("startSim()")) self.connect(self.actionStop, QtCore.SIGNAL("triggered()"), QtCore.SLOT("stopSim()")) # 22 March 2017 - 11:48 - Buat experiment ambil data untuk paper self.timer = QtCore.QTimer(self) #self.timer.setInterval(60000) # one minute experiment self.timer.timeout.connect(self.timeout) # Simulation parameters self.simTick = 1000000 # default value that yield 1second resolution self.runningTime = 0 # 0 means runs forever self.dag = None # this is a list of list of dict that contains target dependency data """ self.srcTarget = dict() # this similar to self.dag, but just contains target for SOURCE node # (as a dict of a list), e.g: from dag0020, srcTarget = {0: [4,3,2]} """ self.srcTarget = list( ) # now scrTarget becomes simpler, because we don't send the trigger's payload self.sdp = sdpComm(self.chipList, ip) self.sdp.histUpdate.connect(self.vis.updateHist) self.setGeometry(0, 0, 1024, 1024) @QtCore.pyqtSlot() def timeout(self): """ Ini buat ambil data. Setelah jalan 1 menit, otomatis stop. Kemudian lihat iobuf dari srcsink node! :return: """ self.stopSim() self.timer.stop() def closeEvent(self, e): self.vis.close() e.accept() @QtCore.pyqtSlot() def Quit(self): # TODO: clean up... self.close() @QtCore.pyqtSlot() def showVisualiser(self): if self.action_Visualiser.isChecked() is True: #self.vis = visWidget(self.mdiArea) # cuman buat sejarah kalau dulu aku letakkan di sini! #self.vis.setGeometry(0,0,1024,1024) self.vis.animate() #self.vis.sceneTimer.start(500) self.vis.show() else: self.vis.deanimate() self.vis.hide() #self.vis.sceneTimer.stop() def buildMap(self): """ Let's build map correctly :input: self.dag :output: self.TGmap """ def readTGmap(self, fname, chipList, numNode): """ Read TGmap configuration from the given fname :param fname: .tgmap configuration file :param chipList: a dict() that contains all active chip coordinate in the machine :return: list() if success, otherwise None """ result = None ok = False with open(fname, 'r') as fid: dct = dict() nodeFound = 0 for line in fid: #print "line:", line idFromXY = getChipIDfromXY(line) if idFromXY is not None: dct.update(idFromXY) nodeFound += 1 if len(dct) > 0: print "Found", nodeFound, "nodes (including SRC/SINK)" result = [-1 for _ in range(len(chipList))] for i in range(len(chipList)): try: result[i] = dct[chipList[i]] except KeyError: result[i] = -1 if nodeFound == numNode + 1: ok = True return result, ok @QtCore.pyqtSlot() def loadXML(self): print "Loading XML..." fullPathFileName = QtGui.QFileDialog.getOpenFileName( self, "Open XML file", "./", "*.xml") if not fullPathFileName: print "Cancelled!" else: fi = QtCore.QFileInfo() fi.setFile(fullPathFileName) fn = fi.fileName() self.dagFile.setText("Using {}".format(fn)) print "Processing ", fullPathFileName parser = xml.sax.make_parser() # turn off namespace parser.setFeature(xml.sax.handler.feature_namespaces, 0) # override the default ContextHandler Handler = tgxmlHandler() parser.setContentHandler(Handler) parser.parse(str(fullPathFileName)) if SHOW_PARSING_RESULT: showParsingResult(Handler) """ Let's put the c-like struct as a list: Let's create a variable cfg, which is a list of a dict. Then, let's create a variable dag, which is a list of cfg. Hence, dag is a list of a list of a dict. """ dag = list() for nodes in Handler.Nodes: cfg = list() srcPayload = list() srcFound = False for target in nodes.Target: dct = dict() dct['nodeID'] = nodes.Id dct['destID'] = target.destId dct['nPkt'] = target.nPkt dct['nDependant'] = target.nDependant for d in range(target.nDependant): srcIDkey = "dep{}_srcID".format(d) nTriggerPktkey = "dep{}_nTriggerPkt".format(d) dct[srcIDkey] = target.Dep[d].srcId dct[nTriggerPktkey] = target.Dep[d].nTriggerPkt # also search for SOURCE dependant if target.Dep[d].srcId == DEF_SOURCE_ID: srcFound = True srcPayload.append(target.Dep[d].nTriggerPkt) cfg.append(dct) # and put the payload to the current word in the dict if srcFound: self.srcTarget.append(nodes.Id) # self.srcTarget[nodes.Id] = srcPayload --> ini yang lama sebelum aku REVISI dag.append(cfg) self.dag = dag #self.dag = experiment_dag0020() # for debugging: #print "SpiNNaker usage :", self.TGmap if SHOW_PARSING_RESULT: print "TG configuration :", self.dag #print len(self.dag) print "Source Target :", self.srcTarget # then load the TGmap configuration file tgmapConfigFile = QtGui.QFileDialog.getOpenFileName( self, "Open TGmap file", "./", "*.tgmap") if not tgmapConfigFile: print "Cancelled!" self.dag = None self.srcTarget = list() return tgmap, ok = self.readTGmap(tgmapConfigFile, self.chipList, len(self.dag)) if tgmap is None: print "Failed to get correct TGmap configuration!" # then cancel the operation and reset self.dag = None self.srcTarget = list() return else: if ok: #print tgmap print "Loaded tgmap from:", tgmapConfigFile self.TGmap = tgmap else: print "Missing node is detected! Maybe dead chip?" # then cancel the operation and reset self.dag = None self.srcTarget = list() """ # Then ask for the appropriate map cbItem = tg2spinMap.keys(); # simTick, ok = QtGui.QInputDialog.getInt(self, "Simulation Tick", "Enter Simulation Tick in microsecond", self.simTick, DEF_MIN_TIMER_TICK, 10000000, 1) mapItem, ok = QtGui.QInputDialog.getItem(self, "Select Map", "Which map will be used?", cbItem, 0, False) if ok is True: print "Will use",mapItem,':',tg2spinMap[str(mapItem)] # self.initMap(mapItem) self.TGmap = tg2spinMap[str(mapItem)] else: print "Cancelled!" return """ # continue with send and init? contSendInit = QtGui.QMessageBox.question( self, "Continue", "Continue with Send and Init?", QtGui.QMessageBox.Ok | QtGui.QMessageBox.Cancel) if contSendInit == QtGui.QMessageBox.Ok: self.sendAndInit() else: QtGui.QMessageBox.information( self, "Done", "Loading XML and TGmap is done! You can continue with Send and Init!" ) @QtCore.pyqtSlot() def testSpin1(self): """ send a request to dump tgsdp configuration data sendSDP(self, flags, tag, dp, dc, dax, day, cmd, seq, arg1, arg2, arg3, bArray): """ f = NO_REPLY t = DEF_SEND_IPTAG p = DEF_SDP_CONF_PORT c = DEF_SDP_CORE m = TGPKT_HOST_ASK_REPORT for item in self.TGmap: if item != -1 and item != DEF_SOURCE_ID: x, y = getChipXYfromID(self.TGmap, item, self.chipList) #print "Sending a request to <{},{}:{}>".format(x,y,c) self.sdp.sendSDP(f, t, p, c, x, y, m, 0, 0, 0, 0, None) time.sleep(DEF_SDP_TIMEOUT) @QtCore.pyqtSlot() def sendAndInit(self): """ will send aplx to corresponding chip and initialize/configure the chip Assuming that the board has been booted? """ if self.dag == None: QtGui.QMessageBox.information(self, "Information", "No valid network structure yet!") return # First, need to translate from node-ID to chip position <x,y>, including the SOURCE and SINK node # use self.TGmap print "Doing translation from node to chip..." self.xSrc, self.ySrc = getChipXYfromID(self.TGmap, DEF_SOURCE_ID, self.chipList) appCores = dict() for item in self.TGmap: if item != -1 and item != DEF_SOURCE_ID: x, y = getChipXYfromID(self.TGmap, item, self.chipList) appCores[(x, y)] = [DEF_APP_CORE] if SHOW_PARSING_RESULT: print "Application cores :", appCores allChips = dict() for item in self.chipList: allChips[(item[0], item[1])] = [DEF_MON_CORE] if SHOW_PARSING_RESULT: print "Monitor cores :", allChips # Second, send the aplx (tgsdp.aplx and srcsink.aplx) to the corresponding chip # example: mc.load_application("bla_bla_bla.aplx", {(0,0):[1,2,10,17]}, app_id=16) # so, the chip is a tupple and cores is in a list!!! # Do you want something nice? Use QFileDialog if ENABLE_IPTAG: print "Send iptag..." self.mc.iptag_set( DEF_TUBO_IPTAG, self.myPC, DEF_TUBO_PORT, 0, 0 ) # prepare iptag for myTub, because boot in rig doesn't provide this self.mc.iptag_set(DEF_REPORT_IPTAG, self.myPC, DEF_REPORT_PORT, 0, 0) print "Send the aplxs to the corresponding chips...", srcsinkaplx = "/local/new_home/indi/Projects/P/Graceful_TG_SDP_virtualenv/src/aplx/srcsink.aplx" tgsdpaplx = "/local/new_home/indi/Projects/P/Graceful_TG_SDP_virtualenv/src/aplx/tgsdp.aplx" monaplx = "/local/new_home/indi/Projects/P/Graceful_TG_SDP_virtualenv/src/aplx/monitor.aplx" self.mc.load_application(srcsinkaplx, {(self.xSrc, self.ySrc): [DEF_APP_CORE]}, app_id=APPID_SRCSINK) self.mc.load_application(tgsdpaplx, appCores, app_id=APPID_TGSDP) self.mc.load_application(monaplx, allChips, app_id=APPID_MONITOR) time.sleep(5) self.mc.send_signal('sync0', app_id=APPID_SRCSINK) self.mc.send_signal('sync0', app_id=APPID_TGSDP) self.mc.send_signal('sync0', app_id=APPID_MONITOR) print "done!" # Debugging: why some chips generate WDOG? self.sdp.sendPing(self.TGmap) # Third, send the configuration to the corresponding node print "Sending the configuration data to the corresponding chip...", for node in self.dag: # self.dag should be a list of a list of a dict #print "Node =",node time.sleep( DEF_SDP_TIMEOUT ) # WEIRD!!!! If I remove this, then node-0 will be corrupted!!! self.sdp.sendConfig(self.TGmap, node) print "done!" print "Sending special configuration to SOURCE/SINK node...", # TODO: send the source target list!!! self.sdp.sendSourceTarget( self.TGmap, self.srcTarget) # butuh TGmap karena butuh xSrc dan ySrc print "done! ---------- WAIT, Abaikan nilai payload-nya!!!! ------------" # NOTE: di bagian sdp.sendSourceTarget() tidak aku ubah untuk akomodasi hal tersebut!!!!!!!!! # Jadi, sangat tergantung srcsink.c untuk betulin-nya!!!! print "Sending network map...", self.sdp.sendChipMap(self.TGmap) print "done! SpiNNaker is ready for TGSDP simulation (set tick if necessary)!" QtGui.QMessageBox.information( self, "Done", "SpiNNaker is ready for TGSDP simulation (set tick if necessary)!") # TODO: 1. Baca P2P table # 2. Petakan dan kirim ke tgsdpvis.py. Nanti tgsdpvis.py akan memberi warna apasihini = self.mc.get_system_info() p2p_tables = {(x, y): self.mc.get_p2p_routing_table(x, y) for x, y in self.mc.get_system_info()} #for c in apasihini.chips(): # print c @QtCore.pyqtSlot() def getSimulationTick(self): simTick, ok = QtGui.QInputDialog.getInt( self, "Simulation Tick", "Enter Simulation Tick in microsecond", self.simTick, DEF_MIN_TIMER_TICK, 1000, 1) if ok is True: print "Sending tick {} microseconds".format(simTick) self.simTick = simTick self.sdp.sendSimTick(self.xSrc, self.ySrc, simTick) @QtCore.pyqtSlot() def startSim(self): # First ask, for how long msLong, ok = QtGui.QInputDialog.getInt( self, "Running Time", "Enter simulation running time (in ms)", 60000, DEF_MIN_RUNNING_TIME, DEF_MAX_RUNNING_TIME, 1) if ok: self.runningTime = msLong self.actionStop.setEnabled(True) self.actionStart.setEnabled(False) self.sdp.sendStartCmd(self.xSrc, self.ySrc) print "Starting simulation..." # untuk ambil data, buat timer: if self.runningTime > 0: print "Set interval to", self.runningTime, "ms" self.timer.setInterval(self.runningTime) self.timer.start() @QtCore.pyqtSlot() def stopSim(self): if self.timer.isActive(): self.timer.stop() self.actionStop.setEnabled(False) self.actionStart.setEnabled(True) # self.sdp.sendStopCmd(self.xSrc, self.ySrc) #-> only to SOURCE/SINK node self.sdp.sendStopCmd(self.xSrc, self.ySrc, self.TGmap) #-> to all nodes print "Experimen selesai. Sekarang lihat iobuf core-1 di chip<0,0> (srcsink node)" QtGui.QMessageBox.information( self, "Experiment Done!", "Look the result at iobuf core-1 in chip<0,0> (srcsink node)!")
def run(self): """Run the simulation.""" # Define the resource requirements of each component in the simulation. vertices_resources = { # Every component runs on exactly one core and consumes a certain # amount of SDRAM to hold configuration data. component: {Cores: 1, SDRAM: component._get_config_size()} for component in self._components } # Work out what SpiNNaker application needs to be loaded for each # component vertices_applications = {component: component._get_kernel() for component in self._components} # Convert the Wire objects into Rig Net objects and create a lookup # from Net to the (key, mask) to use. net_keys = {Net(wire.source, wire.sinks): (wire.routing_key, 0xFFFFFFFF) for wire in self._wires} nets = list(net_keys) # Boot the SpiNNaker machine and interrogate it to determine what # resources (e.g. cores, SDRAM etc.) are available. mc = MachineController(self._hostname) mc.boot() system_info = mc.get_system_info() # Automatically chose which chips and cores to use for each component # and generate routing tables. placements, allocations, application_map, routing_tables = \ place_and_route_wrapper(vertices_resources, vertices_applications, nets, net_keys, system_info) with mc.application(): # Allocate memory for configuration data, tagged by core number. memory_allocations = sdram_alloc_for_vertices(mc, placements, allocations) # Load the configuration data for all components for component, memory in memory_allocations.items(): component._write_config(memory) # Load all routing tables mc.load_routing_tables(routing_tables) # Load all SpiNNaker application kernels mc.load_application(application_map) # Wait for all six cores to reach the 'sync0' barrier mc.wait_for_cores_to_reach_state("sync0", len(self._components)) # Send the 'sync0' signal to start execution and wait for the # simulation to finish. mc.send_signal("sync0") time.sleep(self.length * 0.001) mc.wait_for_cores_to_reach_state("exit", len(self._components)) # Retrieve result data for component, memory in memory_allocations.items(): component._read_results(memory)
class Simulator(object): """SpiNNaker simulator for Nengo models. The simulator period determines how much data will be stored on SpiNNaker and is the maximum length of simulation allowed before data is transferred between the machine and the host PC. If the period is set to `None` function of time Nodes will not be optimised and probes will be disabled. For any other value simulation lengths of less than or equal to the period will be in real-time, longer simulations will be possible but will include short gaps when data is transferred between SpiNNaker and the host. :py:meth:`~.close` should be called when the simulator will no longer be used. This will close all sockets used to communicate with the SpiNNaker machine and will leave the machine in a clean state. Failure to call `close` may result in later failures. Alternatively `with` may be used:: sim = nengo_spinnaker.Simulator(network) with sim: sim.run(10.0) """ _open_simulators = set() @classmethod def _add_simulator(cls, simulator): cls._open_simulators.add(simulator) @classmethod def _remove_simulator(cls, simulator): cls._open_simulators.remove(simulator) def __init__(self, network, dt=0.001, period=10.0, timescale=1.0, hostname=None, use_spalloc=None, allocation_fudge_factor=0.6): """Create a new Simulator with the given network. Parameters ---------- period : float or None Duration of one period of the simulator. This determines how much memory will be allocated to store precomputed and probed data. timescale : float Scaling factor to apply to the simulation, e.g., a value of `0.5` will cause the simulation to run at half real-time. hostname : string or None Hostname of the SpiNNaker machine to use; if None then the machine specified in the config file will be used. use_spalloc : bool or None Allocate a SpiNNaker machine for the simulator using ``spalloc``. If None then the setting specified in the config file will be used. Other Parameters ---------------- allocation_fudge_factor: Fudge factor to allocate more cores than really necessary when using `spalloc` to ensure that (a) there are sufficient "live" cores in the allocated machine, (b) there is sufficient room for a good place and route solution. This should generally be more than 0.1 (10% more cores than necessary) to account for the usual rate of missing chips. """ # Add this simulator to the set of open simulators Simulator._add_simulator(self) # Create the IO controller io_cls = getconfig(network.config, Simulator, "node_io", Ethernet) io_kwargs = getconfig(network.config, Simulator, "node_io_kwargs", dict()) self.io_controller = io_cls(**io_kwargs) # Calculate the machine timestep, this is measured in microseconds # (hence the 1e6 scaling factor). self.timescale = timescale machine_timestep = int((dt / timescale) * 1e6) # Determine the maximum run-time self.max_steps = None if period is None else int(period / dt) self.steps = 0 # Steps simulated # If the simulator is in "run indefinite" mode (i.e., max_steps=None) # then we modify the builders to ignore function of time Nodes and # probes. builder_kwargs = self.io_controller.builder_kwargs if self.max_steps is None: raise NotImplementedError # Create a model from the network, using the IO controller logger.debug("Building model") start_build = time.time() self.model = Model(dt=dt, machine_timestep=machine_timestep, decoder_cache=get_default_decoder_cache()) self.model.build(network, **builder_kwargs) logger.info("Build took {:.3f} seconds".format(time.time() - start_build)) self.model.decoder_cache.shrink() self.dt = self.model.dt self._closed = False # Whether the simulator has been closed or not self.host_sim = self._create_host_sim() # Holder for probe data self.data = {} # Holder for profiling data self.profiler_data = {} # Convert the model into a netlist logger.info("Building netlist") start = time.time() self.netlist = self.model.make_netlist(self.max_steps or 0) # Determine whether to use a spalloc machine or not if use_spalloc is None: # Default is to not use spalloc; this is indicated by either the # absence of the option in the config file OR the option being set # to false. use_spalloc = (rc.has_option("spinnaker_machine", "use_spalloc") and rc.getboolean("spinnaker_machine", "use_spalloc")) # Create a controller for the machine and boot if necessary self.job = None if not use_spalloc or hostname is not None: # Use the specified machine rather than trying to get one # allocated. if hostname is None: hostname = rc.get("spinnaker_machine", "hostname") else: # Attempt to get a machine allocated to us from spalloc import Job # Determine how many boards to ask for (assuming 16 usable cores # per chip and 48 chips per board). n_cores = self.netlist.n_cores * (1.0 + allocation_fudge_factor) n_boards = int(np.ceil((n_cores / 16.) / 48.)) # Request the job self.job = Job(n_boards) logger.info("Allocated job ID %d...", self.job.id) # Wait until we're given the machine logger.info("Waiting for machine allocation...") self.job.wait_until_ready() # spalloc recommends a slight delay before attempting to boot the # machine, later versions of spalloc server may relax this # requirement. time.sleep(5.0) # Store the hostname hostname = self.job.hostname logger.info("Using %d board(s) of \"%s\" (%s)", len(self.job.boards), self.job.machine_name, hostname) self.controller = MachineController(hostname) self.controller.boot() # Get a system-info object to place & route against logger.info("Getting SpiNNaker machine specification") system_info = self.controller.get_system_info() # Place & Route logger.info("Placing and routing") self.netlist.place_and_route( system_info, place=getconfig(network.config, Simulator, 'placer', rig.place_and_route.place), place_kwargs=getconfig(network.config, Simulator, 'placer_kwargs', {}), ) logger.info("{} cores in use".format(len(self.netlist.placements))) chips = set(six.itervalues(self.netlist.placements)) logger.info("Using {}".format(chips)) # Prepare the simulator against the placed, allocated and routed # netlist. self.io_controller.prepare(self.model, self.controller, self.netlist) # Load the application logger.info("Loading application") self.netlist.load_application(self.controller, system_info) # Check if any cores are in bad states if self.controller.count_cores_in_state( ["exit", "dead", "watchdog", "runtime_exception"]): for vertex, (x, y) in six.iteritems(self.netlist.placements): p = self.netlist.allocations[vertex][Cores].start status = self.controller.get_processor_status(p, x, y) if status.cpu_state is not AppState.sync0: print("Core ({}, {}, {}) in state {!s}".format( x, y, p, status)) print(self.controller.get_iobuf(p, x, y)) raise Exception("Unexpected core failures.") logger.info("Preparing and loading machine took {:3f} seconds".format( time.time() - start)) logger.info("Setting router timeout to 16 cycles") for x, y in system_info.chips(): with self.controller(x=x, y=y): data = self.controller.read(0xf1000000, 4) self.controller.write(0xf1000000, data[:-1] + b'\x10') def __enter__(self): """Enter a context which will close the simulator when exited.""" # Return self to allow usage like: # # with nengo_spinnaker.Simulator(model) as sim: # sim.run(1.0) return self def __exit__(self, exception_type, exception_value, traceback): """Exit a context and close the simulator.""" self.close() def run(self, time_in_seconds): """Simulate for the given length of time.""" # Determine how many steps to simulate for steps = int(np.round(float(time_in_seconds) / self.dt)) self.run_steps(steps) def run_steps(self, steps): """Simulate a give number of steps.""" while steps > 0: n_steps = min((steps, self.max_steps)) self._run_steps(n_steps) steps -= n_steps def _run_steps(self, steps): """Simulate for the given number of steps.""" if self._closed: raise Exception("Simulator has been closed and can't be used to " "run further simulations.") if steps is None: if self.max_steps is not None: raise Exception( "Cannot run indefinitely if a simulator period was " "specified. Create a new simulator with Simulator(model, " "period=None) to perform indefinite time simulations.") else: assert steps <= self.max_steps # Prepare the simulation self.netlist.before_simulation(self, steps) # Wait for all cores to hit SYNC0 (either by remaining it or entering # it from init) self._wait_for_transition(AppState.init, AppState.sync0, self.netlist.n_cores) self.controller.send_signal("sync0") # Get a new thread for the IO io_thread = self.io_controller.spawn() # Run the simulation try: # Prep exp_time = steps * self.dt / self.timescale io_thread.start() # Wait for all cores to hit SYNC1 self._wait_for_transition(AppState.sync0, AppState.sync1, self.netlist.n_cores) logger.info("Running simulation...") self.controller.send_signal("sync1") # Execute the local model host_steps = 0 start_time = time.time() run_time = 0.0 local_timestep = self.dt / self.timescale while run_time < exp_time: # Run a step self.host_sim.step() run_time = time.time() - start_time # If that step took less than timestep then spin time.sleep(0.0001) while run_time < host_steps * local_timestep: time.sleep(0.0001) run_time = time.time() - start_time finally: # Stop the IO thread whatever occurs io_thread.stop() # Wait for cores to re-enter sync0 self._wait_for_transition(AppState.run, AppState.sync0, self.netlist.n_cores) # Retrieve simulation data start = time.time() logger.info("Retrieving simulation data") self.netlist.after_simulation(self, steps) logger.info("Retrieving data took {:3f} seconds".format(time.time() - start)) # Increase the steps count self.steps += steps def _wait_for_transition(self, from_state, desired_to_state, num_verts): while True: # If no cores are still in from_state, stop if self.controller.count_cores_in_state(from_state) == 0: break # Wait a bit time.sleep(1.0) # Check if any cores haven't exited cleanly num_ready = self.controller.wait_for_cores_to_reach_state( desired_to_state, num_verts, timeout=5.0) if num_ready != num_verts: # Loop through all placed vertices for vertex, (x, y) in six.iteritems(self.netlist.placements): p = self.netlist.allocations[vertex][Cores].start status = self.controller.get_processor_status(p, x, y) if status.cpu_state is not desired_to_state: print("Core ({}, {}, {}) in state {!s}".format( x, y, p, status.cpu_state)) print(self.controller.get_iobuf(p, x, y)) raise Exception("Unexpected core failures before reaching %s " "state." % desired_to_state) def _create_host_sim(self): # change node_functions to reflect time # TODO: improve the reference simulator so that this is not needed # by adding a realtime option node_functions = {} node_info = dict(start=None) for node in self.io_controller.host_network.all_nodes: if callable(node.output): old_func = node.output if node.size_in == 0: def func(t, f=old_func): now = time.time() if node_info['start'] is None: node_info['start'] = now t = (now - node_info['start']) * self.timescale return f(t) else: def func(t, x, f=old_func): now = time.time() if node_info['start'] is None: node_info['start'] = now t = (now - node_info['start']) * self.timescale return f(t, x) node.output = func node_functions[node] = old_func # Build the host simulator host_sim = nengo.Simulator(self.io_controller.host_network, dt=self.dt) # reset node functions for node, func in node_functions.items(): node.output = func return host_sim def close(self): """Clean the SpiNNaker board and prevent further simulation.""" if not self._closed: # Stop the application self._closed = True self.io_controller.close() self.controller.send_signal("stop") # Destroy the job if we allocated one if self.job is not None: self.job.destroy() # Remove this simulator from the list of open simulators Simulator._remove_simulator(self) def trange(self, dt=None): return np.arange(1, self.steps + 1) * (self.dt or dt)
class Simulator(object): """SpiNNaker simulator for Nengo models. The simulator period determines how much data will be stored on SpiNNaker and is the maximum length of simulation allowed before data is transferred between the machine and the host PC. If the period is set to `None` function of time Nodes will not be optimised and probes will be disabled. For any other value simulation lengths of less than or equal to the period will be in real-time, longer simulations will be possible but will include short gaps when data is transferred between SpiNNaker and the host. :py:meth:`~.close` should be called when the simulator will no longer be used. This will close all sockets used to communicate with the SpiNNaker machine and will leave the machine in a clean state. Failure to call `close` may result in later failures. Alternatively `with` may be used:: sim = nengo_spinnaker.Simulator(network) with sim: sim.run(10.0) """ _open_simulators = set() @classmethod def _add_simulator(cls, simulator): cls._open_simulators.add(simulator) @classmethod def _remove_simulator(cls, simulator): cls._open_simulators.remove(simulator) def __init__(self, network, dt=0.001, period=10.0, timescale=1.0, hostname=None, use_spalloc=None, allocation_fudge_factor=0.6): """Create a new Simulator with the given network. Parameters ---------- period : float or None Duration of one period of the simulator. This determines how much memory will be allocated to store precomputed and probed data. timescale : float Scaling factor to apply to the simulation, e.g., a value of `0.5` will cause the simulation to run at half real-time. hostname : string or None Hostname of the SpiNNaker machine to use; if None then the machine specified in the config file will be used. use_spalloc : bool or None Allocate a SpiNNaker machine for the simulator using ``spalloc``. If None then the setting specified in the config file will be used. Other Parameters ---------------- allocation_fudge_factor: Fudge factor to allocate more cores than really necessary when using `spalloc` to ensure that (a) there are sufficient "live" cores in the allocated machine, (b) there is sufficient room for a good place and route solution. This should generally be more than 0.1 (10% more cores than necessary) to account for the usual rate of missing chips. """ # Add this simulator to the set of open simulators Simulator._add_simulator(self) # Create the IO controller io_cls = getconfig(network.config, Simulator, "node_io", Ethernet) io_kwargs = getconfig(network.config, Simulator, "node_io_kwargs", dict()) self.io_controller = io_cls(**io_kwargs) # Calculate the machine timestep, this is measured in microseconds # (hence the 1e6 scaling factor). self.timescale = timescale machine_timestep = int((dt / timescale) * 1e6) # Determine the maximum run-time self.max_steps = None if period is None else int(period / dt) self.steps = 0 # Steps simulated # If the simulator is in "run indefinite" mode (i.e., max_steps=None) # then we modify the builders to ignore function of time Nodes and # probes. builder_kwargs = self.io_controller.builder_kwargs if self.max_steps is None: raise NotImplementedError # Create a model from the network, using the IO controller logger.debug("Building model") start_build = time.time() self.model = Model(dt=dt, machine_timestep=machine_timestep, decoder_cache=get_default_decoder_cache()) self.model.build(network, **builder_kwargs) logger.info("Build took {:.3f} seconds".format(time.time() - start_build)) self.model.decoder_cache.shrink() self.dt = self.model.dt self._closed = False # Whether the simulator has been closed or not self.host_sim = self._create_host_sim() # Holder for probe data self.data = {} # Holder for profiling data self.profiler_data = {} # Convert the model into a netlist logger.info("Building netlist") start = time.time() self.netlist = self.model.make_netlist(self.max_steps or 0) # Determine whether to use a spalloc machine or not if use_spalloc is None: # Default is to not use spalloc; this is indicated by either the # absence of the option in the config file OR the option being set # to false. use_spalloc = ( rc.has_option("spinnaker_machine", "use_spalloc") and rc.getboolean("spinnaker_machine", "use_spalloc")) # Create a controller for the machine and boot if necessary self.job = None if not use_spalloc or hostname is not None: # Use the specified machine rather than trying to get one # allocated. if hostname is None: hostname = rc.get("spinnaker_machine", "hostname") else: # Attempt to get a machine allocated to us from spalloc import Job # Determine how many boards to ask for (assuming 16 usable cores # per chip and 48 chips per board). n_cores = self.netlist.n_cores * (1.0 + allocation_fudge_factor) n_boards = int(np.ceil((n_cores / 16.) / 48.)) # Request the job self.job = Job(n_boards) logger.info("Allocated job ID %d...", self.job.id) # Wait until we're given the machine logger.info("Waiting for machine allocation...") self.job.wait_until_ready() # spalloc recommends a slight delay before attempting to boot the # machine, later versions of spalloc server may relax this # requirement. time.sleep(5.0) # Store the hostname hostname = self.job.hostname logger.info("Using %d board(s) of \"%s\" (%s)", len(self.job.boards), self.job.machine_name, hostname) self.controller = MachineController(hostname) self.controller.boot() # Get a system-info object to place & route against logger.info("Getting SpiNNaker machine specification") system_info = self.controller.get_system_info() # Place & Route logger.info("Placing and routing") self.netlist.place_and_route( system_info, place=getconfig(network.config, Simulator, 'placer', rig.place_and_route.place), place_kwargs=getconfig(network.config, Simulator, 'placer_kwargs', {}), ) logger.info("{} cores in use".format(len(self.netlist.placements))) chips = set(six.itervalues(self.netlist.placements)) logger.info("Using {}".format(chips)) # Prepare the simulator against the placed, allocated and routed # netlist. self.io_controller.prepare(self.model, self.controller, self.netlist) # Load the application logger.info("Loading application") self.netlist.load_application(self.controller, system_info) # Check if any cores are in bad states if self.controller.count_cores_in_state(["exit", "dead", "watchdog", "runtime_exception"]): for vertex, (x, y) in six.iteritems(self.netlist.placements): p = self.netlist.allocations[vertex][Cores].start status = self.controller.get_processor_status(p, x, y) if status.cpu_state is not AppState.sync0: print("Core ({}, {}, {}) in state {!s}".format( x, y, p, status)) print(self.controller.get_iobuf(p, x, y)) raise Exception("Unexpected core failures.") logger.info("Preparing and loading machine took {:3f} seconds".format( time.time() - start )) logger.info("Setting router timeout to 16 cycles") for x, y in system_info.chips(): with self.controller(x=x, y=y): data = self.controller.read(0xf1000000, 4) self.controller.write(0xf1000000, data[:-1] + b'\x10') def __enter__(self): """Enter a context which will close the simulator when exited.""" # Return self to allow usage like: # # with nengo_spinnaker.Simulator(model) as sim: # sim.run(1.0) return self def __exit__(self, exception_type, exception_value, traceback): """Exit a context and close the simulator.""" self.close() def run(self, time_in_seconds): """Simulate for the given length of time.""" # Determine how many steps to simulate for steps = int(np.round(float(time_in_seconds) / self.dt)) self.run_steps(steps) def run_steps(self, steps): """Simulate a give number of steps.""" while steps > 0: n_steps = min((steps, self.max_steps)) self._run_steps(n_steps) steps -= n_steps def _run_steps(self, steps): """Simulate for the given number of steps.""" if self._closed: raise Exception("Simulator has been closed and can't be used to " "run further simulations.") if steps is None: if self.max_steps is not None: raise Exception( "Cannot run indefinitely if a simulator period was " "specified. Create a new simulator with Simulator(model, " "period=None) to perform indefinite time simulations." ) else: assert steps <= self.max_steps # Prepare the simulation self.netlist.before_simulation(self, steps) # Wait for all cores to hit SYNC0 (either by remaining it or entering # it from init) self._wait_for_transition(AppState.init, AppState.sync0, self.netlist.n_cores) self.controller.send_signal("sync0") # Get a new thread for the IO io_thread = self.io_controller.spawn() # Run the simulation try: # Prep exp_time = steps * self.dt / self.timescale io_thread.start() # Wait for all cores to hit SYNC1 self._wait_for_transition(AppState.sync0, AppState.sync1, self.netlist.n_cores) logger.info("Running simulation...") self.controller.send_signal("sync1") # Execute the local model host_steps = 0 start_time = time.time() run_time = 0.0 local_timestep = self.dt / self.timescale while run_time < exp_time: # Run a step self.host_sim.step() run_time = time.time() - start_time # If that step took less than timestep then spin time.sleep(0.0001) while run_time < host_steps * local_timestep: time.sleep(0.0001) run_time = time.time() - start_time finally: # Stop the IO thread whatever occurs io_thread.stop() # Wait for cores to re-enter sync0 self._wait_for_transition(AppState.run, AppState.sync0, self.netlist.n_cores) # Retrieve simulation data start = time.time() logger.info("Retrieving simulation data") self.netlist.after_simulation(self, steps) logger.info("Retrieving data took {:3f} seconds".format( time.time() - start )) # Increase the steps count self.steps += steps def _wait_for_transition(self, from_state, desired_to_state, num_verts): while True: # If no cores are still in from_state, stop if self.controller.count_cores_in_state(from_state) == 0: break # Wait a bit time.sleep(1.0) # Check if any cores haven't exited cleanly num_ready = self.controller.wait_for_cores_to_reach_state( desired_to_state, num_verts, timeout=5.0) if num_ready != num_verts: # Loop through all placed vertices for vertex, (x, y) in six.iteritems(self.netlist.placements): p = self.netlist.allocations[vertex][Cores].start status = self.controller.get_processor_status(p, x, y) if status.cpu_state is not desired_to_state: print("Core ({}, {}, {}) in state {!s}".format( x, y, p, status.cpu_state)) print(self.controller.get_iobuf(p, x, y)) raise Exception("Unexpected core failures before reaching %s " "state." % desired_to_state) def _create_host_sim(self): # change node_functions to reflect time # TODO: improve the reference simulator so that this is not needed # by adding a realtime option node_functions = {} node_info = dict(start=None) for node in self.io_controller.host_network.all_nodes: if callable(node.output): old_func = node.output if node.size_in == 0: def func(t, f=old_func): now = time.time() if node_info['start'] is None: node_info['start'] = now t = (now - node_info['start']) * self.timescale return f(t) else: def func(t, x, f=old_func): now = time.time() if node_info['start'] is None: node_info['start'] = now t = (now - node_info['start']) * self.timescale return f(t, x) node.output = func node_functions[node] = old_func # Build the host simulator host_sim = nengo.Simulator(self.io_controller.host_network, dt=self.dt) # reset node functions for node, func in node_functions.items(): node.output = func return host_sim def close(self): """Clean the SpiNNaker board and prevent further simulation.""" if not self._closed: # Stop the application self._closed = True self.io_controller.close() self.controller.send_signal("stop") # Destroy the job if we allocated one if self.job is not None: self.job.destroy() # Remove this simulator from the list of open simulators Simulator._remove_simulator(self) def trange(self, dt=None): return np.arange(1, self.steps + 1) * (self.dt or dt)
from rig.machine_control import MachineController import sys import random if len(sys.argv) < 2: print "Usage: python gen_tgmap.py <MACHINE_IP>" sys.exit(1) mc = MachineController(sys.argv[1]) mInfo = mc.get_system_info() chips_org = mInfo.keys() chips_srt = mInfo.keys() chips_srt.sort() chips_rnd = mInfo.keys() random.shuffle(chips_rnd) if len(chips_org) != 144: print "Dead chip(s) detected...!" sys.exit(1) # then select some chips and assign the id to them # Node ID from 0 to 119 # tgmap 1 with open("map_srt.tgmap", "w") as f1: i = 0 f1.write("(0,0)=65535\n") for c in chips_srt: if i == 120: break if c != (0, 0):
def simulate(self, hostname, sim_length=128): """Simulate the current circuit for the specified number of timer ticks. """ # We define the set of ticks for convenience when plotting self.ticks = list(range(sim_length)) # We define our simulation within the following "with" block which # causes the SpiNNaker applications and their associated resources to # be automatically freed at the end of simulation or in the event of # some failure. mc = MachineController(hostname) with mc.application(): # Step 1: Determine what resources are available in the supplied # SpiNNaker machine. system_info = mc.get_system_info() # Step 2: Describe the simulation as a graph of SpiNNaker applications # which Rig will place in the machine # Each device uses a single core and consumes some amount of SDRAM for # config and result data. vertices_resources = { d: {Cores: 1, SDRAM: d.sdram_required(sim_length)} for d in self._devices } vertices_applications = {d: d.app_name for d in self._devices} # We'll make a net for every signal in our circuit. Packets will have # their bottom 31-bits be the unique signal ID and the top bit will # contain the state of the signal (and is thus masked off here) net_keys = {Net(s.source, s.sinks): (s.id, 0x7FFFFFFF) for s in self._signals} nets = list(net_keys) # Step 3: Place and route the application graph we just described placements, allocations, application_map, routing_tables = \ place_and_route_wrapper(vertices_resources, vertices_applications, nets, net_keys, system_info) # Step 4: Allocate SDRAM for each device. We use the # `sdram_alloc_for_vertices` utility method to allocate SDRAM on # the chip each device has been placed on, tagging the allocation # with the core number so the application can discover the # allocation using `sark_tag_ptr`. The returned file-like objects # may then conveniently be used to read/write to this allocated # region of SDRAM. # A dictionary {Device: filelike} is returned. device_sdram_filelikes = sdram_alloc_for_vertices(mc, placements, allocations) # Step 5: Write the config data to SDRAM for all devices. for d in self._devices: d.write_config(device_sdram_filelikes[d], sim_length) # Step 6: Load application binaries and routing tables mc.load_application(application_map) mc.load_routing_tables(routing_tables) # Step 7: Wait for all applications to reach the initial sync0 # barrier and then start the simulation. mc.wait_for_cores_to_reach_state("sync0", len(self._devices)) mc.send_signal("sync0") # Step 8: Wait for the simulation to run and all cores to finish # executing and enter the EXIT state. time.sleep(0.001 * sim_length) mc.wait_for_cores_to_reach_state("exit", len(self._devices)) # Step 9: Retrieve any results and we're done! for d in self._devices: d.read_results(device_sdram_filelikes[d], sim_length)
class MainWindow(QtGui.QMainWindow, QtMainWindow.Ui_QtMainWindow): """ It inherits QMainWindow and uses pyuic4-generated python files from the .ui """ pltDataRdy = pyqtSignal(list) # for streaming data to the plotter/calibrator def __init__(self, mIP=None, logFName=None, parent=None): super(MainWindow, self).__init__(parent) self.setupUi(self) self.setCentralWidget(self.mdiArea); self.statusTxt = QtGui.QLabel("") self.statusBar().addWidget(self.statusTxt) # load setting self.loadSettings() # if machine IP is provided, check if it is booted and/or if the profiler has been loaded if mIP is not None: self.mIP = mIP self.checkSpiNN4() else: self.mIP = None self.connect(self.actionShow_Chips, SIGNAL("triggered()"), SLOT("showChips()")) """ Scenario: - sw and pw send data to MainWindow - MainWindow do the averaging on sw data, then send avg_sw and pw to plotter At the same time, MainWindow store the data """ #-------------------- GUI setup --------------------- # Dump raw data in arduConsole widget (cw). self.cw = ifaceArduSpiNN(logFName,self) self.subWinConsole = QtGui.QMdiSubWindow(self) self.subWinConsole.setWidget(self.cw) self.mdiArea.addSubWindow(self.subWinConsole) self.subWinConsole.setGeometry(0,0,self.cw.width(),500) self.cw.show() # Power plot widget (pw). self.pw = Pwidget(self) self.subWinPW = QtGui.QMdiSubWindow(self) self.subWinPW.setWidget(self.pw) self.mdiArea.addSubWindow(self.subWinPW) self.subWinPW.setGeometry(self.cw.width()+10,0,760,500) self.pw.show() # SpiNNaker profiler plot widget (sw). self.sw = Swidget(self) self.subWinSW = QtGui.QMdiSubWindow(self) self.subWinSW.setWidget(self.sw) self.mdiArea.addSubWindow(self.subWinSW) self.subWinSW.setGeometry(self.subWinPW.x(), self.subWinPW.y()+self.subWinPW.height(),760,500) self.sw.show() # initially, we don't show chip visualizer self.vis = None # SIGNAL-SLOT connection self.cw.spinUpdate.connect(self.sw.readPltData) self.cw.arduUpdate.connect(self.pw.readPltData) # just for debugging: # self.cw.arduUpdate.connect(self.readArduData) # self.cw.spinUpdate.connect(self.readSpinData) def loadSettings(self): """ Load configuration setting from file. Let's use INI format and UserScope :return: """ #init value self.conf = config() #if used before, then load from previous one; otherwise, it use the initial value above self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, "APT", "SpiNN-4 Power Profiler") self.conf.xPos,ok = self.settings.value(self.conf.xPosKey, self.conf.xPos).toInt() self.conf.yPos,ok = self.settings.value(self.conf.yPosKey, self.conf.yPos).toInt() self.conf.width,ok = self.settings.value(self.conf.widthKey, self.conf.width).toInt() self.conf.height,ok = self.settings.value(self.conf.heightKey, self.conf.height).toInt() #print "isWritable?", self.settings.isWritable() #print "conf filename", self.settings.fileName() #then apply to self self.setGeometry(self.conf.xPos, self.conf.yPos, self.conf.width, self.conf.height) def checkSpiNN4(self, alwaysAsk=True): #return #go out immediately for experiment with Basab """ if the MainWindow class is called with an IP, then check if the machine is ready """ loadProfiler = False # first, check if the machine is booted print "Check the machine: ", self.mc = MachineController(self.mIP) bootByMe = self.mc.boot() # if bootByMe is true, then the machine is booted by readSpin4Pwr.py, otherwise it is aleady booted # if rig cannot boot the machine (eq. the machine is not connected or down), the you'll see error # message in the arduConsole if bootByMe is False: print "it is booted already!" else: print "it is now booted!" loadProfiler = True alwaysAsk = False # because the machine is just booted, then force it load profiler # second, ask if profilers need to be loaded cpustat = self.mc.get_processor_status(1,0,0) #core-1 in chip <0,0> profName = cpustat.app_name profState = int(cpustat.cpu_state) profVersion = cpustat.user_vars[0] # read from sark.vcpu->user0 #print "Profiler name: ", profName #print "Profiler state: ", profState #print "Profiler version: ", profVersion if profName.upper()==DEF.REQ_PROF_NAME.upper() and profState==7 and profVersion==DEF.REQ_PROF_VER: print "Required profiler.aplx is running!" loadProfiler = False else: if alwaysAsk: askQ = raw_input('Load the correct profiler.aplx? [Y/n]') if len(askQ) == 0 or askQ.upper() == 'Y': loadProfiler = True else: loadProfiler = False print "[WARNING] profiler.aplx is not ready or invalid version" # third, load the profilers if loadProfiler: # then load the correct profiler version print "Loading profiler from", DEF.REQ_PROF_APLX # populate all chips in the board chips = self.mc.get_system_info().keys() dest = dict() for c in chips: dest[c] = [1] # the profiler.aplx goes to core-1 self.mc.load_application(DEF.REQ_PROF_APLX, dest, app_id=DEF.REQ_PROF_APLX_ID) print "Profilers are sent to SpiNN4!" else: print "No valid profiler! This program might not work correctly!" # Last but important: MAKE SURE IPTAG 3 IS SET iptag = self.mc.iptag_get(DEF.REPORT_IPTAG,0,0) if iptag.addr is '0.0.0.0' or iptag.port is not DEF.REPORT_IPTAG: #iptag DEF.REPORT_IPTAG is not defined yet self.mc.iptag_set(DEF.REPORT_IPTAG, DEF.HOST_PC, DEF.RECV_PORT, 0, 0) @pyqtSlot() def reactiveShopCipMenu(self): self.actionShow_Chips.setEnabled(True) del self.subWinVis @pyqtSlot() def showChips(self): """ Show chip layout :return: """ if self.mIP is None: """ i.e., the IP is not defined when this menu is clicked """ # first, ask the IP of the machine mIP, ok = QtGui.QInputDialog.getText(self, "SpiNN4 Location", "SpiNN4 IP address", QtGui.QLineEdit.Normal, DEF.MACHINE) if ok is True: self.mIP = mIP self.checkSpiNN4(False) # after this, self.mc is available # then open the widget mInfo = self.mc.get_system_info() w = mInfo.width h = mInfo.height chipList = mInfo.keys() #self.vis = visWidget(w, h, chipList) # Segmentation fault self.vis = visWidget(w, h, chipList, self) self.subWinVis = QtGui.QMdiSubWindow(self) self.subWinVis.setWidget(self.vis) self.mdiArea.addSubWindow(self.subWinVis) #self.subWinVis.setGeometry(self.subWinPW.x(), self.subWinPW.y()+self.subWinPW.height(),760,500) # connect to the source of temperature data # masih salah: self.cw.spinUpdate.connect(self.vis.readSpinData) self.vis.show() # and disable the menu item self.actionShow_Chips.setEnabled(False) # the menu will be reset to enable if the widget is closed self.vis.visWidgetTerminated.connect(self.reactiveShopCipMenu) """ ######################### GUI callback ########################### """ # readSpinData and readArduData are just for debugging @pyqtSlot(list) def readSpinData(self, prfData): """ Read profiler data and prepare for saving. prfData is a list of 48 "Integer" item that should be decoded as: freq, nActive, temp Hence, fmt = "<2BH" """ #print len(prfData) #print type(prfData[0]) #return fmt = "<2BH" #fmt = "<H2B" print "{", for i in range(len(prfData)): cpu = struct.pack("<I",prfData[i]) #print "0x%x " % cpu, #f,nA,T = struct.unpack(fmt, prfData[i]) f,nA,T = struct.unpack(fmt, cpu) #print "[{},{},{}]".format(f,nA,T), if i < (len(prfData)-1): print "[{},{},{}],".format(f, nA, T), else: print "[{},{},{}]".format(f, nA, T), print "}" @pyqtSlot(list) def readArduData(self, pwrData): """ Read power data from Arduino and prepare for saving. """ def closeEvent(self, event): #print "x, y, w, h =",self.x(),self.y(),self.width(),self.height() # save the current configuration self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, "APT", "SpiNN-4 Power Profiler") self.settings.setValue(self.conf.xPosKey, self.x()) self.settings.setValue(self.conf.yPosKey, self.y()) self.settings.setValue(self.conf.widthKey, self.width()) self.settings.setValue(self.conf.heightKey, self.height()) self.settings.sync() #print "Conf saved!" # Notify ifaceArduSpiNN to stop the thread: self.cw.stop() # to avoid QThread being destroyed while thread is still running event.accept()