tools/netpipe-2.4-ipv6/PVM.c

/*****************************************************************************/
/* "NetPIPE" -- Network Protocol Independent Performance Evaluator.          */
/* Copyright 1997, 1998 Iowa State University Research Foundation, Inc.      */
/*                                                                           */
/* This program is free software; you can redistribute it and/or modify      */
/* it under the terms of the GNU General Public License as published by      */
/* the Free Software Foundation.  You should have received a copy of the     */
/* GNU General Public License along with this program; if not, write to the  */
/* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.   */
/*                                                                           */
/*     * PVM.c              ---- PVM calls source                            */
/*****************************************************************************/
#include    "netpipe.h"
#include    <pvm3.h>

/**********************************************************************/
/* Set up the communcations system.                                   */
/*    In pvm, this means to join the parallel machine                 */
/**********************************************************************/
int Setup(ArgStruct * p)
{
	p->prot.mytid = pvm_mytid();
#ifdef DEBUG
	printf("My task id is %d \n", p->prot.mytid);
#endif
}

/**********************************************************************/
/* Establish a link with the other processor                          */
/*    In pvm, this means to send a simple message, but to keep the    */
/*    communication line open.  Since the assumption is that we are   */
/*    starting it by hand on the other machine, we don't know what    */
/*    the other task id is.                                           */
/**********************************************************************/
int Establish(ArgStruct * p)
{
	/* Task information for the entire parallel machine (if trans) */
	int tasks_status;
	struct pvmtaskinfo *taskp;
	int ntasks;

	/* Received buffer (if receiver)  */
	int buffer_id;

	/*
	   If we are the transmitting side, go find the other one and send
	   it a message containing our tid. If we are the receiving side,
	   just wait for a message.
	 */
	if (p->tr) {
#ifdef DEBUG
		printf("this is the transmitter\n");
#endif
		tasks_status = pvm_tasks(0, &ntasks, &taskp);
		if (ntasks != 2) {
			printf
			    ("Error, too many processes in parallel machine \n");
			printf("Start a clean machine.  n=%d\n", ntasks);
			exit(-1);
		}

		/* Since there are two tasks, one is ours the other is the receiver */
		p->prot.othertid = -1;
		if (taskp[0].ti_tid == p->prot.mytid) {
			p->prot.othertid = taskp[1].ti_tid;
		}
		if (taskp[1].ti_tid == p->prot.mytid) {
			p->prot.othertid = taskp[0].ti_tid;
		}
		if (p->prot.othertid == -1) {
			printf("Error, cannot find other (receiving) task \n");
			printf("Id's:  %d %d  \n", taskp[0].ti_tid,
			       taskp[1].ti_tid);
		}

		/* Send the receiver a message.  Tell pvm to keep the channel open */

#ifdef DEBUG
		printf("The receiver tid is %d \n", p->prot.othertid);
#endif
		pvm_setopt(PvmRoute, PvmRouteDirect);
		pvm_initsend(PVMDATA);
		pvm_pkint(&p->prot.mytid, 1, 1);
		pvm_send(p->prot.othertid, 1);
	} else {
#ifdef DEBUG
		printf("This is the receiver \n");
#endif

		/* Receive any message from any task */
		buffer_id = pvm_recv(-1, -1);

		if (buffer_id < 0) {
			printf("Error on receive in receiver\n");
			exit(-1);
		}
		pvm_upkint(&p->prot.othertid, 1, 1);
	}
}

/**********************************************************************/
/* Prepare to receive                                                 */
/*    In pvm, you cannot set up a reception buffer ahead of time      */
/**********************************************************************/
void PrepareToReceive(ArgStruct * p)
{
}

/**********************************************************************/
/* Synchronize                                                        */
/*     In pvm, this is not necessary                                  */
/**********************************************************************/
void Sync(ArgStruct * p)
{
}

/**********************************************************************/
/* Send a buffer full of information                                  */
/*    In pvm, we use pvm_pkbyte and then send it.                     */
/**********************************************************************/
void SendData(ArgStruct * p)
{
#ifdef DEBUG
	printf(" In send \n");
#endif
	pvm_initsend(PVMDATA);
	pvm_pkbyte(p->buff, p->bufflen, 1);
	pvm_send(p->prot.othertid, 1);
#ifdef DEBUG
	printf(" message sent.  Size=%d\n", p->bufflen);
#endif
}

/**********************************************************************/
/* Receive a buffer full of information                               */
/**********************************************************************/
void RecvData(ArgStruct * p)
{
#ifdef DEBUG
	printf(" In receive \n");
#endif
	pvm_recv(-1, -1);
	pvm_upkbyte(p->buff, p->bufflen, 1);
#ifdef DEBUG
	printf(" message received .  Size=%d \n", p->bufflen);
#endif
}

/**********************************************************************/
/* Send elapsed time to the other process                             */
/**********************************************************************/
void SendTime(ArgStruct * p, double *t)
{
	pvm_initsend(PVMDATA);
	pvm_pkdouble(t, 1, 1);
	pvm_send(p->prot.othertid, 1);
}

/**********************************************************************/
/* Receive elapsed time from the other process                        */
/**********************************************************************/
void RecvTime(ArgStruct * p, double *t)
{
	pvm_recv(-1, -1);
	pvm_upkdouble(t, 1, 1);
}

/**********************************************************************/
/* Send repeat count to the other process                             */
/**********************************************************************/
void SendRepeat(ArgStruct * p, int rpt)
{
	pvm_initsend(PVMDATA);
	pvm_pkint(&rpt, 1, 1);
	pvm_send(p->prot.othertid, 1);
}

/**********************************************************************/
/* Receiver repeat count from other process                           */
/**********************************************************************/
void RecvRepeat(ArgStruct * p, int *rpt)
{
	pvm_recv(-1, -1);
	pvm_upkint(rpt, 1, 1);
}

/**********************************************************************/
/* Close down the connection.
/**********************************************************************/
int CleanUp(ArgStruct * p)
{
}