示例#1
0
void kill_workers ()
{
	printf ("INFO: Killing the workers\n") ;
	/* kill all the worker */
	pvm_initsend(PvmDataDefault) ;
	pvm_mcast (Worker_tids,NUMBER_OF_WORKERS,KILL) ;

	/* close the window */
	auxCloseWindow() ;

	/* exit pvm */
	pvm_exit() ;

	/* free the pixel buffer */
	free (Pixel_buffer) ;

	/* free the pixel buffer */
	free (Image_buffer) ;

	/* free the worker tids */
	free (Worker_tids) ;

	/* exit the program */
	auxQuit() ;

}
示例#2
0
文件: Manager.c 项目: barroca/Anthill
void sendEof(FilterPlacement *pFilterP) {
    pvm_initsend(PvmDataRaw);
    int tipo_msg = MSGT_EOF;
    pvm_pkint(&tipo_msg, 1, 1);
    //sends the EOF message for all instances of the filter
    pvm_mcast(pFilterP->tids, pFilterP->numInstances, 0);
}
示例#3
0
void mcast_accept_msg(struct state_info info) {
	char diag[200];
	GQueue *waiting_req_q = (*info.my_lift_number == LIFT_1) ? info.waiting_req_q1 : info.waiting_req_q2;
	int len = g_queue_get_length(waiting_req_q);
	// diag_msg(info.mstrtid, info.mytid, "*** 0");
	int *tids = malloc(len * sizeof(int));
	int i = 0;
	sprintf(diag, "*** %d processes awaiting accepts", g_queue_get_length(info.waiting_req_q));
	diag_msg(info.mstrtid, info.mytid, diag);
	while (!g_queue_is_empty(waiting_req_q)) {
		int *tid = g_queue_pop_head(waiting_req_q);
		int *sender_weight_ptr = g_hash_table_lookup(info.skiers_weights, tid);
		int *lift_free = (*info.my_lift_number == LIFT_1) ? info.lift1_free : info.lift2_free;
		*lift_free -= *sender_weight_ptr;
		tids[i] = *tid;
		i++;
		sprintf(diag, "*** mcast MSG_ACCEPT to %d [weight=%d]", *tid, *sender_weight_ptr);
		diag_msg(info.mstrtid, info.mytid, diag);
	}
	*info.local_clock += 1;

	int tag = MSG_ACCEPT;
	pvm_initsend(PvmDataDefault);
	pvm_pkint(&tag, 1, 1);
	pvm_pkint(&info.mytid, 1, 1);
	pvm_pkint(info.local_clock, 1, 1);
	pvm_mcast(tids, len, tag);

	sprintf(diag, "mcast MSG_ACCEPT to %d waiting processes [timestamp=%d]", len, *info.local_clock);
	diag_msg(info.mstrtid, info.mytid, diag);
}
示例#4
0
文件: proccomm.c 项目: e2bsq/Symphony
int msend_msg(int *recipients, int number, int msgtag)
{
   int info;

   PVM_FUNC(info, pvm_mcast(recipients, number, msgtag));

   return(info);
}
示例#5
0
value
Pvm_mcast(value tids, value msgtag)
{
  int *ctids, i, err;
  int n = Wosize_val(tids);

  ctids = (int*)malloc(sizeof(int)*(n+1));
  for(i = 0; i < n; i++) ctids[i] = Int_val(Field(tids, i));

  err = pvm_mcast(ctids, n, Int_val(msgtag));
  free(ctids);
  if (err < 0) TreatError(err);
  return;
}
示例#6
0
void BroadStr(char *str, int tids[], int ntids, int MsgType)
{
  int info;

  info = pvm_initsend(PvmDataDefault);
  if (info) 
  {
     pvm_pkstr(str);
     pvm_mcast(tids,ntids, MsgType);
  }
  else
  {
     fprintf(stderr, "Problems with BroadStr : Message type %d\n", MsgType);
  }
}
示例#7
0
void BroadInt(int IntBuf[], int n, int tid[], int ntid, int MsgType)
{
  int info;

  info = pvm_initsend(PvmDataDefault);
  if (info) 
  {
     pvm_pkint(IntBuf, n, 1);
     pvm_mcast(tid, ntid, MsgType);
  }
  else
  {
     fprintf(stderr, "Problems with BroadInt: Message type %d\n", MsgType);
  }
}
示例#8
0
文件: tools.c 项目: JOravetz/SeisUnix
void BroadINFO(INFO *data, int n, int tid[], int ntid, int MsgType)
{
  int info;

  info = pvm_initsend(PvmDataDefault);

  if (info)
  {
     pvm_pkbyte((char *)data, n*sizeof(INFO), 1);
     pvm_mcast(tid, ntid, MsgType);
  }
  else
  {
     fprintf(stderr, "Problems with BroadINFO : Message type %d\n", MsgType);
  }
}
示例#9
0
void BroadFloat(float *FloatBuf, int n, int tid[], int ntid, int MsgType)
{
  int info;

  info = pvm_initsend(PvmDataDefault);
  /*pvm_pkbyte((char *)FloatBuf, n*sizeof(float), 1);*/
  if (info)
  {
     pvm_pkfloat(FloatBuf, n, 1); /* wences */
     pvm_mcast(tid, ntid, MsgType);
  }
  else
  {
     fprintf(stderr, "Problems with BroadFloat : Message type %d\n", MsgType);
  }
}
示例#10
0
文件: Manager.c 项目: barroca/Anthill
void sendEowToAllInputs(FilterSpec * filterSpec) {
    int i, j;
    // for each input Port of this filter
    for(i = 0; i < filterSpec->numInputs; i++) {
        // i must send 1 Eow for each instace that writes to this filter
        for(j = 0; j < filterSpec->inputs[i]->fromFilter->filterPlacement.numInstances; j++) {
            //send our EOW to listeners on the other side
            int msgType = MSGT_EOW;
            int taskId = -1;

            pvm_initsend(PvmDataRaw);
            pvm_pkint(&msgType, 1, 1);
            pvm_pkint(&taskId, 1, 1);

            pvm_mcast(filterSpec->filterPlacement.tids, filterSpec->filterPlacement.numInstances, filterSpec->inputs[i]->tag);
        }
    }
}
示例#11
0
static void
find_tree_manager(const int my_tid, int &tm_tid)
{
   struct pvmtaskinfo *taskp = 0;
   int ntask = 0;
   pvm_tasks(0, &ntask, &taskp);
   int * tids = new int[ntask];
   int i, k;
   
   for (i = 0, k = 0; i < ntask; ++i) {
      if (taskp[i].ti_ptid != 0)
	 continue; // has a parent, can't be the TM
      if (taskp[i].ti_tid == my_tid)
	 continue; // self
      // Otherwise it could be the TM (might be a console...)
      tids[k++] = taskp[i].ti_tid;
   }

   if (tm_tid != 0) {
      // Check that the given tid is among the candidates
      for (i = 0; i < k; ++i)
	 if (tids[i] == tm_tid)
	    break;
      if (i == k)
	 stop("No TM candidate has the given tid... Aborting.\n");
   } else {
      // Broadcast a query to the candidates
      pvm_initsend(PvmDataRaw);
      pvm_mcast(tids, k, BCP_ARE_YOU_TREEMANAGER);
      // Wait for an answer
      struct timeval tout = {15, 0};
      int bufid = pvm_trecv(-1, BCP_I_AM_TREEMANAGER, &tout);
      if (bufid == 0)
	 stop("No TM candidates replied within 30 seconds... Aborting.\n");
      int bytes = 0, msgtag = 0;
      pvm_bufinfo(bufid, &bytes, &msgtag, &tm_tid);
   }

   delete[] tids;
}
示例#12
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;
                                
}                               
示例#13
0
文件: Manager.c 项目: barroca/Anthill
/// user function:add a new query to a pipeline of filters. Called by user manager runs this.
///	\param layout System Layout.
///	\param work Buffer with a Unit of Work (UoW)
///	\param workSize Unit of Work Size (UoW)
///	\return Zero on success, -1 on error.
int appendWork(Layout *layout, void *work, int workSize) {
#ifdef NO_BARRIER

    // sends work for each filter
    pvm_initsend(PvmDataRaw);
    // First tell that is a mensage of WORK
    int msgType = MSGT_WORK;
    pvm_pkint(&msgType, 1, 1);
    //then attach the work to it
    pvm_pkbyte((char *)work, workSize, 1);

    // for each filter, send his work
    for(i = 0; i < layout->numFilters; i++) {
        FilterPlacement *pFilterP = &(layout->filters[i]->filterPlacement);
        // sends work to all filters of this set
        pvm_mcast(pFilterP->tids, pFilterP->numInstances, 0);
    }

#else
    int i;
    int totalEows = 0, numEowsReceived;
#ifdef ATTACH
    int totalAttachedFilters = 0;
#endif
    int reconf = 0 /** should we reconfigure? */, remainingReconfs = 0; //how many times should we try?

#ifdef VOID_INST
#ifdef BMI_FT
    char instDir[MAX_IDIR_LENGTH];
    sprintf(instDir, "%s/", INST_DIR);
    for (i=0; i < layout->numFilters-1; i++) {
        if (strlen(instDir) >= (MAX_IDIR_LENGTH - 3)) {
            //dont want to overflow this array
            fprintf(stderr, "%s %d: warning, instrumentation directory name too big, truncating to %s\n", __FILE__, __LINE__, instDir);
            break;
        }
        sprintf(instDir, "%s%d-", instDir, layout->filters[i]->filterPlacement.numInstances);
    }
    sprintf(instDir, "%s%d", instDir, layout->filters[layout->numFilters-1]->filterPlacement.numInstances);
    char managerLogFile[MAX_IDIR_LENGTH+20];
    sprintf(managerLogFile, "%s/manager.time", instDir);
    FILE *fp = fopen(managerLogFile, "w");

    struct timeval tv;
    struct timezone tz; //not used
    //get the time
    gettimeofday(&tv, &tz);

    if(fp != NULL)
        fprintf(fp, "1 %ld %ld\n", tv.tv_sec, tv.tv_usec);
#endif
#endif

    //before sending, we check if we received any filter error
    int bufid = pvm_probe(-1, MSGT_FERROR);
    if (bufid != 0) {
        int bytes, tag, tid;
        char *msg;
        pvm_bufinfo(bufid, &bytes, &tag, &tid);
        msg = (char*)malloc(bytes+1);
        pvm_recv(tid, MSGT_FERROR);
        pvm_upkbyte(msg, bytes, 1);
        msg[bytes] = '\0';

        fprintf(stderr, "Manager.c: Error, received death notification\n");
        fprintf(stderr, "Manager.c: %s\n", msg);
        free(msg);
        killAllFilters(layout);
        exit(-1);
    }

    printf("Manager.c: starting work...\n");

    // number of EOWs we expect to receive
    for(i = 0; i < layout->numFilters; i++) {
        totalEows += layout->filters[i]->filterPlacement.numInstances;
#ifdef ATTACH
        if(layout->filters[i]->attached) {
            totalAttachedFilters += layout->filters[i]->filterPlacement.numInstances;
        }
        // TODO:TOSCO:::
        if(layout->filters[i]->attach) return 0;
#endif
    }

    //we stay in this loop while we have to reconfigure
    //usually, this will be only one time, unless a we get some reconf message
    do {

        // sends work for each filter
        pvm_initsend(PvmDataRaw);
        int msgType;
#ifdef VOID_FT
        if(!reconf) {
#endif
            // First tell that is a mensage of WORK
            msgType = MSGT_WORK;
#ifdef VOID_FT
        } else {
            // one fault has occurred
            msgType = MSGT_FT;
        }
#endif
        pvm_pkint(&msgType, 1, 1);
        //then attach the work to it
        pvm_pkbyte((char *)work, workSize, 1);

        reconf = 0; //we are optimistic, always expect to not reconfigure


        // for each filter, send his work
        for(i = 0; i < layout->numFilters; i++) {
            FilterPlacement *pFilterP = &(layout->filters[i]->filterPlacement);
            // sends work to all filters of this set
            pvm_mcast(pFilterP->tids, pFilterP->numInstances, 0);
        }
        /*

        		TaskIdList *finalTaskIdList = NULL, *currentTaskIdList;
        		int filtersThatUseTasks = 0;
        		// Manager receives filter's terminated tasks list
        		for(i = 0; i < layout->numFilters; i++) {
        			FilterPlacement *pFilterP = &(layout->filters[i]->filterPlacement);
#ifdef ATTACH
        			// if this filter is of the attached
        			// type i dont need worry about use Task
        //			if(layout->filters[i]->attached)continue;
#endif
        			for(j = 0; j < pFilterP->numInstances; j++) {
        				int instanceUseTasks = -1;

        				// Get is this filter use tasks
        				pvm_recv(pFilterP->tids[j], 0);
        				pvm_upkint(&instanceUseTasks, 1, 1);
        				layout->filters[i]->useTasks = instanceUseTasks;

#ifdef VOID_FT
        				if (instanceUseTasks) {
        					currentTaskIdList = (TaskIdList *)unpackTaskIdList();

        					//	Para fazer intersecao, gerente ordenar? as listas de tarefas recebidas e utilizar? a fun??o meet() do CrazyMiner/ID3.
        					qsort(currentTaskIdList->vetor, currentTaskIdList->size, sizeof(int), compareTaskId);
        					if(finalTaskIdList == NULL) {
        						finalTaskIdList = currentTaskIdList;
        					} else {
        						// 	Manager makes the intersection of all finished tasks lists
        						finalTaskIdList = taskIdListIntersection(finalTaskIdList, currentTaskIdList);
        						taskIdListDestroy(currentTaskIdList);
        					}
        				}
#endif

        			} // for

        			if (layout->filters[i]->useTasks) filtersThatUseTasks++;
        		}

        		//	Gerente devolve resultado das intersecoes para todas as instancias de todos os filtros.
        		for(i = 0; i < layout->numFilters; i++) {
         			FilterPlacement *pFilterP = &(layout->filters[i]->filterPlacement);
#ifdef ATTACH
        			// if this filter is of the attached
        			// type i dont need worry about use Task
        //TODO			if(layout->filters[i]->attached)continue;
#endif

        			int needForwardTaskMessages = 1;
        			if (filtersThatUseTasks < 2) needForwardTaskMessages = 0;

#ifdef VOID_FT
        			if (layout->filters[i]->useTasks) {
        				// Send if they should forward task messages
        				// and pigback :-) the final task id list
         				pvm_initsend(PvmDataDefault);
         				pvm_pkint(&needForwardTaskMessages, 1, 1);

        				packTaskIdList(finalTaskIdList);
        				pvm_mcast(pFilterP->tids, pFilterP->numInstances, 0);
        			} else {
#endif
        				// Only send if they should forward task messages
         				pvm_initsend(PvmDataDefault);
         				pvm_pkint(&needForwardTaskMessages, 1, 1);
        				pvm_mcast(pFilterP->tids, pFilterP->numInstances, 0);
#ifdef VOID_FT
        			}
#endif
        		}
        		taskIdListDestroy(finalTaskIdList);

        */

        //now we receive the EOWs
        numEowsReceived = 0;

        //now we expect to receive EOW or errors
        while(numEowsReceived < totalEows) {
            //we are open to receive anything from anyone here
            //all messages to the manager should be tagged, so we now their type
            int szMsg = -1;
            int inst_tid = -1;
            int msgTag = -1;
            int bufid = pvm_recv(-1, -1);
            pvm_bufinfo(bufid, &szMsg, &msgTag, &inst_tid);

            switch (msgTag) {
            case (MSGT_EOW): {
                //received EOW, expect this usually
                int instance = -1;
                FilterSpec *pFilter = NULL;

                getFilterByTid(layout, inst_tid, &pFilter, &instance);

                if ((pFilter != NULL) && (instance != -1)) {
                    printf("Manager.c: EOW received from %s, instance %d\n",
                           pFilter->name, instance);
                } else {
                    fprintf(stderr, "Manager.c: unknown EOW received! Shouldnt get here!\n");
                }
                numEowsReceived++;
                break;
            }
            case (MSGT_AEXIT):
            case (MSGT_FERROR): {
                //someone called dsExit or system error at the filter side
                //common cause for this are library not found, wrong initscritpt etc
                char *message = (char*)malloc(sizeof(char)*szMsg+1);
                pvm_upkbyte(message, szMsg, 1);
                message[szMsg] = '\0';

                //the filter and the instance
                FilterSpec *fp = NULL;
                int instance = -1;
                getFilterByTid(layout, inst_tid, &fp, &instance);

                if (msgTag == MSGT_AEXIT) {
                    printf("Manager.c: Filter %s, instance %d(tid %x) called dsExit: %s\n",
                           fp->name, instance, inst_tid, message);
                } else {
                    printf("Manager.c: Filter %s error, instance %d(tid %x) called exit: %s\n",
                           fp->name, instance, inst_tid, message);
                }
                free(message);
                // kill all instances
                killAllFilters(layout);
                exit(-1);
                break;
            }
            //task exited or host crashed
            case (MSGT_TEXIT):
            case (MSGT_HDEL): {
                //we only reconfigure a fixed number of times
                if (remainingReconfs <= 0) {
                    //max number of reconfigurations reached... aborting
                    fprintf(stderr, "Manager.c: max reconfigurations reached, aborting...\n");
                    fflush(stderr);
                    fprintf(stdout, "Manager.c: max reconfigurations reached, aborting...\n");
                    fflush(stdout);
                    reconf = 0;

                    // kill all instances which might be alive
                    killAllFilters(layout);
                    exit(-1);;

                }
#ifdef BMI_FT
                gettimeofday(&tv, &tz);
                fprintf(fp, "2 %ld %ld\n", tv.tv_sec, tv.tv_usec);
#endif

                remainingReconfs--;
                reconf = 1;
                // In case of pvm notification, inst_tid will be t80000000
                int notifiesRecv = 1; // We are receiving the first death notification
                int deadFilterTid = -1;
                FilterSpec *pFilter = NULL;
                int instanceDead = -1;

                // Get the tid and name of the dead filter
                int info = pvm_upkint(&deadFilterTid, 1, 1);
                if (info < 0) pvm_perror("Manager.c: error calling pvm_upkint");

                //discover which filter died
                getFilterByTid(layout, deadFilterTid, &pFilter, &instanceDead);

                if((pFilter != NULL) && (instanceDead != -1)) {
                    if (msgTag == MSGT_TEXIT) {
                        fprintf(stderr, "Manager.c: filter %s: instance %d (tid t%x) of %d is dead!!!\n",
                                pFilter->name, instanceDead, deadFilterTid, pFilter->filterPlacement.numInstances);
                    } else {
                        fprintf(stderr, "Manager.c: filter %s: instance %d (tid t%x) of %d machine's crashed!!!\n",
                                pFilter->name, instanceDead, deadFilterTid, pFilter->filterPlacement.numInstances);
                    }
                }
                printf("Manager.c: starting reconfiguration\n");

                // kill all filters in the pipeline
                killAllFilters(layout);

                if (msgTag == MSGT_HDEL) {
                    //int his case, host died, so we must change layout
                    replaceCrashedHost(layout, pFilter, instanceDead);
                }

#ifdef ATTACH
                if (pFilter->attached) {
                    // In this case, all filters that were killed have to notify
                    // their dead.
                    notifiesRecv = 0;
                }
#endif

                //Flush the streams
                //receive all messages which are about to arrive till we get the death notification
                //pvm order should garantee this
#ifdef ATTACH
                while (notifiesRecv < (totalEows - totalAttachedFilters)) {
#else
                while (notifiesRecv < totalEows) {
#endif
                    int newMsgTag = -1;
                    bufid = pvm_recv(-1, MSGT_TEXIT);
                    info = pvm_bufinfo(bufid, NULL, &newMsgTag, &inst_tid);
                    info = pvm_upkint(&deadFilterTid, 1, 1);
                    if (info < 0) pvm_perror("Manager.c: error calling pvm_upkint");

                    fprintf(stderr, "Manager.c: WARNING: received notification (tag %d) about pvm tid t%x death\n", newMsgTag, deadFilterTid);
                    notifiesRecv++;
                }

#ifdef ATTACH
                if(pFilter->attached) {
                    notifiesRecv = 1;
                } else {
                    notifiesRecv = 0;
                }
                // Receive all EOW messages from the attached filters.
                while(notifiesRecv < totalAttachedFilters) {
                    int newMsgTag = -1;
                    bufid = pvm_recv(-1, MSGT_EOW);
                    info = pvm_bufinfo(bufid, NULL, &newMsgTag, &inst_tid);
                    if (info < 0) pvm_perror("Manager.c: error calling pvm_upkint");

                    fprintf(stderr, "Manager.c: WARNING: received EOW (tag %d) from pvm tid t%x\n", newMsgTag, inst_tid);
                    notifiesRecv++;
                }
#endif
                // probes for remaining machine crash notifications
                while (pvm_probe(-1, MSGT_HDEL) > 0) {
                    int newMsgTag = -1;
                    bufid = pvm_recv(-1, MSGT_HDEL);
                    info = pvm_bufinfo(bufid, NULL, &newMsgTag, &inst_tid);
                    info = pvm_upkint(&deadFilterTid, 1, 1);
                    if (info < 0) pvm_perror("Manager.c: error calling pvm_upkint");

                    fprintf(stderr, "Manager.c: WARNING: received notification (tag %d) about pvm tid t%x machine's crash\n", newMsgTag, deadFilterTid);

                    // Replace the died host
                    FilterSpec *pCrashedFilter = NULL;
                    int crashedInstance = -1;
                    getFilterByTid(layout, deadFilterTid, &pCrashedFilter, &crashedInstance);
                    replaceCrashedHost(layout, pCrashedFilter, crashedInstance);
                }
#ifdef BMI_FT
                updateAllFiltersFaultStatus(layout, FAULT_OTHER_FILTER_INST);
                pFilter->faultStatus = instanceDead;
#endif

                //spawn all filters again
                spawnAllFilter(layout);
#ifdef ATTACH
                // Verifies if the dead filter is an attached. If yes, spawn it.
                if(pFilter->attached == 1) {
                    spawnOneAttachedInstance(layout, pFilter, instanceDead);
                }
#endif
                resetStreams(layout);
                //resend the data
                sendFiltersData(layout);
                //start all over again
                numEowsReceived = 0;

#ifdef BMI_FT
                gettimeofday(&tv, &tz);
                fprintf(fp, "3 %ld %ld\n", tv.tv_sec, tv.tv_usec);
#endif
                break;
            }
#ifdef VOID_TERM
        // One filter instance detected local termination
            case (MSGT_LOCALTERM): {
                int localTermTag; // filter instance local termination tag
                pvm_upkint(&localTermTag, 1, 1);
                verifyGlobalTermination(inst_tid, localTermTag);
                break;
            }
#endif
            default: {
                fprintf(stderr, "Manager.c: error receiving EOW, unknown tag!!!\n");
            }
        } //end switch message tag
        if((msgTag == MSGT_TEXIT) || (msgTag == MSGT_HDEL)) {
            // work should be sent again
            break;
        }
        } //end receiving eows
    }
    while(reconf == 1); //leave this loop if we will not reconfigure

#ifdef BMI_FT
    gettimeofday(&tv, &tz);

    fprintf(fp, "4 %ld %ld\n", tv.tv_sec, tv.tv_usec);
#endif

    printf("Manager.c: Work ended\n\n");
    return 0;
#endif
}


/// Finalize a Void pipeline. Only manager runs this.
int finalizeDs(Layout *layout) {
#ifdef NO_BARRIER

#else
    int i;

    // Envia eof para todos os filtros
    // Primeiro envia se eh work (WORK) ou EOF (END_OF_FILTER)
    pvm_initsend(PvmDataRaw);
    int tipo_msg = MSGT_EOF;
    pvm_pkint(&tipo_msg, 1, 1);
    //sends the EOF message for all instances of the filter
    for(i = 0; i < layout->numFilters; i++) {
        FilterPlacement *pFilterP = &(layout->filters[i]->filterPlacement);
#ifdef ATTACH
        if(layout->filters[i]->attach) continue;// this filter cant not receive a EOF because
        // it needs still runnig
#endif
        pvm_mcast(pFilterP->tids, pFilterP->numInstances, 0);
    }
    destroyLayout(layout);
    pvm_exit();
    return 0;
#endif
}
示例#14
0
/* 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;
}
示例#15
0
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) ;

}