read-dragonfly-sample.c 4.37 KB
Newer Older
1 2 3 4 5 6
/* usage mpirun -np n ./read_file_io 
n is the number of input bgp-log files */
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <mpi.h>
7
#define RADIX 8
8 9 10 11 12 13 14 15 16 17

struct dfly_samples
{
   uint64_t terminal_id;
   long fin_chunks_sample;
   long data_size_sample;
   double fin_hops_sample;
   double fin_chunks_time;
   double busy_time_sample;
   double end_time;
18 19
   long fwd_events;
   long rev_events;
20 21
};

22 23 24
struct dfly_rtr_sample
{
    uint64_t router_id;
25 26
    double busy_time[RADIX];
    int64_t link_traffic[RADIX];
27
    double end_time;
28 29
    long fwd_events;
    long rev_events;
30 31
};

32
static struct dfly_samples * event_array = NULL;
33
static struct dfly_rtr_sample * r_event_array = NULL;
34 35 36 37 38

int main( int argc, char** argv )
{
   int my_rank;
   int size;
39
   int i = 0, j = 0;
40
   /*int radix = atoi(argv[1]);
41 42 43 44 45
   if(!radix)
   {
        printf("\n Router radix should be specified ");
        MPI_Finalize();
        return -1;
46
   }*/
47

48
   printf("\n Router radix %d ", RADIX );
49 50 51 52 53 54
   MPI_Init(&argc, &argv);
   MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
   MPI_Comm_size(MPI_COMM_WORLD, &size);

   FILE* pFile;
   FILE* writeFile;
55
   FILE* writeRouterFile;
56 57 58 59

   char buffer_read[64];
   char buffer_write[64];

60
   sprintf(buffer_read, "dragonfly-cn-sampling-%d.bin", my_rank);
61 62 63 64 65 66 67 68
   pFile = fopen(buffer_read, "r+");

   struct stat st;
   stat(buffer_read, &st);
   long in_sz = st.st_size;
   event_array = malloc(in_sz);

   sprintf(buffer_write, "dragonfly-write-log.%d", my_rank);
69
   writeFile = fopen(buffer_write, "w");
70 71 72 73 74 75 76 77

   if(pFile == NULL || writeFile == NULL)
   {
	fputs("\n File error ", stderr);
	return -1;
   }
   fseek(pFile, 0L, SEEK_SET);
   fread(event_array, sizeof(struct dfly_samples), in_sz / sizeof(struct dfly_samples), pFile);
78
   fprintf(writeFile, " Rank ID Finished chunks Data size Finished hops Time spent Busy time Sample end time");
79 80
   for(i = 0; i < in_sz / sizeof(struct dfly_samples); i++)
   {
81
    printf("\n Terminal id %ld ", event_array[i].terminal_id);
82
    fprintf(writeFile, "\n %ld %ld %ld %lf %lf %lf %lf ", event_array[i].terminal_id,
83 84 85 86 87 88 89 90 91
                                                               event_array[i].fin_chunks_sample,
                                                               event_array[i].data_size_sample,
                                                               event_array[i].fin_hops_sample, 
                                                               event_array[i].fin_chunks_time, 
                                                               event_array[i].busy_time_sample, 
                                                               event_array[i].end_time);
   }
    fclose(pFile);
    fclose(writeFile);
92 93 94 95 96 97

    printf("\n Now reading router file ");
    /* Now read the router sampling file */
    char buffer_rtr_read[64];
    char buffer_rtr_write[64];

98
    sprintf(buffer_rtr_read, "dragonfly-router-sampling-%d.bin", my_rank);
99 100 101 102 103 104 105 106
    pFile = fopen(buffer_rtr_read, "r+");

    struct stat st2;
    stat(buffer_rtr_read, &st2);
    long in_sz_rt = st2.st_size;

    r_event_array = malloc(in_sz_rt);

107
    int sample_size = sizeof(struct dfly_rtr_sample);
108
    sprintf(buffer_rtr_write, "dragonfly-rtr-write-log.%d", my_rank);
109
    writeRouterFile = fopen(buffer_rtr_write, "w");
110

111
    if(writeRouterFile == NULL || pFile == NULL)
112 113 114 115 116 117 118
    {
        fputs("\n File error ", stderr);
        MPI_Finalize();
        return -1;
    }
    fseek(pFile, 0L, SEEK_SET);
    fread(r_event_array, sample_size, in_sz_rt / sample_size, pFile); 
119
    fprintf(writeRouterFile, "\n Router ID Busy time per channel Link traffic per channel Sample end time ");
120
    //printf("\n Sample size %d in_sz_rt %ld ", in_sz_rt / sample_size, in_sz_rt);
121 122
    for(i = 0; i < in_sz_rt / sample_size; i++)
    {
123 124
        //printf("\n %ld ", r_event_array[i].router_id);
        fprintf(writeRouterFile, "\n %ld ", r_event_array[i].router_id);
125
        
126
        for(j = 0; j < RADIX; j++ )
127
        {
128 129
            //printf("\n %lf ", r_event_array[i].busy_time[j]);
            fprintf(writeRouterFile, " %lf ", r_event_array[i].busy_time[j]);
130 131
        }
        
132
        for(j = 0; j < RADIX; j++ )
133 134
        {
            //printf("\n link traffic %ld ", r_event_array[i].link_traffic[j]);
135
            fprintf(writeRouterFile, " %ld ", r_event_array[i].link_traffic[j]);
136
        }
137
        fprintf(writeRouterFile, " %lf \n", r_event_array[i].end_time);
138 139
    }
    fclose(pFile);
140
    fclose(writeRouterFile);
141 142
    MPI_Finalize();
}