开源的互联网

nHash = nHash * 33 + *key++;

static uint64_t tchdbbidx(TCHDB *hdb, const char *kbuf, int ksiz, uint8_t *hp){
  assert(hdb && kbuf && ksiz >= 0 && hp);
  uint64_t idx = 19780211;
  uint32_t hash = 751;
  const char *rp = kbuf + ksiz;
  while(ksiz--){
    idx = idx * 37 + *(uint8_t *)kbuf++;
    hash = (hash * 31) ^ *(uint8_t *)--rp;
  }
  *hp = hash;
  return idx % hdb->bnum;
}

# DJBX33A (Daniel J. Bernstein, Times 33 with Addition)
#  
#   This is Daniel J. Bernstein's popular `times 33' hash function as
#   posted by him years ago on comp.lang.c. It basically uses a function
#   like ``hash(i) = hash(i-1) * 33 + str[i]''. This is one of the best
#   known hash functions for strings. Because it is both computed very
#   fast and distributes very well.
#  
#   The magic of number 33, i.e. why it works better than many other
#   constants, prime or not, has never been adequately explained by
#   anyone. So I try an explanation: if one experimentally tests all
#   multipliers between 1 and 256 (as RSE did now) one detects that even
#   numbers are not useable at all. The remaining 128 odd numbers
#   (except for the number 1) work more or less all equally well. They
#   all distribute in an acceptable way and this way fill a hash table
#   with an average percent of approx. 86%.
#  
#   If one compares the Chi^2 values of the variants, the number 33 not
#   even has the best value. But the number 33 and a few other equally
#   good numbers like 17, 31, 63, 127 and 129 have nevertheless a great
#   advantage to the remaining numbers in the large set of possible
#   multipliers: their multiply operation can be replaced by a faster
#   operation based on just one shift plus either a single addition
#   or subtraction operation. And because a hash function has to both
#   distribute good _and_ has to be very fast to compute, those few
#   numbers should be preferred and seems to be the reason why Daniel J.
#   Bernstein also preferred it.
#  
#                    -- Ralf S. Engelschall

while(off > 0){
    rec.off = off;
    if(!tchdbreadrec(hdb, &rec, rbuf)) return false;
    if(hash > rec.hash){
      off = rec.left;
      entoff = rec.off + (sizeof(uint8_t) + sizeof(uint8_t));
    } else if(hash ba64 ? sizeof(uint64_t) : sizeof(uint32_t));
    } else {
      if(!rec.kbuf && !tchdbreadrecbody(hdb, &rec)) return false;
      /*比较key为了解决hash的冲突*/
      int kcmp = tcreckeycmp(kbuf, ksiz, rec.kbuf, rec.ksiz);
      if(kcmp > 0){
        off = rec.left;
        TCFREE(rec.bbuf);
        rec.kbuf = NULL;
        rec.bbuf = NULL;
        entoff = rec.off + (sizeof(uint8_t) + sizeof(uint8_t));
      } else if(kcmp ba64 ? sizeof(uint64_t) : sizeof(uint32_t));
      } else {
        bool rv;
        int nvsiz;
        char *nvbuf;
        HDBPDPROCOP *procptr;
        .........................
        存储..........
        .........................