set up base-layer tctx info for thread wavefront metadata

src/base/base_entry_point.c

@@ -105,10 +105,10 @@ main_thread_base_entry_point(int arguments_count, char **arguments)
 internal void
 supplement_thread_base_entry_point(void (*entry_point)(void *params), void *params)
 {
-  TCTX tctx;
-  tctx_init_and_equip(&tctx);
+  TCTX *tctx = tctx_alloc();
+  tctx_select(tctx);
   entry_point(params);
-  tctx_release();
+  tctx_release(tctx);
 }
 
 internal U64

src/base/base_thread_context.c

@@ -2,44 +2,53 @@
 // Licensed under the MIT license (https://opensource.org/license/mit/)
 
 ////////////////////////////////
-// NOTE(allen): Thread Context Functions
+//~ rjf: Globals
 
 C_LINKAGE thread_static TCTX* tctx_thread_local;
 #if !BUILD_SUPPLEMENTARY_UNIT
 C_LINKAGE thread_static TCTX* tctx_thread_local = 0;
 #endif
 
-internal void
-tctx_init_and_equip(TCTX *tctx)
+////////////////////////////////
+//~ rjf: Thread Context Functions
+
+//- rjf: thread-context allocation & selection
+
+internal TCTX *
+tctx_alloc(void)
+{
+  Arena *arena = arena_alloc();
+  TCTX *tctx = push_array(arena, TCTX, 1);
+  tctx->arenas[0] = arena;
+  tctx->arenas[1] = arena_alloc();
+  return tctx;
+}
+
+internal void
+tctx_release(TCTX *tctx)
+{
+  arena_release(tctx->arenas[1]);
+  arena_release(tctx->arenas[0]);
+}
+
+internal void
+tctx_select(TCTX *tctx)
 {
-  MemoryZeroStruct(tctx);
-  Arena **arena_ptr = tctx->arenas;
-  for(U64 i = 0; i < ArrayCount(tctx->arenas); i += 1, arena_ptr += 1)
-  {
-    *arena_ptr = arena_alloc();
-  }
   tctx_thread_local = tctx;
 }
 
-internal void
-tctx_release(void)
-{
-  for(U64 i = 0; i < ArrayCount(tctx_thread_local->arenas); i += 1)
-  {
-    arena_release(tctx_thread_local->arenas[i]);
-  }
-}
-
 internal TCTX *
-tctx_get_equipped(void)
+tctx_selected(void)
 {
   return tctx_thread_local;
 }
 
+//- rjf: scratch arenas
+
 internal Arena *
 tctx_get_scratch(Arena **conflicts, U64 count)
 {
-  TCTX *tctx = tctx_get_equipped();
+  TCTX *tctx = tctx_selected();
   Arena *result = 0;
   Arena **arena_ptr = tctx->arenas;
   for(U64 i = 0; i < ArrayCount(tctx->arenas); i += 1, arena_ptr += 1)
@@ -63,10 +72,32 @@ tctx_get_scratch(Arena **conflicts, U64 count)
   return result;
 }
 
