package hrw import ( "encoding/binary" "fmt" "math" "math/rand" "strconv" "testing" "github.com/stretchr/testify/require" ) type ( hashString string unknown byte slices struct { actual interface{} expect interface{} } Uint32Slice []uint32 ) var testKey = []byte("0xff51afd7ed558ccd") func (p Uint32Slice) Len() int { return len(p) } func (p Uint32Slice) Less(i, j int) bool { return p[i] < p[j] } func (p Uint32Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } func Example() { // given a set of servers servers := []string{ "one.example.com", "two.example.com", "three.example.com", "four.example.com", "five.example.com", "six.example.com", } // HRW can consistently select a uniformly-distributed set of servers for // any given key var ( key = []byte("/examples/object-key") h = Hash(key) ) SortSliceByValue(servers, h) for id := range servers { fmt.Printf("trying GET %s%s\n", servers[id], key) } // Output: // trying GET three.example.com/examples/object-key // trying GET two.example.com/examples/object-key // trying GET five.example.com/examples/object-key // trying GET six.example.com/examples/object-key // trying GET one.example.com/examples/object-key // trying GET four.example.com/examples/object-key } func (h hashString) Hash() uint64 { return Hash([]byte(h)) } func TestSortSliceByIndex(t *testing.T) { actual := []string{"a", "b", "c", "d", "e", "f"} expect := []string{"e", "a", "c", "f", "d", "b"} hash := Hash(testKey) SortSliceByIndex(actual, hash) require.Equal(t, expect, actual) } func TestValidateWeights(t *testing.T) { weights := []float64{10, 10, 10, 2, 2, 2} err := ValidateWeights(weights) require.Error(t, err) weights = []float64{math.NaN(), 1, 1, 0.2, 0.2, 0.2} err = ValidateWeights(weights) require.Error(t, err) weights = []float64{1, 1, 1, 0.2, 0.2, 0.2} err = ValidateWeights(weights) require.NoError(t, err) } func TestSortSliceByWeightIndex(t *testing.T) { actual := []string{"a", "b", "c", "d", "e", "f"} weights := []float64{1, 1, 1, 0.2, 0.2, 0.2} expect := []string{"a", "c", "b", "e", "f", "d"} hash := Hash(testKey) SortSliceByWeightIndex(actual, weights, hash) require.Equal(t, expect, actual) } func TestSortSliceByValue(t *testing.T) { actual := []string{"a", "b", "c", "d", "e", "f"} expect := []string{"d", "f", "c", "b", "a", "e"} hash := Hash(testKey) SortSliceByValue(actual, hash) require.Equal(t, expect, actual) } func TestSortSliceByValueFail(t *testing.T) { t.Run("empty slice", func(t *testing.T) { var ( actual []int hash = Hash(testKey) ) require.NotPanics(t, func() { SortSliceByValue(actual, hash) }) }) t.Run("must be slice", func(t *testing.T) { actual := 10 hash := Hash(testKey) require.Panics(t, func() { SortSliceByValue(actual, hash) }) }) t.Run("must 'fail' for unknown type", func(t *testing.T) { actual := []unknown{1, 2, 3, 4, 5} hash := Hash(testKey) require.Panics(t, func() { SortSliceByValue(actual, hash) }) }) } func TestSortSliceByValueHasher(t *testing.T) { actual := []hashString{"a", "b", "c", "d", "e", "f"} expect := []hashString{"d", "f", "c", "b", "a", "e"} hash := Hash(testKey) SortSliceByValue(actual, hash) require.Equal(t, expect, actual) } func TestSortHasherSliceByValue(t *testing.T) { actual := []hashString{"a", "b", "c", "d", "e", "f"} expect := []hashString{"d", "f", "c", "b", "a", "e"} hash := Hash(testKey) SortHasherSliceByValue(actual, hash) require.EqualValues(t, expect, actual) } func TestSortHasherSliceByWeightValue(t *testing.T) { actual := []hashString{"a", "b", "c", "d", "e", "f"} weights := []float64{1.0, 1.0, 1.0, 1.0, 1.0, 1.0} expect := []hashString{"d", "f", "c", "b", "a", "e"} hash := Hash(testKey) SortHasherSliceByWeightValue(actual, weights, hash) require.EqualValues(t, expect, actual) } func TestSortSliceByValueIntSlice(t *testing.T) { cases := []slices{ { actual: []int{0, 1, 2, 3, 4, 5}, expect: []int{2, 0, 5, 3, 1, 4}, }, { actual: []uint{0, 1, 2, 3, 4, 5}, expect: []uint{2, 0, 5, 3, 1, 4}, }, { actual: []int8{0, 1, 2, 3, 4, 5}, expect: []int8{5, 2, 1, 4, 0, 3}, }, { actual: []uint8{0, 1, 2, 3, 4, 5}, expect: []uint8{5, 2, 1, 4, 0, 3}, }, { actual: []int16{0, 1, 2, 3, 4, 5}, expect: []int16{1, 0, 3, 2, 4, 5}, }, { actual: []uint16{0, 1, 2, 3, 4, 5}, expect: []uint16{1, 0, 3, 2, 4, 5}, }, { actual: []int32{0, 1, 2, 3, 4, 5}, expect: []int32{5, 1, 2, 0, 3, 4}, }, { actual: []uint32{0, 1, 2, 3, 4, 5}, expect: []uint32{5, 1, 2, 0, 3, 4}, }, { actual: []int64{0, 1, 2, 3, 4, 5}, expect: []int64{5, 3, 0, 1, 4, 2}, }, { actual: []uint64{0, 1, 2, 3, 4, 5}, expect: []uint64{5, 3, 0, 1, 4, 2}, }, } hash := Hash(testKey) for _, tc := range cases { SortSliceByValue(tc.actual, hash) require.Equal(t, tc.expect, tc.actual) } } func TestSort(t *testing.T) { nodes := []uint64{1, 2, 3, 4, 5} hash := Hash(testKey) actual := Sort(nodes, hash) expected := []uint64{3, 1, 4, 2, 0} require.Equal(t, expected, actual) } func TestDistribution(t *testing.T) { const ( size = 10 keys = 100000 percent = 0.03 ) // We use χ2 method to determine similarity of distribution with uniform distribution. // χ2 = Σ((n-N)**2/N) // https://www.medcalc.org/manual/chi-square-table.php p=0.1 var chiTable = map[int]float64{9: 14.68, 99: 117.407} t.Run("sort", func(t *testing.T) { var ( i uint64 nodes [size]uint64 counts = make(map[uint64]uint64, size) key = make([]byte, 16) ) for i = 0; i < size; i++ { nodes[i] = i } for i = 0; i < keys; i++ { binary.BigEndian.PutUint64(key, i+size) hash := Hash(key) counts[Sort(nodes[:], hash)[0]]++ } var chi2 float64 mean := float64(keys) / float64(size) delta := mean * percent for node, count := range counts { d := mean - float64(count) chi2 += math.Pow(float64(count)-mean, 2) / mean require.True(t, d < delta && (0-d) < delta, "Node %d received %d keys, expected %.0f (+/- %.2f)", node, count, mean, delta) } require.True(t, chi2 < chiTable[size-1], "Chi2 condition for .9 is not met (expected %.2f <= %.2f)", chi2, chiTable[size-1]) }) t.Run("sortByIndex", func(t *testing.T) { var ( i uint64 a, b [size]uint64 counts = make(map[uint64]int, size) key = make([]byte, 16) ) for i = 0; i < size; i++ { a[i] = i } for i = 0; i < keys; i++ { copy(b[:], a[:]) binary.BigEndian.PutUint64(key, i+size) hash := Hash(key) SortSliceByIndex(b[:], hash) counts[b[0]]++ } var chi2 float64 mean := float64(keys) / float64(size) delta := mean * percent for node, count := range counts { d := mean - float64(count) chi2 += math.Pow(float64(count)-mean, 2) / mean require.True(t, d < delta && (0-d) < delta, "Node %d received %d keys, expected %.0f (+/- %.2f)", node, count, mean, delta) } require.True(t, chi2 < chiTable[size-1], "Chi2 condition for .9 is not met (expected %.2f <= %.2f)", chi2, chiTable[size-1]) }) t.Run("sortByValue", func(t *testing.T) { var ( i uint64 a, b [size]int counts = make(map[int]int, size) key = make([]byte, 16) ) for i = 0; i < size; i++ { a[i] = int(i) } for i = 0; i < keys; i++ { copy(b[:], a[:]) binary.BigEndian.PutUint64(key, i+size) hash := Hash(key) SortSliceByValue(b[:], hash) counts[b[0]]++ } var chi2 float64 mean := float64(keys) / float64(size) delta := mean * percent for node, count := range counts { d := mean - float64(count) chi2 += math.Pow(float64(count)-mean, 2) / mean require.True(t, d < delta && (0-d) < delta, "Node %d received %d keys, expected %.0f (+/- %.2f)", node, count, mean, delta) } require.True(t, chi2 < chiTable[size-1], "Chi2 condition for .9 is not met (expected %.2f <= %.2f)", chi2, chiTable[size-1]) }) t.Run("sortByStringValue", func(t *testing.T) { var ( i uint64 a, b [size]string counts = make(map[string]int, size) key = make([]byte, 16) ) for i = 0; i < size; i++ { a[i] = strconv.FormatUint(i, 10) } for i = 0; i < keys; i++ { copy(b[:], a[:]) binary.BigEndian.PutUint64(key, i+size) hash := Hash(key) SortSliceByValue(b[:], hash) counts[b[0]]++ } var chi2 float64 mean := float64(keys) / float64(size) delta := mean * percent for node, count := range counts { d := mean - float64(count) chi2 += math.Pow(float64(count)-mean, 2) / mean require.True(t, d < delta && (0-d) < delta, "Node %d received %d keys, expected %.0f (+/- %.2f)", node, count, mean, delta) } require.True(t, chi2 < chiTable[size-1], "Chi2 condition for .9 is not met (expected %.2f <= %.2f)", chi2, chiTable[size-1]) }) t.Run("sortByInt32Value", func(t *testing.T) { var ( i uint64 a, b [size]int32 counts = make(map[int32]int, size) key = make([]byte, 16) ) for i = 0; i < size; i++ { a[i] = int32(i) } for i = 0; i < keys; i++ { copy(b[:], a[:]) binary.BigEndian.PutUint64(key, i+size) hash := Hash(key) SortSliceByValue(b[:], hash) counts[b[0]]++ } var chi2 float64 mean := float64(keys) / float64(size) delta := mean * percent for node, count := range counts { d := mean - float64(count) chi2 += math.Pow(float64(count)-mean, 2) / mean require.True(t, d < delta && (0-d) < delta, "Node %d received %d keys, expected %.0f (+/- %.2f)", node, count, mean, delta) } require.True(t, chi2 < chiTable[size-1], "Chi2 condition for .9 is not met (expected %.2f <= %.2f)", chi2, chiTable[size-1]) }) t.Run("sortByWeightValue", func(t *testing.T) { var ( i uint64 a, b, result [size]int w [size]float64 key = make([]byte, 16) ) for i = 0; i < size; i++ { a[i] = int(i) w[i] = float64(size-i) / float64(size) } for i = 0; i < keys; i++ { copy(b[:], a[:]) binary.BigEndian.PutUint64(key, i+size) hash := Hash(key) SortSliceByWeightValue(b[:], w[:], hash) result[b[0]]++ } for i := 0; i < size-1; i++ { require.True(t, bool(w[i] > w[i+1]) == bool(result[i] > result[i+1]), "result array %v must be corresponded to weights %v", result, w) } }) t.Run("sortByWeightValueShuffledWeight", func(t *testing.T) { var ( i uint64 a, b, result [size]int w [size]float64 key = make([]byte, 16) ) for i = 0; i < size; i++ { a[i] = int(i) w[i] = float64(size-i) / float64(size) } rand.Shuffle(size, func(i, j int) { w[i], w[j] = w[j], w[i] }) for i = 0; i < keys; i++ { copy(b[:], a[:]) binary.BigEndian.PutUint64(key, i+size) hash := Hash(key) SortSliceByWeightValue(b[:], w[:], hash) result[b[0]]++ } for i := 0; i < size-1; i++ { require.True(t, bool(w[i] > w[i+1]) == bool(result[i] > result[i+1]), "result array %v must be corresponded to weights %v", result, w) } }) t.Run("sortByWeightValueEmptyWeight", func(t *testing.T) { var ( i uint64 a, b [size]int w [size]float64 counts = make(map[int]int, size) key = make([]byte, 16) ) for i = 0; i < size; i++ { a[i] = int(i) } for i = 0; i < keys; i++ { copy(b[:], a[:]) binary.BigEndian.PutUint64(key, i+size) hash := Hash(key) SortSliceByWeightValue(b[:], w[:], hash) counts[b[0]]++ } var chi2 float64 mean := float64(keys) / float64(size) delta := mean * percent for node, count := range counts { d := mean - float64(count) chi2 += math.Pow(float64(count)-mean, 2) / mean require.True(t, d < delta && (0-d) < delta, "Node %d received %d keys, expected %.0f (+/- %.2f)", node, count, mean, delta) } require.True(t, chi2 < chiTable[size-1], "Chi2 condition for .9 is not met (expected %.2f <= %.2f)", chi2, chiTable[size-1]) }) t.Run("sortByWeightValueUniformWeight", func(t *testing.T) { var ( i uint64 a, b [size]int w [size]float64 counts = make(map[int]int, size) key = make([]byte, 16) ) for i = 0; i < size; i++ { a[i] = int(i) w[i] = 0.5 } for i = 0; i < keys; i++ { copy(b[:], a[:]) binary.BigEndian.PutUint64(key, i+size) hash := Hash(key) SortSliceByWeightValue(b[:], w[:], hash) counts[b[0]]++ } var chi2 float64 mean := float64(keys) / float64(size) delta := mean * percent for node, count := range counts { d := mean - float64(count) chi2 += math.Pow(float64(count)-mean, 2) / mean require.True(t, d < delta && (0-d) < delta, "Node %d received %d keys, expected %.0f (+/- %.2f)", node, count, mean, delta) } require.True(t, chi2 < chiTable[size-1], "Chi2 condition for .9 is not met (expected %.2f <= %.2f)", chi2, chiTable[size-1]) }) t.Run("sortByWeightValueAbsoluteW", func(t *testing.T) { const keys = 1 var ( i uint64 a, b [size]int w [size]float64 key = make([]byte, 16) ) for i = 0; i < size; i++ { a[i] = int(i) } w[size-1] = 1 for i = 0; i < keys; i++ { copy(b[:], a[:]) binary.BigEndian.PutUint64(key, i+size) hash := Hash(key) SortSliceByWeightValue(b[:], w[:], hash) require.True(t, b[0] == a[size-1], "expected last value of %v to be the first with highest distance", a) } }) t.Run("sortByWeightValueNormalizedWeight", func(t *testing.T) { var ( i uint64 a, b, result [size]uint64 w, normalizedW [size]float64 key = make([]byte, 16) ) for i = 0; i < size; i++ { a[i] = i w[int(i)] = 10 } w[0] = 100 // Here let's use logarithm normalization for i = 0; i < size; i++ { normalizedW[i] = math.Log2(w[i]) / math.Log2(w[0]) } for i = 0; i < keys; i++ { copy(b[:], a[:]) binary.BigEndian.PutUint64(key, i+size) hash := Hash(key) SortSliceByWeightValue(b[:], normalizedW[:], hash) for j := range b { result[b[j]] += uint64(len(b) - j) } } cutResult := result[1:] var total uint64 for i := range cutResult { total += cutResult[i] } var chi2 float64 mean := float64(total) / float64(len(cutResult)) delta := mean * percent for node, count := range cutResult { d := mean - float64(count) chi2 += math.Pow(float64(count)-mean, 2) / mean require.True(t, d < delta && (0-d) < delta, "Node %d received %d keys, expected %.0f (+/- %.2f)", node, count, mean, delta) } require.True(t, chi2 < chiTable[size-1], "Chi2 condition for .9 is not met (expected %.2f <= %.2f)", chi2, chiTable[size-1]) }) t.Run("hash collision", func(t *testing.T) { var ( i uint64 counts = make(map[uint64]uint64) key = make([]byte, 16) ) for i = 0; i < keys; i++ { binary.BigEndian.PutUint64(key, i+size) hash := Hash(key) counts[hash]++ } for node, count := range counts { if count > 1 { t.Errorf("Node %d received %d keys", node, count) } } }) } func BenchmarkSort_fnv_10(b *testing.B) { hash := Hash(testKey) _ = benchmarkSort(b, 10, hash) } func BenchmarkSort_fnv_100(b *testing.B) { hash := Hash(testKey) _ = benchmarkSort(b, 100, hash) } func BenchmarkSort_fnv_1000(b *testing.B) { hash := Hash(testKey) _ = benchmarkSort(b, 1000, hash) } func BenchmarkSortByIndex_fnv_10(b *testing.B) { hash := Hash(testKey) benchmarkSortByIndex(b, 10, hash) } func BenchmarkSortByIndex_fnv_100(b *testing.B) { hash := Hash(testKey) benchmarkSortByIndex(b, 100, hash) } func BenchmarkSortByIndex_fnv_1000(b *testing.B) { hash := Hash(testKey) benchmarkSortByIndex(b, 1000, hash) } func BenchmarkSortByValue_fnv_10(b *testing.B) { hash := Hash(testKey) benchmarkSortByValue(b, 10, hash) } func BenchmarkSortByValue_fnv_100(b *testing.B) { hash := Hash(testKey) benchmarkSortByValue(b, 100, hash) } func BenchmarkSortByValue_fnv_1000(b *testing.B) { hash := Hash(testKey) benchmarkSortByValue(b, 1000, hash) } func BenchmarkSortHashersByValue_Reflection_fnv_10(b *testing.B) { hash := Hash(testKey) benchmarkSortHashersByValueReflection(b, 10, hash) } func BenchmarkSortHashersByValue_Reflection_fnv_100(b *testing.B) { hash := Hash(testKey) benchmarkSortHashersByValueReflection(b, 100, hash) } func BenchmarkSortHashersByValue_Reflection_fnv_1000(b *testing.B) { hash := Hash(testKey) benchmarkSortHashersByValueReflection(b, 1000, hash) } func BenchmarkSortHashersByValue_Typed_fnv_10(b *testing.B) { hash := Hash(testKey) benchmarkSortHashersByValueTyped(b, 10, hash) } func BenchmarkSortHashersByValue_Typed_fnv_100(b *testing.B) { hash := Hash(testKey) benchmarkSortHashersByValueTyped(b, 100, hash) } func BenchmarkSortHashersByValue_Typed_fnv_1000(b *testing.B) { hash := Hash(testKey) benchmarkSortHashersByValueTyped(b, 1000, hash) } func BenchmarkSortByWeight_fnv_10(b *testing.B) { hash := Hash(testKey) _ = benchmarkSortByWeight(b, 10, hash) } func BenchmarkSortByWeight_fnv_100(b *testing.B) { hash := Hash(testKey) _ = benchmarkSortByWeight(b, 100, hash) } func BenchmarkSortByWeight_fnv_1000(b *testing.B) { hash := Hash(testKey) _ = benchmarkSortByWeight(b, 1000, hash) } func BenchmarkSortByWeightIndex_fnv_10(b *testing.B) { hash := Hash(testKey) benchmarkSortByWeightIndex(b, 10, hash) } func BenchmarkSortByWeightIndex_fnv_100(b *testing.B) { hash := Hash(testKey) benchmarkSortByWeightIndex(b, 100, hash) } func BenchmarkSortByWeightIndex_fnv_1000(b *testing.B) { hash := Hash(testKey) benchmarkSortByWeightIndex(b, 1000, hash) } func BenchmarkSortByWeightValue_fnv_10(b *testing.B) { hash := Hash(testKey) benchmarkSortByWeightValue(b, 10, hash) } func BenchmarkSortByWeightValue_fnv_100(b *testing.B) { hash := Hash(testKey) benchmarkSortByWeightValue(b, 100, hash) } func BenchmarkSortByWeightValue_fnv_1000(b *testing.B) { hash := Hash(testKey) benchmarkSortByWeightValue(b, 1000, hash) } func BenchmarkSortHashersByWeightValueReflection_fnv_10(b *testing.B) { benchmarkSortHashersByWeightValueRelection(b, 10, Hash(testKey)) } func BenchmarkSortHashersByWeightValueReflection_fnv_100(b *testing.B) { benchmarkSortHashersByWeightValueRelection(b, 100, Hash(testKey)) } func BenchmarkSortHashersByWeightValueReflection_fnv_1000(b *testing.B) { benchmarkSortHashersByWeightValueRelection(b, 1000, Hash(testKey)) } func BenchmarkSortHashersByWeightValueTyped_fnv_10(b *testing.B) { benchmarkSortHashersByWeightValueTyped(b, 10, Hash(testKey)) } func BenchmarkSortHashersByWeightValueTyped_fnv_100(b *testing.B) { benchmarkSortHashersByWeightValueTyped(b, 100, Hash(testKey)) } func BenchmarkSortHashersByWeightValueTyped_fnv_1000(b *testing.B) { benchmarkSortHashersByWeightValueTyped(b, 1000, Hash(testKey)) } func benchmarkSort(b *testing.B, n int, hash uint64) uint64 { servers := make([]uint64, n) for i := uint64(0); i < uint64(len(servers)); i++ { servers[i] = i } b.ResetTimer() b.ReportAllocs() var x uint64 for i := 0; i < b.N; i++ { x += Sort(servers, hash)[0] } return x } func benchmarkSortByIndex(b *testing.B, n int, hash uint64) { servers := make([]uint64, n) for i := uint64(0); i < uint64(len(servers)); i++ { servers[i] = i } b.ResetTimer() b.ReportAllocs() for i := 0; i < b.N; i++ { SortSliceByIndex(servers, hash) } } func benchmarkSortByValue(b *testing.B, n int, hash uint64) { servers := make([]string, n) for i := uint64(0); i < uint64(len(servers)); i++ { servers[i] = "localhost:" + strconv.FormatUint(60000-i, 10) } b.ResetTimer() b.ReportAllocs() for i := 0; i < b.N; i++ { SortSliceByValue(servers, hash) } } func benchmarkSortByWeight(b *testing.B, n int, hash uint64) uint64 { servers := make([]uint64, n) weights := make([]float64, n) for i := uint64(0); i < uint64(len(servers)); i++ { weights[i] = float64(uint64(n)-i) / float64(n) servers[i] = i } b.ResetTimer() b.ReportAllocs() var x uint64 for i := 0; i < b.N; i++ { x += SortByWeight(servers, weights, hash)[0] } return x } func benchmarkSortByWeightIndex(b *testing.B, n int, hash uint64) { servers := make([]uint64, n) weights := make([]float64, n) for i := uint64(0); i < uint64(len(servers)); i++ { weights[i] = float64(uint64(n)-i) / float64(n) servers[i] = i } b.ResetTimer() b.ReportAllocs() for i := 0; i < b.N; i++ { SortSliceByWeightIndex(servers, weights, hash) } } func benchmarkSortByWeightValue(b *testing.B, n int, hash uint64) { servers := make([]string, n) weights := make([]float64, n) for i := uint64(0); i < uint64(len(servers)); i++ { weights[i] = float64(uint64(n)-i) / float64(n) servers[i] = "localhost:" + strconv.FormatUint(60000-i, 10) } b.ResetTimer() b.ReportAllocs() for i := 0; i < b.N; i++ { SortSliceByWeightValue(servers, weights, hash) } } func benchmarkSortHashersByWeightValueRelection(b *testing.B, n int, hash uint64) { servers := make([]hashString, n) weights := make([]float64, n) for i := uint64(0); i < uint64(len(servers)); i++ { weights[i] = float64(uint64(n)-i) / float64(n) servers[i] = hashString("localhost:" + strconv.FormatUint(60000-i, 10)) } b.ResetTimer() b.ReportAllocs() for i := 0; i < b.N; i++ { SortSliceByWeightValue(servers, weights, hash) } } func benchmarkSortHashersByWeightValueTyped(b *testing.B, n int, hash uint64) { servers := make([]hashString, n) weights := make([]float64, n) for i := uint64(0); i < uint64(len(servers)); i++ { weights[i] = float64(uint64(n)-i) / float64(n) servers[i] = hashString("localhost:" + strconv.FormatUint(60000-i, 10)) } b.ResetTimer() b.ReportAllocs() for i := 0; i < b.N; i++ { SortHasherSliceByWeightValue(servers, weights, hash) } } func benchmarkSortHashersByValueReflection(b *testing.B, n int, hash uint64) { servers := make([]hashString, n) for i := uint64(0); i < uint64(len(servers)); i++ { servers[i] = hashString("localhost:" + strconv.FormatUint(60000-i, 10)) } b.ResetTimer() b.ReportAllocs() for i := 0; i < b.N; i++ { SortSliceByValue(servers, hash) } } func benchmarkSortHashersByValueTyped(b *testing.B, n int, hash uint64) { servers := make([]hashString, n) for i := uint64(0); i < uint64(len(servers)); i++ { servers[i] = hashString("localhost:" + strconv.FormatUint(60000-i, 10)) } b.ResetTimer() b.ReportAllocs() for i := 0; i < b.N; i++ { SortHasherSliceByValue(servers, hash) } }