SSSim

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <stdint.h>

#include "core.h"

#include "sched.h"

#include "stats.h"

#include "td.h"

FILE *resfile;

FILE *delayfile;

FILE *statusfile;

static int ts;

static struct peer *peers;

static struct chunk *chunks;

static int num_peers;

extern float convergence_precision;

extern uint32_t analysis_window;

extern float netload;

int comp(int chunk)

{

  return (chunks[chunk].received == num_peers);

}

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

///     the network model :)

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

//chunks propagate through receiver's recv_chunks array

static void chunk_send(int k, struct peer *p, int dl)

{

#if 0

  if (p->chunks[k]) {

    fprintf(stderr, "Error: sending chunk %d to %d which already has it!\n", k, p->id);

    exit(-1);

  }

#endif

  if (p->recv_chunks[win_idx(p, k)]) {

    fprintf(stderr, "Error: sending chunk %d (idx: %d) to %d which already receives it (%d)!\n", k, win_idx(p, k), p->id, p->recv_chunks[k]->chunk);

    exit(-1);

  }

  if (p->chunks[win_idx(p, k)]) {

    p->recv_chunks[win_idx(p, k)] = p->chunks[win_idx(p, k)];

    p->chunks[win_idx(p, k)] = NULL;

  } else {

    p->recv_chunks[win_idx(p, k)] = malloc(sizeof(struct chunk_instance));

  }

  p->recv_chunks[win_idx(p, k)]->dl = dl;

  p->recv_chunks[win_idx(p, k)]->chunk = k;

  //CACHE latest_not_needed

  p->latest_not_needed = max(k,p->latest_not_needed);

  chunks[k].received += 1;

}

static int receive(int t)

{

  int p, c;

  int cnt;

  cnt = 0;

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

    for (c = 0; c < peers[p].buf_size; c++) {

      int idx = win_idx(&peers[p], c /* + peers[p].buf_size*/);

      if (peers[p].recv_chunks[idx]) {

        cnt++;

        peers[p].chunks[idx] = peers[p].recv_chunks[idx];

        peers[p].chunks[idx]->completed = t;

        peers[p].recv_chunks[idx] = NULL;

        chunks[peers[p].chunks[idx]->chunk].avg_delay += t - peers[p].chunks[idx]->chunk;

        chunks[peers[p].chunks[idx]->chunk].max_delay = max(chunks[peers[p].chunks[idx]->chunk].max_delay, t - peers[p].chunks[idx]->chunk);

        if (delayfile) {

            fprintf(delayfile, "%d,%d,%d,%d\n", t, p, peers[p].chunks[idx]->chunk,  t - peers[p].chunks[idx]->chunk);

            fflush(delayfile);

        }

        if (chunks[peers[p].chunks[idx]->chunk].received == num_peers) {

          if (resfile) {

            fprintf(resfile, "Chunk %d received at %d in %d\n", peers[p].chunks[idx]->chunk, t, t - peers[p].chunks[idx]->chunk);

            fflush(resfile);

          }

        }

      }

    }

  }

#if 0

  for (c = 0; c < num_chunks; j++) {

    if (completed[c] == 0) {

      completed[c] = t;

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

        if (peers[p].chunks[c] == NULL) {

          completed[c] = 0;

        }

      }

    }

  }

#endif

  return cnt;

}

struct chunk *td_loop(struct peer *p, int np, int num_chunks, int server_period)

{

  int done, t, offers;

  struct stats * stat = NULL;

  offers = ((int)netload) > 0 ? ((int)netload) : 1;

  chunks = malloc(num_chunks * sizeof(struct chunk));

  if (chunks == NULL) {

    perror("MAlloc");

    return NULL;

  }

  memset(chunks, 0, num_chunks * sizeof(struct chunk));

  num_peers = np;

  peers = p;

  ts = server_period;

  done = 0; t = 0;  // t is the time in chunk time (discrete)

  while (!done) {

    int i, j;

    struct peer *target;

    // loop stuff

    done = ((t != 0) && (receive(t) == 0));

    status_print(statusfile, peers, num_peers, chunks, num_chunks, t);

    if (trace) fprintf(trace, "Time %d:\n", t);

    // source seeding

    source_send(t, &target);

    if (target != NULL) {

      chunk_send(t, target, t + ts);

    }

    // peer offering

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

      int chunk;

      for (j = 0; j < offers; j++)

      {

              peer_send(&peers[i], t, &chunk, &target);

              if (target != NULL) {

                peers[i].chunks[win_idx(&peers[i], chunk)]->dl += ts;

                chunk_send(chunk, target, peers[i].chunks[win_idx(&peers[i], chunk)]->dl);

              }

      }

    }

    t++;

    if (convergence_precision && chunk_stats_converge(&stat, chunks, num_chunks, peers, num_peers, t - 1, analysis_window))

            done = 1;

  }

  chunk_stats_converge(&stat, chunks, num_chunks, peers, num_peers, t - 1, analysis_window);

  chunk_stats_print(stat, CSV_STATS);

  if (stat) free(stat);

  return chunks;

}