TBBT/trace_play/generate_xmgr.c

   1 #include <stdio.h>
   2 #include "rfs_assert.h"
   3
   4 #define EVEN_CHUNK_SIZE_MAX 2
   5 #define CHUNK_NUM_MAX 17
   6 #define FS_SIZE_MB_MAX 81
   7 #define STAGE_NUM_MAX 65
   8 typedef struct {
   9         int flag;
  10         int frag_num;
  11         int avg_frag_distance;
  12         int avg_block_distance;
  13 } result_t;
  14 result_t result[EVEN_CHUNK_SIZE_MAX][CHUNK_NUM_MAX][FS_SIZE_MB_MAX][STAGE_NUM_MAX];
  15
  16 int range_check (int i, int min, int max)
  17 {
  18         if (i<min)
  19                 return 0;
  20         if (i>max)
  21                 return 0;
  22         return 1;
  23 }
  24
  25 int file_ratio, active_ratio, chunk_num, fs_size_MB, even_chunk_size, stage_num;
  26 #define SEQ_NUM 11
  27 int frag_num[SEQ_NUM], td_MB[SEQ_NUM], td[SEQ_NUM], tblock_num[SEQ_NUM], file_num;
  28 main(int argc, char ** argv)
  29 {
  30         char line[1024];
  31         FILE * fp;
  32         unsigned long long distance;
  33         unsigned long long tll;
  34         int avg_frag_distance = 0;
  35         int max_blockno=0, avg_block_distance=0;
  36         char * p;
  37         int sequence[SEQ_NUM]={1,2,5,10,20,30,50,100,200,250,500};
  38         int i;
  39         char fhmap[1024];
  40         result_t * resultp= NULL;
  41
  42
  43         memset (result, 0, sizeof(result));
  44
  45         fp = fopen (argv[1], "r");
  46         if (!fp) {
  47                 perror("open");
  48                 exit(-1);
  49         }
  50         i=-1;
  51         while (fgets(line, sizeof(line), fp)) {
  52                 if (feof(fp))
  53                         break;
  54                 if (strstr(line, "==>")) {
  55                         RFS_ASSERT (resultp == NULL);
  56
  57                         p = strrchr (line, '/');
  58                         if (p==NULL)
  59                                 p=line;
  60                         p = strchr (p, '_');
  61                         if (p==NULL) {
  62                                 printf("error 2\n");
  63                                 exit(-1);
  64                         }
  65                         sscanf (p, "_%d_%d_%d_%d_%d_%d_%s.5 <==\n", &even_chunk_size, &file_ratio, &active_ratio, &chunk_num, &fs_size_MB, &stage_num, fhmap);
  66                         i = chunk_num;
  67                         RFS_ASSERT (range_check (even_chunk_size, 0, EVEN_CHUNK_SIZE_MAX-1));
  68                         RFS_ASSERT (range_check (chunk_num, 0, CHUNK_NUM_MAX-1));
  69                         RFS_ASSERT (range_check (fs_size_MB/100, 0, FS_SIZE_MB_MAX-1));
  70                         RFS_ASSERT (range_check (stage_num, 0, STAGE_NUM_MAX-1));
  71                         resultp = & (result[even_chunk_size][chunk_num][fs_size_MB/100][stage_num]);
  72                         RFS_ASSERT (resultp->flag == 0);
  73                 }
  74                 if (strstr(line, "****")) {
  75
  76                         RFS_ASSERT (resultp);
  77
  78                         sscanf(line, "****total FRAG_NUM %d td_MB %d td %d tblock_num %d max_blockno %d file_num %d avg_frag_distance %d avg_block_distance %d", &frag_num[0], &td_MB[0], &td[0],  &tblock_num[0], &max_blockno, &file_num, &avg_frag_distance, &avg_block_distance);
  79                         sscanf(line, "****total FRAG_NUM %d td_MB %d td %d tblock_num %d max_blockno %d file_num %d avg_frag_distance %d avg_block_distance %d", &(resultp->frag_num), &td_MB[0], &td[0],  &tblock_num[0], &max_blockno, &file_num, &(resultp->avg_frag_distance), &(resultp->avg_block_distance));
  80                         resultp ->flag = 1;
  81
  82                         //printf("%d %d %d %d %d %d\n", chunk_num, frag_num[0], avg_frag_distance, td_MB[0], tblock_num[0], avg_block_distance);
  83
  84                         resultp = NULL;
  85                 }
  86         }
  87
  88         print_xmgr ("avg_block_distance");
  89         print_xmgr ("frag_num");
  90         print_xmgr ("frag_size");
  91         print_xmgr ("avg_frag_distance");
  92         print_xmgr_chunk_stage ("avg_block_distance");
  93 }
  94
  95 int print_y(FILE * fp, result_t * resultp, char * y_axis)
  96 {
  97         if (!strcmp (y_axis, "avg_block_distance")) {
  98                 fprintf (fp, "%d ", resultp->avg_block_distance);
  99         } else if (!strcmp (y_axis, "frag_num")) {
 100                 fprintf (fp, "%d ", resultp->frag_num);
 101         } else if (!strcmp (y_axis, "frag_size")) {
 102                 fprintf (fp, "%f ", (float)tblock_num[0]/(float)resultp->frag_num);
 103         } else if (!strcmp (y_axis, "avg_frag_distance")) {
 104                 fprintf (fp, "%d ", resultp->avg_frag_distance);
 105         } else {
 106                 RFS_ASSERT (0);
 107         }
 108 }
 109         /* statistics for avg_block_distance */
 110 int print_xmgr (char * y_axis)
 111 {
 112         int flag1, flag2;
 113         result_t * resultp;
 114         char name[1024];
 115
 116         FILE * fp = NULL;
 117
 118         for (even_chunk_size = 0; even_chunk_size < EVEN_CHUNK_SIZE_MAX; even_chunk_size ++) {
 119                 for (fs_size_MB = 0; fs_size_MB < FS_SIZE_MB_MAX; fs_size_MB ++) {
 120
 121                         sprintf (name, "xmgr.%d_%d.stage.%s", even_chunk_size, fs_size_MB*100, y_axis);
 122                         fp = NULL;
 123                         flag1 = 1;
 124                         for (stage_num = 0; stage_num < STAGE_NUM_MAX; stage_num++) {
 125                                 flag2 = 1;
 126                                 for (chunk_num = 0; chunk_num < CHUNK_NUM_MAX; chunk_num++) {
 127                                         resultp = &(result[even_chunk_size][chunk_num][fs_size_MB][stage_num]);
 128                                         if (resultp->flag) {
 129                                                 if (flag1) {
 130                                                         printf ("*** even %d fs_size_MB %d X: stage_num Y: %s Lines: different chunk_num ***\n", even_chunk_size, fs_size_MB*100, y_axis);
 131                                                         flag1 = 0;
 132                                                         if (!fp) {
 133                                                                 fp = fopen (name, "w");
 134                                                                 if (!fp)
 135                                                                         RFS_ASSERT (0);
 136                                                         }
 137                                                 }
 138                                                 if (flag2) {
 139                                                         //fprintf (fp, "%d ", file_num/stage_num);
 140                                                         fprintf (fp, "%f ", 1/((float)stage_num));
 141                                                         flag2 = 0;
 142                                                 }
 143                                                 print_y (fp, resultp, y_axis);
 144                                         }
 145                                 }
 146                                 if (!flag2)
 147                                         fprintf (fp, "\n");
 148                         }
 149                         if (fp)
 150                                 fclose (fp);
 151                 }
 152         }
 153
 154         for (even_chunk_size = 0; even_chunk_size < EVEN_CHUNK_SIZE_MAX; even_chunk_size ++) {
 155                 for (fs_size_MB = 0; fs_size_MB < FS_SIZE_MB_MAX; fs_size_MB ++) {
 156                         sprintf (name, "xmgr.%d_%d.chunk.%s", even_chunk_size, fs_size_MB*100, y_axis);
 157                         fp = NULL;
 158                         flag1 = 1;
 159                         for (chunk_num = 0; chunk_num < CHUNK_NUM_MAX; chunk_num++) {
 160                                 flag2 = 1;
 161                                 for (stage_num = 0; stage_num < STAGE_NUM_MAX; stage_num++) {
 162                                         resultp = &(result[even_chunk_size][chunk_num][fs_size_MB][stage_num]);
 163                                         if (resultp->flag) {
 164                                                 if (flag1) {
 165                                                         printf ("*** even %d fs_size_MB %d X: chunk_num Y: %s Lines: different stage_num ***\n", even_chunk_size, fs_size_MB*100, y_axis);
 166                                                         flag1 = 0;
 167                                                         if (!fp) {
 168                                                                 fp = fopen (name, "w");
 169                                                                 if (!fp)
 170                                                                         RFS_ASSERT (0);
 171                                                         }
 172                                                 }
 173                                                 if (flag2) {
 174                                                         fprintf (fp, "%d ", chunk_num);
 175                                                         flag2 = 0;
 176                                                 }
 177                                                 print_y (fp, resultp, y_axis);
 178                                         }
 179                                 }
 180                                 if (!flag2)
 181                                         fprintf (fp, "\n");
 182                         }
 183                         if (fp)
 184                                 fclose (fp);
 185                 }
 186         }
 187 }
 188 int print_xmgr_chunk_stage (char * y_axis)
 189 {
 190         int flag1, flag2;
 191         result_t * resultp;
 192         char name[1024];
 193
 194         FILE * fp = NULL;
 195
 196         for (even_chunk_size = 0; even_chunk_size < EVEN_CHUNK_SIZE_MAX; even_chunk_size ++) {
 197                 for (fs_size_MB = 0; fs_size_MB < FS_SIZE_MB_MAX; fs_size_MB ++) {
 198
 199                         sprintf (name, "xmgr.%d_%d.stage_chunk.%s", even_chunk_size, fs_size_MB*100, y_axis);
 200                         fp = NULL;
 201                         flag1 = 1;
 202                         for (stage_num = STAGE_NUM_MAX-1; stage_num>=0; stage_num--) {
 203                                 flag2 = 1;
 204                                 for (chunk_num = 0; chunk_num < CHUNK_NUM_MAX; chunk_num++) {
 205                                         resultp = &(result[even_chunk_size][chunk_num][fs_size_MB][stage_num]);
 206                                         if (resultp->flag) {
 207                                                 if (flag1) {
 208                                                         printf ("*** even %d fs_size_MB %d X: stage_num Y: %s Lines: different chunk_num ***\n", even_chunk_size, fs_size_MB*100, y_axis);
 209                                                         flag1 = 0;
 210                                                         if (!fp) {
 211                                                                 fp = fopen (name, "w");
 212                                                                 if (!fp)
 213                                                                         RFS_ASSERT (0);
 214                                                         }
 215                                                 }
 216                                                 fprintf (fp, "%f ", chunk_num/((float)stage_num));
 217                                                 print_y (fp, resultp, y_axis);
 218                                                 fprintf (fp, "\n");
 219                                         }
 220                                 }
 221                         }
 222                         if (fp)
 223                                 fclose (fp);
 224                 }
 225         }
 226 }