def close_and_finalize(port_send, port_receive, logger_master): # close port MPI.Close_port(port_send) MPI.Close_port(port_receive) logger_master.info('close communicator') # finalise MPI MPI.Finalize()
def close(): MPI.Unpublish_name(self.service, self.info, self.port) print '[Server] Service unpublished' MPI.Close_port(self.port) print '[Server] Service port closed'
def main_server(COMM): nprocs = COMM.Get_size() myrank = COMM.Get_rank() service, port, info = None, None, MPI.INFO_NULL if myrank == 0: port = MPI.Open_port(info) log(COMM, "open port '%s'", port) service = 'cpi' MPI.Publish_name(service, info, port) log(COMM, "service '%s' published.", service) else: port = '' log(COMM, "waiting for client connection ...") icomm = COMM.Accept(port, info, root=0) log(COMM, "client connection accepted.") worker(icomm) log(COMM, "disconnecting from client ...") icomm.Disconnect() log(COMM, "client disconnected.") if myrank == 0: MPI.Unpublish_name(service, info, port) log(COMM, "service '%s' unpublished", port) MPI.Close_port(port) log(COMM, "closed port '%s' ", port)
def __del__(self): if ( self.procID == 0 ): MPI.Close_port(self.portName) self.SERVER_COMM_CLIENT.Barrier() self.SERVER_COMM_CLIENT.Disconnect() self.PARENT.Barrier() self.PARENT.Disconnect()
def simulate_TVB_reception(path): ''' simulate the receptor of the translator for nest to TVB :param path: the path to the file for the connections :return: ''' # Init connection from file connection print(path) print("TVB INPUT : Waiting for port details") sys.stdout.flush() while not os.path.exists(path): print("Port file not found yet, retry in 1 second") time.sleep(1) fport = open(path, "r") port = fport.readline() fport.close() print("TVB INPUT :wait connection " + port) sys.stdout.flush() comm = MPI.COMM_WORLD.Connect(port) print('TVB INPUT :connect to ' + port) sys.stdout.flush() status_ = MPI.Status() while (True): # send to the translator, I want the next part req = comm.isend(True, dest=1, tag=0) req.wait() times = np.empty(2, dtype='d') comm.Recv([times, MPI.FLOAT], source=1, tag=0) # get the size of the rate size = np.empty(1, dtype='i') comm.Recv([size, MPI.INT], source=1, tag=0) # get the rate rates = np.empty(size, dtype='d') comm.Recv([rates, size, MPI.DOUBLE], source=1, tag=MPI.ANY_TAG, status=status_) # print the summary of the data if status_.Get_tag() == 0: print("TVB INPUT :", comm.Get_rank(), times, np.sum(rates)) sys.stdout.flush() else: break if times[1] > 9900: break # closing the connection at this end req = comm.isend(True, dest=1, tag=1) req.wait() print('TVB INPUT :end') sys.stdout.flush() comm.Disconnect() MPI.Close_port(port) print('TVB INPUT :exit') sys.stdout.flush() MPI.Finalize()
def badport(): if MPI.get_vendor()[0] != 'MPICH': return False try: port = MPI.Open_port() MPI.Close_port(port) except: port = "" return port == ""
def testNamePublishing(self): rank = MPI.COMM_WORLD.Get_rank() service = "mpi4py-%d" % rank port = MPI.Open_port() MPI.Publish_name(service, port) found = MPI.Lookup_name(service) self.assertEqual(port, found) MPI.Unpublish_name(service, port) MPI.Close_port(port)
def testConnectAccept(self): comm_self = MPI.COMM_SELF comm_world = MPI.COMM_WORLD wsize = comm_world.Get_size() wrank = comm_world.Get_rank() if wsize == 1: return group_world = comm_world.Get_group() group = group_world.Excl([0]) group_world.Free() comm = comm_world.Create(group) group.Free() if wrank == 0: self.assertEqual(comm, MPI.COMM_NULL) else: self.assertNotEqual(comm, MPI.COMM_NULL) self.assertEqual(comm.size, comm_world.size - 1) self.assertEqual(comm.rank, comm_world.rank - 1) if wrank == 0: port = comm_world.recv(source=1) intercomm = comm_self.Connect(port) self.assertEqual(intercomm.remote_size, comm_world.size - 1) self.assertEqual(intercomm.size, 1) self.assertEqual(intercomm.rank, 0) else: if wrank == 1: port = MPI.Open_port() comm_world.send(port, dest=0) else: port = None intercomm = comm.Accept(port, root=0) if wrank == 1: MPI.Close_port(port) self.assertEqual(intercomm.remote_size, 1) self.assertEqual(intercomm.size, comm_world.size - 1) self.assertEqual(intercomm.rank, comm.rank) comm.Free() if wrank == 0: message = TestDPM.message root = MPI.ROOT else: message = None root = 0 message = intercomm.bcast(message, root) if wrank == 0: self.assertEqual(message, None) else: self.assertEqual(message, TestDPM.message) intercomm.Free()
def end_mpi(comm, path, sending, logger): """ ending the communication :param comm: MPI communicator :param path: for the close the port :param sending: if the translator is for sending or receiving data :return: nothing """ # read the port before the deleted file fport = open(path, "r") port = fport.readline() fport.close() # different ending of the translator if sending: logger.info("TVB close connection send " + port) sys.stdout.flush() status_ = MPI.Status() # wait until the translator accept the connections logger.info("TVB send check") accept = False while not accept: req = comm.irecv(source=0, tag=0) accept = req.wait(status_) logger.info("TVB send end simulation") source = status_.Get_source() # the id of the excepted source times = np.array([0., 0.], dtype='d') # time of starting and ending step comm.Send([times, MPI.DOUBLE], dest=source, tag=1) else: logger.info("TVB close connection receive " + port) # send to the translator : I want the next part req = comm.isend(True, dest=1, tag=1) req.wait() # closing the connection at this end logger.info("TVB disconnect communication") comm.Disconnect() logger.info("TVB close " + port) MPI.Close_port(port) logger.info("TVB close connection " + port) return
logger_receive = create_logger( path_config, 'tvb_to_nest_receive' + str(id_first_spike_detector), log_level) # create the thread for receive and send data th_send = Thread(target=send, args=(logger_send, id_first_spike_detector, status_data, buffer_spike, comm_send)) th_receive = Thread(target=receive, args=(logger_receive, generator, status_data, buffer_spike, comm_receive)) # start the threads # FAT END POINT logger_master.info('Start thread') th_receive.start() th_send.start() th_receive.join() th_send.join() logger_master.info('thread join') MPI.Close_port(port_send) MPI.Close_port(port_receive) logger_master.info('close communicator') MPI.Finalize() logger_master.info('clean file') # Clean up port files and locks for path_send in path_to_files_sends: os.remove(path_send) os.remove(path_to_files_receive) logger_master.info('end')
def simulate_spike_detector(path, min_delay): ''' simulate spike detector output for testing the nest to tvb translator input :param path: the path to the file for the connections :param min_delay: the time of one simulation :return: ''' # Init connection from file connection print(path) print("Nest Output : Waiting for port details") sys.stdout.flush() while not os.path.exists(path): print("Port file not found yet, retry in 1 second") time.sleep(1) fport = open(path, "r") port = fport.readline() fport.close() print('Nest Output : wait connection ' + port) sys.stdout.flush() comm = MPI.COMM_WORLD.Connect(port) print('Nest Output : connect to ' + port) sys.stdout.flush() starting = 0.0 # the begging of each time of synchronization check = np.empty(1, dtype='b') status_ = MPI.Status() # status of the different message while True: # wait until the translator accept the connections comm.Send([np.array([True], dtype='b'), 1, MPI.CXX_BOOL], dest=0, tag=0) comm.Recv([check, 1, MPI.CXX_BOOL], source=MPI.ANY_SOURCE, tag=0, status=status_) # create random data size = np.random.randint(0, 1000) times = starting + np.random.rand(size) * (min_delay - 0.2) times = np.around(np.sort(np.array(times)), decimals=1) id_neurons = np.random.randint(0, 10, size) id_detector = np.random.randint(0, 10, size) data = np.ascontiguousarray(np.swapaxes( [id_detector, id_neurons, times], 0, 1), dtype='d') # send data one by one like spike generator comm.Send([np.array([size * 3], dtype='i'), 1, MPI.INT], dest=status_.Get_source(), tag=0) comm.Send([data, size * 3, MPI.DOUBLE], dest=status_.Get_source(), tag=0) # ending the actual run comm.Send([np.array([True], dtype='b'), 1, MPI.CXX_BOOL], dest=0, tag=1) #print result and go to the next run print("Nest Output : ", comm.Get_rank(), size) sys.stdout.flush() starting += min_delay if starting > 10000: break # closing the connection at this end print("Nest Output : ending") sys.stdout.flush() # send the signal for end the translation comm.Send([np.array([True], dtype='b'), 1, MPI.CXX_BOOL], dest=0, tag=2) print("Nest Output : ending") sys.stdout.flush() comm.Disconnect() MPI.Close_port(port) MPI.Finalize() print('Nest Output : exit') sys.stdout.flush()
root = 0 message = intercomm.bcast(message, root) if rank == 0: self.assertEqual(message, None) else: self.assertEqual(message, TestDPM.message) intercomm.Free() MPI.COMM_WORLD.Barrier() name, version = MPI.get_vendor() if name == 'MPICH' or name == 'MPICH2': if MPI.COMM_WORLD.Get_attr(MPI.APPNUM) is None: del TestDPM.testNamePublishing elif name == 'Open MPI': del TestDPM elif name == 'MVAPICH2': del TestDPM elif name == 'Microsoft MPI': del TestDPM elif name == 'Platform MPI': del TestDPM.testNamePublishing else: try: MPI.Close_port(MPI.Open_port()) except NotImplementedError: del TestDPM if __name__ == '__main__': unittest.main()
logger_master.info('Translate Receive: path_file: ' + path_to_files) # Wait until connection logger_master.info('Waiting communication') comm_receiver = MPI.COMM_WORLD.Accept(port_receive, info, root) logger_master.info('get communication and start thread') ######################### # create the thread for receive and save data logger_receive = create_logger(path_folder_config, 'nest_to_tvb_receive', level_log) logger_save = create_logger(path_folder_config, 'nest_to_tvb_send', level_log) th_receive = Thread(target=receive, args=(logger_receive, store, status_data, buffer, comm_receiver)) th_save = Thread(target=save, args=(path_folder_save, logger_save, nb_step, step_save, status_data, buffer)) # start the threads # FAT END POINT logger_master.info('start thread') th_receive.start() th_save.start() th_receive.join() th_save.join() logger_master.info('join thread') MPI.Close_port(port_receive) MPI.Finalize() else: print('missing argument')
def input(path): """ Simulate some random current input :param path: the file for the configurations of the connection :return: """ #Start communication channels path_to_files = path #For NEST # Init connection print("Waiting for port details") info = MPI.INFO_NULL root = 0 port = MPI.Open_port(info) fport = open(path_to_files, "w+") fport.write(port) fport.close() print('wait connection ' + port) sys.stdout.flush() comm = MPI.COMM_WORLD.Accept(port, info, root) print('connect to ' + port) #test one rate status_ = MPI.Status() check = np.empty(1, dtype='b') starting = 1 while True: comm.Recv([check, 1, MPI.CXX_BOOL], source=0, tag=MPI.ANY_TAG, status=status_) print(" start to send") sys.stdout.flush() print(" status a tag ", status_.Get_tag()) sys.stdout.flush() if status_.Get_tag() == 0: # receive list ids size_list = np.empty(1, dtype='i') comm.Recv([size_list, 1, MPI.INT], source=0, tag=0, status=status_) print("size list id", size_list) sys.stdout.flush() list_id = np.empty(size_list, dtype='i') comm.Recv([list_id, size_list, MPI.INT], source=0, tag=0, status=status_) print(" id ", list_id) sys.stdout.flush() shape = np.random.randint(0, 50, 1, dtype='i') * 2 data = starting + np.random.rand(shape[0]) * 200 data = np.around(np.sort(np.array(data, dtype='d')), decimals=1) send_shape = np.array(np.concatenate([shape, shape]), dtype='i') comm.Send([send_shape, MPI.INT], dest=status_.Get_source(), tag=list_id[0]) print(" shape data ", shape) sys.stdout.flush() comm.Send([data, MPI.DOUBLE], dest=status_.Get_source(), tag=list_id[0]) print(" send data", data) sys.stdout.flush() comm.Recv([check, 1, MPI.CXX_BOOL], source=status_.Get_source(), tag=MPI.ANY_TAG, status=status_) print("end run") sys.stdout.flush() starting += 200 elif (status_.Get_tag() == 2): print("end simulation") sys.stdout.flush() print("ending time : ", starting) sys.stdout.flush() break else: print(status_.Get_tag()) break comm.Disconnect() MPI.Close_port(port) os.remove(path_to_files) print('exit') MPI.Finalize()
def __server(self): """ Server side logic for the client/server MPI communication approach NOTE: check notes below where the method is called Returns: """ if self.__mpi_cw_rank == 0: try: file_object = open(self.__mmap_path_filename, 'rb+') except FileNotFoundError: self.error('{} could not be opened'.format( self.__mmap_path_filename)) return RETURN_NOT_OK try: mmap_object = mmap.mmap(file_object.fileno(), length=0, access=mmap.ACCESS_WRITE, offset=0) except SyntaxError: self.error('{} could not be mmaped'.format( self.__mmap_path_filename)) return RETURN_NOT_OK # Open Listening Port try: self.__mpi_info = MPI.INFO_NULL self.__mpi_port_name = MPI.Open_port(self.__mpi_info) self.__mpi_port_name_length = len(self.__mpi_port_name) except MPI.Exception as ierr: self.report_mpi_error(mpi_ierr=ierr, mpi_operation_name='MPI.Open_port') return RETURN_NOT_OK # publishing the port name by means of the mmaped file mmap_object.seek(0) mmap_object[MemMap.PORT_LENGTH_LOC:MemMap.PORT_LENGTH_LENGTH] = \ self.__mpi_port_name_length.to_bytes(length=MemMap.PORT_LENGTH_LENGTH, byteorder='big') mmap_object[MemMap.PORT_NAME_LOC:MemMap.PORT_NAME_LOC + self.__mpi_port_name_length] = \ bytes('{}'.format(self.__mpi_port_name), 'utf8', ) mmap_object.flush() # self.__mpi_expected_source = 0 else: self.__mpi_expected_source = MPI.PROC_NULL self.info('waiting for client connection {}'.format( self.__mpi_port_name)) self.__mpi_comm = self.__MPI_COMM_WORLD.Accept(self.__mpi_port_name, self.__mpi_info, self.__mpi_root) self.info('client connected, waiting for PING value') ping_value = self.__mpi_comm.recv(source=self.__mpi_expected_source, tag=self.__mpi_message_tag) if self.__mpi_cw_rank == 0: if ping_value == self.__ping_value: self.info('Gotten expected PING value {} from client'.format( ping_value)) else: self.info( 'expected PING value from client should be {}, received {}' .format(self.__ping_value, ping_value)) self.__mpi_comm.Disconnect() return RETURN_NOT_OK else: # finishing server running on rank > 0 MPI processes self.info('Gotten {} from client'.format(ping_value)) return RETURN_OK self.info('sending PONG value') self.__mpi_comm.send(self.__pong_value, dest=0, tag=self.__mpi_message_tag) while True: self.info('Waiting for the poison pill') poison_pill = self.__mpi_comm.recv( source=self.__mpi_expected_source, tag=self.__mpi_message_tag) if poison_pill is None: break self.info('by waiting for poison pill, {} was received'.format( poison_pill)) self.__mpi_comm.Disconnect() if self.__mpi_cw_rank == 0: MPI.Close_port(self.__mpi_port_name) self.info('Server Processing Done') return RETURN_OK
def simulate_TVB_output(path, min_delay): ''' simulate the input of the translator tvb_to_nest :param path: the path to the file for the connections :param min_delay: the time of one simulation :return: ''' print("TVB_OUTPUT : Waiting for port details") sys.stdout.flush() while not os.path.exists(path): print("Port file not found yet, retry in 1 second") time.sleep(1) ''' ### OLD Code ### TODO: further investigate the '.unlock' file approach max_mpi_connection_attempts = 50 file_unlock=False for attempt in range(max_mpi_connection_attempts): print("file to read",path);sys.stdout.flush() if os.path.exists(path+".unlock"): print ("MPI connection file available after t={0} seconds".format(attempt));sys.stdout.flush() file_unlock=True break if file_unlock is False: print("Could file not unlocked after 20 attempts, exit");sys.stdout.flush() sys.exit (1) ''' fport = open(path, "r") port = fport.readline() fport.close() print('TVB_OUTPUT :wait connection: ' + port + ": " + path) sys.stdout.flush() comm = MPI.COMM_WORLD.Connect(port) print('TVB_OUTPUT :connect to ' + port) sys.stdout.flush() status_ = MPI.Status() starting = 0.0 # the begging of each time of synchronization while True: # wait until the translator accept the connections accept = False print("TVB_OUTPUT :wait acceptation") sys.stdout.flush() while not accept: req = comm.irecv(source=0, tag=0) accept = req.wait(status_) print("TVB_OUTPUT :accepted") sys.stdout.flush() # TODO: the irecv above is from source 0, so 'source = status_.Get_source()' will be 0. # TODO: If the goal was to send from multiple TVB ranks to multiple sources, this needs some work. # TODO: essentially this would be an M:N coupling then source = status_.Get_source() # the id of the excepted source # create random data size = int(min_delay / 0.1) rate = np.random.rand(size) * 400 data = np.ascontiguousarray(rate, dtype='d') # format the rate for sending shape = np.array(data.shape[0], dtype='i') # size of data times = np.array([starting, starting + min_delay], dtype='d') # time of stating and ending step print("TVB_OUTPUT :send time : " + str(times)) sys.stdout.flush() comm.Send([times, MPI.DOUBLE], dest=source, tag=0) print("TVB_OUTPUT :send shape : " + str(shape)) sys.stdout.flush() comm.Send([shape, MPI.INT], dest=source, tag=0) print("TVB_OUTPUT :send data : " + str(np.sum(np.sum(data)))) sys.stdout.flush() print("TVB_OUTPUT :send data array : ", data.shape) sys.stdout.flush() comm.Send([data, MPI.DOUBLE], dest=source, tag=0) # print result and go to the next run starting += min_delay if starting > 10000: break print("TVB_OUTPUT :ending") sys.stdout.flush() accept = False print("TVB_OUTPUT :wait acceptation") sys.stdout.flush() while not accept: req = comm.irecv(source=0, tag=0) accept = req.wait(status_) print("TVB_OUTPUT :ending 2") sys.stdout.flush() comm.Send([times, MPI.DOUBLE], dest=0, tag=1) comm.Disconnect() MPI.Close_port(port) print('TVB_OUTPUT :exit') MPI.Finalize()
def analyse(path, file, nb_mpi): """ simulate the recorder module :param path: the file for the configurations of the connection :param file: number of the device and the file connection :param nb_mpi: number of mpi rank for testing multi-threading and MPI simulation :return: """ data_save = [] logger = create_logger(path, name='record_' + file) # Start communication channels path_to_files = path + file + '.txt' # For NEST # Init connection logger.info("Waiting for port details") info = MPI.INFO_NULL root = 0 port = MPI.Open_port(info) fport = open(path_to_files, "w+") fport.write(port) fport.close() logger.info('wait connection ' + port) comm = MPI.COMM_WORLD.Accept(port, info, root) logger.info('connect to ' + port) #test one rate status_ = MPI.Status() check = np.empty(1, dtype='b') source_sending = np.arange( 0, comm.Get_remote_size(), 1) # list of all the process for the commmunication while (True): comm.Recv([check, 1, MPI.CXX_BOOL], source=MPI.ANY_SOURCE, tag=MPI.ANY_TAG, status=status_) logger.info(" start to send") logger.info(" status a tag " + str(status_.Get_tag()) + " source " + str(status_.Get_source())) if status_.Get_tag() == 0: for i in range(nb_mpi - 1): comm.Recv([check, 1, MPI.CXX_BOOL], source=MPI.ANY_SOURCE, tag=0, status=status_) for source in source_sending: logger.info("source is " + str(source)) comm.Send([np.array(True, dtype='b'), MPI.BOOL], dest=source, tag=0) shape = np.empty(1, dtype='i') comm.Recv([shape, 1, MPI.INT], source=source, tag=0, status=status_) logger.info("shape is " + str(shape[0])) data = np.empty(shape[0], dtype='d') comm.Recv([data, shape[0], MPI.DOUBLE], source=status_.Get_source(), tag=0, status=status_) data_save.append( copy.deepcopy(data).reshape(int(shape[0] / 3), 3)) logger.info("data is " + str(data)) elif status_.Get_tag() == 1: logger.info("end run") pass elif status_.Get_tag() == 2: for i in range(nb_mpi - 1): logger.info(" receive ending " + str(i)) comm.Recv([check, 1, MPI.CXX_BOOL], source=MPI.ANY_SOURCE, tag=MPI.ANY_TAG, status=status_) logger.info("end simulation") break else: logger.info(str(status_.Get_tag())) break comm.Disconnect() MPI.Close_port(port) os.remove(path_to_files) logger.info('exit') MPI.Finalize() np.save(path + '../recording_mpi_' + file + '.npy', data_save, allow_pickle=True)
def input(path,file,nb_mpi,nb_run,time_sim): """ Simulate some random spike train input :param path: the file for the configurations of the connection :param file: number of the device and the file connection :param nb_mpi: number of mpi of nest :param nb_run: the number of run of the simulation (should be more integrate) :param time_sim: time of one simulation :return: """ logger = create_logger(path,name='input_'+file) datas = generate_current(int(file),nb_run,time_sim) #Start communication channels path_to_files = path + file + '.txt' #For NEST # Init connection logger.info("Waiting for port details") info = MPI.INFO_NULL root=0 port = MPI.Open_port(info) fport = open(path_to_files, "w+") fport.write(port) fport.close() logger.info('wait connection '+port) sys.stdout.flush() comm = MPI.COMM_WORLD.Accept(port, info, root) logger.info('connect to '+port) #test one rate status_ = MPI.Status() check = np.empty(1,dtype='b') source_sending = np.arange(0,nb_mpi,1) # list of all the process for the communication starting = 1 run_x=0 while True: tag = -1 for source in source_sending: comm.Recv([check, 1, MPI.CXX_BOOL], source=source, tag=MPI.ANY_TAG, status=status_) if tag == -1: tag = status_.Get_tag() elif tag != status_.Get_tag(): raise Exception('bad tags') logger.info(" start to send") logger.info(" status a tag "+str(status_.Get_tag())) if tag == 0 : # receive list ids size_list = np.empty(1, dtype='i') shape = np.array(datas[0][run_x],dtype='i') data = np.array(np.concatenate(datas[1][run_x]),dtype='d') logger.info("shape data init"+str( data.shape)+ " shape "+str(shape)) for source in source_sending: logger.info(" source :"+str(source)) comm.Recv([size_list, 1, MPI.INT], source=source, tag=0, status=status_) if size_list[0] != 0 : logger.info("size list id"+str(size_list)) list_id = np.empty(size_list, dtype='i') comm.Recv([list_id, size_list, MPI.INT], source=status_.Get_source(), tag=0, status=status_) logger.info("id "+str(list_id)) data_send = np.concatenate(np.repeat([data],size_list[0]+1,axis=0)) logger.info(data_send) send_shape = np.array(np.concatenate([[data_send.shape[0]], np.repeat(shape,size_list[0])]), dtype='i') comm.Send([send_shape, MPI.INT], dest=status_.Get_source(), tag=list_id[0]) logger.info("shape data "+str(send_shape)) comm.Send([data_send, MPI.DOUBLE], dest=status_.Get_source(), tag=list_id[0]) logger.info("send data "+str( data.shape)+" data send "+str(data_send.shape)) for source in source_sending: comm.Recv([check, 1, MPI.CXX_BOOL], source=source, tag=MPI.ANY_TAG, status=status_) logger.info("source "+str(source)+" end run") run_x+=1 starting+=200 elif(tag == 2): logger.info("end simulation") logger.info("ending time : "+str(starting)) break else: logger.info(tag) break comm.Disconnect() MPI.Close_port(port) os.remove(path_to_files) logger.info('exit') MPI.Finalize()
def analyse(path): """ simulate the recorder module :param path: the file for the configurations of the connection :return: """ #Start communication channels path_to_files = path #For NEST # Init connection print("Waiting for port details") info = MPI.INFO_NULL root = 0 port = MPI.Open_port(info) fport = open(path_to_files, "w+") fport.write(port) fport.close() print('wait connection ' + port) comm = MPI.COMM_WORLD.Accept(port, info, root) print('connect to ' + port) #test one rate status_ = MPI.Status() check = np.empty(1, dtype='b') while (True): comm.Recv([check, 1, MPI.CXX_BOOL], source=MPI.ANY_SOURCE, tag=MPI.ANY_TAG, status=status_) print(" start to send") sys.stdout.flush() print(" status a tag ", status_.Get_tag()) sys.stdout.flush() if status_.Get_tag() == 0: comm.Send([np.array(True, dtype='b'), MPI.BOOL], dest=status_.Get_source(), tag=0) shape = np.empty(1, dtype='i') comm.Recv([shape, 1, MPI.INT], source=status_.Get_source(), tag=0, status=status_) print("shape is", shape) sys.stdout.flush() data = np.empty(shape[0], dtype='d') comm.Recv([data, shape[0], MPI.DOUBLE], source=status_.Get_source(), tag=0, status=status_) print("data is ", data) sys.stdout.flush() comm.Recv([check, 1, MPI.CXX_BOOL], source=status_.Get_source(), tag=MPI.ANY_TAG, status=status_) print("end run") sys.stdout.flush() elif status_.Get_tag() == 2: print("end simulation") sys.stdout.flush() break else: print(status_.Get_tag()) break comm.Disconnect() MPI.Close_port(port) os.remove(path_to_files) print('exit') MPI.Finalize()
Run this with 1 processes like: $ mpiexec -n 1 python server.py """ import numpy as np from mpi4py import MPI comm = MPI.COMM_WORLD service_name = 'compute' # open a port port_name = MPI.Open_port() # bind the opened port to a service_name, # client can connect to the port by looking-up this service_name MPI.Publish_name(service_name, port_name) # wait for client to connect inter_comm = comm.Accept(port_name) # receive message from client recv_obj = inter_comm.recv(source=0, tag=0) print 'Server receives %s from client.' % recv_obj send_obj = eval(recv_obj) # reply the result to the client print 'Server sends %s to client.' % send_obj inter_comm.send(send_obj, dest=0, tag=1) # unpublish the service_name, close the port and disconnect MPI.Unpublish_name(service_name, port_name) MPI.Close_port(port_name) inter_comm.Disconnect()
if version == (4, 0, 0): SKIP_POOL_TEST = True if version == (4, 0, 1) and sys.platform == 'darwin': SKIP_POOL_TEST = True if version == (4, 0, 2) and sys.platform == 'darwin': SKIP_POOL_TEST = True if name == 'MPICH': if sys.platform == 'darwin': if version >= (3, 4) and version < (4, 0): SKIP_POOL_TEST = True if MPI.COMM_WORLD.Get_attr(MPI.APPNUM) is None: SKIP_POOL_TEST = True port = MPI.Open_port() if port == "": SKIP_POOL_TEST = True MPI.Close_port(port) del port if name == 'MVAPICH2': SKIP_POOL_TEST = True if name == 'MPICH2': if MPI.COMM_WORLD.Get_attr(MPI.APPNUM) is None: SKIP_POOL_TEST = True if name == 'Microsoft MPI': if version < (8, 1, 0): SKIP_POOL_TEST = True if MPI.COMM_WORLD.Get_attr(MPI.APPNUM) is None: SKIP_POOL_TEST = True if name == 'Platform MPI': SKIP_POOL_TEST = True if MPI.Get_version() < (2, 0): SKIP_POOL_TEST = True
def simulate_nest_generator(path): ''' simulate the spike generator of the translator for tvb to nest :param path: the path to the file for the connections :return: ''' # Init connection max_mpi_connection_attempts = 50 file_unlock = False for attempt in range(max_mpi_connection_attempts): print("file to read", path) sys.stdout.flush() if os.path.exists(path + ".unlock"): print("MPI connection file available after t={0} seconds".format( attempt)) sys.stdout.flush() file_unlock = True break if file_unlock is False: print("Could file not unlocked after 20 attempts, exit") sys.stdout.flush() sys.exit(1) print("Nest_Input:" + path) print("Nest_Input :Waiting for port details") sys.stdout.flush() fport = open(path, "r") port = fport.readline() fport.close() print("Nest_Input :wait connection " + port) sys.stdout.flush() comm = MPI.COMM_WORLD.Connect(port) print('Nest_Input :connect to ' + port) sys.stdout.flush() status_ = MPI.Status() ids = np.arange(0, 10, 1) # random id of spike detector print(ids) sys.stdout.flush() while (True): # Send start simulation comm.Send([np.array([True], dtype='b'), MPI.CXX_BOOL], dest=0, tag=0) comm.Send([np.array(10, dtype='i'), MPI.INT], dest=0, tag=0) # send ID of spike generator comm.Send([np.array(ids, dtype='i'), MPI.INT], dest=0, tag=0) # receive the number of spikes for updating the spike detector size = np.empty(11, dtype='i') comm.Recv([size, 11, MPI.INT], source=0, tag=ids[0], status=status_) print("Nest_Input (" + str(ids[0]) + ") :receive size : " + str(size)) sys.stdout.flush() # receive the spikes for updating the spike detector data = np.empty(size[0], dtype='d') comm.Recv([data, size[0], MPI.DOUBLE], source=0, tag=ids[0], status=status_) print("Nest_Input (" + str(id) + ") : " + str(np.sum(data))) sys.stdout.flush() # printing value and exist print("Nest_Input: Before print ") sys.stdout.flush() if ids[0] == 0: print("Nest_Input:" + str([ids[0], data, np.sum(data)])) sys.stdout.flush() print("Nest_Input: debug end of loop") sys.stdout.flush() #send ending the the run of the simulation print("Nest_Input: Debug before send") sys.stdout.flush() comm.Send([np.array([True], dtype='b'), MPI.CXX_BOOL], dest=0, tag=1) print("Nest_Input: Debug after send") sys.stdout.flush() print("Nest_Input: before break") sys.stdout.flush() # print ("Nest_Input: before break" + str(data > 10000));sys.stdout.flush() if np.any(data > 10000): break # closing the connection at this end print('Nest_Input : Disconnect') comm.Send([np.array([True], dtype='b'), MPI.CXX_BOOL], dest=0, tag=2) comm.Disconnect() MPI.Close_port(port) print('Nest_Input :exit') MPI.Finalize()
def input(path,nb_mpi): """ Simulate some random spike train input :param path: the file for the configurations of the connection :param nb_mpi: number of mpi rank for testing multi-threading and MPI simulation :return: """ #Start communication channels path_to_files = path #For NEST # Init connection print("INPUT : Waiting for port details") info = MPI.INFO_NULL root=0 port = MPI.Open_port(info) fport = open(path_to_files, "w+") fport.write(port) fport.close() print('INPUT : wait connection '+port) sys.stdout.flush() comm = MPI.COMM_WORLD.Accept(port, info, root) print('INPUT : connect to '+port) #test one rate status_ = MPI.Status() check = np.empty(1,dtype='b') source_sending = np.arange(0,comm.Get_remote_size(),1) # list of all the process for the commmunication starting = 1 while True: comm.Recv([check, 1, MPI.CXX_BOOL], source=0, tag=MPI.ANY_TAG, status=status_) print("INPUT : start to send"); sys.stdout.flush() print("INPUT : status a tag ",status_.Get_tag() ); sys.stdout.flush() if status_.Get_tag() == 0 : for source in source_sending: if source != 0: comm.Recv([check, 1, MPI.CXX_BOOL], source=source, tag=MPI.ANY_TAG, status=status_) print("Input : source is", source); sys.stdout.flush() # receive list ids size_list = np.empty(1, dtype='i') comm.Recv([size_list, 1, MPI.INT], source=source, tag=0, status=status_) print("INPUT : size list id",size_list);sys.stdout.flush() if size_list[0] != 0: list_id = np.empty(size_list, dtype='i') comm.Recv([list_id, size_list, MPI.INT], source=source, tag=0, status=status_) print("INPUT : id ", list_id);sys.stdout.flush() shape = np.random.randint(0,100,1,dtype='i') data = starting+np.random.rand(shape[0])*200 data = np.around(np.sort(np.array(data,dtype='d')),decimals=1) send_shape = np.array(np.concatenate([shape,shape]),dtype ='i') comm.Send([send_shape, MPI.INT], dest=source, tag=list_id[0]) print("INPUT : shape data ",shape);sys.stdout.flush() comm.Send([data, MPI.DOUBLE], dest=source, tag=list_id[0]) print("INPUT : send data", data);sys.stdout.flush() for source in source_sending: print("INPUT : end");sys.stdout.flush() comm.Recv([check, 1, MPI.CXX_BOOL], source=source, tag=MPI.ANY_TAG, status=status_) print("INPUT : end run");sys.stdout.flush() starting+=200 elif(status_.Get_tag() ==2): for i in range(nb_mpi-1): print(" receive ending");sys.stdout.flush() comm.Recv([check, 1, MPI.CXX_BOOL], source=MPI.ANY_SOURCE, tag=MPI.ANY_TAG, status=status_) print("INPUT : end simulation");sys.stdout.flush() print("INPUT : ending time : ",starting) break else: print(status_.Get_tag()) break comm.Disconnect() MPI.Close_port(port) os.remove(path_to_files) print('INPUT : exit') MPI.Finalize()