/************
**
**  Old arpha-net protocol simulator
**
**
**
** "@(#)alpha.m 1.1 - 96/01/05"
**************/
#include "maisie.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 "topology"
entity driver {argc,argv}
int argc;
char **argv;
{
  int i, j, input;
  int so, de, time;
  FILE *fp;

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

  message ready ready;

  if (argc == 2)
    maxclock(argv[1]);
  else maxclock(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]);
    invoke routers[i] with source {comps[i]};
#endif
  }

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

#ifdef CONS
  for(i=0; i<2*N; i++) wait until mtype(ready);

  for(i=0; i<N; i++) {
    invoke routers[i] with start;
    invoke comps[i] with start;
  }

  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
    zzcla(SEND_TABLE);
    zzmaxla(MAXINT);
#endif
    hold(SEND_TABLE);
    for(i=0; i<N; i++)
      invoke routers[i] with send_table;
  }
}

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

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

  message address {ename router[N];} address;
  message send_table send_table;
  message table_info {int source; int delay[N];} table_info;
  message packet {int time; int so; int dest; int hops; int time_sent;} packet;
  message start start;
  message source {ename comp;} 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
  wait until mtype(source);
  add_sorc(msg.source.comp);
#endif

  wait until mtype(address);
  address = msg.address;

#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]);
  }

  invoke driver with ready;
  wait until mtype(start);
  del_dest(driver);
#endif

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

  while (1) {
#ifdef CONS
    zzcla(1);
    zzmaxla(MAXINT);
#endif
      wait until {
        mtype (send_table) {
#ifdef CONS
          zzcla(N);
          zzmaxla(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))
              invoke address.router[i] with table_info { myid, tb.delay};
        } or mtype (table_info) {
          table_info = msg.table_info;
#ifdef CONS
          zzcla(1);
          zzmaxla(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 mtype (packet) {
          packet = msg.packet;
#ifdef DEBUG
printf("packet received, id = %d, dest = %d; clock = %d\n",myid,packet.dest,packet.time);
#endif
#ifdef CONS
          zzcla(1);
          zzmaxla(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",
                   sclock(),packet.so,packet.dest,packet.hops);
#endif
          } else if (tb.delay[packet.dest] < MAX_DELAY) {
#ifdef CONS
            zzcla(map[myid][tb.send_to[packet.dest]]);
            zzmaxla(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
            invoke address.router[tb.send_to[packet.dest]]
                 with packet {packet.time,
                              packet.so,
                              packet.dest,
                              packet.hops+1,
                              packet.time_sent};
          } else {
#ifdef DEBUG
printf("sim time = %d, so = %d, de = %d, can't rout packet\n"
                      ,sclock(), packet.so, packet.dest);
#endif
          }
        }
      }
  }
}

entity computer {myid, router, driver}
int myid;
ename router, driver;
{
  int de, i, time;
  unsigned short seed[3];
  message start start;

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

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

  invoke driver with ready;
  wait until mtype(start);
  del_dest(driver);
#endif

  while(1) {
    i=expo(LOAD,seed);
#ifdef CONS
    zzcla(i);
    zzmaxla(MAXINT);
#endif
    hold (i);
    de = urand(0,N-1,seed);
    while (myid == de) de = urand(0,N-1,seed);
    time = sclock();
/*#ifdef DEBUG
printf("hold for %d units, send msg at %d, so = %d, de = %d\n",i,time,myid,de);
#endif*/
    invoke router with packet {time,myid,de,0,time};
  }
}

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;
}