static void TestProbe()
/*
Process 0 sleeps for 20 seconds and then sends each
process a message. The other processes sleep for periods
of 2 seconds and probes until it gets a message. All processes
respond to process 0 which recieves using a wildcard probe.
*/
{
long type_syn = 32;
long type_msg = 33;
long type_ack = 34;
long me = NODEID_();
char buf;
long lenbuf = sizeof buf;
long sync = 1;
if (me == 0) {
(void) printf("Probe test ... processes should sleep for 20s only\n");
(void) printf("----------\n\n");
(void) fflush(stdout);
}
SYNCH_(&type_syn);
if (me == 0) {
long nproc = NNODES_();
long anyone = -1;
long ngot = 0;
long node;
(void) sleep((unsigned) 20);
for (node=1; node<nproc; node++) {
SND_(&type_msg, &buf, &lenbuf, &node, &sync);
(void) printf(" Sent message to %ld\n", (long)node);
(void) fflush(stdout);
}
while (ngot < (nproc-1))
if (PROBE_(&type_ack, &anyone)) {
RCV_(&type_ack, &buf, &lenbuf, &lenbuf, &anyone, &node, &sync);
(void) printf(" Got response from %ld\n", (long)node);
(void) fflush(stdout);
ngot++;
}
}
else {
long node = 0;
while (!PROBE_(&type_msg, &node)) {
(void) printf(" Node %ld sleeping\n", (long)me);
(void) fflush(stdout);
(void) sleep((unsigned) 2);
}
RCV_(&type_msg, &buf, &lenbuf, &lenbuf, &node, &node, &sync);
SND_(&type_ack, &buf, &lenbuf, &node, &sync);
}
SYNCH_(&type_syn);
}
static void Hello()
/*
Everyone says hi to everyone else
*/
{
char buf[30];
long lenbuf = sizeof buf;
long type=19 | MSGCHR;
long node, kode, nodefrom, lenmes;
long sync = 1;
if (NODEID_() == 0) {
(void) printf("Hello test ... show network integrity\n----------\n\n");
(void) fflush(stdout);
}
for (node = 0; node<NNODES_(); node++) {
if (node == NODEID_()) {
for (kode = 0; kode<NNODES_(); kode++) {
(void) sprintf(buf, "Hello to %ld from %ld", (long)kode, (long)NODEID_());
if (node != kode)
SND_(&type, buf, &lenbuf, &kode, &sync);
}
}
else {
RCV_(&type, buf, &lenbuf, &lenmes, &node, &nodefrom, &sync);
(void) printf("me=%ld, from=%ld: %s\n",(long)NODEID_(), (long)node, buf);
(void) fflush(stdout);
}
}
}
void SendData(ArgStruct *p)
{
long type = MSGCHR;
long sync_snd = 0;
long lbufflen = p->bufflen;
SND_( &type, p->s_ptr, &lbufflen, &p->prot.nbor, &sync_snd);
}
void tcg_snd(long type, void *buf, long lenbuf, long node, long sync)
{
long atype = type;
long alenbuf = lenbuf;
long anode = node;
long async = sync;
SND_(&atype, buf, &alenbuf, &anode, &async);
}
void tcg_snd(long type, void *buf, long lenbuf, long node, long sync)
{
Integer atype = type;
Integer alenbuf = lenbuf;
Integer anode = node;
Integer async = sync;
SND_(&atype, buf, &alenbuf, &anode, &async);
}
void SendTime(ArgStruct *p, double *t)
{
long ttype;
long lenbuf;
long sync_snd = 1;
ttype = MSGDBL;
lenbuf = sizeof(double);
SND_( &ttype, t, &lenbuf, &p->prot.nbor, &sync_snd);
}
void SendRepeat(ArgStruct *p, int n)
{
long ttype;
long lenbuf;
long sync_snd = 1;
ttype = MSGINT;
lenbuf = sizeof(int);
SND_( &ttype, &n, &lenbuf, &p->prot.nbor, &sync_snd);
}
void NextValueServer()
/*
This runs as process SR_n_proc and provides load balancing service.
*/
{
long cnt = 0; /* actual counter */
long lencnt = sizeof cnt; /* length of cnt */
long ndone = 0; /* no. finished for this loop */
long ntermin = 0; /* no. terminated so far (pend) */
long node = -1; /* select any node */
long type = TYPE_NXTVAL; /* message type */
long buf[2]; /* buffer to get values */
long lenbuf = sizeof buf; /* length of buffer */
long mproc; /* no. of processes running loop */
long nval; /* no. of values requested */
long done_list[MAX_PROCESS]; /* list of processes finished with this loop */
long sync = 1; /* all info goes synchronously */
long on=0;
long lenmes, nodefrom;
SR_exit_on_error = FALSE; /* Want to return no matter what */
if (setjmp(SR_jmp_buf)) { /* Error should long jump to here */
/* (void) printf("Error long jumped to NXTVAL ... returning.\n"); */
SR_exit_on_error = TRUE;
return;
}
SETDBG_(&on);
while (1) {
/* Wait for input from any node */
RCV_(&type, (char *) buf, &lenbuf, &lenmes, &node, &nodefrom, &sync);
if (lenmes != lenbuf) {
Error("NextValueServer: lenmes != lenbuf", lenmes);
return; /* Never actually gets here as does long jump */
}
mproc = buf[0];
nval = buf[1];
if (DEBUG_)
(void) printf("NVS: from=%ld, mproc=%ld, ndone=%ld, ntermin=%ld\n",
nodefrom, mproc, ndone, ntermin);
if (mproc == 0) {
/* Sending process is about to terminate. Send reply and disable
sending to him. If all processes have finished return.
Modified so that all processes block on waiting for message
from nxtval server before terminating. nxtval only lets
everyone go when all have registered termination.
This is so that processes do not close their sockets
while another process is doing a RCV from any node (which
results in an unavoidable error condition). */
if (++ntermin == NNODES_()) {
(void) signal(SIGCHLD, SIG_DFL); /* Will be dying naturally */
for (node=0; node<NNODES_(); node++) {
SND_(&type, (char *) &cnt, &lencnt, &node, &sync);
(void) close(SR_proc_info[node].sock);
SR_proc_info[node].sock = -1;
}
return;
}
}
else if (mproc > 0) {
/* This is what we are here for */
SND_(&type, (char *) &cnt, &lencnt, &nodefrom, &sync);
cnt += nval;
}
else if (mproc < 0) {
/* This process has finished the loop. Wait until all mproc
processes have finished before releasing it */
done_list[ndone++] = nodefrom;
if (ndone == -mproc) {
while (ndone--) {
nodefrom = done_list[ndone];
SND_(&type, (char *) &cnt, &lencnt, &nodefrom, &sync);
}
cnt = 0;
ndone = 0;
}
}
}
}
