Add benchmarks

Author: fpetkovski

README.md

@@ -8,9 +8,46 @@ This library implements several state-of-the-art compression algorithms for time
 
 - **ALP (Adaptive Lossless floating-Point)** - Lossless compression for float64 values using adaptive scaling and bit-packing
 - **Delta Encoding** - First-order delta encoding for int32/int64 values
-- **Delta-of-Delta (DoD)** - Second-order delta encoding for highly correlated timeseries
+- **Delta-of-Delta (DoD)** - Second-order delta encoding for regular timeseries
 - **Bitpacking** - Low-level bit manipulation with architecture-specific optimizations (amd64, arm64)
 
+## Benchmarks
+
+Compressing timeseries data with timestamps and float values:
+
+```go
+// Compress 120 samples of timestamps and floats
+timestamps := []int64{...}  // Unix millisecond timestamps
+values := []float64{...}     // Sensor readings, prices, etc.
+
+// Encode using Delta-of-Delta + ALP
+compressedTimestamps := dod.EncodeInt64(nil, timestamps)
+compressedValues := alp.Encode(nil, values)
+
+// Decode back to original data
+var decodedTimestamps [120]int64
+var decodedValues [120]float64
+dod.DecodeInt64(decodedTimestamps[:], compressedTimestamps)
+alp.Decode(decodedValues[:], compressedValues)
+```
+
+Performance comparison vs Gorilla (XOR) compression from Prometheus (Apple M3, 120 samples):
+
+| Codec | Operation | Time/op | Throughput | Compressed Size | Allocs |
+|-------|-----------|---------|------------|-----------------|--------|
+| Gorilla | Encode | 3321 ns/op | - | 982 bytes | 7 allocs/op |
+| Gorilla | Decode | 1715 ns/op | - | - | 1 allocs/op |
+| ALP+DoD | Encode | **1406 ns/op** | **2.4x faster** | **840 bytes** | 6 allocs/op |
+| ALP+DoD | Decode | **252 ns/op** | **6.8x faster, 3330 MB/s** | - | **0 allocs/op** |
+
+Run benchmarks:
+```bash
+cd benchmarks
+go test -bench=BenchmarkFloats -benchmem
+```
+
+See [benchmarks/gorilla_bench_test.go](benchmarks/gorilla_bench_test.go) for implementation details.
+
 ## Installation
 
 ```bash
@@ -34,11 +71,11 @@ func main() {
     data := []float64{1.1, 2.2, 3.3, 4.4, 5.5}
     // Compress
 	compressed := make([]byte, 10)
-	compressed = alp.Compress(compressed, data)
+	compressed = alp.Encode(compressed, data)
 
     // Decompress
     decompressed := make([]float64, len(data))
-    alp.Decompress(decompressed, compressed)
+    alp.Decode(decompressed, compressed)
 
     // Calculate compression ratio
     ratio := alp.CompressionRatio(len(data), len(compressed))

alp/alp.go

@@ -46,8 +46,8 @@ type CompressionMetadata struct {
 	ConstantValue float64
 }
 
-// Compress compresses an array of float64 values using ALP
-func Compress(dst []byte, data []float64) []byte {
+// Encode compresses an array of float64 values using ALP
+func Encode(dst []byte, data []float64) []byte {
 	if len(data) == 0 {
 		return encodeMetadata(CompressionMetadata{
 			EncodingType: EncodingNone,
@@ -117,8 +117,8 @@ func Compress(dst []byte, data []float64) []byte {
 	return result
 }
 
-// Decompress decompresses ALP-encoded data
-func Decompress(dst []float64, data []byte) []float64 {
+// Decode decompresses ALP-encoded data
+func Decode(dst []float64, data []byte) []float64 {
 	if len(data) == 0 {
 		return dst[:0]
 	}

alp/alp_test.go

@@ -114,12 +114,12 @@ func TestALPCompression(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			// Compress
-			compressed := Compress(nil, tt.data)
+			// Encode
+			compressed := Encode(nil, tt.data)
 
-			// Decompress
+			// Decode
 			decompressed := make([]float64, len(tt.data))
-			decompressed = Decompress(decompressed, compressed)
+			decompressed = Decode(decompressed, compressed)
 
 			// Verify length
 			if len(decompressed) != len(tt.data) {
@@ -148,9 +148,9 @@ func TestALPRandomDataset(t *testing.T) {
 		data[i] = randGen.Float64() * 1e10
 	}
 
-	compressed := Compress(nil, data)
+	compressed := Encode(nil, data)
 	decompressed := make([]float64, len(data))
-	decompressed = Decompress(decompressed, compressed)
+	decompressed = Decode(decompressed, compressed)
 
 	if len(decompressed) != len(data) {
 		t.Errorf("Length mismatch: got %d, want %d", len(decompressed), len(data))
@@ -182,9 +182,9 @@ func TestALPLargeDataset(t *testing.T) {
 		data[i] = float64(i) * 0.1
 	}
 
-	compressed := Compress(nil, data)
+	compressed := Encode(nil, data)
 	decompressed := make([]float64, len(data))
-	decompressed = Decompress(decompressed, compressed)
+	decompressed = Decode(decompressed, compressed)
 	if len(decompressed) != len(data) {
 		t.Errorf("Length mismatch: got %d, want %d", len(decompressed), len(data))
 	}

alp/benchmark_test.go

@@ -25,29 +25,29 @@ func BenchmarkALP(b *testing.B) {
 		dataset[i] = randGen.Float64() * 1000
 	}
 
-	compressed := Compress(nil, dataset)
+	compressed := Encode(nil, dataset)
 	b.Run("CompressionSpeed", func(b *testing.B) {
 		for _, size := range benchmarkSizes {
 			data := dataset[:size]
 			b.Run(strconv.Itoa(size), func(b *testing.B) {
 				b.SetBytes(int64(size * 8))
 				b.ResetTimer()
 				for b.Loop() {
-					_ = Compress(compressed, data)
+					_ = Encode(compressed, data)
 				}
 			})
 		}
 	})
 
 	b.Run("DecompressionSpeed", func(b *testing.B) {
 		for _, size := range benchmarkSizes {
-			compressed := Compress(compressed, dataset[:size])
+			compressed := Encode(compressed, dataset[:size])
 			decompressed := make([]float64, size)
 			b.Run(strconv.Itoa(size), func(b *testing.B) {
 				b.SetBytes(int64(size * 8))
 				b.ResetTimer()
 				for b.Loop() {
-					_ = Decompress(decompressed, compressed)
+					_ = Decode(decompressed, compressed)
 				}
 			})
 		}
@@ -96,24 +96,24 @@ func BenchmarkALP(b *testing.B) {
 
 		for patternName, generator := range patterns {
 			data := generator()
-			b.Run("Compress/"+patternName, func(b *testing.B) {
+			b.Run("Encode/"+patternName, func(b *testing.B) {
 				b.SetBytes(int64(size * 8))
 				b.ResetTimer()
 				for b.Loop() {
-					_ = Compress(compressed, data)
+					_ = Encode(compressed, data)
 				}
 			})
 		}
 
 		for patternName, generator := range patterns {
 			data := generator()
-			compressed = Compress(compressed, data)
+			compressed = Encode(compressed, data)
 			decompressed := make([]float64, size)
-			b.Run("Decompress/"+patternName, func(b *testing.B) {
+			b.Run("Decode/"+patternName, func(b *testing.B) {
 				b.SetBytes(int64(size * 8))
 				b.ResetTimer()
 				for b.Loop() {
-					_ = Decompress(decompressed, compressed)
+					_ = Decode(decompressed, compressed)
 				}
 			})
 		}