Caleb Gardner
126 lines
4.3 KiB
Zig
126 lines
4.3 KiB
Zig
const std = @import("std");
|
|
const Io = std.Io;
|
|
|
|
const Decompressor = @import("util/decompressor.zig");
|
|
const MetadataReader = @import("util/metadata.zig");
|
|
const OffsetFile = @import("util/offset_file.zig");
|
|
|
|
pub fn lookupValue(comptime T: anytype, alloc: std.mem.Allocator, decomp: *const Decompressor, file: OffsetFile, table_start: u64, idx: u32) !T {
|
|
const T_PER_BLOCK: u16 = 8192 / @sizeOf(T);
|
|
|
|
const block = idx / T_PER_BLOCK;
|
|
const block_offset = idx % T_PER_BLOCK;
|
|
|
|
const offset_pos = table_start + (8 * block);
|
|
const offset: u64 = std.mem.readInt(u64, @ptrCast(file.map.memory[offset_pos .. offset_pos + 8]), .little);
|
|
|
|
var rdr = file.readerAt(offset);
|
|
var meta: MetadataReader = .init(alloc, &rdr, decomp);
|
|
|
|
try meta.interface.discardAll(@sizeOf(T) * block_offset);
|
|
var out: T = undefined;
|
|
try meta.interface.readSliceEndian(T, @ptrCast(&out), .little);
|
|
return out;
|
|
}
|
|
|
|
pub const Error = Io.Cancelable || Io.File.Reader.SeekError || Io.Reader.ReadAllocError;
|
|
|
|
pub fn CachedTable(comptime T: anytype) type {
|
|
return struct {
|
|
const T_PER_BLOCK: u16 = 8192 / @sizeOf(T);
|
|
|
|
const Table = @This();
|
|
|
|
alloc: std.mem.Allocator,
|
|
fil: OffsetFile,
|
|
decomp: *const Decompressor,
|
|
|
|
table_start: u64,
|
|
total_num: u32,
|
|
|
|
table: std.AutoHashMap(u32, []T),
|
|
|
|
mut: Io.RwLock = .init,
|
|
|
|
pub fn init(alloc: std.mem.Allocator, fil: OffsetFile, decomp: *const Decompressor, offset: u64, total_num: u32) Table {
|
|
return .{
|
|
.alloc = alloc,
|
|
.fil = fil,
|
|
.decomp = decomp,
|
|
|
|
.table_start = offset,
|
|
.total_num = total_num,
|
|
|
|
.table = .init(alloc),
|
|
};
|
|
}
|
|
pub fn deinit(self: *Table, io: Io) void {
|
|
self.mut.lockUncancelable(io);
|
|
var iter = self.table.valueIterator();
|
|
while (iter.next()) |val|
|
|
self.alloc.free(val.*);
|
|
self.table.deinit();
|
|
}
|
|
|
|
pub fn fill(self: *Table, io: Io) Error!void {
|
|
try self.mut.lock(io);
|
|
defer self.mut.unlock(io);
|
|
|
|
var num_blocks = self.total_num / T_PER_BLOCK;
|
|
if (self.total_num % T_PER_BLOCK > 0)
|
|
num_blocks += 1;
|
|
|
|
for (0..num_blocks) |block| {
|
|
const offset_pos = self.table_start + (8 * block);
|
|
const offset: u64 = std.mem.readInt(u64, @ptrCast(self.fil.map.memory[offset_pos .. offset_pos + 8]), .little);
|
|
|
|
const len: u16 = if (self.total_num % T_PER_BLOCK != 0 and block == (self.total_num - 1) / T_PER_BLOCK)
|
|
@truncate(self.total_num % T_PER_BLOCK)
|
|
else
|
|
T_PER_BLOCK;
|
|
|
|
var rdr = self.fil.readerAt(offset);
|
|
var meta: MetadataReader = .init(self.alloc, &rdr.interface, self.decomp);
|
|
|
|
const slice = try meta.interface.readSliceEndianAlloc(self.alloc, T, len, .little);
|
|
try self.table.put(@truncate(block), slice);
|
|
}
|
|
}
|
|
|
|
pub fn get(self: *Table, io: Io, idx: u32) Error!T {
|
|
const block = idx / T_PER_BLOCK;
|
|
const block_offset = idx % T_PER_BLOCK;
|
|
|
|
{
|
|
try self.mut.lockShared(io);
|
|
defer self.mut.unlockShared(io);
|
|
|
|
if (self.table.contains(block))
|
|
return self.table.get(block).?[block_offset];
|
|
}
|
|
|
|
try self.mut.lock(io);
|
|
defer self.mut.unlock(io);
|
|
|
|
if (self.table.contains(block))
|
|
return self.table.get(block).?[block_offset];
|
|
|
|
const offset_pos = self.table_start + (8 * block);
|
|
const offset: u64 = std.mem.readInt(u64, @ptrCast(self.fil.map.memory[offset_pos .. offset_pos + 8]), .little);
|
|
|
|
const len: u16 = if (self.total_num % T_PER_BLOCK != 0 and block == (self.total_num - 1) / T_PER_BLOCK)
|
|
@truncate(self.total_num % T_PER_BLOCK)
|
|
else
|
|
T_PER_BLOCK;
|
|
|
|
var rdr = self.fil.readerAt(offset);
|
|
var meta: MetadataReader = .init(self.alloc, &rdr, self.decomp);
|
|
|
|
const slice = try meta.interface.readSliceEndianAlloc(self.alloc, T, len, .little);
|
|
try self.table.put(@truncate(block), slice);
|
|
|
|
return slice[block_offset];
|
|
}
|
|
};
|
|
}
|