src/unit_test.c

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