void send_assign(int tid, tassign *assign) { int bufid, datasize, i, toint[ASSIGN_NINT]; double *tdbl, todbl[ASSIGN_NDBL]; float *tflt; toint[ASSIGN_ID] = (int)(assign->id); toint[ASSIGN_CHANS] = (int)(assign->chans); toint[ASSIGN_FRAMES] = (int)(assign->frames); toint[ASSIGN_EPOCHS] = (int)(assign->epochs); toint[ASSIGN_BIAS] = (int)(assign->bias); toint[ASSIGN_SIGNS] = (int)(assign->signs); toint[ASSIGN_EXTENDED] = (int)(assign->extended); toint[ASSIGN_EXTBLOCKS] = (int)(assign->extblocks); toint[ASSIGN_PDFSIZE] = (int)(assign->pdfsize); toint[ASSIGN_NSUB] = (int)(assign->nsub); toint[ASSIGN_VERBOSE] = (int)(assign->verbose); toint[ASSIGN_BLOCK] = (int)(assign->block); toint[ASSIGN_MAXSTEPS] = (int)(assign->maxsteps); todbl[ASSIGN_LRATE] = (double)(assign->lrate); todbl[ASSIGN_ANNEALSTEP] = (double)(assign->annealstep); todbl[ASSIGN_ANNEALDEG] = (double)(assign->annealdeg); todbl[ASSIGN_NOCHANGE] = (double)(assign->nochange); todbl[ASSIGN_MOMENTUM] = (double)(assign->momentum); bufid = pvm_initsend(PvmDataDefault); pvm_pkint(toint,ASSIGN_NINT,1); pvm_pkdouble(todbl,ASSIGN_NDBL,1); datasize = assign->chans * assign->frames * assign->epochs; if (sizeof(float) != sizeof(doublereal)) { tflt = (float*)malloc(datasize*sizeof(float)); for (i=0 ; i<datasize ; i++) tflt[i] = (float)(assign->data[i]); pvm_pkfloat(tflt,datasize,1); free(tflt); } else pvm_pkfloat((float*)(assign->data),datasize,1); datasize = assign->chans * assign->chans; if (sizeof(double) != sizeof(doublereal)) { tdbl = (double*)malloc(datasize*sizeof(double)); for (i=0 ; i<datasize ; i++) tdbl[i] = (double)(assign->weights[i]); pvm_pkdouble(tdbl,datasize,1); free(tdbl); } else pvm_pkdouble((double*)(assign->weights),datasize,1); pvm_send(tid,1); pvm_freebuf(bufid); }
// Send the bits of the genome to the task that requested them. First we send // the number of bits, then we send the bits themselves. Note that we can // handle genomes of varying lengths with this setup. We also pack the score // and stuff that in as well (so that they don't have to do an eval at the // other end). If we did this as a member function we could save the hassle // of an extra copy of the bits... // Returns negative number (error code) if failure. int PackIndividual(GAGenome& g) { GA1DBinaryStringGenome& genome = (GA1DBinaryStringGenome&)g; static int* bits = 0; static int nbits = 0; int status = 0;; if(nbits < genome.length()){ nbits = genome.length(); delete [] bits; bits = new int [nbits]; } int length = genome.length(); for(int i=0; i<length; i++) bits[i] = genome.gene(i); status = pvm_pkint(&length, 1, 1); status = pvm_pkint(bits, length, 1); float score = g.score(); status = pvm_pkfloat(&score, 1, 1); return status; }
int send_float_array(float *array, int size) { int info; PVM_FUNC(info, pvm_pkfloat(array, size, 1)); return(info); }
// Send only the score of the genome to the specified task. int SendGenomeScore(GAGenome& g, int tid) { int status = 0; float score = g.score(); status = pvm_initsend(PvmDataDefault); status = pvm_pkfloat(&score, 1, 1); status = pvm_send(tid, MSG_GENOME_SCORE); return status; }
void SendFloat(float *FloatBuf, int n, int tid, int MsgType) { int info; info = pvm_initsend(PvmDataDefault); /* pvm_pkbyte((char *)FloatBuf, n*sizeof(float), 1); */ if (info) { pvm_pkfloat(FloatBuf, n, 1); pvm_send(tid, MsgType); } else { fprintf(stderr, "Problems with SendFloat : Message type %d\n", MsgType); } }
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(void) { struct p7trace_s *tr; /* traceback of an alignment */ int master_tid; /* PVM TID of our master */ char *hmmfile; /* file to read HMM(s) from */ HMMFILE *hmmfp; /* opened hmmfile for reading */ struct plan7_s *hmm; char *seq; char *dsq; int len; int nhmm; /* number of HMM to work on */ float sc; int my_idx = -1; /* my index, 0..nslaves-1 */ float globT; /* T parameter: keep only hits > globT bits */ double globE; /* E parameter: keep hits < globE E-value */ double pvalue; /* Z*pvalue = Evalue */ int Z; /* nseq to base E value calculation on */ int send_trace; /* TRUE if score is significant */ int do_xnu; /* TRUE to do XNU filter on seq */ int do_forward; /* TRUE to use Forward() scores not Viterbi */ int do_null2; /* TRUE to correct scores w/ ad hoc null2 */ int alphatype; /* alphabet type, hmmAMINO or hmmNUCLEIC */ int code; /* return code after initialization */ /* Register leave_pvm() cleanup function so any exit() call * first calls pvm_exit(). */ if (atexit(leave_pvm) != 0) { pvm_exit(); Die("slave couldn't register leave_pvm()"); } /***************************************************************** * initialization. * Master broadcasts to us: * 1) len of HMM file name (int) * 2) name of HMM file (string) * 3) length of sequence string (int) * 4) sequence (string) * 5) globT threshold * 6) globE threshold * 7) Z * 8) do_xnu flag * 9) do_forward flag * 10) do_null2 flag * 11) alphabet type * We receive the broadcast and open the files. ******************************************************************/ master_tid = pvm_parent(); /* who's our master? */ pvm_recv(master_tid, HMMPVM_INIT); pvm_upkint(&len, 1, 1); hmmfile = MallocOrDie(sizeof(char *) * (len+1)); pvm_upkstr(hmmfile); pvm_upkint(&len, 1, 1); seq = MallocOrDie(sizeof(char *) * (len+1)); pvm_upkstr(seq); pvm_upkfloat(&globT, 1, 1); pvm_upkdouble(&globE, 1, 1); pvm_upkint(&Z, 1, 1); pvm_upkint(&do_xnu, 1, 1); pvm_upkint(&do_forward, 1, 1); pvm_upkint(&do_null2, 1, 1); pvm_upkint(&alphatype, 1, 1); SetAlphabet(alphatype); /* Open HMM file (maybe in HMMERDB) */ code = HMMPVM_OK; if ((hmmfp = HMMFileOpen(hmmfile, "HMMERDB")) == NULL) code = HMMPVM_NO_HMMFILE; else if (hmmfp->gsi == NULL) code = HMMPVM_NO_INDEX; /* report our status. */ pvm_initsend(PvmDataDefault); pvm_pkint(&code, 1, 1); pvm_send(master_tid, HMMPVM_RESULTS); dsq = DigitizeSequence(seq, len); if (do_xnu) XNU(dsq, len); /***************************************************************** * Main loop. * Receive an integer 0..nhmm-1 for which HMM to search against. * If we receive a -1, we shut down. *****************************************************************/ for (;;) { pvm_recv(master_tid, HMMPVM_WORK); pvm_upkint(&nhmm, 1, 1); if (my_idx < 0) my_idx = nhmm; /* first time thru, remember what index we are. */ if (nhmm == -1) break; /* shutdown signal */ /* move to our assigned HMM in the HMM file, and read it */ HMMFilePositionByIndex(hmmfp, nhmm); if (! HMMFileRead(hmmfp, &hmm)) Die("unexpected end of HMM file"); if (hmm == NULL) Die("unexpected failure to parse HMM file"); P7Logoddsify(hmm, TRUE); /* Score sequence, do alignment (Viterbi), recover trace */ if (P7ViterbiSize(len, hmm->M) <= RAMLIMIT) { SQD_DPRINTF1(("P7Viterbi(): Estimated size %d Mb\n", P7ViterbiSize(len, hmm->M))); sc = P7Viterbi(dsq, len, hmm, &tr); } else { SQD_DPRINTF1(("P7SmallViterbi() called; %d Mb > %d\n", P7ViterbiSize(len, hmm->M), RAMLIMIT)); sc = P7SmallViterbi(dsq, len, hmm, &tr); } if (do_forward) sc = P7Forward(dsq, len, hmm, NULL); if (do_null2) sc -= TraceScoreCorrection(hmm, tr, dsq); pvalue = PValue(hmm, sc); send_trace = (sc > globT && pvalue * (float) Z < globE) ? 1 : 0; /* return output */ pvm_initsend(PvmDataDefault); pvm_pkint(&my_idx, 1, 1); /* tell master who we are */ pvm_pkstr(hmm->name); /* double check that we did the right thing */ pvm_pkfloat(&sc, 1, 1); pvm_pkdouble(&pvalue, 1, 1); pvm_pkint(&send_trace, 1, 1); /* flag for whether a trace structure is coming */ if (send_trace) PVMPackTrace(tr); pvm_send(master_tid, HMMPVM_RESULTS); /* cleanup */ FreePlan7(hmm); P7FreeTrace(tr); } /*********************************************** * Cleanup, return. ***********************************************/ HMMFileClose(hmmfp); free(seq); free(dsq); free(hmmfile); return 0; }
int main (int argc, char **argv) { int Finish,dip=65; int nz; /* number of migrated depth samples */ int nxo,nx; /* number of midpoints */ int iz,iw,ix,ix2,ix3,ixshot; /* loop counters*/ int ntfft; /* fft size*/ int nw; /* number of frequency*/ int mytid,msgtype,rc,parent_tid; float dt=0.004,dz; /*time and depth sampling interval*/ float dw; /*frequency sampling interval */ float fw; /* first frequency*/ float w; /* frequency*/ float dx; /* spatial sampling interval*/ float **cresult; /*output data*/ float v1; float para; double kz2; float **vp,**v; complex cshift2; complex **cp,**cp1; /* complex input,output */ /*get my and father pids*/ mytid=pvm_mytid(); parent_tid=pvm_parent(); /*receive global parameters*/ msgtype=PARA_MSGTYPE; rc=pvm_recv(-1,msgtype); rc=pvm_upkint(&nxo,1,1); rc=pvm_upkint(&nz,1,1); rc=pvm_upkint(&dip,1,1); rc=pvm_upkfloat(¶,1,1); /*allocate space for velocity profile and receive velocity from father*/ vp=alloc2float(nxo,nz); msgtype=VEL_MSGTYPE; rc=pvm_recv(-1,msgtype); rc=pvm_upkfloat(vp[0],nxo*nz,1); /*allocate space for the storage of partial image and zero it out now*/ cresult = alloc2float(nz,nxo); for(ix=0;ix<nxo;ix++) for(iz=0;iz<nz;iz++) cresult[ix][iz]=0.0; /*loop over shotgather*/ loop: /*receive parameters for each shot gather*/ msgtype=PARA_MSGTYPE; rc=pvm_recv(parent_tid,msgtype); rc=pvm_upkint(&Finish,1,1); if(Finish==FinalDone)goto end; rc=pvm_upkint(&ntfft,1,1); rc=pvm_upkint(&ix2,1,1); rc=pvm_upkint(&ix3,1,1); rc=pvm_upkint(&ixshot,1,1); nx=ix3-ix2+1; rc=pvm_upkfloat(&dx,1,1); rc=pvm_upkfloat(&dz,1,1); rc=pvm_upkfloat(&dw,1,1); rc=pvm_upkfloat(&dt,1,1); /*allocate space for velocity profile within the aperature*/ v=alloc2float(nx,nz); for(iz=0;iz<nz;iz++) for(ix=0;ix<nx;ix++){ v[iz][ix]=vp[iz][ix+ix2]; } while(1){ /*receive parameters and data for processing*/ msgtype=DATA_MSGTYPE; rc=pvm_recv(parent_tid,msgtype); rc=pvm_upkint(&Finish,1,1); if(Finish==Done) {free2float(v);goto loop; } rc=pvm_upkfloat(&fw,1,1); rc=pvm_upkint(&nw,1,1); cp = alloc2complex(nx,nw); cp1 = alloc2complex(nx,nw); rc=pvm_upkfloat((float *)cp[0],nx*nw*2,1); rc=pvm_upkfloat((float *)cp1[0],nx*nw*2,1); /* loops over depth */ for(iz=0;iz<nz;++iz){ /*the imaging condition*/ /* for(ix=0;ix<nx;ix++){ for(iw=0,w=fw;iw<nw;w+=dw,iw++){ complex tmp; float ratio=10.0; if(fabs(ix+ix2-ixshot)*dx<ratio*iz*dz) tmp=cmul(cp[iw][ix],cp1[iw][ix]); else tmp=cmplx(0.0,0.0); cresult[ix+ix2][iz]+=tmp.r/ntfft; } } */ /* anothe imaging condition, slightly different from the above one, but not quite slow*/ for(iw=0,w=fw;iw<nw;w+=dw,iw++){ float kk=0.0; complex tmp; float ratio=1.5; if(dip<80)ratio=1.5; else ratio=1.5; for(ix=0;ix<nx;ix++){ kk+=(pow(cp1[iw][ix].i,2.0)+pow(cp1[iw][ix].r,2.0))/nx; } for(ix=0;ix<nx;ix++){ tmp=cmul(cp[iw][ix],cp1[iw][ix]); if(fabs(ix+ix2-ixshot)*dx<ratio*iz*dz) tmp=crmul(tmp,1.0/(kk+1.0e-10)); else tmp=cmplx(0.0,0.0); cresult[ix+ix2][iz]+=tmp.r/ntfft; } } /*get the average velocity*/ v1=0.0; for(ix=0;ix<nx;++ix) {v1+=v[iz][ix]/nx;} /*compute time-invariant wavefield*/ /* for(ix=0;ix<nx;++ix) for(iw=0,w=fw;iw<nw;w+=dw,++iw) { kz2=-(1.0/v1)*w*dz; cshift2=cmplx(cos(kz2),sin(kz2)); cp[iw][ix]=cmul(cp[iw][ix],cshift2); cp1[iw][ix]=cmul(cp1[iw][ix],cshift2); } */ /*wave-propagation using finite-difference method*/ fdmig( cp, nx, nw,v[iz],fw,dw,dz,dx,dt,dip,para); fdmig( cp1,nx, nw,v[iz],fw,dw,dz,dx,dt,dip,para); /*apply thin lens term here*/ for(ix=0;ix<nx;++ix) for(iw=0,w=fw;iw<nw;w+=dw,++iw){ float Wi=-dw; kz2=-(1.0/v[iz][ix])*dz; /* kz2=-(1.0/v[iz][ix]-1.0/v1)*w*dz; cshift2=cmplx(cos(kz2),sin(kz2));*/ cshift2=cexp(cmplx(-Wi*kz2,w*kz2)); cp[iw][ix]=cmul(cp[iw][ix],cshift2); cp1[iw][ix]=cmul(cp1[iw][ix],cshift2); } } /*finish a portion of the data, request more*/ pvm_initsend(PvmDataDefault); pvm_pkint(&mytid,1,1); msgtype=COM_MSGTYPE; pvm_send(parent_tid,msgtype); free2complex(cp); free2complex(cp1); } end: /*everything done,send back partial image and wait for signal to kill itself*/ pvm_initsend(PvmDataDefault); pvm_pkfloat(cresult[0],nxo*nz,1); msgtype=RESULT_MSGTYPE; pvm_send(parent_tid,msgtype); msgtype=COM_MSGTYPE; pvm_recv(-1,msgtype); pvm_exit(); exit(0); }
int main(void) { int master_tid; /* PVM TID of our master */ int slaveidx; /* my slave index (0..nslaves-1) */ struct plan7_s *hmm; /* HMM to calibrate, sent from master */ struct histogram_s *hist; /* score histogram */ int hmmidx; /* index of this HMM */ char *seq; /* synthetic random sequence */ char *dsq; /* digitized seq */ int len; /* length of seq */ float sc; /* score of seq aligned to HMM */ float max; /* maximum score seen in sample */ int seed; /* random number seed */ int nsample; /* number of seqs to sample */ int fixedlen; /* if nonzero, fixed length of seq */ float lenmean; /* Gaussian mean length of seq */ float lensd; /* Gaussian length std. dev. for seq */ int fitok; /* TRUE if EVD fit was OK */ float randomseq[MAXABET]; /* iid frequencies of residues */ float p1; int alphatype; /* alphabet type, hmmAMINO or hmmNUCLEIC */ int idx; int code; /* Register leave_pvm() cleanup function so any exit() call * first calls pvm_exit(). */ if (atexit(leave_pvm) != 0) { pvm_exit(); Die("slave couldn't register leave_pvm()"); } /***************************************************************** * initialization. * Master broadcasts the problem to us: parameters of the * HMM calibration. ******************************************************************/ master_tid = pvm_parent(); /* who's our master? */ pvm_recv(master_tid, HMMPVM_INIT); pvm_upkint(&nsample, 1, 1); pvm_upkint(&fixedlen, 1, 1); pvm_upkfloat(&lenmean, 1, 1); pvm_upkfloat(&lensd, 1, 1); /* tell the master we're OK and ready to go (or not) */ code = HMMPVM_OK; pvm_initsend(PvmDataDefault); pvm_pkint(&code, 1, 1); pvm_send(master_tid, HMMPVM_RESULTS); /***************************************************************** * Main loop. * Receive a random number seed, then an HMM to search against. * If we receive a -1 seed, we shut down. *****************************************************************/ slaveidx = -1; for (;;) { pvm_recv(master_tid, HMMPVM_WORK); pvm_upkint(&seed, 1, 1); if (seed == -1) break; /* shutdown signal */ pvm_upkint(&hmmidx, 1, 1); pvm_upkint(&alphatype,1, 1); SetAlphabet(alphatype); hmm = PVMUnpackHMM(); if (hmm == NULL) Die("oh no, the HMM never arrived"); if (slaveidx == -1) slaveidx = hmmidx; P7DefaultNullModel(randomseq, &p1); sre_srandom(seed); P7Logoddsify(hmm, TRUE); hist = AllocHistogram(-200, 200, 100); max = -FLT_MAX; for (idx = 0; idx < nsample; idx++) { /* choose length of random sequence */ if (fixedlen) len = fixedlen; else do len = (int) Gaussrandom(lenmean, lensd); while (len < 1); /* generate it */ seq = RandomSequence(Alphabet, randomseq, Alphabet_size, len); dsq = DigitizeSequence(seq, len); if (P7ViterbiSize(len, hmm->M) <= RAMLIMIT) sc = P7Viterbi(dsq, len, hmm, NULL); else sc = P7SmallViterbi(dsq, len, hmm, NULL); AddToHistogram(hist, sc); if (sc > max) max = sc; free(seq); free(dsq); } /* Fit an EVD to the observed histogram. * The TRUE left-censors and fits only the right slope of the histogram. * The 9999. is an arbitrary high number that means we won't trim outliers * on the right. */ fitok = ExtremeValueFitHistogram(hist, TRUE, 9999.); /* Return output to master. * Currently we don't send the histogram back, but we could. */ pvm_initsend(PvmDataDefault); pvm_pkint(&slaveidx, 1, 1); pvm_pkint(&hmmidx, 1, 1); PVMPackString(hmm->name); pvm_pkint(&fitok, 1, 1); pvm_pkfloat(&(hist->param[EVD_MU]), 1, 1); pvm_pkfloat(&(hist->param[EVD_LAMBDA]), 1, 1); pvm_pkfloat(&max, 1, 1); pvm_send(master_tid, HMMPVM_RESULTS); /* cleanup */ FreeHistogram(hist); FreePlan7(hmm); } /*********************************************** * Cleanup, return. ***********************************************/ return 0; /* pvm_exit() is called by atexit() registration. */ }
/* Function: main_loop_pvm() * Date: SRE, Wed Aug 19 13:59:54 1998 [St. Louis] * * Purpose: Given an HMM and parameters for synthesizing random * sequences; return a histogram of scores. * (PVM version) * * Args: hmm - an HMM to calibrate. * seed - random number seed * nsample - number of seqs to synthesize * lumpsize- # of seqs per slave exchange; controls granularity * lenmean - mean length of random sequence * lensd - std dev of random seq length * fixedlen- if nonzero, override lenmean, always this len * hist - RETURN: the score histogram * ret_max - RETURN: highest score seen in simulation * extrawatch - RETURN: total CPU time spend in slaves. * ret_nslaves- RETURN: number of PVM slaves run. * * Returns: (void) * hist is alloc'ed here, and must be free'd by caller. */ static void main_loop_pvm(struct plan7_s *hmm, int seed, int nsample, int lumpsize, float lenmean, float lensd, int fixedlen, struct histogram_s **ret_hist, float *ret_max, Stopwatch_t *extrawatch, int *ret_nslaves) { struct histogram_s *hist; int master_tid; int *slave_tid; int nslaves; int nsent; /* # of seqs we've asked for so far */ int ndone; /* # of seqs we've got results for so far */ int packet; /* # of seqs to have a slave do */ float max; int slaveidx; /* id of a slave */ float *sc; /* scores returned by a slave */ Stopwatch_t slavewatch; int i; StopwatchZero(extrawatch); hist = AllocHistogram(-200, 200, 100); max = -FLT_MAX; /* Initialize PVM */ if ((master_tid = pvm_mytid()) < 0) Die("pvmd not responding -- do you have PVM running?"); #if DEBUGLEVEL >= 1 pvm_catchout(stderr); /* catch output for debugging */ #endif PVMSpawnSlaves("hmmcalibrate-pvm", &slave_tid, &nslaves); /* Initialize the slaves */ pvm_initsend(PvmDataDefault); pvm_pkfloat(&lenmean, 1, 1); pvm_pkfloat(&lensd, 1, 1); pvm_pkint( &fixedlen, 1, 1); pvm_pkint( &Alphabet_type, 1, 1); pvm_pkint( &seed, 1, 1); if (! PVMPackHMM(hmm)) Die("Failed to pack the HMM"); pvm_mcast(slave_tid, nslaves, HMMPVM_INIT); SQD_DPRINTF1(("Initialized %d slaves\n", nslaves)); /* Confirm slaves' OK status. */ PVMConfirmSlaves(slave_tid, nslaves); SQD_DPRINTF1(("Slaves confirm that they're ok...\n")); /* Load the slaves */ nsent = ndone = 0; for (slaveidx = 0; slaveidx < nslaves; slaveidx++) { packet = (nsample - nsent > lumpsize ? lumpsize : nsample - nsent); pvm_initsend(PvmDataDefault); pvm_pkint(&packet, 1, 1); pvm_pkint(&slaveidx, 1, 1); pvm_send(slave_tid[slaveidx], HMMPVM_WORK); nsent += packet; } SQD_DPRINTF1(("Loaded %d slaves\n", nslaves)); /* Receive/send loop */ sc = MallocOrDie(sizeof(float) * lumpsize); while (nsent < nsample) { /* integrity check of slaves */ PVMCheckSlaves(slave_tid, nslaves); /* receive results */ SQD_DPRINTF2(("Waiting for results...\n")); pvm_recv(-1, HMMPVM_RESULTS); pvm_upkint(&slaveidx, 1, 1); pvm_upkint(&packet, 1, 1); pvm_upkfloat(sc, packet, 1); SQD_DPRINTF2(("Got results.\n")); ndone += packet; /* store results */ for (i = 0; i < packet; i++) { AddToHistogram(hist, sc[i]); if (sc[i] > max) max = sc[i]; } /* send new work */ packet = (nsample - nsent > lumpsize ? lumpsize : nsample - nsent); pvm_initsend(PvmDataDefault); pvm_pkint(&packet, 1, 1); pvm_pkint(&slaveidx, 1, 1); pvm_send(slave_tid[slaveidx], HMMPVM_WORK); SQD_DPRINTF2(("Told slave %d to do %d more seqs.\n", slaveidx, packet)); nsent += packet; } /* Wait for the last output to come in. */ while (ndone < nsample) { /* integrity check of slaves */ PVMCheckSlaves(slave_tid, nslaves); /* receive results */ SQD_DPRINTF1(("Waiting for final results...\n")); pvm_recv(-1, HMMPVM_RESULTS); pvm_upkint(&slaveidx, 1, 1); pvm_upkint(&packet, 1, 1); pvm_upkfloat(sc, packet, 1); SQD_DPRINTF2(("Got some final results.\n")); ndone += packet; /* store results */ for (i = 0; i < packet; i++) { AddToHistogram(hist, sc[i]); if (sc[i] > max) max = sc[i]; } } /* Shut down the slaves: send -1,-1,-1. */ pvm_initsend(PvmDataDefault); packet = -1; pvm_pkint(&packet, 1, 1); pvm_pkint(&packet, 1, 1); pvm_pkint(&packet, 1, 1); pvm_mcast(slave_tid, nslaves, HMMPVM_WORK); /* Collect stopwatch results; quit the VM; return. */ for (i = 0; i < nslaves; i++) { pvm_recv(-1, HMMPVM_RESULTS); pvm_upkint(&slaveidx, 1, 1); StopwatchPVMUnpack(&slavewatch); SQD_DPRINTF1(("Slave %d finished; says it used %.2f cpu, %.2f sys\n", slaveidx, slavewatch.user, slavewatch.sys)); StopwatchInclude(extrawatch, &slavewatch); } free(slave_tid); free(sc); pvm_exit(); *ret_hist = hist; *ret_max = max; *ret_nslaves = nslaves; 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) ; }