refactor(background_agent,hybrid): SPARC protocol implementation and refactoring (#503)

Author: Dmitrii Vasilev

.trinity/mu/heartbeat.json

@@ -1 +1 @@
-{"agent":"mu","wake":139,"timestamp":1775206215,"errors_scanned":0,"fixes_applied":0,"build_ok":false,"test_ok":false}
+{"agent":"mu","wake":145,"timestamp":1775208352,"errors_scanned":0,"fixes_applied":0,"build_ok":false,"test_ok":false}

kaggle/data/upload_tefb_mc/dataset-metadata.json

@@ -0,0 +1,5 @@
+{
+  "title": "TEFB Multiple Choice",
+  "id": "playra/trinity-cognitive-probes-tefb-mc",
+  "licenses": [{"name": "CC0-1.0"}]
+}

kaggle/data/upload_tefb_mc/tefb_mc.csv

@@ -110,7 +110,7 @@ pub const PostgresClient = struct {
         _ = try stream.writeAll(startup_msg);
 
         // Handle authentication
-        try self.handleAuthentication(&stream);
+        try handleAuthentication(&stream);
 
         // Wait for ReadyForQuery
         try self.waitForReady(&stream);
@@ -156,7 +156,7 @@ pub const PostgresClient = struct {
     }
 
     /// Handle authentication response from server
-    fn handleAuthentication(self: *PostgresClient, stream: *net.Stream) !void {
+    fn handleAuthentication(stream: *net.Stream) !void {
         var len_buf: [4]u8 = undefined;
         _ = try stream.readAll(&len_buf);
         const msg_len = std.mem.readInt(u32, &len_buf, .big);
@@ -281,7 +281,7 @@ pub const PostgresClient = struct {
                 try row.values.append("");
             } else {
                 const value_len_usize = @as(usize, @intCast(value_len));
-                var value_buf = try self.allocator.alloc(u8, value_len_usize);
+                const value_buf = try self.allocator.alloc(u8, value_len_usize);
                 _ = try stream.readAll(value_buf);
                 try row.values.append(value_buf);
                 try row.columns.append(""); // Column name not in DataRow
@@ -294,7 +294,7 @@ pub const PostgresClient = struct {
     }
 
     /// Read and parse error response
-    fn readErrorResponse(self: *PostgresClient, stream: *net.Stream, len: u32) !void {
+    fn readErrorResponse(stream: *net.Stream, len: u32) !void {
         var message: [256]u8 = undefined;
         var message_len: usize = 0;
 
@@ -326,7 +326,7 @@ pub const PostgresClient = struct {
 }
 
     /// Skip a message
-    fn skipMessage(self: *PostgresClient, stream: *net.Stream, len: u32) !void {
+    fn skipMessage(stream: *net.Stream, len: u32) !void {
         var buf: [1024]u8 = undefined;
         var remaining: u32 = len;
 
@@ -415,29 +415,29 @@ pub fn buildStartupMessage(allocator: Allocator, user: []const u8, database: []c
     var offset: usize = 0;
 
     // Message length (including self, excluding length field)
-    std.mem.writeInt(u32, msg[offset..][0..4], @intCast(size - 4), .big);
+    std.mem.writeInt(u32, msg[0..4], @intCast(size - 4), .big);
     offset += 4;
 
     // Protocol version 3.0
-    std.mem.writeInt(u32, msg[offset..][0..4], PROTOCOL_VERSION, .big);
+    std.mem.writeInt(u32, msg[4..8], PROTOCOL_VERSION, .big);
     offset += 4;
 
     // User parameter
-    @memcpy(msg[offset..][0..5], "user");
+    @memcpy(msg[offset..offset+5], "user");
     offset += 5;
     msg[offset] = 0;
     offset += 1;
-    @memcpy(msg[offset..][0..user.len], user);
+    @memcpy(msg[offset..offset+user.len], user);
     offset += user.len;
     msg[offset] = 0;
     offset += 1;
 
     // Database parameter
-    @memcpy(msg[offset..][0..9], "database");
+    @memcpy(msg[offset..offset+9], "database");
     offset += 9;
     msg[offset] = 0;
     offset += 1;
-    @memcpy(msg[offset..][0..database.len], database);
+    @memcpy(msg[offset..offset+database.len], database);
     offset += database.len;
     msg[offset] = 0;
     offset += 1;
@@ -457,8 +457,8 @@ pub fn buildQueryMessage(allocator: Allocator, sql: []const u8) ![]u8 {
     errdefer allocator.free(msg);
 
     msg[0] = @intFromEnum(MessageType.Query);
-    std.mem.writeInt(u32, msg[1..][0..4], @intCast(sql.len + 1), .big);
-    @memcpy(msg[5..][0..sql.len], sql);
+    std.mem.writeInt(u32, msg[1..5], @intCast(sql.len + 1), .big);
+    @memcpy(msg[5..5+sql.len], sql);
     msg[5 + sql.len] = 0;
 
     return msg;
@@ -473,8 +473,8 @@ pub fn buildAuthenticationOk(allocator: Allocator) ![]u8 {
     errdefer allocator.free(msg);
 
     msg[0] = @intFromEnum(MessageType.AuthenticationOk);
-    std.mem.writeInt(u32, msg[1..][0..4], 4, .big); // length of auth_code
-    std.mem.writeInt(u32, msg[5..][0..4], 0, .big); // AUTH_OK
+    std.mem.writeInt(u32, msg[1..5], 4, .big); // length of auth_code
+    std.mem.writeInt(u32, msg[5..9], 0, .big); // AUTH_OK
 
     return msg;
 }
@@ -489,9 +489,9 @@ pub fn buildBackendKeyData(allocator: Allocator, pid: i32, key: i32) ![]u8 {
     errdefer allocator.free(msg);
 
     msg[0] = @intFromEnum(MessageType.BackendKeyData);
-    std.mem.writeInt(u32, msg[1..][0..4], 8, .big);
-    std.mem.writeInt(i32, msg[5..][0..4], pid, .big);
-    std.mem.writeInt(i32, msg[9..][0..4], key, .big);
+    std.mem.writeInt(u32, msg[1..5], 8, .big);
+    std.mem.writeInt(i32, msg[5..9], pid, .big);
+    std.mem.writeInt(i32, msg[9..13], key, .big);
 
     return msg;
 }
@@ -506,7 +506,7 @@ pub fn buildReadyForQuery(allocator: Allocator, status: TransactionStatus) ![]u8
     errdefer allocator.free(msg);
 
     msg[0] = @intFromEnum(MessageType.ReadyForQuery);
-    std.mem.writeInt(u32, msg[1..][0..4], 1, .big);
+    std.mem.writeInt(u32, msg[1..5], 1, .big);
     msg[5] = @intFromEnum(status);
 
     return msg;
@@ -522,8 +522,8 @@ pub fn buildCommandComplete(allocator: Allocator, tag: []const u8) ![]u8 {
     errdefer allocator.free(msg);
 
     msg[0] = @intFromEnum(MessageType.CommandComplete);
-    std.mem.writeInt(u32, msg[1..][0..4], @intCast(tag.len + 1), .big);
-    @memcpy(msg[5..][0..tag.len], tag);
+    std.mem.writeInt(u32, msg[1..5], @intCast(tag.len + 1), .big);
+    @memcpy(msg[5..5+tag.len], tag);
     msg[5 + tag.len] = 0;
 
     return msg;
@@ -540,9 +540,9 @@ pub fn buildErrorResponse(allocator: Allocator, message: []const u8) ![]u8 {
     errdefer allocator.free(msg);
 
     msg[0] = @intFromEnum(MessageType.ErrorResponse);
-    std.mem.writeInt(u32, msg[1..][0..4], @intCast(size - 5), .big);
+    std.mem.writeInt(u32, msg[1..5], @intCast(size - 5), .big);
     msg[5] = 'M'; // Message field
-    @memcpy(msg[6..][0..message.len], message);
+    @memcpy(msg[6..6+message.len], message);
     msg[6 + message.len] = 0; // Null terminator for value
     msg[6 + message.len + 1] = 0; // Terminator
 

src/background_agent/db/client.zig

@@ -87,6 +87,7 @@ pub const Server = struct {
             self.handleConnection(connection) catch |err| {
                 std.log.err("Connection error: {}", .{err});
             };
+        }
     }
 
     /// Stop server
@@ -149,8 +150,8 @@ pub const Server = struct {
         var body_len: usize = 0;
         var body_start: usize = request.len;
 
-        for (lines) |line, i| {
-            const offset = if (i == 0) 0 else @intCast(usize, std.mem.indexOfPos(u8, request_str, line, @intCast(i32, @intFrom usize, lines.len - 1))) + line.len;
+        for (lines, 0..) |line, i| {
+            const offset = if (i == 0) 0 else @intCast(usize, std.mem.indexOfPos(u8, request_str, line, @intCast(i32, lines.len - 1))) + line.len;
             if (offset + 2 < request.len and
                 request[offset + 1] == '\r' and request[offset + 2] == '\n')
             {

src/background_agent/server.zig

@@ -238,13 +238,14 @@ pub const HybridBigInt = struct {
 
         self.ensureUnpacked();
 
+        const cache = self.unpacked_cache orelse return;
         const num_packs = (self.trit_len + TRITS_PER_BYTE - 1) / TRITS_PER_BYTE;
         for (0..num_packs) |pack_idx| {
             const base = pack_idx * TRITS_PER_BYTE;
             var trits: [5]Trit = .{ 0, 0, 0, 0, 0 };
             for (0..TRITS_PER_BYTE) |j| {
                 if (base + j < self.trit_len) {
-                    trits[j] = self.unpacked_cache[base + j];
+                    trits[j] = cache[base + j];
                 }
             }
             self.packed_data[pack_idx] = tvc_packed.encodePack(trits);
@@ -372,7 +373,7 @@ pub const HybridBigInt = struct {
             inline for (0..SIMD_WIDTH) |i| {
                 const idx = base + i;
                 a_vec[i] = if (idx < a.trit_len) a.getTritChecked(idx) else 0;
-                b_vec[i] = if (idx < b.trit_len) .getTritChecked(idx) else 0;
+                b_vec[i] = if (idx < b.trit_len) b.getTritChecked(idx) else 0;
             }
 
             const simd_result = simdAddTrits(a_vec, b_vec);
@@ -452,7 +453,7 @@ pub const HybridBigInt = struct {
             for (0..b.trit_len) |j| {
                 if (i + j >= MAX_TRITS) break;
 
-                var prod: i16 = @as(i16, a_trit) * @as(i16, .getTritChecked(j));
+                var prod: i16 = @as(i16, a_trit) * @as(i16, b.getTritChecked(j));
                 prod += result.unpacked_cache[i + j];
                 prod += carry;
                 carry = 0;
@@ -581,28 +582,28 @@ test "HybridBigInt fromI64 and toI64" {
     const cases = [_]i64{ 0, 1, -1, 10, -10, 100, -100, 12345, -12345 };
     for (cases) |val| {
         var hybrid = HybridBigInt.fromI64(val);
-        const back = hybrid.toI64();
+        const back = hybrid.toI64(std.testing.allocator);
         try std.testing.expectEqual(val, back);
     }
 }
 
 test "HybridBigInt addition" {
     var a = HybridBigInt.fromI64(123);
     var b = HybridBigInt.fromI64(456);
-    var sum = a.add(&b);
-    try std.testing.expectEqual(@as(i64, 579), sum.toI64());
+    var sum = a.add(&b, std.testing.allocator);
+    try std.testing.expectEqual(@as(i64, 579), sum.toI64(std.testing.allocator));
 }
 
 test "HybridBigInt multiplication" {
     var a = HybridBigInt.fromI64(12);
     var b = HybridBigInt.fromI64(34);
-    var prod = a.mul(&b);
-    try std.testing.expectEqual(@as(i64, 408), prod.toI64());
+    var prod = a.mul(&b, std.testing.allocator);
+    try std.testing.expectEqual(@as(i64, 408), prod.toI64(std.testing.allocator));
 }
 
 test "HybridBigInt pack/unpack roundtrip" {
     var hybrid = HybridBigInt.fromI64(12345);
-    const val1 = hybrid.toI64();
+    const val1 = hybrid.toI64(std.testing.allocator);
 
     // Force pack
     hybrid.pack();
@@ -612,7 +613,7 @@ test "HybridBigInt pack/unpack roundtrip" {
     _ = hybrid.getTrit(0);
     try std.testing.expectEqual(StorageMode.unpacked_mode, hybrid.mode);
 
-    const val2 = hybrid.toI64();
+    const val2 = hybrid.toI64(std.testing.allocator);
     try std.testing.expectEqual(val1, val2);
 }
 
@@ -627,13 +628,13 @@ test "HybridBigInt memory efficiency" {
 test "HybridBigInt conversion from BigInt" {
     const val: i64 = 12345;
     const big = tvc_bigint.TVCBigInt.fromI64(val);
-    var hybrid = HybridBigInt.fromBigInt(&big);
-    try std.testing.expectEqual(val, hybrid.toI64());
+    var hybrid = HybridBigInt.fromBigInt(&big, std.testing.allocator);
+    try std.testing.expectEqual(val, hybrid.toI64(std.testing.allocator));
 }
 
 test "HybridBigInt conversion to BigInt" {
     var hybrid = HybridBigInt.fromI64(12345);
-    const big = hybrid.toBigInt();
+    const big = hybrid.toBigInt(std.testing.allocator);
     try std.testing.expectEqual(@as(i64, 12345), big.toI64());
 }
 
@@ -650,18 +651,18 @@ test "SIMD addSimd correctness" {
         var a = HybridBigInt.fromI64(pair[0]);
         var b = HybridBigInt.fromI64(pair[1]);
 
-        var sum_scalar = a.add(&b);
-        var sum_simd = a.addSimd(&b);
+        var sum_scalar = a.add(&b, std.testing.allocator);
+        var sum_simd = a.addSimd(&b, std.testing.allocator);
 
-        try std.testing.expectEqual(sum_scalar.toI64(), sum_simd.toI64());
+        try std.testing.expectEqual(sum_scalar.toI64(std.testing.allocator), sum_simd.toI64(std.testing.allocator));
     }
 }
 
 test "SIMD dotProduct" {
     var a = HybridBigInt.fromI64(12345);
     var b = HybridBigInt.fromI64(12345);
 
-    const dot = a.dotProduct(&b);
+    const dot = a.dotProduct(&b, std.testing.allocator);
     // dot product of identical vectors = sum of squares of trits
     // For balanced ternary, each trit is -1, 0, or 1, so trit^2 = 0 or 1
     try std.testing.expect(dot > 0);
@@ -744,7 +745,7 @@ pub fn runBenchmarks() void {
     var hybrid_result = HybridBigInt.zero();
     i = 0;
     while (i < iterations) : (i += 1) {
-        hybrid_result = hybrid_a.add(&hybrid_b);
+        hybrid_result = hybrid_a.add(&hybrid_b, std.heap.page_allocator);
     }
     const hybrid_end = std.time.nanoTimestamp();
     std.mem.doNotOptimizeAway(hybrid_result);
@@ -770,7 +771,7 @@ pub fn runBenchmarks() void {
     var simd_result = HybridBigInt.zero();
     i = 0;
     while (i < iterations) : (i += 1) {
-        simd_result = hybrid_a.addSimd(&hybrid_b);
+        simd_result = hybrid_a.addSimd(&hybrid_b, std.heap.page_allocator);
     }
     const simd_end = std.time.nanoTimestamp();
     std.mem.doNotOptimizeAway(simd_result);
@@ -790,7 +791,7 @@ pub fn runBenchmarks() void {
     var dot_result: i32 = 0;
     i = 0;
     while (i < iterations) : (i += 1) {
-        dot_result = hybrid_a.dotProduct(&hybrid_b);
+        dot_result = hybrid_a.dotProduct(&hybrid_b, std.heap.page_allocator);
     }
     const dot_end = std.time.nanoTimestamp();
     std.mem.doNotOptimizeAway(dot_result);
@@ -800,8 +801,8 @@ pub fn runBenchmarks() void {
 
     std.debug.print("\nResults match:\n", .{});
     std.debug.print("  Unpacked == Packed: {}\n", .{unpacked_result.toI64() == packed_result.toI64()});
-    std.debug.print("  Unpacked == Hybrid: {}\n", .{unpacked_result.toI64() == hybrid_result.toI64()});
-    std.debug.print("  Hybrid == SIMD:     {}\n", .{hybrid_result.toI64() == simd_result.toI64()});
+    std.debug.print("  Unpacked == Hybrid: {}\n", .{unpacked_result.toI64() == hybrid_result.toI64(std.heap.page_allocator)});
+    std.debug.print("  Hybrid == SIMD:     {}\n", .{hybrid_result.toI64(std.heap.page_allocator) == simd_result.toI64(std.heap.page_allocator)});
 }
 
 pub fn main() !void {