jacob/power_play
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

alloc - > acquire

Browse Source
This commit is contained in:
jacob 2025-08-05 15:06:06 -05:00
parent 26bff4e741
commit f0052f700e
40 changed files with 324 additions and 315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/.vscode/settings.json vendored Normal file
View File

@ -0,0 +1,9 @@
{
"files.associations": {
"*.rst": "hlsl",
"*.knl": "hlsl",
"chrono": "c",
"system_error": "c",
"xlocale": "c"
}
}

2
src/app/app_core.c
View File

@ -167,7 +167,7 @@ void Startup(void)
BB_Test();
#endif
g->arena = AllocArena(Gibi(64));
g->arena = AcquireArena(Gibi(64));
g->write_path = InitializeAppWriteDirectory(g->arena, Lit(WRITE_DIR));

2
src/asset_cache/asset_cache_core.c
View File

@ -9,7 +9,7 @@ void AC_StartupCore(void)
{
__prof;
AC_SharedState *g = &AC_shared_state;
g->store_arena = AllocArena(Gibi(64));
g->store_arena = AcquireArena(Gibi(64));
}
////////////////////////////////

2
src/base/base_arena.c
View File

@ -1,7 +1,7 @@
SharedArenaCtx shared_arena_ctx = ZI;
/* NOTE: Application will exit if arena fails to reserve or commit initial memory. */
Arena *AllocArena(u64 reserve)
Arena *AcquireArena(u64 reserve)
{
__prof;
reserve += ArenaHeaderSize;

8
src/base/base_arena.h
View File

@ -56,7 +56,7 @@ extern SharedArenaCtx shared_arena_ctx;
#define PopStruct(a, type, dst) PopBytes((a), sizeof(type), dst)
#define PopStructs(a, type, n, dst) PopBytes((a), sizeof(type) * (n), dst)
/* Returns a pointer to where the next allocation would be (at alignment of type).
/* Returns a pointer to where the next push would be (at alignment of type).
* Equivalent to PushStruct but without actually allocating anything or modifying the arena. */
#define PushDry(a, type) (type *)(_PushDry((a), alignof(type)))
@ -107,7 +107,7 @@ Inline void *_PushDry(Arena *arena, u64 align)
////////////////////////////////
//~ Arena management
Arena *AllocArena(u64 reserve);
Arena *AcquireArena(u64 reserve);
void ReleaseArena(Arena *arena);
void CopyArena(Arena *dst, Arena *src);
@ -165,9 +165,9 @@ Inline ArenaCtx *ArenaCtxFromFiberId(i16 fiber_id)
if (!ctx->scratch_arenas[0]) {
__profn("Initialize fiber arena ctx");
for (i32 i = 0; i < (i32)countof(ctx->scratch_arenas); ++i) {
ctx->scratch_arenas[i] = AllocArena(Gibi(64));
ctx->scratch_arenas[i] = AcquireArena(Gibi(64));
}
ctx->perm_arena = AllocArena(Gibi(64));
ctx->perm_arena = AcquireArena(Gibi(64));
}
return ctx;
}

10
src/base/base_buddy.c
View File

