ed/raddebugger
1
0
Fork 0
mirror of https://github.com/Ed94/raddebugger.git synced 2026-08-14 17:28:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

adjust rdi make to keep per-unit info organization - flatten / join in baker, to ensure unit-sorted order

Browse Source
This commit is contained in:
Ryan Fleury
2026-04-20 09:57:31 -07:00
parent b7644a1d34
commit 57e4b69e64
4 changed files with 181 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/lib_rdi_make/rdi_make.c
+23 -6
View File
@@ -51,6 +51,23 @@ rdim_memcpy_struct(dst, to_push); \
} \
rdim_memzero_struct(to_push);
#define RDIM_IdxedChunkListShallowCopy(list_type, chunk_type, src, ...) \
list_type dst = {0};\
RDI_U64 base_idx = 0;\
for(chunk_type *src_n = src->first; src_n != 0; src_n = src_n->next)\
{\
chunk_type *dst_n = rdim_push_array(arena, chunk_type, 1);\
RDIM_SLLQueuePush(dst.first, dst.last, dst_n);\
dst.total_count += src_n->count;\
dst.chunk_count += 1;\
dst_n->count = src_n->count;\
dst_n->cap = dst_n->count;\
dst_n->base_idx = base_idx;\
dst_n->v = src_n->v;\
base_idx += dst_n->count;\
}\
return dst;
////////////////////////////////
//~ rjf: Basic Helpers
@@ -943,6 +960,12 @@ rdim_symbol_chunk_list_concat_in_place(RDIM_SymbolChunkList *dst, RDIM_SymbolChu
RDIM_IdxedChunkListConcatInPlace(RDIM_SymbolChunkNode, dst, to_push);
}
RDI_PROC RDIM_SymbolChunkList
rdim_symbol_chunk_list_shallow_copy(RDIM_Arena *arena, RDIM_SymbolChunkList *src)
{
RDIM_IdxedChunkListShallowCopy(RDIM_SymbolChunkList, RDIM_SymbolChunkNode, src);
}
////////////////////////////////
//~ rjf: [Building] Inline Site Info Building
@@ -1223,12 +1246,6 @@ rdim_bake_params_concat_in_place(RDIM_BakeParams *dst, RDIM_BakeParams *src)
rdim_udt_chunk_list_concat_in_place(&dst->udts, &src->udts);
rdim_src_file_chunk_list_concat_in_place(&dst->src_files, &src->src_files);
rdim_line_table_chunk_list_concat_in_place(&dst->line_tables, &src->line_tables);
rdim_symbol_chunk_list_concat_in_place(&dst->global_variables, &src->global_variables);
rdim_symbol_chunk_list_concat_in_place(&dst->thread_variables, &src->thread_variables);
rdim_symbol_chunk_list_concat_in_place(&dst->constants, &src->constants);
rdim_symbol_chunk_list_concat_in_place(&dst->procedures, &src->procedures);
rdim_scope_chunk_list_concat_in_place(&dst->scopes, &src->scopes);
rdim_inline_site_chunk_list_concat_in_place(&dst->inline_sites, &src->inline_sites);
}
}
src/lib_rdi_make/rdi_make.h
+44 -43
View File
@@ -628,43 +628,6 @@ struct RDIM_LineTableChunkList
RDI_U64 total_col_count;
};
////////////////////////////////
//~ rjf: Per-Compilation-Unit Info Types
typedef struct RDIM_Unit RDIM_Unit;
struct RDIM_Unit
{
struct RDIM_UnitChunkNode *chunk;
RDIM_String8 unit_name;
RDIM_String8 compiler_name;
RDIM_String8 source_file;
RDIM_String8 object_file;
RDIM_String8 archive_file;
RDIM_String8 build_path;
RDI_Language language;
RDIM_LineTable *line_table;
RDIM_Rng1U64ChunkList voff_ranges;
};
typedef struct RDIM_UnitChunkNode RDIM_UnitChunkNode;
struct RDIM_UnitChunkNode
{
RDIM_UnitChunkNode *next;
RDIM_Unit *v;
RDI_U64 count;
RDI_U64 cap;
RDI_U64 base_idx;
};
typedef struct RDIM_UnitChunkList RDIM_UnitChunkList;
struct RDIM_UnitChunkList
{
RDIM_UnitChunkNode *first;
RDIM_UnitChunkNode *last;
RDI_U64 chunk_count;
RDI_U64 total_count;
};
////////////////////////////////
//~ rjf: Namespace Types
@@ -999,6 +962,49 @@ struct RDIM_ScopeChunkList
RDI_U64 local_count;
};
////////////////////////////////
//~ rjf: Per-Compilation-Unit Info Types
typedef struct RDIM_Unit RDIM_Unit;
struct RDIM_Unit
{
struct RDIM_UnitChunkNode *chunk;
RDIM_String8 unit_name;
RDIM_String8 compiler_name;
RDIM_String8 source_file;
RDIM_String8 object_file;
RDIM_String8 archive_file;
RDIM_String8 build_path;
RDI_Language language;
RDIM_LineTable *line_table;
RDIM_Rng1U64ChunkList voff_ranges;
RDIM_SymbolChunkList global_variables;
RDIM_SymbolChunkList thread_variables;
RDIM_SymbolChunkList constants;
RDIM_SymbolChunkList procedures;
RDIM_ScopeChunkList scopes;
RDIM_InlineSiteChunkList inline_sites;
};
typedef struct RDIM_UnitChunkNode RDIM_UnitChunkNode;
struct RDIM_UnitChunkNode
{
RDIM_UnitChunkNode *next;
RDIM_Unit *v;
RDI_U64 count;
RDI_U64 cap;
RDI_U64 base_idx;
};
typedef struct RDIM_UnitChunkList RDIM_UnitChunkList;
struct RDIM_UnitChunkList
{
RDIM_UnitChunkNode *first;
RDIM_UnitChunkNode *last;
RDI_U64 chunk_count;
RDI_U64 total_count;
};
////////////////////////////////
//~ rjf: Baking Types
@@ -1016,12 +1022,6 @@ struct RDIM_BakeParams
RDIM_UDTChunkList udts;
RDIM_SrcFileChunkList src_files;
RDIM_LineTableChunkList line_tables;
RDIM_SymbolChunkList global_variables;
RDIM_SymbolChunkList thread_variables;
RDIM_SymbolChunkList constants;
RDIM_SymbolChunkList procedures;
RDIM_ScopeChunkList scopes;
RDIM_InlineSiteChunkList inline_sites;
};
//- rjf: data sections
@@ -1475,6 +1475,7 @@ RDI_PROC RDIM_UDTEnumVal *rdim_udt_push_enum_val(RDIM_Arena *arena, RDIM_UDTChun
RDI_PROC RDIM_Symbol *rdim_symbol_chunk_list_push(RDIM_Arena *arena, RDIM_SymbolChunkList *list, RDI_U64 cap);
RDI_PROC RDI_U64 rdim_idx_from_symbol(RDIM_Symbol *symbol);
RDI_PROC void rdim_symbol_chunk_list_concat_in_place(RDIM_SymbolChunkList *dst, RDIM_SymbolChunkList *to_push);
RDI_PROC RDIM_SymbolChunkList rdim_symbol_chunk_list_shallow_copy(RDIM_Arena *arena, RDIM_SymbolChunkList *src);
////////////////////////////////
//~ rjf: [Building] Inline Site Info Building
src/rdi_from_pdb/rdi_from_pdb.c
+11 -106
View File
@@ -1173,12 +1173,12 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
lane_sync_u64(&src_file_map, 0);
//////////////////////////////////////////////////////////////
//- rjf: convert unit info
//- rjf: convert unit header info
//
RDIM_UnitChunkList *all_units_ptr = 0;
RDIM_LineTableChunkList *units_line_tables = 0;
RDIM_LineTable **units_first_inline_site_line_tables = 0;
ProfScope("convert unit info")
ProfScope("convert unit header info")
{
//- rjf: set up outputs
ProfScope("set up outputs") if(lane_idx() == 0)
@@ -3259,14 +3259,8 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
all_udts = *all_udts_ptr;
//////////////////////////////////////////////////////////////
//- rjf: produce symbols from all streams
//- rjf: convert symbols from all units
//
RDIM_SymbolChunkList *syms_procedures = 0;
RDIM_SymbolChunkList *syms_global_variables = 0;
RDIM_SymbolChunkList *syms_thread_variables = 0;
RDIM_SymbolChunkList *syms_constants = 0;
RDIM_ScopeChunkList *syms_scopes = 0;
RDIM_InlineSiteChunkList *syms_inline_sites = 0;
RDIM_TypeChunkList *syms_typedefs = 0;
ProfScope("produce symbols from all streams")
{
@@ -3277,20 +3271,8 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
//
if(lane_idx() == 0)
{
syms_procedures = push_array(arena, RDIM_SymbolChunkList, all_syms_count);
syms_global_variables = push_array(arena, RDIM_SymbolChunkList, all_syms_count);
syms_thread_variables = push_array(arena, RDIM_SymbolChunkList, all_syms_count);
syms_constants = push_array(arena, RDIM_SymbolChunkList, all_syms_count);
syms_scopes = push_array(arena, RDIM_ScopeChunkList, all_syms_count);
syms_inline_sites = push_array(arena, RDIM_InlineSiteChunkList, all_syms_count);
syms_typedefs = push_array(arena, RDIM_TypeChunkList, all_syms_count);
}
lane_sync_u64(&syms_procedures, 0);
lane_sync_u64(&syms_global_variables, 0);
lane_sync_u64(&syms_thread_variables, 0);
lane_sync_u64(&syms_constants, 0);
lane_sync_u64(&syms_scopes, 0);
lane_sync_u64(&syms_inline_sites, 0);
lane_sync_u64(&syms_typedefs, 0);
////////////////////////////
@@ -3329,12 +3311,13 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
U64 sym_constants_chunk_cap = 2048;
U64 sym_scopes_chunk_cap = 4096;
U64 sym_inline_sites_chunk_cap = 2048;
RDIM_SymbolChunkList *sym_procedures = &syms_procedures[sym_idx];
RDIM_SymbolChunkList *sym_global_variables = &syms_global_variables[sym_idx];
RDIM_SymbolChunkList *sym_thread_variables = &syms_thread_variables[sym_idx];
RDIM_SymbolChunkList *sym_constants = &syms_constants[sym_idx];
RDIM_ScopeChunkList *sym_scopes = &syms_scopes[sym_idx];
RDIM_InlineSiteChunkList *sym_inline_sites = &syms_inline_sites[sym_idx];
RDIM_Unit *sym_unit = &all_units_ptr->first->v[sym_idx];
RDIM_SymbolChunkList *sym_procedures = &sym_unit->procedures;
RDIM_SymbolChunkList *sym_global_variables = &sym_unit->global_variables;
RDIM_SymbolChunkList *sym_thread_variables = &sym_unit->thread_variables;
RDIM_SymbolChunkList *sym_constants = &sym_unit->constants;
RDIM_ScopeChunkList *sym_scopes = &sym_unit->scopes;
RDIM_InlineSiteChunkList *sym_inline_sites = &sym_unit->inline_sites;
RDIM_TypeChunkList *typedefs = &syms_typedefs[sym_idx];
//////////////////////////
@@ -4219,82 +4202,16 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
lane_sync();
//////////////////////////////////////////////////////////////
//- rjf: join all lane symbols
//- rjf: join extra types from units
//
RDIM_SymbolChunkList all_procedures = {0};
RDIM_SymbolChunkList all_global_variables = {0};
RDIM_SymbolChunkList all_thread_variables = {0};
RDIM_SymbolChunkList all_constants = {0};
RDIM_ScopeChunkList all_scopes = {0};
RDIM_InlineSiteChunkList all_inline_sites = {0};
RDIM_TypeChunkList all_types = {0};
{
RDIM_SymbolChunkList *all_procedures_ptr = 0;
RDIM_SymbolChunkList *all_global_variables_ptr = 0;
RDIM_SymbolChunkList *all_thread_variables_ptr = 0;
RDIM_SymbolChunkList *all_constants_ptr = 0;
RDIM_ScopeChunkList *all_scopes_ptr = 0;
RDIM_InlineSiteChunkList *all_inline_sites_ptr = 0;
RDIM_TypeChunkList *all_types_ptr = 0;
if(lane_idx() == 0)
{
all_procedures_ptr = push_array(scratch.arena, RDIM_SymbolChunkList, 1);
all_global_variables_ptr = push_array(scratch.arena, RDIM_SymbolChunkList, 1);
all_thread_variables_ptr = push_array(scratch.arena, RDIM_SymbolChunkList, 1);
all_constants_ptr = push_array(scratch.arena, RDIM_SymbolChunkList, 1);
all_scopes_ptr = push_array(scratch.arena, RDIM_ScopeChunkList, 1);
all_inline_sites_ptr = push_array(scratch.arena, RDIM_InlineSiteChunkList, 1);
all_types_ptr = push_array(scratch.arena, RDIM_TypeChunkList, 1);
}
lane_sync_u64(&all_procedures_ptr, 0);
lane_sync_u64(&all_global_variables_ptr, 0);
lane_sync_u64(&all_thread_variables_ptr, 0);
lane_sync_u64(&all_constants_ptr, 0);
lane_sync_u64(&all_scopes_ptr, 0);
lane_sync_u64(&all_inline_sites_ptr, 0);
lane_sync_u64(&all_types_ptr, 0);
if(lane_idx() == lane_from_task_idx(1)) ProfScope("join procedures")
{
for EachIndex(idx, all_syms_count)
{
rdim_symbol_chunk_list_concat_in_place(all_procedures_ptr, &syms_procedures[idx]);
}
}
if(lane_idx() == lane_from_task_idx(2)) ProfScope("join global variables")
{
for EachIndex(idx, all_syms_count)
{
rdim_symbol_chunk_list_concat_in_place(all_global_variables_ptr, &syms_global_variables[idx]);
}
}
if(lane_idx() == lane_from_task_idx(3)) ProfScope("join thread variables")
{
for EachIndex(idx, all_syms_count)
{
rdim_symbol_chunk_list_concat_in_place(all_thread_variables_ptr, &syms_thread_variables[idx]);
}
}
if(lane_idx() == lane_from_task_idx(4)) ProfScope("join constants")
{
for EachIndex(idx, all_syms_count)
{
rdim_symbol_chunk_list_concat_in_place(all_constants_ptr, &syms_constants[idx]);
}
}
if(lane_idx() == lane_from_task_idx(5)) ProfScope("join scopes")
{
for EachIndex(idx, all_syms_count)
{
rdim_scope_chunk_list_concat_in_place(all_scopes_ptr, &syms_scopes[idx]);
}
}
if(lane_idx() == lane_from_task_idx(6)) ProfScope("join inline sites")
{
for EachIndex(idx, all_syms_count)
{
rdim_inline_site_chunk_list_concat_in_place(all_inline_sites_ptr, &syms_inline_sites[idx]);
}
}
if(lane_idx() == lane_from_task_idx(7)) ProfScope("join typedefs")
{
for EachIndex(idx, all_syms_count)
@@ -4304,12 +4221,6 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
*all_types_ptr = *all_types__pre_typedefs_ptr;
}
lane_sync();
all_procedures = *all_procedures_ptr;
all_global_variables = *all_global_variables_ptr;
all_thread_variables = *all_thread_variables_ptr;
all_constants = *all_constants_ptr;
all_scopes = *all_scopes_ptr;
all_inline_sites = *all_inline_sites_ptr;
all_types = *all_types_ptr;
}
lane_sync();
@@ -4362,12 +4273,6 @@ p2r_convert(Arena *arena, P2R_ConvertParams *params)
result.udts = all_udts;
result.src_files = all_src_files;
result.line_tables = all_line_tables;
result.global_variables = all_global_variables;
result.thread_variables = all_thread_variables;
result.constants = all_constants;
result.procedures = all_procedures;
result.scopes = all_scopes;
result.inline_sites = all_inline_sites;
}
scratch_end(scratch);
src/rdi_make/rdi_make_local.c
+103 -62
View File
@@ -281,6 +281,47 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
{
Temp scratch = scratch_begin(&arena, 1);
//////////////////////////////////////////////////////////////
//- rjf: @rdim_bake_stage form joined symbol lists, from all units
//
RDIM_SymbolChunkList *all_global_variables = 0;
RDIM_SymbolChunkList *all_thread_variables = 0;
RDIM_SymbolChunkList *all_constants = 0;
RDIM_SymbolChunkList *all_procedures = 0;
RDIM_ScopeChunkList *all_scopes = 0;
RDIM_InlineSiteChunkList *all_inline_sites = 0;
if(lane_idx() == 0)
{
all_global_variables = push_array(scratch.arena, RDIM_SymbolChunkList, 1);
all_thread_variables = push_array(scratch.arena, RDIM_SymbolChunkList, 1);
all_constants = push_array(scratch.arena, RDIM_SymbolChunkList, 1);
all_procedures = push_array(scratch.arena, RDIM_SymbolChunkList, 1);
all_scopes = push_array(scratch.arena, RDIM_ScopeChunkList, 1);
all_inline_sites = push_array(scratch.arena, RDIM_InlineSiteChunkList, 1);
for EachNode(unit_n, RDIM_UnitChunkNode, params->units.first)
{
for EachIndex(unit_n_idx, unit_n->count)
{
RDIM_Unit *unit = &unit_n->v[unit_n_idx];
RDIM_SymbolChunkList global_variables_shallow_copy = rdim_symbol_chunk_list_shallow_copy(scratch.arena, &unit->global_variables);
RDIM_SymbolChunkList thread_variables_shallow_copy = rdim_symbol_chunk_list_shallow_copy(scratch.arena, &unit->thread_variables);
RDIM_SymbolChunkList constants_shallow_copy = rdim_symbol_chunk_list_shallow_copy(scratch.arena, &unit->constants);
RDIM_SymbolChunkList procedures_shallow_copy = rdim_symbol_chunk_list_shallow_copy(scratch.arena, &unit->procedures);
rdim_symbol_chunk_list_concat_in_place(all_global_variables, &global_variables_shallow_copy);
rdim_symbol_chunk_list_concat_in_place(all_thread_variables, &thread_variables_shallow_copy);
rdim_symbol_chunk_list_concat_in_place(all_constants, &constants_shallow_copy);
rdim_symbol_chunk_list_concat_in_place(all_procedures, &procedures_shallow_copy);
// TODO(rjf): @locpass scopes, inline sites
}
}
}
lane_sync_u64(&all_global_variables, 0);
lane_sync_u64(&all_thread_variables, 0);
lane_sync_u64(&all_constants, 0);
lane_sync_u64(&all_procedures, 0);
lane_sync_u64(&all_scopes, 0);
lane_sync_u64(&all_inline_sites, 0);
//////////////////////////////////////////////////////////////
//- rjf: @rdim_bake_stage bake vmaps
//
@@ -328,14 +369,14 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
U64 *lane_chunk_range_counts = 0;
if(lane_idx() == 0)
{
lane_chunk_range_counts = push_array(scratch.arena, U64, params->scopes.chunk_count * lane_count());
lane_chunk_range_counts = push_array(scratch.arena, U64, all_scopes->chunk_count * lane_count());
}
lane_sync_u64(&lane_chunk_range_counts, 0);
{
U64 chunk_idx = 0;
for EachNode(n, RDIM_ScopeChunkNode, params->scopes.first)
for EachNode(n, RDIM_ScopeChunkNode, all_scopes->first)
{
U64 slot_idx = lane_idx()*params->scopes.chunk_count + chunk_idx;
U64 slot_idx = lane_idx()*all_scopes->chunk_count + chunk_idx;
Rng1U64 range = lane_range(n->count);
for EachInRange(n_idx, range)
{
@@ -351,14 +392,14 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
U64 total_range_count = 0;
if(lane_idx() == 0)
{
lane_chunk_range_offs = push_array(scratch.arena, U64, params->scopes.chunk_count * lane_count());
lane_chunk_range_offs = push_array(scratch.arena, U64, all_scopes->chunk_count * lane_count());
U64 off = 0;
U64 chunk_idx = 0;
for EachNode(n, RDIM_ScopeChunkNode, params->scopes.first)
for EachNode(n, RDIM_ScopeChunkNode, all_scopes->first)
{
for EachIndex(l_idx, lane_count())
{
U64 slot_idx = l_idx*params->scopes.chunk_count + chunk_idx;
U64 slot_idx = l_idx*all_scopes->chunk_count + chunk_idx;
lane_chunk_range_offs[slot_idx] = off;
off += lane_chunk_range_counts[slot_idx];
}
@@ -381,9 +422,9 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
//- rjf: fill records
{
U64 chunk_idx = 0;
for EachNode(n, RDIM_ScopeChunkNode, params->scopes.first)
for EachNode(n, RDIM_ScopeChunkNode, all_scopes->first)
{
U64 slot_idx = lane_idx()*params->scopes.chunk_count + chunk_idx;
U64 slot_idx = lane_idx()*all_scopes->chunk_count + chunk_idx;
U64 off = lane_chunk_range_offs[slot_idx];
Rng1U64 range = lane_range(n->count);
for EachInRange(n_idx, range)
@@ -414,14 +455,14 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
U64 *lane_chunk_range_counts = 0;
if(lane_idx() == 0)
{
lane_chunk_range_counts = push_array(scratch.arena, U64, params->global_variables.chunk_count * lane_count());
lane_chunk_range_counts = push_array(scratch.arena, U64, all_global_variables->chunk_count * lane_count());
}
lane_sync_u64(&lane_chunk_range_counts, 0);
{
U64 chunk_idx = 0;
for EachNode(n, RDIM_SymbolChunkNode, params->global_variables.first)
for EachNode(n, RDIM_SymbolChunkNode, all_global_variables->first)
{
U64 slot_idx = lane_idx()*params->global_variables.chunk_count + chunk_idx;
U64 slot_idx = lane_idx()*all_global_variables->chunk_count + chunk_idx;
Rng1U64 range = lane_range(n->count);
for EachIndex(n_idx, n->count)
{
@@ -441,14 +482,14 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
U64 total_range_count = 0;
if(lane_idx() == 0)
{
lane_chunk_range_offs = push_array(scratch.arena, U64, params->global_variables.chunk_count * lane_count());
lane_chunk_range_offs = push_array(scratch.arena, U64, all_global_variables->chunk_count * lane_count());
U64 off = 0;
U64 chunk_idx = 0;
for EachNode(n, RDIM_SymbolChunkNode, params->global_variables.first)
for EachNode(n, RDIM_SymbolChunkNode, all_global_variables->first)
{
for EachIndex(l_idx, lane_count())
{
U64 slot_idx = l_idx*params->global_variables.chunk_count + chunk_idx;
U64 slot_idx = l_idx*all_global_variables->chunk_count + chunk_idx;
lane_chunk_range_offs[slot_idx] = off;
off += lane_chunk_range_counts[slot_idx];
}
@@ -471,9 +512,9 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
//- rjf: fill records
{
U64 chunk_idx = 0;
for EachNode(n, RDIM_SymbolChunkNode, params->global_variables.first)
for EachNode(n, RDIM_SymbolChunkNode, all_global_variables->first)
{
U64 slot_idx = lane_idx()*params->global_variables.chunk_count + chunk_idx;
U64 slot_idx = lane_idx()*all_global_variables->chunk_count + chunk_idx;
U64 off = lane_chunk_range_offs[slot_idx];
Rng1U64 range = lane_range(n->count);
for EachInRange(n_idx, range)
@@ -1076,9 +1117,9 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
bake_strings = push_array(scratch.arena, RDIM_BakeStringMapTight, 1);
top = push_array(scratch2.arena, RDIM_BakeStringMapTopology, 1);
top->slots_count = (64 +
params->procedures.total_count*1 +
params->global_variables.total_count*1 +
params->thread_variables.total_count*1 +
all_procedures->total_count*1 +
all_global_variables->total_count*1 +
all_thread_variables->total_count*1 +
params->types.total_count/2);
lane_maps__loose = push_array(scratch2.arena, RDIM_BakeStringMapLoose *, lane_count());
map__loose = rdim_bake_string_map_loose_make(scratch2.arena, top);
@@ -1194,10 +1235,10 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
// rjf: push strings from symbols
RDIM_SymbolChunkList *symbol_lists[] =
{
&params->global_variables,
&params->thread_variables,
&params->procedures,
&params->constants,
all_global_variables,
all_thread_variables,
all_procedures,
all_constants,
};
ProfScope("symbols")
{
@@ -1218,7 +1259,7 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
//- rjf: push strings from inline sites
ProfScope("inline sites")
{
for EachNode(n, RDIM_InlineSiteChunkNode, params->inline_sites.first)
for EachNode(n, RDIM_InlineSiteChunkNode, all_inline_sites->first)
{
Rng1U64 range = lane_range(n->count);
for EachInRange(n_idx, range)
@@ -1231,7 +1272,7 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
//- rjf: push strings from scopes
ProfScope("scopes")
{
for EachNode(n, RDIM_ScopeChunkNode, params->scopes.first)
for EachNode(n, RDIM_ScopeChunkNode, all_scopes->first)
{
Rng1U64 range = lane_range(n->count);
for EachInRange(n_idx, range)
@@ -1352,11 +1393,11 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
case RDI_NameMapKind_COUNT:
{}break;
#define Case(name, total_count) case RDI_NameMapKind_##name:{slot_count = ((total_count) + (total_count)/4);}break
Case(GlobalVariables, params->global_variables.total_count);
Case(ThreadVariables, params->thread_variables.total_count);
Case(Constants, params->constants.total_count);
Case(Procedures, params->procedures.total_count);
Case(LinkNameProcedures, params->procedures.total_count);
Case(GlobalVariables, all_global_variables->total_count);
Case(ThreadVariables, all_thread_variables->total_count);
Case(Constants, all_constants->total_count);
Case(Procedures, all_procedures->total_count);
Case(LinkNameProcedures, all_procedures->total_count);
Case(Types, params->types.total_count);
Case(NormalSourcePaths, params->src_files.total_count);
#undef Case
@@ -1383,11 +1424,11 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
case RDI_NameMapKind_NULL:
case RDI_NameMapKind_COUNT:
{}break;
case RDI_NameMapKind_GlobalVariables: {symbols = &params->global_variables;}goto symbol_name_map_build;
case RDI_NameMapKind_ThreadVariables: {symbols = &params->thread_variables;}goto symbol_name_map_build;
case RDI_NameMapKind_Constants: {symbols = &params->constants;}goto symbol_name_map_build;
case RDI_NameMapKind_Procedures: {symbols = &params->procedures;}goto symbol_name_map_build;
case RDI_NameMapKind_LinkNameProcedures:{symbols = &params->procedures; link_names = 1;}goto symbol_name_map_build;
case RDI_NameMapKind_GlobalVariables: {symbols = all_global_variables;}goto symbol_name_map_build;
case RDI_NameMapKind_ThreadVariables: {symbols = all_thread_variables;}goto symbol_name_map_build;
case RDI_NameMapKind_Constants: {symbols = all_constants;}goto symbol_name_map_build;
case RDI_NameMapKind_Procedures: {symbols = all_procedures;}goto symbol_name_map_build;
case RDI_NameMapKind_LinkNameProcedures:{symbols = all_procedures; link_names = 1;}goto symbol_name_map_build;
symbol_name_map_build:;
{
for EachNode(n, RDIM_SymbolChunkNode, symbols->first)
@@ -1512,9 +1553,9 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
if(lane_idx() == 0) ProfScope("set up per-lane outputs")
{
top = push_array(scratch.arena, RDIM_BakeIdxRunMapTopology, 1);
top->slots_count = 64 + ((params->procedures.total_count +
params->global_variables.total_count +
params->thread_variables.total_count +
top->slots_count = 64 + ((all_procedures->total_count +
all_global_variables->total_count +
all_thread_variables->total_count +
params->udts.total_count) * 3) / 4;
lane_maps__loose = push_array(scratch.arena, RDIM_BakeIdxRunMapLoose *, lane_count());
map__loose = rdim_bake_idx_run_map_loose_make(scratch.arena, top);
@@ -2713,7 +2754,7 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
RDI_U64 total_location_case_count;
};
LocLayout *loc_layout = 0;
U64 total_location_case_chunk_count = (params->scopes.chunk_count + params->procedures.chunk_count);
U64 total_location_case_chunk_count = (all_scopes->chunk_count + params->procedures.chunk_count);
ProfScope("compute lane location block layout")
{
// rjf: set up
@@ -2729,7 +2770,7 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
{
// rjf: count location cases in scopes
U64 chunk_idx = 0;
for EachNode(n, RDIM_ScopeChunkNode, params->scopes.first)
for EachNode(n, RDIM_ScopeChunkNode, all_scopes->first)
{
U64 slot_idx = lane_idx() * total_location_case_chunk_count + chunk_idx;
Rng1U64 range = lane_range(n->count);
@@ -2762,7 +2803,7 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
{
U64 chunk_idx = 0;
U64 location_case_layout_off = 1;
for EachNode(n, RDIM_ScopeChunkNode, params->scopes.first)
for EachNode(n, RDIM_ScopeChunkNode, all_scopes->first)
{
for EachIndex(l_idx, lane_count())
{
@@ -2808,7 +2849,7 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
U64 chunk_idx = 0;
ProfScope("wide fill from scopes")
{
for EachNode(n, RDIM_ScopeChunkNode, params->scopes.first)
for EachNode(n, RDIM_ScopeChunkNode, all_scopes->first)
{
U64 layout_slot_idx = lane_idx() * total_location_case_chunk_count + chunk_idx;
U64 layout_off = loc_layout->location_case_chunk_lane_offs[layout_slot_idx];
@@ -2929,17 +2970,17 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
if(lane_idx() == 0)
{
scope_layout = push_array(scratch.arena, ScopeLayout, 1);
scope_layout->scope_local_chunk_lane_counts = push_array(arena, RDI_U64, lane_count() * params->scopes.chunk_count);
scope_layout->scope_local_chunk_lane_offs = push_array(arena, RDI_U64, lane_count() * params->scopes.chunk_count);
scope_layout->scope_voff_chunk_lane_counts = push_array(arena, RDI_U64, lane_count() * params->scopes.chunk_count);
scope_layout->scope_voff_chunk_lane_offs = push_array(arena, RDI_U64, lane_count() * params->scopes.chunk_count);
scope_layout->scope_local_chunk_lane_counts = push_array(arena, RDI_U64, lane_count() * all_scopes->chunk_count);
scope_layout->scope_local_chunk_lane_offs = push_array(arena, RDI_U64, lane_count() * all_scopes->chunk_count);
scope_layout->scope_voff_chunk_lane_counts = push_array(arena, RDI_U64, lane_count() * all_scopes->chunk_count);
scope_layout->scope_voff_chunk_lane_offs = push_array(arena, RDI_U64, lane_count() * all_scopes->chunk_count);
}
lane_sync_u64(&scope_layout, 0);
// rjf: count per-lane-chunk
{
U64 chunk_idx = 0;
for EachNode(n, RDIM_ScopeChunkNode, params->scopes.first)
for EachNode(n, RDIM_ScopeChunkNode, all_scopes->first)
{
U64 num_locals_in_this_lane_and_node = 0;
U64 num_voffs_in_this_lane_and_node = 0;
@@ -2949,8 +2990,8 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
num_locals_in_this_lane_and_node += n->v[n_idx].locals.total_count;
num_voffs_in_this_lane_and_node += n->v[n_idx].voff_ranges.count*2;
}
scope_layout->scope_local_chunk_lane_counts[lane_idx()*params->scopes.chunk_count + chunk_idx] = num_locals_in_this_lane_and_node;
scope_layout->scope_voff_chunk_lane_counts[lane_idx()*params->scopes.chunk_count + chunk_idx] = num_voffs_in_this_lane_and_node;
scope_layout->scope_local_chunk_lane_counts[lane_idx()*all_scopes->chunk_count + chunk_idx] = num_locals_in_this_lane_and_node;
scope_layout->scope_voff_chunk_lane_counts[lane_idx()*all_scopes->chunk_count + chunk_idx] = num_voffs_in_this_lane_and_node;
chunk_idx += 1;
}
}
@@ -2962,11 +3003,11 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
U64 local_layout_off = 1;
U64 voff_layout_off = 1;
U64 chunk_idx = 0;
for EachNode(n, RDIM_ScopeChunkNode, params->scopes.first)
for EachNode(n, RDIM_ScopeChunkNode, all_scopes->first)
{
for EachIndex(l_idx, lane_count())
{
U64 slot_idx = l_idx*params->scopes.chunk_count + chunk_idx;
U64 slot_idx = l_idx*all_scopes->chunk_count + chunk_idx;
scope_layout->scope_local_chunk_lane_offs[slot_idx] = local_layout_off;
scope_layout->scope_voff_chunk_lane_offs[slot_idx] = voff_layout_off;
local_layout_off += scope_layout->scope_local_chunk_lane_counts[slot_idx];
@@ -3002,12 +3043,12 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
lane_sync_u64(&baked_scopes, 0);
if(lane_idx() == lane_from_task_idx(0))
{
baked_scopes->scopes_count = params->scopes.total_count+1;
baked_scopes->scopes_count = all_scopes->total_count+1;
baked_scopes->scopes = push_array(arena, RDI_Scope, baked_scopes->scopes_count);
}
if(lane_idx() == lane_from_task_idx(1))
{
baked_scopes->scope_voffs_count = params->scopes.scope_voff_count+1;
baked_scopes->scope_voffs_count = all_scopes->scope_voff_count+1;
baked_scopes->scope_voffs = push_array(arena, RDI_U64, baked_scopes->scope_voffs_count);
}
lane_sync();
@@ -3015,10 +3056,10 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
//- rjf: wide fill
{
U64 chunk_idx = 0;
for EachNode(n, RDIM_ScopeChunkNode, params->scopes.first)
for EachNode(n, RDIM_ScopeChunkNode, all_scopes->first)
{
Rng1U64 range = lane_range(n->count);
U64 scope_chunk_lane_slot_idx = lane_idx()*params->scopes.chunk_count + chunk_idx;
U64 scope_chunk_lane_slot_idx = lane_idx()*all_scopes->chunk_count + chunk_idx;
U64 chunk_local_off = scope_layout->scope_local_chunk_lane_offs[scope_chunk_lane_slot_idx];
U64 chunk_voff_off = scope_layout->scope_voff_chunk_lane_offs[scope_chunk_lane_slot_idx];
for EachInRange(n_idx, range)
@@ -3096,7 +3137,7 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
U64 chunk_idx = 0;
for EachNode(n, RDIM_SymbolChunkNode, params->procedures.first)
{
U64 location_block_layout_slot_idx = lane_idx()*total_location_case_chunk_count + params->scopes.chunk_count + chunk_idx;
U64 location_block_layout_slot_idx = lane_idx()*total_location_case_chunk_count + all_scopes->chunk_count + chunk_idx;
U64 location_block_off = loc_layout->location_case_chunk_lane_offs[location_block_layout_slot_idx];
Rng1U64 range = lane_range(n->count);
for EachInRange(n_idx, range)
@@ -3272,7 +3313,7 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
}
if(lane_idx() == lane_from_task_idx(2))
{
baked_inline_sites_count = params->inline_sites.total_count+1;
baked_inline_sites_count = all_inline_sites->total_count+1;
baked_inline_sites = push_array(arena, RDI_InlineSite, baked_inline_sites_count);
}
lane_sync_u64(&baked_units, lane_from_task_idx(0));
@@ -3447,7 +3488,7 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
//- rjf: bake inline sites
ProfScope("bake inline sites")
{
for EachNode(n, RDIM_InlineSiteChunkNode, params->inline_sites.first)
for EachNode(n, RDIM_InlineSiteChunkNode, all_inline_sites->first)
{
Rng1U64 range = lane_range(n->count);
for EachInRange(n_idx, range)
@@ -3485,10 +3526,10 @@ rdim_bake(Arena *arena, RDIM_BakeParams *params)
}
symbol_table_lists[] =
{
{&params->global_variables, &baked_global_variables, &baked_global_variables_count},
{&params->thread_variables, &baked_thread_variables, &baked_thread_variables_count},
{&params->procedures, &baked_procedures, &baked_procedures_count},
{&params->constants, &baked_constants, &baked_constants_count},
{all_global_variables, &baked_global_variables, &baked_global_variables_count},
{all_thread_variables, &baked_thread_variables, &baked_thread_variables_count},
{all_procedures, &baked_procedures, &baked_procedures_count},
{all_constants, &baked_constants, &baked_constants_count},
{&baked_scopes->arranged_locals, &baked_locals, &baked_locals_count},
};