64位Hash算法Pascal版本

murmur的hash算法：http://sites.google.com/site/murmurhash/avalanche
c代码：
unsigned long long MurmurHash64B ( const void * key, int len, unsigned int seed )
{
    const unsigned int m = 0x5bd1e995;
    const int r = 24;


    unsigned int h1 = seed ^ len;
    unsigned int h2 = 0;


    const unsigned int * data = (const unsigned int *)key;


    while(len >= 8)
    {
        unsigned int k1 = *data++;
        k1 *= m; k1 ^= k1 >> r; k1 *= m;
        h1 *= m; h1 ^= k1;
        len -= 4;


        unsigned int k2 = *data++;
        k2 *= m; k2 ^= k2 >> r; k2 *= m;
        h2 *= m; h2 ^= k2;
        len -= 4;
    }


    if(len >= 4)
    {
        unsigned int k1 = *data++;
        k1 *= m; k1 ^= k1 >> r; k1 *= m;
        h1 *= m; h1 ^= k1;
        len -= 4;
    }


    switch(len)
    {
    case 3: h2 ^= ((unsigned char*)data)[2] << 16;
    case 2: h2 ^= ((unsigned char*)data)[1] << 8;
    case 1: h2 ^= ((unsigned char*)data)[0];
            h2 *= m;
    };


    h1 ^= h2 >> 18; h1 *= m;
    h2 ^= h1 >> 22; h2 *= m;  
    h1 ^= h2 >> 17; h1 *= m;
    h2 ^= h1 >> 19; h2 *= m;  
   
    unsigned long long h = h1;  
   
    h = (h << 32) | h2;  
   
    return h;
}


更改为Pascal代码：


function MurmurHash64P(const key: Pointer; const len: Integer; const Seed: Cardinal): UInt64; {$IFDEF HAVE_INLINE}inline;{$ENDIF}
type
  PByte4 = ^TByte4;
  TByte4 = array[0..3] of Byte;
const
  m = $5bd1e995;
  r = 24;
var
  h1, h2: Cardinal;


  data: PCardinal;
  iLen: Integer;


  k1, k2: Cardinal;
  iTemp: Cardinal;
begin
  Result := 0;


  iLen := len;


  h1 := Seed xor iLen;
  h2 := 0;


  data := key;


  while (iLen >= 8) do
  begin
    k1 := data^;
    k1 := k1 * m; k1 := (k1 shr r) xor k1; k1 := k1 * m;
    h1 := h1 * m; h1 := h1 xor k1;
    Inc(data); Dec(iLen, 4);


    k2 := data^;
    k2 := k2 * m; k2 := (k2 shr r) xor k2; k2 := k2 * m;
    h2 := h2 * m; h2 := h2 xor k2;
    Inc(data); Dec(iLen, 4);
  end;


  if (iLen >= 4) then
  begin
    k1 := data^;
    k1 := k1 * m; k1 := (k1 shr r) xor k1; k1 := k1 * m;
    h1 := h1 * m; h1 := h1 xor k1;
    Inc(data); Dec(iLen, 4);
  end;


  case iLen of
    3:
      begin
        iTemp := PByte4(data)^[2];


        h2 := h2 xor (iTemp shl 16);
      end;
    2:
      begin
        iTemp := PByte4(data)^[1];
        h2 := h2 xor (iTemp shl 8);
      end;
    1:
      begin
        h2 := PByte4(data)^[0]; h2 := h2 * m;
      end;
  end;


  h1 := h1 xor (h2 shr 18); h1 := h1 * m;
  h2 := h2 xor (h1 shr 22); h2 := h2 * m;
  h1 := h1 xor (h2 shr 17); h1 := h1 * m;
  h2 := h2 xor (h1 shr 19); h2 := h2 * m;


  Result := h1;
  Result := (Result shl 32) or h2;
end;


const
  C_DEF_HASH64_SEED = $EE6B27EB;


function HashOf64(const Value: PByte; const Len: Integer): UInt64; overload;
begin
  Result := MurmurHash64P(Value, Len, C_DEF_HASH64_SEED);
end;


function HashOf64(const Value: TBytes): UInt64; overload;
begin
  Result := HashOf64(@Value[0], Length(Value));
end;


function HashOf64(const Value: string): UInt64; overload;
begin
  Result := MurmurHash64P(@Value[1], Length(Value), C_DEF_HASH64_SEED);
end;