/************
**
**  Old arpha-net protocol simulator
**
**  	compile with: 	pcc -o arpanet.par -sync mpc arpanet.pc	-lm
**      Adapted for PARSEC on 10-9-97 by Monnica Terwilliger
**
**************/
#include <stdio.h>
#include <stdlib.h>

#define N 10
#define MAX_CLOCK "1000"
#define MAX_DELAY 10000
#define LOAD 20
#define SEND_TABLE 300
#define MAXINT 2147483647

#define INPUT_FILE "alpha.input"

message Ready {};
message Address {ename router[N];};
message Send_table {};
message Table_info {int source; int delay[N];};
message Packet {int time; int so; int dest; int hops; int time_sent;};
message Start {};
message Source {ename comp;};

entity router (int, int[N][N], ename);
entity computer (int, ename, ename);

int expo(int, unsigned short []);
int urand (int, int, unsigned short []);

struct table {
  int router[N];
  int send_to[N];
  int delay[N];
};


entity driver (int argc, char **argv)
{
  int i, j, input;
  int so, de, time;
  FILE *fp;

  int map[N][N], endsim;
  ename routers[N], comps[N];

  if (argc == 2)
    setmaxclock( atoi(argv[1]));
  else setmaxclock( atoi(MAX_CLOCK));

  if ((fp = fopen (INPUT_FILE, "r")) == NULL)
    fputs("error opening the input file\n",stderr);

/* read in the network topology */
  for (i=0; i<N; i++)
    for (j=0; j<N; j++) {
      fscanf(fp,"%d", &input);
      map[i][j] = input;
    }
  fclose(fp);

/* create the routers */
  for(i=0; i<N; i++) {
    routers[i] = new router (i, map, self) at i;
#ifdef CONS
    add_sorc(routers[i]);
#endif
    comps[i] = new computer (i, routers[i], self) at i;
#ifdef CONS
    add_sorc(comps[i]);
    send Source {comps[i]} to routers[i];
#endif
  }

/* send the address of routers */
  for(i=0; i<N; i++)
    send Address {routers} to routers[i];

#ifdef CONS
  for(i=0; i<2*N; i++) receive (Ready signal);

  for(i=0; i<N; i++) {
    send Start to routers[i];
    send Start to comps[i];
  }

  for(i=0;i<N;i++){
    del_sorc(routers[i]);
    del_sorc(comps[i]);
  }
#endif

/* make the routers exchange tables every SEND_TABLE time unit */
/* also make the stats entity print out the statistics before ending */

  while (1) {
#ifdef CONS
    setlookahead (SEND_TABLE, MAXINT);
#endif
    hold(SEND_TABLE);
    for(i=0; i<N; i++)
      send Send_table {} to routers[i];
  }
}

entity router (int myid, int map[N][N], ename Driver)
{
  int i,j;
  struct table tb;
  unsigned short seed[3];

  message Address address;
  message Table_info table_info;
  message Packet packet;
  message Source source;

  seed[0] = seed[1] = seed[2] = myid;

  for(i=0; i<N; i++) {
#ifdef DEBUG
printf("%d ", map[myid][i]);
#endif
    tb.send_to[i] = i;
    if (map[myid][i] != 0) {
      tb.router[i] = map[myid][i];
      tb.delay[i] = map[myid][i];
    } else {
      tb.router[i] = MAX_DELAY;
      tb.delay[i] = MAX_DELAY;
    }
  }

#ifdef CONS
  receive (Source source)
  {     add_sorc(source.comp)};
#endif

  receive (Address tmp) {address = tmp;}

#ifdef CONS
  /* set up the topology */
  for(i=0; i<N; i++) {
    if ((myid != i) && (map[i][myid] != 0)) add_sorc(address.router[i]);
    if ((myid != i) && (map[myid][i] != 0)) add_dest(address.router[i]);
  }

  send Ready {} to Driver; 
  receive (Start signal);
  del_dest(Driver);
#endif

#ifdef DEBUG
printf("\n");
printf("running simulation : id = %d\n",myid);
#endif

  while (1) {
#ifdef CONS
    setlookahead(1, atoi (MAXINT));
#endif
      receive (Send_table send_table) {
#ifdef CONS
    setlookahead(N, atoi (MAXINT));
#endif
          hold(N);  /* it takes N time units to broad cast */
          for(i=0; i<N; i++)
            if ((i != myid) && (map[myid][i] != 0))
              send Table_info {myid, tb.delay} to address.router[i];
        } or receive (Table_info temp) {
          table_info = temp;
#ifdef CONS
    setlookahead(1, atoi (MAXINT));
#endif
          hold(1); /* it takes 1 time unit to process the table */
          for (i=0; i<N; i++)
            if ((table_info.delay[i]+tb.router[table_info.source])
                 < tb.delay[i]) {
              tb.delay[i] = table_info.delay[i]
                            + tb.router[table_info.source];
              tb.send_to[i] = table_info.source;
            }
#ifdef DEBUG
printf("table received: id = %d\n", myid);
for(i=0; i<N; i++)
  printf("%d ",tb.delay[i]);
printf("\n");
#endif
        } or receive (Packet temp) {
          packet = temp;
#ifdef DEBUG
printf("packet received, id = %d, dest = %d; clock = %d\n",myid,packet.dest,packet.time);
#endif
#ifdef CONS
        setlookahead(1, atoi (MAXINT));
#endif
          hold(1); /* it takes 1 time unit to process the packet */
          if (packet.dest == myid) {

            /* collect statistics here */
#ifdef DEBUG
            printf("received, sim time = %d, so = %d, de = %d, hops = %d\n",
                   simclock(),packet.so,packet.dest,packet.hops);
#endif
          } else if (tb.delay[packet.dest] < MAX_DELAY) {
#ifdef CONS
            setlookahead (map[myid][tb.send_to[packet.dest]], atoi (MAXINT));;
#endif
            hold(map[myid][tb.send_to[packet.dest]]);
#ifdef DEBUG
printf(" dest = %d, forward to %d\n",packet.dest, tb.send_to[packet.dest]);
#endif
         send Packet {packet.time, packet.so, packet.dest, packet.hops+1,
                      packet.time_sent}
              to address.router[tb.send_to[packet.dest]];
          } else {
#ifdef DEBUG
printf("sim time = %d, so = %d, de = %d, can't rout packet\n"
                      ,simclock(), packet.so, packet.dest);
#endif
          }
        }
  }
}

entity computer (int myid, ename router, ename Driver)
{
  int de, i, time;
  unsigned short seed[3];

  seed[0] = seed[1] = seed[2] = myid;

#ifdef CONS
  add_dest(Driver);
  add_dest(router);

  send Ready {} to driver;
  receive (Start signal) {};
  del_dest(Driver);
#endif

  while(1) {
    i=expo(LOAD,seed);
#ifdef CONS
    setlookahead (i, atoi (MAXINT));
#endif
    hold (i);
    de = urand(0,N-1,seed);
    while (myid == de) de = urand(0,N-1,seed);
    time = simclock();
/*#ifdef DEBUG
printf("hold for %d units, send msg at %d, so = %d, de = %d\n",i,time,myid,de);
#endif*/
    send Packet {time, myid, de, 0, time} to router;
  }
}

int expo(mean, seed)
int mean;
unsigned short seed[3];
{
  extern double erand48();
  extern double log();
  return ((int)((-log((double)(1.0-erand48(seed)))) * ((double) mean)) +1);
}

int urand (l, r, seed)
int l,r;
unsigned short seed[3];
{
  extern double erand48();

  return (int)((r-l)*erand48(seed))+l;
}