Add ring benchmarks

buffer/BUILD.bazel

@@ -7,6 +7,7 @@ go_library(
         "bytes_buffer.go",
         "pool.go",
     ],
+    importpath = "github.com/freshdresch/go-data-structures/buffer",
     visibility = ["//visibility:public"],
 )
 

maps/BUILD.bazel

@@ -3,6 +3,7 @@ load("@rules_go//go:def.bzl", "go_library", "go_test")
 go_library(
     name = "maps",
     srcs = ["maps.go"],
+    importpath = "github.com/freshdresch/go-data-structures/maps",
     visibility = ["//visibility:public"],
 )
 

ring/BUILD.bazel

@@ -3,16 +3,35 @@ load("@rules_go//go:def.bzl", "go_library", "go_test")
 go_library(
     name = "ring",
     srcs = ["ring.go"],
+    importpath = "github.com/freshdresch/go-data-structures/ring",
     visibility = ["//visibility:public"],
 )
 
+# Internal tests (white-box)
 go_test(
-    name = "ring_test",
-    srcs = ["ring_test.go"],
+    name = "ring_internal_test",
+    srcs = [
+        "ring_test.go",
+    ],
     embed = [":ring"],
     deps = [
         "@com_github_stretchr_testify//assert:assert",
         "@com_github_stretchr_testify//require:require",
     ],
     visibility = ["//:__subpackages__"],
 )
+
+# External benchmarks (black-box)
+go_test(
+    name = "ring_bench",
+    srcs = [
+        "channel_bench_test.go",
+        "common_bench_test.go",
+        "mutex_slice_bench_test.go",
+        "ring_bench_test.go",
+    ],
+    deps = [
+        ":ring",
+    ],
+    visibility = ["//:__subpackages__"],
+)

ring/channel_bench_test.go

