bloomfilter: load offset values directly

                      │ baseline.log │              field.log              │
                      │    sec/op    │   sec/op     vs base                │
FilterAdd/Add-32        34.23n ± 27%   24.99n ± 3%  -26.99% (p=0.000 n=10)
FilterAdd/Contains-32   26.53n ± 18%   25.72n ± 3%        ~ (p=0.724 n=10)
geomean                 30.14n         25.35n       -15.87%

Change-Id: I0c9e186700f8b94539a7f18ff73a6c525f1a8ae4

Author: egonelbre

bloomfilter/filter.go

@@ -36,17 +36,23 @@ type Filter struct {
 	hashCount byte
 	table     []byte
 
-	tableSize fastdiv.Uint64
+	offset      byte
+	rangeOffset byte
+	tableSize   fastdiv.Uint64
 }
 
 // NewExplicit returns a new filter with the explicit seed and parameters.
 func NewExplicit(seed, hashCount byte, sizeInBytes int) *Filter {
+	offset, rangeOffset := initialConditions(seed)
+
 	return &Filter{
 		seed:      seed,
 		hashCount: hashCount,
 		table:     make([]byte, sizeInBytes),
 
-		tableSize: fastdiv.NewUint64(uint64(sizeInBytes)),
+		offset:      offset,
+		rangeOffset: rangeOffset,
+		tableSize:   fastdiv.NewUint64(uint64(sizeInBytes)),
 	}
 }
 
@@ -82,59 +88,57 @@ func (filter *Filter) Add(pieceID storj.PieceID) {
 	copy(id[:], pieceID[:])
 	copy(id[len(pieceID):], pieceID[:])
 
-	offset, rangeOffset := initialConditions(filter.seed)
-	for k := byte(0); k < filter.hashCount; k++ {
+	offset, rangeOffset := filter.offset, filter.rangeOffset
+	for h := int(filter.hashCount); h > 0; h-- {
 		hash, bit := binary.LittleEndian.Uint64(id[offset:offset+8]), id[offset+8]
-		offset = (offset + rangeOffset) % len(storj.PieceID{})
-
 		bucket := filter.tableSize.Mod(hash)
 		filter.table[bucket] |= 1 << (bit % 8)
+		offset = (offset + rangeOffset) % byte(len(storj.PieceID{}))
 	}
 }
 
-// AddFilter adds the given filter into the receiver. The filters
-// must have a matching seed and parameters.
-func (filter *Filter) AddFilter(operand *Filter) error {
-	switch {
-	case filter.seed != operand.seed:
-		return errs.New("cannot merge: mismatched seed: expected %d but got %d", filter.seed, operand.seed)
-	case filter.hashCount != operand.hashCount:
-		return errs.New("cannot merge: mismatched hash count: expected %d but got %d", filter.hashCount, operand.hashCount)
-	case len(filter.table) != len(operand.table):
-		return errs.New("cannot merge: mismatched table size: expected %d but got %d", len(filter.table), len(operand.table))
-	}
-	for i := 0; i < len(filter.table); i++ {
-		filter.table[i] |= operand.table[i]
-	}
-	return nil
-}
-
 // Contains return true if pieceID may be in the set.
 func (filter *Filter) Contains(pieceID storj.PieceID) bool {
 	var id [len(pieceID) * 2]byte
 	copy(id[:], pieceID[:])
 	copy(id[len(pieceID):], pieceID[:])
 
-	offset, rangeOffset := initialConditions(filter.seed)
+	offset, rangeOffset := filter.offset, filter.rangeOffset
 	for k := byte(0); k < filter.hashCount; k++ {
 		hash, bit := binary.LittleEndian.Uint64(id[offset:offset+8]), id[offset+8]
-		offset = (offset + rangeOffset) % len(storj.PieceID{})
-
 		bucket := filter.tableSize.Mod(hash)
 		if filter.table[bucket]&(1<<(bit%8)) == 0 {
 			return false
 		}
+		offset = (offset + rangeOffset) % byte(len(storj.PieceID{}))
 	}
 
 	return true
 }
 
-func initialConditions(seed byte) (initialOffset, rangeOffset int) {
-	initialOffset = int(seed % 32)
-	rangeOffset = int(rangeOffsets[int(seed/32)%len(rangeOffsets)])
+func initialConditions(seed byte) (initialOffset, rangeOffset byte) {
+	initialOffset = seed % 32
+	rangeOffset = rangeOffsets[int(seed/32)%len(rangeOffsets)]
 	return initialOffset, rangeOffset
 }
 
+// AddFilter adds the given filter into the receiver. The filters
+// must have a matching seed and parameters.
+func (filter *Filter) AddFilter(operand *Filter) error {
+	switch {
+	case filter.seed != operand.seed:
+		return errs.New("cannot merge: mismatched seed: expected %d but got %d", filter.seed, operand.seed)
+	case filter.hashCount != operand.hashCount:
+		return errs.New("cannot merge: mismatched hash count: expected %d but got %d", filter.hashCount, operand.hashCount)
+	case len(filter.table) != len(operand.table):
+		return errs.New("cannot merge: mismatched table size: expected %d but got %d", len(filter.table), len(operand.table))
+	}
+	for i := 0; i < len(filter.table); i++ {
+		filter.table[i] |= operand.table[i]
+	}
+	return nil
+}
+
 // NewFromBytes decodes the filter from a sequence of bytes.
 //
 // Note: data will be referenced inside the table.
@@ -155,6 +159,7 @@ func NewFromBytes(data []byte) (*Filter, error) {
 		return nil, errs.New("invalid hash count %d", filter.hashCount)
 	}
 
+	filter.offset, filter.rangeOffset = initialConditions(filter.seed)
 	filter.tableSize = fastdiv.NewUint64(uint64(len(filter.table)))
 
 	return filter, nil