Esempio n. 1
0
value
Pvm_probe(value tid,value msgtag)
{
  int res=pvm_probe(Int_val(tid),Int_val(msgtag));
  if (res<0) TreatError(res);
  return(Val_int(res));
}
Esempio n. 2
0
/// 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
}
IPstream::IPstream
(
    const int fromProcNo,
    const label bufSize,
    streamFormat format,
    versionNumber version
)
:
    Pstream(bufSize),
    Istream(format, version),
    fromProcNo_(fromProcNo),
    messageSize_(0)
{
    setOpened();
    setGood();

    int bufid, tag, tid;

    // If the buffer size is not specified then probe the incomming message

    if (!bufSize)
    {
        // Probe read buffer until message arrives.
        while (!(bufid = pvm_probe(procID(fromProcNo_), msgType())));

        // When the message arrives find its size
        pvm_bufinfo(bufid, &messageSize_, &tag, &tid);

        // Resize buffer to message size
        buf_.setSize(messageSize_);
    }


    // Read message into buffer

    if
    (
        pvm_precv
        (
            procID(fromProcNo_),
            msgType(),
            buf_.begin(),
            buf_.size(),
            PVM_BYTE,
            &tid, &tag, &messageSize_
        ) != PvmOk
    )
    {
        FatalErrorIn("IPstream::IPstream(const int fromProcNo)")
            << "pvm_precv cannot receive incomming message"
            << ::abort;
    }


    // Check size of message read

    if (messageSize_ > buf_.size())
    {
        FatalErrorIn("IPstream::IPstream(const int fromProcNo)")
            << "buffer (" << buf_.size()
            << ") not large enough for incomming message ("
            << messageSize_ << ')'
            << ::abort;
    }
}
Esempio n. 4
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;
}
Esempio n. 5
0
render_frame()
{
	pixel Pixel_colour ;	/* pixel colour values */

	int X_counter ;		/* X axis counter */
	int Y_counter ;		/* Y axis counter */
	int Block_counter ;          /* block section counter */
	int Worker_counter ;		/* counter for the number of workers done */

	double Block_angle ;		/* angle between blocks */

	viewer Viewpoint ;		/* the viewpoint of the user */

	/* copy the users viewpoint into the working variable */
	Viewpoint.X=User.X ;
	Viewpoint.Y=User.Y ;
	Viewpoint.Z=User.Z ;
	Viewpoint.X_angle=User.X_angle ;
	Viewpoint.Y_angle=User.Y_angle ;
	Viewpoint.Z_angle=User.Z_angle ;

	/* set up the ray angles */
	Block_angle=(X_view_angle/User_view.X_size)*Pixel_buffer_width ;
	Viewpoint.Z_angle=Viewpoint.Z_angle-(X_view_angle/2)-((1/360)*2*M_PI) ;

	for (Block_counter=0;Block_counter<Number_of_workers;Block_counter++)
	{
		/* send out work to worker */
		pvm_initsend (PvmDataDefault) ;

		pvm_pkdouble(&Viewpoint.X,1,1);
		pvm_pkdouble(&Viewpoint.Y,1,1) ;
		pvm_pkdouble(&Viewpoint.Z,1,1) ;
		pvm_pkdouble(&Viewpoint.X_angle,1,1) ;
		pvm_pkdouble(&Viewpoint.Y_angle,1,1) ;
		pvm_pkdouble(&Viewpoint.Z_angle,1,1) ;

		pvm_send (Worker_tids[Block_counter],WORK) ;

		/* set the viewpoint for the next one */
		Viewpoint.Z_angle=Viewpoint.Z_angle+Block_angle ;

	}
	/* end of for loop */
	/* finished sending the data */

	/* set the number of workers finished to zero */
	Worker_counter=0 ;

	/* get the data back */
	while ( Worker_counter < Number_of_workers)
	{
		for (Block_counter=0;Block_counter<Number_of_workers;Block_counter++)
		{
			if (pvm_probe (Worker_tids[Block_counter],DATA))
				/* wait for reply */
			{
				pvm_recv (Worker_tids[Block_counter],DATA) ;
				pvm_upkbyte (Pixel_buffer,Pixel_buffer_size,1) ;

				/* increment the counter for the number of workers that have finished */
				Worker_counter=Worker_counter+1 ;

				/* copy the pixel to the image buffer */
				for (X_counter=0 ;
					X_counter<Pixel_buffer_width ;
					X_counter++ )
				{
					for (Y_counter=0;
						Y_counter<User_view.Y_size ;
						Y_counter++ )
					{
						/* copy pixel data */
						Image_buffer [(Y_counter*User_view.X_size*3)+
							(X_counter*3)+
							(Block_counter*Pixel_buffer_width*3)+
							0]
						=
							Pixel_buffer[(Y_counter*Pixel_buffer_width*3)+
							(X_counter*3)+
							0] ;

						Image_buffer[(Y_counter*User_view.X_size*3)+
							(X_counter*3)+
							(Block_counter*Pixel_buffer_width*3)+
							1]
						=
							Pixel_buffer[(Y_counter*Pixel_buffer_width*3)+
							(X_counter*3)+
							1] ;

						Image_buffer[(Y_counter*User_view.X_size*3)+
							(X_counter*3)+
							(Block_counter*Pixel_buffer_width*3)+
							2]
						=
							Pixel_buffer[(Y_counter*Pixel_buffer_width*3)+
							(X_counter*3)+
							2] ;

						/* end Y loop */
					}

					/* end X loop */
				}
			}
			/* end the if */

		}
		/* end the while loop */

		/* end drawing code */
	}

	/* copy the data to the window */
	glDrawPixels(User_view.X_size,User_view.Y_size,GL_RGB,
		GL_UNSIGNED_BYTE,Image_buffer) ;

	/* flush the graphics pipeline */
	glFlush();

}