SSSim

#include <stdio.h>

#include <math.h>

#include "stats.h"

#include "sched.h"

#include "malloc.h"

#define EPSILON 0.0000001

#define DELAY_MAX 2*num_chunks+10

#define ABS(a) (((a) >= 0) ? (a) : -(a))

#define MIN(a,b) ((a) < (b) ? (a) : (b))

extern float convergence_precision;

extern int needs(int k, const struct peer *p);

int chunk_is_active(int k,const struct peer *peers, int num_peers)

{

        int needed = 0;

        int i = 0;

        while (!needed && i < num_peers)

                needed = needs(k, &(peers[i++]));

        return needed;

}

void chunk_stats_print(const struct stats *s, int type)

{

        if (s)

        {

                switch(type) {

                        case PLAIN_STATS:

                                fprintf(stderr,"----------STATS---------------\n");

                                if (s->last_non_active >= 0)

                                {

                                        fprintf(stderr,"Elapsed time: %f\n", s->elapsed_time);

                                        fprintf(stderr,"Last chunk out of the game: %d\n", s->last_non_active);

                                        fprintf(stderr,"Average delay: %f\n", s->avg_delay);

                                        fprintf(stderr,"Average maximum delay: %f\n", s->avg_max_delay);

                                        fprintf(stderr,"Maximum delay: %f\n", s->max_delay);

                                        fprintf(stderr,"Loss: %f\n", s->loss);

                                }

                                else

                                        fprintf(stderr,"All chunks are still active.\n");

                                fprintf(stderr,"------------------------------\n");

                                break;

                        case CSV_STATS:

                                        //Time, last chunk, avg delay, avg max delay, max delay, loss

                                        fprintf(stderr,"%f,%d,%f,%f,%f,%f\n", s->elapsed_time, s->last_non_active, s->avg_delay, s->avg_max_delay, s->max_delay, s->loss);

                                break;

                        default:

                                fprintf(stderr,"ERROR: Statistics format unknown.\n");

                }

        }

}

//calculate per chunk delay statistics

//returns true if optimal

int per_chunk_stats_analysis(const struct chunk *chunks, int num_chunks, int num_peers, double *avg_delay, double *avg_max_delay, double *max_delay, double *loss)

{

    int c;  //chunk, peer

    double d_avg_sum=0;   //average of per chunk delays on each <chunk,node>

    double d_avg_sum_opt=0;   //optimum of d_avg_sum

    double d_max_sum=0;   //average of per chunk max delay on each chunk

    double d_max_sum_opt=0;   //optimum of d_max_sum

    int optimal=1;        // true if optimal

    double d_max_max = 0;

    double dropped = 0;

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

      double d_avg=0;

      d_avg = chunks[c].avg_delay / chunks[c].received;

      d_max_sum += chunks[c].max_delay;

      d_avg_sum += d_avg;

      d_max_max = max(chunks[c].max_delay, d_max_max);

      dropped += (num_peers - chunks[c].received);

    }

    dropped /= (num_chunks * num_peers);

    d_avg_sum /= num_chunks;

    d_avg_sum_opt = ilogb(num_peers) + (double)((num_peers-(1<<ilogb(num_peers)))*2+1)/num_peers;

    if (d_avg_sum-d_avg_sum_opt > EPSILON) optimal = 0;

    d_max_sum /= num_chunks;

    d_max_sum_opt = PO_DELAY;

    if (d_max_sum-d_max_sum_opt > EPSILON) optimal = 0;

    *avg_delay = d_avg_sum;

    *avg_max_delay = d_max_sum;

    *loss = dropped;

    *max_delay = d_max_max;

    return optimal;

}

int chunk_stats_converge(struct stats** s, const struct chunk *chunks, int num_chunks, const struct peer * peers, int num_peers, double elapsed_time, uint32_t window)

