From b4f6dd0edcf15a96160155754f05616146ebdd97 Mon Sep 17 00:00:00 2001
From: Perfloop Agent <agent@perfloop.ai>
Date: Wed, 19 Aug 2026 13:49:52 +0000
Subject: [PATCH 1/2] Add SumBigValues benchmark

---
 roaring64/bsi64_test.go | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/roaring64/bsi64_test.go b/roaring64/bsi64_test.go
index 39dbdcde..1a06371a 100644
--- a/roaring64/bsi64_test.go
+++ b/roaring64/bsi64_test.go
@@ -822,6 +822,31 @@ func TestSumWithNil(t *testing.T) {
 	assert.Equal(t, int64(0), sum)
 }
 
+func BenchmarkBSI64SumBigValues(b *testing.B) {
+	const valueCount = 128
+
+	bsi := NewBSI(Max64BitSigned, 0)
+	foundSet := bsi.GetExistenceBitmap()
+	want := new(big.Int)
+	for columnID := uint64(0); columnID < valueCount; columnID++ {
+		value := int64(columnID)
+		bsi.SetValue(columnID, value)
+		want.Add(want, big.NewInt(value))
+	}
+	if bsi.BitCount() != 63 {
+		b.Fatalf("BitCount() = %d, want 63", bsi.BitCount())
+	}
+
+	var sum *big.Int
+	var count uint64
+	for b.Loop() {
+		sum, count = bsi.SumBigValues(foundSet)
+	}
+	if count != valueCount || sum.Cmp(want) != 0 {
+		b.Fatalf("SumBigValues() = (%v, %d), want (%v, %d)", sum, count, want, valueCount)
+	}
+}
+
 func TestTransposeWithCountsNil(t *testing.T) {
 	bsi := setup()
 	bsi.SetValue(101, 50)

From 83c91fb8d27e44ca589efee80e650a086e8c12f0 Mon Sep 17 00:00:00 2001
From: Perfloop Agent <agent@perfloop.ai>
Date: Wed, 19 Aug 2026 13:51:37 +0000
Subject: [PATCH 2/2] Avoid goroutine fan-out in SumBigValues

---
 roaring64/bsi64.go      | 26 ++++++++++----------------
 roaring64/bsi64_test.go | 41 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+), 16 deletions(-)

diff --git a/roaring64/bsi64.go b/roaring64/bsi64.go
index 134eb58c..a58d8e0c 100644
--- a/roaring64/bsi64.go
+++ b/roaring64/bsi64.go
@@ -1131,22 +1131,16 @@ func (b *BSI) SumBigValues(foundSet *Bitmap) (sum *big.Int, count uint64) {
 	}
 	sum = new(big.Int)
 	count = foundSet.GetCardinality()
-	resultsChan := make(chan int64, b.BitCount())
-	var wg sync.WaitGroup
-	for i := 0; i < b.BitCount(); i++ {
-		wg.Add(1)
-		go func(j int) {
-			defer wg.Done()
-			resultsChan <- int64(foundSet.AndCardinality(&b.bA[j]) << uint(j))
-		}(i)
-	}
-	wg.Wait()
-	close(resultsChan)
-
-	for val := range resultsChan {
-		sum.Add(sum, big.NewInt(val))
-	}
-	sum.Sub(sum, big.NewInt(int64(foundSet.AndCardinality(&b.bA[b.BitCount()])<<uint(b.BitCount()))))
+	bitCount := b.BitCount()
+	var temp big.Int
+	for i := 0; i < bitCount; i++ {
+		temp.SetUint64(foundSet.AndCardinality(&b.bA[i]))
+		temp.Lsh(&temp, uint(i))
+		sum.Add(sum, &temp)
+	}
+	temp.SetUint64(foundSet.AndCardinality(&b.bA[bitCount]))
+	temp.Lsh(&temp, uint(bitCount))
+	sum.Sub(sum, &temp)
 
 	return sum, count
 }
diff --git a/roaring64/bsi64_test.go b/roaring64/bsi64_test.go
index 1a06371a..d514f817 100644
--- a/roaring64/bsi64_test.go
+++ b/roaring64/bsi64_test.go
@@ -822,6 +822,47 @@ func TestSumWithNil(t *testing.T) {
 	assert.Equal(t, int64(0), sum)
 }
 
+func TestSumBigValues(t *testing.T) {
+	positive := new(big.Int).Lsh(big.NewInt(1), 149)
+	positive.Add(positive, big.NewInt(7))
+	negative := new(big.Int).Lsh(big.NewInt(1), 120)
+	negative.Neg(negative)
+	negative.Sub(negative, big.NewInt(11))
+	values := []struct {
+		columnID uint64
+		value    *big.Int
+	}{
+		{1, big.NewInt(-9)},
+		{2, positive},
+		{3, negative},
+		{4, big.NewInt(7)},
+	}
+
+	bsi := NewDefaultBSI()
+	want := new(big.Int)
+	for _, value := range values {
+		bsi.SetBigValue(value.columnID, value.value)
+		want.Add(want, value.value)
+	}
+
+	filteredWant := new(big.Int).Add(values[0].value, values[2].value)
+	for _, test := range []struct {
+		name     string
+		foundSet *Bitmap
+		want     *big.Int
+		count    uint64
+	}{
+		{"all", nil, want, uint64(len(values))},
+		{"filtered", BitmapOf(1, 3), filteredWant, 2},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			sum, count := bsi.SumBigValues(test.foundSet)
+			assert.Equal(t, test.count, count)
+			assert.Zero(t, sum.Cmp(test.want))
+		})
+	}
+}
+
 func BenchmarkBSI64SumBigValues(b *testing.B) {
 	const valueCount = 128