IDA_new/gf-complete/tools/gf_inline_time.c

   1 /*
   2  * GF-Complete: A Comprehensive Open Source Library for Galois Field Arithmetic
   3  * James S. Plank, Ethan L. Miller, Kevin M. Greenan,
   4  * Benjamin A. Arnold, John A. Burnum, Adam W. Disney, Allen C. McBride.
   5  *
   6  * gf_inline_time.c
   7  *
   8  * Times inline single multiplication when w = 4, 8 or 16
   9  */
  10
  11 #include <stdio.h>
  12 #include <stdint.h>
  13 #include <string.h>
  14 #include <stdlib.h>
  15 #include <time.h>
  16 #include <sys/time.h>
  17
  18 #include "gf_complete.h"
  19 #include "gf_rand.h"
  20
  21 void
  22 timer_start (double *t)
  23 {
  24     struct timeval  tv;
  25
  26     gettimeofday (&tv, NULL);
  27     *t = (double)tv.tv_sec + (double)tv.tv_usec * 1e-6;
  28 }
  29
  30 double
  31 timer_split (const double *t)
  32 {
  33     struct timeval  tv;
  34     double  cur_t;
  35
  36     gettimeofday (&tv, NULL);
  37     cur_t = (double)tv.tv_sec + (double)tv.tv_usec * 1e-6;
  38     return (cur_t - *t);
  39 }
  40
  41 void problem(char *s)
  42 {
  43   fprintf(stderr, "Timing test failed.\n");
  44   fprintf(stderr, "%s\n", s);
  45   exit(1);
  46 }
  47
  48 void usage(char *s)
  49 {
  50   fprintf(stderr, "usage: gf_inline_time w seed #elts iterations - does timing of single multiplies\n");
  51   fprintf(stderr, "\n");
  52   fprintf(stderr, "Legal w are: 4, 8 or 16\n");
  53   fprintf(stderr, "\n");
  54   fprintf(stderr, "Use -1 for time(0) as a seed.\n");
  55   fprintf(stderr, "\n");
  56   if (s != NULL) fprintf(stderr, "%s\n", s);
  57   exit(1);
  58 }
  59
  60 int main(int argc, char **argv)
  61 {
  62   int w, j, i, size, iterations;
  63   gf_t      gf;
  64   double timer, elapsed, dnum, num;
  65   uint8_t *ra = NULL, *rb = NULL, *mult4, *mult8;
  66   uint16_t *ra16 = NULL, *rb16 = NULL, *log16, *alog16;
  67   time_t t0;
  68
  69   if (argc != 5) usage(NULL);
  70   if (sscanf(argv[1], "%d", &w) == 0) usage("Bad w\n");
  71   if (w != 4 && w != 8 && w != 16) usage("Bad w\n");
  72   if (sscanf(argv[2], "%ld", &t0) == 0) usage("Bad seed\n");
  73   if (sscanf(argv[3], "%d", &size) == 0) usage("Bad #elts\n");
  74   if (sscanf(argv[4], "%d", &iterations) == 0) usage("Bad iterations\n");
  75   if (t0 == -1) t0 = time(0);
  76   MOA_Seed(t0);
  77
  78   num = size;
  79
  80   gf_init_easy(&gf, w);
  81
  82   printf("Seed: %ld\n", t0);
  83
  84   if (w == 4 || w == 8) {
  85     ra = (uint8_t *) malloc(size);
  86     rb = (uint8_t *) malloc(size);
  87
  88     if (ra == NULL || rb == NULL) { perror("malloc"); exit(1); }
  89   } else if (w == 16) {
  90     ra16 = (uint16_t *) malloc(size*2);
  91     rb16 = (uint16_t *) malloc(size*2);
  92
  93     if (ra16 == NULL || rb16 == NULL) { perror("malloc"); exit(1); }
  94   }
  95
  96   if (w == 4) {
  97     mult4 = gf_w4_get_mult_table(&gf);
  98     if (mult4 == NULL) {
  99       printf("Couldn't get inline multiplication table.\n");
 100       exit(1);
 101     }
 102     elapsed = 0;
 103     dnum = 0;
 104     for (i = 0; i < iterations; i++) {
 105       for (j = 0; j < size; j++) {
 106         ra[j] = MOA_Random_W(w, 1);
 107         rb[j] = MOA_Random_W(w, 1);
 108       }
 109       timer_start(&timer);
 110       for (j = 0; j < size; j++) {
 111         ra[j] = GF_W4_INLINE_MULTDIV(mult4, ra[j], rb[j]);
 112       }
 113       dnum += num;
 114       elapsed += timer_split(&timer);
 115     }
 116     printf("Inline mult:   %10.6lf s   Mops: %10.3lf    %10.3lf Mega-ops/s\n",
 117            elapsed, dnum/1024.0/1024.0, dnum/1024.0/1024.0/elapsed);
 118
 119   } else if (w == 8) {
 120     mult8 = gf_w8_get_mult_table(&gf);
 121     if (mult8 == NULL) {
 122       printf("Couldn't get inline multiplication table.\n");
 123       exit(1);
 124     }
 125     elapsed = 0;
 126     dnum = 0;
 127     for (i = 0; i < iterations; i++) {
 128       for (j = 0; j < size; j++) {
 129         ra[j] = MOA_Random_W(w, 1);
 130         rb[j] = MOA_Random_W(w, 1);
 131       }
 132       timer_start(&timer);
 133       for (j = 0; j < size; j++) {
 134         ra[j] = GF_W8_INLINE_MULTDIV(mult8, ra[j], rb[j]);
 135       }
 136       dnum += num;
 137       elapsed += timer_split(&timer);
 138     }
 139     printf("Inline mult:   %10.6lf s   Mops: %10.3lf    %10.3lf Mega-ops/s\n",
 140            elapsed, dnum/1024.0/1024.0, dnum/1024.0/1024.0/elapsed);
 141   } else if (w == 16) {
 142     log16 = gf_w16_get_log_table(&gf);
 143     alog16 = gf_w16_get_mult_alog_table(&gf);
 144     if (log16 == NULL) {
 145       printf("Couldn't get inline multiplication table.\n");
 146       exit(1);
 147     }
 148     elapsed = 0;
 149     dnum = 0;
 150     for (i = 0; i < iterations; i++) {
 151       for (j = 0; j < size; j++) {
 152         ra16[j] = MOA_Random_W(w, 1);
 153         rb16[j] = MOA_Random_W(w, 1);
 154       }
 155       timer_start(&timer);
 156       for (j = 0; j < size; j++) {
 157         ra16[j] = GF_W16_INLINE_MULT(log16, alog16, ra16[j], rb16[j]);
 158       }
 159       dnum += num;
 160       elapsed += timer_split(&timer);
 161     }
 162     printf("Inline mult:   %10.6lf s   Mops: %10.3lf    %10.3lf Mega-ops/s\n",
 163            elapsed, dnum/1024.0/1024.0, dnum/1024.0/1024.0/elapsed);
 164   }
 165   free (ra);
 166   free (rb);
 167   free (ra16);
 168   free (rb16);
 169   return 0;
 170 }