+//- rjf: wavefront metadata
+
+internal void
+tctx_set_wavefront_info(U64 wavefront_idx, U64 wavefront_count)
+{
+  TCTX *tctx = tctx_selected();
+  OS_Handle barrier = os_barrier_alloc(wavefront_count);
+  tctx->wavefront_idx = wavefront_idx;
+  tctx->wavefront_count = wavefront_count;
+  tctx->wavefront_barrier_id = barrier.u64[0];
+}
+
+internal void
+tctx_wavefront_barrier_wait(void)
+{
+  TCTX *tctx = tctx_selected();
+  OS_Handle barrier = {tctx->wavefront_barrier_id};
+  os_barrier_wait(barrier);
+}
+
+//- rjf: thread names
+
 internal void
 tctx_set_thread_name(String8 string)
 {
-  TCTX *tctx = tctx_get_equipped();
+  TCTX *tctx = tctx_selected();
   U64 size = ClampTop(string.size, sizeof(tctx->thread_name));
   MemoryCopy(tctx->thread_name, string.str, size);
   tctx->thread_name_size = size;
@@ -75,15 +106,17 @@ tctx_set_thread_name(String8 string)
 internal String8
 tctx_get_thread_name(void)
 {
-  TCTX *tctx = tctx_get_equipped();
+  TCTX *tctx = tctx_selected();
   String8 result = str8(tctx->thread_name, tctx->thread_name_size);
   return result;
 }
 
+//- rjf: thread source-locations
+
 internal void
 tctx_write_srcloc(char *file_name, U64 line_number)
 {
-  TCTX *tctx = tctx_get_equipped();
+  TCTX *tctx = tctx_selected();
   tctx->file_name = file_name;
   tctx->line_number = line_number;
 }
@@ -91,7 +124,7 @@ tctx_write_srcloc(char *file_name, U64 line_number)
 internal void
 tctx_read_srcloc(char **file_name, U64 *line_number)
 {
-  TCTX *tctx = tctx_get_equipped();
+  TCTX *tctx = tctx_selected();
   *file_name = tctx->file_name;
   *line_number = tctx->line_number;
 }

src/base/base_thread_context.h

@@ -5,37 +5,55 @@
 #define BASE_THREAD_CONTEXT_H
 
 ////////////////////////////////
-// NOTE(allen): Thread Context
+//~ rjf: Base Per-Thread State Bundle
 
 typedef struct TCTX TCTX;
 struct TCTX
 {
+  // rjf: scratch arenas
   Arena *arenas[2];
   
+  // rjf: thread name
   U8 thread_name[32];
   U64 thread_name_size;
   
+  // rjf: wavefront info
+  U64 wavefront_idx;
+  U64 wavefront_count;
+  U64 wavefront_barrier_id;
+  
+  // rjf: source location info
   char *file_name;
   U64 line_number;
 };
 
 ////////////////////////////////
-// NOTE(allen): Thread Context Functions
+//~ rjf: Thread Context Functions
 
-internal void      tctx_init_and_equip(TCTX *tctx);
-internal void      tctx_release(void);
-internal TCTX*     tctx_get_equipped(void);
-
-internal Arena*    tctx_get_scratch(Arena **conflicts, U64 count);
-
-internal void      tctx_set_thread_name(String8 name);
-internal String8   tctx_get_thread_name(void);
-
-internal void      tctx_write_srcloc(char *file_name, U64 line_number);
-internal void      tctx_read_srcloc(char **file_name, U64 *line_number);
-#define tctx_write_this_srcloc() tctx_write_srcloc(__FILE__, __LINE__)
+//- rjf: thread-context allocation & selection
+internal TCTX *tctx_alloc(void);
+internal void tctx_release(TCTX *tctx);
+internal void tctx_select(TCTX *tctx);
+internal TCTX *tctx_selected(void);
 
+//- rjf: scratch arenas
+internal Arena *tctx_get_scratch(Arena **conflicts, U64 count);
 #define scratch_begin(conflicts, count) temp_begin(tctx_get_scratch((conflicts), (count)))
 #define scratch_end(scratch) temp_end(scratch)
 
+//- rjf: wavefront metadata
+internal void tctx_set_wavefront_info(U64 wavefront_idx, U64 wavefront_count);
+internal void tctx_wavefront_barrier_wait(void);
+#define wavefront_thread(idx, count) tctx_set_wavefront_info((idx), (count))
+#define wavefront_barrier() tctx_wavefront_barrier_wait()
+
+//- rjf: thread names
+internal void tctx_set_thread_name(String8 name);
+internal String8 tctx_get_thread_name(void);
+
+//- rjf: thread source-locations
+internal void tctx_write_srcloc(char *file_name, U64 line_number);
+internal void tctx_read_srcloc(char **file_name, U64 *line_number);
+#define tctx_write_this_srcloc() tctx_write_srcloc(__FILE__, __LINE__)
+
 #endif // BASE_THREAD_CONTEXT_H

src/os/core/linux/os_core_linux.c

@@ -123,10 +123,7 @@ os_lnx_thread_entry_point(void *ptr)
   OS_LNX_Entity *entity = (OS_LNX_Entity *)ptr;
   OS_ThreadFunctionType *func = entity->thread.func;
   void *thread_ptr = entity->thread.ptr;
-  TCTX tctx_;
-  tctx_init_and_equip(&tctx_);
-  func(thread_ptr);
-  tctx_release();
+  supplement_thread_base_entry_point(func, thread_ptr);
   return 0;
 }
 
@@ -1302,8 +1299,8 @@ main(int argc, char **argv)
     }
     
     //- rjf: set up thread context
-    local_persist TCTX tctx;
-    tctx_init_and_equip(&tctx);
+    TCTX *tctx = tctx_alloc();
+    tctx_select(tctx);
     
     //- rjf: set up dynamically allocated state
     os_lnx_state.arena = arena_alloc();

src/os/core/win32/os_core_win32.c

@@ -145,10 +145,7 @@ os_w32_thread_entry_point(void *ptr)
   OS_W32_Entity *entity = (OS_W32_Entity *)ptr;
   OS_ThreadFunctionType *func = entity->thread.func;
   void *thread_ptr = entity->thread.ptr;
-  TCTX tctx_;
-  tctx_init_and_equip(&tctx_);
-  func(thread_ptr);
-  tctx_release();
+  supplement_thread_base_entry_point(func, thread_ptr);
   return 0;
 }
 
@@ -1776,8 +1773,8 @@ w32_entry_point_caller(int argc, WCHAR **wargv)
   }
   
   //- rjf: set up thread context
-  local_persist TCTX tctx;
-  tctx_init_and_equip(&tctx);
+  TCTX *tctx = tctx_alloc();
+  tctx_select(tctx);
   
   //- rjf: set up dynamically-alloc'd state
   Arena *arena = arena_alloc();