191 lines
7.2 KiB
Odin
191 lines
7.2 KiB
Odin
package host
|
|
|
|
//region STATIC MEMORY
|
|
// All program defined process memory here. (There will still be artifacts from the OS CRT and third-party pacakges)
|
|
host_memory: ProcessMemory
|
|
@(thread_local) thread_memory: ThreadMemory
|
|
|
|
//endregion STATIC MEMORY
|
|
|
|
//region HOST RUNTIME
|
|
|
|
load_client_api :: proc(version_id: int) -> (loaded_module: Client_API) {
|
|
using loaded_module
|
|
// Make sure we have a dll to work with
|
|
file_io_err: OS_Error; write_time, file_io_err = file_last_write_time_by_name("sectr.dll")
|
|
if file_io_err != OS_ERROR_NONE {
|
|
panic_contextless( "Could not resolve the last write time for sectr")
|
|
}
|
|
//TODO(Ed): Lets try to minimize this...
|
|
thread_sleep( Millisecond * 100 )
|
|
// Get the live dll loaded up
|
|
live_file := Path_Sectr_Live_Module
|
|
file_copy_sync( Path_Sectr_Module, live_file, allocator = context.temp_allocator )
|
|
did_load: bool; lib, did_load = os_lib_load( live_file )
|
|
if ! did_load do panic( "Failed to load the sectr module.")
|
|
startup = cast( type_of( host_memory.client_api.startup)) os_lib_get_proc(lib, "startup")
|
|
tick_lane_startup = cast( type_of( host_memory.client_api.tick_lane_startup)) os_lib_get_proc(lib, "tick_lane_startup")
|
|
hot_reload = cast( type_of( host_memory.client_api.hot_reload)) os_lib_get_proc(lib, "hot_reload")
|
|
tick_lane = cast( type_of( host_memory.client_api.tick_lane)) os_lib_get_proc(lib, "tick_lane")
|
|
clean_frame = cast( type_of( host_memory.client_api.clean_frame)) os_lib_get_proc(lib, "clean_frame")
|
|
if startup == nil do panic("Failed to load sectr.startup symbol" )
|
|
if tick_lane_startup == nil do panic("Failed to load sectr.tick_lane_startup symbol" )
|
|
if hot_reload == nil do panic("Failed to load sectr.hot_reload symbol" )
|
|
if tick_lane == nil do panic("Failed to load sectr.tick_lane symbol" )
|
|
if clean_frame == nil do panic("Failed to load sectr.clean_frmae symbol" )
|
|
lib_version = version_id
|
|
return
|
|
}
|
|
|
|
master_prepper_proc :: proc(thread: ^SysThread) {}
|
|
main :: proc()
|
|
{
|
|
// Setup host arenas
|
|
arena_init(& host_memory.host_persist, host_memory.host_persist_buf[:])
|
|
arena_init(& host_memory.host_scratch, host_memory.host_scratch_buf[:])
|
|
context.allocator = arena_allocator(& host_memory.host_persist)
|
|
context.temp_allocator = arena_allocator(& host_memory.host_scratch)
|
|
when SHOULD_SETUP_PROFILERS
|
|
{
|
|
// Setup profilers
|
|
buffer_backing := make([]u8, SPALL_BUFFER_DEFAULT_SIZE * 4)
|
|
host_memory.spall_profiler.ctx = spall_context_create(Path_Sectr_Spall_Record)
|
|
host_memory.spall_profiler.buffer = spall_buffer_create(buffer_backing)
|
|
}
|
|
// Setu the "Master Prepper" thread
|
|
thread_memory.id = .Master_Prepper
|
|
thread_id := thread_current_id()
|
|
{
|
|
using thread_memory
|
|
system_ctx = & host_memory.threads[WorkerID.Master_Prepper]
|
|
system_ctx.creation_allocator = {}
|
|
system_ctx.procedure = master_prepper_proc
|
|
when ODIN_OS == .Windows {
|
|
// system_ctx.win32_thread = w32_get_current_thread()
|
|
// system_ctx.win32_thread_id = w32_get_current_thread_id()
|
|
system_ctx.id = cast(int) system_ctx.win32_thread_id
|
|
}
|
|
free_all(context.temp_allocator)
|
|
}
|
|
// Setup the logger
|
|
{
|
|
fmt_backing := make([]byte, 32 * Kilo)
|
|
defer free_all(context.temp_allocator)
|
|
|
|
// Generating the logger's name, it will be used when the app is shutting down.
|
|
path_logger_finalized : string
|
|
{
|
|
startup_time := time_now()
|
|
year, month, day := time_date( startup_time)
|
|
hour, min, sec := time_clock_from_time( startup_time)
|
|
|
|
if ! os_is_directory( Path_Logs ) {
|
|
os_make_directory( Path_Logs )
|
|
}
|
|
timestamp := str_pfmt_buffer( fmt_backing, "%04d-%02d-%02d_%02d-%02d-%02d", year, month, day, hour, min, sec)
|
|
path_logger_finalized = str_pfmt_buffer( fmt_backing, "%s/sectr_%v.log", Path_Logs, timestamp)
|
|
}
|
|
logger_init( & host_memory.logger, "Sectr Host", str_pfmt_buffer( fmt_backing, "%s/sectr.log", Path_Logs ) )
|
|
context.logger = to_odin_logger( & host_memory.logger )
|
|
{
|
|
// Log System Context
|
|
builder := strbuilder_from_bytes( fmt_backing )
|
|
str_pfmt_builder( & builder, "Core Count: %v, ", os_core_count() )
|
|
str_pfmt_builder( & builder, "Page Size: %v", os_page_size() )
|
|
log_print( to_str(builder) )
|
|
}
|
|
}
|
|
context.logger = to_odin_logger( & host_memory.logger )
|
|
// Load the Enviornment API for the first-time
|
|
{
|
|
host_memory.client_api = load_client_api( 1 )
|
|
verify( host_memory.client_api.lib_version != 0, "Failed to initially load the sectr module" )
|
|
}
|
|
// Client API Startup
|
|
host_memory.client_api.startup(& host_memory, & thread_memory)
|
|
// Start the tick lanes
|
|
/*thread_wide_startup() :: proc()*/ {
|
|
assert(thread_memory.id == .Master_Prepper)
|
|
if THREAD_TICK_LANES > 1 {
|
|
launch_tick_lane_thread(.Atomic_Accountant)
|
|
barrier_init(& host_memory.client_api_sync_lock, THREAD_TICK_LANES)
|
|
}
|
|
host_tick_lane_startup(thread_memory.system_ctx)
|
|
}
|
|
}
|
|
launch_tick_lane_thread :: proc(id : WorkerID) {
|
|
assert_contextless(thread_memory.id == .Master_Prepper)
|
|
// TODO(Ed): We need to make our own version of this that doesn't allocate memory.
|
|
lane_thread := thread_create(host_tick_lane_startup, .High)
|
|
lane_thread.user_index = int(id)
|
|
thread_start(lane_thread)
|
|
}
|
|
|
|
host_tick_lane_startup :: proc(lane_thread: ^SysThread) {
|
|
thread_memory.system_ctx = lane_thread
|
|
thread_memory.id = cast(WorkerID) lane_thread.user_index
|
|
host_memory.client_api.tick_lane_startup(& thread_memory)
|
|
host_tick_lane()
|
|
}
|
|
host_tick_lane :: proc()
|
|
{
|
|
delta_ns: Duration
|
|
|
|
host_tick := time_tick_now()
|
|
|
|
running : b64 = true
|
|
for ; running ;
|
|
{
|
|
profile("Host Tick")
|
|
leader := barrier_wait(& host_memory.client_api_sync_lock)
|
|
sync_client_api()
|
|
|
|
running = host_memory.client_api.tick_lane( duration_seconds(delta_ns), delta_ns )
|
|
// host_memory.client_api.clean_frame()
|
|
|
|
delta_ns = time_tick_lap_time( & host_tick )
|
|
host_tick = time_tick_now()
|
|
}
|
|
}
|
|
|
|
@export
|
|
sync_client_api :: proc()
|
|
{
|
|
profile(#procedure)
|
|
{
|
|
if thread_memory.id == .Master_Prepper
|
|
{
|
|
profile("Master_Prepper: Reloading client module")
|
|
write_time, result := file_last_write_time_by_name( Path_Sectr_Module );
|
|
if result == OS_ERROR_NONE && host_memory.client_api.write_time != write_time
|
|
{
|
|
sync_store(& host_memory.client_api_hot_reloaded, true, .Release)
|
|
version_id := host_memory.client_api.lib_version + 1
|
|
unload_client_api( & host_memory.client_api )
|
|
// Wait for pdb to unlock (linker may still be writting)
|
|
for ; file_is_locked( Path_Sectr_Debug_Symbols ) && file_is_locked( Path_Sectr_Live_Module ); {}
|
|
thread_sleep( Millisecond * 100 )
|
|
host_memory.client_api = load_client_api( version_id )
|
|
verify( host_memory.client_api.lib_version != 0, "Failed to hot-reload the sectr module" )
|
|
}
|
|
}
|
|
}
|
|
leader := barrier_wait(& host_memory.client_api_sync_lock)
|
|
if sync_load(& host_memory.client_api_hot_reloaded, .Acquire)
|
|
{
|
|
host_memory.client_api.hot_reload(& host_memory, & thread_memory)
|
|
if thread_memory.id == .Master_Prepper {
|
|
sync_store(& host_memory.client_api_hot_reloaded, false, .Release)
|
|
}
|
|
}
|
|
}
|
|
unload_client_api :: proc( module : ^Client_API )
|
|
{
|
|
os_lib_unload( module.lib )
|
|
file_remove( Path_Sectr_Live_Module )
|
|
module^ = {}
|
|
log_print("Unloaded client API")
|
|
}
|
|
|
|
//endregion HOST RUNTIME
|