Tests to see how 64bit hash functions perform in Go.

64bit_hash_collisions_test.go

package main

import (
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"hash/fnv"
	"testing"
	"time"

	"github.com/cespare/xxhash/v2"
	"golang.org/x/exp/rand"
)

func TestEachHash(t *testing.T) {

	hashes := make(map[string]struct{})
	max := 10000000

	var b [40]byte
	for i := 0; i < max; i++ {

		if i%1000000 == 0 {
			time.Sleep(time.Millisecond)
		}

		_, err := rand.Read(b[:])
		if err != nil {
			t.Error(err)
			t.Fail()
		}

		// result := sha256hash(b[:])
		// result := fnv1ahash(b[:])
		result := xxhashhelper(b[:])

		// Sanity check
		if i < 5 {
			fmt.Println(i, result)
		}

		if _, ok := hashes[result]; ok {
			t.Logf("%s == %v", result, b)
			t.Errorf("Found collision after %d searches", i)
		}

		hashes[result] = struct{}{}
	}

	fmt.Println("no collisions found", max)
}

func TestXXHash(t *testing.T) {

	hashes := make(map[uint64]struct{})
	max := 50000000

	var b [40]byte
	for i := 0; i < max; i++ {

		if i%10000000 == 0 {
			t.Logf("iteration: %d\n", i)
		}

		_, err := rand.Read(b[:])
		if err != nil {
			t.Error(err)
			t.Fail()
		}

		result := xxhash.Sum64(b[:])

		// Sanity check
		if i < 5 {
			fmt.Println(i, result)
		}

		if _, ok := hashes[result]; ok {
			t.Logf("%d == %v", result, b)
			t.Errorf("Found collision after %d searches", i)
		}

		hashes[result] = struct{}{}
	}

	fmt.Println("no collisions found", max)
}

func sha256hash(b []byte) string {
	h := sha256.New()
	h.Write(b)

	var r [8]byte
	copy(r[:], h.Sum(nil))

	return hex.EncodeToString(r[:])
}

func fnv1ahash(b []byte) string {
	h := fnv.New64a()
	h.Write(b)

	var r [8]byte
	copy(r[:], h.Sum(nil))

	return hex.EncodeToString(r[:])
}

func xxhashhelper(b []byte) string {

	h := xxhash.New()
	h.Write(b)

	var r [8]byte
	copy(r[:], h.Sum(nil))

	return hex.EncodeToString(r[:])

	// return fmt.Sprintf("%d", xxhash.Sum64(b))

}