main() { char *me = "inheritb"; int context_original, context_1, context_2; int ptid, tid, gptid, cc; char buf[100]; char machine[25]; int i=0; gethostname( machine, 25 ); printf( "%d:%s: t%x on machine <%s> with context %d.\n", i++, me, pvm_mytid(), machine, pvm_getcontext() ); context_original = pvm_getcontext(); /* retrieve initial context */ context_1 = pvm_newcontext(); /* get new context 1 */ pvm_setcontext( context_1 ); /* activate new context 1 */ printf( "%d:%s: t%x on machine <%s> with new #1 context %d ", i++, me, pvm_mytid(), machine, pvm_getcontext() ); printf( "--> spawn 1st inherit2.\n" ); /* start 1st inherit2 worker @ context 1 */ pvm_spawn( "inherit2", (char **) 0, PvmTaskDefault, "", 1, &tid ); context_2 = pvm_newcontext(); /* get new context 2 */ pvm_setcontext(context_2); /* activate new context 2 */ printf( "%d:%s: t%x on machine <%s> with new #2 context %d ", i++, me, pvm_mytid(), machine, pvm_getcontext() ); printf( "--> spawn 2nd inherit2.\n" ); /* start 2nd inherit2 worker @ context 2 */ pvm_spawn( "inherit2", (char **) 0, PvmTaskDefault, "", 1, &tid ); /* receive from inherit2 worker 2 @ context 2 */ cc = pvm_recv( -1, -1 ); pvm_bufinfo( cc, (int *) 0, (int *) 0, &tid ); pvm_upkstr( buf ); printf( "%d:%s: t%x %s <-- received from 2nd inherit2.\n", i++, me, tid, buf); /* reactivate initial context 1*/ pvm_setcontext(context_1); printf( "%d:%s: t%x on machine <%s> with new #1 context %d.\n", i++, me, pvm_mytid(), machine, pvm_getcontext() ); /* receive from inherit2 worker 1 @ context 1 */ cc = pvm_recv( -1, -1 ); pvm_bufinfo( cc, (int *) 0, (int *) 0, &tid ); pvm_upkstr( buf ); printf( "%d:%s: t%x %s <-- received from 1st inherit2.\n", i++, me, tid, buf ); pvm_exit(); exit( 0 ); }
int main(int argc, char **argv) { int nproc, status; int tids[SLAVENUM], ok, mytid; nproc = pvm_spawn("sort_slave",0,PvmTaskDefault, "LINUX64",SLAVENUM, tids); printf("Master id %d\n", nproc ); //app for sorting do { status = 0; //if 0 - all done //if 1 - continue for(int i = 0; i < SLAVENUM; i++) { int slave_status ; pvm_recv (-1 , TAG_SLAVE); pvm_upkint(&slave_status, 1, 1); if (slave_status == 0) { status = 1; } } for (int i = 0; i < SLAVENUM; ++i) { pvm_initsend( PvmDataRaw ); pvm_pkint(&status, 1, 1); pvm_send( tids[i], TAG_MASTER ); } } while(status == 1); printf("Master end!"); pvm_exit(); }
int main(int argc, char* argv[]) { setbuf(stdout, NULL); double x; srand(time(NULL)); if (argc == 2) x = atof(argv[1]); else x = ((double)rand() / (RAND_MAX)); printf("[p(x)]:Hello! I'm p(x). I check condition if x < 0.5\n") ; printf("[p(x)]:x = %lf\n", x); char name[8]; if (x < 0.5) strcpy(name, "f1x"); else strcpy(name, "f2x"); char* args[2]; char buf[32]; sprintf(buf, "%lf", x); args[0] = buf; args[1] = '\0'; int tid; printf("[p(x)]: spawning %s\n", name); int code = pvm_spawn(name, args, 0, "", 1, &tid); //printf("[p(x)]: pvm_spawn returns code %d\n", code); return 0; }
int main(int argc, char **argv){ NodoBusqueda nodo_problema; int mintareas=4, cantidad_tareas, numt, *tids=NULL,i; GList *tareas, *tarptr; NodoBusqueda solucion; int problema[_SUDOK_FILAS][_SUDOK_COLUMNAS] = { {1,0,0,0,0,7,0,9,0}, {0,3,0,0,2,0,0,0,8}, {0,0,9,6,0,0,5,0,0}, {0,0,5,3,0,0,9,0,0}, {0,1,0,0,8,0,0,0,2}, {6,0,0,0,0,4,0,0,0}, {3,0,0,0,0,0,0,1,0}, {0,4,0,0,0,0,0,0,7}, {0,0,7,0,0,0,3,0,0} }; inicializarMatrizAdyacencia(); nodo_problema= nodoInicial(problema); tareas=generarTareas(nodo_problema,mintareas); cantidad_tareas = g_list_length(tareas); tids=malloc(sizeof(int)*cantidad_tareas); numt=pvm_spawn("sudokuterm",NULL,0,"",cantidad_tareas,tids); if(numt<cantidad_tareas){ fprintf(stderr, "ERROR. sudokuhub: no se pudo hacer spawn de todas las tareas"); exit(1); } //iteramos sobre las tareas y les pasamos los datos tarptr=g_list_first(tareas); for(i=0;i<cantidad_tareas;i++){ pvm_initsend(PvmDataDefault); pvm_pkNodoBusqueda((NodoBusqueda*)(tarptr->data)); pvm_send(tids[i],_TIPOMSG_NODOBUSQUEDA); tarptr=tarptr->next; } //esperamos las respuestas y velamos por una solucion for(i=0;i<cantidad_tareas;i++){ int exitofracaso,j; pvm_recv(tids[i],_TIPOMSG_EXITOFRACASO); pvm_upkint(&exitofracaso,1,1); if(exitofracaso==1){ pvm_recv(tids[i],_TIPOMSG_NODOBUSQUEDA); pvm_upkNodoBusqueda(&solucion); printf("\nSE ENCONTRO UNA SOLUCION\n"); printNodoBusqueda(&solucion); for(j=0;j<cantidad_tareas;j++) pvm_kill(tids[j]); pvm_exit(); exit(0); } } printf("\nNO SE ENCONTRO NINGUNA SOLUCION\n"); return 0; }
void pvm_init(int argc, char *argv[]) { int mytid, mygid, ctid[MAXPROC]; int np, i; mytid = pvm_mytid(); if((argc != 2) && (argc != 1)) goto usage; if(argc == 1) np = 1; if(argc == 2) if((np = atoi(argv[1])) < 1) goto usage; if(np > MAXPROC) goto usage; mygid = pvm_joingroup(MPGROUP); if(np > 1) if (mygid == 0) i = pvm_spawn(argv[0], argv+1, 0, "", np-1, ctid); while(pvm_gsize(MPGROUP) < np) sleep(1); /* sync */ pvm_barrier(MPGROUP, np); printf("PVM initialization done!\n"); return; usage: fprintf(stderr, "usage: %s <nproc>\n", argv[0]); pvm_exit(); exit(-1); }
void pvmfspawn (WatcomFortranStr *aout_str, int *flag, WatcomFortranStr *where_str, int *count, int *tids, int *info) { char* aout_ptr = aout_str->strP; int aout_len = aout_str->len; char* where_ptr = where_str->strP; int where_len = where_str->len; #else void __stdcall PVMFSPAWN (char *aout_ptr,int aout_len, int *flag, char *where_ptr,int where_len, int *count, int *tids, int *info) { #endif char taout[MAX_PROC_NAME + 1]; char twhere[MAX_HOST_NAME + 1]; /* * Copy the program and where names to make sure there's * a NUL at the end. */ if (ftocstr(taout, sizeof(taout), aout_ptr, aout_len)) { *info = PvmBadParam; return; } /* * if the where parameter is '*', pass a NULL pointer to * initiate which will allow execution on any machine. */ if (*(where_ptr) == '*') { *info = pvm_spawn(taout, (char**)0, *flag, "", *count, tids); } else { if (ftocstr(twhere, sizeof(twhere), where_ptr, where_len)) { *info = PvmBadParam; return; } *info = pvm_spawn(taout, (char**)0, *flag, twhere, *count, tids); } }
/* Create the PE Tasks. We spawn (nPEs-1) pvm threads: the Main Thread (which starts execution and performs IO) is created by forking SysMan */ static int createPEs(int total_nPEs) { int i, spawn_nPEs, iSpawn = 0, nArch, nHost; struct pvmhostinfo *hostp; int sysman_host; spawn_nPEs = total_nPEs-1; if (spawn_nPEs > 0) { IF_PAR_DEBUG(verbose, fprintf(stderr, "==== [%x] Spawning %d PEs(%s) ...\n", sysman_id, spawn_nPEs, petask); fprintf(stderr, " args: "); for (i = 0; pargv[i]; ++i) fprintf(stderr, "%s, ", pargv[i]); fprintf(stderr, "\n")); pvm_config(&nHost,&nArch,&hostp); sysman_host=pvm_tidtohost(sysman_id); /* create PEs on the specific machines in the specified order! */ for (i=0; (iSpawn<spawn_nPEs) && (i<nHost); i++) if (hostp[i].hi_tid != sysman_host) { checkComms(pvm_spawn(petask, pargv, spawn_flag+PvmTaskHost, hostp[i].hi_name, 1, gtids+iSpawn), "SysMan startup"); IF_PAR_DEBUG(verbose, fprintf(stderr, "==== [%x] Spawned PE %d onto %s\n", sysman_id, i, hostp[i].hi_name)); iSpawn++; } /* create additional PEs anywhere you like */ if (iSpawn<spawn_nPEs) { checkComms(pvm_spawn(petask, pargv, spawn_flag, "", spawn_nPEs-iSpawn, gtids+iSpawn), "SysMan startup"); IF_PAR_DEBUG(verbose, fprintf(stderr,"==== [%x] Spawned %d additional PEs anywhere\n", sysman_id, spawn_nPEs-iSpawn)); } }
int CreateSlaves(int *SeisSlaves, char *SlaveName, int pn) { int info; info = pvm_spawn(SlaveName, (char **)0, 0, (char *)0, pn, SeisSlaves); if (info != pn) { fprintf(stderr, "Error starting pvm applications %s \n", SlaveName); return(-1); } return(pn); } /* End of CreateSlaves */
int spawn(char *task, char **argv, int flag, char *where, int ntask, int *tids) { int status; if ((status = pvm_spawn(task, argv, flag, where, ntask, tids)) != ntask){ printf("Couldn't start %s!! \n", task); PVM_ERROR(*tids); exit(0); } return(status); }
main() { int cc, tid; char buf[100]; printf("i'm t%x\n", pvm_mytid()); cc = pvm_spawn("hello_other", (char**)0, 0, "", 1, &tid); if (cc == 1) { cc = pvm_recv(-1, -1); pvm_bufinfo(cc, (int*)0, (int*)0, &tid); pvm_upkstr(buf); printf("from t%x: %s\n", tid, buf); } else printf("can't start hello_other\n"); pvm_exit(); exit(0); }
// Set up the PVM stuff. Register this task then set up all of the slaves. // Return 1 if a problem, 0 if everything went ok. int StartupPVM(const char* prog, PVMData& d) { int i; d.masterid = pvm_mytid(); int nhost, narch; struct pvmhostinfo* hostp; int status = pvm_config(&nhost, &narch, &hostp); if(status == PvmSysErr) { cerr<<"\n" << prog << ": PVM not responding. Have you started the PVM?\n"; return 1; } d.tid = new int [d.nreq]; // task IDs for the slaves d.ntasks = pvm_spawn(SLAVE_NAME, (char**)0, 0, "", d.nreq, d.tid); if(d.ntasks <= 0) { cerr << prog << ": Error spawning slaves.\n"; cerr << " Error codes of failed spawns are:\n"; for(i=0; i<d.nreq; i++) { cerr << " slave "; cerr.width(3); cerr << i << ": " << d.tid[i] << "\n"; } pvm_exit(); return 1; } else if(d.ntasks < d.nreq) { cerr << prog << ": Spawned only "<<d.ntasks<<" of "<<d.nreq<<"\n"; cerr << " Error codes of failed spawns are:\n"; for(i=0; i<d.nreq; i++) { cerr << " slave "; cerr.width(3); cerr << i << ": " << d.tid[i] << "\n"; } } else { cerr << prog << ": Spawned " << d.nreq << " slave processes...\n"; } return 0; }
int main(int argc, char *argv[]){ int mytid, tids[MAXNODES]; int numt, n, nproc, msgtype; double val, work, result; double xs[10000]; double ys[10000][10000]; for(int i=0; i<10000; i++){ xs[i] = rand(); for(int j=0; i<10000; j++){ ys[i][j] = rand(); } } mytid = pvm_mytid(); nproc=4; numt = pvm_spawn(CLIENTNAME, NULL, PvmTaskDefault, NULL, nproc, tids); if (numt != nproc){ fprintf(stderr, "numt = %d, nproc = %d\n", numt, nproc); fprintf(stderr, "error: pvm_spawn()\n"); pvm_exit(); exit(1); } msgtype=11; for(n=0; n<nproc; n++){ pvm_initsend(PvmDataDefault); pvm_pkint(&n, 1, 1); pvm_pkdouble(&xs, 10000, 1); pvm_pkdouble(&ys, 10000, 1); pvm_send(tids[n], msgtype); } msgtype=22; result=0.0; for(n=0; n<nproc; n++){ pvm_recv(-1, msgtype); pvm_upkdouble(&work, 1, 1); result += work; } printf("Result = %25.15lf\n", result); return 0; }
value Pvm_spawn_native(value task, value argv, value flag, value host, value ntasks, value tids) { char **cargv; unsigned i; int numt; unsigned cntasks = Int_val(ntasks); int *ctids; char *chost; cargv = malloc((Wosize_val(argv)+1)*sizeof(char*)); ctids = malloc(cntasks*sizeof(int)); for(i = 0; i < Wosize_val(argv); i++) cargv[i] = String_val(Field(argv, i)); cargv[Wosize_val(argv)] = NULL; chost = (string_length(host) == 0 ? NULL : String_val(host)); numt = pvm_spawn(String_val(task), cargv, Int_val(flag),chost,cntasks,ctids); if (numt<0) {free(cargv); free(ctids);TreatError(numt);} for(i = 0; i < cntasks; i++) modify(&Field(tids, i), Val_int(ctids[i])); free(cargv); free(ctids); return Val_int(numt); }
void pvmica(doublereal *data, doublereal *weights, doublereal *sphere, doublereal *eigv, integer chans, integer ncomps, integer frames, integer epochs, int *window, doublereal *bias, integer *signs, char **fnames) { struct pvmhostinfo *hinfo; int i, j, datasize, maxep, maxfr, segs, speed, spwnd = 0, id = 0; int *tids, tid, nhost, narch, nproc = 0, ntask = 0, last = 0; char *name; FILE *fids[3]; integer **srec; doublereal **wrec, **brec, *basedata, *windata, *prjdata, deflr = lrate; tresult result; tassign assign; /* pvm_catchout(stdout);*/ pvm_config(&nhost,&narch,&hinfo); for (i=0 ; i<nhost ; i++) nproc += speed2proc(hinfo[i].hi_speed); basedata = (doublereal*)malloc(ncomps*epochs*window[BASELINE]*sizeof(doublereal)); baseline(data,basedata,ncomps,frames,epochs,window); runica(basedata,weights,ncomps,1,window[BASELINE]*epochs,bias,signs); free(basedata); assign.weights = weights; assign.chans = ncomps; assign.frames = window[FRAMEWINDOW]; assign.epochs = window[EPOCHWINDOW]; assign.bias = (int)(bias!=NULL); assign.signs = (int)(signs!=NULL); assign.extended = extended; assign.extblocks = extblocks; assign.pdfsize = pdfsize; assign.nsub = nsub; assign.verbose = verbose; assign.block = block; assign.maxsteps = maxsteps; assign.lrate = deflr; assign.annealstep = annealstep; assign.annealdeg = annealdeg; assign.nochange = nochange; assign.momentum = momentum; datasize = window[FRAMEWINDOW] * window[EPOCHWINDOW] * ncomps; windata = (doublereal*)malloc(datasize*sizeof(doublereal)); prjdata = (doublereal*)malloc(datasize*sizeof(doublereal)); maxep = (epochs-window[EPOCHWINDOW])/window[EPOCHSTEP] + 1; maxfr = (frames-window[FRAMEWINDOW])/window[FRAMESTEP] + 1; segs = maxep*maxfr; if (segs > nproc) { tids = (int*)malloc(nproc*sizeof(int)); for (i=0 ; i<nhost ; i++) { name = hinfo[i].hi_name; speed = hinfo[i].hi_speed; spwnd = pvm_spawn(SPAWN_ICA,NULL,1,name,speed2proc(speed),&tids[ntask]); if (spwnd <= 0) error("Failed to spawn processes"); ntask += spwnd; } } else { tids = (int*)malloc(segs*sizeof(int)); spwnd += pvm_spawn(SPAWN_ICA,NULL,0,"",segs,tids); if (spwnd <= 0) error("Failed to spawn processes"); ntask += spwnd; } for (i=0,j=0 ; i<ntask ; i++,j+=2,id++) { if (j >= ntask) j=1; assign.id = id; assign.data = extract(data,windata,(int)ncomps,(int)frames,(int)epochs,(int)id,window); send_assign(tids[j],&assign); } wrec = (doublereal**)malloc(segs*sizeof(doublereal*)); brec = (doublereal**)malloc(segs*sizeof(doublereal*)); srec = (integer**)malloc(segs*sizeof(integer*)); for (i=0 ; i<segs ; i++) { wrec[i] = NULL; brec[i] = NULL; srec[i] = NULL; } for (i=0 ; i<3 ; i++) fids[i] = NULL; if (fnames[0] != NULL) fids[0] = fopen(fnames[0],"wb"); if (fnames[1] != NULL) fids[1] = fopen(fnames[1],"wb"); if (fnames[2] != NULL) fids[2] = fopen(fnames[2],"wt"); for (i=0 ; i<segs ; i++) { tid = receive_result(&result); printf("Received id %d\n",result.id); wrec[result.id] = result.weights; brec[result.id] = result.bias; srec[result.id] = result.signs; if (ntask < segs) { assign.id = id; assign.data = extract(data,windata,(int)ncomps,(int)frames,(int)epochs,(int)id,window); send_assign(tid,&assign); ntask++; id++; } else { send_kill(tid); } datasize = window[FRAMEWINDOW] * window[EPOCHWINDOW]; extract(data,windata,(int)ncomps,(int)frames,(int)epochs,(int)result.id,window); geproj(windata,result.weights,(integer)ncomps,(integer)datasize,prjdata); if (eigv) varsort(prjdata,result.weights,sphere,&eigv[chans*(chans-ncomps)],result.bias,result.signs,(integer)ncomps,(integer)datasize,(integer)chans); else varsort(prjdata,result.weights,sphere,NULL,result.bias,result.signs,(integer)ncomps,(integer)datasize,(integer)chans); while (last<segs && wrec[last]!=NULL) { if (fids[0]!=NULL && wrec[last]!=NULL) fbc_matwrite(fids[0],chans*ncomps,wrec[last]); if (fids[1]!=NULL && brec[last]!=NULL) fbc_matwrite(fids[1],ncomps,brec[last]); if (fids[2]!=NULL && srec[last]!=NULL) iac_matwrite(fids[2],ncomps,srec[last]); if (wrec[last] != NULL) free(wrec[last]); if (brec[last] != NULL) free(brec[last]); if (srec[last] != NULL) free(srec[last]); last++; } } for (i=0 ; i<3 ; i++) if (fids[i] != NULL) fclose(fids[i]); if (wrec != NULL) free(wrec); if (brec != NULL) free(brec); if (srec != NULL) free(srec); if (windata != NULL) free(windata); if (prjdata != NULL) free(prjdata); if (tids != NULL) free(tids); }
int main(int argc, char ** argv){ TAILQ_INIT(&head); int nproc, numt, i, nhost, narch; int num_tasks = 0; struct pvmhostinfo *hostp; struct stat s; FILE * codefile = fopen("./codes", "w"); if(argc != 2){ exit_prog("USAGE: ./taskgen directory\n",1); } else { stat(argv[1], &s); if(s.st_mode & S_IFDIR){ char path[PATH_MAX+1]; realpath(argv[1],path); printf("Loading graphs from %s...", path); fflush(stdout); load_graph_dir(path, &num_tasks); printf("done. Found %d tasks.\n", num_tasks); } else{ printf("%s is not a directory. Please check arguments.\n", argv[1]); exit_prog(NULL, 1); } } pvm_config(&nhost, &narch, &hostp); /*Set number of slaves to start */ nproc = nhost * 3; /*3 processes per host */ printf("Spawning %d worker tasks on %d machines...", nproc, nhost); int tids[nproc]; /*hold the task ids of the workers */ int flags = PvmTaskDefault; // flags += PvmTaskDebug; numt =pvm_spawn("worker", (char**)0, flags, "", nproc, tids); /*start up the workers */ if(numt < nproc){ /*Error Checking */ printf("\n Trouble spawing slaves. Error codes are:\n"); for(i = numt; i < nproc; i++){ printf("TID %d: %d\n", i, tids[i]); } for(i = 0; i < numt; i++){ pvm_kill(tids[i]); } exit_prog("Failure.\n",1); } printf("done. Connected.\n"); /* Main loop */ int bufid, bytes, msgtype, source; int sent_tasks, comp_tasks, found_codes = 0; int finished = 0; int percent_comp = 0; char * buf; while(!finished){ bufid = pvm_recv(-1, -1); /*Accept any message from any task BLOCKING CALL*/ pvm_bufinfo(bufid, &bytes, &msgtype, &source); switch(msgtype){ case MSGREQTASK: if(!TAILQ_EMPTY(&head)){ send_task(source); /*send out the message */ sent_tasks++; } break; case MSGCODE: buf = malloc(bytes); pvm_upkstr(buf); fprintf(codefile, "%s\n", buf); fflush(codefile); comp_tasks++; found_codes++; break; case MSGNOCODE: comp_tasks++; break; default: printf("Incorrect MSGTYPE received from task %d. Received: %d\n", source, msgtype); break; } if(((float)comp_tasks/num_tasks * 100) > percent_comp + 1){ printf("Tasks Complete: %d Tasks Sent: %d Percent Complete: %.2f\n", comp_tasks, sent_tasks, (float)comp_tasks/num_tasks * 100); percent_comp = (float)comp_tasks/num_tasks * 100; } if(comp_tasks == num_tasks){ finished = 1; } } printf("All tasks complete.\n"); exit_prog(NULL, 0); return 0; }
int main (int argc, char **argv) { int nt; /* number of time samples */ int nz; /* number of migrated depth samples */ int nx,nxshot; /* number of midpoints,shotgathers, the folds in a shot gather */ int flag=1; /*flag to use ft or meter as the unit*/ int dip=65; /*maximum dip angle to migrate*/ int iz,iw,ix,it,oldsx; /* loop counters*/ int ntfft; /* fft size*/ int nw; /* number of wave numbers */ int mytid,tids[NNTASKS],msgtype,rc,i;/*variable for PVM function*/ int nw1,task; int lpad=9999,rpad=9999; /*zero-traces padded on left and right sides*/ float f1,f2,f3,f4; /*frequencies to build the Hamming window*/ int nf1,nf2,nf3,nf4; /*the index for above frequencies*/ int NTASKS=0; /*number of slave tasks to start*/ char cpu_name[NNTASKS][80]; /*strings to store the computers' name*/ int flag_cpu=0; /*flag to control if using NTASKS variable*/ float sx,gxmin,gxmax; /*location of geophone and receivers*/ int isx,nxo,ifx=0; /*index for geophone and receivers*/ int ix1,ix2,ix3,il,ir; /*dummy index*/ float *wl,*wtmp; /*pointers for the souce function*/ float Fmax=25; /*peak frequency to make the Ricker wavelet*/ int ntw,truenw; /*number of frequencies to be migrated*/ float dt=0.004,dz; /*time, depth sampling interval*/ float ft; /*first time sample*/ float dw; /*frequency sampling interval*/ float fw; /*first frequency*/ float dx; /*spatial sampling interval*/ float **p,**cresult,**result_tmp; /* input, output data*/ float **v; /*double pointer direct to velocity structure*/ complex *wlsp,**cp,**cq,**cq1; /*pointers for internal usage*/ char *vfile=""; /* name of file containing velocities */ char *cpufile=""; /* name of file containing CPU name */ FILE *vfp,*cpu_fp; /* hook up getpar to handle the parameters */ initargs(argc,argv); requestdoc(1); /* get optional parameters */ if (!getparfloat("ft",&ft)) ft = 0.0; if (!getparint("nz",&nz)) err("nz must be specified"); if (!getparfloat("dz",&dz)) err("dz must be specified"); if (!getparstring("vfile", &vfile)) err("vfile must be specified"); if (!getparint("nxo",&nxo)) err("nxo must be specified"); if (!getparint("nxshot",&nxshot)) err("nshot must be specified"); if (!getparfloat("Fmax",&Fmax)) err("Fmax must be specified"); if (!getparfloat("f1",&f1)) f1 = 10.0; if (!getparfloat("f2",&f2)) f2 = 20.0; if (!getparfloat("f3",&f3)) f3 = 40.0; if (!getparfloat("f4",&f4)) f4 = 50.0; if (!getparint("lpad",&lpad)) lpad=9999; if (!getparint("rpad",&rpad)) rpad=9999; if (!getparint("flag",&flag)) flag=1; if (!getparint("dip",&dip)) dip=65; if (getparstring("cpufile", &cpufile)){ cpu_fp=fopen(cpufile,"r"); NTASKS=0; while(!feof(cpu_fp)){ fscanf(cpu_fp,"%s",cpu_name[NTASKS]); NTASKS++; } NTASKS-=1; flag_cpu=1; } else /*if cpufile not specified, the use NTASKS*/ if (!getparint("NTASKS",&NTASKS)) err("No CPUfile specified, NTASKS must be specified"); /*allocate space for the velocity profile*/ tshot=nxshot; v=alloc2float(nxo,nz); /*load velicoty file*/ vfp=efopen(vfile,"r"); efread(v[0],FSIZE,nz*nxo,vfp); efclose(vfp); /*PVM communication starts here*/ mytid=pvm_mytid(); /*get my pid*/ task=NTASKS; warn("\n %d",task); rc=0; /*spawn slave processes here*/ if(!flag_cpu){ rc=pvm_spawn(child,NULL,PvmTaskDefault,"",task,tids); } else{ for(i=0;i<NTASKS;i++){ rc+=pvm_spawn(child,NULL,PvmTaskHost,cpu_name[i],1,&tids[i]); } } /*show the pid of slaves if*/ for(i=0;i<NTASKS;i++){ if(tids[i]<0)warn("\n %d",tids[i]); else warn("\nt%x\t",tids[i]); } /*if not all the slaves start, then quit*/ if(rc<NTASKS){ warn("error");pvm_exit();exit(1);} /*broadcast the global parameters nxo,nz,dip to all slaves*/ pvm_initsend(PvmDataDefault); rc=pvm_pkint(&nxo,1,1); rc=pvm_pkint(&nz,1,1); rc=pvm_pkint(&dip,1,1); msgtype=PARA_MSGTYPE; task=NTASKS; rc=pvm_mcast(tids,task,msgtype); /*broadcast the velocity profile to all slaves*/ pvm_initsend(PvmDataDefault); rc=pvm_pkfloat(v[0],nxo*nz,1); msgtype=VEL_MSGTYPE; rc=pvm_mcast(tids,task,msgtype); /*free the space for velocity profile*/ free2float(v); /*loop over shot gathers begin here*/ loop: /* get info from first trace */ if (!gettr(&tr)) err("can't get first trace"); nt = tr.ns; /* let user give dt and/or dx from command line */ if (!getparfloat("dt", &dt)) { if (tr.dt) { /* is dt field set? */ dt = ((double) tr.dt)/1000000.0; } else { /* dt not set, assume 4 ms */ dt = 0.004; warn("tr.dt not set, assuming dt=0.004"); } } if (!getparfloat("dx",&dx)) { if (tr.d2) { /* is d2 field set? */ dx = tr.d2; } else { dx = 1.0; warn("tr.d2 not set, assuming d2=1.0"); } } sx=tr.sx; isx=sx/dx; gxmin=gxmax=tr.gx; oldsx=sx; /* determine frequency sampling interval*/ ntfft = npfar(nt); nw = ntfft/2+1; dw = 2.0*PI/(ntfft*dt); /*compute the index of the frequency to be migrated*/ fw=2.0*PI*f1; nf1=fw/dw+0.5; fw=2.0*PI*f2; nf2=fw/dw+0.5; fw=2.0*PI*f3; nf3=fw/dw+0.5; fw=2.0*PI*f4; nf4=fw/dw+0.5; /*the number of frequency to migrated*/ truenw=nf4-nf1+1; fw=0.0+nf1*dw; warn("nf1=%d nf2=%d nf3=%d nf4=%d nw=%d",nf1,nf2,nf3,nf4,truenw); fw=0.0; /* allocate space */ wl=alloc1float(ntfft); wlsp=alloc1complex(nw); /*generate the Ricker wavelet*/ wtmp=ricker(Fmax,dt,&ntw); for(it=0;it<ntfft;it++) wl[it]=0.0; for(it=0;it<ntw-12;it++) wl[it]=wtmp[it+12]; free1float( wtmp); /*Fourier transform the Ricker wavelet to frequency domain*/ pfarc(-1,ntfft,wl,wlsp); /* allocate space */ p = alloc2float(ntfft,nxo); cp = alloc2complex(nw,nxo); for (ix=0; ix<nxo; ix++) for (it=0; it<ntfft; it++) p[ix][it] = 0.0; /*read in a single shot gather*/ ix=tr.gx/dx; memcpy( (void *) p[ix], (const void *) tr.data,nt*FSIZE); nx = 0; while(gettr(&tr)){ int igx; if(tr.sx!=oldsx){ fseek(stdin,(long)(-240-nt*4),SEEK_CUR); break;} igx=tr.gx/dx; memcpy( (void *) p[igx], (const void *) tr.data,nt*FSIZE); if(gxmin>tr.gx)gxmin=tr.gx; if(gxmax<tr.gx)gxmax=tr.gx; nx++; oldsx=tr.sx; } warn("\nnx= %d",nx); warn("sx %f , gxmin %f gxmax %f",sx,gxmin,gxmax); /*transform the shot gather from time to frequency domain*/ pfa2rc(1,1,ntfft,nxo,p[0],cp[0]); /*compute the most left and right index for the migrated section*/ ix1=sx/dx; ix2=gxmin/dx; ix3=gxmax/dx; if(ix1>=ix3)ix3=ix1; if(ix1<=ix2)ix2=ix1; il=ix2; ir=ix3; ix2-=lpad; ix3+=rpad; if(ix2<0)ix2=0; if(ix3>nxo-1)ix3=nxo-1; /*the total traces to be migrated*/ nx=ix3-ix2+1; /*allocate space*/ cq = alloc2complex(nx,nw); cq1 = alloc2complex(nx,nw); /*transpose the frequency domain data from data[ix][iw] to data[iw][ix] and apply a Hamming at the same time*/ for (ix=0; ix<nx; ix++) for (iw=0; iw<nw; iw++){ float tmpp=0.0,tmppp=0.0; if(iw<nf1||iw>nf4) cq[iw][ix]=cmplx(0.0,0.0); else{ if(iw>=nf1&&iw<=nf2){tmpp=PI/(nf2-nf1);tmppp=tmpp*(iw-nf1)-PI;tmpp=0.54+0.46*cos(tmppp); cq[iw][ix]=crmul(cp[ix+ix2][iw],tmpp);} else{ if(iw>=nf3&&iw<=nf4){tmpp=PI/(nf4-nf3);tmppp=tmpp*(iw-nf3);tmpp=0.54+0.46*cos(tmppp); cq[iw][ix]=crmul(cp[ix+ix2][iw],tmpp);} else {cq[iw][ix]=cp[ix+ix2][iw];} } } cq[iw][ix]=cp[ix+ix2][iw]; cq1[iw][ix]=cmplx(0.0,0.0); } ix=sx/dx-ifx; warn("ix %d",ix); for(iw=0;iw<nw;iw++){ cq1[iw][ix-ix2]=wlsp[iw]; } free2float(p); free2complex(cp); free1float(wl); free1complex(wlsp); /*if the horizontal spacing interval is in feet, convert it to meter*/ if(!flag) dx*=0.3048; /*start of the timing function*/ time(&t1); /* send local parameters to all slaves*/ pvm_initsend(PvmDataDefault); ix=15; rc=pvm_pkint(&ix,1,1); rc=pvm_pkint(&ntfft,1,1); rc=pvm_pkint(&ix2,1,1); rc=pvm_pkint(&ix3,1,1); rc=pvm_pkint(&isx,1,1); rc=pvm_pkint(&il,1,1); rc=pvm_pkint(&ir,1,1); rc=pvm_pkfloat(&dx,1,1); rc=pvm_pkfloat(&dz,1,1); rc=pvm_pkfloat(&dw,1,1); rc=pvm_pkfloat(&dt,1,1); msgtype=PARA_MSGTYPE; task=NTASKS; rc=pvm_mcast(tids,task,msgtype); /* send all the frequency to slaves*/ count=NTASKS*5; /*count is the number of frequency components in a shot gather*/ nw=truenw; nw1=nw/(count); if(nw1==0)nw1=1; total=count=ceil(nw*1.0/nw1); /* if it is the first shot gather, send equal data to all the slaves, then for the following shot gathers, only send data when slave requests*/ if(nxshot==tshot){ for(i=0;i<NTASKS;i++){ float *tmpp; float fw1; int nww,byte,nwww; pvm_initsend(PvmDataDefault); nww=nf1+i*nw1;fw1=fw+nww*dw; nwww=nw1; byte=UnDone; rc=pvm_pkint(&byte,1,1); rc=pvm_pkfloat(&fw1,1,1); rc=pvm_pkint(&nwww,1,1); rc=pvm_pkfloat((float *)cq[nww],nx*nwww*2,1); rc=pvm_pkfloat((float *)cq1[nww],nx*nwww*2,1); msgtype=DATA_MSGTYPE; pvm_send(tids[i],msgtype); } count-=NTASKS; } while(count){ int tid0,bufid; float *tmpp; float fw1; int nww,byte,nwww; int i; i=total-count; msgtype=COM_MSGTYPE; bufid=pvm_recv(-1,msgtype); rc=pvm_upkint(&tid0,1,1); pvm_freebuf(bufid); pvm_initsend(PvmDataDefault); nww=nf1+i*nw1;fw1=fw+nww*dw; if(i==total-1)nwww=nw-nw1*i; else nwww=nw1; byte=UnDone; rc=pvm_pkint(&byte,1,1); rc=pvm_pkfloat(&fw1,1,1); rc=pvm_pkint(&nwww,1,1); rc=pvm_pkfloat((float *)cq[nww],nx*nwww*2,1); rc=pvm_pkfloat((float *)cq1[nww],nx*nwww*2,1); msgtype=DATA_MSGTYPE; pvm_send(tid0,msgtype); count--; } ix=Done; pvm_initsend(PvmDataDefault); rc=pvm_pkint(&ix,1,1); msgtype=DATA_MSGTYPE; pvm_mcast(tids,task,msgtype); free2complex(cq); free2complex(cq1); time(&t2); warn("\n %d shot been finished in %f seconds, Ntask=%d",nxshot,difftime(t2,t1),NTASKS); nxshot--; if(nxshot)goto loop; /*when all the shot gathers done, send signal to all slaves to request the partial imaging*/ ix=FinalDone; pvm_initsend(PvmDataDefault); rc=pvm_pkint(&ix,1,1); msgtype=PARA_MSGTYPE; pvm_mcast(tids,task,msgtype); /*allocate space for the final image*/ cresult = alloc2float(nz,nxo); for(ix=0;ix<nxo;ix++) for(iz=0;iz<nz;iz++) { cresult[ix][iz]=0.0; } result_tmp= alloc2float(nz,nxo); /*receive partial image from all the slaves*/ msgtype=RESULT_MSGTYPE; i=0; while(i<NTASKS){ int bufid; bufid=pvm_recv(-1,msgtype); rc=pvm_upkfloat(result_tmp[0],nxo*nz,1); pvm_freebuf(bufid); for(ix=0;ix<nxo;ix++) for(iz=0;iz<nz;iz++) { cresult[ix][iz]+=result_tmp[ix][iz]; } i=i+1; warn("\n i=%d been received",i); } /*send signal to all slaves to kill themselves*/ pvm_initsend(PvmDataDefault); pvm_mcast(tids,task,COM_MSGTYPE); /*output the final image*/ for(ix=0; ix<nxo; ix++){ tr.ns = nz ; tr.dt = dz*1000000.0 ; tr.d2 = dx; tr.offset = 0; tr.cdp = tr.tracl = ix; memcpy( (void *) tr.data, (const void *) cresult[ix],nz*FSIZE); puttr(&tr); } pvm_exit(); return EXIT_SUCCESS; }
int main(int argc, char **argv) { int tid; int parent; struct pvmhostinfo *hostp; int nhost, narch; tid = pvm_mytid(); if(tid < 0) pvm_ferror("pvm_mytid", 1); parent = pvm_parent(); if(parent == PvmNoParent || parent == PvmParentNotSet) { /* Processus pere */ int nchildren, children[MAXCHILDREN]; int i, j, res, rc; int bytes, tag, from_tid; /* Ask PVM for information about the virtual machine, and display it to the user. */ pvm_config(&nhost, &narch, &hostp); printf("I found the following %d hosts...\n",nhost); for (i = 0; i < nhost; i++) printf("%d. %s \t(%s)\n",i,hostp[i].hi_name,hostp[i].hi_arch); rc = pvm_spawn("pvm_mandel", NULL, PvmTaskDefault, NULL, NUMCHILDREN, children); if(rc < 0) pvm_ferror("pvm_spawn", 1); printf("%d enfants\n", rc); nchildren = 0; for(i = 0; i < NUMCHILDREN; i++) { printf("Enfant %d, tid = %d\n", i, children[i]); if(children[i] >= 0) nchildren++; if(nchildren < 1) pvm_ferror("Pas d'enfants", 0); } for(i = -MAXX; i <= MAXX; i++) { for(j = -MAXY; j <= MAXY; j++) { rc = pvm_recv(-1,-1); if (rc < 0) { printf("An error occurred when trying to receive a message.\n"); break; } /* Find out who this message is from, and how big it is. */ rc = pvm_bufinfo(rc,&bytes,&tag,&from_tid); /* printf("received message from %s of %d bytes, tag %d\n", get_host_by_tid(hostp,nhost,from_tid), bytes, tag); */ rc = pvm_upkint(&res, 1, 1); if(rc < 0) pvm_ferror("pvm_upkint", 1); cases[i + MAXX][j + MAXY] = res; } } dump_ppm("mandel.ppm", cases); printf("Fini.\n"); pvm_exit(); exit(0); } else if(parent >= 0) { /* On est l'un des fils */ double x, y; int i, j, res, rc; printf("Fils: %d\n", tid); for(i = -MAXX; i <= MAXX; i++) { for(j = -MAXY; j <= MAXY; j++) { x = 2 * i / (double)MAXX; y = 1.5 * j / (double)MAXY; res = mandel(x, y); rc = pvm_initsend(PvmDataDefault); if(rc < 0) pvm_ferror("pvm_initsend", 1); rc = pvm_pkint(&res, 1, 1); if(rc < 0) pvm_ferror("pvm_pkint", 1); rc = pvm_send(parent, 0); if(rc < 0) pvm_ferror("pvm_send", 1); } } printf("Fils %d termine.\n", tid); pvm_exit(); exit(0); } else pvm_ferror("pvm_parent", 1); assert(0); }
/* Rank sort paralelizado*/ int main (int argc, char *argv[]){ int tam, i, j, rank, id, tag=100, processos, retorno; int *numeros, *rankeados, *tids, *ranks; char *grupo = "grupo"; srand(time(NULL)); printf("Digite numero de processos a serem disparados:\n"); scanf("%d", &processos); printf("Digite o tamanho do vetor a ser ordenado:\n"); scanf("%d", &tam ); retorno=(tam/processos); numeros=(int *) malloc (tam*sizeof(int)); rankeados=(int*) malloc (tam*sizeof(int)); tids=(int*) malloc (processos*sizeof(int)); ranks=(int*)malloc ((tam)*sizeof(int)); if((!numeros)||(!rankeados)||(!tids)||(!ranks)) { printf("Erro na alocacao de memoria\n"); return 1; } printf("Vetor não ordenado:\n"); printf("Números: "); for(i=0;i<tam;i++) { numeros[i]=rand() % 1001; printf(" %d ", numeros[i] ); } printf("\n"); pvm_initsend(PvmDataDefault); pvm_cachout(stdout); id = pvm_joingroup(grupo); if(id==0) { if(pvm_spawn("tarefas", NULL, PvmTaskDefault, "", processos-1,tids)!=(processos-1)) { printf("Erro: Não foi possível disparar os processos\n"); return 2; } else { for(i=0;i<tam;i++) { pvm_barrier(grupo, NPROCS); pvm_scatter(ranks,numeros,(tam/processos),PVM_INT,tag,grupo,0); rank=0; if((numeros[i]<numeros[j]) || ((numeros[i]==numeros[j])&&(j<i))) { rank++; } // rankeados[rank]=numeros[i]; printf("rank:%d ", rank); } // pvm_barrier(grupo, NPROCS); } } /* for(i=0;i<tam;i++) { rank=0; for(j=0;j<tam;j++) { if((numeros[i]<numeros[j]) || ((numeros[i]==numeros[j])&&(j<i))) { rank++; } } rankeados[rank]=numeros[i]; printf("rank:%d ", rank); } */ printf("Vetor ordenado:\n"); printf("Números: "); for(i=0;i<tam;i++) { printf(" %d ", rankeados[i] ); } printf("\n"); free(numeros); free(rankeados); return 0; }
// Hook up to the pvm and spawn the slave processes. int PVMDemeGA::spawn(const char* slavename) { _mid = pvm_mytid(); if(_mid < 0) { cerr << "\n" << className() << ": spawn:\n"; cerr << " Bad ID for master task. Have you started the PVM?\n"; return _status = _mid; } struct pvmhostinfo* hostp; _status = pvm_config(&_nhosts, &_narch, &hostp); if(_status == PvmSysErr) { cerr << "\n" << className() << ": spawn:\n"; cerr << " PVM not responding. Have you started the PVM?\n"; return _status; } _Ntid = npop; _tid = new int [_Ntid]; // task IDs for the slaves char sn[32]; // PVM is not const-safe... strcpy(sn, slavename); _ntid = pvm_spawn(sn, (char**)0, 0, "", _Ntid, _tid); if(_ntid <= 0) { cerr << className() << ": spawn:\n Error spawning slaves.\n"; cerr << " Error codes of failed spawns are:\n"; for(int i=0; i<_Ntid; i++) { cerr << " slave "; cerr.width(3); cerr<<i<<": "<<_tid[i]<<"\n"; } pvm_exit(); return _status = -1; } else if(_ntid < _Ntid) { cerr << className() << ": spawn:\n "; cerr << " Spawned only "<<_ntid<<" of "<<_Ntid<<"\n"; cerr << " Error codes of failed spawns are:\n"; for(int i=0; i<_Ntid; i++) { if(_tid[i] < 0) { cerr << " slave "; cerr.width(3); cerr<<i<<": "<<_tid[i]<<"\n"; } } } else { cerr << className() << ": spawn:\n"; cerr << " Spawned " << _Ntid << " slave processes...\n"; } #ifdef DEBUG cerr << "waiting for response from slaves...\n"; #endif int flag = _ntid; while(flag > 0) { int bufid = pvm_recv(-1, -1); if(bufid >= 0) { int bytes, msgtag, tid; _status = pvm_bufinfo(bufid, &bytes, &msgtag, &tid); int which = tid2idx(tid); switch(msgtag) { case MSG_READY: #ifdef DEBUG cerr << " slave " << tid << " (" << which << ") is alive\n"; #endif flag--; break; default: cerr << className() << ": spawn:\n"; cerr << " unexpected msgtag: " << msgtag << "\n"; break; } } else { cerr << className() << ": spawn:\n"; cerr << " error from pvm_recv: " << bufid << "\n"; } } #ifdef DEBUG cerr << "slaves appear to be up and running.\n"; #endif return _status; }
void population_fitness(struct pop_c* pop_conf, struct state** population) { int ntask = MAXNCHILD; int info; int mytid; int child[MAXNCHILD]; int i, j; mytid = pvm_mytid(); if (mytid < 0) { /* the perneially informative error message of my youth. */ pvm_perror("wat"); exit(-1); } /* spawn the child tasks */ info = pvm_spawn("/home/rwblair/projects/parallel_ga/slave", (char**)0, PvmTaskDefault, (char*)0, ntask, child); /* only proceeds if all children properly spawned. It doesn't have to be * this way but its easiest */ printf("result of pvm_spawn call: %d\n", info); printf("value of first index of child array: %d\n", child[0]); if (info != ntask) { pvm_exit(); exit(-1); } int tmp; for (i = 0; i < ntask; i++) { tmp = ((pop_conf->pop_size)/ntask); if (i < (pop_conf->pop_size % ntask)) tmp++; pvm_initsend(PvmDataDefault); pvm_pkint(&tmp, 1, 1); pvm_pkint(&(pop_conf->n), 1, 1); info = pvm_send(child[i], 0); } j = 0; for (i = 0; i < pop_conf->pop_size; i++) { pvm_initsend(PvmDataDefault); pvm_pkint(&i, 1, 1); pvm_pkint(population[i]->configuration, pop_conf->n, 1); if ((i == pop_conf->pop_size -1) || (((pop_conf->pop_size / MAXNCHILD)) * (j + 1)) - 1 == i) { info = pvm_send(child[j++], 0); } } int recv_ret; int recv_index; int recv_fit; /* error handling, if a given thing f***s up how can it be unfucked? */ for (i = 0; i < pop_conf->pop_size; i++) { recv_ret = pvm_recv(-1, -1); pvm_upkint(&recv_index, 1, 1); pvm_upkint(&recv_fit, 1, 1); printf("recieved fitness: %d\n", recv_fit); population[recv_index]->fitness = recv_fit; /* if ((recv_index < 0) || (recv_index >= pop_conf->pop_size)) printf("BAD RECV_INDEX\n"); */ } pvm_exit(); return; }
void main (int argc, char** argv) { int Message_counter ; /* counter for message packing */ int My_tid ; /* my task id */ /* show start up message */ printf ("\n-=> Fractal Terrain Engine version 2.1 release 2 <=-\n\n") ; /* read the config files */ read_config (argc,argv) ; /* set up the pixel buffer and it's variables */ Pixel_buffer_width=User_view.X_size/Number_of_workers; Pixel_buffer_size= Pixel_buffer_width*User_view.Y_size*3*sizeof(unsigned char) ; Pixel_buffer=(unsigned char *) malloc(Pixel_buffer_size) ; /* set up worker tids array */ Worker_tids=(int *)malloc(Number_of_workers*sizeof(int)) ; /* set up the image buffer */ Image_buffer=(unsigned char *) malloc ((User_view.X_size*User_view.Y_size*3*sizeof(unsigned char))) ; /* start up pvm */ if ((My_tid = pvm_mytid()) < 0) { exit(1); } /* start up the workers */ pvm_spawn(WORKER_NAME,(char**)0,PvmTaskDefault,"", Number_of_workers,Worker_tids) ; printf ("INFO:Spawned %i Workers\n",Number_of_workers) ; /* tell the worker what values to use for the terrain function */ pvm_initsend(PvmDataDefault) ; pvm_pkdouble(&H,1,1) ; pvm_pkdouble(&Lacunarity,1,1); pvm_pkdouble(&Octaves,1,1); pvm_pkdouble(&Offset,1,1) ; pvm_pkfloat(&Ambient_light,1,1) ; pvm_pkfloat(&Fog.Red,1,1) ; pvm_pkfloat(&Fog.Green,1,1); pvm_pkfloat(&Fog.Blue,1,1) ; pvm_pkfloat(&Sky.Red,1,1) ; pvm_pkfloat(&Sky.Green,1,1) ; pvm_pkfloat(&Sky.Blue,1,1) ; pvm_pkfloat(&Horizon.Red,1,1) ; pvm_pkfloat(&Horizon.Green,1,1) ; pvm_pkfloat(&Horizon.Blue,1,1) ; pvm_pkdouble(Colour_boundaries,NUMBER_OF_TERRAIN_COLOURS,1) ; for ( Message_counter = 0 ; Message_counter<NUMBER_OF_TERRAIN_COLOURS ; Message_counter++ ) { pvm_pkfloat(&Terrain_colours[Message_counter].Red,1,1) ; pvm_pkfloat(&Terrain_colours[Message_counter].Green,1,1) ; pvm_pkfloat(&Terrain_colours[Message_counter].Blue,1,1) ; } pvm_pkdouble(&Fog_start,1,1) ; pvm_pkdouble(&Fog_end,1,1) ; /* tell the worker what values to use for the display */ pvm_pkdouble(&Ray_step,1,1) ; pvm_pkdouble(&X_view_angle,1,1) ; pvm_pkdouble(&Y_view_angle,1,1) ; pvm_pkint(&Pixel_buffer_width,1,1) ; pvm_pkint(&User_view.Y_size,1,1) ; pvm_pkdouble(&X_ray_angle,1,1) ; pvm_pkdouble(&Y_ray_angle,1,1) ; /* send the message to all the workers */ pvm_mcast (Worker_tids,Number_of_workers,INFO) ; /* set up light source */ normalize_3d(Light_source) ; /* set the light source */ Light_source[0]=0.1 ; Light_source[1]=0.4 ; Light_source[2]=0.3 ; /* tell the worker what values to use for the light source */ pvm_initsend(PvmDataDefault) ; pvm_pkdouble(Light_source,3,1) ; pvm_mcast (Worker_tids,Number_of_workers,NEW_LIGHT_SOURCE) ; /* set up the users view point */ Height=1.0 ; User.X=0 ; User.Y=0 ; User.Z=Height ; User.X_angle=0.0 ; User.Y_angle=0.0 ; User.Z_angle=0.0 ; /* set up window */ open_window() ; print_keys() ; /* */ /* set up the keyboard,Reshape and display routines */ /* */ auxKeyFunc(AUX_Q,kill_workers) ; auxKeyFunc(AUX_q,kill_workers) ; auxKeyFunc(AUX_ESCAPE,kill_workers) ; auxKeyFunc(AUX_LEFT,left) ; auxKeyFunc(AUX_RIGHT,right) ; auxKeyFunc(AUX_UP,forwards) ; auxKeyFunc(AUX_DOWN,backwards) ; auxKeyFunc(AUX_a,up) ; auxKeyFunc(AUX_A,up) ; auxKeyFunc(AUX_Z,down) ; auxKeyFunc(AUX_z,down) ; auxKeyFunc(AUX_J,save_image) ; auxKeyFunc(AUX_j,save_image) ; auxMainLoop(display_loop) ; }
int main(int argc, char **argv) { int myTID; int tids[NPROC] = {[0 ... NPROC-1] = 0}; int res; myTID = pvm_mytid(); printf("Master: TID is %d\n", myTID); double a; double b; int num_points; a = atof(argv[1]); b = atof(argv[2]); num_points = atoi(argv[3]); double begins[NPROC]; double ends[NPROC]; double basic_range = (b-a)/NPROC; //double extra_range = fmod((b-a),NPROC); for (int procindex = 0; procindex < NPROC; procindex++) { begins[procindex] = procindex * basic_range; ends[procindex] = begins[procindex] + basic_range; printf("begins[%d]= %f ends[%d]= %f\n", procindex,begins[procindex], procindex,ends[procindex]); } printf ("basic_range = %f\n", basic_range); res = pvm_spawn("slave", NULL, PvmTaskDefault, "", NPROC, tids); printf("res %d\n", res); if (res<1) { printf("Master: pvm_spawn error\n"); pvm_exit(); exit(1); } //for (int procindex = 0; procindex < NPROC; procindex++) printf("tids[%d] = %d\n", procindex, tids[procindex]); for (int procindex = 0; procindex < NPROC; procindex++) { pvm_initsend(PvmDataDefault); pvm_pkdouble(&begins[procindex], 1, 1); pvm_pkdouble(&ends[procindex], 1, 1); pvm_pkint(&num_points, 1, 1); pvm_send(tids[procindex], 1); } double result=0; for (int procindex = 0; procindex < NPROC; procindex++) { double r=0; pvm_recv(-1, -1); pvm_upkdouble(&r, 1, 1); printf("Master has received r=%f\n", r); result += r; } printf("Result %f\n", result); pvm_exit(); return 0; }
int main(int argc, char* argv[]) { // Timeout for Message Receive struct timeval tmout; tmout.tv_usec=100; tmout.tv_sec=0; // Size for Data Packets int data_size; // Numer of running tasks int curcount; // Check if all data sent bool finished; // TID of host to send data int slave_tid; // Data Buffer for outgoing messages int buff; // Read the frequency list read_freq_list(FREQ_LIST_FILE); // Total number of Data Elements int data_count=freq_count; // Current possition in the array int current_data=0; // Store master-id in PVM { int master_id=pvm_mytid(); pvm_delete((char *) "master",0); pvm_insert((char *)"master",0,master_id); // Parameters for Spawn char *params[2]={(char *) "1", NULL}; char *slave=(char *) "matcher_slave"; int tids[HOST_COUNT]; int spawncount=pvm_spawn(slave,params,PvmTaskDefault,NULL,HOST_COUNT,tids); } // Get number of current tasks pvm_tasks(0,&curcount,NULL); finished=false; do { // Check for error if (pvm_probe(-1,MSG_SLAVE_ERROR)) { char error[32]; int err_no=0; pvm_recv(-1,MSG_SLAVE_ERROR); pvm_upkint(&slave_tid,1,1); pvm_upkint(&err_no,1,1); printf("Fehler in Slave %d Code %d\n",slave_tid,err_no); } // Send Data or End-Of-Data else if(pvm_trecv(-1,MSG_SLAVE_READY,&tmout)>0) { pvm_upkint(&slave_tid,1,1); // No more data if (finished) { pvm_initsend(PvmDataDefault); pvm_send(slave_tid,MSG_MASTER_EOD); } // Send data packet else { buff=pvm_initsend(PvmDataDefault); if (data_count>=PACK_SIZE) data_size=PACK_SIZE; else data_size=data_count; data_count-=data_size; pvm_pkint(&data_size,1,1); for(int ct=0;ct<data_size;ct++) { // Store the data in the buffer if (current_data<=freq_count) { pvm_pkstr(freq_list[current_data]->word.getValue()); pvm_pkulong(&(freq_list[current_data]->count),1,1); current_data++; } } pvm_initsend(PvmDataDefault); pvm_send(slave_tid,MSG_MASTER_DATA); printf("Send %d sets of %d to %d\n",data_size,data_count,slave_tid); if (data_count==0) finished=true; } } // Receive Result else if (pvm_probe(-1,MSG_SLAVE_RESULT)) { if (pvm_trecv(-1,MSG_SLAVE_RESULT,&tmout)>0) { pvm_upkint(&slave_tid,1,1); // Number of elements pvm_upkint(&data_size,1,1); for (int ct=0;ct<data_size;ct++) { unsigned long res1=0; unsigned long res2=0; // Read the result data /* to fill */ // pvm_upkulong(&res1,1,1); // pvm_upkulong(&res2,1,1); // printf("Result %llu\n",(unsigned long long int)res2*ULONG_MAX+res1); } PvmDataDefault pvm_send(slave_tid,MSG_MASTER_EXIT); } } pvm_tasks(0,&curcount,NULL); } while(curcount>2); pvm_exit(); return 0; }
int main (int argc, char* argv[]) { if(argc !=4) { printf("usage : ./craquage p r m\n"); return EXIT_FAILURE; } //Initialisation des variables int nb_esclaves = atoi(argv[1]); int* tids = (int*) calloc(nb_esclaves, sizeof(int)); int longueur_mdp = atoi(argv[2]); char* mdp = (char*) calloc(strlen(argv[3])+1, sizeof(char)); strcpy(mdp, argv[3]); //declaration de type de tres long entiers (avec bibliotheque GMP) mpz_t debut_sequence, pas_reel, pas, fin_exec; mpz_init(debut_sequence); mpz_init(pas_reel); mpz_init(pas); mpz_init(fin_exec); //recuperation du chemin de l executable char* chemin = getcwd(NULL, 1000); strcat(chemin, "/craquage_esclave"); //creation des arguments pour l esclave char *argv_esclave[3]; argv_esclave[2]=NULL; argv_esclave[0] = (char*) calloc(strlen(argv[2])+1, sizeof(char)); strcpy(argv_esclave[0],argv[2]); argv_esclave[1] = (char*) calloc(strlen(argv[3])+1, sizeof(char)); strcpy(argv_esclave[1],argv[3]); //printf("strlen %lu, %lu\n", (long unsigned)strlen(argv[2]),(long unsigned) strlen(argv[3])); //printf("nb_esclaves %d\n", nb_esclaves); int i; int trouve = 0; int fini = 0; int size; int nb_envoi = 0; int nb_pas = nb_esclaves*longueur_mdp; int nb_changement = 0; char* envoi_char; int bufid, info, bytes, type, source; char * solution; pvm_catchout(stderr); struct timeval tv1, tv2; gettimeofday(&tv1, NULL); pvm_spawn(chemin, argv_esclave, PvmTaskDefault,"", nb_esclaves, tids); //calcul du pas, fin_exec (= fin execution) mpz_set_ui(debut_sequence, 0); mpz_ui_pow_ui(fin_exec, 15, longueur_mdp+1); mpz_sub_ui(fin_exec, fin_exec, 15); mpz_cdiv_q_ui(fin_exec, fin_exec, 14); mpz_set(pas, fin_exec); mpz_cdiv_q_ui(pas, pas, nb_pas); if(mpz_cmp_ui(pas, 0)==0) { mpz_set_ui(pas,1); } //gmp_printf("fin_exec: %Zd\npas:%Zd\ndebut_sequence:%Zd\n",fin_exec, pas, debut_sequence); //boucle principale while(!trouve && fini!=nb_esclaves) { //Attente de reception de donnees d un esclave bufid = pvm_recv( -1, -1 ); info = pvm_bufinfo( bufid, &bytes, &type, &source ); if (info < 0) { printf("Erreur de reception : %d\n", info); exit(1); } //selon le tag du message, demande de donnees ou solution trouvee switch(type) { case(0)://mot de passe trouve solution = calloc(bytes, sizeof(char)); pvm_upkstr(solution); printf("\nLa solution est : %s\n\n", solution); trouve = 1; break; case(1)://esclave veut plus de donnees //prendre en compte la fin des donnees dans le calcul du pas if(nb_changement <= 2 && nb_envoi>=(3*nb_pas/4)) { mpz_cdiv_q_ui(pas, pas, 2); nb_envoi = 0; nb_pas/=2; nb_changement++; } //gmp_printf("fin_exec: %Zd pas:%Zd debut_sequence:%Zd\n",fin_exec, pas, debut_sequence); if(mpz_cmp(debut_sequence, fin_exec)< 0){ mpz_sub(pas_reel, fin_exec, debut_sequence); if(mpz_cmp(pas, pas_reel)<0) { mpz_set(pas_reel, pas); } //envoi des donnes a l esclave pvm_initsend(PvmDataDefault); size = gmp_asprintf(&envoi_char, "%Zd", debut_sequence); pvm_pkint(&size, 1, 1); pvm_pkbyte(envoi_char,size+1, 1); free(envoi_char); size = gmp_asprintf(&envoi_char, "%Zd", pas_reel); pvm_pkint(&size, 1, 1); pvm_pkbyte(envoi_char,size+1 , 1); free(envoi_char); pvm_send(source,0); if(mpz_cmp(pas_reel,pas)!=0) { mpz_set(debut_sequence,fin_exec); } else { mpz_add(debut_sequence, debut_sequence,pas); } nb_envoi++; } else{ fini++ ; printf("Pas de solution pour %d esclave(s)\n", fini); } break; default: break; } } // suppression des esclave for(i=0; i<nb_esclaves;i++) { info = pvm_kill(tids[i]); //printf("Suppression de l esclave %d: retour de pvm_kill: %d\n",i ,info); } pvm_exit(); gettimeofday(&tv2, NULL); printf("%d %ld\n",longueur_mdp,(tv2.tv_sec-tv1.tv_sec)*1000 + (tv2.tv_usec-tv1.tv_usec)/1000); mpz_clear(debut_sequence); mpz_clear(pas_reel); mpz_clear(pas); mpz_clear(fin_exec); free(tids); free(mdp); free(argv_esclave[0]); free(argv_esclave[1]); return EXIT_SUCCESS; }
int adpvm_manager::start_slave_processes_for_random_effects(const ad_comm& _mp) { ad_comm& mp=(ad_comm&) _mp; cout << (mp.pvm_manager)->nhost; int i,j,check; mp.get_slave_assignments(); if (allocated(id)) id.deallocate(); id.allocate(1,nhost,1,num_per_host); adstring slavedir; int on=0; int use_td32=1; if (use_td32) { char ** pvmargs=new pchar[ad_comm::argc+5]; int i; for (i=0;i<ad_comm::argc+5;i++) { pvmargs[i]=0; } pvmargs[0]=new char[strlen(ad_comm::adprogram_name)+1]; strcpy(pvmargs[0],ad_comm::adprogram_name); strlwr(pvmargs[0]); for (i=1;i<ad_comm::argc;i++) { pvmargs[i]=new char[strlen(ad_comm::argv[i])+1]; strcpy(pvmargs[i],ad_comm::argv[i]); } pvmargs[ad_comm::argc]=new char[strlen("-slave")+1]; strcpy(pvmargs[ad_comm::argc],"-slave"); pvmargs[ad_comm::argc+1]=new char[10]; pvmargs[ad_comm::argc+3]=0; for (i=0;i<nhost;i++) { for (j=1;j<=num_per_host(i+1);j++) { strncpy(pvmargs[ad_comm::argc+1], (char*)(str(slave_assignments(i+1,j))),9); //check=pvm_spawn(pvmargs[0],pvmargs, check=pvm_spawn("td32rem",pvmargs, PvmTaskHost /* | PvmTaskDebug */ , hostp[i].hi_name, 1, &(id(i+1,j))); if (!check) printf("Couldn't start slave process %d on %s\n",j,hostp[i].hi_name); else printf("Started slave process %d on %s\n",j,hostp[i].hi_name); } } } else { for (i=0;i<nhost;i++) { for (j=1;j<=num_per_host(i+1);j++) { check=pvm_spawn(ad_comm::adprogram_name,0, PvmTaskHost /* | PvmTaskDebug */ , hostp[i].hi_name, 1, &(id(i+1,j))); if (!check) printf("Couldn't start slave process %d on %s\n",j,hostp[i].hi_name); else printf("Started slave process %d on %s\n",j,hostp[i].hi_name); } } } return 0; }
int main(int argc, char *argv[]) { /* argv[1] - ilość narciarzy */ time_t t; srand((unsigned)time(&t)); int number_of_skiers = 0; if (argc >= 2) { number_of_skiers = atoi(argv[1]); } else { number_of_skiers = rand() % 50 + 10; } printf("Liczba narciarzy: %d\n", number_of_skiers); int *skiers_weights; skiers_weights = malloc(sizeof(int) * number_of_skiers); int min_skier_weight = SKIERS_MAX_WEIGHT; int sum_skiers_weights = 0; int i; int weights_arg_index = -1; for (i = 0; i < argc; i++) { if (!strcmp(argv[i], "weights")) { weights_arg_index = i; break; } } for(i=0; i<number_of_skiers; i++) { if (weights_arg_index == -1) skiers_weights[i] = rand() % (SKIERS_MAX_WEIGHT - SKIERS_MIN_WEIGHT + 1) + SKIERS_MIN_WEIGHT; else skiers_weights[i] = atoi(argv[weights_arg_index + 1 + i]); sum_skiers_weights += skiers_weights[i]; if (skiers_weights[i] < min_skier_weight) { min_skier_weight = skiers_weights[i]; } } for(i=0; i<number_of_skiers; i++) { printf("Narciarz %d ma wage: %d\n", i, skiers_weights[i]); } printf("Min waga: %d\n", min_skier_weight); printf("Sum waga: %d\n", sum_skiers_weights); int min_perc_sum = 0.2 * sum_skiers_weights; int max_perc_sum = 0.4 * sum_skiers_weights; int first_lift_capacity; int second_lift_capacity; do { first_lift_capacity = rand() % (max_perc_sum - min_perc_sum) + min_perc_sum; } while (first_lift_capacity < min_skier_weight); do { second_lift_capacity = rand() % (max_perc_sum - min_perc_sum) + min_perc_sum; } while (second_lift_capacity < min_skier_weight); // read lifts capacities from console int lifts_arg_index = -1; for (i = 0; i < argc; i++) { if (!strcmp(argv[i], "lifts")) { lifts_arg_index = i; break; } } if (lifts_arg_index != -1) { first_lift_capacity = atoi(argv[lifts_arg_index + 1]); second_lift_capacity = atoi(argv[lifts_arg_index + 2]); } printf("Pierwszy wyciag: %d\n", first_lift_capacity); printf("Drugi wyciag: %d\n", second_lift_capacity); int mytid; int tids[number_of_skiers]; /* slave task ids */ char slave_name[NAMESIZE]; int nproc, j, who; mytid = pvm_mytid(); pvm_catchout(stdout); nproc=pvm_spawn(SLAVENAME, NULL, PvmTaskDefault, "", number_of_skiers, tids); for( i=0 ; i<nproc ; i++ ) { pvm_initsend(PvmDataDefault); pvm_pkint(&mytid, 1, 1); pvm_pkint(&number_of_skiers, 1, 1); for (j=0; j<nproc; j++) { pvm_pkint(&tids[j], 1, 1); } for (j=0; j<nproc; j++) { pvm_pkint(&skiers_weights[j], 1, 1); } pvm_pkint(&first_lift_capacity, 1, 1); pvm_pkint(&second_lift_capacity, 1, 1); pvm_send(tids[i], MSG_MSTR); } int current_skier_weight; for( i=0 ; i<nproc ; i++ ) { pvm_recv( -1, MSG_SLV ); pvm_upkint(&who, 1, 1 ); pvm_upkstr(slave_name ); pvm_upkint(¤t_skier_weight, 1, 1); printf("%d: weight %d\n",who, current_skier_weight); } int msgnum = 1; while (1) { pvm_recv(-1, MSG_DIAG); char diag_str[200]; pvm_upkstr(diag_str); printf("[%d] %s\n", msgnum, diag_str); msgnum++; } pvm_exit(); }
void BBSDirect::start() { char* client = 0; int tid, host_mytid; int i, n, ncpu, nncpu; struct pvmhostinfo* hostp; if (started_) { return; } BBSImpl::start(); mytid_ = pvm_mytid(); nrnmpi_myid = 0; if (mytid_ < 0) { perror("start"); } host_mytid = pvm_tidtohost(mytid_); tid = pvm_parent(); if (tid == PvmSysErr) { perror("start"); }else if (tid == PvmNoParent) { is_master_ = true; pvm_catchout(stdout); pvm_setopt(PvmRoute, PvmRouteDirect); pvm_config(&n, NULL, &hostp); nncpu = 0; for (i=0; i < n; ++i) { ncpu = hostp[i].hi_speed; if (ncpu%1000) { hoc_warning(hostp[i].hi_name, " speed in pvm configuration file is not a multiple of 1000. Assuming 1000."); ncpu = 1000; } nncpu += ncpu/1000; } nrnmpi_numprocs = nncpu; ncids = 0; }else{ // a worker, impossible assert(false); } if (nrnmpi_numprocs > 1 && tid == PvmNoParent) { char ** sargv; // args are workingdirectory specialOrNrniv -bbs_nhost nhost args sargv = new char*[nrn_global_argc + 4]; for (i=1; i < nrn_global_argc; ++i) { sargv[i+3] = nrn_global_argv[i]; } sargv[nrn_global_argc + 3] = 0; sargv[0] = rel_working_dir(); //printf("sargv[0]=|%s|\n", sargv[0]); sargv[1] = nrn_global_argv[0]; sargv[2] = "-bbs_nhost"; sargv[3] = new char[10]; sprintf(sargv[3], "%d", nrnmpi_numprocs); cids = new int[nrnmpi_numprocs-1]; if (nrn_global_argv[nrn_global_argc] != 0) { printf("argv not null terminated\n"); exit(1); } BBSDirectServer::server_->start(); bbs_sig_set(); bbs_handle(); //spawn according to number of cpu's (but master has one less) //printf("%d total number of cpus on %d machines\n", nncpu, n); int icid = 0; bool first = true; while (icid < nrnmpi_numprocs - 1) { for (i=0; i < n; ++i) { ncpu = hostp[i].hi_speed; if (ncpu%1000) { ncpu = 1000; } ncpu /= 1000; //printf("%d cpu for machine %d (%s)\n", ncpu, i, hostp[i].hi_name); if (first && hostp[i].hi_tid == host_mytid) { // spawn one fewer on master first time through --ncpu; } if (icid + ncpu >= nrnmpi_numprocs) { ncpu = nrnmpi_numprocs - icid - 1; } //printf("before spawn %d processes (icid=%d) for machine %d (%s)\n", ncpu, icid, i, hostp[i].hi_name); if (ncpu) { ncids = pvm_spawn("bbswork.sh", sargv, PvmTaskHost, hostp[i].hi_name, ncpu, cids + icid); if (ncids != ncpu) { fprintf(stderr, "Tried to spawn %d tasks, only %d succeeded on %s\n", ncpu, ncids, hostp[i].hi_name); hoc_execerror("Could not spawn all the requested tasks for", hostp[i].hi_name); } //printf("spawned %d for %s with cids starting at %d\n", ncpu, hostp[i].hi_name, icid); icid += ncpu; } if (icid >= nrnmpi_numprocs) { break; } } first = false; } ncids = icid; printf("spawned %d more %s on %d cpus on %d machines\n", ncids, nrn_global_argv[0], nncpu, n); delete [] sargv[3]; delete [] sargv; } }
int adpvm_manager::start_slave_processes(const ad_comm& _mp) { ad_comm& mp=(ad_comm&) _mp; cout << (mp.pvm_manager)->nhost; int i,j,check; mp.get_slave_assignments(); if (allocated(id)) id.deallocate(); id.allocate(1,nhost,1,num_per_host); adstring slavedir; int on=0; int noptslave=0; int td32flag=option_match(ad_comm::argc,ad_comm::argv,"-td32"); if (td32flag>0) { strcpy(*slave_argv,slave_names[1]); } if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-dbg"))>-1) strcpy(*slave_argv,"-dbg"); if ( (on=option_match(ad_comm::argc,ad_comm::argv,"-slavedir",noptslave))>-1) { if (noptslave !=1) { cerr << "Wrong number of options to -slavedir -- must be 1" " you have " << noptslave << endl; ad_exit(1); } } else { noptslave=0; } int on1,nopt1; if ( (on1=option_match(ad_comm::argc,ad_comm::argv,"-mcmc",nopt1))>-1) { if ( (on1=option_match(ad_comm::argc,ad_comm::argv,"-mcmc2",nopt1))>-1) { cerr << "Error -mcmc2 option not implemented for parallel processing" << endl; ad_exit(1); } if (nopt1 !=1) { cerr << "Wrong number of options to -mcmc -- must be 1" " you have " << noptslave << endl; ad_exit(1); } strcpy((*slave_argv),"-mcmc"); strcpy((*slave_argv),ad_comm::argv[on1+1]); } if ( (on1=option_match(ad_comm::argc,ad_comm::argv,"-nohess"))>-1) { strcpy((*slave_argv),"-nohess"); } if ( (on1=option_match(ad_comm::argc,ad_comm::argv,"-lprof"))>-1) { strcpy((*slave_argv),"-lprof"); } int gdbflag=option_match(ad_comm::argc,ad_comm::argv,"-gdb"); int slave_con=option_match(ad_comm::argc,ad_comm::argv,"-scon"); int ii=0; for (i=0; i<nhost; i++) /* spawn processes on */ { /* all physical machines */ for (j=slave_assignments(i+1).indexmin();j<=slave_assignments(i+1).indexmax(); j++) { strcpy((*slave_argv),"-slavename"); strcpy((*slave_argv),ad_comm::adprogram_name); strcpy((*slave_argv),"-slave"); strcpy((*slave_argv),(char*)(str(slave_assignments(i+1,j)))); if (noptslave ==1) { strcpy((*slave_argv),"-slavedir"); strcpy((*slave_argv),ad_comm::argv[on+1]); } if (td32flag<0) { //check=pvm_spawn(slave_names[1],*slave_argv , char ** args; args=new pchar[10]; args[0]=new char[20]; args[1]=new char[20]; strcpy(args[0],"-slave"); strcpy(args[1],(char*)str(ii+1)); args[2]=0; check=pvm_spawn(ad_comm::adprogram_name,args , PvmTaskHost /* | PvmTaskDebug */ , hostp[i].hi_name, 1, &(id(i+1,j))); ii++; } else { char ** args; args=new pchar[10]; if (slave_con>0) { args[0]=new char[50]; args[1]=new char[20]; args[2]=new char[20]; strncpy(args[0],ad_comm::adprogram_name,49); strncpy(args[1],"-slave",19); strncpy(args[2],(char*)str(ii+1),19); args[3]=0; } else { args[0]=new char[20]; args[1]=new char[50]; args[2]=new char[20]; args[3]=new char[50]; strcpy(args[0],"td32"); strncpy(args[1],ad_comm::adprogram_name,49); strcpy(args[2],"-slave"); strcpy(args[3],(char*)str(ii+1)); args[4]=0; } //check=pvm_spawn("nrunslave",*slave_argv , check=pvm_spawn("nrunslave",args , PvmTaskHost /* | PvmTaskDebug */ , hostp[i].hi_name, 1, &(id(i+1,j))); ii++; } (*slave_argv)--; (*slave_argv)--; (*slave_argv)--; (*slave_argv)--; if (noptslave ==1) { (*slave_argv)--; (*slave_argv)--; } if (!check) printf("Couldn't start process on %s\n",hostp[i].hi_name); else printf("Started process on %s\n",hostp[i].hi_name); } } return check; }