perf/memrw.c

   1 #define _GNU_SOURCE
   2 #include <string.h>
   3 #include <pthread.h>
   4 #include <stdlib.h>
   5 #include <stdio.h>
   6 #include <unistd.h>
   7 #include <sys/types.h>
   8
   9 // memrw provides a simulation of an application
  10 // reading and writing memory, for the sake of tuning helgrind.
  11 // It is a very simple (simplistic) model:
  12 //  * only one thread
  13 //  * only one exe context reading or writing the memory
  14 //  * the working set of the application is unrealistically
  15 //    concentrated on a consecutive nr of MB.
  16 // At this moment, it was just used to tune the EvM data structure
  17 // of helgrind.
  18 // It would be nice to enhance this program to cope with a richer
  19 // model e.g. multiple threads, many different stack traces touching
  20 // the memory, better working set distribution, ...
  21
  22 static int sz_b; // size of a block
  23 static int nr_b; // total nr of blocks used by the program
  24 static int nr_b_ws; // nr_b in program working set
  25 static int nr_loops; // nr of loops reading or writing the ws
  26 static int nr_thr; // nr of threads (hardcoded to 1 currently)
  27 static int nr_repeat; // nr of times we will allocate, use, then free total+ws
  28
  29 // Note: the total nr of MB is what is explicitly allocated.
  30 // On top of that, we have the stacks, local vars, lib vars, ...
  31 // The working set is just the first nr_b_ws blocks of nr_b.
  32
  33 static int verbose = 0;
  34 static unsigned char **t_b; // Pointers to all blocks
  35
  36 static void *memrw_fn(void *v)
  37 {
  38    int loops, m, b;
  39    int dowrite;
  40    int differs = 0;
  41    unsigned char prev = 0;
  42
  43    for (loops = 0; loops < nr_loops; loops++) {
  44       // printf("loop %d dowrite %d\n", loops, dowrite);
  45       // Note: in case of multiple threads, we will have
  46       // to add lock/unlock somewhere in the below, maybe to lock
  47       // the MB we are reading or writing.
  48       for (m = 0; m < nr_b_ws; m++) {
  49          for (b = 0; b < sz_b; b++) {
  50             dowrite = b % 5 == 0;
  51             // Do some write or read operations.
  52             if (dowrite) {
  53                if (t_b[m][b] < 255)
  54                   t_b[m][b] += differs;
  55                else
  56                   t_b[m][b] = 0;
  57             } else {
  58                differs = t_b[m][b] != prev;
  59                prev = t_b[m][b];
  60             }
  61          }
  62       }
  63    }
  64    return NULL;
  65 }
  66
  67 int main (int argc, char *argv[])
  68 {
  69    int a;
  70    int ret;
  71    int i;
  72    int r;
  73    pthread_t thr;
  74
  75    // usage: memrw [-b blocksize default 1MB ]
  76    //              [-t nr_b default 10] [-w nr_b_ws default 10]
  77    //              [-l nr_loops_on_ws default 3]
  78    //              [-r nr_repeat default 1]
  79    //              [-f fan_out default 0]
  80    //              [-v verbosity default 0]
  81    sz_b = 1024 * 1024;
  82    nr_b = 10;
  83    nr_b_ws = 10;
  84    nr_loops = 3;
  85    nr_repeat = 1;
  86    verbose = 0;
  87    for (a = 1; a < argc; a+=2) {
  88       if        (strcmp(argv[a], "-b") == 0) {
  89          sz_b = atoi(argv[a+1]);
  90       } else if (strcmp(argv[a], "-t") == 0) {
  91          nr_b = atoi(argv[a+1]);
  92       } else if (strcmp(argv[a], "-w") == 0) {
  93          nr_b_ws = atoi(argv[a+1]);
  94       } else if (strcmp(argv[a], "-l") == 0) {
  95          nr_loops = atoi(argv[a+1]);
  96       } else if (strcmp(argv[a], "-r") == 0) {
  97          nr_repeat = atoi(argv[a+1]);
  98       } else if (strcmp(argv[a], "-v") == 0) {
  99          verbose = atoi(argv[a+1]);
 100       } else {
 101          printf("unknown arg %s\n", argv[a]);
 102       }
 103    }
 104    if (nr_b_ws > nr_b)
 105       nr_b_ws = nr_b; // to make it easy to do loops combining values
 106
 107    nr_thr = 1;
 108
 109    printf ("total program memory -t %llu MB"
 110            " working set -w %llu MB\n",
 111            ((unsigned long long)nr_b * sz_b)
 112              / (unsigned long long) (1024*1024),
 113            ((unsigned long long)nr_b_ws * sz_b)
 114              / (unsigned long long)(1024*1024));
 115    printf (" working set R or W -l %d times"
 116            " repeat the whole stuff -r %d times\n",
 117            nr_loops,
 118            nr_repeat);
 119
 120    for (r = 0; r < nr_repeat; r++) {
 121       printf ("creating and initialising the total program memory\n");
 122       t_b = malloc(nr_b * sizeof(char*));
 123       if (t_b == NULL)
 124          perror("malloc t_b");
 125       for (i = 0; i < nr_b; i++) {
 126          t_b[i] = calloc(sz_b, 1);
 127          if (t_b[i] == NULL)
 128             perror("malloc t_b[i]");
 129       }
 130
 131       printf("starting thread that will read or write the working set\n");
 132       ret = pthread_create(&thr, NULL, memrw_fn, &nr_thr);
 133       if (ret != 0)
 134          perror("pthread_create");
 135       printf("waiting for thread termination\n");
 136
 137       ret = pthread_join(thr, NULL);
 138       if (ret != 0)
 139          perror("pthread_join");
 140       printf("thread terminated\n");
 141
 142       /* Now, free the memory used, for the next repeat */
 143       for (i = 0; i < nr_b; i++)
 144          free (t_b[i]);
 145       free (t_b);
 146       printf("memory freed\n");
 147    }
 148
 149    return 0;
 150 }