Optimize BSI64 BatchEqual cube patterns

Author: guymolinari

roaring64/bsi64.go

@@ -1004,6 +1004,12 @@ func (b *BSI) BatchEqual(parallelism int, values []int64) *Bitmap {
 	}
 
 	sort.Slice(vals, func(i, j int) bool { return vals[i] < vals[j] })
+	if result, ok := b.matchInt64Cube(vals, bitCount); ok {
+		if b.runOptimized {
+			result.RunOptimize()
+		}
+		return result
+	}
 	result := b.matchInt64Trie(vals, bitCount, &b.eBM, false)
 	if b.runOptimized {
 		result.RunOptimize()
@@ -1028,6 +1034,56 @@ func encodeBSI64Value(value int64, bitCount int) uint64 {
 	return uint64(value) & mask
 }
 
+func (b *BSI) matchInt64Cube(vals []uint64, bitCount int) (*Bitmap, bool) {
+	if bitCount >= 63 {
+		return nil, false
+	}
+	widthMask := (uint64(1) << uint(bitCount+1)) - 1
+	fixedOnes := vals[0] & widthMask
+	fixedZeros := ^vals[0] & widthMask
+	for _, v := range vals[1:] {
+		fixedOnes &= v
+		fixedZeros &= ^v & widthMask
+	}
+
+	variableMask := ^(fixedOnes | fixedZeros) & widthMask
+	combinations := uint64(1) << uint(countBSI64Bits(variableMask))
+	if uint64(len(vals)) != combinations {
+		return nil, false
+	}
+	for _, v := range vals {
+		if v&fixedOnes != fixedOnes || (^v)&fixedZeros != fixedZeros {
+			return nil, false
+		}
+	}
+
+	result := b.eBM.Clone()
+	for i := 0; i <= bitCount; i++ {
+		bit := uint64(1) << uint(i)
+		if variableMask&bit != 0 {
+			continue
+		}
+		if fixedOnes&bit != 0 {
+			result.And(&b.bA[i])
+		} else {
+			result.AndNot(&b.bA[i])
+		}
+		if result.IsEmpty() {
+			break
+		}
+	}
+	return result, true
+}
+
+func countBSI64Bits(value uint64) int {
+	count := 0
+	for value != 0 {
+		value &= value - 1
+		count++
+	}
+	return count
+}
+
 func (b *BSI) matchInt64Trie(vals []uint64, p int, prefix *Bitmap, owned bool) *Bitmap {
 	if prefix.IsEmpty() {
 		if owned {

roaring64/bsi64_batch_equal_test.go

@@ -135,6 +135,22 @@ func TestBSI64BatchEqualConsistentWithGetValue(t *testing.T) {
 	}
 }
 
+func TestBSI64BatchEqualBitCubePattern(t *testing.T) {
+	bsi := NewDefaultBSI()
+	for col := uint64(0); col < 512; col++ {
+		bsi.SetValue(col, int64(col%256))
+	}
+
+	odds := make([]int64, 0, 128)
+	for v := int64(1); v < 256; v += 2 {
+		odds = append(odds, v)
+	}
+
+	expected := expectedBSI64BatchEqual(bsi, odds)
+	actual := bsi.BatchEqual(0, odds)
+	assert.True(t, actual.Equals(expected), "expected %v got %v", expected.ToArray(), actual.ToArray())
+}
+
 func TestBSI64BatchEqualExistenceAuthority(t *testing.T) {
 	ebm := BitmapOf(1)
 	plane := BitmapOf(1, 2)