src/unit_test.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <sys/resource.h>
   5
   6 #include "storage_number.h"
   7 #include "rrd.h"
   8 #include "log.h"
   9 #include "web_buffer.h"
  10
  11 #define ACCURACY_LOSS 0.0000001
  12
  13 int check_storage_number(calculated_number n, int debug) {
  14         char buffer[100];
  15
  16         storage_number s = pack_storage_number(n);
  17         calculated_number d = unpack_storage_number(s);
  18
  19         calculated_number ddiff = d - n;
  20         calculated_number dcdiff = ddiff * 100.0 / n;
  21
  22         if(dcdiff < 0) dcdiff = -dcdiff;
  23
  24         size_t len = print_calculated_number(buffer, d);
  25         calculated_number p = strtold(buffer, NULL);
  26         calculated_number pdiff = n - p;
  27         calculated_number pcdiff = pdiff * 100.0 / n;
  28         if(pcdiff < 0) pcdiff = -pcdiff;
  29
  30         if(debug) {
  31                 fprintf(stderr,
  32                         CALCULATED_NUMBER_FORMAT " original\n"
  33                         CALCULATED_NUMBER_FORMAT " packed and unpacked, (stored as 0x%08X, diff " CALCULATED_NUMBER_FORMAT ", " CALCULATED_NUMBER_FORMAT "%%)\n"
  34                         "%s printed after unpacked (%zu bytes)\n"
  35                         CALCULATED_NUMBER_FORMAT " re-parsed from printed (diff " CALCULATED_NUMBER_FORMAT ", " CALCULATED_NUMBER_FORMAT "%%)\n\n",
  36                         n,
  37                         d, s, ddiff, dcdiff,
  38                         buffer,
  39                         len, p, pdiff, pcdiff
  40                 );
  41                 if(len != strlen(buffer)) fprintf(stderr, "ERROR: printed number %s is reported to have length %zu but it has %zu\n", buffer, len, strlen(buffer));
  42                 if(dcdiff > ACCURACY_LOSS) fprintf(stderr, "WARNING: packing number " CALCULATED_NUMBER_FORMAT " has accuracy loss %0.7Lf %%\n", n, dcdiff);
  43                 if(pcdiff > ACCURACY_LOSS) fprintf(stderr, "WARNING: re-parsing the packed, unpacked and printed number " CALCULATED_NUMBER_FORMAT " has accuracy loss %0.7Lf %%\n", n, pcdiff);
  44         }
  45
  46         if(len != strlen(buffer)) return 1;
  47         if(dcdiff > ACCURACY_LOSS) return 3;
  48         if(pcdiff > ACCURACY_LOSS) return 4;
  49         return 0;
  50 }
  51
  52 void benchmark_storage_number(int loop, int multiplier) {
  53         int i, j;
  54         calculated_number n, d;
  55         storage_number s;
  56         unsigned long long user, system, total, mine, their;
  57
  58         char buffer[100];
  59
  60         struct rusage now, last;
  61
  62         fprintf(stderr, "\n\nBenchmarking %d numbers, please wait...\n\n", loop);
  63
  64         // ------------------------------------------------------------------------
  65
  66         fprintf(stderr, "SYSTEM  LONG DOUBLE    SIZE: %zu bytes\n", sizeof(calculated_number));
  67         fprintf(stderr, "NETDATA FLOATING POINT SIZE: %zu bytes\n", sizeof(storage_number));
  68
  69         mine = (calculated_number)sizeof(storage_number) * (calculated_number)loop;
  70         their = (calculated_number)sizeof(calculated_number) * (calculated_number)loop;
  71
  72         if(mine > their) {
  73                 fprintf(stderr, "\nNETDATA NEEDS %0.2Lf TIMES MORE MEMORY. Sorry!\n", (long double)(mine / their));
  74         }
  75         else {
  76                 fprintf(stderr, "\nNETDATA INTERNAL FLOATING POINT ARITHMETICS NEEDS %0.2Lf TIMES LESS MEMORY.\n", (long double)(their / mine));
  77         }
  78
  79         fprintf(stderr, "\nNETDATA FLOATING POINT\n");
  80         fprintf(stderr, "MIN POSITIVE VALUE " CALCULATED_NUMBER_FORMAT "\n", (calculated_number)STORAGE_NUMBER_POSITIVE_MIN);
  81         fprintf(stderr, "MAX POSITIVE VALUE " CALCULATED_NUMBER_FORMAT "\n", (calculated_number)STORAGE_NUMBER_POSITIVE_MAX);
  82         fprintf(stderr, "MIN NEGATIVE VALUE " CALCULATED_NUMBER_FORMAT "\n", (calculated_number)STORAGE_NUMBER_NEGATIVE_MIN);
  83         fprintf(stderr, "MAX NEGATIVE VALUE " CALCULATED_NUMBER_FORMAT "\n", (calculated_number)STORAGE_NUMBER_NEGATIVE_MAX);
  84         fprintf(stderr, "Maximum accuracy loss: " CALCULATED_NUMBER_FORMAT "%%\n\n\n", (calculated_number)ACCURACY_LOSS);
  85
  86         // ------------------------------------------------------------------------
  87
  88         fprintf(stderr, "INTERNAL LONG DOUBLE PRINTING: ");
  89         getrusage(RUSAGE_SELF, &last);
  90
  91         // do the job
  92         for(j = 1; j < 11 ;j++) {
  93                 n = STORAGE_NUMBER_POSITIVE_MIN * j;
  94
  95                 for(i = 0; i < loop ;i++) {
  96                         n *= multiplier;
  97                         if(n > STORAGE_NUMBER_POSITIVE_MAX) n = STORAGE_NUMBER_POSITIVE_MIN;
  98
  99                         print_calculated_number(buffer, n);
 100                 }
 101         }
 102
 103         getrusage(RUSAGE_SELF, &now);
 104         user   = now.ru_utime.tv_sec * 1000000ULL + now.ru_utime.tv_usec - last.ru_utime.tv_sec * 1000000ULL + last.ru_utime.tv_usec;
 105         system = now.ru_stime.tv_sec * 1000000ULL + now.ru_stime.tv_usec - last.ru_stime.tv_sec * 1000000ULL + last.ru_stime.tv_usec;
 106         total  = user + system;
 107         mine = total;
 108
 109         fprintf(stderr, "user %0.5Lf, system %0.5Lf, total %0.5Lf\n", (long double)(user / 1000000.0), (long double)(system / 1000000.0), (long double)(total / 1000000.0));
 110
 111         // ------------------------------------------------------------------------
 112
 113         fprintf(stderr, "SYSTEM   LONG DOUBLE PRINTING: ");
 114         getrusage(RUSAGE_SELF, &last);
 115
 116         // do the job
 117         for(j = 1; j < 11 ;j++) {
 118                 n = STORAGE_NUMBER_POSITIVE_MIN * j;
 119
 120                 for(i = 0; i < loop ;i++) {
 121                         n *= multiplier;
 122                         if(n > STORAGE_NUMBER_POSITIVE_MAX) n = STORAGE_NUMBER_POSITIVE_MIN;
 123                         snprintf(buffer, 100, CALCULATED_NUMBER_FORMAT, n);
 124                 }
 125         }
 126
 127         getrusage(RUSAGE_SELF, &now);
 128         user   = now.ru_utime.tv_sec * 1000000ULL + now.ru_utime.tv_usec - last.ru_utime.tv_sec * 1000000ULL + last.ru_utime.tv_usec;
 129         system = now.ru_stime.tv_sec * 1000000ULL + now.ru_stime.tv_usec - last.ru_stime.tv_sec * 1000000ULL + last.ru_stime.tv_usec;
 130         total  = user + system;
 131         their = total;
 132
 133         fprintf(stderr, "user %0.5Lf, system %0.5Lf, total %0.5Lf\n", (long double)(user / 1000000.0), (long double)(system / 1000000.0), (long double)(total / 1000000.0));
 134
 135         if(mine > total) {
 136                 fprintf(stderr, "NETDATA CODE IS SLOWER %0.2Lf %%\n", (long double)(mine * 100.0 / their - 100.0));
 137         }
 138         else {
 139                 fprintf(stderr, "NETDATA CODE IS  F A S T E R  %0.2Lf %%\n", (long double)(their * 100.0 / mine - 100.0));
 140         }
 141
 142         // ------------------------------------------------------------------------
 143
 144         fprintf(stderr, "\nINTERNAL LONG DOUBLE PRINTING WITH PACK / UNPACK: ");
 145         getrusage(RUSAGE_SELF, &last);
 146
 147         // do the job
 148         for(j = 1; j < 11 ;j++) {
 149                 n = STORAGE_NUMBER_POSITIVE_MIN * j;
 150
 151                 for(i = 0; i < loop ;i++) {
 152                         n *= multiplier;
 153                         if(n > STORAGE_NUMBER_POSITIVE_MAX) n = STORAGE_NUMBER_POSITIVE_MIN;
 154
 155                         s = pack_storage_number(n);
 156                         d = unpack_storage_number(s);
 157                         print_calculated_number(buffer, d);
 158                 }
 159         }
 160
 161         getrusage(RUSAGE_SELF, &now);
 162         user   = now.ru_utime.tv_sec * 1000000ULL + now.ru_utime.tv_usec - last.ru_utime.tv_sec * 1000000ULL + last.ru_utime.tv_usec;
 163         system = now.ru_stime.tv_sec * 1000000ULL + now.ru_stime.tv_usec - last.ru_stime.tv_sec * 1000000ULL + last.ru_stime.tv_usec;
 164         total  = user + system;
 165         mine = total;
 166
 167         fprintf(stderr, "user %0.5Lf, system %0.5Lf, total %0.5Lf\n", (long double)(user / 1000000.0), (long double)(system / 1000000.0), (long double)(total / 1000000.0));
 168
 169         if(mine > their) {
 170                 fprintf(stderr, "WITH PACKING UNPACKING NETDATA CODE IS SLOWER %0.2Lf %%\n", (long double)(mine * 100.0 / their - 100.0));
 171         }
 172         else {
 173                 fprintf(stderr, "EVEN WITH PACKING AND UNPACKING, NETDATA CODE IS  F A S T E R  %0.2Lf %%\n", (long double)(their * 100.0 / mine - 100.0));
 174         }
 175
 176         // ------------------------------------------------------------------------
 177
 178 }
 179
 180 int unit_test_storage()
 181 {
 182         calculated_number c, a = 0;
 183         int i, j, g, r = 0;
 184
 185         for(g = -1; g <= 1 ; g++) {
 186                 a = 0;
 187
 188                 if(!g) continue;
 189
 190                 for(j = 0; j < 9 ;j++) {
 191                         a += 0.0000001;
 192                         c = a * g;
 193                         for(i = 0; i < 21 ;i++, c *= 10) {
 194                                 if(c > 0 && c < STORAGE_NUMBER_POSITIVE_MIN) continue;
 195                                 if(c < 0 && c > STORAGE_NUMBER_NEGATIVE_MAX) continue;
 196
 197                                 if(check_storage_number(c, 1)) return 1;
 198                         }
 199                 }
 200         }
 201
 202         benchmark_storage_number(1000000, 2);
 203         return r;
 204 }
 205
 206 int unit_test(long delay, long shift)
 207 {
 208         static int repeat = 0;
 209         repeat++;
 210
 211         char name[101];
 212         snprintf(name, 100, "unittest-%d-%ld-%ld", repeat, delay, shift);
 213
 214         debug_flags = 0xffffffff;
 215         memory_mode = NETDATA_MEMORY_MODE_RAM;
 216         update_every = 1;
 217
 218         int do_abs = 1;
 219         int do_inc = 1;
 220         int do_abst = 1;
 221         int do_absi = 1;
 222
 223         RRD_STATS *st = rrd_stats_create("netdata", name, name, "netdata", "Unit Testing", "a value", 1, 1, CHART_TYPE_LINE);
 224         st->debug = 1;
 225
 226         RRD_DIMENSION *rdabs = NULL;
 227         RRD_DIMENSION *rdinc = NULL;
 228         RRD_DIMENSION *rdabst = NULL;
 229         RRD_DIMENSION *rdabsi = NULL;
 230
 231         if(do_abs) rdabs = rrd_stats_dimension_add(st, "absolute", "absolute", 1, 1, RRD_DIMENSION_ABSOLUTE);
 232         if(do_inc) rdinc = rrd_stats_dimension_add(st, "incremental", "incremental", 1, 1 * update_every, RRD_DIMENSION_INCREMENTAL);
 233         if(do_abst) rdabst = rrd_stats_dimension_add(st, "percentage-of-absolute-row", "percentage-of-absolute-row", 1, 1, RRD_DIMENSION_PCENT_OVER_ROW_TOTAL);
 234         if(do_absi) rdabsi = rrd_stats_dimension_add(st, "percentage-of-incremental-row", "percentage-of-incremental-row", 1, 1, RRD_DIMENSION_PCENT_OVER_DIFF_TOTAL);
 235
 236         long increment = 1000;
 237         collected_number i = 0;
 238
 239         unsigned long c, dimensions = 0;
 240         RRD_DIMENSION *rd;
 241         for(rd = st->dimensions ; rd ; rd = rd->next) dimensions++;
 242
 243         for(c = 0; c < 20 ;c++) {
 244                 i += increment;
 245
 246                 fprintf(stderr, "\n\nLOOP = %lu, DELAY = %ld, VALUE = " COLLECTED_NUMBER_FORMAT "\n", c, delay, i);
 247                 if(c) {
 248                         rrd_stats_next_usec(st, delay);
 249                 }
 250                 if(do_abs) rrd_stats_dimension_set(st, "absolute", i);
 251                 if(do_inc) rrd_stats_dimension_set(st, "incremental", i);
 252                 if(do_abst) rrd_stats_dimension_set(st, "percentage-of-absolute-row", i);
 253                 if(do_absi) rrd_stats_dimension_set(st, "percentage-of-incremental-row", i);
 254
 255                 if(!c) {
 256                         gettimeofday(&st->last_collected_time, NULL);
 257                         st->last_collected_time.tv_usec = shift;
 258                 }
 259
 260                 // prevent it from deleting the dimensions
 261                 for(rd = st->dimensions ; rd ; rd = rd->next) rd->last_collected_time.tv_sec = st->last_collected_time.tv_sec;
 262
 263                 rrd_stats_done(st);
 264         }
 265
 266         unsigned long oincrement = increment;
 267         increment = increment * st->update_every * 1000000 / delay;
 268         fprintf(stderr, "\n\nORIGINAL INCREMENT: %lu, INCREMENT %lu, DELAY %lu, SHIFT %lu\n", oincrement * 10, increment * 10, delay, shift);
 269
 270         int ret = 0;
 271         storage_number v;
 272         for(c = 0 ; c < st->counter ; c++) {
 273                 fprintf(stderr, "\nPOSITION: c = %lu, VALUE %lu\n", c, (oincrement + c * increment + increment * (1000000 - shift) / 1000000 )* 10);
 274
 275                 for(rd = st->dimensions ; rd ; rd = rd->next) {
 276                         fprintf(stderr, "\t %s " STORAGE_NUMBER_FORMAT "   ->   ", rd->id, rd->values[c]);
 277
 278                         if(rd == rdabs) v =
 279                                 (         oincrement
 280                                         + (increment * (1000000 - shift) / 1000000)
 281                                         + c * increment
 282                                 ) * 10;
 283
 284                         else if(rd == rdinc) v = (c?(increment):(increment * (1000000 - shift) / 1000000)) * 10;
 285                         else if(rd == rdabst) v = oincrement / dimensions;
 286                         else if(rd == rdabsi) v = oincrement / dimensions;
 287                         else v = 0;
 288
 289                         if(v == rd->values[c]) fprintf(stderr, "passed.\n");
 290                         else {
 291                                 fprintf(stderr, "ERROR! (expected " STORAGE_NUMBER_FORMAT ")\n", v);
 292                                 ret = 1;
 293                         }
 294                 }
 295         }
 296
 297         if(ret)
 298                 fprintf(stderr, "\n\nUNIT TEST(%ld, %ld) FAILED\n\n", delay, shift);
 299
 300         return ret;
 301 }
 302