Add block serialization benchmark

Author: stringintech

bench/README.md

@@ -0,0 +1,28 @@
+# Benchmarks
+
+## Block Serialization Benchmark
+
+**File:** `block_bytes_bench_test.go`
+
+**What it compares:**
+Two different approaches to serializing blocks to bytes:
+
+1. **Bytes()** - Uses growing slice with dynamic allocations
+2. **PreAllocBytes()** - Pre-allocates slice using `btck_block_get_serialize_size` C API
+
+### Running the Benchmark
+
+```bash
+go test -bench=BenchmarkComparison -benchmem -benchtime=10x ./bench/
+```
+
+### Sample Results
+
+```
+BenchmarkComparison/Bytes         	      10	   7074350 ns/op	10590606 B/op	      43 allocs/op
+BenchmarkComparison/PreAllocBytes 	      10	   6973412 ns/op	 1802627 B/op	       9 allocs/op
+```
+
+- **Memory efficiency**: ~83% reduction in total allocations (10.6MB → 1.8MB)
+- **Allocation count**: ~79% reduction (43 → 9 allocations) 
+- **CPU performance**: ~1.4% improvement (7.07ms → 6.97ms)

bench/block_bytes_bench_test.go

@@ -0,0 +1,55 @@
+package bench
+
+import (
+	"encoding/hex"
+	"github.com/stringintech/go-bitcoinkernel/kernel"
+	"os"
+	"strings"
+	"testing"
+)
+
+func loadTestBlock(tb testing.TB) *kernel.Block {
+	tb.Helper()
+
+	// Load a recent mainnet block
+	hexBytes, err := os.ReadFile("../data/mainnet/block911451.txt")
+	if err != nil {
+		tb.Fatal(err)
+	}
+	hexString := strings.TrimSpace(string(hexBytes))
+
+	bytes, err := hex.DecodeString(hexString)
+	if err != nil {
+		tb.Fatal(err)
+	}
+
+	block, err := kernel.NewBlockFromRaw(bytes)
+	if err != nil {
+		tb.Fatal(err)
+	}
+
+	return block
+}
+
+func BenchmarkComparison(b *testing.B) {
+	block := loadTestBlock(b)
+	defer block.Destroy()
+
+	b.Run("Bytes", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			if _, err := block.Bytes(); err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+
+	b.Run("PreAllocBytes", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			if _, err := block.PreAllocBytes(); err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}

data/mainnet/block911451.txt

@@ -965,8 +965,20 @@ int btck_block_to_bytes(const btck_Block* block, btck_WriteBytes writer, void* u
     }
 }
 
+int btck_block_get_serialize_size(const btck_Block* block)
+{
+    try {
+        return ::GetSerializeSize(TX_WITH_WITNESS(*block->m_block));
+    } catch (...) {
+        return -1;
+    }
+}
+
 int btck_block_pointer_to_bytes(const btck_BlockPointer* block_, btck_WriteBytes writer, void* user_data)
 {
+//    auto*v=new std::vector<char>(500000);
+//    ;delete v;
+
     auto block{cast_const_cblock(block_)};
     try {
         WriterStream ws{writer, user_data};

depend/bitcoin/src/kernel/bitcoinkernel.cpp

@@ -1143,6 +1143,16 @@ BITCOINKERNEL_API int btck_block_to_bytes(
     void* user_data
 ) BITCOINKERNEL_ARG_NONNULL(1, 2);
 
+/*
+ * @brief Returns the serialized size of the block.
+ *
+ * @param[in] block     Non-null.
+ * @return              The size in bytes of the serialized block, or -1 on error.
+ */
+BITCOINKERNEL_API int btck_block_get_serialize_size(
+    const btck_Block* block
+) BITCOINKERNEL_ARG_NONNULL(1);
+
 /*
  * @brief Serializes the block pointer through the passed in callback to bytes.
  * This is consensus serialization that is also used for the p2p network.

depend/bitcoin/src/kernel/bitcoinkernel.h

@@ -49,9 +49,12 @@ class RefWrapper
 };
 
 template <typename T>
-std::vector<std::byte> write_bytes(const T* object, int (*to_bytes)(const T*, btck_WriteBytes, void*))
+std::vector<std::byte> write_bytes(const T* object, int (*to_bytes)(const T*, btck_WriteBytes, void*), size_t initial_size = 0)
 {
     std::vector<std::byte> bytes;
+    if (initial_size > 0) {
+        bytes.reserve(initial_size);
+    }
     struct UserData {
         std::vector<std::byte>* bytes;
         std::exception_ptr exception;

depend/bitcoin/src/kernel/bitcoinkernel_wrapper.h

@@ -5,6 +5,7 @@ package kernel
 */
 import "C"
 import (
+	"fmt"
 	"runtime"
 	"unsafe"
 )
@@ -57,6 +58,21 @@ func (b *Block) Bytes() ([]byte, error) {
 	})
 }
 
+func (b *Block) PreAllocBytes() ([]byte, error) {
+	checkReady(b)
+
+	// Get the serialize size first
+	size := int(C.btck_block_get_serialize_size(b.ptr))
+	if size < 0 {
+		return nil, fmt.Errorf("failed to get serialize size")
+	}
+
+	// Use the callback helper with pre-allocated buffer to collect bytes from btck_block_to_bytes
+	return writeToPreAllocBytes(func(writer C.btck_WriteBytes, userData unsafe.Pointer) C.int {
+		return C.btck_block_to_bytes(b.ptr, writer, userData)
+	}, size)
+}
+
 // Copy creates a copy of the block
 func (b *Block) Copy() (*Block, error) {
 	checkReady(b)

kernel/block.go

@@ -9,6 +9,7 @@ package kernel
 
 // Bridge function: exported Go function that C library can call
 extern int go_writer_callback_bridge(void* bytes, size_t size, void* userdata);
+extern int go_pre_alloc_writer_callback_bridge(void* bytes, size_t size, void* userdata);
 */
 import "C"
 import (
@@ -41,7 +42,14 @@ func go_writer_callback_bridge(bytes unsafe.Pointer, size C.size_t, userdata uns
 // writeToBytes is a helper function that uses a callback pattern to collect bytes
 // It takes a function that calls the C API with the writer callback
 func writeToBytes(writerFunc func(C.btck_WriteBytes, unsafe.Pointer) C.int) ([]byte, error) {
+	return writeToPreAllocBytes(writerFunc, 0)
+}
+
+func writeToPreAllocBytes(writerFunc func(C.btck_WriteBytes, unsafe.Pointer) C.int, preallocSize int) ([]byte, error) {
 	callbackData := &writerCallbackData{}
+	if preallocSize > 0 {
+		callbackData.buffer = make([]byte, 0, preallocSize)
+	}
 
 	// Create cgo handle for the callback data
 	handle := cgo.NewHandle(callbackData)
@@ -57,6 +65,5 @@ func writeToBytes(writerFunc func(C.btck_WriteBytes, unsafe.Pointer) C.int) ([]b
 		return nil, callbackData.err
 	}
 
-	// Return exactly the bytes that were written (slice the buffer to actual size)
 	return callbackData.buffer, nil
 }