SSSim

/*

 * This is SSSim: the Simple & Stupid Simulator

 *

 *  Copyright (c) 2008 Luca Abeni

 *  Copyright (c) 2008 Csaba Kiraly

 *

 *  This is free software; see gpl-3.0.txt

 */

#include <unistd.h>

#include <stdlib.h>

#include <getopt.h>

#include <stdio.h>

#include <string.h>

#include <time.h>

#include <math.h>

#include "config.h"

#include "core.h"

#include "graph.h"

#include "sched.h"

#include "stats.h"

#include "td.h"

#include "ed.h"

#include "overlay.h"

static struct peer *peers;

extern FILE *resfile;

extern FILE *delayfile;

extern FILE *statusfile;

static FILE *statsfile;

static FILE *graphfile;

char inputgraph[200] = {'\0'};;

int PO_DELAY;    // playout delay

static int num_peers = N;   //number of nodes

static int num_chunks = K;   //number of chunks

static int nn;

static unsigned int seed = 1;

static int buf_size;

static int ts = 2;

static int event_driven = 0;

static int display_neighbourhood;

static void show_usage(char *argv[])

{

  printf("Usage: %s [options]\n", argv[0]);

  printf("Options:\n");

  printf("\t-s <seed>:\t\t\tSet the seed for the random numbers generator\n");

  printf("\t-c <number of chunks>:\t\tSet the number of chunks\n");

  printf("\t-o <neighbourhood size>:\tSet the neighbourhood size (outdegree)\n");

  printf("\t-n <number of peers>:\t\tSet the number of peers\n");

  printf("\t-t <trace file>\n");

  printf("\t-r <results file>:\t\t(dynamically generated during simulation)\n");

  printf("\t-d <delay file>:\t\t(dynamically generated during simulation)\n");

  printf("\t-p <status file>\n");

  printf("\t-P:\t\t\t\tPrint the neighbourhoods\n");

  printf("\t-S <stats file>\n");

  printf("\t-b <chunks buffer size>:\t(playout delay)\n");

  printf("\t-T <Server Period>:\t\tSet the deadline postponing amount\n");

  printf("\t-g <Graph file name>:\t\tSave the overlay as a DOT file\n");

  printf("\t-e:\t\t\t\tSwitch to event-driven mode\n");

  printf("\t-G <Edge Graph file name>:\tImport the overlay from an '.edges' file. Options: [,optimize][,random_source]\n");

  exit(0);

}

static int opts_parse(int argc, char *argv[])

{

  int o;

  while ((o = getopt(argc, argv, "d:c:eo:n:t:r:s:p:S:b:T:g:G:hP")) != -1) {

    switch(o) {

      case 'e':

        event_driven = 1;

        break;

      case 'n':

        num_peers = atoi(optarg);

        break;

      case 'c':

        num_chunks = atoi(optarg);

        break;

      case 'o':

        nn = atoi(optarg);

        break;

      case 'b':

        buf_size = pow(2, ilogb(2 * atoi(optarg) - 1));

        break;

      case 't':

        if (strcmp(optarg, "-") == 0) {

          trace = stdout;

        } else {

          trace = fopen(optarg, "w");

        }

        break;

      case 'r':

        resfile = fopen(optarg, "w");

        break;

      case 'd':

        delayfile = fopen(optarg, "w");

        break;

      case 'p':

        statusfile = fopen(optarg, "w");

        break;

      case 'P':

        display_neighbourhood = 1;

        break;

      case 'S':

        statsfile = fopen(optarg, "w");

        break;

      case 's':

        seed = atoi(optarg);

        if (seed == 0) {

          seed = time(NULL);

        }

        break;

      case 'T':

        ts = atoi(optarg);

        if (ts <= 1) {

          fprintf(stderr, "Invalid Server Period %d\n", ts);

          exit(-1);

        }

        break;

      case 'g':

        graphfile = fopen(optarg, "w");

        break;

      case 'G':

        strcpy(inputgraph, optarg);;

        break;

      case 'h':

        show_usage(argv);

      default:

        fprintf(stderr, "Error: unknown option %c\n", o);

        exit(-1);

      }

  }

  if (nn == 0) {

    nn = num_peers - 1;

  }

  return optind - 1;

}

///==========================================================

///     main

///==========================================================

int main(int argc, char *argv[])

{

  int n;

  struct chunk *ch;

  struct peer source;

  n = opts_parse(argc, argv);

  argc -= n;

  argv += n;

  srand(seed);

  if (strlen(inputgraph) > 0)

          peers = overlay_from_edgefile(inputgraph, &num_peers, &nn, num_chunks, &buf_size, &PO_DELAY, &source);

  else

          peers = overlay_from_parameters(&num_peers, &nn, num_chunks, &buf_size, &PO_DELAY, &source);

  if (!peers)

          return -1;

    if (display_neighbourhood) {

      for (n = 0; n < num_peers; n++) {

        printf("Peer %d Neighbourhood: ", n);

        neighbourhood_print(peers[n].neighbour, peers[n].neigh_size);

        printf("\n");

      }

    }

    if (graphfile) {

      graph_dotprint(graphfile, &source, peers, n);

    }

    if (delayfile) {

        fprintf(delayfile, "Time,Receiver,Chunk,Delay\n");

        fflush(delayfile);

    }

    printf("Buf Size: %d\n", buf_size);

    if(event_driven)

                        ch = ed_loop(peers, num_peers, num_chunks, ts);

    else

                        ch = td_loop(peers, num_peers, num_chunks, ts);

    if (!per_chunk_delay_analysis(NULL, ch, num_chunks, num_peers)){

      printf("sub-optimal distribution!!!\n");

    }

    if (trace){

      per_chunk_delay_analysis(trace, ch, num_chunks, num_peers);

      per_node_delay_analysis(trace,  ch, num_chunks);

    }

    if (statsfile) {

      fprintf(statsfile, "Seed: %u\n", seed);

      per_chunk_delay_analysis(statsfile, ch, num_chunks, num_peers);

      per_node_delay_analysis(statsfile,  ch, num_chunks);

    }

    if (delayfile)

            fclose(delayfile);

  return 0;

}