From d32f396204ad05552afe5e35c4ba8e9f71393960 Mon Sep 17 00:00:00 2001 From: Evgeniy Kulikov Date: Fri, 24 May 2019 12:51:39 +0300 Subject: [PATCH] =?UTF-8?q?=E2=9C=8C=EF=B8=8F=20Fixed=20in=20SortSliceByVa?= =?UTF-8?q?lue=20issue=20when=20weight=20calculated=20twice=20(#4)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - fixes for SortSliceByValue - fixes for tests --- hrw.go | 25 ++++++++++++------------- hrw_test.go | 42 +++++++++++++++++++++--------------------- 2 files changed, 33 insertions(+), 34 deletions(-) diff --git a/hrw.go b/hrw.go index 9efe654..ceb985b 100644 --- a/hrw.go +++ b/hrw.go @@ -87,64 +87,63 @@ func SortSliceByValue(slice interface{}, hash uint64) { var key = make([]byte, 16) for i := 0; i < length; i++ { binary.BigEndian.PutUint64(key, uint64(slice[i])) - rule = append(rule, weight(Hash(key), hash)) + rule = append(rule, Hash(key)) } case []uint: var key = make([]byte, 16) for i := 0; i < length; i++ { binary.BigEndian.PutUint64(key, uint64(slice[i])) - rule = append(rule, weight(Hash(key), hash)) + rule = append(rule, Hash(key)) } case []int8: for i := 0; i < length; i++ { key := byte(slice[i]) - rule = append(rule, weight(Hash([]byte{key}), hash)) + rule = append(rule, Hash([]byte{key})) } case []uint8: for i := 0; i < length; i++ { key := slice[i] - rule = append(rule, weight(Hash([]byte{key}), hash)) + rule = append(rule, Hash([]byte{key})) } case []int16: var key = make([]byte, 8) for i := 0; i < length; i++ { binary.BigEndian.PutUint16(key, uint16(slice[i])) - rule = append(rule, weight(Hash(key), hash)) + rule = append(rule, Hash(key)) } case []uint16: var key = make([]byte, 8) for i := 0; i < length; i++ { binary.BigEndian.PutUint16(key, slice[i]) - rule = append(rule, weight(Hash(key), hash)) + rule = append(rule, Hash(key)) } case []int32: var key = make([]byte, 16) for i := 0; i < length; i++ { binary.BigEndian.PutUint32(key, uint32(slice[i])) - rule = append(rule, weight(Hash(key), hash)) + rule = append(rule, Hash(key)) } case []uint32: var key = make([]byte, 16) for i := 0; i < length; i++ { binary.BigEndian.PutUint32(key, slice[i]) - rule = append(rule, weight(Hash(key), hash)) + rule = append(rule, Hash(key)) } case []int64: var key = make([]byte, 32) for i := 0; i < length; i++ { binary.BigEndian.PutUint64(key, uint64(slice[i])) - rule = append(rule, weight(Hash(key), hash)) + rule = append(rule, Hash(key)) } case []uint64: var key = make([]byte, 32) for i := 0; i < length; i++ { binary.BigEndian.PutUint64(key, slice[i]) - rule = append(rule, weight(Hash(key), hash)) + rule = append(rule, Hash(key)) } case []string: for i := 0; i < length; i++ { - rule = append(rule, weight(hash, - Hash([]byte(slice[i])))) + rule = append(rule, Hash([]byte(slice[i]))) } default: @@ -154,7 +153,7 @@ func SortSliceByValue(slice interface{}, hash uint64) { for i := 0; i < length; i++ { h := val.Index(i).Interface().(Hasher) - rule = append(rule, weight(hash, h.Hash())) + rule = append(rule, h.Hash()) } } diff --git a/hrw_test.go b/hrw_test.go index 5f5a1dd..5fd86b8 100644 --- a/hrw_test.go +++ b/hrw_test.go @@ -50,12 +50,12 @@ func Example() { } // Output: - // trying GET four.example.com/examples/object-key // trying GET three.example.com/examples/object-key - // trying GET one.example.com/examples/object-key // trying GET two.example.com/examples/object-key - // trying GET six.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 { @@ -74,7 +74,7 @@ func TestSortSliceByIndex(t *testing.T) { func TestSortSliceByValue(t *testing.T) { actual := []string{"a", "b", "c", "d", "e", "f"} - expect := []string{"d", "b", "a", "f", "c", "e"} + expect := []string{"d", "f", "c", "b", "a", "e"} hash := Hash(testKey) SortSliceByValue(actual, hash) if !reflect.DeepEqual(actual, expect) { @@ -144,7 +144,7 @@ func TestSortSliceByValueFail(t *testing.T) { func TestSortSliceByValueHasher(t *testing.T) { actual := []hashString{"a", "b", "c", "d", "e", "f"} - expect := []hashString{"d", "b", "a", "f", "c", "e"} + expect := []hashString{"d", "f", "c", "b", "a", "e"} hash := Hash(testKey) SortSliceByValue(actual, hash) if !reflect.DeepEqual(actual, expect) { @@ -156,42 +156,42 @@ func TestSortSliceByValueIntSlice(t *testing.T) { cases := []slices{ { actual: []int{0, 1, 2, 3, 4, 5}, - expect: []int{2, 3, 1, 4, 0, 5}, + expect: []int{2, 0, 5, 3, 1, 4}, }, { actual: []uint{0, 1, 2, 3, 4, 5}, - expect: []uint{2, 3, 1, 4, 0, 5}, + expect: []uint{2, 0, 5, 3, 1, 4}, }, { actual: []int8{0, 1, 2, 3, 4, 5}, - expect: []int8{2, 0, 5, 1, 4, 3}, + expect: []int8{5, 2, 1, 4, 0, 3}, }, { actual: []uint8{0, 1, 2, 3, 4, 5}, - expect: []uint8{2, 0, 5, 1, 4, 3}, + expect: []uint8{5, 2, 1, 4, 0, 3}, }, { actual: []int16{0, 1, 2, 3, 4, 5}, - expect: []int16{5, 4, 0, 3, 2, 1}, + expect: []int16{1, 0, 3, 2, 4, 5}, }, { actual: []uint16{0, 1, 2, 3, 4, 5}, - expect: []uint16{5, 4, 0, 3, 2, 1}, + expect: []uint16{1, 0, 3, 2, 4, 5}, }, { actual: []int32{0, 1, 2, 3, 4, 5}, - expect: []int32{1, 3, 5, 4, 2, 0}, + expect: []int32{5, 1, 2, 0, 3, 4}, }, { actual: []uint32{0, 1, 2, 3, 4, 5}, - expect: []uint32{1, 3, 5, 4, 2, 0}, + expect: []uint32{5, 1, 2, 0, 3, 4}, }, { @@ -201,12 +201,12 @@ func TestSortSliceByValueIntSlice(t *testing.T) { { actual: []int64{0, 1, 2, 3, 4, 5}, - expect: []int64{1, 5, 3, 4, 2, 0}, + expect: []int64{5, 3, 0, 1, 4, 2}, }, { actual: []uint64{0, 1, 2, 3, 4, 5}, - expect: []uint64{1, 5, 3, 4, 2, 0}, + expect: []uint64{5, 3, 0, 1, 4, 2}, }, } hash := Hash(testKey) @@ -253,7 +253,7 @@ func TestUniformDistribution(t *testing.T) { } for i = 0; i < keys; i++ { - binary.BigEndian.PutUint64(key, i) + binary.BigEndian.PutUint64(key, i+size) hash := Hash(key) counts[SortByWeight(nodes[:], hash)[0]]++ } @@ -293,7 +293,7 @@ func TestUniformDistribution(t *testing.T) { for i = 0; i < keys; i++ { copy(b[:], a[:]) - binary.BigEndian.PutUint64(key, i) + binary.BigEndian.PutUint64(key, i+size) hash := Hash(key) SortSliceByIndex(b[:], hash) counts[b[0]]++ @@ -333,7 +333,7 @@ func TestUniformDistribution(t *testing.T) { for i = 0; i < keys; i++ { copy(b[:], a[:]) - binary.BigEndian.PutUint64(key, i) + binary.BigEndian.PutUint64(key, i+size) hash := Hash(key) SortSliceByValue(b[:], hash) counts[b[0]]++ @@ -373,7 +373,7 @@ func TestUniformDistribution(t *testing.T) { for i = 0; i < keys; i++ { copy(b[:], a[:]) - binary.BigEndian.PutUint64(key, i) + binary.BigEndian.PutUint64(key, i+size) hash := Hash(key) SortSliceByValue(b[:], hash) counts[b[0]]++ @@ -413,7 +413,7 @@ func TestUniformDistribution(t *testing.T) { for i = 0; i < keys; i++ { copy(b[:], a[:]) - binary.BigEndian.PutUint64(key, i) + binary.BigEndian.PutUint64(key, i+size) hash := Hash(key) SortSliceByValue(b[:], hash) counts[b[0]]++ @@ -447,7 +447,7 @@ func TestUniformDistribution(t *testing.T) { ) for i = 0; i < keys; i++ { - binary.BigEndian.PutUint64(key, i) + binary.BigEndian.PutUint64(key, i+size) hash := Hash(key) counts[hash]++ }