read-dragonfly-sample.c 4.24 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/* 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>

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

19
20
21
22
23
24
25
26
struct dfly_rtr_sample
{
    uint64_t router_id;
    double * busy_time;
    int64_t * link_traffic;
    double end_time;
};

27
static struct dfly_samples * event_array = NULL;
28
static struct dfly_rtr_sample * r_event_array = NULL;
29
30
31
32
33

int main( int argc, char** argv )
{
   int my_rank;
   int size;
34
35
36
37
38
39
40
41
   int i = 0, j = 0;
   int radix = atoi(argv[1]);
   if(!radix)
   {
        printf("\n Router radix should be specified ");
        MPI_Finalize();
        return -1;
   }
42

43
   printf("\n Router radix %d ", radix );
44
45
46
47
48
49
50
51
52
53
   MPI_Init(&argc, &argv);
   MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
   MPI_Comm_size(MPI_COMM_WORLD, &size);

   FILE* pFile;
   FILE* writeFile;

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

54
   sprintf(buffer_read, "dragonfly-cn-sampling-%d.bin", my_rank);
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
   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);
   writeFile = fopen(buffer_write, "w+");

   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);
   fprintf(writeFile, " Rank ID \t Finished chunks \t Data size \t Finished hops \t Time spent \t Busy time \t  Sample end time");
   for(i = 0; i < in_sz / sizeof(struct dfly_samples); i++)
   {
    fprintf(writeFile, "\n %ld \t %ld \t %ld \t %lf \t %lf \t %lf \t %lf ", event_array[i].terminal_id,
                                                               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);
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

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

    sprintf(buffer_rtr_read, "dragonfly-router-sampling-%d.bin", my_rank);
    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);

    int sample_size = sizeof(struct dfly_rtr_sample) + radix * (sizeof(int64_t) + sizeof(double));
    for(i = 0; i < in_sz_rt / sample_size; i++)
    {
        r_event_array[i].busy_time = malloc(sizeof(double) * radix);
        r_event_array[i].link_traffic = malloc(sizeof(int64_t) * radix);
    }
    sprintf(buffer_rtr_write, "dragonfly-rtr-write-log.%d", my_rank);
    writeFile = fopen(buffer_rtr_write, "w+");

    if(writeFile == NULL || pFile == NULL)
    {
        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); 
    fprintf(writeFile, "\n Router ID \t Busy time per channel \t Link traffic per channel \t Sample end time ");
    for(i = 0; i < in_sz_rt / sample_size; i++)
    {
        printf("\n %ld ", r_event_array[i].router_id);
        fprintf(writeFile, "\n %ld ", r_event_array[i].router_id);
        
        for(j = 0; j < radix; j++ )
        {
            printf("\n %lf ", r_event_array[i].busy_time[j]);
            fprintf(writeFile, " %lf ", r_event_array[i].busy_time[j]);
        }
        
        for(j = 0; j < radix; j++ )
            fprintf(writeFile, " %ld ", r_event_array[i].link_traffic[j]);
        
        fprintf(writeFile, "\n %lf ", r_event_array[i].end_time);
    }
    fclose(pFile);
    fclose(writeFile);
136
137
    MPI_Finalize();
}