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() {