SkChecksum.cpp File Reference

#include "src/core/SkChecksum.h"
#include <cstring>

Go to the source code of this file.

Namespaces
namespace	SkChecksum

Macros
#define	_likely_(x)   (x)
#define	_unlikely_(x)   (x)

Functions
static void	_wymum (uint64_t *A, uint64_t *B)
static uint64_t	_wymix (uint64_t A, uint64_t B)
static uint64_t	_wyr8 (const uint8_t *p)
static uint64_t	_wyr4 (const uint8_t *p)
static uint64_t	_wyr3 (const uint8_t *p, size_t k)
static uint64_t	wyhash (const void *key, size_t len, uint64_t seed, const uint64_t *secret)
uint32_t	SkChecksum::Hash32 (const void *data, size_t bytes, uint32_t seed)
uint64_t	SkChecksum::Hash64 (const void *data, size_t bytes, uint64_t seed)

Variables
static const uint64_t	_wyp [4]

Macro Definition Documentation

_likely_

#define _likely_

(

x

)

(x)

Definition at line 18 of file SkChecksum.cpp.

_unlikely_

#define _unlikely_

(

x

)

(x)

Definition at line 19 of file SkChecksum.cpp.

Function Documentation

_wymix()

static uint64_t _wymix ( uint64_t  A, uint64_t  B  )

inlinestatic

Definition at line 44 of file SkChecksum.cpp.

                                                      {
    _wymum(&A, &B);
    return A ^ B;
}

_wymum()

static void _wymum ( uint64_t *  A, uint64_t *  B  )

inlinestatic

Definition at line 23 of file SkChecksum.cpp.

                                                    {
#if defined(__SIZEOF_INT128__)
    __uint128_t r = *A;
    r *= *B;
    *A = (uint64_t)r;
    *B = (uint64_t)(r >> 64);
#elif defined(_MSC_VER) && defined(_M_X64)
    *A = _umul128(*A, *B, B);
#else
    uint64_t ha = *A >> 32, hb = *B >> 32, la = (uint32_t)*A, lb = (uint32_t)*B, hi, lo;
    uint64_t rh = ha * hb, rm0 = ha * lb, rm1 = hb * la, rl = la * lb, t = rl + (rm0 << 32),
             c = t < rl;
    lo = t + (rm1 << 32);
    c += lo < t;
    hi = rh + (rm0 >> 32) + (rm1 >> 32) + c;
    *A = lo;
    *B = hi;
#endif
}

_wyr3()

static uint64_t _wyr3 ( const uint8_t *  p, size_t  k  )

inlinestatic

Definition at line 62 of file SkChecksum.cpp.

                                                         {
    return (((uint64_t)p[0]) << 16) | (((uint64_t)p[k >> 1]) << 8) | p[k - 1];
}

_wyr4()

static uint64_t _wyr4 ( const uint8_t *  p )

inlinestatic

Definition at line 56 of file SkChecksum.cpp.

                                               {
    uint32_t v;
    memcpy(&v, p, 4);
    return v;
}

_wyr8()

static uint64_t _wyr8 ( const uint8_t *  p )

inlinestatic

Definition at line 50 of file SkChecksum.cpp.

                                               {
    uint64_t v;
    memcpy(&v, p, 8);
    return v;
}

wyhash()

static uint64_t wyhash ( const void *  key, size_t  len, uint64_t  seed, const uint64_t *  secret  )

inlinestatic

Definition at line 67 of file SkChecksum.cpp.

                                                                                                  {
    const uint8_t* p = (const uint8_t*)key;
    seed ^= _wymix(seed ^ secret[0], secret[1]);
    uint64_t a, b;
    if (_likely_(len <= 16)) {
        if (_likely_(len >= 4)) {
            a = (_wyr4(p) << 32) | _wyr4(p + ((len >> 3) << 2));
            b = (_wyr4(p + len - 4) << 32) | _wyr4(p + len - 4 - ((len >> 3) << 2));
        } else if (_likely_(len > 0)) {
            a = _wyr3(p, len);
            b = 0;
        } else
            a = b = 0;
    } else {
        size_t i = len;
        if (_unlikely_(i > 48)) {
            uint64_t see1 = seed, see2 = seed;
            do {
                seed = _wymix(_wyr8(p) ^ secret[1], _wyr8(p + 8) ^ seed);
                see1 = _wymix(_wyr8(p + 16) ^ secret[2], _wyr8(p + 24) ^ see1);
                see2 = _wymix(_wyr8(p + 32) ^ secret[3], _wyr8(p + 40) ^ see2);
                p += 48;
                i -= 48;
            } while (_likely_(i > 48));
            seed ^= see1 ^ see2;
        }
        while (_unlikely_(i > 16)) {
            seed = _wymix(_wyr8(p) ^ secret[1], _wyr8(p + 8) ^ seed);
            i -= 16;
            p += 16;
        }
        a = _wyr8(p + i - 16);
        b = _wyr8(p + i - 8);
    }
    a ^= secret[1];
    b ^= seed;
    _wymum(&a, &b);
    return _wymix(a ^ secret[0] ^ len, b ^ secret[1]);
}

Variable Documentation

_wyp

const uint64_t _wyp[4]

static

Initial value:

= {
        0xa0761d6478bd642full, 0xe7037ed1a0b428dbull, 0x8ebc6af09c88c6e3ull, 0x589965cc75374cc3ull}

Definition at line 108 of file SkChecksum.cpp.

                                {
        0xa0761d6478bd642full, 0xe7037ed1a0b428dbull, 0x8ebc6af09c88c6e3ull, 0x589965cc75374cc3ull};