test_hash_fast.c

/* By Paul Hsieh (C) 2004, 2005.  Covered under the Paul Hsieh derivative
   license. See:
   http://www.azillionmonkeys.com/qed/weblicense.html for license details.

   http://www.azillionmonkeys.com/qed/hash.html */
#include <stdint.h>
#define NULL (void*)0
#undef get16bits
#if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__) \
  || defined(_MSC_VER) || defined (__BORLANDC__) || defined (__TURBOC__)
#define get16bits(d) (*((const uint16_t *) (d)))
#endif

#if !defined (get16bits)
#define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)\
                       +(uint32_t)(((const uint8_t *)(d))[0]) )
#endif


/* Benchmark */

#include <time.h>
#include <stdio.h>
#include <unistd.h>

int main(void) {
  struct timespec start, end;
  long secs;
  long hashes = 0;
  char data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
  clock_gettime(CLOCK_MONOTONIC, &start);
  clock_gettime(CLOCK_MONOTONIC, &end);
  while ((secs = end.tv_sec - start.tv_sec) < 20) {
    // Begin of ``uint32_t hash = SuperFastHash(data, 20);''
    const char * data_c = data; // from function declaration (had to be renamed)
    int len = 20;               // from function declaration
    uint32_t hash = len, tmp;
    int rem;
    
    if (len <= 0 || data == NULL) return 0;
    
    rem = len & 3;
    len >>= 2;
    
    /* Main loop */
    for (;len > 0; len--) {
      hash  += get16bits (data);
      tmp    = (get16bits (data+2) << 11) ^ hash;
      hash   = (hash << 16) ^ tmp;
      data_c  += 2*sizeof (uint16_t);
      hash  += hash >> 11;
    }
    
    /* Handle end cases */
    switch (rem) {
      case 3: hash += get16bits (data_c);
              hash ^= hash << 16;
              hash ^= ((signed char)data_c[sizeof (uint16_t)]) << 18;
              hash += hash >> 11;
              break;
      case 2: hash += get16bits (data_c);
              hash ^= hash << 11;
              hash += hash >> 17;
              break;
      case 1: hash += (signed char)*data_c;
              hash ^= hash << 10;
              hash += hash >> 1;
    }
    
    /* Force "avalanching" of final 127 bits */
    hash ^= hash << 3;
    hash += hash >> 5;
    hash ^= hash << 4;
    hash += hash >> 17;
    hash ^= hash << 25;
    hash += hash >> 6;
    // End of ``uint32_t hash = SuperFastHash(data, 20);''

    data[hash % 20] += 1;
    clock_gettime(CLOCK_MONOTONIC, &end);
    ++hashes;
  }

  printf("secs: %ld, hashes: %ld, hashes/sec: %f, Khashes/sec: %f\n", secs, hashes, hashes/20.0,
      hashes/20.0/1000.0);
  return 0;
}