gsimm.c

   1 #include "rabinpoly.h"
   2 #include "gsimm.h"
   3
   4 /* Has to be power of two. Since the Rabin hash only has 63
   5    usable bits, the number of hashes is limited to 32.
   6    Lower powers of two could be used for speeding up processing
   7    of very large files.  */
   8 #define NUM_HASHES_PER_CHAR 32
   9
  10 /* Size of cache used to eliminate duplicate substrings.
  11    Make small enough to comfortably fit in L1 cache.  */
  12 #define DUP_CACHE_SIZE 256
  13
  14 /* For the final counting, do not count each bit individually, but
  15    group them. Must be power of two, at most NUM_HASHES_PER_CHAR.
  16    However, larger sizes result in higher cache usage. Use 8 bits
  17    per group for efficient processing of large files on fast machines
  18    with decent caches, or 4 bits for faster processing of small files
  19    and for machines with small caches.  */
  20 #define GROUP_BITS 4
  21 #define GROUP_COUNTERS (1<<GROUP_BITS)
  22
  23 static void freq_to_md(u_char *md, int *freq)
  24 { int j, k;
  25
  26   for (j = 0; j < MD_LENGTH; j++)
  27   { u_char ch = 0;
  28
  29     for (k = 0; k < 8; k++) ch = 2*ch + (freq[8*j+k] > 0);
  30     md[j] = ch;
  31   }
  32   bzero (freq, sizeof(freq[0]) * MD_BITS);
  33 }
  34
  35 void gb_simm_process(u_char *data, unsigned len, u_char *md)
  36 { size_t j = 0;
  37   u_int32_t ofs;
  38   u_int32_t dup_cache[DUP_CACHE_SIZE];
  39   u_int32_t count [MD_BITS * (GROUP_COUNTERS/GROUP_BITS)];
  40   int freq[MD_BITS];
  41
  42   bzero (freq, sizeof(freq[0]) * MD_BITS);
  43   bzero (dup_cache, DUP_CACHE_SIZE * sizeof (u_int32_t));
  44   bzero (count, (MD_BITS * (GROUP_COUNTERS/GROUP_BITS) * sizeof (u_int32_t)));
  45
  46   /* Ignore incomplete substrings */
  47   while (j < len && j < RABIN_WINDOW_SIZE) rabin_slide8 (data[j++]);
  48
  49   while (j < len)
  50   { u_int64_t hash;
  51     u_int32_t ofs, sum;
  52     u_char idx;
  53     int k;
  54
  55     hash = rabin_slide8 (data[j++]);
  56
  57     /* In order to update a much larger frequency table
  58        with only 32 bits of checksum, randomly select a
  59        part of the table to update. The selection should
  60        only depend on the content of the represented data,
  61        and be independent of the bits used for the update.
  62
  63        Instead of updating 32 individual counters, process
  64        the checksum in MD_BITS / GROUP_BITS groups of
  65        GROUP_BITS bits, and count the frequency of each bit pattern.
  66     */
  67
  68     idx = (hash >> 32);
  69     sum = (u_int32_t) hash;
  70     ofs = idx % (MD_BITS / NUM_HASHES_PER_CHAR) * NUM_HASHES_PER_CHAR;
  71     idx %= DUP_CACHE_SIZE;
  72     if (dup_cache[idx] != sum)
  73     { dup_cache[idx] = sum;
  74       for (k = 0; k < NUM_HASHES_PER_CHAR / GROUP_BITS; k++)
  75       { count[ofs * GROUP_COUNTERS / GROUP_BITS + (sum % GROUP_COUNTERS)]++;
  76         ofs += GROUP_BITS;
  77         sum >>= GROUP_BITS;
  78   } } }
  79
  80   /* Distribute the occurrences of each bit group over the frequency table. */
  81   for (ofs = 0; ofs < MD_BITS; ofs += GROUP_BITS)
  82   { int j;
  83     for (j = 0; j < GROUP_COUNTERS; j++)
  84     { int k;
  85       for (k = 0; k < GROUP_BITS; k++)
  86       { freq[ofs + k] += ((1<<k) & j)
  87           ? count[ofs * GROUP_COUNTERS / GROUP_BITS + j]
  88           : -count[ofs * GROUP_COUNTERS / GROUP_BITS + j];
  89   } } }
  90
  91   if (md)
  92   { rabin_reset();
  93     freq_to_md (md, freq);
  94 } }