def getArrayFromNT(table, nrows=0): bd = BlockDescriptor_Float64() if nrows == 0: nrows = table.getNumberOfRows() table.getBlockOfRows(0, nrows, readOnly, bd) npa = bd.getArray() table.releaseBlockOfRows(bd) return npa if __name__ == "__main__": trainDatasetFileNames = getDatasetFileNames('news_train_dense_dist_data_*.csv') comm = MPI.COMM_WORLD comm_size = comm.Get_size() rankId = comm.Get_rank() print("I am a worker with rank %d on %s." % (rankId, MPI.Get_processor_name())) start = MPI.Wtime() trainModel() if rankId == MPI_ROOT: end = MPI.Wtime() testModel() testGroundTruth = FileDataSource(testGroundTruthFileName, DataSourceIface.doAllocateNumericTable, DataSourceIface.doDictionaryFromContext) testGroundTruth.loadDataBlock() a = getArrayFromNT(predictionResult.get(classifier.prediction.prediction)) b = getArrayFromNT(testGroundTruth.getNumericTable()) acc = metrics.accuracy_score(a, b, normalize=True) print('Accuracy: {:.4f}'.format(acc)) print('Computational time: {:.2f}'.format(end - start))
def getprocessorinfo(): from mpi4py import MPI rank = MPI.COMM_WORLD.Get_rank() name = MPI.Get_processor_name() return (rank, name)
#writing ensight Gold binary (comaptible with vtk 8) #parallelization borowed here https://gist.github.com/fspaolo/51eaf5a20d6d418bd4d0 import numpy as np #needs install import os import pandas #needs install from mpi4py import MPI #needs install from queue import Queue WORKTAG = 1 DIETAG = 0 comm = MPI.COMM_WORLD my_rank = comm.Get_rank() my_name = MPI.Get_processor_name() # In[9]: #------------------------------------------------- # # Parse arguments # #------------------------------------------------- inputfolder = None project_name = None outputfolder = None try: if my_rank == 0: import argparse
def v1_kcat_mwc_validate(): name = MPI.Get_processor_name() rank = MPI.COMM_WORLD.Get_rank() size = MPI.COMM_WORLD.Get_size() if rank == 0: # create ident object first v1_ident = ModelIdent( ident_fun=kotte_model.flux_1_kcat_ident, arranged_data_file_name=os.path.join( os.getcwd(), 'exp/exp_v1_2_experiments_mwc'), ident_data_file_name=os.path.join(os.getcwd(), 'ident/ident_v1_kcat_mwc'), **{ 'original_exp_file': os.path.join(os.getcwd(), 'exp/experiments_mwc'), 'flux_id': 1, 'flux_choice': 2, 'values_figure': os.path.join(os.getcwd(), 'results/v1_kcat_mwc_parameter_values.eps'), 'ident_figure': os.path.join(os.getcwd(), 'results/v1_kcat_mwc_ident.eps'), 'exp_figure': os.path.join(os.getcwd(), 'results/v1_kcat_mwc_exp.eps'), 'figure_format': 'eps', 'ident_index_label': ['sample_name', 'data_set_id'] }) # retrieve identifiability data and process it for validation v1_ident.validation_info() user_ode_opts = { 'iter': 'Newton', 'discr': 'Adams', 'atol': 1e-10, 'rtol': 1e-10, 'time_points': 200, 'display_progress': True, 'verbosity': 30 } # initial ss to begin all simulations from y0 = np.array([5, 1, 1]) # get and set true parameter values, if available separately default_parameters = true_parameter_values() v1_valid_obj = ValidateSim( kotte_model.kotte_ode, kotte_model.kotte_flux, **{ 'kinetics': 1, 'ode_opts': user_ode_opts, 't_final': 200, 'wt_y0': y0, 'i_parameter': default_parameters, 'sample_size': 1, 'noise_std': 0.05, 'validate_index_label': ['estimate_id', 'sample_name', 'data_set_id', 'experiment_id'], 'validate_file_name': os.path.join(os.getcwd(), 'validate/v1_kcat_mwc_validate'), 'original_exp_file': v1_ident.original_exp_file, 'c_validate_file': os.path.join(os.getcwd(), 'results/v1_kcat_mwc_c_validate.eps'), 'f_validate_file': os.path.join(os.getcwd(), 'results/v1_kcat_mwc_f_validate.eps'), 'c_exp_file': os.path.join(os.getcwd(), 'results/v1_kcat_mwc_c_exp.eps'), 'v_exp_file': os.path.join(os.getcwd(), 'results/v1_kcat_mwc_f_exp.eps'), 'format': v1_ident.figure_format }) parameter_estimates, estimate_info = v1_valid_obj.create_parameter_list( v1_ident.select_values) job = ParallelValidate(slaves=range(1, size)) validate_results = job.run_all(task='initial_sim', **{ 'parameters': parameter_estimates, 'estimate_info': estimate_info, 'sim_obj': v1_valid_obj }) job.terminate_slaves() # process validation data for plots validate_processing(v1_valid_obj, validate_results) else: print('I am %s Slave with rank %s of %s' % (name, str(rank), str(size))) ValidateSlave().run() return None
from mpi4py import MPI comm = MPI.COMM_WORLD size = comm.Get_size() rank = comm.Get_rank() node_name = MPI.Get_processor_name() # get the name of the node print('Hello world from process %d at %s.' % (rank, size))
process_file(f) #send unfinished buffers for id_dest in range(cnt_reducers): for pos_buf in range(pos_bufers[id_dest], size_buffer): buffers[id_dest][pos_buf][0] = -1 comm.Send(buffers[id_dest], dest=id_dest + cnt_mappers, tag=1) print("m{} finished! sppend {:.2f} s on waiting Send".format( id_worker, timings["wait_send"])) #print (lst_files) else: #this is reducer timings["collecting"] -= timer() rstart, rend = get_interval(cnt_words, cnt_reducers, id_reducer) m = ArrayOfTrees(rend - rstart) print( "I'm reducer {} of {} running on {}, my ownership range is from {} to {}" .format(id_reducer, cnt_reducers, MPI.Get_processor_name(), rstart, rend)) buffer = np.empty((size_buffer, 2), dtype=np.int64) cnt_mappers_finished = 0 has_work = True while has_work: #print("r{}: waiting rcv".format(id_reducer)) sys.stdout.flush() comm.Recv(buffer, source=MPI.ANY_SOURCE, tag=1) #print ("r{} recvd {}".format(id_reducer,buffer.shape)) for i in range(size_buffer): if buffer[i, 0] >= 0: m.accumulate(int(buffer[i][0] - rstart), int(buffer[i][1])) #todo mapping for aot else: cnt_mappers_finished += 1
def classify_subvolumes(): """ Assigns each pixels to the class with the highest probability value determined by Ilastik classifier. Ilastik returns probability map in the "exported_data" dataset with the dimensions of x,y,z (pixel location) by N values and N is the number of classes (labels) defined in the Ilastik trained data file. This script adds N datasets to each of the input hdf5 files. Dimension of each dataset is x,y,z (pixel location) and value of zero or one. The pixel location in the added datasets with the highest probability value is one, zero otherwise. Input: Ilastik sub-volumes pixel classified hdf5 files - file location is specified in seg_user_param.py. Output: Datasets added to the sub-volume input files - one dataset per each class/label in trained data. """ start_time = time.time() comm = MPI.COMM_WORLD rank = comm.Get_rank() size = MPI.COMM_WORLD.Get_size() name = MPI.Get_processor_name() ilastik_classes = get_ilastik_labels() if rank == 0: print("*** Time is %d Entered classify_subvolumes() ****" % time.time()) print("Ilastik classes are ", ilastik_classes) # Get list of pixel classified sub-volume files with probability maps . Assumes file extension is .h5 input_files = sorted(glob(hdf_subvol_files_location + '/*Probabilities.h5')) if not input_files: print("*** Did not find any file ending with .h5 extension ***", hdf_subvol_files_location) return if rank == 0: print("Number of HDF5 files is %d, and Number of processes is %d" % ((len(input_files)), size)) print("Sub-Volume file location is %s" % hdf_subvol_files_location) iterations = int(len(input_files) / size) + (len(input_files) % size > 0) for idx in range(iterations): if (rank + (size * idx)) >= len(input_files): print( "\nBREAKING out, my rank is %d, number of files is %d, size is %d and idx is %d" % (rank, len(input_files), size, idx)) break infile = h5py.File(input_files[rank + (size * idx)], 'r+') exds = infile[ilastik_ds_name] start_read = time.time() export_indata = exds[...] export_outdata = np.zeros(export_indata.shape, dtype='uint8') print("export_indata data shape is", export_indata.shape) end_read = time.time() print("Read time for all rows of Ilastik Prob map is %d Sec" % (end_read - start_read)) print_cycle = 100 start_loop_time = time.time() for row in range(export_outdata.shape[0]): for colmn in range(export_outdata.shape[1]): outdata = np.zeros( (export_outdata.shape[2], export_outdata.shape[3]), 'uint8') if row == 0: if colmn == 0: print("outdata shape is", outdata.shape) outdata[np.arange(len(outdata)), np.argmax(export_indata[row, colmn, :, :], axis=-1)] = 1 if np.count_nonzero(outdata) != export_outdata.shape[2]: print( "Something is very wrong - check row %d and colmn %d" % (row, colmn)) export_outdata[row, colmn, :, :] = outdata.copy() if row % print_cycle == 0: print("time to classify %d rows is %d Sec" % (print_cycle, (time.time() - start_loop_time))) start_loop_time = time.time() # Segment classes and saved them into datasets start_ds_time = time.time() no_of_classes = export_outdata.shape[3] export_outdata = np.transpose(export_outdata, (3, 0, 1, 2)) for idx in range(no_of_classes): time_per_ds = time.time() if infile.get(ilastik_classes[idx], getclass=True): print("*** Deleting subvolume object map %s ***" % (ilastik_classes[idx])) infile.__delitem__(ilastik_classes[idx]) outdataset = infile.create_dataset( ilastik_classes[idx], (export_outdata.shape[1], export_outdata.shape[2], export_outdata.shape[3]), export_outdata.dtype) outdataset[...] = export_outdata[idx, ...] print("Time to save %s dataset is %d Sec" % (ilastik_classes[idx], (time.time() - time_per_ds))) # Print time to save datasets print("Time to save all object maps is %d Sec" % (time.time() - start_ds_time)) infile.close() print("Exec time for this function was %d Sec and rank is %d" % ((time.time() - start_time), rank))
def set_MPI(self, comm): self.rank = comm.Get_rank() self.size = comm.Get_size() self.name = MPI.Get_processor_name() return self
def main(): comm = MPI.COMM_WORLD comm.Barrier() wt = MPI.Wtime() rank = comm.Get_rank() size = comm.Get_size() processorName = MPI.Get_processor_name() BLOCKS = int(sqrt(size)) for k in range(BLOCKS + 1): i = int(rank / BLOCKS) j = int(rank % BLOCKS) if k == 0: if rank == 0: A = read_matrix_from_file('input/matrixA') #B = read_matrix_from_file('input/matrixB') SUB_ELEM = int(len(A) / BLOCKS) ma = divide_into_blocks(A, BLOCKS) #mb = divide_into_blocks(B, BLOCKS) ma = initial_shift_left(ma) #mb = initial_shift_up(mb) for n in range(BLOCKS): for m in range(BLOCKS): if n == 0 and m == 0: continue comm.send(ma[n][m], dest=(n * BLOCKS + m), tag=1) #comm.send(mb[n][m], dest=(n * BLOCKS + m), tag=2) dataA = ma[0][0] #dataB = mb[0][0] dataB = comm.recv(source=1, tag=2) C = [[0 for i in range(SUB_ELEM)] for j in range(SUB_ELEM)] elif rank == 1: B = read_matrix_from_file('input/matrixB') SUB_ELEM = int(len(B) / BLOCKS) mb = divide_into_blocks(B, BLOCKS) mb = initial_shift_up(mb) for n in range(BLOCKS): for m in range(BLOCKS): if n == 0 and m == 1: continue comm.send(mb[n][m], dest=(n * BLOCKS + m), tag=2) dataB = mb[0][1] dataA = comm.recv(source=0, tag=1) C = [[0 for i in range(SUB_ELEM)] for j in range(SUB_ELEM)] else: dataA = comm.recv(source=0, tag=1) dataB = comm.recv(source=1, tag=2) SUB_ELEM = int(len(dataA)) C = [[0 for i in range(SUB_ELEM)] for j in range(SUB_ELEM)] else: # izracunaj C = multiple_matrixes(dataA, dataB, C, 0, 0) comm.send(dataA, dest=(i * BLOCKS + (j + BLOCKS - 1) % BLOCKS), tag=1) comm.send(dataB, dest=(((i + BLOCKS - 1) % BLOCKS) * BLOCKS + j), tag=2) dataA = comm.recv(source=(i * BLOCKS + (j + 1) % BLOCKS), tag=1) dataB = comm.recv(source=(((i + 1) % BLOCKS) * BLOCKS + j), tag=2) if rank == 0: blocks = [[] for i in range(size)] blocks[0] = C for i in range(1, size): blocks[i] = comm.recv(source=i) res = [[0 for i in range(len(A))] for j in range(len(A[0]))] res = blocks_to_matrix(blocks, res) write_matrix_to_file("output/parallelOutput", res) else: comm.send(C, dest=0) comm.Barrier() if rank == 0: wt = MPI.Wtime() - wt print("Vreme: ", wt)
def run_mpi_sim(args, inputfile, usernamespace, optparams=None): """ Run mixed mode MPI/OpenMP simulation - MPI task farm for models with each model parallelised using either OpenMP (CPU) or CUDA (GPU) Args: args (dict): Namespace with command line arguments inputfile (object): File object for the input file. usernamespace (dict): Namespace that can be accessed by user in any Python code blocks in input file. optparams (dict): Optional argument. For Taguchi optimisation it provides the parameters to optimise and their values. """ from mpi4py import MPI status = MPI.Status() hostname = MPI.Get_processor_name() # Set range for number of models to run modelstart = args.restart if args.restart else 1 modelend = modelstart + args.n numbermodelruns = args.n # Command line flag used to indicate a spawned worker instance workerflag = '--mpi-worker' numworkers = args.mpi - 1 ################## # Master process # ################## if workerflag not in sys.argv: # N.B Spawned worker flag (--mpi-worker) applied to sys.argv when MPI.Spawn is called # Get MPI communicator object either through argument or just get comm_world if hasattr(args, 'mpicomm'): comm = args.mpicomm else: comm = MPI.COMM_WORLD rank = comm.Get_rank() # rank of this process tsimstart = perf_counter() print('MPI master ({}, rank {}) on {} using {} workers\n'.format( comm.name, rank, hostname, numworkers)) # Assemble a sys.argv replacement to pass to spawned worker # N.B This is required as sys.argv not available when gprMax is called via api() # Ignore mpicomm object if it exists as only strings can be passed via spawn myargv = [] for key, value in vars(args).items(): if value: # Input file name always comes first if 'inputfile' in key: myargv.append(value) elif 'gpu' in key: myargv.append('-' + key) # If specific GPU device ID is given then add it if not isinstance(value, list): myargv.append(str(value.deviceID)) elif 'mpicomm' in key: pass elif '_' in key: key = key.replace('_', '-') myargv.append('--' + key) else: myargv.append('-' + key) if value is not True: myargv.append(str(value)) # Create a list of work worklist = [] for model in range(modelstart, modelend): workobj = dict() workobj['currentmodelrun'] = model if optparams: workobj['optparams'] = optparams worklist.append(workobj) # Add stop sentinels worklist += ([StopIteration] * numworkers) # Spawn workers newcomm = comm.Spawn(sys.executable, args=['-m', 'gprMax'] + myargv + [workerflag], maxprocs=numworkers) # Reply to whoever asks until done for work in worklist: newcomm.recv(source=MPI.ANY_SOURCE, status=status) newcomm.send(obj=work, dest=status.Get_source()) # Shutdown communicators newcomm.Disconnect() tsimend = perf_counter() simcompletestr = '\n=== Simulation completed in [HH:MM:SS]: {}'.format( datetime.timedelta(seconds=tsimend - tsimstart)) print('{} {}\n'.format( simcompletestr, '=' * (get_terminal_width() - 1 - len(simcompletestr)))) ################## # Worker process # ################## elif workerflag in sys.argv: print('Worker') # Connect to parent to get communicator try: comm = MPI.Comm.Get_parent() rank = comm.Get_rank() except ValueError: raise ValueError('MPI worker could not connect to parent') # Ask for work until stop sentinel for work in iter(lambda: comm.sendrecv(0, dest=0), StopIteration): currentmodelrun = work['currentmodelrun'] # Get info and setup device ID for GPU(s) gpuinfo = '' if args.gpu is not None: # Set device ID for multiple GPUs if isinstance(args.gpu, list): deviceID = (rank - 1) % len(args.gpu) args.gpu = next(gpu for gpu in args.gpu if gpu.deviceID == deviceID) gpuinfo = ' using {} - {}, {} RAM '.format( args.gpu.deviceID, args.gpu.name, human_size(args.gpu.totalmem, a_kilobyte_is_1024_bytes=True)) # If Taguchi optimistaion, add specific value for each parameter to # optimise for each experiment to user accessible namespace if 'optparams' in work: tmp = {} tmp.update((key, value[currentmodelrun - 1]) for key, value in work['optparams'].items()) modelusernamespace = usernamespace.copy() modelusernamespace.update({'optparams': tmp}) else: modelusernamespace = usernamespace # Run the model print('MPI worker (rank {}) starting model {}/{}{} on {}\n'.format( rank, currentmodelrun, numbermodelruns, gpuinfo, hostname)) run_model(args, currentmodelrun, modelend - 1, numbermodelruns, inputfile, modelusernamespace) # Shutdown comm.Disconnect()
def run_mpi_alt_sim(args, inputfile, usernamespace, optparams=None): """ Alternate MPI implementation that avoids using the spawn mechanism. This implementation is designed to be used as e.g. 'mpirun -n 5 python -m gprMax user_models/mymodel.in -n 10 -mpialt' Run mixed mode MPI/OpenMP simulation - MPI task farm for models with each model parallelised using either OpenMP (CPU) or CUDA (GPU) Args: args (dict): Namespace with command line arguments inputfile (object): File object for the input file. usernamespace (dict): Namespace that can be accessed by user in any Python code blocks in input file. optparams (dict): Optional argument. For Taguchi optimisation it provides the parameters to optimise and their values. """ from mpi4py import MPI # Define MPI message tags tags = Enum('tags', {'READY': 0, 'DONE': 1, 'EXIT': 2, 'START': 3}) # Initializations and preliminaries comm = MPI.COMM_WORLD size = comm.Get_size() # total number of processes rank = comm.Get_rank() # rank of this process status = MPI.Status() # get MPI status object hostname = MPI.Get_processor_name() # get name of processor/host # Set range for number of models to run modelstart = args.restart if args.restart else 1 modelend = modelstart + args.n numbermodelruns = args.n currentmodelrun = modelstart # can use -task argument to start numbering from something other than 1 numworkers = size - 1 ################## # Master process # ################## if rank == 0: tsimstart = perf_counter() print('MPI master ({}, rank {}) on {} using {} workers\n'.format( comm.name, rank, hostname, numworkers)) closedworkers = 0 while closedworkers < numworkers: comm.recv(source=MPI.ANY_SOURCE, tag=MPI.ANY_TAG, status=status) source = status.Get_source() tag = status.Get_tag() # Worker is ready, so send it a task if tag == tags.READY.value: if currentmodelrun < modelend: comm.send(currentmodelrun, dest=source, tag=tags.START.value) currentmodelrun += 1 else: comm.send(None, dest=source, tag=tags.EXIT.value) # Worker has completed a task elif tag == tags.DONE.value: pass # Worker has completed all tasks elif tag == tags.EXIT.value: closedworkers += 1 tsimend = perf_counter() simcompletestr = '\n=== Simulation completed in [HH:MM:SS]: {}'.format( datetime.timedelta(seconds=tsimend - tsimstart)) print('{} {}\n'.format( simcompletestr, '=' * (get_terminal_width() - 1 - len(simcompletestr)))) ################## # Worker process # ################## else: while True: comm.send(None, dest=0, tag=tags.READY.value) # Receive a model number to run from the master currentmodelrun = comm.recv(source=0, tag=MPI.ANY_TAG, status=status) tag = status.Get_tag() # Run a model if tag == tags.START.value: # Get info and setup device ID for GPU(s) gpuinfo = '' if args.gpu is not None: # Set device ID for multiple GPUs if isinstance(args.gpu, list): deviceID = (rank - 1) % len(args.gpu) args.gpu = next(gpu for gpu in args.gpu if gpu.deviceID == deviceID) gpuinfo = ' using {} - {}, {}'.format( args.gpu.deviceID, args.gpu.name, human_size(args.gpu.totalmem, a_kilobyte_is_1024_bytes=True)) # If Taguchi optimistaion, add specific value for each parameter # to optimise for each experiment to user accessible namespace if optparams: tmp = {} tmp.update((key, value[currentmodelrun - 1]) for key, value in optparams.items()) modelusernamespace = usernamespace.copy() modelusernamespace.update({'optparams': tmp}) else: modelusernamespace = usernamespace # Run the model print('MPI worker (rank {}) starting model {}/{}{} on {}\n'. format(rank, currentmodelrun, numbermodelruns, gpuinfo, hostname)) run_model(args, currentmodelrun, modelend - 1, numbermodelruns, inputfile, modelusernamespace) comm.send(None, dest=0, tag=tags.DONE.value) # Break out of loop when work receives exit message elif tag == tags.EXIT.value: break comm.send(None, dest=0, tag=tags.EXIT.value)
from mpi4py import MPI comm = MPI.COMM_WORLD print('Hello from {}. {} of {}'.format(MPI.Get_processor_name(), comm.rank, comm.size))
def go(self): if rank == 0: self.initialize_controller() self.complete_snp_task_count = 0 with open(self.output_vcf_fp, 'w') as self.output_file, \ open(self.output_cv_scores_fp, 'w') as self.output_cv_scores_file: # this process is the controller # while there are still running workers wait for a work request num_workers = size - 1 a_task_gen = self.get_task() # need a fake task that is not None to get started a_task = object() while num_workers > 0: msg = comm.recv(source=MPI.ANY_SOURCE, tag=MPI.ANY_TAG, status=status) source = status.Get_source() tag = status.Get_tag() print( '[controller] recv message from worker {} with tag {}'. format(source, tag)) if tag == READY_ and a_task is None: # if a_task is None there are no more SNPs to test # and we should not call next(a_task_gen) again print('[controller] sending exit message to worker {}'. format(source)) comm.send(None, dest=source, tag=EXIT_) elif tag == READY_ and a_task is not None: a_task = next(a_task_gen) if a_task is None: print( '[controller] sending exit message to worker {}' .format(source)) comm.send(None, dest=source, tag=EXIT_) else: print( '[controller] sending a task to worker {} with SNP {} {}' .format(source, a_task.snp_with_rsq_df.GENE[0], a_task.snp_with_rsq_df.ID[0])) comm.send(a_task, dest=source, tag=START_) elif tag == DONE_: # save the results self.complete_snp_task_count += 1 self.task_complete(msg) print( '[controller] received a processed task from worker {}' .format(source)) elif tag == EXIT_: print( '[controller] received exit message from worker {}' .format(source)) num_workers -= 1 elif tag == EXCEPTION_: print( '[controller] received exception message from worker {} with SNP {} {}' .format(source, msg.snp_with_rsq_df.GENE[0], msg.snp_with_rsq_df.ID[0])) self.task_failed(msg) num_workers -= 1 else: print( '[controller] unrecognized message from source {} with tag {}:\n{}' .format(source, tag, msg)) print('[controller] all workers have exited') else: # this process is a worker self.initialize_worker() worker_t0 = time.time() task_count = 0 name = MPI.Get_processor_name() print("[worker {}] running on {}".format(rank, name)) while True: print('[worker {}] sending request for work'.format(rank)) comm.send(None, dest=0, tag=READY_) print('[worker {}] waiting for work'.format(rank)) t0 = time.time() my_task = comm.recv(source=0, tag=MPI.ANY_TAG, status=status) t1 = time.time() print('[worker {}] waited {:4.2f}s for work'.format( rank, t1 - t0)) tag = status.Get_tag() print('[worker {}] received message with tag {}'.format( rank, tag)) if tag == START_: try: t0 = time.time() my_task.do() t1 = time.time() print('[worker {}] task time: {:5.2f}s'.format( rank, t1 - t0)) comm.send(my_task, dest=0, tag=DONE_) task_count += 1 except Exception as e: print( '[worker {}] quitting with exception'.format(rank)) traceback.print_exc() comm.send(my_task, dest=0, tag=EXCEPTION_) break elif tag == EXIT_: print('[worker {}] received exit message'.format(rank)) comm.send(None, dest=0, tag=EXIT_) break else: # an unknown message was received - maybe from outer space? print( '[worker {}] received an unrecognized message with tag {} - exiting' .format(rank, tag)) break worker_t1 = time.time() print('[worker {}] exiting after {} tasks in {:6.2f}s'.format( rank, task_count, worker_t1 - worker_t0))
def vessel_seg_post_proc(): comm = MPI.COMM_WORLD rank = comm.Get_rank() size = MPI.COMM_WORLD.Get_size() name = MPI.Get_processor_name() start_time = int(time.time()) # Get the list of all segmented sub-volume files. input_files = sorted(glob(outimage_file_location + '/*subvol*.h5')) if not input_files: print("*** Did not find any sub-volume segmented file in location %s ***" % outimage_file_location) return # Get the "Vessel" label index vessel_label_defined, vessel_label_idx = save_prob_map('Vessel') if vessel_label_defined == False: print("Vessel class is not labeled in the Ilastik training data file, no processing will take place") return # Shape/Dimension of the volume image is available in the last sub-volume file. volume_ds_shape = np.zeros((3,), dtype='uint64') # Last file has the dimensions for the volume. f = h5py.File(input_files[-1], 'r') volshape = f['orig_indices'] volume_ds_shape[0] = volshape[1] volume_ds_shape[1] = volshape[3] volume_ds_shape[2] = volshape[5] f.close() # Get the list of segmented datasets # seg_ds_list = f.keys() labeld_obj = get_ilastik_labels() ds_name = labeld_obj[vessel_label_idx] # Create an hdf file to contain the post segmentation cell volume image. par, name = os.path.split(post_seg_volume_location) seg_volume_file = post_seg_volume_location + '/volume_vessel_' + name + '.h5' if rank == 0: print("Post segmentation directory is %s, number of file is %d and number of python processes is %d" % (post_seg_volume_location, len(input_files), size)) print("Volume shape is", volume_ds_shape) # Create directory for the post segmentation processing if it does not exist. if rank == 0: if not os.path.exists(post_seg_volume_location): os.mkdir(post_seg_volume_location) print("File directory for post segmentation did not exist, was created") comm.Barrier() # Need Parallel HDF for faster processing. However the below test lets processing to continue even if # Parallel HDF is not available. if size == 1: vol_img_file = h5py.File(seg_volume_file, 'w') else: vol_img_file = h5py.File(seg_volume_file, 'w', driver='mpio', comm=comm) if rank == 0: print("Dataset name to apply post processing is %s" % ds_name) vol_seg_dataset = vol_img_file.create_dataset(ds_name, volume_ds_shape, dtype='uint32', chunks=(1, il_sub_vol_y, il_sub_vol_z)) iterations = int(len(input_files) / size) + (len(input_files) % size > 0) for idx in range(iterations): if (rank + (size * idx)) >= len(input_files): print("\nBREAKING out, my rank is %d, number of files is %d, size is %d and idx is %d" % (rank, len(input_files), size, idx)) break print("*** Working on file %s and rank is %d ***" % (input_files[rank + size * idx], rank)) subvol_file = h5py.File(input_files[rank + size * idx], 'r') # Retrieve indices into the whole volume. orig_idx_ds = subvol_file['orig_indices'] orig_idx = orig_idx_ds[...] # Retrieve overlap size to the right and left side of the sub-volume. right_overlapds = subvol_file['right_overlap'] rightoverlap = right_overlapds[...] left_overlapds = subvol_file['left_overlap'] leftoverlap = left_overlapds[...] myds = subvol_file[ds_name] subvoldata = myds[...] x_dim = subvoldata.shape[0] y_dim = subvoldata.shape[1] z_dim = subvoldata.shape[2] subvoldata = subvoldata > 0 subvoldata = ndi.binary_fill_holes(subvoldata) subvoldata = morphology.erosion(subvoldata, morphology.ball(2)) subvoldata = morphology.dilation(subvoldata, morphology.ball(2)) subvoldata = ndi.binary_fill_holes(subvoldata) subvoldata = morphology.remove_small_objects(subvoldata, MINSZ_VESSEL, connectivity=2) subvoldata = morphology.label(subvoldata.astype('uint32')) vol_seg_dataset[orig_idx[0]:orig_idx[1], orig_idx[2]:orig_idx[3], orig_idx[4]:orig_idx[5]] = \ subvoldata[leftoverlap[0] : x_dim - rightoverlap[0], leftoverlap[1] : y_dim - rightoverlap[1], leftoverlap[2] : z_dim - rightoverlap[2]] subvol_file.close() vol_img_file.close() print("Time to execute vessel_seg_post_proc() is %d seconds and rank is %d" % ((time.time() - start_time), rank))
def _setup_MPI_grid(self): """Split space up according to the number of MPI tasks. Set instance attributes for spatial extent and number of points in this MPI task, and create buffers and persistent communication requests for sending data to adjacent processes""" self.MPI_size = MPI.COMM_WORLD.Get_size() self.MPI_size_x, self.MPI_size_y = get_best_2D_segmentation( self.nx_global, self.ny_global, self.MPI_size) self.MPI_comm = MPI.COMM_WORLD.Create_cart( [self.MPI_size_x, self.MPI_size_y], periods=[self.periodic_x, self.periodic_y], reorder=True) self.MPI_rank = self.MPI_comm.Get_rank() self.MPI_x_coord, self.MPI_y_coord = self.MPI_comm.Get_coords( self.MPI_rank) if self.MPI_x_coord > 0 or self.periodic_x: self.MPI_rank_left = self.MPI_comm.Get_cart_rank( (self.MPI_x_coord - 1, self.MPI_y_coord)) else: self.MPI_rank_left = MPI.PROC_NULL if self.MPI_x_coord < self.MPI_size_x - 1 or self.periodic_x: self.MPI_rank_right = self.MPI_comm.Get_cart_rank( (self.MPI_x_coord + 1, self.MPI_y_coord)) else: self.MPI_rank_right = MPI.PROC_NULL if self.MPI_y_coord > 0 or self.periodic_y: self.MPI_rank_down = self.MPI_comm.Get_cart_rank( (self.MPI_x_coord, self.MPI_y_coord - 1)) else: self.MPI_rank_down = MPI.PROC_NULL if self.MPI_y_coord < self.MPI_size_y - 1 or self.periodic_y: self.MPI_rank_up = self.MPI_comm.Get_cart_rank( (self.MPI_x_coord, self.MPI_y_coord + 1)) else: self.MPI_rank_up = MPI.PROC_NULL self.processor_name = MPI.Get_processor_name() # Share out the points between processes in each direction: self.nx, nx_remaining = divmod(self.nx_global, self.MPI_size_x) if self.MPI_x_coord < nx_remaining: # Give the remaining to the lowest ranked processes: self.nx += 1 self.ny, ny_remaining = divmod(self.ny_global, self.MPI_size_y) if self.MPI_y_coord < ny_remaining: # Give the remaining to the lowest ranked processes: self.ny += 1 # What are our coordinates in the global array? self.global_first_x_index = self.nx * self.MPI_x_coord # Be sure to count the extra points the lower ranked processes have: if self.MPI_x_coord >= nx_remaining: self.global_first_x_index += nx_remaining self.global_first_y_index = self.ny * self.MPI_y_coord # Be sure to count the extra points the lower ranked processes have: if self.MPI_y_coord >= ny_remaining: self.global_first_y_index += ny_remaining # We need to tag our data to have a way other than rank to distinguish # between multiple messages the two tasks might be sending each other # at the same time: TAG_LEFT_TO_RIGHT = 0 TAG_RIGHT_TO_LEFT = 1 TAG_DOWN_TO_UP = 2 TAG_UP_TO_DOWN = 3 # Buffers and MPI request objects for sending and receiving data to # and from other processes. Sorted by whether the datatype is real or # complex. self.MPI_send_buffers = {} self.MPI_receive_buffers = {} self.MPI_requests = {} for dtype in [np.float64, np.complex128]: x_edge_shape = (self.n_edge_pts, self.ny) y_edge_shape = (self.nx, self.n_edge_pts) left_send_buffer = np.zeros(x_edge_shape, dtype=dtype) left_receive_buffer = np.zeros(x_edge_shape, dtype=dtype) right_send_buffer = np.zeros(x_edge_shape, dtype=dtype) right_receive_buffer = np.zeros(x_edge_shape, dtype=dtype) bottom_send_buffer = np.zeros(y_edge_shape, dtype=dtype) bottom_receive_buffer = np.zeros(y_edge_shape, dtype=dtype) top_send_buffer = np.zeros(y_edge_shape, dtype=dtype) top_receive_buffer = np.zeros(y_edge_shape, dtype=dtype) send_left = self.MPI_comm.Send_init(left_send_buffer, self.MPI_rank_left, tag=TAG_RIGHT_TO_LEFT) send_right = self.MPI_comm.Send_init(right_send_buffer, self.MPI_rank_right, tag=TAG_LEFT_TO_RIGHT) send_bottom = self.MPI_comm.Send_init(bottom_send_buffer, self.MPI_rank_down, tag=TAG_UP_TO_DOWN) send_top = self.MPI_comm.Send_init(top_send_buffer, self.MPI_rank_up, tag=TAG_DOWN_TO_UP) receive_left = self.MPI_comm.Recv_init(left_receive_buffer, self.MPI_rank_left, tag=TAG_LEFT_TO_RIGHT) receive_right = self.MPI_comm.Recv_init(right_receive_buffer, self.MPI_rank_right, tag=TAG_RIGHT_TO_LEFT) receive_bottom = self.MPI_comm.Recv_init(bottom_receive_buffer, self.MPI_rank_down, tag=TAG_DOWN_TO_UP) receive_top = self.MPI_comm.Recv_init(top_receive_buffer, self.MPI_rank_up, tag=TAG_UP_TO_DOWN) self.MPI_send_buffers[dtype] = (left_send_buffer, right_send_buffer, bottom_send_buffer, top_send_buffer) self.MPI_receive_buffers[dtype] = (left_receive_buffer, right_receive_buffer, bottom_receive_buffer, top_receive_buffer) self.MPI_requests[dtype] = (send_left, send_right, send_bottom, send_top, receive_left, receive_right, receive_bottom, receive_top) self.pending_requests = None
def mpiPI(nroProcesso, rank):#funcao que calcula o valor aprox de pi N = 840 i = int(1 + (N/nroProcesso)*rank) k = int((N/nroProcesso)*(rank+1)) somatorio = 0 for j in range(i,k+1): somatorio += 1/(1+((j-0.5)/N)**2) #print(i,k)#intervalos #print((somatorio/N)*4)#somatorio de cada intervalo return (somatorio/N)*4 if __name__ == "__main__": #main -- Segunda versão comm = MPI.COMM_WORLD rank = comm.Get_rank()#rank do processo atual numDeProcessos = comm.Get_size()#numero de processos idmaquina = MPI.Get_processor_name()#hostname damaquina comm.Barrier()#barreira inicio tinicial = MPI.Wtime() res1 = mpiPI(comm.Get_size(),rank) comm.Barrier()#barreira fim tfinal=MPI.Wtime() k = ("Resposta do processo [" + str(rank) + "] = " + str(res1) + " ID Máquina = "+str(idmaquina)) #print("-"*len(k)+"\n"+k+"\n") if rank == 0: bufferAux = [tfinal-tinicial] for i in range(1,numDeProcessos): bufferAux.append(comm.recv(source = i)) arquivo.write(str(max(bufferAux))+"\n") arquivo.close() #print("Tempo de execução:",max(bufferAux))#tempo do processo que durou mais else:
""" Performs a reduction on valin across all processes in MPI_COMM_WORLD. Reduced value is stored in valout Reduction operation is controlled by rop: rop = MPI_SUM => Summation rop = MPI_MIN => Min rop = MPI_MAX => Max """ valout = 0 return valout ########################### # Initialize Communication cw = MPI.COMM_WORLD rank = cw.rank size = cw.size proc = MPI.Get_processor_name() ############################################# # Read problem parameters from command line num = numpy.zeros(1, dtype='i') if (rank == 0): try: num[0] = int(sys.argv[2]) except: num[0] = 1 cw.Bcast(num, root=0) op = num[0] if (op > 3):
import os from mpi4py import MPI import re import time import codecs from analyse_tweet import analyseTweet, combineResults from senticnet import * from sentiwordnet import SentiWordNet from sasa_tweet_classifier import SasaTweetClassifier from nltk_tweet_classifier import NLTKTweetClassifier from logger import Logger SIZE = MPI.COMM_WORLD.Get_size() RANK = MPI.COMM_WORLD.Get_rank() NAME = MPI.Get_processor_name() COMM = MPI.COMM_WORLD if RANK == 0: log = Logger("logs/log_" + str(int(time.time())) + ".txt") log.log("MPI.COMM_WORLD.Get_size(): " + str(SIZE)) totalTime = time.time() lapTime = time.time() log.log("Opening config file: config/config.txt") f = open('config/config.txt', 'r') config = f.read() config = config.split("#-#-#-#") filename = config[0] title = config[1] title_file_prefix = title.lower()
def main(): global TOTAL_SIMS_TO_RUN, PHOTONS_PER_BIN, SIZE_OF_WAVEBINS COMM = MPI.COMM_WORLD SIZE = COMM.Get_size() RANK = COMM.Get_rank() NAME = MPI.Get_processor_name() #for convenenience if TOTAL_SIMS_TO_RUN < 1: TOTAL_SIMS_TO_RUN = SIM_SAMPLES * SIZE #give everyone SIM_SAMPLES, and take an average time for comparision #just for learning purposes #in this specific case, could skip this entirely and just have each worker use its RANK as the seed #as well as the total sims to run ... since this is previously agreed on (as a global constant) seed = None if (RANK == 0): # MPI start the clock walltime = MPI.Wtime() # print ("Start time:", walltime) #since the program has this defined, no need to actually communicate here #build the seeds: seed = np.arange(SIZE, dtype=int) #send everybody the total number to run COMM.bcast(TOTAL_SIMS_TO_RUN) #send each core its own seed seed = COMM.scatter(seed) #ALL cores (manager and workers) run simulations n_esc = run_all(RANK, TOTAL_SIMS_TO_RUN, SIZE, seed) #ALL cores send results to manager recvbuf = None if RANK == 0: recvbuf = np.empty([SIZE, SIZE_OF_WAVEBINS], dtype=int) #I think there is another way to do this ... like a Reduce call? #gather up everyone's n_esc COMM.Gather(n_esc, recvbuf, root=0) #sum up ... manager sum = [] count = 0 if RANK == 0: sum = np.zeros(SIZE_OF_WAVEBINS) for i in range(SIZE): if DEBUG_PRINT: print("Summing", i, recvbuf[i]) sum += recvbuf[i] if DEBUG_PRINT: print("SUM", sum) sum = np.array(sum).astype(float) f_esc = sum / (PHOTONS_PER_BIN * TOTAL_SIMS_TO_RUN) if DEBUG_PRINT: print("f_esc", f_esc) if RANK == 0: # MPI stop the clock, get ellapsed time walltime = MPI.Wtime() - walltime print("Delta-time: ", walltime) print(" Per-sim: ", walltime / TOTAL_SIMS_TO_RUN) #todo: here is where we would make the plots, but don't bother since this is just #todo: a timing exercise if (RANK == 0): #sanity check .. make sure the escape curve matches the original data wavelengths = np.logspace(-2, 0.5, SIZE_OF_WAVEBINS) # 10AA ~ 30,000AA plt.close('all') plt.plot(wavelengths, f_esc, label="mean f_esc") #plt.fill_between(wavelengths, f_esc_low, f_esc_high, color='k', alpha=0.3, label=r"1-$\sigma$") plt.xscale('log') plt.legend() plt.title("f_esc by wavelength (%d simulations)" % (TOTAL_SIMS_TO_RUN)) plt.xlabel("wavelength bin [microns]") plt.ylabel("fraction of escaped photons") plt.savefig("rel_f_esc.png") MPI.Finalize()
#### ################################################################ ################################################################ from mpi4py import MPI import numpy as np import time comm = MPI.COMM_WORLD nprocs = comm.Get_size() procno = comm.Get_rank() ntests = 100 if procno==0 or procno==nprocs-1: print "Node name:",MPI.Get_processor_name() ## Determine who will be communicating: ## set processA, processB #### your code here #### ## ## Do a range of test sizes ## for s in [1,10,100,1000,10000,100000,1000000]: if procno==processA: #### #### Originating process: #### ##
def do_work(self, data): """do work method overrides Slave.do_work() and defines work to be done by every slave""" rank = MPI.COMM_WORLD.Get_rank() name = MPI.Get_processor_name() print(' Slave %s rank %d executing task %s' % (name, rank, data['task'])) if data['task'] == 'initial_sim': # define explicit assimulo problem sim_obj = data['sim_obj'] rhs_fun = sim_obj.rhs_fun # data['rhs_fun'] y_initial = data['y0'] estimate_id = data['id'] ode_opts = sim_obj.ode_opts # data['ode_opts'] ode_sys_opts = data['ode_sys_opts'] t_final = sim_obj.t_final # data['t_final'] all_options = [ode_opts, ode_sys_opts] print( ' Slave %s rank %d executing initial_sim for estimate: %s sample: %s, data set: %s' % (name, rank, estimate_id[0], estimate_id[1], estimate_id[2])) slave_tout, slave_yout, _, _ = simulate_ode(rhs_fun, y_initial, tf=t_final, opts=all_options) print(' ode simulation complete ') # calculate flux flux_fun = sim_obj.flux_fun # data['flux_fun'] slave_flux = np.array( list(map(lambda x: flux_fun(x, ode_sys_opts), slave_yout))) result = (slave_tout, slave_yout, slave_flux, estimate_id[0], estimate_id[1], estimate_id[2], sim_obj, ode_sys_opts) elif data['task'] == 'perturbation_sim': sim_obj = data['sim_obj'] rhs_fun = sim_obj.rhs_fun # data['rhs_fun'] y_initial = data['y0'] estimate_id = data['id'] perturbation_id = data['perturbation_id'] ode_opts = sim_obj.ode_opts # data['ode_opts'] ode_sys_opts = data['ode_sys_opts'] t_final = sim_obj.t_final # data['t_final'] all_options = [ode_opts, ode_sys_opts] print( ' Slave %s rank %d executing initial_sim for estimate: %s sample: %s, data set: %s ' 'perturbation: %s' % (name, rank, estimate_id[0], estimate_id[1], estimate_id[2], perturbation_id)) slave_tout, slave_yout, _, _ = simulate_ode(rhs_fun, y_initial, tf=t_final, opts=all_options) print(' ode perturbation simulation complete ') # calculate flux flux_fun = sim_obj.flux_fun # data['flux_fun'] slave_flux = np.array( list(map(lambda x: flux_fun(x, ode_sys_opts), slave_yout))) result = (slave_tout, slave_yout, slave_flux, estimate_id[0], estimate_id[1], estimate_id[2], perturbation_id) return data['task'], result
import os if len(sys.argv) != 5: sys.stdout.write( 'ERROR:\tUnexpected number of arguments.\nUSAGE:\tpython %s INPUT_PATH OUTPUT_PATH OVERWRITE(int) MPI(int)\n' % sys.argv[0]) sys.exit(1) this_dir = os.path.dirname(sys.argv[0]) inPath = sys.argv[1] outPath = sys.argv[2] overwrite = bool(int(sys.argv[3])) mpi = bool(int(sys.argv[4])) if mpi: from mpi4py import MPI nproc = MPI.COMM_WORLD.Get_size() iproc = MPI.COMM_WORLD.Get_rank() inode = MPI.Get_processor_name() else: nproc, iproc, inode = 1, 0, 0 try: (_, _, f) = next(os.walk(inPath)) except StopIteration: sys.stdout.write('ERROR: Empty input directory.\n') sys.exit(1) if mpi: fs = np.array_split(f, nproc)[iproc] else: fs = f for i, filename in enumerate(fs): outFile = os.path.join(outPath, filename) if os.path.isfile(outFile) and not overwrite: continue ascii_df = pd.read_csv(os.path.join(inPath, filename), delim_whitespace=True,
from mpi4py import MPI import time import os comm = MPI.COMM_WORLD rank = comm.Get_rank() host = MPI.Get_processor_name() payload_size = 32 size = comm.Get_size() msg_num = 0 status_ = MPI.Status() has_run = False if os.path.isfile('./results.csv') is False: with open('results.csv', 'a') as csv: ColumnRow = 'rank, msg_num, timestamp\n' csv.write(ColumnRow) while msg_num < 100: with open('results.csv', 'a') as csv: if rank == 0: # print("Rank %s sending %d" % (rank, msg_num)) data = bytes(payload_size) # send to mpi2 time_send = time.time() comm.send(data, dest=1, tag=msg_num) csv.write('1, %s, %f' % (msg_num, time_send)) csv.write('\n') # send to mpi3 time_send = time.time()
def main(self): # Initializations and preliminaries comm = MPI.COMM_WORLD # get MPI communicator object size = comm.size # total number of processes rank = comm.rank # rank of this process status = MPI.Status() # get MPI status object comm.Barrier() start_time = time.time() # Master process executes code below if rank == 0: num_workers = size - 1 closed_workers = 0 space = [self.spaceDict[key] for key in self.params] print("space: ", space) eval_counter = 0 parDict = {} evalDict = {} resultsList = [] parDict['kappa']=self.kappa init_x = [] delta = 0.05 #patience = max(100, 3 * num_workers-1) patience = len(self.params) * self.patience_fac last_imp = 0 curr_best = math.inf if self.base_estimator =='NND': opt = Optimizer(space, base_estimator=NeuralNetworksDropoutRegressor(), acq_optimizer='sampling', acq_func = self.acq_func, acq_func_kwargs=parDict, random_state=seed) else: opt = Optimizer(space, base_estimator=self.base_estimator, acq_optimizer=self.acq_optimizer, acq_func=self.acq_func, acq_func_kwargs=parDict, random_state=seed, n_initial_points=self.n_initial_points) print('Master starting with {} workers'.format(num_workers)) while closed_workers < num_workers: data = comm.recv(source=MPI.ANY_SOURCE, tag=MPI.ANY_TAG, status=status) source = status.Get_source() tag = status.Get_tag() elapsed_time = float(time.time() - start_time) print('elapsed_time:%1.3f'%elapsed_time) if tag == tags.READY: if last_imp < patience and eval_counter < self.max_evals and elapsed_time < self.max_time: if self.starting_point is not None: x = self.starting_point if num_workers-1 > 0: init_x = opt.ask(n_points=num_workers-1) self.starting_point = None else: if len(init_x) > 0: x = init_x.pop(0) else: x = opt.ask(n_points=1, strategy='cl_min')[0] key = str(x) print('sample %s' % key) if key in evalDict.keys(): print('%s already evalauted' % key) evalDict[key] = None task = {} task['x'] = x task['eval_counter'] = eval_counter task['rank_master'] = rank #task['start_time'] = elapsed_time print('Sending task {} to worker {}'.format (eval_counter, source)) comm.send(task, dest=source, tag=tags.START) eval_counter = eval_counter + 1 else: comm.send(None, dest=source, tag=tags.EXIT) elif tag == tags.DONE: result = data result['end_time'] = elapsed_time print('Got data from worker {}'.format(source)) resultsList.append(result) x = result['x'] y = result['cost'] opt.tell(x, y) percent_improv = -100*((y+0.1) - (curr_best+0.1))/(curr_best+0.1) if y < curr_best: if percent_improv >= delta or curr_best==math.inf: curr_best = y last_imp = 0 else: last_imp = last_imp+1 print('curr_best={} percent_improv={} patience={}/{}'.format(curr_best, percent_improv, last_imp, patience)) elif tag == tags.EXIT: print('Worker {} exited.'.format(source)) closed_workers = closed_workers + 1 resultsList = data print('Search finished..') #resultsList = comm.recv(source=MPI.ANY_SOURCE, tag=MPI.ANY_TAG, status=status) #comm.recv(source=MPI.ANY_SOURCE, tag=tags.EXIT) #print(resultsList) saveResults(resultsList, self.results_json_fname, self.results_csv_fname) y_best = np.min(opt.yi) best_index = np.where(opt.yi==y_best)[0][0] x_best = opt.Xi[best_index] print('Best: x = {}; y={}'.format(y_best, x_best)) else: # Worker processes execute code below name = MPI.Get_processor_name() print("worker with rank %d on %s." % (rank, name)) resultsList = [] while True: comm.send(None, dest=0, tag=tags.READY) task = comm.recv(source=0, tag=MPI.ANY_TAG, status=status) tag = status.Get_tag() if tag == tags.START: result = self.evaluate(self.problem, task, self.jobs_dir, self.results_dir) elapsed_time = float(time.time() - start_time) result['elapsed_time'] = elapsed_time print(result) resultsList.append(result) comm.send(result, dest=0, tag=tags.DONE) elif tag == tags.EXIT: print(f'Exit rank={comm.rank}') break comm.send(resultsList, dest=0, tag=tags.EXIT)
from mpi4py import MPI import libyt hwmess = 'Hello, World! I am process %d of %d on %s.' myrank = MPI.COMM_WORLD.Get_rank() nprocs = MPI.COMM_WORLD.Get_size() procnm = MPI.Get_processor_name() print(hwmess % (myrank, nprocs, procnm)) # print ("----------------------") # print ("prop1 exist = %s" % ("prop1" in dir(libyt.libytSub))) # print ("prop2 exist = %s" % ("prop2" in dir(libyt))) # print ("prop3 exist = %s" % ("prop3" in dir(libyt))) # print ("----------------------") # print ("before yt_set_parameter(), libyt.prop1 = ", libyt.prop1) def yt_inline(): print(dir(libyt)) # print (libyt.dict.prop1) print("======================") a = libyt.fputs("Write to file : Here I am.", "write.txt") print("======================") print(libyt.prop1) # print (libyt.FPUTS_FLAG) # print ("======================") # print ("myrank = ", myrank) # print ("after yt_set_parameter, libyt.prop1 = ", libyt.prop1) # print ("libyt.prop3 = ", libyt.prop3)
#PartitionNum = 20 DataPath = '/home/mapred/GraphData/uk/subdata/' VertexNum = 787803000 PartitionNum = 3000 #DataPath = '/home/mapred/GraphData/twitter/subdata/' #VertexNum = 41652250 #PartitionNum = 50 GraphInfo = (DataPath, VertexNum, PartitionNum, VertexNum / PartitionNum) test_graph = satgraph() rank_0_host = None if MPI.COMM_WORLD.Get_rank() == 0: rank_0_host = MPI.Get_processor_name() rank_0_host = MPI.COMM_WORLD.bcast(rank_0_host, root=0) test_graph.set_Dtype_All(Dtype_All) test_graph.set_GraphInfo(GraphInfo) test_graph.set_IP(rank_0_host) test_graph.set_port(18086) #test_graph.set_ThreadNum(1) test_graph.set_ThreadNum(4) test_graph.set_MaxIteration(50) test_graph.set_StaleNum(0) test_graph.set_FilterThreshold(0.000000001) test_graph.set_CalcFunc(calc_pagerank) test_graph.run('pagerank') os._exit(0)
if __name__ == '__main__': if len(sys.argv) != 6: sys.exit( 'ERROR:\tPlease provide the path of the project directory.\nUSAGE:\t%s PROJECT_DIR CLIP_PREPROCESS? OUT_DIR_NAME OVERWRITE? PARALLEL?\n' % sys.argv[0]) clip = bool(int(sys.argv[2])) outdir = sys.argv[3] overwrite = bool(int(sys.argv[4])) parallel = bool(int(sys.argv[5])) if parallel: from mpi4py import MPI size = MPI.COMM_WORLD.Get_size() # Size of communicator rank = MPI.COMM_WORLD.Get_rank() # Ranks in communicator name = MPI.Get_processor_name() # Node where this MPI process runs WORKDIR = os.path.abspath(sys.argv[1]) sys.stdout.write('Project directory: %s\n' % WORKDIR) SRC = os.path.join(WORKDIR, 'src') DATA = os.path.join(WORKDIR, 'data') RESULTS = os.path.join(WORKDIR, 'results') TRAIN = os.path.join(DATA, 'datapack2.0train/Public') TEST = os.path.join(DATA, 'datapack2.0test/Public') image_catalog = pd.read_csv(os.path.join( DATA, 'catalog/image_catalog2.0train.csv'), comment='#', index_col=0) image_catalog['is_lens'] = (image_catalog['mag_lens'] > 1.2) & (image_catalog['n_sources'] != 0) #image_catalog[['ID', 'is_lens']].to_csv(os.path.join(RESULTS, 'lens_id_labels.csv'), index=False) train_outpath = os.path.join(DATA, 'train_%s' % outdir)
#print(line) if line[0] == '>': continue for i in line: #print(i) if i == 't': resultLine += 'a' elif i == 'a': resultLine += 'u' elif i == 'c': resultLine += 'g' elif i == 'g': resultLine += 'c' else: resultLine += i resultLine += '\n' resultado.write(resultLine) f.close() resultado.close() start = datetime.now() sys.stdout.flush() main() end = datetime.now() total = end - start tiempo_total = total.seconds print("Procesador: " + MPI.Get_processor_name() + ', Timpo de ejecución:' + str(tiempo_total) + "s") sys.stdout.flush()
""" 6. Itaration over EQ, ST, Comp and frequency ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~""" L = [] #for worker in range(size): # # if worker==me : for EQstCompFreq in LEqStCompFreq_split: # # 6.0 take case feature EQ, station component and frequency EQname, Station, Year, jJul, Hour, Secondp, Seconds, Ml, Depth, Rdistance, Lat, Long, Az, BAz, Component, number, freqband = EQstCompFreq if Year <> f[EQname].attrs['Year'] or Hour <> f[EQname].attrs[ 'Hour'] or jJul <> f[EQname].attrs['JJul']: print 'ERROR PROBLEM OF EQ FEATURES', 'Je suis le worker {} et je traite le seisme {}, et la composante {} pour la frequence max {}'.format( me, EQname, Component, freqband[1]) print 'I am the worker {} on the node {} delealing with Eq {} component {} and freq {}'.format( me, MPI.Get_processor_name(), EQname, Component, freqband[1]) ## 6.1 read file ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~(~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ if not os.path.exists( '/home/burtin/DATA/LinTianShan/Seismic_Data/20%s/R%s.02/GSW0%s.%s.%s.%s.00.00.BHN.SAC' % (Year, jJul, Station, Year, jJul, str(Hour))): print 'file not existing Year :', Year, 'Julian day : ', jJul, 'Hour : ', Hour f[EQname]['St{}'.format(Station)]['Exist_{}'.format( Component)][0] = False continue st = Read_event(Year, jJul, Hour, Secondp, Station, False) #if the begining of the signal is too close to 00min then the wave peaking won't be accurate thus it's necessary to merge the signal whith the previous one! if Secondp < 100: if int(Hour) - 1 >= 0: st = st + Read_event(Year, jJul, str(int(Hour) - 1), Secondp, Station, False)
from mpi4py import MPI import sys sys.path.insert(0, '//home/csunix/sc16ho/dev/miind/build/libs/PythonWrapper') import libmiindpw comm = MPI.COMM_WORLD print "MASTER RANK: " + str(comm.Get_rank()) print MPI.Get_processor_name() wrapped = libmiindpw.Wrapped() wrapped.init() wrapped.startSimulation() x = [0.0 for a in range(76)] while (1): x = wrapped.evolveSingleStep(x)