func testIncremental(t *testing.T, h hash.Hash32, result uint32, which string) {
h.Reset()
h.Write([]byte("hello"))
h.Write([]byte("h"))
h.Write([]byte("e"))
h.Write([]byte("l"))
h.Write([]byte("l"))
h.Write([]byte("o"))
h.Write([]byte("hellohello"))
h32 := h.Sum32()
if h32 != result {
t.Errorf("%s: incremental failed: got %08x", which, h32)
}
h.Reset()
h.Write([]byte("hellohellohellohello"))
h32 = h.Sum32()
if h32 != result {
t.Errorf("%s: failed: got %08x", which, h32)
}
}
func testIncremental(t *testing.T, h hash.Hash32, result uint32, which string) {
h.Reset()
var parts = []string{
"h",
"ell",
"o",
"he",
"llo",
"hellohello",
}
for _, p := range parts {
l, _ := h.Write([]byte(p))
if l != len(p) {
t.Errorf("Write(%d bytes) = %d, want %d\n", len(p), l, len(p))
}
}
h32 := h.Sum32()
if h32 != result {
t.Errorf("%s: incremental failed: got %08x", which, h32)
}
h.Reset()
h.Write([]byte("hellohellohellohello"))
h32 = h.Sum32()
if h32 != result {
t.Errorf("%s: failed: got %08x", which, h32)
}
}
func commonBench(b *testing.B, h hash.Hash32, golden []_Golden) {
for i := 0; i < b.N; i++ {
for _, g := range golden {
h.Reset()
h.Write([]byte(g.in))
h.Sum32()
}
}
}
func imageHash(h hash.Hash32, dir *Directory, img *Image) int {
h.Reset()
h.Write([]byte(dir.RelPat()))
h.Write([]byte(img.Name()))
bytes, err := img.FileTime().MarshalBinary()
if err == nil {
h.Write(bytes)
}
return int(h.Sum32())
}
// FilesPathToPartition hashes a file path to a partition.
func FilesPathToPartition(h hash.Hash32,
partitions []string, path string) string {
if len(partitions) <= 0 {
return ""
}
h.Reset()
io.WriteString(h, path)
i := h.Sum32() % uint32(len(partitions))
return partitions[i]
}
// Returns shard under given key
func (m ConcurrentMap) GetShard(key string) *ConcurrentMapShared {
hasherAsInterface := hashPool.Get()
var hasher hash.Hash32
if hasherAsInterface == nil {
hasher = fnv.New32()
} else {
hasher = hasherAsInterface.(hash.Hash32)
hasher.Reset()
}
hasher.Write([]byte(key))
sum := hasher.Sum32()
hashPool.Put(hasher)
return m[uint(sum)%uint(SHARD_COUNT)]
}
func becnchmark(b *testing.B, h hash.Hash32, n int64) {
b.SetBytes(n)
data := make([]byte, n)
for i := range data {
data[i] = byte(i)
}
in := make([]byte, 0, h.Size())
b.ResetTimer()
for i := 0; i < b.N; i++ {
h.Reset()
h.Write(data)
h.Sum(in)
}
}
func benchmark(b *testing.B, h hash.Hash32, n, alignment int64) {
b.SetBytes(n)
data := make([]byte, n+alignment)
data = data[alignment:]
for i := range data {
data[i] = byte(i)
}
in := make([]byte, 0, h.Size())
// Warm up
h.Reset()
h.Write(data)
h.Sum(in)
b.ResetTimer()
for i := 0; i < b.N; i++ {
h.Reset()
h.Write(data)
h.Sum(in)
}
}
func testGolden(t *testing.T, h hash.Hash32, golden []_Golden, which string) {
for _, g := range golden {
h.Reset()
h.Write([]byte(g.in))
sum := h.Sum32()
if sum != g.out {
t.Errorf("%s(%s) = 0x%x want 0x%x", which, g.in, sum, g.out)
}
bsum := h.Sum(nil)
if len(bsum) != 4 {
t.Errorf("%s Sum(nil) returned %d bytes, wanted 4: %s\n", which, len(bsum), bsum)
}
s := binary.BigEndian.Uint32(bsum)
if s != sum {
t.Errorf("%s(%s).Sum(nil) = 0x%x want 0x%x", which, g.in, sum, g.out)
}
bsum = h.Sum([]byte{0x01, 0x02, 0x03, 0x04})
if len(bsum) != 8 {
t.Errorf("%s Sum(bsum) returned %d bytes, wanted 8: %x\n", which, len(bsum), bsum)
}
s = binary.BigEndian.Uint32(bsum[0:])
s2 := binary.BigEndian.Uint32(bsum[4:])
if s != 0x01020304 || s2 != sum {
t.Errorf("%s(%s).Sum(bsum) = %x (expected 0x01020304 %x )", which, g.in, bsum, sum)
}
}
}
// SeriesHash returns a hash of the metric, tags pair. The hash falls in uint16
// range.
func (c cmd) SeriesHash(hash hash.Hash32) int {
hash.Reset()
buf := c.Point()
// include Metric
i := bytes.IndexByte(buf, ' ')
hash.Write(buf[:i])
buf = buf[i+1:]
// exclude Time
i = bytes.IndexByte(buf, ' ')
buf = buf[i+1:]
// exclude Value
i = bytes.IndexByte(buf, ' ')
// include Tags
hash.Write(buf[i:])
// Sum
sum := hash.Sum32()
return int(uint16(sum))
}
func (p *xxhPool) Put(h hash.Hash32) {
h.Reset()
p.Pool.Put(h)
}
// ReleaseCRC32Checksum releases a CRC32 back to the allocation pool.
func ReleaseCRC32Checksum(crc hash.Hash32) {
crc.Reset()
crc32Pool.Put(crc)
}
// Hash32 is a convenience method for hashing a string against a hash.Hash32
func Hash32(s string, h hash.Hash32) uint32 {
h.Reset()
h.Write([]byte(s))
return h.Sum32()
}
})
It("has no error", func() {
_, err := jhash.Write(key)
Expect(err).To(BeNil())
})
})
Describe("Reset", func() {
It("sets back to 0", func() {
Expect(jhash.Sum32()).To(Equal(uint32(0)))
jhash.Write(key)
Expect(jhash.Sum32()).NotTo(Equal(uint32(0)))
jhash.Reset()
Expect(jhash.Sum32()).To(Equal(uint32(0)))
})
})
Describe("Size", func() {
It("is 4", func() {
Expect(jhash.Size()).To(Equal(4))
})
})
Describe("BlockSize", func() {