refactor(balancer): dataplane/controlplane/cli

.editorconfig

@@ -0,0 +1,10 @@
+root = true
+
+[*.{c,h}]
+indent_style = tab
+indent_size = 8
+tab_width = 8
+
+[*.proto]
+indent_style = space
+indent_size = 2

api/agent.h

@@ -212,3 +212,9 @@ int
 agent_storage_put(
 	struct agent *agent, const char *name, void *data, size_t size
 );
+
+void *
+agent_alloc(struct agent *agent, size_t size);
+
+void
+agent_free(struct agent *agent, void *ptr, size_t size);

balancer.yaml

@@ -10,7 +10,7 @@ packet_handler:
     - addr: "192.0.2.1"
       port: 80
       proto: TCP  # Accepts: TCP, tcp
-      scheduler: SOURCE_HASH  # Accepts: SOURCE_HASH, source_hash, SH, sh
+      scheduler: sh
       flags:
         gre: false
         fix_mss: true
@@ -28,11 +28,6 @@ packet_handler:
           weight: 100
           src_addr: "192.0.2.1"
           src_mask: "255.255.255.255"
-        - ip: "10.1.1.2"
-          port: 0
-          weight: 50
-          src_addr: "192.0.2.1"
-          src_mask: "255.255.255.255"
       peers:
         - "192.0.2.10"
         - "192.0.2.11"
@@ -42,7 +37,7 @@ packet_handler:
     - addr: "192.0.2.2"
       port: 443
       proto: tcp  # Lowercase also accepted
-      scheduler: round_robin  # Accepts: ROUND_ROBIN, round_robin, RR, rr
+      scheduler: wrr
       flags:
         gre: false
         fix_mss: true
@@ -76,7 +71,7 @@ packet_handler:
     - addr: "192.0.2.4"
       port: 53
       proto: UDP
-      scheduler: SH  # Short form
+      scheduler: sh
       flags:
         gre: false
         fix_mss: false
@@ -104,7 +99,7 @@ packet_handler:
     - addr: "192.0.2.3"
       port: 0  # MUST be 0 for pure_l3 mode
       proto: tcp
-      scheduler: sh  # Short form lowercase
+      scheduler: wrr
       flags:
         gre: false
         fix_mss: false
@@ -126,7 +121,7 @@ packet_handler:
     - addr: "2001:db8::1"
       port: 443
       proto: TCP
-      scheduler: RR
+      scheduler: wrr
       flags:
         gre: false
         fix_mss: true
@@ -160,7 +155,6 @@ packet_handler:
     tcp_fin: 10
     tcp: 60
     udp: 30
-    default: 60
 
 # State management configuration
 state:

cli/modules/counters/src/main.rs

@@ -448,16 +448,8 @@ fn format_batch_counter(counter: &PerfCounter, next_min_batch: Option<u32>, widt
     let total_bytes = counter.bytes;
 
     // Average latency per packet and per batch
-    let avg_latency_per_packet = if total_packets > 0 {
-        counter.summary_latency / total_packets
-    } else {
-        0
-    };
-    let avg_latency_per_batch = if total_batches > 0 {
-        counter.summary_latency / total_batches
-    } else {
-        0
-    };
+    let avg_latency_per_packet = counter.summary_latency.checked_div(total_packets).unwrap_or(0);
+    let avg_latency_per_batch = counter.summary_latency.checked_div(total_batches).unwrap_or(0);
 
     // Line 1: Total batches, packets, and bytes
     let total_content = format!(

common/btree/u32.h

@@ -294,7 +294,7 @@ btree_u32_init(
 	// Initialize all blocks with maximum value (last element)
 	// This ensures sentinel values for incomplete blocks
 	if (n > 0) {
-		uint32_t max_val = data[n - 1];
+		uint32_t max_val = data[n - 1] ^ 0x80000000;
 		size_t total_values = nblocks * BTREE_U32_BLOCK_SIZE;
 		for (size_t i = 0; i < total_values; ++i) {
 			uint32_t *ptr = (uint32_t *)big_array_get(

common/btree/u64.h

@@ -5,7 +5,6 @@
 #include <immintrin.h>
 #include <stddef.h>
 #include <stdint.h>
-#include <stdio.h>
 #include <string.h>
 
 /**
@@ -304,7 +303,7 @@ btree_u64_init(
 	// Initialize all blocks with maximum value (last element)
 	// This ensures sentinel values for incomplete blocks
 	if (n > 0) {
-		uint64_t max_val = data[n - 1];
+		uint64_t max_val = data[n - 1] ^ 0x8000000000000000ULL;
 		size_t total_values = nblocks * BTREE_U64_BLOCK_SIZE;
 		for (size_t i = 0; i < total_values; ++i) {
 			uint64_t *ptr = (uint64_t *)big_array_get(

common/go/relptr/relptr.go

@@ -0,0 +1,78 @@
+package relptr
+
+import "unsafe"
+
+// Deref resolves a relative pointer field to *T.
+//
+// A relative pointer P stores the offset from its own address to the target:
+//
+//	target = &P + P  (when P != 0)
+//	target = nil     (when P == 0)
+//
+// This mirrors the C macro ADDR_OF from common/memory_address.h.
+// The field parameter must be a pointer to a pointer field (e.g. &vs.Reals).
+func Deref[T any](field **T) *T {
+	raw := (*uintptr)(unsafe.Pointer(field))
+	offset := *raw
+	if offset == 0 {
+		return nil
+	}
+	return (*T)(unsafe.Pointer(offset + uintptr(unsafe.Pointer(field))))
+}
+
+// Slice resolves a relative pointer field to a []T slice over contiguous
+// memory. The returned slice shares the underlying memory (zero-copy).
+func Slice[T any](field **T, count uint32) []T {
+	if count == 0 {
+		return nil
+	}
+	ptr := Deref(field)
+	if ptr == nil {
+		return nil
+	}
+	return unsafe.Slice(ptr, count)
+}
+
+// Set makes a relative pointer field point to ptr.
+//
+// This mirrors the C macro SET_OFFSET_OF from common/memory_address.h.
+func Set[T any](field **T, ptr *T) {
+	raw := (*uintptr)(unsafe.Pointer(field))
+	if ptr == nil {
+		*raw = 0
+		return
+	}
+	*raw = uintptr(unsafe.Pointer(ptr)) - uintptr(unsafe.Pointer(field))
+}
+
+func Equate[T any](dst **T, src **T) {
+	Set(dst, Deref(src))
+}
+
+func SetSlice[T any](field **T, ptr []T) {
+	if len(ptr) == 0 {
+		Set(field, nil)
+		return
+	}
+	Set(field, &ptr[0])
+}
+
+// DerefOpaque resolves a relative pointer stored in a uintptr field.
+// Use this for opaque pointer fields (e.g. filter, selector) where
+// the concrete type is not known to Go.
+func DerefOpaque(field *uintptr) unsafe.Pointer {
+	offset := *field
+	if offset == 0 {
+		return nil
+	}
+	return unsafe.Pointer(offset + uintptr(unsafe.Pointer(field)))
+}
+
+// SetOpaque makes a uintptr relative pointer field point to addr.
+func SetOpaque(field *uintptr, addr unsafe.Pointer) {
+	if addr == nil {
+		*field = 0
+		return
+	}
+	*field = uintptr(addr) - uintptr(unsafe.Pointer(field))
+}