@@ -0,0 +1,302 @@
+package ring_test
+
+import (
+	"fmt"
+	"sync"
+	"testing"
+)
+
+type ChanWrapper[T any] struct {
+	ch chan T
+}
+
+func NewChanWrapper[T any](capacity int) *ChanWrapper[T] {
+	return &ChanWrapper[T]{ch: make(chan T, capacity)}
+}
+
+func (c *ChanWrapper[T]) EnqueueBurst(batch []T) {
+	for _, v := range batch {
+		c.ch <- v
+	}
+}
+
+func (c *ChanWrapper[T]) DequeueBurst(n int) []T {
+	res := make([]T, 0, n)
+	for i := 0; i < n; i++ {
+		select {
+		case v := <-c.ch:
+			res = append(res, v)
+		default:
+			return res
+		}
+	}
+	return res
+}
+
+func BenchmarkChan_SPSC_Seq(b *testing.B) {
+	for _, size := range payloadSizes {
+		b.Run(fmt.Sprintf("%dB", size), func(b *testing.B) {
+			ch := make(chan []byte, ringSize)
+			payload := make([]byte, size)
+
+			b.SetBytes(int64(size))
+			b.ResetTimer()
+
+			for i := 0; i < b.N; i++ {
+				ch <- payload
+				<-ch
+			}
+		})
+	}
+}
+
+func BenchmarkChan_MPSC_Parallel(b *testing.B) {
+	const producers = 4
+	for _, size := range payloadSizes {
+		b.Run(fmt.Sprintf("%dB", size), func(b *testing.B) {
+			ch := make(chan []byte, 1024)
+			payload := make([]byte, size)
+
+			b.SetBytes(int64(size))
+			b.ResetTimer()
+
+			var wg sync.WaitGroup
+			wg.Add(producers)
+
+			for i := 0; i < producers; i++ {
+				go func() {
+					defer wg.Done()
+					for j := 0; j < b.N; j++ {
+						ch <- payload
+					}
+				}()
+			}
+
+			for i := 0; i < b.N*producers; i++ {
+				<-ch
+			}
+			wg.Wait()
+		})
+	}
+}
+
+func BenchmarkChan_SPMC_Parallel(b *testing.B) {
+	const consumers = 4
+	for _, size := range payloadSizes {
+		b.Run(fmt.Sprintf("%dB", size), func(b *testing.B) {
+			ch := make(chan []byte, 1024)
+			payload := make([]byte, size)
+
+			b.SetBytes(int64(size))
+			b.ResetTimer()
+
+			var wg sync.WaitGroup
+			wg.Add(consumers)
+
+			for i := 0; i < consumers; i++ {
+				go func() {
+					defer wg.Done()
+					for j := 0; j < b.N; j++ {
+						<-ch
+					}
+				}()
+			}
+
+			for i := 0; i < b.N*consumers; i++ {
+				ch <- payload
+			}
+			wg.Wait()
+		})
+	}
+}
+
+func BenchmarkChan_MPMC_Parallel(b *testing.B) {
+	const (
+		producers = 4
+		consumers = 4
+	)
+	for _, size := range payloadSizes {
+		b.Run(fmt.Sprintf("%dB", size), func(b *testing.B) {
+			ch := make(chan []byte, 1024)
+			payload := make([]byte, size)
+
+			b.SetBytes(int64(size))
+			b.ResetTimer()
+
+			var prodWG, consWG sync.WaitGroup
+			prodWG.Add(producers)
+			consWG.Add(consumers)
+
+			for i := 0; i < producers; i++ {
+				go func() {
+					defer prodWG.Done()
+					for j := 0; j < b.N; j++ {
+						ch <- payload
+					}
+				}()
+			}
+
+			for i := 0; i < consumers; i++ {
+				go func() {
+					defer consWG.Done()
+					for j := 0; j < b.N; j++ {
+						<-ch
+					}
+				}()
+			}
+
+			prodWG.Wait()
+			consWG.Wait()
+		})
+	}
+}
+
+func BenchmarkChan_SPSC_Seq_Batch(b *testing.B) {
+	for _, batchSize := range batchSizes {
+		for _, payloadSize := range payloadSizes {
+			b.Run(
+				fmt.Sprintf("batch%d_%dB", batchSize, payloadSize),
+				func(b *testing.B) {
+					ch := make(chan [][]byte, ringSize)
+					payload := make([][]byte, batchSize)
+					for i := range payload {
+						payload[i] = make([]byte, payloadSize)
+					}
+
+					b.SetBytes(int64(payloadSize))
+					b.ResetTimer()
+
+					for i := 0; i < b.N; i++ {
+						ch <- payload
+						<-ch
+					}
+				},
+			)
+		}
+	}
+}
+
+func BenchmarkChan_MPSC_Parallel_Batch(b *testing.B) {
+	const producers = 4
+	for _, batchSize := range batchSizes {
+		for _, payloadSize := range payloadSizes {
+			b.Run(
+				fmt.Sprintf("batch%d_%dB", batchSize, payloadSize),
+				func(b *testing.B) {
+					ch := make(chan [][]byte, ringSize)
+					payload := make([][]byte, batchSize)
+					for i := range payload {
+						payload[i] = make([]byte, payloadSize)
+					}
+
+					b.SetBytes(int64(payloadSize))
+					b.ResetTimer()
+
+					var wg sync.WaitGroup
+					wg.Add(producers)
+
+					for i := 0; i < producers; i++ {
+						go func() {
+							defer wg.Done()
+							for j := 0; j < b.N; j++ {
+								ch <- payload
+							}
+						}()
+					}
+
+					for i := 0; i < b.N*producers; i++ {
+						<-ch
+					}
+					wg.Wait()
+				},
+			)
+		}
+	}
+}
+
+func BenchmarkChan_SPMC_Parallel_Batch(b *testing.B) {
+	const consumers = 4
+	for _, batchSize := range batchSizes {
+		for _, payloadSize := range payloadSizes {
+			b.Run(
+				fmt.Sprintf("batch%d_%dB", batchSize, payloadSize),
+				func(b *testing.B) {
+					ch := make(chan [][]byte, ringSize)
+					payload := make([][]byte, batchSize)
+					for i := range payload {
+						payload[i] = make([]byte, payloadSize)
+					}
+
+					b.SetBytes(int64(payloadSize))
+					b.ResetTimer()
+
+					var wg sync.WaitGroup
+					wg.Add(consumers)
+
+					for i := 0; i < consumers; i++ {
+						go func() {
+							defer wg.Done()
+							for j := 0; j < b.N; j++ {
+								<-ch
+							}
+						}()
+					}
+
+					for i := 0; i < b.N*consumers; i++ {
+						ch <- payload
+					}
+					wg.Wait()
+				},
+			)
+		}
+	}
+}
+
+func BenchmarkChan_MPMC_Parallel_Batch(b *testing.B) {
+	const (
+		producers = 4
+		consumers = 4
+	)
+	for _, batchSize := range batchSizes {
+		for _, payloadSize := range payloadSizes {
+			b.Run(
+				fmt.Sprintf("batch%d_%dB", batchSize, payloadSize),
+				func(b *testing.B) {
+					ch := make(chan [][]byte, ringSize)
+					payload := make([][]byte, batchSize)
+					for i := range payload {
+						payload[i] = make([]byte, payloadSize)
+					}
+
+					b.SetBytes(int64(payloadSize))
+					b.ResetTimer()
+
+					var prodWG, consWG sync.WaitGroup
+					prodWG.Add(producers)
+					consWG.Add(consumers)
+
+					for i := 0; i < producers; i++ {
+						go func() {
+							defer prodWG.Done()
+							for j := 0; j < b.N; j++ {
+								ch <- payload
+							}
+						}()
+					}
+
+					for i := 0; i < consumers; i++ {
+						go func() {
+							defer consWG.Done()
+							for j := 0; j < b.N; j++ {
+								<-ch
+							}
+						}()
+					}
+
+					prodWG.Wait()
+					consWG.Wait()
+				},
+			)
+		}
+	}
+}

ring/common_bench_test.go

@@ -0,0 +1,8 @@
+package ring_test
+
+const ringSize = 1024
+
+var (
+	batchSizes = []int{1, 8, 16, 32, 64}
+	payloadSizes = []int{8, 32, 64, 256, 512} // bytes
+)