ed/WATL_Exercise
1
0
Fork 0
mirror of https://github.com/Ed94/WATL_Exercise.git synced 2025-10-20 09:40:51 -07:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: ed:2bbe654047f2370c1a1ac442015174e1af59cb33
Branches Tags
ed:master
..
compare: ed:master
Branches Tags
ed:master

1 Commits
2bbe654047 ... master

Author SHA1 Message Date
Ed_
9e4bc141d0 Remove reundeant cell pool slice in kt1cx impl across c and odin versions 
wasn't being used, don't plan on using it.
 2025-10-12 00:39:06 -04:00
4 changed files with 28 additions and 37 deletions
Expand all files Collapse all files

16
C/watl.v0.llvm.lottes_hybrid.c
View File

@@ -570,10 +570,9 @@ def_struct(tmpl(KT1CX_Cell,type)) { \
tmpl(KT1CX_Slot,type) slots[depth]; \
tmpl(KT1CX_Slot,type)* next; \
}
#define def_KT1CX(type) \
def_struct(tmpl(KT1CX,type)) { \
tmpl(Slice_KT1CX_Cell,type) cell_pool; \
tmpl(Slice_KT1CX_Cell,type) table; \
#define def_KT1CX(type) \
def_struct(tmpl(KT1CX,type)) { \
tmpl(Slice_KT1CX_Cell,type) table; \
}
typedef def_struct(KT1CX_Byte_Slot) {
U8 key;
@@ -584,7 +583,6 @@ typedef def_struct(KT1CX_Byte_Cell) {
U8 next;
};
typedef def_struct(KT1CX_Byte) {
Slice_Mem cell_pool;
Slice_Mem table;
};
typedef def_struct(KT1CX_ByteMeta) {
@@ -617,11 +615,10 @@ finline U8 kt1cx_slot_id(KT1CX_Byte kt, U8 key, KT1CX_ByteMeta meta);
U8 kt1cx_get (KT1CX_Byte kt, U8 key, KT1CX_ByteMeta meta);
U8 kt1cx_set (KT1CX_Byte kt, U8 key, Slice_Mem value, AllocatorInfo backing_cells, KT1CX_ByteMeta meta);
#define kt1cx_assert(kt) do { \
slice_assert(kt.cell_pool); \
#define kt1cx_assert(kt) do { \
slice_assert(kt.table); \
} while(0)
#define kt1cx_byte(kt) (KT1CX_Byte){slice_mem_s(kt.cell_pool), (Slice_Mem){u8_(kt.table.ptr), kt.table.len} }
#define kt1cx_byte(kt) (KT1CX_Byte){ (Slice_Mem){u8_(kt.table.ptr), kt.table.len} }
#pragma endregion KT1CX
#pragma region String Operations
@@ -1484,8 +1481,7 @@ void kt1cx_init(KT1CX_Info info, KT1CX_InfoMeta m, KT1CX_Byte*R_ result) {
assert(m.cell_pool_size >= kilo(4));
assert(m.table_size >= kilo(4));
assert(m.type_width > 0);
result->table = mem_alloc(info.backing_table, m.table_size * m.cell_size); slice_assert(result->table);
result->cell_pool = mem_alloc(info.backing_cells, m.cell_size * m.cell_pool_size); slice_assert(result->cell_pool);
result->table = mem_alloc(info.backing_table, m.table_size * m.cell_size); slice_assert(result->table);
result->table.len = m.table_size; // Setting to the table number of elements instead of byte length.
}
inline

16
C/watl.v0.msvc.c
View File

@@ -464,10 +464,9 @@ def_struct(tmpl(KT1CX_Cell,type)) { \
tmpl(KT1CX_Slot,type) slots[depth]; \
tmpl(KT1CX_Cell,type)* next; \
}
#define def_KT1CX(type) \
def_struct(tmpl(KT1CX,type)) { \
tmpl(Slice_KT1CX_Cell,type) cell_pool; \
tmpl(Slice_KT1CX_Cell,type) table; \
#define def_KT1CX(type) \
def_struct(tmpl(KT1CX,type)) { \
tmpl(Slice_KT1CX_Cell,type) table; \
}
typedef def_struct(KT1CX_Byte_Slot) {
U64 key;
@@ -478,7 +477,6 @@ typedef def_struct(KT1CX_Byte_Cell) {
Byte* next;
};
typedef def_struct(KT1CX_Byte) {
Slice_Byte cell_pool;
Slice_Byte table;
};
typedef def_struct(KT1CX_ByteMeta) {
@@ -511,11 +509,10 @@ U64 kt1cx_slot_id(KT1CX_Byte kt, U64 key, KT1CX_ByteMeta meta);
Byte* kt1cx_get (KT1CX_Byte kt, U64 key, KT1CX_ByteMeta meta);
Byte* kt1cx_set (KT1CX_Byte kt, U64 key, Slice_Byte value, AllocatorInfo backing_cells, KT1CX_ByteMeta meta);
#define kt1cx_assert(kt) do { \
slice_assert(kt.cell_pool); \
#define kt1cx_assert(kt) do { \
slice_assert(kt.table); \
} while(0)
#define kt1cx_byte(kt) (KT1CX_Byte){slice_byte(kt.cell_pool), { cast(Byte*, kt.table.ptr), kt.table.len } }
#define kt1cx_byte(kt) (KT1CX_Byte){ { cast(Byte*, kt.table.ptr), kt.table.len } }
#pragma endregion KT1CX
#pragma region String Operations
@@ -1389,8 +1386,7 @@ void kt1cx_init(KT1CX_Info info, KT1CX_InfoMeta m, KT1CX_Byte* result) {
assert(m.cell_pool_size >= kilo(4));
assert(m.table_size >= kilo(4));
assert(m.type_width > 0);
result->table = mem_alloc(info.backing_table, m.table_size * m.cell_size); slice_assert(result->table);
result->cell_pool = mem_alloc(info.backing_cells, m.cell_size * m.cell_pool_size); slice_assert(result->cell_pool);
result->table = mem_alloc(info.backing_table, m.table_size * m.cell_size); slice_assert(result->table);
result->table.len = m.table_size; // Setting to the table number of elements instead of byte length.
}
void kt1cx_clear(KT1CX_Byte kt, KT1CX_ByteMeta m) {

31
Odin/watl.v0.win32.odin
View File

@@ -95,25 +95,25 @@ Tera :: Giga * 1024
ptr_cursor :: #force_inline proc "contextless" (ptr: ^$Type) -> [^]Type { return transmute([^]Type) ptr }
align_pow2 :: proc(x: int, b: int) -> int {
align_pow2 :: #force_inline proc(x: int, b: int) -> int {
assert(b != 0)
assert((b & (b - 1)) == 0) // Check power of 2
return ((x + b - 1) & ~(b - 1))
}
memory_zero :: proc "contextless" (data: rawptr, len: int) -> rawptr {
memory_zero :: #force_inline proc "contextless" (data: rawptr, len: int) -> rawptr {
intrinsics.mem_zero(data, len)
return data
}
memory_zero_explicit :: proc "contextless" (data: rawptr, len: int) -> rawptr {
memory_zero_explicit :: #force_inline proc "contextless" (data: rawptr, len: int) -> rawptr {
intrinsics.mem_zero_volatile(data, len) // Use the volatile mem_zero
intrinsics.atomic_thread_fence(.Seq_Cst) // Prevent reordering
return data
}
memory_copy_overlapping :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr {
memory_copy_overlapping :: #force_inline proc "contextless" (dst, src: rawptr, len: int) -> rawptr {
intrinsics.mem_copy(dst, src, len)
return dst
}
memory_copy :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr {
memory_copy :: #force_inline proc "contextless" (dst, src: rawptr, len: int) -> rawptr {
intrinsics.mem_copy_non_overlapping(dst, src, len)
return dst
}
@@ -155,15 +155,15 @@ slice_end :: #force_inline proc "contextless" (s : $SliceType / []$Type) -> ^Typ
@(require_results) slice_to_bytes :: proc "contextless" (s: []$Type) -> []byte { return ([^]byte)(raw_data(s))[:len(s) * size_of(Type)] }
@(require_results) slice_raw :: proc "contextless" (s: []$Type) -> SliceRaw(Type) { return transmute(SliceRaw(Type)) s }
slice_zero :: proc "contextless" (data: $SliceType / []$Type) { memory_zero(raw_data(data), size_of(Type) * len(data)) }
slice_copy :: proc "contextless" (dst, src: $SliceType / []$Type) -> int {
slice_zero :: #force_inline proc "contextless" (data: $SliceType / []$Type) { memory_zero(raw_data(data), size_of(Type) * len(data)) }
slice_copy :: #force_inline proc "contextless" (dst, src: $SliceType / []$Type) -> int {
n := max(0, min(len(dst), len(src)))
if n > 0 {
intrinsics.mem_copy_non_overlapping(raw_data(dst), raw_data(src), n * size_of(Type))
}
return n
}
slice_copy_overlapping :: proc "contextless" (dst, src: $SliceType / []$Type) -> int {
slice_copy_overlapping :: #force_inline proc "contextless" (dst, src: $SliceType / []$Type) -> int {
n := max(0, min(len(dst), len(src)))
if n > 0 {
intrinsics.mem_copy(raw_data(dst), raw_data(src), n * size_of(Type))
@@ -975,8 +975,7 @@ KT1CX_Cell :: struct($type: typeid, $depth: int) {
next: ^KT1CX_Cell(type, depth),
}
KT1CX :: struct($cell: typeid / KT1CX_Cell($type, $depth)) {
cell_pool: []cell,
table: []cell,
table: []cell,
}
KT1CX_Byte_Slot :: struct {
key: u64,
@@ -986,8 +985,7 @@ KT1CX_Byte_Cell :: struct {
next: ^byte,
}
KT1CX_Byte :: struct {
cell_pool: []byte,
table: []byte,
table: []byte,
}
KT1CX_ByteMeta :: struct {
slot_size: int,
@@ -1021,10 +1019,8 @@ kt1cx_init :: proc(info: KT1CX_Info, m: KT1CX_InfoMeta, result: ^KT1CX_Byte) {
assert(m.cell_pool_size >= 4 * Kilo)
assert(m.table_size >= 4 * Kilo)
assert(m.type_width > 0)
table_raw := transmute(SliceByte) mem_alloc(info.backing_table, m.table_size * m.cell_size)
table_raw := transmute(SliceByte) mem_alloc(info.backing_table, m.table_size * m.cell_size)
slice_assert(transmute([]byte) table_raw)
result.cell_pool = mem_alloc(info.backing_cells, m.cell_size * m.cell_pool_size)
slice_assert(result.cell_pool)
table_raw.len = m.table_size
result.table = transmute([]byte) table_raw
}
@@ -1126,10 +1122,11 @@ kt1cx_set :: proc(kt: KT1CX_Byte, key: u64, value: []byte, backing_cells: Alloca
}
}
kt1cx_assert :: proc(kt: $type / KT1CX) {
slice_assert(kt.cell_pool)
slice_assert(kt.table)
}
kt1cx_byte :: proc(kt: $type / KT1CX) -> KT1CX_Byte { return { slice_to_bytes(kt.cell_pool), slice( transmute([^]byte) cursor(kt.table), len(kt.table)) } }
kt1cx_byte :: proc(kt: $type / KT1CX) -> KT1CX_Byte { return {
slice( transmute([^]byte) cursor(kt.table), len(kt.table))
} }
//endregion Key Table 1-Layer Chained-Chunked-Cells (KT1CX)
//region String Operations

2
scripts/build.odin.odin
View File

@@ -106,6 +106,8 @@ main :: proc() {
flag_file,
join_str(flag_output_path, file_exe),
flag_optimize_none,
// flag_optimize_minimal,
// flag_optimize_speed,
// falg_optimize_aggressive,
flag_default_allocator_nil,
flag_debug,