{

        struct stats * stat;

        int convergence = 0;

        double avg_delay = -1, avg_max_delay = -1, max_delay = -1, loss = -1;

        int last_chunk, win_start, last_win_start;

        if (*s == NULL)

        {

                (*s) = (struct stats *) malloc (sizeof(struct stats));

                (*s)->last_non_active = -1;

                (*s)->avg_delay = -1;

                (*s)->avg_max_delay = -1;

                (*s)->max_delay = -1;

                (*s)->loss = -1;

        }

        stat = *s;

        stat->elapsed_time = elapsed_time;

        last_chunk = stat->last_non_active;

        while ((stat->last_non_active + 1) < num_chunks &&

                !chunk_is_active(stat->last_non_active + 1, peers, num_peers))

                stat->last_non_active++;

        win_start = window ? (((stat->last_non_active+1)/window)-1) * window : 0;

        last_win_start = window ? (((last_chunk+1)/window)-1) * window : 0;

        //fprintf(stderr,"[DEBUG] start: %d, last start: %d\n", win_start, last_win_start);

        if (!window || (win_start >= 0 && win_start > last_win_start))

        {

                if (!window && !convergence_precision)

                       window = num_chunks;        

                window = window ? window : stat->last_non_active + 1;

                //fprintf(stderr,"[DEBUG] start: %d, length: %d\n", win_start, MIN(num_chunks - win_start, window));

                per_chunk_stats_analysis(chunks + win_start,

                                MIN(num_chunks - win_start, window),

                                num_peers, &avg_delay, &avg_max_delay,

                                &max_delay, &loss);

                if (stat->last_non_active > last_chunk) 

                        convergence = ((float)ABS(avg_delay - stat->avg_delay)) < convergence_precision ? 1 : 0;

                stat->avg_delay = avg_delay;

                stat->max_delay = max_delay;

                stat->avg_max_delay = avg_max_delay;

                stat->loss = loss;

        }

        //fprintf(stderr,"convergence: %d(%f)\n", convergence, convergence_precision);

        return convergence;

}

int status_print(FILE *f, struct peer *peers, int num_peers, struct chunk * chunks, int num_chunks, int t)

{

  int i, j, res;

  if (f) {

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

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

      fprintf(f,"\tPeer %d:", i);

      for (j = 0; j < peers[i].buf_size; j++) {

        if (peers[i].chunks[j]) {

          fprintf(f," %d", peers[i].chunks[j]->chunk);

#if 0

        } else {

          if (t > num_chunks + PO_DELAY)

             printf(" time %d: peer %d misses chunk %d\n", t, i, j);

          res = 0;

#endif

        }

      }

      fprintf(f, "\n");

    }

  }

  res = 1;

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

    //if (!comp(i)) res = 0;

    if (chunks[i].received != num_peers) res = 0;

  }

  return res;

}

int per_chunk_delay_analysis(FILE *stream, const struct chunk *chunks, int num_chunks, int num_peers)

{

    double d_avg_sum=0;   //average of per chunk delays on each <chunk,node>

    double d_max_sum=0;   //average of per chunk max delay on each chunk

    int optimal=1;        // true if optimal

    double dropped = 0;

    double d_max_max = 0;

    double d_max_sum_opt=0;   //optimum of d_max_sum

    double d_avg_sum_opt=0;   //optimum of d_avg_sum

    d_max_sum_opt = PO_DELAY;

    d_avg_sum_opt = ilogb(num_peers) + (double)((num_peers-(1<<ilogb(num_peers)))*2+1)/num_peers;

    optimal = per_chunk_stats_analysis(chunks, num_chunks, num_peers, &d_avg_sum, &d_max_sum, &d_max_max, &dropped);

    if (stream) fprintf(stream, "Average chunk distribution delay %f (optimal %f)\n", d_avg_sum, d_avg_sum_opt);

    if (stream) fprintf(stream, "Maximum chunk distribution delay %f\n", d_max_max);

    if (stream) fprintf(stream, "Average chunk diffusion delay %f (optimal %f)\n", d_max_sum, d_max_sum_opt);

    //if (!stream) printf("\tTESTresults\t%f\t%f\t%f\n", dropped, d_avg_sum, d_max_max);

    return optimal;

}

//calculate per node delay statistics

void per_node_delay_analysis(FILE *stream, struct chunk *chunks, int num_chunks)

{

#if 0

    int p,c;    //peer, chunk

    int d_avg = 0;  //average playout delay

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

      int d = 0;

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

        if (peers[p].chunks[c]->completed - c > d) d = peers[p].chunks[c]->completed - c;

      }

      //fprintf(trace, "Node %d had max delay of %d \n", p, d);

      d_avg += d;

    }

    //fprintf(trace, "Average playout delay %f\n", (double)d_avg/num_peers);

    if (stream) fprintf(stream,"Average playout delay %f (optimal ?)\n", (double)d_avg/num_peers);

#endif

}