crc/test.c

   1 #include <inttypes.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5
   6 #include "../gettime.h"
   7 #include "../fio_time.h"
   8 #include "../lib/rand.h"
   9 #include "../os/os.h"
  10
  11 #include "../crc/md5.h"
  12 #include "../crc/crc64.h"
  13 #include "../crc/crc32.h"
  14 #include "../crc/crc32c.h"
  15 #include "../crc/crc16.h"
  16 #include "../crc/crc7.h"
  17 #include "../crc/sha1.h"
  18 #include "../crc/sha256.h"
  19 #include "../crc/sha512.h"
  20 #include "../crc/sha3.h"
  21 #include "../crc/xxhash.h"
  22 #include "../crc/murmur3.h"
  23 #include "../crc/fnv.h"
  24 #include "../hash.h"
  25
  26 #include "test.h"
  27
  28 #define CHUNK           131072U
  29 #define NR_CHUNKS         2048U
  30
  31 struct test_type {
  32         const char *name;
  33         unsigned int mask;
  34         void (*fn)(struct test_type *, void *, size_t);
  35         uint32_t output;
  36 };
  37
  38 enum {
  39         T_MD5           = 1U << 0,
  40         T_CRC64         = 1U << 1,
  41         T_CRC32         = 1U << 2,
  42         T_CRC32C        = 1U << 3,
  43         T_CRC16         = 1U << 4,
  44         T_CRC7          = 1U << 5,
  45         T_SHA1          = 1U << 6,
  46         T_SHA256        = 1U << 7,
  47         T_SHA512        = 1U << 8,
  48         T_XXHASH        = 1U << 9,
  49         T_MURMUR3       = 1U << 10,
  50         T_JHASH         = 1U << 11,
  51         T_FNV           = 1U << 12,
  52         T_SHA3_224      = 1U << 13,
  53         T_SHA3_256      = 1U << 14,
  54         T_SHA3_384      = 1U << 15,
  55         T_SHA3_512      = 1U << 16,
  56 };
  57
  58 static void t_md5(struct test_type *t, void *buf, size_t size)
  59 {
  60         uint32_t digest[4];
  61         struct fio_md5_ctx ctx = { .hash = digest };
  62         int i;
  63
  64         fio_md5_init(&ctx);
  65
  66         for (i = 0; i < NR_CHUNKS; i++) {
  67                 fio_md5_update(&ctx, buf, size);
  68                 fio_md5_final(&ctx);
  69         }
  70 }
  71
  72 static void t_crc64(struct test_type *t, void *buf, size_t size)
  73 {
  74         int i;
  75
  76         for (i = 0; i < NR_CHUNKS; i++)
  77                 t->output += fio_crc64(buf, size);
  78 }
  79
  80 static void t_crc32(struct test_type *t, void *buf, size_t size)
  81 {
  82         int i;
  83
  84         for (i = 0; i < NR_CHUNKS; i++)
  85                 t->output += fio_crc32(buf, size);
  86 }
  87
  88 static void t_crc32c(struct test_type *t, void *buf, size_t size)
  89 {
  90         int i;
  91
  92         for (i = 0; i < NR_CHUNKS; i++)
  93                 t->output += fio_crc32c(buf, size);
  94 }
  95
  96 static void t_crc16(struct test_type *t, void *buf, size_t size)
  97 {
  98         int i;
  99
 100         for (i = 0; i < NR_CHUNKS; i++)
 101                 t->output += fio_crc16(buf, size);
 102 }
 103
 104 static void t_crc7(struct test_type *t, void *buf, size_t size)
 105 {
 106         int i;
 107
 108         for (i = 0; i < NR_CHUNKS; i++)
 109                 t->output += fio_crc7(buf, size);
 110 }
 111
 112 static void t_sha1(struct test_type *t, void *buf, size_t size)
 113 {
 114         uint32_t sha[5];
 115         struct fio_sha1_ctx ctx = { .H = sha };
 116         int i;
 117
 118         fio_sha1_init(&ctx);
 119
 120         for (i = 0; i < NR_CHUNKS; i++) {
 121                 fio_sha1_update(&ctx, buf, size);
 122                 fio_sha1_final(&ctx);
 123         }
 124 }
 125
 126 static void t_sha256(struct test_type *t, void *buf, size_t size)
 127 {
 128         uint8_t sha[64];
 129         struct fio_sha256_ctx ctx = { .buf = sha };
 130         int i;
 131
 132         fio_sha256_init(&ctx);
 133
 134         for (i = 0; i < NR_CHUNKS; i++) {
 135                 fio_sha256_update(&ctx, buf, size);
 136                 fio_sha256_final(&ctx);
 137         }
 138 }
 139
 140 static void t_sha512(struct test_type *t, void *buf, size_t size)
 141 {
 142         uint8_t sha[128];
 143         struct fio_sha512_ctx ctx = { .buf = sha };
 144         int i;
 145
 146         fio_sha512_init(&ctx);
 147
 148         for (i = 0; i < NR_CHUNKS; i++)
 149                 fio_sha512_update(&ctx, buf, size);
 150 }
 151
 152 static void t_sha3_224(struct test_type *t, void *buf, size_t size)
 153 {
 154         uint8_t sha[SHA3_224_DIGEST_SIZE];
 155         struct fio_sha3_ctx ctx = { .sha = sha };
 156         int i;
 157
 158         fio_sha3_224_init(&ctx);
 159
 160         for (i = 0; i < NR_CHUNKS; i++) {
 161                 fio_sha3_update(&ctx, buf, size);
 162                 fio_sha3_final(&ctx);
 163         }
 164 }
 165
 166 static void t_sha3_256(struct test_type *t, void *buf, size_t size)
 167 {
 168         uint8_t sha[SHA3_256_DIGEST_SIZE];
 169         struct fio_sha3_ctx ctx = { .sha = sha };
 170         int i;
 171
 172         fio_sha3_256_init(&ctx);
 173
 174         for (i = 0; i < NR_CHUNKS; i++) {
 175                 fio_sha3_update(&ctx, buf, size);
 176                 fio_sha3_final(&ctx);
 177         }
 178 }
 179
 180 static void t_sha3_384(struct test_type *t, void *buf, size_t size)
 181 {
 182         uint8_t sha[SHA3_384_DIGEST_SIZE];
 183         struct fio_sha3_ctx ctx = { .sha = sha };
 184         int i;
 185
 186         fio_sha3_384_init(&ctx);
 187
 188         for (i = 0; i < NR_CHUNKS; i++) {
 189                 fio_sha3_update(&ctx, buf, size);
 190                 fio_sha3_final(&ctx);
 191         }
 192 }
 193
 194 static void t_sha3_512(struct test_type *t, void *buf, size_t size)
 195 {
 196         uint8_t sha[SHA3_512_DIGEST_SIZE];
 197         struct fio_sha3_ctx ctx = { .sha = sha };
 198         int i;
 199
 200         fio_sha3_512_init(&ctx);
 201
 202         for (i = 0; i < NR_CHUNKS; i++) {
 203                 fio_sha3_update(&ctx, buf, size);
 204                 fio_sha3_final(&ctx);
 205         }
 206 }
 207
 208 static void t_murmur3(struct test_type *t, void *buf, size_t size)
 209 {
 210         int i;
 211
 212         for (i = 0; i < NR_CHUNKS; i++)
 213                 t->output += murmurhash3(buf, size, 0x8989);
 214 }
 215
 216 static void t_jhash(struct test_type *t, void *buf, size_t size)
 217 {
 218         int i;
 219
 220         for (i = 0; i < NR_CHUNKS; i++)
 221                 t->output += jhash(buf, size, 0x8989);
 222 }
 223
 224 static void t_fnv(struct test_type *t, void *buf, size_t size)
 225 {
 226         int i;
 227
 228         for (i = 0; i < NR_CHUNKS; i++)
 229                 t->output += fnv(buf, size, 0x8989);
 230 }
 231
 232 static void t_xxhash(struct test_type *t, void *buf, size_t size)
 233 {
 234         void *state;
 235         int i;
 236
 237         state = XXH32_init(0x8989);
 238
 239         for (i = 0; i < NR_CHUNKS; i++)
 240                 XXH32_update(state, buf, size);
 241
 242         t->output = XXH32_digest(state);
 243 }
 244
 245 static struct test_type t[] = {
 246         {
 247                 .name = "md5",
 248                 .mask = T_MD5,
 249                 .fn = t_md5,
 250         },
 251         {
 252                 .name = "crc64",
 253                 .mask = T_CRC64,
 254                 .fn = t_crc64,
 255         },
 256         {
 257                 .name = "crc32",
 258                 .mask = T_CRC32,
 259                 .fn = t_crc32,
 260         },
 261         {
 262                 .name = "crc32c",
 263                 .mask = T_CRC32C,
 264                 .fn = t_crc32c,
 265         },
 266         {
 267                 .name = "crc16",
 268                 .mask = T_CRC16,
 269                 .fn = t_crc16,
 270         },
 271         {
 272                 .name = "crc7",
 273                 .mask = T_CRC7,
 274                 .fn = t_crc7,
 275         },
 276         {
 277                 .name = "sha1",
 278                 .mask = T_SHA1,
 279                 .fn = t_sha1,
 280         },
 281         {
 282                 .name = "sha256",
 283                 .mask = T_SHA256,
 284                 .fn = t_sha256,
 285         },
 286         {
 287                 .name = "sha512",
 288                 .mask = T_SHA512,
 289                 .fn = t_sha512,
 290         },
 291         {
 292                 .name = "xxhash",
 293                 .mask = T_XXHASH,
 294                 .fn = t_xxhash,
 295         },
 296         {
 297                 .name = "murmur3",
 298                 .mask = T_MURMUR3,
 299                 .fn = t_murmur3,
 300         },
 301         {
 302                 .name = "jhash",
 303                 .mask = T_JHASH,
 304                 .fn = t_jhash,
 305         },
 306         {
 307                 .name = "fnv",
 308                 .mask = T_FNV,
 309                 .fn = t_fnv,
 310         },
 311         {
 312                 .name = "sha3-224",
 313                 .mask = T_SHA3_224,
 314                 .fn = t_sha3_224,
 315         },
 316         {
 317                 .name = "sha3-256",
 318                 .mask = T_SHA3_256,
 319                 .fn = t_sha3_256,
 320         },
 321         {
 322                 .name = "sha3-384",
 323                 .mask = T_SHA3_384,
 324                 .fn = t_sha3_384,
 325         },
 326         {
 327                 .name = "sha3-512",
 328                 .mask = T_SHA3_512,
 329                 .fn = t_sha3_512,
 330         },
 331         {
 332                 .name = NULL,
 333         },
 334 };
 335
 336 static unsigned int get_test_mask(const char *type)
 337 {
 338         char *ostr, *str = strdup(type);
 339         unsigned int mask;
 340         char *name;
 341         int i;
 342
 343         ostr = str;
 344         mask = 0;
 345         while ((name = strsep(&str, ",")) != NULL) {
 346                 for (i = 0; t[i].name; i++) {
 347                         if (!strcmp(t[i].name, name)) {
 348                                 mask |= t[i].mask;
 349                                 break;
 350                         }
 351                 }
 352         }
 353
 354         free(ostr);
 355         return mask;
 356 }
 357
 358 static int list_types(void)
 359 {
 360         int i;
 361
 362         for (i = 0; t[i].name; i++)
 363                 printf("%s\n", t[i].name);
 364
 365         return 1;
 366 }
 367
 368 int fio_crctest(const char *type)
 369 {
 370         unsigned int test_mask = 0;
 371         uint64_t mb = CHUNK * NR_CHUNKS;
 372         struct frand_state state;
 373         int i, first = 1;
 374         void *buf;
 375
 376         crc32c_arm64_probe();
 377         crc32c_intel_probe();
 378
 379         if (!type)
 380                 test_mask = ~0U;
 381         else if (!strcmp(type, "help") || !strcmp(type, "list"))
 382                 return list_types();
 383         else
 384                 test_mask = get_test_mask(type);
 385
 386         if (!test_mask) {
 387                 fprintf(stderr, "fio: unknown hash `%s`. Available:\n", type);
 388                 return list_types();
 389         }
 390
 391         buf = malloc(CHUNK);
 392         init_rand_seed(&state, 0x8989, 0);
 393         fill_random_buf(&state, buf, CHUNK);
 394
 395         for (i = 0; t[i].name; i++) {
 396                 struct timespec ts;
 397                 double mb_sec;
 398                 uint64_t usec;
 399                 char pre[3];
 400
 401                 if (!(t[i].mask & test_mask))
 402                         continue;
 403
 404                 /*
 405                  * For first run, make sure CPUs are spun up and that
 406                  * we've touched the data.
 407                  */
 408                 if (first) {
 409                         usec_spin(100000);
 410                         t[i].fn(&t[i], buf, CHUNK);
 411                 }
 412
 413                 fio_gettime(&ts, NULL);
 414                 t[i].fn(&t[i], buf, CHUNK);
 415                 usec = utime_since_now(&ts);
 416
 417                 if (usec) {
 418                         mb_sec = (double) mb / (double) usec;
 419                         mb_sec /= (1.024 * 1.024);
 420                         if (strlen(t[i].name) >= 7)
 421                                 sprintf(pre, "\t");
 422                         else
 423                                 sprintf(pre, "\t\t");
 424                         printf("%s:%s%8.2f MiB/sec\n", t[i].name, pre, mb_sec);
 425                 } else
 426                         printf("%s:inf MiB/sec\n", t[i].name);
 427                 first = 0;
 428         }
 429
 430         free(buf);
 431         return 0;
 432 }