@ -3,13 +3,13 @@
////////////////////////////////
//~ Buddy ctx
BuddyCtx *AllocBuddyCtx(u64 reserve)
BuddyCtx *AcquireBuddyCtx(u64 reserve)
{
/* TODO: Determine meta reserve dynamically */
Arena *meta_arena = AllocArena(Gibi(64));
Arena *meta_arena = AcquireArena(Gibi(64));
BuddyCtx *ctx = PushStruct(meta_arena, BuddyCtx);
ctx->meta_arena = meta_arena;
ctx->data_arena = AllocArena(reserve);
ctx->data_arena = AcquireArena(reserve);
/* TODO: Minimum block size */
ctx->levels = PushStructs(ctx->meta_arena, BuddyLevel, 64);
@ -31,9 +31,9 @@ void ReleaseBuddyCtx(BuddyCtx *ctx)
}
////////////////////////////////
//~ Block alloc / release
//~ Block acquire / release
BuddyBlock *AllocBuddyBlock(BuddyCtx *ctx, u64 size)
BuddyBlock *AcquireBuddyBlock(BuddyCtx *ctx, u64 size)
{
if (size > 0x00FFFFFFFFFFFFFFULL)
{

6
src/base/base_buddy.h
View File

@ -38,14 +38,14 @@ Struct(BuddyCtx)
////////////////////////////////
//~ Buddy context operations
BuddyCtx *AllocBuddyCtx(u64 reserve);
BuddyCtx *AcquireBuddyCtx(u64 reserve);
void ReleaseBuddyCtx(BuddyCtx *ctx);
////////////////////////////////
//~ Buddy block operations
//- Alloc / release
BuddyBlock *AllocBuddyBlock(BuddyCtx *ctx, u64 size);
//- Acquire / release
BuddyBlock *AcquireBuddyBlock(BuddyCtx *ctx, u64 size);
void ReleaseBuddyBlock(BuddyBlock *block);
//- Push / pop

36
src/base/win32/base_win32_job.c
View File

@ -36,16 +36,16 @@ void StartupBaseJobs(void)
/* Init fibers */
g->num_fibers = 1; /* Fiber at index 0 always nil */
g->fiber_names_arena = AllocArena(Gibi(64));
g->fiber_names_arena = AcquireArena(Gibi(64));
/* Init job descs */
g->job_descs_arena = AllocArena(Gibi(64));
g->job_descs_arena = AcquireArena(Gibi(64));
/* Convert main thread to fiber */
W32_AllocFiber(0);
W32_AcquireFiber(0);
/* Init wait lists */
g->wait_lists_arena = AllocArena(Gibi(64));
g->wait_lists_arena = AcquireArena(Gibi(64));
/* Init job pools */
for (JobPool pool_kind = 0; pool_kind < (i32)countof(g->job_pools); ++pool_kind)
@ -56,16 +56,16 @@ void StartupBaseJobs(void)
for (JobPriority priority = 0; priority < (i32)countof(pool->job_queues); ++priority)
{
W32_JobQueue *queue = &pool->job_queues[priority];
queue->arena = AllocArena(Gibi(64));
queue->arena = AcquireArena(Gibi(64));
}
}
/* Init threads pool */
g->threads_arena = AllocArena(Gibi(64));
g->threads_arena = AcquireArena(Gibi(64));
/* Start job scheduler */
Atomic64FetchSet(&g->current_scheduler_cycle_period_ns.v, W32_DefaultSchedulerPeriodNs);
W32_Thread *scheduler_thread = W32_AllocThread(W32_JobSchedulerEntryFunc, 0, Lit("Scheduler thread"), PROF_THREAD_GROUP_SCHEDULER);
W32_Thread *scheduler_thread = W32_AcquireThread(W32_JobSchedulerEntryFunc, 0, Lit("Scheduler thread"), PROF_THREAD_GROUP_SCHEDULER);
LAX scheduler_thread;
//- Start job workers
@ -120,7 +120,7 @@ void StartupBaseJobs(void)
pool->thread_affinity_mask = 0x0000000000000FFFull;
} break;
}
pool->worker_threads_arena = AllocArena(Gibi(64));
pool->worker_threads_arena = AcquireArena(Gibi(64));
pool->worker_threads = PushStructs(pool->worker_threads_arena, W32_Thread *, pool->num_worker_threads);
pool->worker_contexts = PushStructs(pool->worker_threads_arena, W32_WorkerCtx, pool->num_worker_threads);
for (i32 i = 0; i < pool->num_worker_threads; ++i)
@ -129,7 +129,7 @@ void StartupBaseJobs(void)
ctx->pool_kind = pool_kind;
ctx->id = i;
String name = StringFormat(pool->worker_threads_arena, name_fmt, FmtSint(i));
pool->worker_threads[i] = W32_AllocThread(W32_JobWorkerEntryFunc, ctx, name, prof_group + i);
pool->worker_threads[i] = W32_AcquireThread(W32_JobWorkerEntryFunc, ctx, name, prof_group + i);
}
}
}
@ -209,7 +209,7 @@ void ShutdownJobs(void)
DWORD WINAPI W32_Win32ThreadProc(LPVOID vt)
{
W32_AllocFiber(0);
W32_AcquireFiber(0);
W32_Thread *t = (W32_Thread *)vt;
__profthread(t->thread_name_cstr, t->profiler_group);
@ -234,7 +234,7 @@ DWORD WINAPI W32_Win32ThreadProc(LPVOID vt)
return 0;
}
W32_Thread *W32_AllocThread(W32_ThreadFunc *entry_point, void *thread_data, String thread_name, i32 profiler_group)
W32_Thread *W32_AcquireThread(W32_ThreadFunc *entry_point, void *thread_data, String thread_name, i32 profiler_group)
{
__prof;
TempArena scratch = BeginScratchNoConflict();
@ -242,7 +242,7 @@ W32_Thread *W32_AllocThread(W32_ThreadFunc *entry_point, void *thread_data, Stri
Assert(entry_point != 0);
//P_LogInfoF("Creating thread \"%F\"", FmtString(thread_name));
/* Allocate thread object */
/* Acquire thread object */
W32_Thread *t = 0;
{
LockTicketMutex(&g->threads_tm);
@ -701,9 +701,9 @@ void W32_WakeByTime(u64 time)
////////////////////////////////
//~ Win32 fiber
//- Allocate fiber
//- Acquire fiber
/* If `pool` is 0, then the currently running thread will be converted into a fiber */
W32_Fiber *W32_AllocFiber(W32_JobPool *pool)
W32_Fiber *W32_AcquireFiber(W32_JobPool *pool)
{
W32_SharedJobCtx *g = &W32_shared_job_ctx;
i16 fiber_id = 0;
@ -1046,7 +1046,7 @@ W32_ThreadDef(W32_JobWorkerEntryFunc, worker_ctx_arg)
{
if (!job_fiber)
{
job_fiber = W32_AllocFiber(pool);
job_fiber = W32_AcquireFiber(pool);
}
job_fiber_id = job_fiber->id;
{
@ -1128,7 +1128,7 @@ W32_ThreadDef(W32_JobWorkerEntryFunc, worker_ctx_arg)
wait_addr_list = tmp;
}
}
//- Allocate new wait addr list
//- Acquire new wait addr list
if (!wait_addr_list)
{
if (wait_addr_bin->first_free_wait_list)
@ -1182,7 +1182,7 @@ W32_ThreadDef(W32_JobWorkerEntryFunc, worker_ctx_arg)
wait_time_list = tmp;
}
}
//- Allocate new wait time list
//- Acquire new wait time list
if (!wait_time_list)
{
if (wait_time_bin->first_free_wait_list)
@ -1419,7 +1419,7 @@ GenericJobDesc *PushJobDesc_(u64 sig_size, u64 sig_align, GenericJobFunc *func,
else
{
result = PushStructNoZero(g->job_descs_arena, GenericJobDesc);
arena = AllocArena(Mebi(4));
arena = AcquireArena(Mebi(4));
}
}
UnlockTicketMutex(&g->job_descs_tm);

4
src/base/win32/base_win32_job.h
View File

@ -259,7 +259,7 @@ void ShutdownJobs(void);
//~ Thread operations
DWORD WINAPI W32_Win32ThreadProc(LPVOID vt);
W32_Thread *W32_AllocThread(W32_ThreadFunc *entry_point, void *thread_data, String thread_name, i32 profiler_group);
W32_Thread *W32_AcquireThread(W32_ThreadFunc *entry_point, void *thread_data, String thread_name, i32 profiler_group);
b32 W32_TryReleaseThread(W32_Thread *thread, f32 timeout_seconds);
void W32_WaitReleaseThread(W32_Thread *thread);
@ -273,7 +273,7 @@ void W32_WakeByTime(u64 time);
////////////////////////////////
//~ Fiber operations
W32_Fiber *W32_AllocFiber(W32_JobPool *pool);
W32_Fiber *W32_AcquireFiber(W32_JobPool *pool);
void W32_ReleaseFiber(W32_JobPool *pool, W32_Fiber *fiber);
ForceInline W32_Fiber *W32_FiberFromId(i16 id);
ForceNoInline void W32_FiberResume(W32_Fiber *fiber);

6
src/bitbuff/bitbuff_core.c
View File

@ -3,10 +3,10 @@
////////////////////////////////
//~ Buff management
BB_Buff AllocBitbuff(u64 arena_reserve)
BB_Buff AcquireBitbuff(u64 arena_reserve)
{
BB_Buff result = ZI;
result.arena = AllocArena(arena_reserve);
result.arena = AcquireArena(arena_reserve);
result.is_backed_by_arena = 1;
return result;
}
@ -809,7 +809,7 @@ void BB_Test(void)
String encoded = ZI;
{
BB_Buff bb = AllocBitbuff(Gibi(64));
BB_Buff bb = AcquireBitbuff(Gibi(64));
BB_Writer bw = BB_WriterFromBuff(&bb);
for (u64 i = 0; i < countof(cases); ++i)
{

2
src/bitbuff/bitbuff_core.h
View File

@ -63,7 +63,7 @@ typedef u32 BB_DebugMagicKind; enum
////////////////////////////////
//~ Buff management
BB_Buff AllocBitbuff(u64 arena_reserve);
BB_Buff AcquireBitbuff(u64 arena_reserve);
void ReleaseBitbuff(BB_Buff *bitbuff);
BB_Buff BitbuffFromString(String s);

2
src/draw/draw_core.c
View File

@ -8,7 +8,7 @@ void D_StartupCore(void)
__prof;
D_SharedState *g = &D_shared_state;
u32 pixel_white = 0xFFFFFFFF;
g->solid_white_texture = GPU_AllocTexture(GP_TEXTURE_FORMAT_R8G8B8A8_UNORM, 0, VEC2I32(1, 1), &pixel_white);
g->solid_white_texture = GPU_AcquireTexture(GP_TEXTURE_FORMAT_R8G8B8A8_UNORM, 0, VEC2I32(1, 1), &pixel_white);
}
////////////////////////////////

4
src/font/font_core.c
View File

@ -48,9 +48,9 @@ JobDef(F_LoadJob, sig, _)
RES_CloseResource(&res);
/* Send texture to GPU */
GPU_Resource *texture = GPU_AllocTexture(GP_TEXTURE_FORMAT_R8G8B8A8_UNORM, 0, VEC2I32(result.image_width, result.image_height), result.image_pixels);
GPU_Resource *texture = GPU_AcquireTexture(GP_TEXTURE_FORMAT_R8G8B8A8_UNORM, 0, VEC2I32(result.image_width, result.image_height), result.image_pixels);
/* Allocate store memory */
/* Acquire store memory */
F_Font *font = 0;
{
AC_Store store = AC_OpenStore();

6
src/gpu/gpu_core.h
View File

@ -125,14 +125,14 @@ void GPU_ReleaseResourceFenced(GPU_Resource *resource);
////////////////////////////////
//~ Texture operations
GPU_Resource *GPU_AllocTexture(GPU_TextureFormat format, u32 flags, Vec2I32 size, void *initial_data);
GPU_Resource *GPU_AcquireTexture(GPU_TextureFormat format, u32 flags, Vec2I32 size, void *initial_data);
Vec2I32 GPU_GetTextureSize(GPU_Resource *texture);
////////////////////////////////
//~ Render operations
GPU_RenderSig *GPU_AllocRenderSig(void);
GPU_RenderSig *GPU_AcquireRenderSig(void);
/* Returns a cmd id internal to the sig */
u32 GPU_PushRenderCmd(GPU_RenderSig *render_sig, GPU_RenderCmdDesc *desc);
@ -147,7 +147,7 @@ GPU_MemoryInfo GPU_QueryMemoryInfo(void);
////////////////////////////////
//~ Swapchain
GPU_Swapchain *GPU_AllocSwapchain(P_Window *window, Vec2I32 resolution);
GPU_Swapchain *GPU_AcquireSwapchain(P_Window *window, Vec2I32 resolution);
void GPU_ReleaseSwapchain(GPU_Swapchain *gp_swapchain);

130
src/gpu/gpu_dx12.c
View File

@ -28,26 +28,26 @@ void GPU_StartupCore(void)
}
/* Initialize command descriptor heaps pool */
g->command_descriptor_heaps_arena = AllocArena(Gibi(64));
g->command_descriptor_heaps_arena = AcquireArena(Gibi(64));
/* Initialize command buffers pool */
g->command_buffers_arena = AllocArena(Gibi(64));
g->command_buffers_arena = AcquireArena(Gibi(64));
g->command_buffers_dict = InitDict(g->command_buffers_arena, 4096);
/* Initialize resources pool */
g->resources_arena = AllocArena(Gibi(64));
g->resources_arena = AcquireArena(Gibi(64));
/* Initialize swapchains pool */
g->swapchains_arena = AllocArena(Gibi(64));
g->swapchains_arena = AcquireArena(Gibi(64));
/* Initialize pipeline cache */
g->pipelines_arena = AllocArena(Gibi(64));
g->pipelines_arena = AcquireArena(Gibi(64));
g->pipeline_descs = InitDict(g->pipelines_arena, 1024);
g->top_pipelines = InitDict(g->pipelines_arena, 1024);
g->top_successful_pipelines = InitDict(g->pipelines_arena, 1024);
/* Initialize fenced releases queue */
g->fenced_releases_arena = AllocArena(Gibi(64));
g->fenced_releases_arena = AcquireArena(Gibi(64));
/* Initialize embedded shader archive */
String embedded_data = INC_GetDxcTar();
@ -310,12 +310,12 @@ void GPU_D12_InitObjects(void)
g->desc_counts[D3D12_DESCRIPTOR_HEAP_TYPE_RTV] = DX12_NUM_RTV_DESCRIPTORS;
/* Create global descriptor heaps */
g->cbv_srv_uav_heap = GPU_D12_AllocCpuDescriptorHeap(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
g->rtv_heap = GPU_D12_AllocCpuDescriptorHeap(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
g->cbv_srv_uav_heap = GPU_D12_AcquireCpuDescriptorHeap(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
g->rtv_heap = GPU_D12_AcquireCpuDescriptorHeap(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
/* Create command queues */
{
__profn("Allocate command queues");
__profn("Acquire command queues");
GPU_D12_CommandQueueDesc params[] = {
{.type = D3D12_COMMAND_LIST_TYPE_DIRECT, .priority = D3D12_COMMAND_QUEUE_PRIORITY_NORMAL, .dbg_name = Lit("Direct queue") },
{.type = D3D12_COMMAND_LIST_TYPE_COMPUTE, .priority = D3D12_COMMAND_QUEUE_PRIORITY_NORMAL, .dbg_name = Lit("Compute queue") },
@ -324,7 +324,7 @@ void GPU_D12_InitObjects(void)
};
{
Counter counter = ZI;
RunJob(DX12_NUM_QUEUES, GPU_D12_AllocCommandQueueJob, JobPool_Inherit, JobPriority_Low, &counter, .descs_in = params, .cqs_out = g->command_queues);
RunJob(DX12_NUM_QUEUES, GPU_D12_AcquireCommandQueueJob, JobPool_Inherit, JobPriority_Low, &counter, .descs_in = params, .cqs_out = g->command_queues);
WaitOnCounter(&counter);
DEBUGBREAKABLE;
}
@ -336,7 +336,7 @@ void GPU_D12_InitObjects(void)
{
GPU_D12_CommandQueue *cq = g->command_queues[i];
String dbg_name = params[i].dbg_name;
__prof_dx12_ctx_alloc(cq->prof, g->device, cq->cq, dbg_name.text, dbg_name.len);
__prof_dx12_ctx_acquire(cq->prof, g->device, cq->cq, dbg_name.text, dbg_name.len);
LAX dbg_name;
}
}
@ -415,9 +415,9 @@ void GPU_InitPipelines(void)
}
GPU_D12_Pipeline **pipelines = PushStructs(scratch.arena, GPU_D12_Pipeline *, num_pipelines);
{
__profn("Allocate pipelines");
__profn("Acquire pipelines");
Counter counter = ZI;
RunJob(num_pipelines, GPU_D12_AllocPipelineJob, JobPool_Inherit, JobPriority_Inherit, &counter, .descs_in = descs, .pipelines_out = pipelines);
RunJob(num_pipelines, GPU_D12_AcquirePipelineJob, JobPool_Inherit, JobPriority_Inherit, &counter, .descs_in = descs, .pipelines_out = pipelines);
WaitOnCounter(&counter);
}
for (u32 i = 0; i < num_pipelines; ++i)
@ -490,8 +490,8 @@ void GPU_D12_InitNoise(void)
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
GPU_D12_Resource *r = GPU_D12_AllocResource(heap_props, heap_flags, desc, D3D12_RESOURCE_STATE_COPY_DEST);
r->srv_descriptor = GPU_D12_AllocDescriptor(g->cbv_srv_uav_heap);
GPU_D12_Resource *r = GPU_D12_AcquireResource(heap_props, heap_flags, desc, D3D12_RESOURCE_STATE_COPY_DEST);
r->srv_descriptor = GPU_D12_AcquireDescriptor(g->cbv_srv_uav_heap);
ID3D12Device_CreateShaderResourceView(g->device, r->resource, 0, r->srv_descriptor->handle);
/* Upload texture */
@ -568,7 +568,7 @@ JobDef(GPU_D12_CompileShaderJob, sig, id)
* Pipeline
* ========================== */
JobDef(GPU_D12_AllocPipelineJob, sig, id)
JobDef(GPU_D12_AcquirePipelineJob, sig, id)
{
__prof;
GPU_D12_SharedState *g = &GPU_D12_shared_state;
@ -936,7 +936,7 @@ GPU_D12_PipelineScope *GPU_D12_BeginPipelineScope(void)
}
else
{
arena = AllocArena(Mebi(64));
arena = AcquireArena(Mebi(64));
}
ResetArena(arena);
scope = PushStruct(arena, GPU_D12_PipelineScope);
@ -1170,7 +1170,7 @@ W_CallbackFuncDef(GPU_D12_WatchPipelineCallback, name)
GPU_D12_Pipeline **pipelines = PushStructs(scratch.arena, GPU_D12_Pipeline *, num_pipelines);
{
Counter counter = ZI;
RunJob(num_pipelines, GPU_D12_AllocPipelineJob, JobPool_Inherit, JobPriority_Low, &counter, .descs_in = pipeline_descs, .pipelines_out = pipelines);
RunJob(num_pipelines, GPU_D12_AcquirePipelineJob, JobPool_Inherit, JobPriority_Low, &counter, .descs_in = pipeline_descs, .pipelines_out = pipelines);
WaitOnCounter(&counter);
}
{
@ -1219,7 +1219,7 @@ W_CallbackFuncDef(GPU_D12_WatchPipelineCallback, name)
* Descriptor
* ========================== */
GPU_D12_Descriptor *GPU_D12_AllocDescriptor(GPU_D12_CpuDescriptorHeap *dh)
GPU_D12_Descriptor *GPU_D12_AcquireDescriptor(GPU_D12_CpuDescriptorHeap *dh)
{
__prof;
GPU_D12_Descriptor *d = 0;
@ -1268,13 +1268,13 @@ void GPU_D12_ReleaseDescriptor(GPU_D12_Descriptor *descriptor)
* CPU descriptor heap
* ========================== */
GPU_D12_CpuDescriptorHeap *GPU_D12_AllocCpuDescriptorHeap(enum D3D12_DESCRIPTOR_HEAP_TYPE type)
GPU_D12_CpuDescriptorHeap *GPU_D12_AcquireCpuDescriptorHeap(enum D3D12_DESCRIPTOR_HEAP_TYPE type)
{
__prof;
GPU_D12_SharedState *g = &GPU_D12_shared_state;
GPU_D12_CpuDescriptorHeap *dh = 0;
{
Arena *arena = AllocArena(Mebi(64));
Arena *arena = AcquireArena(Mebi(64));
dh = PushStruct(arena, GPU_D12_CpuDescriptorHeap);
dh->arena = arena;
}
@ -1363,7 +1363,7 @@ void GPU_D12_ReleaseDataFenced(void *data, GPU_D12_FencedReleaseKind kind)
* Resource
* ========================== */
GPU_D12_Resource *GPU_D12_AllocResource(D3D12_HEAP_PROPERTIES heap_props, D3D12_HEAP_FLAGS heap_flags, D3D12_RESOURCE_DESC desc, D3D12_RESOURCE_STATES initial_state)
GPU_D12_Resource *GPU_D12_AcquireResource(D3D12_HEAP_PROPERTIES heap_props, D3D12_HEAP_FLAGS heap_flags, D3D12_RESOURCE_DESC desc, D3D12_RESOURCE_STATES initial_state)
{
__prof;
GPU_D12_SharedState *g = &GPU_D12_shared_state;
@ -1502,9 +1502,9 @@ void GPU_D12_InsertBarrier(ID3D12GraphicsCommandList *cl, i32 num_descs, GPU_D12
* Command queue
* ========================== */
GPU_D12_CommandListPool *GPU_D12_AllocCommandListPool(GPU_D12_CommandQueue *cq);
GPU_D12_CommandListPool *GPU_D12_AcquireCommandListPool(GPU_D12_CommandQueue *cq);
JobDef(GPU_D12_AllocCommandQueueJob, sig, id)
JobDef(GPU_D12_AcquireCommandQueueJob, sig, id)
{
__prof;
GPU_D12_SharedState *g = &GPU_D12_shared_state;
@ -1512,7 +1512,7 @@ JobDef(GPU_D12_AllocCommandQueueJob, sig, id)
{
GPU_D12_CommandQueue *cq = 0;
{
Arena *arena = AllocArena(Gibi(64));
Arena *arena = AcquireArena(Gibi(64));
cq = PushStruct(arena, GPU_D12_CommandQueue);
cq->arena = arena;
}
@ -1534,7 +1534,7 @@ JobDef(GPU_D12_AllocCommandQueueJob, sig, id)
Panic(Lit("Failed to create command queue fence"));
}
cq->cl_pool = GPU_D12_AllocCommandListPool(cq);
cq->cl_pool = GPU_D12_AcquireCommandListPool(cq);
sig->cqs_out[id] = cq;
}
@ -1552,11 +1552,11 @@ void GPU_D12_ReleaseCommandQueue(GPU_D12_CommandQueue *cq)
* Command list
* ========================== */
GPU_D12_CommandListPool *GPU_D12_AllocCommandListPool(GPU_D12_CommandQueue *cq)
GPU_D12_CommandListPool *GPU_D12_AcquireCommandListPool(GPU_D12_CommandQueue *cq)
{
GPU_D12_CommandListPool *pool = 0;
{
Arena *arena = AllocArena(Gibi(64));
Arena *arena = AcquireArena(Gibi(64));
pool = PushStruct(arena, GPU_D12_CommandListPool);
pool->arena = arena;
}
@ -1768,7 +1768,7 @@ GPU_D12_CommandDescriptorHeap *GPU_D12_PushDescriptorHeap(GPU_D12_CommandList *c
GPU_D12_SharedState *g = &GPU_D12_shared_state;
Assert(dh_cpu->type == D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); /* Src heap must have expected type */
/* Allocate GPU heap */
/* Acquire GPU heap */
GPU_D12_CommandDescriptorHeap *cdh = 0;
ID3D12DescriptorHeap *old_heap = 0;
D3D12_CPU_DESCRIPTOR_HANDLE old_start_cpu_handle = ZI;
@ -1877,7 +1877,7 @@ GPU_D12_CommandBuffer *GPU_D12__PushCommandBuffer(GPU_D12_CommandList *cl, u64 d
/* Determine size */
u64 size = MaxU64(DX12_COMMAND_BUFFER_MIN_SIZE, AlignU64Pow2(data_len));
/* Allocate buffer */
/* Acquire buffer */
GPU_D12_CommandBufferGroup *cb_group = 0;
GPU_D12_CommandBuffer *cb = 0;
GPU_D12_Resource *r = 0;
@ -1931,7 +1931,7 @@ GPU_D12_CommandBuffer *GPU_D12__PushCommandBuffer(GPU_D12_CommandList *cl, u64 d
}
else
{
/* Allocate new */
/* Acquire new */
cb = PushStructNoZero(g->command_buffers_arena, GPU_D12_CommandBuffer);
}
Unlock(&lock);
@ -1963,8 +1963,8 @@ GPU_D12_CommandBuffer *GPU_D12__PushCommandBuffer(GPU_D12_CommandList *cl, u64 d
desc.SampleDesc.Quality = 0;
D3D12_RESOURCE_STATES initial_state = D3D12_RESOURCE_STATE_GENERIC_READ;
r = GPU_D12_AllocResource(heap_props, heap_flags, desc, initial_state);
r->srv_descriptor = GPU_D12_AllocDescriptor(g->cbv_srv_uav_heap);
r = GPU_D12_AcquireResource(heap_props, heap_flags, desc, initial_state);
r->srv_descriptor = GPU_D12_AcquireDescriptor(g->cbv_srv_uav_heap);
}
cb->resource = r;
@ -2024,7 +2024,7 @@ JobDef(GPU_D12_WaitOnFenceJob, sig, UNUSED id)
* Texture
* ========================== */
GPU_Resource *GPU_AllocTexture(GPU_TextureFormat format, u32 flags, Vec2I32 size, void *initial_data)
GPU_Resource *GPU_AcquireTexture(GPU_TextureFormat format, u32 flags, Vec2I32 size, void *initial_data)
{
__prof;
GPU_D12_SharedState *g = &GPU_D12_shared_state;
@ -2069,15 +2069,15 @@ GPU_Resource *GPU_AllocTexture(GPU_TextureFormat format, u32 flags, Vec2I32 size
D3D12_RESOURCE_STATES initial_state = D3D12_RESOURCE_STATE_COPY_DEST;
GPU_D12_Resource *r = GPU_D12_AllocResource(heap_props, heap_flags, desc, initial_state);
GPU_D12_Resource *r = GPU_D12_AcquireResource(heap_props, heap_flags, desc, initial_state);
r->texture_size = size;
r->srv_descriptor = GPU_D12_AllocDescriptor(g->cbv_srv_uav_heap);
r->srv_descriptor = GPU_D12_AcquireDescriptor(g->cbv_srv_uav_heap);
ID3D12Device_CreateShaderResourceView(g->device, r->resource, 0, r->srv_descriptor->handle);
if (flags & GP_TEXTURE_FLAG_TARGETABLE)
{
desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
r->uav_descriptor = GPU_D12_AllocDescriptor(g->cbv_srv_uav_heap);
r->rtv_descriptor = GPU_D12_AllocDescriptor(g->rtv_heap);
r->uav_descriptor = GPU_D12_AcquireDescriptor(g->cbv_srv_uav_heap);
r->rtv_descriptor = GPU_D12_AcquireDescriptor(g->rtv_heap);
ID3D12Device_CreateUnorderedAccessView(g->device, r->resource, 0, 0, r->uav_descriptor->handle);
ID3D12Device_CreateRenderTargetView(g->device, r->resource, 0, r->rtv_descriptor->handle);
}
@ -2145,7 +2145,7 @@ JobDef(GPU_D12_UploadJob, sig, UNUSED id)
upload_desc.SampleDesc.Quality = 0;
D3D12_RESOURCE_STATES upload_initial_state = D3D12_RESOURCE_STATE_GENERIC_READ;
upload = GPU_D12_AllocResource(upload_heap_props, upload_heap_flags, upload_desc, upload_initial_state);
upload = GPU_D12_AcquireResource(upload_heap_props, upload_heap_flags, upload_desc, upload_initial_state);
}
GPU_D12_CommandQueue *cq = g->command_queues[DX12_QUEUE_COPY_BACKGROUND];
@ -2302,7 +2302,7 @@ D3D12_INDEX_BUFFER_VIEW GPU_D12_IbvFromCommandBuffer(GPU_D12_CommandBuffer *cb,
return ibv;
}
GPU_D12_Resource *GPU_D12_AllocGbuff(DXGI_FORMAT format, Vec2I32 size, D3D12_RESOURCE_STATES initial_state)
GPU_D12_Resource *GPU_D12_AcquireGbuff(DXGI_FORMAT format, Vec2I32 size, D3D12_RESOURCE_STATES initial_state)
{
__prof;
GPU_D12_SharedState *g = &GPU_D12_shared_state;
@ -2325,10 +2325,10 @@ GPU_D12_Resource *GPU_D12_AllocGbuff(DXGI_FORMAT format, Vec2I32 size, D3D12_RES
desc.SampleDesc.Quality = 0;
desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
GPU_D12_Resource *r = GPU_D12_AllocResource(heap_props, heap_flags, desc, initial_state);
r->srv_descriptor = GPU_D12_AllocDescriptor(g->cbv_srv_uav_heap);
r->uav_descriptor = GPU_D12_AllocDescriptor(g->cbv_srv_uav_heap);
r->rtv_descriptor = GPU_D12_AllocDescriptor(g->rtv_heap);
GPU_D12_Resource *r = GPU_D12_AcquireResource(heap_props, heap_flags, desc, initial_state);
r->srv_descriptor = GPU_D12_AcquireDescriptor(g->cbv_srv_uav_heap);
r->uav_descriptor = GPU_D12_AcquireDescriptor(g->cbv_srv_uav_heap);
r->rtv_descriptor = GPU_D12_AcquireDescriptor(g->rtv_heap);
ID3D12Device_CreateShaderResourceView(g->device, r->resource, 0, r->srv_descriptor->handle);
ID3D12Device_CreateUnorderedAccessView(g->device, r->resource, 0, 0, r->uav_descriptor->handle);
ID3D12Device_CreateRenderTargetView(g->device, r->resource, 0, r->rtv_descriptor->handle);
@ -2349,21 +2349,21 @@ D3D12_GPU_DESCRIPTOR_HANDLE GPU_D12_GpuHandleFromDescriptor(GPU_D12_Descriptor *
* Render sig
* ========================== */
GPU_D12_RenderSig *GPU_D12_AllocRenderSig(void)
GPU_D12_RenderSig *GPU_D12_AcquireRenderSig(void)
{
__prof;
GPU_D12_RenderSig *sig = 0;
{
Arena *arena = AllocArena(Mebi(64));
Arena *arena = AcquireArena(Mebi(64));
sig = PushStruct(arena, GPU_D12_RenderSig);
sig->arena = arena;
}
sig->material_instance_descs_arena = AllocArena(Gibi(1));
sig->material_grid_descs_arena = AllocArena(Gibi(1));
sig->ui_rect_instance_descs_arena = AllocArena(Gibi(1));
sig->ui_shape_verts_arena = AllocArena(Gibi(1));
sig->ui_shape_indices_arena = AllocArena(Gibi(1));
sig->material_instance_descs_arena = AcquireArena(Gibi(1));
sig->material_grid_descs_arena = AcquireArena(Gibi(1));
sig->ui_rect_instance_descs_arena = AcquireArena(Gibi(1));
sig->ui_shape_verts_arena = AcquireArena(Gibi(1));
sig->ui_shape_indices_arena = AcquireArena(Gibi(1));
return sig;
}
@ -2389,10 +2389,10 @@ void GPU_D12_ResetRenderSig(GPU_D12_RenderSig *sig)
ResetArena(sig->material_grid_descs_arena);
}
GPU_RenderSig *GPU_AllocRenderSig(void)
GPU_RenderSig *GPU_AcquireRenderSig(void)
{
__prof;
GPU_D12_RenderSig *sig = GPU_D12_AllocRenderSig();
GPU_D12_RenderSig *sig = GPU_D12_AcquireRenderSig();
return (GPU_RenderSig *)sig;
}
@ -2488,7 +2488,7 @@ GPU_Resource *GPU_RunRender(GPU_RenderSig *gp_render_sig, GPU_RenderParams param
Rect render_viewport = RectFromVec2(VEC2(0, 0), VEC2(render_size.x, render_size.y));
/* Allocate render buffers */
/* Acquire render buffers */
if (rsig->shade_target && !EqVec2I32(render_size, rsig->shade_target->texture_size))
{
__profn("Release sig resources");
@ -2502,16 +2502,16 @@ GPU_Resource *GPU_RunRender(GPU_RenderSig *gp_render_sig, GPU_RenderParams param
}
if (!rsig->shade_target)
{
__profn("Allocate sig resources");
rsig->albedo = GPU_D12_AllocGbuff(DXGI_FORMAT_R8G8B8A8_UNORM, render_size, D3D12_RESOURCE_STATE_RENDER_TARGET);
rsig->emittance = GPU_D12_AllocGbuff(DXGI_FORMAT_R16G16B16A16_FLOAT, render_size, D3D12_RESOURCE_STATE_RENDER_TARGET);
rsig->emittance_flood_read = GPU_D12_AllocGbuff(DXGI_FORMAT_R16G16_UINT, render_size, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
rsig->emittance_flood_target = GPU_D12_AllocGbuff(DXGI_FORMAT_R16G16_UINT, render_size, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
rsig->shade_read = GPU_D12_AllocGbuff(DXGI_FORMAT_R16G16B16A16_FLOAT, render_size, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
rsig->shade_target = GPU_D12_AllocGbuff(DXGI_FORMAT_R16G16B16A16_FLOAT, render_size, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
__profn("Acquire sig resources");
rsig->albedo = GPU_D12_AcquireGbuff(DXGI_FORMAT_R8G8B8A8_UNORM, render_size, D3D12_RESOURCE_STATE_RENDER_TARGET);
rsig->emittance = GPU_D12_AcquireGbuff(DXGI_FORMAT_R16G16B16A16_FLOAT, render_size, D3D12_RESOURCE_STATE_RENDER_TARGET);
rsig->emittance_flood_read = GPU_D12_AcquireGbuff(DXGI_FORMAT_R16G16_UINT, render_size, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
rsig->emittance_flood_target = GPU_D12_AcquireGbuff(DXGI_FORMAT_R16G16_UINT, render_size, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
rsig->shade_read = GPU_D12_AcquireGbuff(DXGI_FORMAT_R16G16B16A16_FLOAT, render_size, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
rsig->shade_target = GPU_D12_AcquireGbuff(DXGI_FORMAT_R16G16B16A16_FLOAT, render_size, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
}
/* Allocate ui buffers */
/* Acquire ui buffers */
if (rsig->ui_target && !EqVec2I32(ui_size, rsig->ui_target->texture_size))
{
GPU_D12_ReleaseDataFenced(rsig->ui_target, GPU_D12_FencedReleaseKind_Resource);
@ -2519,7 +2519,7 @@ GPU_Resource *GPU_RunRender(GPU_RenderSig *gp_render_sig, GPU_RenderParams param
}
if (!rsig->ui_target)
{
rsig->ui_target = GPU_D12_AllocGbuff(DXGI_FORMAT_R8G8B8A8_UNORM, ui_size, D3D12_RESOURCE_STATE_RENDER_TARGET);
rsig->ui_target = GPU_D12_AcquireGbuff(DXGI_FORMAT_R8G8B8A8_UNORM, ui_size, D3D12_RESOURCE_STATE_RENDER_TARGET);
}
GPU_D12_PipelineScope *pipeline_scope = GPU_D12_BeginPipelineScope();
@ -3005,13 +3005,13 @@ void GPU_D12_InitSwapchainResources(GPU_D12_Swapchain *swapchain)
ZeroStruct(sb);
sb->swapchain = swapchain;
sb->resource = resource;
sb->rtv_descriptor = GPU_D12_AllocDescriptor(g->rtv_heap);
sb->rtv_descriptor = GPU_D12_AcquireDescriptor(g->rtv_heap);
sb->state = D3D12_RESOURCE_STATE_COMMON;
ID3D12Device_CreateRenderTargetView(g->device, sb->resource, 0, sb->rtv_descriptor->handle);
}
}
GPU_Swapchain *GPU_AllocSwapchain(P_Window *window, Vec2I32 resolution)
GPU_Swapchain *GPU_AcquireSwapchain(P_Window *window, Vec2I32 resolution)
{
GPU_D12_SharedState *g = &GPU_D12_shared_state;
HRESULT hr = 0;

18
src/gpu/gpu_dx12.h
View File

@ -463,7 +463,7 @@ JobDecl(GPU_D12_CompileShaderJob, { Arena *arena; GPU_D12_ShaderDesc *descs; GPU
* Pipeline
* ========================== */
JobDecl(GPU_D12_AllocPipelineJob, { GPU_D12_PipelineDesc *descs_in; GPU_D12_Pipeline **pipelines_out; });
JobDecl(GPU_D12_AcquirePipelineJob, { GPU_D12_PipelineDesc *descs_in; GPU_D12_Pipeline **pipelines_out; });
void GPU_D12_ReleasePipelineNow(GPU_D12_Pipeline *pipeline);
@ -486,7 +486,7 @@ W_CallbackFuncDef(GPU_D12_WatchPipelineCallback, name);
* Descriptor
* ========================== */
GPU_D12_Descriptor *GPU_D12_AllocDescriptor(GPU_D12_CpuDescriptorHeap *dh);
GPU_D12_Descriptor *GPU_D12_AcquireDescriptor(GPU_D12_CpuDescriptorHeap *dh);
void GPU_D12_ReleaseDescriptor(GPU_D12_Descriptor *descriptor);
@ -494,7 +494,7 @@ void GPU_D12_ReleaseDescriptor(GPU_D12_Descriptor *descriptor);
* CPU descriptor heap
* ========================== */
GPU_D12_CpuDescriptorHeap *GPU_D12_AllocCpuDescriptorHeap(enum D3D12_DESCRIPTOR_HEAP_TYPE type);
GPU_D12_CpuDescriptorHeap *GPU_D12_AcquireCpuDescriptorHeap(enum D3D12_DESCRIPTOR_HEAP_TYPE type);
/* ========================== *
* Fenced release
@ -506,7 +506,7 @@ void GPU_D12_ReleaseDataFenced(void *data, GPU_D12_FencedReleaseKind kind);
* Resource
* ========================== */
GPU_D12_Resource *GPU_D12_AllocResource(D3D12_HEAP_PROPERTIES heap_props, D3D12_HEAP_FLAGS heap_flags, D3D12_RESOURCE_DESC desc, D3D12_RESOURCE_STATES initial_state);
GPU_D12_Resource *GPU_D12_AcquireResource(D3D12_HEAP_PROPERTIES heap_props, D3D12_HEAP_FLAGS heap_flags, D3D12_RESOURCE_DESC desc, D3D12_RESOURCE_STATES initial_state);
void GPU_D12_ReleaseResourceNow(GPU_D12_Resource *t);
@ -522,7 +522,7 @@ void GPU_D12_InsertBarrier(ID3D12GraphicsCommandList *cl, i32 num_descs, GPU_D12
* Command queue
* ========================== */
JobDecl(GPU_D12_AllocCommandQueueJob, { GPU_D12_CommandQueueDesc *descs_in; GPU_D12_CommandQueue **cqs_out; });
JobDecl(GPU_D12_AcquireCommandQueueJob, { GPU_D12_CommandQueueDesc *descs_in; GPU_D12_CommandQueue **cqs_out; });
void GPU_D12_ReleaseCommandQueue(GPU_D12_CommandQueue *cq);
@ -530,7 +530,7 @@ void GPU_D12_ReleaseCommandQueue(GPU_D12_CommandQueue *cq);
* Command list
* ========================== */
GPU_D12_CommandListPool *GPU_D12_AllocCommandListPool(GPU_D12_CommandQueue *cq);
GPU_D12_CommandListPool *GPU_D12_AcquireCommandListPool(GPU_D12_CommandQueue *cq);
GPU_D12_CommandList *GPU_D12_BeginCommandList(GPU_D12_CommandListPool *pool);
@ -581,7 +581,7 @@ D3D12_VERTEX_BUFFER_VIEW GPU_D12_VbvFromCommandBuffer(GPU_D12_CommandBuffer *cb,
D3D12_INDEX_BUFFER_VIEW GPU_D12_IbvFromCommandBuffer(GPU_D12_CommandBuffer *cb, DXGI_FORMAT format);
GPU_D12_Resource *GPU_D12_AllocGbuff(DXGI_FORMAT format, Vec2I32 size, D3D12_RESOURCE_STATES initial_state);
GPU_D12_Resource *GPU_D12_AcquireGbuff(DXGI_FORMAT format, Vec2I32 size, D3D12_RESOURCE_STATES initial_state);
D3D12_GPU_DESCRIPTOR_HANDLE GPU_D12_GpuHandleFromDescriptor(GPU_D12_Descriptor *descriptor, GPU_D12_CommandDescriptorHeap *cdh);
@ -589,11 +589,11 @@ D3D12_GPU_DESCRIPTOR_HANDLE GPU_D12_GpuHandleFromDescriptor(GPU_D12_Descriptor *
* Render sig
* ========================== */
GPU_D12_RenderSig *GPU_D12_AllocRenderSig(void);
GPU_D12_RenderSig *GPU_D12_AcquireRenderSig(void);
void GPU_D12_ResetRenderSig(GPU_D12_RenderSig *sig);
GPU_RenderSig *GPU_AllocRenderSig(void);
GPU_RenderSig *GPU_AcquireRenderSig(void);
/* ========================== *
* Swapchain

8
src/mixer/mixer_core.c
View File

@ -23,7 +23,7 @@ void MIX_StartupCore(void)
{
__prof;
MIX_SharedState *g = &M_shared_state;
g->track_arena = AllocArena(Gibi(64));
g->track_arena = AcquireArena(Gibi(64));
g->listener_pos = VEC2(0, 0);
g->listener_dir = VEC2(0, -1);
}
@ -52,7 +52,7 @@ MIX_Track *MIX_TrackFromHandle(MIX_Handle handle)
}
}
MIX_Track *MIX_AllocTrackLocked(Lock *lock, SND_Sound *sound)
MIX_Track *MIX_AcquireTrackLocked(Lock *lock, SND_Sound *sound)
{
MIX_SharedState *g = &M_shared_state;
AssertLockedE(lock, &g->mutex);
@ -73,7 +73,7 @@ MIX_Track *MIX_AllocTrackLocked(Lock *lock, SND_Sound *sound)
}
else
{
/* Allocate new */
/* Acquire new */
track = PushStruct(g->track_arena, MIX_Track);
track->gen = 1;
}
@ -156,7 +156,7 @@ MIX_Handle MIX_PlaySoundEx(SND_Sound *sound, MIX_TrackDesc desc)
{
Lock lock = LockE(&g->mutex);
{
track = MIX_AllocTrackLocked(&lock, sound);
track = MIX_AcquireTrackLocked(&lock, sound);
track->desc = desc;
}
Unlock(&lock);

2
src/mixer/mixer_core.h
View File

@ -105,7 +105,7 @@ void MIX_StartupCore(void);
MIX_Handle MIX_HandleFromTrack(MIX_Track *track);
MIX_Track *MIX_TrackFromHandle(MIX_Handle handle);
MIX_Track *MIX_AllocTrackLocked(Lock *lock, SND_Sound *sound);
MIX_Track *MIX_AcquireTrackLocked(Lock *lock, SND_Sound *sound);
void MIX_ReleaseTrackLocked(Lock *lock, MIX_Track *track);
////////////////////////////////

30
src/net/net_core.c
View File

@ -15,19 +15,19 @@
////////////////////////////////
//~ Host
N_Host *N_AllocHost(u16 listen_port)
N_Host *N_AcquireHost(u16 listen_port)
{
Arena *arena = AllocArena(Gibi(64));
Arena *arena = AcquireArena(Gibi(64));
N_Host *host = PushStruct(arena, N_Host);
host->arena = arena;
host->cmd_arena = AllocArena(Gibi(64));
host->channel_arena = AllocArena(Gibi(64));
host->cmd_arena = AcquireArena(Gibi(64));
host->channel_arena = AcquireArena(Gibi(64));
host->rcv_buffer_read = PushStruct(host->arena, N_RcvBuffer);
host->rcv_buffer_write = PushStruct(host->arena, N_RcvBuffer);
host->rcv_buffer_read->arena = AllocArena(Gibi(64));
host->rcv_buffer_write->arena = AllocArena(Gibi(64));
host->buddy = AllocBuddyCtx(Gibi(64));
host->rcv_buffer_read->arena = AcquireArena(Gibi(64));
host->rcv_buffer_write->arena = AcquireArena(Gibi(64));
host->buddy = AcquireBuddyCtx(Gibi(64));
host->channels = PushDry(host->channel_arena, N_Channel);
@ -37,7 +37,7 @@ N_Host *N_AllocHost(u16 listen_port)
host->num_msg_assembler_lookup_bins = N_NumMsgAssemblerLookupBins;
host->msg_assembler_lookup_bins = PushStructs(host->arena, N_MsgAssemblerLookupBin, host->num_msg_assembler_lookup_bins);
host->sock = P_AllocSock(listen_port, Mebi(2), Mebi(2));
host->sock = P_AcquireSock(listen_port, Mebi(2), Mebi(2));
return host;
}
@ -128,7 +128,7 @@ N_ChannelList N_ChannelsFromId(Arena *arena, N_Host *host, N_ChannelId channel_i
return result;
}
N_Channel *N_AllocChannel(N_Host *host, P_Address address)
N_Channel *N_AcquireChannel(N_Host *host, P_Address address)
{
N_ChannelId id = ZI;
N_Channel *channel;
@ -248,7 +248,7 @@ N_MsgAssembler *N_MsgAssemblerFromMsg(N_Host *host, N_ChannelId channel_id, u64
return 0;
}
N_MsgAssembler *N_AllocMsgAssembler(N_Channel *channel, u64 msg_id, u64 chunk_count, u64 now_ns, b32 is_reliable)
N_MsgAssembler *N_AcquireMsgAssembler(N_Channel *channel, u64 msg_id, u64 chunk_count, u64 now_ns, b32 is_reliable)
{
N_Host *host = channel->host;
N_MsgAssembler *ma;
@ -275,10 +275,10 @@ N_MsgAssembler *N_AllocMsgAssembler(N_Channel *channel, u64 msg_id, u64 chunk_co
}
u64 chunk_data_size = chunk_count * N_MaxPacketChunkLen;
/* Allocate msg data using buddy allocator since the assembler has
/* Acquire msg data using buddy allocator since the assembler has
* arbitrary lifetime and data needs to stay contiguous for random
* access as packets are received */
ma->buddy_block = AllocBuddyBlock(host->buddy, chunk_bitmap_size + chunk_data_size);
ma->buddy_block = AcquireBuddyBlock(host->buddy, chunk_bitmap_size + chunk_data_size);
ma->chunk_bitmap = ma->buddy_block->memory;
ZeroBytes(ma->chunk_bitmap, chunk_bitmap_size);
ma->chunk_data = ma->chunk_bitmap + chunk_bitmap_size;
@ -504,7 +504,7 @@ void N_Connect(N_Host *host, P_Address connect_address)
N_Channel *channel = N_ChannelFromAddress(host, connect_address);
if (!channel->valid)
{
channel = N_AllocChannel(host, connect_address);
channel = N_AcquireChannel(host, connect_address);
}
}
@ -632,7 +632,7 @@ N_EventList N_BeginUpdate(Arena *arena, N_Host *host)
{
P_LogInfoF("Host received conection attempt from %F", FmtString(P_StringFromAddress(scratch.arena, address)));
/* TODO: Verify that some per-host uuid isn't present in a rolling window to prevent reconnects right after a disconnect? */
channel = N_AllocChannel(host, address);
channel = N_AcquireChannel(host, address);
}
N_Cmd *cmd = N_PushCmd(host);
cmd->kind = N_CmdKind_ConnectSuccess;
@ -702,7 +702,7 @@ N_EventList N_BeginUpdate(Arena *arena, N_Host *host)
N_MsgAssembler *ma = N_MsgAssemblerFromMsg(host, channel->id, msg_id);
if (!ma)
{
ma = N_AllocMsgAssembler(channel, msg_id, chunk_count, now_ns, is_reliable);
ma = N_AcquireMsgAssembler(channel, msg_id, chunk_count, now_ns, is_reliable);
}
if (chunk_count == ma->num_chunks_total && chunk_id < chunk_count)

14
src/net/net_core.h
View File

@ -236,13 +236,13 @@ Struct(N_Host)
N_Channel *first_free_channel;
u64 num_channels_reserved;
N_SndPacket *first_free_packet; /* Allocated in `arena` */
N_MsgAssembler *first_free_msg_assembler; /* Allocated in `arena` */
N_SndPacket *first_free_packet; /* Acquired in `arena` */
N_MsgAssembler *first_free_msg_assembler; /* Acquired in `arena` */
N_ChannelLookupBin *channel_lookup_bins; /* Allocated in `arena` */
N_ChannelLookupBin *channel_lookup_bins; /* Acquired in `arena` */
u64 num_channel_lookup_bins;
N_MsgAssemblerLookupBin *msg_assembler_lookup_bins; /* Allocated in `arena` */
N_MsgAssemblerLookupBin *msg_assembler_lookup_bins; /* Acquired in `arena` */
u64 num_msg_assembler_lookup_bins;
/* Double buffer for incoming data */
@ -262,7 +262,7 @@ Readonly Global N_Channel N_nil_channel = { .valid = 0 };
////////////////////////////////
//~ Host initialization
N_Host *N_AllocHost(u16 listen_port);
N_Host *N_AcquireHost(u16 listen_port);
void N_ReleaseHost(N_Host *host);
////////////////////////////////
@ -278,7 +278,7 @@ u64 N_HashFromAddress(P_Address address);
N_Channel *N_ChannelFromAddress(N_Host *host, P_Address address);
N_Channel *N_ChannelFromId(N_Host *host, N_ChannelId channel_id);
N_ChannelList N_ChannelsFromId(Arena *arena, N_Host *host, N_ChannelId channel_id);
N_Channel *N_AllocChannel(N_Host *host, P_Address address);
N_Channel *N_AcquireChannel(N_Host *host, P_Address address);
void N_ReleaseChannel(N_Channel *channel);
////////////////////////////////
@ -286,7 +286,7 @@ void N_ReleaseChannel(N_Channel *channel);
u64 N_HashFromMsg(N_ChannelId channel_id, u64 msg_id);
N_MsgAssembler *N_MsgAssemblerFromMsg(N_Host *host, N_ChannelId channel_id, u64 msg_id);
N_MsgAssembler *N_AllocMsgAssembler(N_Channel *channel, u64 msg_id, u64 chunk_count, u64 now_ns, b32 is_reliable);
N_MsgAssembler *N_AcquireMsgAssembler(N_Channel *channel, u64 msg_id, u64 chunk_count, u64 now_ns, b32 is_reliable);
void N_ReleaseMessageAssembler(N_MsgAssembler *ma);
void N_TouchMessageAssembler(N_MsgAssembler *ma, i64 now_ns);
b32 N_IsChunkFilled(N_MsgAssembler *ma, u64 chunk_id);

6
src/platform/platform_core.h
View File

@ -348,7 +348,7 @@ String P_GetFileMapData(P_FileMap map);
//~ @hookdecl Watch operations
// A watch object allows the caller to watch for changes in a directory
P_Watch *P_AllocWatch(String path);
P_Watch *P_AcquireWatch(String path);
void P_ReleaseWatch(P_Watch *dw);
P_WatchInfoList P_ReadWatchWait(Arena *arena, P_Watch *dw);
void P_WakeWatch(P_Watch *dw);
@ -356,7 +356,7 @@ void P_WakeWatch(P_Watch *dw);
////////////////////////////////
//~ @hookdecl Window operations
P_Window *P_AllocWindow(void);
P_Window *P_AcquireWindow(void);
void P_ReleaseWindow(P_Window *window);
//- Events
@ -390,7 +390,7 @@ b32 P_AddressIsEqual(P_Address a, P_Address b);
////////////////////////////////
//~ @hookdecl Sock operations
P_Sock *P_AllocSock(u16 listen_port, u64 sndbuf_size, u64 rcvbuf_size);
P_Sock *P_AcquireSock(u16 listen_port, u64 sndbuf_size, u64 rcvbuf_size);
void P_ReleaseSock(P_Sock *sock);
P_SockReadResult P_ReadSock(Arena *arena, P_Sock *sock);
void P_WriteSock(P_Sock *sock, P_Address address, String data);

2
src/platform/platform_log.c
View File

@ -10,7 +10,7 @@ void P_StartupLog(String logfile_path)
{
__prof;
P_SharedLogState *ctx = &P_shared_log_state;
ctx->callbacks_arena = AllocArena(Mebi(8));
ctx->callbacks_arena = AcquireArena(Mebi(8));
if (logfile_path.len > 0)
{
/* Create / wipe log file */

22
src/platform/platform_win32.c
View File

@ -105,14 +105,14 @@ void P_StartupCore(void)
}
//- Init watches pool
g->watches_arena = AllocArena(Gibi(64));
g->watches_arena = AcquireArena(Gibi(64));
//- Init windows pool
g->windows_arena = AllocArena(Gibi(64));
g->windows_arena = AcquireArena(Gibi(64));
//- Init winsock
WSAStartup(MAKEWORD(2, 2), &g->wsa_data);
g->socks_arena = AllocArena(Gibi(64));
g->socks_arena = AcquireArena(Gibi(64));
}
////////////////////////////////
@ -168,7 +168,7 @@ String P_W32_StringFromWin32Path(Arena *arena, wchar_t *src)
////////////////////////////////
//~ Win32 window
P_W32_Window *P_W32_AllocWindow(void)
P_W32_Window *P_W32_AcquireWindow(void)
{
P_W32_SharedCtx *g = &P_W32_shared_ctx;
P_W32_Window *window = 0;
@ -187,15 +187,15 @@ P_W32_Window *P_W32_AllocWindow(void)
}
ZeroStruct(window);
window->event_arenas[0] = AllocArena(Gibi(64));
window->event_arenas[1] = AllocArena(Gibi(64));
window->event_arenas[0] = AcquireArena(Gibi(64));
window->event_arenas[1] = AcquireArena(Gibi(64));
/* Start window event thread */
/* NOTE: This thread must finish building for the window to actually be
* created and receive a HWND, because on Windows a the event proc must run on
* the same thread that created the window. */
AddCounter(&window->ready_fence, 1);
window->window_thread = W32_AllocThread(&P_W32_WindowThreadEntryFunc, window, Lit("Window thread"), PROF_THREAD_GROUP_WINDOW);
window->window_thread = W32_AcquireThread(&P_W32_WindowThreadEntryFunc, window, Lit("Window thread"), PROF_THREAD_GROUP_WINDOW);
WaitOnCounter(&window->ready_fence);
return window;
@ -1251,7 +1251,7 @@ String P_GetFileMapData(P_FileMap map)
////////////////////////////////
//~ @hookdef Watch hooks
P_Watch *P_AllocWatch(String dir_path)
P_Watch *P_AcquireWatch(String dir_path)
{
TempArena scratch = BeginScratchNoConflict();
struct P_W32_SharedCtx *g = &P_W32_shared_ctx;
@ -1440,10 +1440,10 @@ void P_WakeWatch(P_Watch *dw)
////////////////////////////////
//~ @hookdef Window hooks
P_Window *P_AllocWindow(void)
P_Window *P_AcquireWindow(void)
{
__prof;
return (P_Window *)P_W32_AllocWindow();
return (P_Window *)P_W32_AcquireWindow();
}
void P_ReleaseWindow(P_Window *p_window)
@ -1786,7 +1786,7 @@ b32 P_AddressIsEqual(P_Address a, P_Address b)
////////////////////////////////
//~ @hookdef Sock hooks
P_Sock *P_AllocSock(u16 listen_port, u64 sndbuf_size, u64 rcvbuf_size)
P_Sock *P_AcquireSock(u16 listen_port, u64 sndbuf_size, u64 rcvbuf_size)
{
P_W32_SharedCtx *g = &P_W32_shared_ctx;
P_W32_Sock *ws = 0;

2
src/platform/platform_win32.h
View File

@ -146,7 +146,7 @@ String P_W32_StringFromWin32Path(Arena *arena, wchar_t *src);
////////////////////////////////
//~ Window operations
P_W32_Window *P_W32_AllocWindow(void);
P_W32_Window *P_W32_AcquireWindow(void);
void P_W32_ReleaseWindow(P_W32_Window *window);
HWND P_W32_InitWindow(P_W32_Window *window);

82
src/pp/pp_core.c
View File

@ -10,7 +10,7 @@ void StartupUser(void)
SetGstat(GSTAT_DEBUG_STEPS, U64Max);
g->arena = AllocArena(Gibi(64));
g->arena = AcquireArena(Gibi(64));
g->real_time_ns = TimeNs();
/* TODO: Remove this */
@ -21,26 +21,26 @@ void StartupUser(void)
g->average_local_to_user_snapshot_publish_dt_ns = NsFromSeconds(1) / SIM_TICKS_PER_SECOND;
/* User blend clients */
g->user_client_store = sim_client_store_alloc();
g->user_unblended_client = sim_client_alloc(g->user_client_store);
g->user_blended_client = sim_client_alloc(g->user_client_store);
g->user_client_store = sim_client_store_acquire();
g->user_unblended_client = sim_client_acquire(g->user_client_store);
g->user_blended_client = sim_client_acquire(g->user_client_store);
g->ss_blended = sim_snapshot_nil();
/* Local to user client */
g->local_to_user_client_store = sim_client_store_alloc();
g->local_to_user_client = sim_client_alloc(g->local_to_user_client_store);
g->local_to_user_client_store = sim_client_store_acquire();
g->local_to_user_client = sim_client_acquire(g->local_to_user_client_store);
/* GPU handles */
g->world_to_ui_xf = XformIdentity;
g->world_to_render_xf = XformIdentity;
g->render_sig = GPU_AllocRenderSig();
g->render_sig = GPU_AcquireRenderSig();
g->console_logs_arena = AllocArena(Gibi(64));
g->console_logs_arena = AcquireArena(Gibi(64));
//P_RegisterLogCallback(ConsoleLogCallback, P_LogLevel_Success);
P_RegisterLogCallback(ConsoleLogCallback, P_LogLevel_Debug);
g->window = P_AllocWindow();
g->swapchain = GPU_AllocSwapchain(g->window, VEC2I32(100, 100));
g->window = P_AcquireWindow();
g->swapchain = GPU_AcquireSwapchain(g->window, VEC2I32(100, 100));
P_ShowWindow(g->window);
/* Start jobs */
@ -419,7 +419,7 @@ void UpdateUser(P_Window *window)
if (last_tick > old_last_tick)
{
Snapshot *src = sim_snapshot_from_tick(g->local_to_user_client, last_tick);
sim_snapshot_alloc(g->user_unblended_client, src, src->tick);
sim_snapshot_acquire(g->user_unblended_client, src, src->tick);
g->last_local_to_user_snapshot_published_at_ns = g->local_to_user_client_publish_time_ns;
g->average_local_to_user_snapshot_publish_dt_ns -= g->average_local_to_user_snapshot_publish_dt_ns / 50;
g->average_local_to_user_snapshot_publish_dt_ns += g->local_to_user_client_publish_dt_ns / 50;
@ -494,15 +494,15 @@ void UpdateUser(P_Window *window)
if (left_snapshot->valid && right_snapshot->valid)
{
f64 blend = (f64)(g->render_time_ns - left_snapshot->sim_time_ns) / (f64)(right_snapshot->sim_time_ns - left_snapshot->sim_time_ns);
g->ss_blended = sim_snapshot_alloc_from_lerp(g->user_blended_client, left_snapshot, right_snapshot, blend);
g->ss_blended = sim_snapshot_acquire_from_lerp(g->user_blended_client, left_snapshot, right_snapshot, blend);
}
else if (left_snapshot->valid)
{
g->ss_blended = sim_snapshot_alloc(g->user_blended_client, left_snapshot, left_snapshot->tick);
g->ss_blended = sim_snapshot_acquire(g->user_blended_client, left_snapshot, left_snapshot->tick);
}
else if (right_snapshot->valid)
{
g->ss_blended = sim_snapshot_alloc(g->user_blended_client, right_snapshot, right_snapshot->tick);
g->ss_blended = sim_snapshot_acquire(g->user_blended_client, right_snapshot, right_snapshot->tick);
}
/* Release unneeded unblended snapshots */
@ -516,7 +516,7 @@ void UpdateUser(P_Window *window)
/* Interp disabled, just copy latest snapshot */
g->render_time_target_ns = newest_snapshot->sim_time_ns;
g->render_time_ns = newest_snapshot->sim_time_ns;
g->ss_blended = sim_snapshot_alloc(g->user_blended_client, newest_snapshot, newest_snapshot->tick);
g->ss_blended = sim_snapshot_acquire(g->user_blended_client, newest_snapshot, newest_snapshot->tick);
/* Release unneeded unblended snapshots */
if (newest_snapshot->tick > 0)
@ -930,9 +930,9 @@ void UpdateUser(P_Window *window)
}
#if 0
//- Alloc / release tile cache entries
//- Acquire / release tile cache entries
/* Alloc entries from new sim chunks */
/* Acquire entries from new sim chunks */
for (u64 ent_index = 0; ent_index < g->ss_blended->num_ents_reserved; ++ent_index)
{
@ -942,7 +942,7 @@ void UpdateUser(P_Window *window)
struct user_tile_cache_entry *entry = user_tile_cache_entry_from_chunk_pos(chunk_ent->tile_chunk_pos);
if (!entry->valid)
{
entry = user_tile_cache_entry_alloc(chunk_ent->tile_chunk_pos);
entry = user_tile_cache_entry_acquire(chunk_ent->tile_chunk_pos);
}
}
}
@ -2083,13 +2083,13 @@ void GenerateuserInputCmds(Client *user_input_client, u64 tick)
{
SharedUserState *g = &shared_user_state;
Snapshot *prev_user_input_ss = sim_snapshot_from_tick(user_input_client, user_input_client->last_tick);
Snapshot *user_input_ss = sim_snapshot_alloc(user_input_client, prev_user_input_ss, tick);
Snapshot *user_input_ss = sim_snapshot_acquire(user_input_client, prev_user_input_ss, tick);
Entity *user_input_root = sim_ent_from_id(user_input_ss, SIM_ENT_ROOT_ID);
/* Find / create local control cmd ent */
Entity *control_cmd = sim_ent_find_first_match_one(user_input_ss, SEPROP_CMD);
if (!control_cmd->valid)
{
control_cmd = sim_ent_alloc_sync_src(user_input_root);
control_cmd = sim_ent_acquire_sync_src(user_input_root);
control_cmd->cmd_kind = SIM_CMD_KIND_CONTROL;
control_cmd->predictor = user_input_client->player_id;
sim_ent_enable_prop(control_cmd, SEPROP_CMD);
@ -2106,7 +2106,7 @@ void GenerateuserInputCmds(Client *user_input_client, u64 tick)
/* Create chat cmd */
if (g->user_sim_cmd_chat.len > 0)
{
Entity *chat_cmd = sim_ent_alloc_sync_src(user_input_root);
Entity *chat_cmd = sim_ent_acquire_sync_src(user_input_root);
chat_cmd->cmd_kind = SIM_CMD_KIND_CHAT;
//chat_cmd->chat_msg = ZI
}
@ -2125,7 +2125,7 @@ JobDef(SimJob, UNUSED sig, UNUSED id)
#if 0
struct host_listen_address local_listen_addr = host_listen_address_from_local_name(Lit("LOCAL_SIM"));
struct host_listen_address net_listen_addr = host_listen_address_from_net_port(12345);
//N_Host *host = N_AllocHost();
//N_Host *host = N_AcquireHost();
/* TODO: Host system should allocate & copy string stored in local_listen_addr */
//host_listen(host, local_listen_addr);
//host_listen(host, net_listen_addr);
@ -2135,24 +2135,24 @@ JobDef(SimJob, UNUSED sig, UNUSED id)
N_Host *host;
if (g->connect_address_str.len > 0)
{
host = N_AllocHost(0);
host = N_AcquireHost(0);
P_Address addr = P_AddressFromString(g->connect_address_str);
N_Connect(host, addr);
}
else
{
host = N_AllocHost(12345);
host = N_AcquireHost(12345);
is_master = 1;
}
BB_Buff msg_writer_bb = AllocBitbuff(Gibi(64));
BB_Buff snapshot_writer_bb = AllocBitbuff(Gibi(64));
SimAccel accel = sim_accel_alloc();
BB_Buff msg_writer_bb = AcquireBitbuff(Gibi(64));
BB_Buff snapshot_writer_bb = AcquireBitbuff(Gibi(64));
SimAccel accel = sim_accel_acquire();
ClientStore *store = sim_client_store_alloc();
Client *user_input_client = sim_client_alloc(store); /* Stores snapshots containing commands to be published to local client */
Client *local_client = sim_client_alloc(store); /* Stores snapshots produced locally */
Client *publish_client = sim_client_alloc(store); /* Stores versions of local snapshots that will be published to remote sims */
ClientStore *store = sim_client_store_acquire();
Client *user_input_client = sim_client_acquire(store); /* Stores snapshots containing commands to be published to local client */
Client *local_client = sim_client_acquire(store); /* Stores snapshots produced locally */
Client *publish_client = sim_client_acquire(store); /* Stores versions of local snapshots that will be published to remote sims */
Client *master_client = sim_client_nil(); /* Stores snapshots received from master */
Client *master_blended_client = sim_client_nil(); /* Stores interpolated master snapshots */
@ -2229,7 +2229,7 @@ JobDef(SimJob, UNUSED sig, UNUSED id)
if (is_master)
{
/* Create remote client */
client = sim_client_alloc(store);
client = sim_client_acquire(store);
sim_client_set_channel_id(client, channel_id);
}
else
@ -2237,10 +2237,10 @@ JobDef(SimJob, UNUSED sig, UNUSED id)
/* Create master client */
if (!master_client->valid)
{
client = sim_client_alloc(store);
client = sim_client_acquire(store);
sim_client_set_channel_id(client, channel_id);
master_client = client;
master_blended_client = sim_client_alloc(store);
master_blended_client = sim_client_acquire(store);
}
else
{
@ -2374,8 +2374,8 @@ JobDef(SimJob, UNUSED sig, UNUSED id)
BB_Buff bb = BitbuffFromString(n->tmp_encoded);
BB_Reader br = BB_ReaderFromBuff(&bb);
/* Alloc & decode snapshot */
Snapshot *ss = sim_snapshot_alloc(client, base_ss, tick);
/* Acquire & decode snapshot */
Snapshot *ss = sim_snapshot_acquire(client, base_ss, tick);
sim_snapshot_decode(&br, ss);
/* Assume all incoming ents want to be sync srcs */
@ -2494,7 +2494,7 @@ JobDef(SimJob, UNUSED sig, UNUSED id)
ctx.master_client = master_client;
ctx.publish_client = publish_client;
Snapshot *prev_world = sim_snapshot_from_tick(local_client, prev_tick);
ctx.world = sim_snapshot_alloc(local_client, prev_world, next_tick);
ctx.world = sim_snapshot_acquire(local_client, prev_world, next_tick);
GenerateuserInputCmds(user_input_client, next_tick);
sim_step(&ctx);
}
@ -2576,7 +2576,7 @@ JobDef(SimJob, UNUSED sig, UNUSED id)
else
{
master_ss_is_blended = 1;
master_ss = sim_snapshot_alloc_from_lerp(master_blended_client, left_snapshot, right_snapshot, blend);
master_ss = sim_snapshot_acquire_from_lerp(master_blended_client, left_snapshot, right_snapshot, blend);
/* Release unneeded blended master snapshots */
if (master_ss->tick > 0)
@ -2696,7 +2696,7 @@ JobDef(SimJob, UNUSED sig, UNUSED id)
}
else
{
base_ss = sim_snapshot_alloc(local_client, master_ss, step_base_tick);
base_ss = sim_snapshot_acquire(local_client, master_ss, step_base_tick);
}
}
@ -2718,7 +2718,7 @@ JobDef(SimJob, UNUSED sig, UNUSED id)
Snapshot *prev_ss = base_ss;
while (step_tick <= step_end_tick)
{
ctx.world = sim_snapshot_alloc(local_client, prev_ss, step_tick);
ctx.world = sim_snapshot_acquire(local_client, prev_ss, step_tick);
if (!mispredicted_tick && step_tick == step_end_tick)
{
sim_snapshot_sync_ents(ctx.world, master_ss, master_player->id, SIM_SYNC_FLAG_NOSYNC_PREDICTABLES);
@ -2786,7 +2786,7 @@ JobDef(SimJob, UNUSED sig, UNUSED id)
{
/* TODO: Double buffer */
Lock lock = LockE(&g->local_to_user_client_mutex);
sim_snapshot_alloc(g->local_to_user_client, local_ss, local_ss->tick);
sim_snapshot_acquire(g->local_to_user_client, local_ss, local_ss->tick);
i64 publish_ns = TimeNs();
if (last_publish_to_user_ns == 0)
{

34
src/pp/pp_ent.c
View File

@ -21,7 +21,7 @@ internal Entity *ent_from_index(Snapshot *ss, u32 index)
* Entity allocation
* ========================== */
Entity *sim_ent_alloc_raw(Snapshot *ss, Entity *parent, EntityId id)
Entity *sim_ent_acquire_raw(Snapshot *ss, Entity *parent, EntityId id)
{
Assert(parent->valid);
Assert(ss->valid);
@ -49,47 +49,47 @@ Entity *sim_ent_alloc_raw(Snapshot *ss, Entity *parent, EntityId id)
return ent;
}
/* Allocates a new entity that will not sync */
Entity *sim_ent_alloc_local(Entity *parent)
/* Acquires a new entity that will not sync */
Entity *sim_ent_acquire_local(Entity *parent)
{
Snapshot *ss = parent->ss;
Entity *e = sim_ent_alloc_raw(ss, parent, sim_ent_random_id());
Entity *e = sim_ent_acquire_raw(ss, parent, sim_ent_random_id());
e->owner = ss->local_player;
return e;
}
Entity *sim_ent_alloc_local_with_id(Entity *parent, EntityId id)
Entity *sim_ent_acquire_local_with_id(Entity *parent, EntityId id)
{
Snapshot *ss = parent->ss;
Entity *e = sim_ent_alloc_raw(ss, parent, id);
Entity *e = sim_ent_acquire_raw(ss, parent, id);
e->owner = ss->local_player;
return e;
}
/* Allocates a new entity to be synced to clients */
Entity *sim_ent_alloc_sync_src(Entity *parent)
/* Acquires a new entity to be synced to clients */
Entity *sim_ent_acquire_sync_src(Entity *parent)
{
Snapshot *ss = parent->ss;
Entity *e = sim_ent_alloc_raw(ss, parent, sim_ent_random_id());
Entity *e = sim_ent_acquire_raw(ss, parent, sim_ent_random_id());
sim_ent_enable_prop(e, SEPROP_SYNC_SRC);
e->owner = ss->local_player;
return e;
}
Entity *sim_ent_alloc_sync_src_with_id(Entity *parent, EntityId id)
Entity *sim_ent_acquire_sync_src_with_id(Entity *parent, EntityId id)
{
Snapshot *ss = parent->ss;
Entity *e = sim_ent_alloc_raw(ss, parent, id);
Entity *e = sim_ent_acquire_raw(ss, parent, id);
sim_ent_enable_prop(e, SEPROP_SYNC_SRC);
e->owner = ss->local_player;
return e;
}
/* Allocates a new entity that will sync with incoming net src ents containing id, and coming from the specified owner */
Entity *sim_ent_alloc_sync_dst(Entity *parent, EntityId ent_id, EntityId owner_id)
/* Acquires a new entity that will sync with incoming net src ents containing id, and coming from the specified owner */
Entity *sim_ent_acquire_sync_dst(Entity *parent, EntityId ent_id, EntityId owner_id)
{
Snapshot *ss = parent->ss;
Entity *e = sim_ent_alloc_raw(ss, parent, ent_id);
Entity *e = sim_ent_acquire_raw(ss, parent, ent_id);
sim_ent_enable_prop(e, SEPROP_SYNC_DST);
e->owner = owner_id;
return e;
@ -624,7 +624,7 @@ void sim_ent_lerp(Entity *e, Entity *e0, Entity *e1, f64 blend)
* ========================== */
/* Walks a local & remote ent tree and allocates any missing net dst ents from remote src ents */
void sim_ent_sync_alloc_tree(Entity *local_parent, Entity *remote, EntityId remote_player)
void sim_ent_sync_acquire_tree(Entity *local_parent, Entity *remote, EntityId remote_player)
{
__prof;
if (sim_ent_has_prop(remote, SEPROP_SYNC_SRC)) {
@ -634,10 +634,10 @@ void sim_ent_sync_alloc_tree(Entity *local_parent, Entity *remote, EntityId remo
EntityId id = remote->id;
Entity *local_ent = sim_ent_from_id(local_ss, id);
if (!local_ent->valid) {
local_ent = sim_ent_alloc_sync_dst(local_parent, id, remote_player);
local_ent = sim_ent_acquire_sync_dst(local_parent, id, remote_player);
}
for (Entity *remote_child = sim_ent_from_id(remote_ss, remote->first); remote_child->valid; remote_child = sim_ent_from_id(remote_ss, remote_child->next)) {
sim_ent_sync_alloc_tree(local_ent, remote_child, remote_player);
sim_ent_sync_acquire_tree(local_ent, remote_child, remote_player);
}
}
}

16
src/pp/pp_ent.h
View File

@ -487,13 +487,13 @@ Inline b32 sim_ent_should_simulate(Entity *ent)
* Entity functions
* ========================== */
/* Alloc */
Entity *sim_ent_alloc_raw(Snapshot *ss, Entity *parent, EntityId id);
Entity *sim_ent_alloc_local(Entity *parent);
Entity *sim_ent_alloc_local_with_id(Entity *parent, EntityId id);
Entity *sim_ent_alloc_sync_src(Entity *parent);
Entity *sim_ent_alloc_sync_src_with_id(Entity *parent, EntityId id);
Entity *sim_ent_alloc_sync_dst(Entity *parent, EntityId ent_id, EntityId owner_id);
/* Acquire */
Entity *sim_ent_acquire_raw(Snapshot *ss, Entity *parent, EntityId id);
Entity *sim_ent_acquire_local(Entity *parent);
Entity *sim_ent_acquire_local_with_id(Entity *parent, EntityId id);
Entity *sim_ent_acquire_sync_src(Entity *parent);
Entity *sim_ent_acquire_sync_src_with_id(Entity *parent, EntityId id);
Entity *sim_ent_acquire_sync_dst(Entity *parent, EntityId ent_id, EntityId owner_id);
void sim_ent_release_raw(Entity *ent);
void sim_ent_release(Entity *ent);
@ -542,7 +542,7 @@ TileKind sim_get_chunk_tile(Entity *chunk_ent, Vec2I32 local_tile_index);
void sim_ent_lerp(Entity *e, Entity *e0, Entity *e1, f64 blend);
/* Sync */
void sim_ent_sync_alloc_tree(Entity *local_parent, Entity *remote, EntityId remote_player);
void sim_ent_sync_acquire_tree(Entity *local_parent, Entity *remote, EntityId remote_player);
void sim_ent_sync(Entity *local, Entity *remote);
/* Encode / decode */

6
src/pp/pp_phys.c
View File

@ -93,7 +93,7 @@ void phys_create_and_update_contacts(PhysStepCtx *ctx, f32 elapsed_dt, u64 phys_
if (!constraint_ent->valid) {
is_start = 1;
/* Create constraint */
constraint_ent = sim_ent_alloc_local_with_id(root, constraint_id);
constraint_ent = sim_ent_acquire_local_with_id(root, constraint_id);
constraint_ent->contact_constraint_data.e0 = e0->id;
constraint_ent->contact_constraint_data.e1 = e1->id;
/* Both entities must be solid and one must be dynamic for a solve to be necessary. */
@ -232,7 +232,7 @@ void phys_create_and_update_contacts(PhysStepCtx *ctx, f32 elapsed_dt, u64 phys_
Entity *dbg_ent = sim_ent_from_id(ss, dbg_ent_id);
if (!dbg_ent->valid) {
/* FIXME: Entity never released */
dbg_ent = sim_ent_alloc_local_with_id(root, dbg_ent_id);
dbg_ent = sim_ent_acquire_local_with_id(root, dbg_ent_id);
sim_ent_enable_prop(dbg_ent, SEPROP_COLLISION_DEBUG);
}
@ -1221,7 +1221,7 @@ void phys_update_aabbs(PhysStepCtx *ctx)
Xform xf = sim_ent_get_xform(ent);
SpaceEntry *space_entry = space_entry_from_handle(space, ent->space_handle);
if (!space_entry->valid) {
space_entry = space_entry_alloc(space, ent->id);
space_entry = space_entry_acquire(space, ent->id);
ent->space_handle = space_entry->handle;
}
Aabb aabb = CLD_AabbFromShape(&ent->local_collider, xf);

32
src/pp/pp_sim.c
View File

@ -55,7 +55,7 @@ Readonly Entity **_g_sim_ent_nil = &G.nil_ent;
void StartupSim(void)
{
__prof;
G.nil_arena = AllocArena(Gibi(1));
G.nil_arena = AcquireArena(Gibi(1));
/* Nil client store */
G.nil_client_store = PushStruct(G.nil_arena, ClientStore);
@ -93,19 +93,19 @@ void StartupSim(void)
* Client store alloc
* ========================== */
ClientStore *sim_client_store_alloc(void)
ClientStore *sim_client_store_acquire(void)
{
__prof;
ClientStore *store;
{
Arena *arena = AllocArena(Gibi(64));
Arena *arena = AcquireArena(Gibi(64));
store = PushStruct(arena, ClientStore);
store->arena = arena;
}
store->valid = 1;
store->num_client_lookup_bins = CLIENT_LOOKUP_BINS;
store->client_lookup_bins = PushStructs(store->arena, ClientLookupBin, store->num_client_lookup_bins);
store->clients_arena = AllocArena(Gibi(64));
store->clients_arena = AcquireArena(Gibi(64));
store->clients = PushDry(store->clients_arena, Client);
return store;
}
@ -127,7 +127,7 @@ void sim_client_store_release(ClientStore *store)
* Client alloc
* ========================== */
Client *sim_client_alloc(ClientStore *store)
Client *sim_client_acquire(ClientStore *store)
{
ClientHandle handle = ZI;
Client *client = sim_client_from_handle(store, store->first_free_client);
@ -148,7 +148,7 @@ Client *sim_client_alloc(ClientStore *store)
client->valid = 1;
client->handle = handle;
client->snapshots_arena = AllocArena(Gibi(8));
client->snapshots_arena = AcquireArena(Gibi(8));
client->num_snapshot_lookup_bins = TICK_LOOKUP_BINS;
client->snapshot_lookup_bins = PushStructs(client->snapshots_arena, SnapshotLookupBin, client->num_snapshot_lookup_bins);
@ -266,7 +266,7 @@ Client *sim_client_from_handle(ClientStore *store, ClientHandle handle)
* ========================== */
/* Produces a new snapshot at `tick` with data copied from `src` snapshot. */
Snapshot *sim_snapshot_alloc(Client *client, Snapshot *src, u64 tick)
Snapshot *sim_snapshot_acquire(Client *client, Snapshot *src, u64 tick)
{
if (tick == 0) {
return sim_snapshot_nil();
@ -285,8 +285,8 @@ Snapshot *sim_snapshot_alloc(Client *client, Snapshot *src, u64 tick)
arena = ss->arena;
} else {
/* Arenas allocated here will be released with client */
arena = AllocArena(Gibi(1));
ents_arena = AllocArena(Gibi(1));
arena = AcquireArena(Gibi(1));
ents_arena = AcquireArena(Gibi(1));
}
}
ResetArena(arena);
@ -596,7 +596,7 @@ void sim_snapshot_set_tile(Snapshot *ss, Vec2I32 world_tile_index, TileKind tile
Entity *chunk_ent = sim_ent_from_id(ss, chunk_id);
if (!chunk_ent->valid) {
Entity *root = sim_ent_from_id(ss, SIM_ENT_ROOT_ID);
chunk_ent = sim_ent_alloc_sync_src_with_id(root, chunk_id);
chunk_ent = sim_ent_acquire_sync_src_with_id(root, chunk_id);
sim_ent_enable_prop(chunk_ent, SEPROP_TILE_CHUNK);
chunk_ent->tile_chunk_index = chunk_index;
}
@ -609,7 +609,7 @@ void sim_snapshot_set_tile(Snapshot *ss, Vec2I32 world_tile_index, TileKind tile
* Snapshot lerp
* ========================== */
Snapshot *sim_snapshot_alloc_from_lerp(Client *client, Snapshot *ss0, Snapshot *ss1, f64 blend)
Snapshot *sim_snapshot_acquire_from_lerp(Client *client, Snapshot *ss0, Snapshot *ss1, f64 blend)
{
__prof;
@ -619,12 +619,12 @@ Snapshot *sim_snapshot_alloc_from_lerp(Client *client, Snapshot *ss0, Snapshot *
Snapshot *ss;
b32 should_blend = 1;
if (ss0->continuity_gen == ss1->continuity_gen && 0 < blend && blend < 1) {
ss = sim_snapshot_alloc(client, ss0, ss0->tick);
ss = sim_snapshot_acquire(client, ss0, ss0->tick);
} else if (RoundF64ToI64(blend) <= 0) {
ss = sim_snapshot_alloc(client, ss0, ss0->tick);
ss = sim_snapshot_acquire(client, ss0, ss0->tick);
should_blend = 0;
} else {
ss = sim_snapshot_alloc(client, ss1, ss1->tick);
ss = sim_snapshot_acquire(client, ss1, ss1->tick);
should_blend = 0;
}
@ -674,7 +674,7 @@ void sim_snapshot_sync_ents(Snapshot *local_ss, Snapshot *remote_ss, EntityId re
/* Create new ents from remote */
for (Entity *remote_top = sim_ent_from_id(remote_ss, remote_root->first); remote_top->valid; remote_top = sim_ent_from_id(remote_ss, remote_top->next)) {
sim_ent_sync_alloc_tree(local_root, remote_top, remote_player);
sim_ent_sync_acquire_tree(local_root, remote_top, remote_player);
}
/* Sync ents with remote, skipping index 0 (nil) & index 1 (root) */
@ -1014,7 +1014,7 @@ void sim_snapshot_decode(BB_Reader *br, Snapshot *ss)
should_read_ent = BB_ReadBit(br);
}
/* Allocate new ents from decode queue */
/* Acquire new ents from decode queue */
for (struct sim_ent_decode_node *n = queue.first; n; n = n->next) {
if (n->is_new) {
u32 index = n->index;

10
src/pp/pp_sim.h
View File

@ -57,7 +57,7 @@ Inline ClientStore *sim_client_store_nil(void)
return *_g_sim_client_store_nil;
}
ClientStore *sim_client_store_alloc(void);
ClientStore *sim_client_store_acquire(void);
void sim_client_store_release(ClientStore *store);
/* ========================== *
@ -122,7 +122,7 @@ Inline b32 sim_client_handle_eq(ClientHandle a, ClientHandle b)
return a.gen == b.gen && a.idx == b.idx;
}
Client *sim_client_alloc(ClientStore *store);
Client *sim_client_acquire(ClientStore *store);
void sim_client_release(Client *client);
Client *sim_client_from_channel_id(ClientStore *store, N_ChannelId channel_id);
@ -221,8 +221,8 @@ Inline Snapshot *sim_snapshot_nil(void)
return *_g_sim_snapshot_nil;
}
/* Alloc */
Snapshot *sim_snapshot_alloc(Client *client, Snapshot *src, u64 tick);
/* Acquire */
Snapshot *sim_snapshot_acquire(Client *client, Snapshot *src, u64 tick);
void sim_snapshot_release(Snapshot *sim_snapshot);
void sim_snapshot_release_ticks_in_range(Client *client, u64 start, u64 end);
@ -240,7 +240,7 @@ Vec2I32 sim_tile_chunk_index_from_world_tile_index(Vec2I32 world_tile_index);
void sim_snapshot_set_tile(Snapshot *ss, Vec2I32 world_tile_index, TileKind tile_kind);
/* Lerp */
Snapshot *sim_snapshot_alloc_from_lerp(Client *client, Snapshot *ss0, Snapshot *ss1, f64 blend);
Snapshot *sim_snapshot_acquire_from_lerp(Client *client, Snapshot *ss0, Snapshot *ss1, f64 blend);
/* Sync */
void sim_snapshot_sync_ents(Snapshot *local_ss, Snapshot *remote_ss, EntityId remote_player, u32 sync_flags);

12
src/pp/pp_space.c
View File

@ -15,11 +15,11 @@ Readonly Space _g_space_nil = { .valid = 0 };
/* NOTE:
* The number of bins determines how often tiles will collide in the spatial hash.
* For example, at `num_bins_sqrt` = 256 (65536 bins), tiles <1, 1>, <1, 257>, and <257, 257> will collide. */
Space *space_alloc(f32 cell_size, u32 num_bins_sqrt)
Space *space_acquire(f32 cell_size, u32 num_bins_sqrt)
{
Space *space;
{
Arena *arena = AllocArena(Gibi(64));
Arena *arena = AcquireArena(Gibi(64));
space = PushStruct(arena, Space);
space->entry_arena = arena;
}
@ -27,7 +27,7 @@ Space *space_alloc(f32 cell_size, u32 num_bins_sqrt)
space->valid = 1;
space->entries = PushDry(space->entry_arena, SpaceEntry);
space->cell_arena = AllocArena(Gibi(64));
space->cell_arena = AcquireArena(Gibi(64));
space->cell_size = cell_size;
space->num_bins = num_bins_sqrt * num_bins_sqrt;
space->num_bins_sqrt = num_bins_sqrt;
@ -129,7 +129,7 @@ internal void space_cell_node_alloc(Vec2I32 cell_pos, SpaceEntry *entry)
}
}
/* Allocate new cell if necessary */
/* Acquire new cell if necessary */
if (!cell) {
if (space->first_free_cell) {
cell = space->first_free_cell;
@ -150,7 +150,7 @@ internal void space_cell_node_alloc(Vec2I32 cell_pos, SpaceEntry *entry)
cell->valid = 1;
}
/* Allocate node */
/* Acquire node */
SpaceCellNode *node;
{
if (space->first_free_cell_node) {
@ -267,7 +267,7 @@ SpaceEntry *space_entry_from_handle(Space *space, SpaceEntryHandle handle)
return entry;
}
SpaceEntry *space_entry_alloc(Space *space, EntityId ent)
SpaceEntry *space_entry_acquire(Space *space, EntityId ent)
{
SpaceEntry *entry = 0;
SpaceEntryHandle handle = ZI;

4
src/pp/pp_space.h
View File

@ -114,7 +114,7 @@ Inline Space *space_nil(void)
* Space
* ========================== */
Space *space_alloc(f32 cell_size, u32 num_bins_sqrt);
Space *space_acquire(f32 cell_size, u32 num_bins_sqrt);
void space_release(Space *space);
void space_reset(Space *space);
@ -131,7 +131,7 @@ SpaceCell *space_get_cell(Space *space, Vec2I32 cell_pos);
* ========================== */
SpaceEntry *space_entry_from_handle(Space *space, SpaceEntryHandle handle);
SpaceEntry *space_entry_alloc(Space *space, EntityId entity);
SpaceEntry *space_entry_acquire(Space *space, EntityId entity);
void space_entry_release(SpaceEntry *entry);
void space_entry_update_aabb(SpaceEntry *entry, Aabb new_aabb);

62
src/pp/pp_step.c
View File

@ -2,10 +2,10 @@
* Sim accel
* ========================== */
SimAccel sim_accel_alloc(void)
SimAccel sim_accel_acquire(void)
{
SimAccel accel = ZI;
accel.space = space_alloc(SPACE_CELL_SIZE, SPACE_CELL_BINS_SQRT);
accel.space = space_acquire(SPACE_CELL_SIZE, SPACE_CELL_BINS_SQRT);
return accel;
}
@ -35,7 +35,7 @@ void sim_accel_reset(Snapshot *ss, SimAccel *accel)
internal Entity *test_spawn_smg(Entity *parent)
{
Entity *e = sim_ent_alloc_sync_src(parent);
Entity *e = sim_ent_acquire_sync_src(parent);
e->sprite = S_TagFromPath(Lit("sprite/gun.ase"));
sim_ent_enable_prop(e, SEPROP_ATTACHED);
@ -51,7 +51,7 @@ internal Entity *test_spawn_smg(Entity *parent)
internal Entity *test_spawn_launcher(Entity *parent)
{
Entity *e = sim_ent_alloc_sync_src(parent);
Entity *e = sim_ent_acquire_sync_src(parent);
e->sprite = S_TagFromPath(Lit("sprite/gun.ase"));
sim_ent_enable_prop(e, SEPROP_ATTACHED);
@ -67,7 +67,7 @@ internal Entity *test_spawn_launcher(Entity *parent)
internal Entity *test_spawn_chucker(Entity *parent)
{
Entity *chucker = sim_ent_alloc_sync_src(parent);
Entity *chucker = sim_ent_acquire_sync_src(parent);
chucker->sprite = S_TagFromPath(Lit("sprite/gun.ase"));
sim_ent_enable_prop(chucker, SEPROP_ATTACHED);
@ -80,7 +80,7 @@ internal Entity *test_spawn_chucker(Entity *parent)
/* Chucker zone */
{
Entity *zone = sim_ent_alloc_sync_src(chucker);
Entity *zone = sim_ent_acquire_sync_src(chucker);
sim_ent_enable_prop(zone, SEPROP_CHUCKER_ZONE);
@ -106,7 +106,7 @@ internal Entity *test_spawn_employee(Entity *parent)
Entity *employee = sim_ent_nil();
{
Entity *e = sim_ent_alloc_sync_src(parent);
Entity *e = sim_ent_acquire_sync_src(parent);
Vec2 pos = VEC2(1, -1);
@ -188,7 +188,7 @@ internal Entity *test_spawn_camera(Entity *parent, Entity *follow)
{
Entity *camera_ent = sim_ent_nil();
if (follow->valid) {
camera_ent = sim_ent_alloc_sync_src(parent);
camera_ent = sim_ent_acquire_sync_src(parent);
sim_ent_set_xform(camera_ent, XformIdentity);
sim_ent_enable_prop(camera_ent, SEPROP_CAMERA);
@ -205,7 +205,7 @@ internal Entity *test_spawn_camera(Entity *parent, Entity *follow)
internal Entity *test_spawn_explosion(Entity *parent, Vec2 pos, f32 strength, f32 radius)
{
Entity *ent = sim_ent_alloc_sync_src(parent);
Entity *ent = sim_ent_acquire_sync_src(parent);
sim_ent_set_xform(ent, XformFromPos(pos));
sim_ent_enable_prop(ent, SEPROP_EXPLOSION);
@ -247,8 +247,8 @@ internal void test_spawn_entities2(Entity *parent, Vec2 pos)
/* Small Box */
#if 1
{
//Entity *e = sim_ent_alloc_local(parent);
Entity *e = sim_ent_alloc_sync_src(parent);
//Entity *e = sim_ent_acquire_local(parent);
Entity *e = sim_ent_acquire_sync_src(parent);
f32 rot = 0;
Vec2 size = VEC2(0.125, 0.125);
@ -290,7 +290,7 @@ internal void test_spawn_entities2(Entity *parent, Vec2 pos)
/* Tiny box */
#if 0
{
Entity *e = sim_ent_alloc_sync_src(parent);
Entity *e = sim_ent_acquire_sync_src(parent);
f32 r = Pi / 4;
Vec2 size = VEC2(0.5, 0.25);
@ -317,8 +317,8 @@ internal void test_spawn_entities3(Entity *parent, Vec2 pos)
/* Heavy box */
{
//Entity *e = sim_ent_alloc_local(parent);
Entity *e = sim_ent_alloc_sync_src(parent);
//Entity *e = sim_ent_acquire_local(parent);
Entity *e = sim_ent_acquire_sync_src(parent);
f32 r = 0;
Vec2 size = VEC2(1, 1);
@ -341,7 +341,7 @@ internal void test_spawn_entities4(Entity *parent, Vec2 pos)
LAX pos;
/* Light box */
Entity *e = sim_ent_alloc_sync_src(parent);
Entity *e = sim_ent_acquire_sync_src(parent);
f32 r = 0;
Vec2 size = VEC2(2, 1);
@ -361,7 +361,7 @@ internal void test_spawn_entities4(Entity *parent, Vec2 pos)
internal void test_spawn_tile(Snapshot *world, Vec2 world_pos)
{
#if 0
Entity *e = sim_ent_alloc_sync_src(parent);
Entity *e = sim_ent_acquire_sync_src(parent);
i32 sign_x = (world_pos.x >= 0) - (world_pos.x < 0);
i32 sign_y = (world_pos.y >= 0) - (world_pos.y < 0);
@ -659,7 +659,7 @@ internal void test_generate_walls(Snapshot *world)
/* Create wall entities */
for (struct wall_node *node = first_wall; node; node = node->next) {
Entity *wall_ent = sim_ent_alloc_sync_src(root);
Entity *wall_ent = sim_ent_acquire_sync_src(root);
sim_ent_enable_prop(wall_ent, SEPROP_WALL);
Vec2 start = sim_pos_from_world_tile_index(node->start);
@ -747,7 +747,7 @@ internal PHYS_COLLISION_CALLBACK_FUNC_DEF(on_collision, data, step_ctx)
/* TODO: Remove this */
{
Xform xf = XformFromTrs(TRS(.t = point, .r = RandF64FromState(&step_ctx->rand, 0, Tau)));
Entity *decal = sim_ent_alloc_sync_src(root);
Entity *decal = sim_ent_acquire_sync_src(root);
decal->sprite = S_TagFromPath(Lit("sprite/blood.ase"));
decal->sprite_tint = Rgba32F(1, 1, 1, 0.25f);
decal->layer = SIM_LAYER_FLOOR_DECALS;
@ -877,7 +877,7 @@ void sim_step(SimStepCtx *ctx)
/* Create player if necessary */
if (is_master && !player->valid) {
/* FIXME: Player never released upon disconnect */
player = sim_ent_alloc_sync_src(root);
player = sim_ent_acquire_sync_src(root);
player->player_client_handle = client->handle;
sim_ent_enable_prop(player, SEPROP_PLAYER);
player->predictor = player->id;
@ -1088,7 +1088,7 @@ void sim_step(SimStepCtx *ctx)
struct sim_data_key msg_key = cmd_ent->cmd_chat_msg;
String msg = sim_data_from_key(sim_data_store, msg_key);
if (msg.len > 0) {
Entity *chat_ent = sim_ent_alloc_sync_src(root);
Entity *chat_ent = sim_ent_acquire_sync_src(root);
sim_ent_enable_prop(chat_ent, SEPROP_CHAT);
chat_ent->chat_player = player->id;
chat_ent->chat_msg = msg_key;
@ -1359,7 +1359,7 @@ void sim_step(SimStepCtx *ctx)
/* Spawn bullet */
Entity *bullet;
{
bullet = sim_ent_alloc_sync_src(root);
bullet = sim_ent_acquire_sync_src(root);
sim_ent_enable_prop(bullet, SEPROP_BULLET);
bullet->bullet_src = ent->id;
@ -1382,7 +1382,7 @@ void sim_step(SimStepCtx *ctx)
/* Spawn tracer */
{
Entity *tracer = sim_ent_alloc_sync_src(root);
Entity *tracer = sim_ent_acquire_sync_src(root);
tracer->tracer_fade_duration = 0.025f;
tracer->layer = SIM_LAYER_TRACERS;
sim_ent_enable_prop(tracer, SEPROP_TRACER);
@ -1406,7 +1406,7 @@ void sim_step(SimStepCtx *ctx)
/* Spawn bullet */
Entity *bullet;
{
bullet = sim_ent_alloc_sync_src(root);
bullet = sim_ent_acquire_sync_src(root);
sim_ent_enable_prop(bullet, SEPROP_BULLET);
bullet->bullet_src = ent->id;
@ -1428,7 +1428,7 @@ void sim_step(SimStepCtx *ctx)
/* Spawn tracer */
{
Entity *tracer = sim_ent_alloc_sync_src(root);
Entity *tracer = sim_ent_acquire_sync_src(root);
tracer->tracer_fade_duration = 0.025f;
tracer->layer = SIM_LAYER_TRACERS;
sim_ent_enable_prop(tracer, SEPROP_TRACER);
@ -1448,7 +1448,7 @@ void sim_step(SimStepCtx *ctx)
Entity *old_joint_ent = sim_ent_from_id(world, ent->chucker_joint);
if (sim_ent_is_valid_and_active(target) && zone->chucker_zone_ent_tick == world->tick - 1) {
if (!sim_ent_id_eq(old_joint_ent->weld_joint_data.e1, target->id)) {
Entity *joint_ent = sim_ent_alloc_sync_src(root);
Entity *joint_ent = sim_ent_acquire_sync_src(root);
sim_ent_enable_prop(joint_ent, SEPROP_ACTIVE);
Xform xf0 = sim_ent_get_xform(ent);
@ -1487,7 +1487,7 @@ void sim_step(SimStepCtx *ctx)
if (sim_ent_has_prop(ent, SEPROP_CONTROLLED)) {
Entity *joint_ent = sim_ent_from_id(world, ent->move_joint);
if (is_master && !sim_ent_is_valid_and_active(joint_ent)) {
joint_ent = sim_ent_alloc_sync_src(root);
joint_ent = sim_ent_acquire_sync_src(root);
joint_ent->predictor = ent->predictor;
joint_ent->mass_unscaled = F32Infinity;
joint_ent->inertia_unscaled = F32Infinity;
@ -1528,7 +1528,7 @@ void sim_step(SimStepCtx *ctx)
/* Retrieve / create aim joint */
Entity *joint_ent = sim_ent_from_id(world, ent->aim_joint);
if (is_master && !sim_ent_is_valid_and_active(joint_ent)) {
joint_ent = sim_ent_alloc_sync_src(root);
joint_ent = sim_ent_acquire_sync_src(root);
joint_ent->predictor = ent->predictor;
joint_ent->mass_unscaled = F32Infinity;
joint_ent->inertia_unscaled = F32Infinity;
@ -1630,7 +1630,7 @@ void sim_step(SimStepCtx *ctx)
def.max_torque = ent->angular_ground_friction;
if (joint_ent->motor_joint_data.max_force != def.max_force || joint_ent->motor_joint_data.max_torque != def.max_torque) {
if (is_master && !sim_ent_is_valid_and_active(joint_ent)) {
joint_ent = sim_ent_alloc_sync_src(root);
joint_ent = sim_ent_acquire_sync_src(root);
joint_ent->predictor = ent->predictor;
sim_ent_enable_prop(joint_ent, SEPROP_MOTOR_JOINT);
sim_ent_enable_prop(joint_ent, SEPROP_ACTIVE);
@ -1667,7 +1667,7 @@ void sim_step(SimStepCtx *ctx)
if (sim_ent_should_simulate(target_ent)) {
if (!sim_ent_is_valid_and_active(joint_ent)) {
/* FIXME: Joint ent may never release */
joint_ent = sim_ent_alloc_local(root);
joint_ent = sim_ent_acquire_local(root);
joint_ent->mass_unscaled = F32Infinity;
joint_ent->inertia_unscaled = F32Infinity;
player->player_dbg_drag_joint_ent = joint_ent->id;
@ -1794,7 +1794,7 @@ void sim_step(SimStepCtx *ctx)
/* Spawn quake */
{
Entity *quake = sim_ent_alloc_sync_src(root);
Entity *quake = sim_ent_acquire_sync_src(root);
sim_ent_set_xform(quake, XformFromPos(pos));
quake->quake_intensity = 0.2f;
quake->quake_fade = quake->quake_intensity / 0.1f;
@ -1915,7 +1915,7 @@ void sim_step(SimStepCtx *ctx)
if (publish_client->valid && world->tick > publish_client->last_tick) {
Snapshot *prev_pub_world = sim_snapshot_from_tick(publish_client, publish_client->last_tick);
Snapshot *pub_world = sim_snapshot_alloc(publish_client, prev_pub_world, world->tick);
Snapshot *pub_world = sim_snapshot_acquire(publish_client, prev_pub_world, world->tick);
/* Sync */
sim_snapshot_sync_ents(pub_world, world, world_client->player_id, 0);

2
src/pp/pp_step.h
View File

@ -10,7 +10,7 @@ struct SimAccel {
Space *space;
};
SimAccel sim_accel_alloc(void);
SimAccel sim_accel_acquire(void);
void sim_accel_release(SimAccel *accel);
void sim_accel_reset(Snapshot *ss, SimAccel *accel);

14
src/prof/prof_tracy.h
View File

@ -41,7 +41,7 @@ inline void __prof_zone_cleanup_func(TracyCZoneCtx *ctx) { TracyCZoneEnd(*ctx) }
#define __prof __profnc(0, 0)
#define __profvalue(v) TracyCZoneValue(__tracy_zone_ctx, (v))
#define __profalloc(ptr, size) TracyCAlloc((ptr), (size))
#define __profalloc(ptr, size) TracyCAcquire((ptr), (size))
#define __proffree(ptr) TracyCFree((ptr))
#define __profmsg(txt, len, col) TracyCMessageC((txt), (len), Bgr32(col))
#define __profframe(name) TracyCFrameMarkNamed((name))
@ -86,7 +86,7 @@ enum __prof_plot_type {
#if ProfilingLocks
# define __proflock_ctx(name) struct TracyCSharedLockCtx *name
# define __proflock_alloc(ctx) TracyCSharedLockAnnounce((ctx))
# define __proflock_acquire(ctx) TracyCSharedLockAnnounce((ctx))
# define __proflock_release(ctx) TracyCSharedLockTerminate((ctx))
# define __proflock_before_exclusive_lock(ctx) TracyCSharedLockBeforeExclusiveLock((ctx))
# define __proflock_after_exclusive_lock(ctx) TracyCSharedLockAfterExclusiveLock((ctx))
@ -99,7 +99,7 @@ enum __prof_plot_type {
# define __proflock_mark(ctx) TracyCSharedLockMark((ctx))
# define __proflock_custom_name(ctx, name, len) TracyCSharedLockCustomName((ctx), (name), (len))
#else
# define __proflock_alloc(ctx)
# define __proflock_acquire(ctx)
# define __proflock_release(ctx)
# define __proflock_before_exclusive_lock(ctx)
# define __proflock_after_exclusive_lock(ctx)
@ -118,24 +118,24 @@ enum __prof_plot_type {
inline void __prof_dx11_zone_cleanup_func(TracyCD3D11ZoneCtx *ctx) { ___tracy_d3d11_emit_zone_end(*ctx); }
# define __profnc_dx11(dx11_ctx, name, color) static const struct ___tracy_source_location_data Cat(__tracy_gpu_d3d11_source_location,__LINE__) = { name, __func__, __FILE__, (uint32_t)__LINE__, Bgr32(color) }; __attribute((cleanup(__prof_dx11_zone_cleanup_func))) TracyCD3D11ZoneCtx __tracy_d3d11_zone_ctx; ___tracy_d3d11_emit_zone_begin( dx11_ctx, &__tracy_d3d11_zone_ctx, &Cat(__tracy_gpu_d3d11_source_location,__LINE__), 1)
# define __prof_dx11_ctx(name) struct TracyCD3D11Ctx *name
# define __prof_dx11_ctx_alloc(ctx, device, device_ctx, name, name_len) ctx = ___tracy_d3d11_context_announce(device, device_ctx, name, name_len)
# define __prof_dx11_ctx_acquire(ctx, device, device_ctx, name, name_len) ctx = ___tracy_d3d11_context_announce(device, device_ctx, name, name_len)
# define __prof_dx11_ctx_release(ctx) ___tracy_d3d11_context_terminate(ctx)
# define __prof_dx11_collect(ctx) ___tracy_d3d11_context_collect(ctx)
/* Dx12 */
inline void __prof_dx12_zone_cleanup_func(TracyCD3D12ZoneCtx *ctx) { ___tracy_d3d12_emit_zone_end(*ctx); }
# define __profnc_dx12(dx12_ctx, cmd_list, name, color) static const struct ___tracy_source_location_data Cat(__tracy_gpu_d3d12_source_location,__LINE__) = { name, __func__, __FILE__, (uint32_t)__LINE__, Bgr32(color) }; __attribute((cleanup(__prof_dx12_zone_cleanup_func))) TracyCD3D12ZoneCtx __tracy_d3d12_zone_ctx; ___tracy_d3d12_emit_zone_begin( dx12_ctx, cmd_list, &__tracy_d3d12_zone_ctx, &Cat(__tracy_gpu_d3d12_source_location,__LINE__), 1)
# define __prof_dx12_ctx(name) struct TracyCD3D12Ctx *name
# define __prof_dx12_ctx_alloc(ctx, device, queue, name, name_len) ctx = ___tracy_d3d12_context_announce(device, queue, name, name_len)
# define __prof_dx12_ctx_acquire(ctx, device, queue, name, name_len) ctx = ___tracy_d3d12_context_announce(device, queue, name, name_len)
# define __prof_dx12_ctx_release(ctx) ___tracy_d3d12_context_terminate(ctx)
# define __prof_dx12_new_frame(ctx) ___tracy_d3d12_context_new_frame(ctx)
# define __prof_dx12_collect(ctx) ___tracy_d3d12_context_collect(ctx)
#else
# define __profnc_dx11(dx11_ctx, name, color)
# define __prof_dx11_ctx_alloc(ctx, device, device_ctx, name, name_len)
# define __prof_dx11_ctx_acquire(ctx, device, device_ctx, name, name_len)
# define __prof_dx11_ctx_release(ctx)
# define __prof_dx11_collect(ctx)
# define __profnc_dx12(dx11_ctx, queue, name, color)
# define __prof_dx12_ctx_alloc(ctx, device, queue, name, name_len)
# define __prof_dx12_ctx_acquire(ctx, device, queue, name, name_len)
# define __prof_dx12_ctx_release(ctx)
# define __prof_dx12_new_frame(ctx)
# define __prof_dx12_collect(ctx)

20
src/sprite/sprite_core.c
View File

@ -7,7 +7,7 @@ void S_StartupCore(void)
{
__prof;
S_SharedState *g = &S_shared_state;
g->perm_arena = AllocArena(Mebi(1));
g->perm_arena = AcquireArena(Mebi(1));
{
/* Init loading texture */
g->loading_texture = PushStruct(g->perm_arena, S_Texture);
@ -20,7 +20,7 @@ void S_StartupCore(void)
u32 width = 64;
u32 height = 64;
u32 *pixels = S_GeneratePurpleBlackImage(scratch.arena, width, height);
g->nil_texture->gp_texture = GPU_AllocTexture(GP_TEXTURE_FORMAT_R8G8B8A8_UNORM, 0, VEC2I32(width, height), pixels);
g->nil_texture->gp_texture = GPU_AcquireTexture(GP_TEXTURE_FORMAT_R8G8B8A8_UNORM, 0, VEC2I32(width, height), pixels);
EndScratch(scratch);
}
@ -37,10 +37,10 @@ void S_StartupCore(void)
}
SetArenaReadonly(g->perm_arena);
g->cache.arena = AllocArena(Gibi(64));
g->cache.arena = AcquireArena(Gibi(64));
g->cache.bins = PushStructs(g->cache.arena, S_CacheEntryBin, S_CacheBinsCount);
g->scopes_arena = AllocArena(Gibi(64));
g->scopes_arena = AcquireArena(Gibi(64));
RunJob(1, S_EvictorJob, JobPool_Background, JobPriority_Low, &g->shutdown_counter, 0);
@ -252,7 +252,7 @@ S_Sheet S_SheetFromAseResult(Arena *arena, ASE_DecodedSheet ase)
}
}
/* Allocate slice groups & fill originals in 2d array */
/* Acquire slice groups & fill originals in 2d array */
sheet.slice_groups_count = num_temp_slice_group_nodes;
sheet.slice_groups = PushStructs(arena, S_SheetSliceGroup, sheet.slice_groups_count);
sheet.slice_groups_dict = InitDict(arena, (u64)(num_temp_slice_group_nodes * S_SliceLookupTableBinRatio));
@ -470,7 +470,7 @@ void S_LoadCacheEntryTexture(S_CacheEntryRef ref, S_Tag tag)
/* TODO: Replace arena allocs w/ buddy allocator */
/* TODO: Arena probably overkill. Just using it to store texture struct. */
e->arena = AllocArena(S_TextureArenaReserve);
e->arena = AcquireArena(S_TextureArenaReserve);
u64 memory_size = 0;
{
/* Decode */
@ -496,7 +496,7 @@ void S_LoadCacheEntryTexture(S_CacheEntryRef ref, S_Tag tag)
e->texture->height = decoded.height;
e->texture->valid = 1;
e->texture->loaded = 1;
e->texture->gp_texture = GPU_AllocTexture(GP_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB, 0, VEC2I32(decoded.width, decoded.height), decoded.pixels);
e->texture->gp_texture = GPU_AcquireTexture(GP_TEXTURE_FORMAT_R8G8B8A8_UNORM_SRGB, 0, VEC2I32(decoded.width, decoded.height), decoded.pixels);
/* TODO: Query gpu for more accurate texture size in VRAM */
memory_size += (decoded.width * decoded.height) * sizeof(*decoded.pixels);
success = 1;
@ -553,7 +553,7 @@ void S_LoadCacheEntrySheet(S_CacheEntryRef ref, S_Tag tag)
Assert(e->kind == S_CacheEntryKind_Sheet);
/* TODO: Replace arena allocs w/ buddy allocator */
e->arena = AllocArena(S_SheetArenaReserve);
e->arena = AcquireArena(S_SheetArenaReserve);
{
/* Decode */
ASE_DecodedSheet decoded = ZI;
@ -702,7 +702,7 @@ S_ScopeCacheEntryRef *S_EnsureRefFromRef(S_Scope *scope, S_CacheEntryRef ref)
S_Scope *S_BeginScope(void)
{
S_SharedState *g = &S_shared_state;
/* Alloc scope */
/* Acquire scope */
S_Scope *result = 0;
S_ScopeCacheEntryRef **bins = 0;
S_ScopeCacheEntryRef *pool = 0;
@ -949,7 +949,7 @@ void *S_DataFromTag(S_Scope *scope, S_Tag tag, S_CacheEntryKind kind, b32 await)
}
else
{
/* Allocate cmd */
/* Acquire cmd */
S_PushLoadJob(ref, tag);
}
}

2
src/sprite/sprite_core.h
View File

@ -128,7 +128,7 @@ Struct(S_CacheEntry)
Atomic32 state;
Atomic64Padded refcount_struct; /* Cast fetched result to `cache_refcount` */
/* Allocated data */
/* Acquired data */
/* NOTE: This data is finalized once entry state = loaded */
i64 load_time_ns;
u64 memory_usage;

4
src/ttf/ttf_dwrite.cpp
View File

@ -139,10 +139,10 @@ TTF_Result TTF_Decode(Arena *arena, String encoded, f32 point_size, u32 *cache_c
}
//- Setup atlas
/* Allocate font memory */
/* Acquire font memory */
TTF_Glyph *glyphs = (TTF_Glyph *)PushStructs(arena, TTF_Glyph, glyph_count);
/* Allocate (starting) atlas memory
/* Acquire (starting) atlas memory
* NOTE: This is unecessary since atlas memory will grow anyway. Could
* just start w/ atlas height 0.
*/

4
src/watch/watch_core.c
View File

@ -6,9 +6,9 @@ W_SharedState W_shared_state = ZI;
void W_StartupCore(void)
{
W_SharedState *g = &W_shared_state;
g->watch = P_AllocWatch(Lit("./"));
g->watch = P_AcquireWatch(Lit("./"));
g->watch_events_arena = AllocArena(Gibi(64));
g->watch_events_arena = AcquireArena(Gibi(64));
RunJob(1, W_MonitorJob, JobPool_Floating, JobPriority_Low, &g->watch_jobs_counter, 0);
RunJob(1, W_DispatcherJob, JobPool_Floating, JobPriority_Low, &g->watch_jobs_counter, 0);