Commit 3c080a86f2a7cc235c0d64245399fcf306cde245 | lib/zig/git

author	Meghan Denny <hello@nektro.net> 2026-04-13 02:16:24 -07:00
committer	Meghan Denny <hello@nektro.net> 2026-04-13 02:16:24 -07:00
log	3c080a86f2a7cc235c0d64245399fcf306cde245
tree	3d831d02a84c7b6e60b5761ed3f746f6d4a1b31a
parent	c75a9bfb2d1523607ab3f3d676ce747a2f897a59
signature	Signed by SSH key SHA256:4hHJbtBRU58AYXwjL7fkz2fnQHdiye8x1QpTCQ0sHNw

implement the oid .idx binary search

1 files changed, 41 insertions(+), 20 deletions(-)

git.zig+41-20

 @@ -986,10 +986,14 @@ pub const Repository = struct {
         // read .idx
         if (r.idx_content.count() == 0) {
+            const t2 = tracer.trace(@src(), " read objects/pack", .{});
+            defer t2.end();
             const packdir = try r.gitdir.openDir("objects/pack", .{});
             defer packdir.close();
             var iter = packdir.iterate();
             while (try iter.next()) |entry| {
+                const t3 = tracer.trace(@src(), " {s}", .{entry.name});
+                defer t3.end();
                 if (entry.type != .REG) continue;
                 if (!std.mem.endsWith(u8, entry.name, ".idx")) continue;
                 // std.log.debug("packdir iterate: {s}", .{entry.name});
 @@ -1005,7 +1009,11 @@ pub const Repository = struct {
                 );
             }
         }
+        const t4 = tracer.trace(@src(), " find pack_index/pack_offset", .{});
+        errdefer t4.end();
         const pack_index, const pack_offset = blk: for (r.idx_content.keys(), r.idx_content.values()) |idx_path, idx_content| {
+            const t5 = tracer.trace(@src(), " {s}", .{idx_path});
+            defer t5.end();
             if (std.mem.startsWith(u8, idx_content, "\xfftOc")) {
                 std.debug.assert(std.mem.readInt(u32, idx_content[4..][0..4], .big) == 2);
                 const flfo_table_bytes = idx_content[8..][0 .. 256 * 4];
 @@ -1013,31 +1021,42 @@ pub const Repository = struct {
                 const name_bytes = idx_content[8..][1024..][0 .. object_count * 20];
                 const crc32_bytes = idx_content[8..][1024..][name_bytes.len..][0 .. object_count * 4];
                 const offset_bytes = idx_content[8..][1024..][name_bytes.len..][crc32_bytes.len..][0 .. object_count * 4];
-                for (0..object_count) |i| {
+                // std.sort.binarySearch;
-                    const object_id = &extras.to_hex(name_bytes[i * 20 ..][0..20].*);
+                const i = bll: {
-                    const pack_offset = std.mem.readInt(u32, offset_bytes[i * 4 ..][0..4], .big);
+                    var low: usize = 0;
-                    if (std.mem.eql(u8, object_id, oid)) {
+                    var high: usize = object_count;
-                        // std.log.debug("found {s} in {s} at offset {d}", .{ oid, idx_path, pack_offset });
+                    while (low < high) {
-                        const pack_index = r.pack_content.getIndex(idx_path) orelse clk: {
+                        const mid = low + (high - low) / 2;
-                            var pack_path: [128]u8 = @splat(0);
+                        const object_id = &extras.to_hex(name_bytes[mid * 20 ..][0..20].*);
-                            @memcpy(pack_path[0..13], "objects/pack/");
+                        switch (std.mem.order(u8, oid, object_id)) {
-                            @memcpy(pack_path[13..][0..idx_path.len], idx_path);
+                            .eq => break :bll mid,
-                            @memcpy(pack_path[13..][idx_path.len - 4 ..][0..5], ".pack");
+                            .gt => low = mid + 1,
-                            const pack_name_nidx = std.mem.indexOfScalar(u8, &pack_path, 0).?;
+                            .lt => high = mid,
-                            const pack_file = try r.gitdir.openFile(pack_path[0..pack_name_nidx :0], .{});
+                        }
-                            defer pack_file.close();
-                            const pack_content = try pack_file.mmap();
-                            errdefer nfs.munmap(pack_content);
-                            try r.pack_content.put(r.gpa, idx_path, pack_content);
-                            break :clk r.pack_content.count() - 1;
-                        };
-                        break :blk .{ pack_index, pack_offset };
                     }
-                }
+                    continue;
+                };
+                const pack_offset = std.mem.readInt(u32, offset_bytes[i * 4 ..][0..4], .big);
+                // std.log.debug("found {s} in {s} at offset {d}", .{ oid, idx_path, pack_offset });
+                const pack_index = r.pack_content.getIndex(idx_path) orelse clk: {
+                    var pack_path: [128]u8 = @splat(0);
+                    @memcpy(pack_path[0..13], "objects/pack/");
+                    @memcpy(pack_path[13..][0..idx_path.len], idx_path);
+                    @memcpy(pack_path[13..][idx_path.len - 4 ..][0..5], ".pack");
+                    const pack_name_nidx = std.mem.indexOfScalar(u8, &pack_path, 0).?;
+                    const pack_file = try r.gitdir.openFile(pack_path[0..pack_name_nidx :0], .{});
+                    defer pack_file.close();
+                    const pack_content = try pack_file.mmap();
+                    errdefer nfs.munmap(pack_content);
+                    try r.pack_content.put(r.gpa, idx_path, pack_content);
+                    break :clk r.pack_content.count() - 1;
+                };
+                break :blk .{ pack_index, pack_offset };
             } else {
                 return error.Version1Idx;
             }
         } else return null;
+        t4.end();
         // parse .pack
         // std.log.debug("pack_index={d} pack_offset={d}", .{ pack_index, pack_offset });
 @@ -1066,6 +1085,8 @@ pub const Repository = struct {
                     size += (c & 0x7f) << shift;
                     shift += 7;
                 }
+                const t2 = tracer.trace(@src(), " 2 {s} {d}", .{ @tagName(ty), size });
+                defer t2.end();
                 switch (ty) {
                     .none => {
                         unreachable;