diff --git a/.agents/skills/mirai-agent-api/references/methods.md b/.agents/skills/mirai-agent-api/references/methods.md
index ed2af3827..c2546a123 100644
--- a/.agents/skills/mirai-agent-api/references/methods.md
+++ b/.agents/skills/mirai-agent-api/references/methods.md
@@ -320,6 +320,13 @@ Reading a capture:
per second, the mean interval between two and its deviation (how even the pace is) and the
latency from the start of a frame to its image. With generation there are twice as many images as
frames.
+- **The GPU of a frame.** A frame's `gpu_ms` and passes are those of its own submissions, at the
+ time they ran (`start_ms` since the frame began on the CPU). A frame whose submissions did not all
+ come back says `gpu_measured:false`, and the GPU numbers of the summary and of `profile.compare`
+ leave it out (`gpu_frames`).
+- **Memory.** `profile.capture` with `memory:true` samples it at the end of each frame, as the part
+ `memory` of the frame, and the summary gives `memory`: the World's tables and storages (its peak
+ over the capture and its rise), the process and the GPU. Leave it off to measure cost.
- **Own time.** `self_ms` excludes the zones inside: a function that waits for its tasks has them
as children (`job`, `range`); what the workers run appears with `thread:"workers"`.
- **Conditions.** `notes` warns about what invalidates a reading: engine at `-o:minimal`,
diff --git a/.agents/skills/mirai-core/references/host.md b/.agents/skills/mirai-core/references/host.md
index 247c36ec3..640146bc7 100644
--- a/.agents/skills/mirai-core/references/host.md
+++ b/.agents/skills/mirai-core/references/host.md
@@ -190,12 +190,24 @@ entities or persistent data.
always covered, like the editor bars, is not drawn.
**Profiling (`profile.odin`).** `profile_start(app, frames)` records the following frames: zones of
-the main thread, one per loop function, the tasks of each worker and what the renderer
-measures. The first `profile_start` reserves the memory: recording does
-not allocate, without recording a zone costs one branch and what does not fit is counted in `lost`.
-Whoever reads the zones as they happen (a profiling plugin) calls `profile_request` in every frame
-and reads them with its own cursor; without a recording or a request, the device writes no
-per-pass timestamps. The editor exposes it with
+the main thread, one per loop function, the tasks of each worker, what the renderer measures and the
+GPU passes of every submission of the frame (a capture or a thumbnail besides the window). Those
+come back `rhi.MAX_FRAMES_IN_FLIGHT` submissions later, by `rhi` frame number, and go to the frame
+that submitted them; a frame is measured once all of its submissions came back, and a recording runs
+a few frames past its last one, keeping no zones, until they do. The first `profile_start` reserves
+the memory: recording does not allocate, without recording a zone costs one branch and what does not
+fit is counted in `lost`. Whoever reads the zones as they happen (a profiling plugin) calls
+`profile_request` in every frame and reads them with its own cursor; without a recording or a
+request, the device writes no per-pass timestamps. A recording that asks for memory
+(`profile_start(app, frames, memory)`, off by default) samples it at the end of each frame, inside
+the frame as its part `memory`: what the tables and storages of the World that ran last hold
+(`core.world_memory`, the game loop's World, else the editor's), the private and resident memory of
+the process (`platform.process_memory`) and the device memory. `core.world_memory` adds up the
+capacity of the arrays, maps and slices of the tables and storages and of what their elements and
+map values hold, reading the containers that `world_info_index` found once in their types, so a
+sample costs one read per container header, those of every slot of a pool included; the bytes of
+strings are not in it (a string may be a literal or a view), nor what game code allocates outside
+its storages. The editor exposes it with
[`profile.*`](../../mirai-agent-api/references/methods.md#profiling).
**Loads (`load_profile.odin`).** `app.load_profile` keeps the last load of each kind (scene, Play,
diff --git a/.agents/skills/mirai-plugins/references/profiling.md b/.agents/skills/mirai-plugins/references/profiling.md
index 4a29537c2..b5140b695 100644
--- a/.agents/skills/mirai-plugins/references/profiling.md
+++ b/.agents/skills/mirai-plugins/references/profiling.md
@@ -13,8 +13,10 @@ View > Profiler panel. **Record** records frames into a
agent see the same captures, and the panel shows the last finished one.
- It shows the capture summary, a chart with one bar per frame colored by what it waited on (CPU,
- GPU or pacing), the timeline of the chosen frame (main thread zones, one row per worker and the
- GPU passes) and the most expensive zones per frame.
+ GPU or pacing), and a tab per track for the chosen frame: CPU (main thread zones, one row per
+ worker, the most expensive zones per frame), GPU (its passes where they ran, the most expensive
+ passes) and Memory (the World, the process and the GPU over the frames). Its recordings sample
+ memory; the tabs keep the height of the tallest, so the panel does not move under the pointer.
- It draws with [`editor.drawing`](../../mirai-editor/references/extensions.md#a-panel); what it
computes from a capture it computes when it starts showing it.
diff --git a/.agents/skills/mirai-rendering/references/frame-graph.md b/.agents/skills/mirai-rendering/references/frame-graph.md
index 390becdf7..51ba55004 100644
--- a/.agents/skills/mirai-rendering/references/frame-graph.md
+++ b/.agents/skills/mirai-rendering/references/frame-graph.md
@@ -223,6 +223,9 @@ or interleave its own passes.
of `tick_now` (QPC on Windows, `CLOCK_MONOTONIC_RAW` on Linux). Without the extension, Vulkan
places the last timestamp of the frame at the moment it collects it: it keeps the durations but
arrives late;
+- `renderer_gpu_submissions`: a copy of the timings of each submission since
+ `renderer_gpu_clear`, with the `rhi` frame it was (`rhi.frame_timings`), for whoever accounts for
+ every submission of a host frame; `Stats.timings` is only the last one the GPU finished;
- visible, culled and occluded instances, probes and estimated rays per frame;
- what was discarded by capacity ([UI limits](ui.md#capacities));
- materials, textures, their memory, reduced textures and compression
diff --git a/core/world_data.odin b/core/world_data.odin
index ae8332619..25cd64da9 100644
--- a/core/world_data.odin
+++ b/core/world_data.odin
@@ -302,3 +302,39 @@ world_detach :: proc(info:^World_Info,world,shared:rawptr) {
}
}
}
+
+// The bytes the tables and storages of a World hold behind their pointers:
+// the capacity of the arrays, maps and slices of each table and storage of
+// the place World, and of its entities, as the ops world_info_index compiled
+// from their types read them. It reads capacities, not the allocator, so
+// what game code allocates outside its storages is not in it. 0 for a
+// World_Info without schema.
+world_memory :: proc(info:^World_Info,data:rawptr) -> (bytes:int) {
+ if info==nil || data==nil || info.schema==nil {return}
+ ws:=info.schema
+ bytes=memory_read(ws.memory,ws.entities,entities_of(info,data))
+ for &t,i in info.tables {
+ if t.place!=.World {continue}
+ table:=table_of(data,&t)
+ bytes+=table_bytes(table,t.info.size)
+ held:=ws.tables[i].held
+ if held[0]==held[1] {continue}
+ for row in 0..
(bytes:int) {
+ bytes=(t.values.cap+t.added.cap+t.edited.cap)*size
+ bytes+=cap(t.entities)*size_of(Entity)+cap(t.stamps)*size_of(u64)+cap(t.page_stamps)*size_of(u64)
+ bytes+=cap(t.off)*size_of(bool)+cap(t.turns)*size_of(u64)+cap(t.pending)*size_of(Pending)
+ bytes+=cap(t.edits)*size_of(Edit)+cap(t.gone.items)*size_of(Entity)+cap(t.owners)*size_of(Row_Owner)
+ bytes+=len(t.locks)*size_of(Lock)+cap(t.rows)*size_of([]i32)
+ for page in t.rows {bytes+=len(page)*size_of(i32)}
+ when CHECK_WRITES {bytes+=cap(t.settled.values)}
+ return
+}
diff --git a/core/world_memory_test.odin b/core/world_memory_test.odin
new file mode 100644
index 000000000..efa9751ea
--- /dev/null
+++ b/core/world_memory_test.odin
@@ -0,0 +1,147 @@
+package core
+
+import "base:runtime"
+import "core:testing"
+
+@(private) Mem_Slot :: struct {points:[dynamic][3]f32,tag:u32,bytes:[]u8}
+@(private) Mem_Node :: struct {kids:[dynamic]Mem_Node,weight:u32}
+@(private) Mem_Pools :: struct {
+ slots:[dynamic]Mem_Slot,
+ fixed:[4]Mem_Slot,
+ names:map[u32]u32,
+ lists:map[u32][dynamic]u32,
+ tree:[dynamic]Mem_Node,
+ flat:[8]u32,
+}
+
+@(private)
+@(test_world)
+Mem_World :: struct {
+ using world:Test_World,
+ values:Table(u32),
+ pools:Mem_Pools,
+}
+
+// What a World's tables and storages hold grows with their rows and items,
+// by the capacity they reserved.
+@(test)
+the_memory_of_a_world_follows_what_its_tables_and_storages_hold :: proc(t:^testing.T) {
+ info,described:=test_info(t,Mem_World)
+ if !described {return}
+ defer test_info_destroy(&info)
+ w:Mem_World
+ if !testing.expect(t,world_init(&info,.World,&w,context.allocator)) {return}
+ defer world_destroy(&info,.World,&w)
+ empty:=world_memory(&info,&w)
+ for i in 0..<100 {
+ e:=create(&w.entities)
+ add(&w.values,e,u32(i))
+ }
+ settle(&info,&w,nil)
+ rows:=world_memory(&info,&w)
+ testing.expectf(t,rows>=empty+100*size_of(Entity),"100 rows and their entities add to it: %d -> %d",empty,rows)
+ append(&w.pools.slots,Mem_Slot{})
+ for i in 0..<1000 {append(&w.pools.slots[0].points,[3]f32{f32(i),0,0})}
+ items:=world_memory(&info,&w)
+ testing.expect_value(t,items-rows,cap(w.pools.slots)*size_of(Mem_Slot)+cap(w.pools.slots[0].points)*size_of([3]f32))
+}
+
+// The ops world_info_index compiles read what reading the types at every
+// step reads, in arrays of values that hold arrays, fixed or not, in the
+// values of a map and in a type that holds itself.
+@(test)
+the_compiled_memory_ops_read_what_the_types_say :: proc(t:^testing.T) {
+ info,described:=test_info(t,Mem_World)
+ if !described {return}
+ defer test_info_destroy(&info)
+ w:Mem_World
+ if !testing.expect(t,world_init(&info,.World,&w,context.allocator)) {return}
+ defer world_destroy(&info,.World,&w)
+ defer { // world_destroy frees arrays and slices, not maps
+ delete(w.pools.names)
+ for _,list in w.pools.lists {delete(list)}
+ delete(w.pools.lists)
+ }
+ for i in 0..<5 {
+ append(&w.pools.slots,Mem_Slot{tag=u32(i)})
+ for _ in 0..5*size_of(Mem_Slot),"the pools hold something")
+}
+
+@(private="file")
+reflected :: proc(data:rawptr,info:^runtime.Type_Info) -> int {bytes,_:=reflected_bytes(data,info);return bytes}
+
+// What a value holds behind its pointers, read from its type at every step:
+// what the compiled ops of world_memory must give.
+@(private="file")
+reflected_bytes :: proc(data:rawptr,info:^runtime.Type_Info) -> (bytes,elements:int) {
+ base:=runtime.type_info_base(info)
+ #partial switch v in base.variant {
+ case runtime.Type_Info_Struct:
+ for i in 0.. ^Wor
return nil
}
}
+ ops:=make([dynamic]Memory_Op,allocator)
+ compiled:=make(map[typeid][2]i32,context.temp_allocator)
+ entities,ok:=memory_compile(&ops,&compiled,type_info_of(Entities))
+ ws.entities=entities
+ for t,i in info.tables {ws.tables[i].held,ok=memory_compile(&ops,&compiled,t.info);if !ok {break}}
+ for s,i in info.storages {if ok {ws.storages[i].held,ok=memory_compile(&ops,&compiled,s.info)}}
+ ws.memory=ops[:]
+ if !ok {
+ world_schema_destroy(ws)
+ return nil
+ }
return ws
}
+// A container a value holds: where it is in the value and how to read what
+// it holds. Its children are the ops of one element, read for each element
+// it has: of a fixed array, a dynamic array or a slice, or a value of a map.
+// A key holds no container: a type that does is not comparable.
+@(private)
+Memory_Op :: struct {
+ offset:uintptr,
+ kind:Memory_Kind,
+ count:int, // Array: elements
+ elem_size:int,
+ map_info:^runtime.Map_Info,
+ children:[2]i32, // the ops of one element, from its start
+}
+@(private)
+Memory_Kind :: enum u8 {Dynamic,Slice,Map,Array}
+
+// Appends the ops of what a type holds behind pointers: first its own, then
+// those of each of their elements. held: the range of its own. A type is
+// compiled once: its later uses, as an element of itself too, read that range.
+@(private="file")
+memory_compile :: proc(ops:^[dynamic]Memory_Op,compiled:^map[typeid][2]i32,info:^runtime.Type_Info) -> (held:[2]i32,ok:bool) {
+ if known,found:=compiled[info.id];found {return known,true}
+ own:=make([dynamic]Memory_Op,context.temp_allocator)
+ elems:=make([dynamic]^runtime.Type_Info,context.temp_allocator)
+ memory_collect(&own,&elems,info,0)
+ held={i32(len(ops)),i32(len(ops)+len(own))}
+ if _,error:=append(ops,..own[:]);error!=nil {return held,false}
+ if _,error:=map_insert(compiled,info.id,held);error!=nil {return held,false}
+ for elem,i in elems {
+ if elem==nil {continue}
+ children,done:=memory_compile(ops,compiled,elem)
+ if !done {return held,false}
+ ops[int(held[0])+i].children=children
+ }
+ return held,true
+}
+
+// The containers of a value at offset in it, not of their elements: elems
+// gets, by op, the type of an element that holds containers.
+@(private="file")
+memory_collect :: proc(own:^[dynamic]Memory_Op,elems:^[dynamic]^runtime.Type_Info,info:^runtime.Type_Info,offset:uintptr) {
+ if value_flat(info) {return}
+ add :: proc(own:^[dynamic]Memory_Op,elems:^[dynamic]^runtime.Type_Info,op:Memory_Op,elem:^runtime.Type_Info) {
+ append(own,op)
+ append(elems,elem if elem!=nil && !value_flat(elem) else nil)
+ }
+ #partial switch v in runtime.type_info_base(info).variant {
+ case runtime.Type_Info_Struct:
+ for i in 0.. (bytes:int) {
+ for op in ops[held[0]:held[1]] {
+ at:=rawptr(uintptr(data)+op.offset)
+ count,first:=0,rawptr(nil)
+ switch op.kind {
+ case .Dynamic:
+ a:=cast(^runtime.Raw_Dynamic_Array)at
+ bytes+=a.cap*op.elem_size
+ count,first=a.len,a.data
+ case .Slice:
+ a:=cast(^runtime.Raw_Slice)at
+ bytes+=a.len*op.elem_size
+ count,first=a.len,a.data
+ case .Map:
+ bytes+=memory_read_map(ops,op,(cast(^runtime.Raw_Map)at)^)
+ case .Array:
+ count,first=op.count,at
+ }
+ if op.children[0]==op.children[1] {continue}
+ for i in 0.. (bytes:int) {
+ if m.data==0 || op.map_info==nil {return}
+ capacity:=uintptr(runtime.map_cap(m))
+ bytes=int(runtime.map_total_allocation_size(capacity,op.map_info))
+ if op.children[0]==op.children[1] {return}
+ _,values,hashes,_,_:=runtime.map_kvh_data_dynamic(m,op.map_info)
+ for i in 0.. (s:^serial.Schema,index:serial.Type_Index,ok:bool) {
@@ -194,7 +305,7 @@ world_schema_destroy :: proc(ws:^World_Schema) {
for &v in ws.storages {value_schema_destroy(&v,allocator)}
for &v in ws.records {value_schema_destroy(&v,allocator)}
delete(ws.tables,allocator);delete(ws.storages,allocator);delete(ws.records,allocator)
- delete(ws.table_hashes,allocator)
+ delete(ws.table_hashes,allocator);delete(ws.memory,allocator)
delete(ws.choices,allocator);delete(ws.schema.named)
serial.schema_destroy(&ws.schema)
_=runtime.mem_free(ws,allocator)
diff --git a/core/worlds_gen_test.odin b/core/worlds_gen_test.odin
index 6844430a2..878af0842 100644
--- a/core/worlds_gen_test.odin
+++ b/core/worlds_gen_test.odin
@@ -440,6 +440,25 @@ test_info_rewound_world :: proc(allocator:=context.allocator) -> (info:World_Inf
return info,true
}
+@(private="file")
+test_info_mem_world :: proc(allocator:=context.allocator) -> (info:World_Info,ok:bool) {
+ context.allocator=allocator
+ tables,tables_error:=make([]Table_Info,1)
+ storages,storages_error:=make([]Storage_Info,1)
+ if tables_error!=nil || storages_error!=nil {
+ delete(tables);delete(storages)
+ return
+ }
+ tables[0]={name="values",library="",type=typeid_of(type_of((^Mem_World)(nil).values.values[0])),info=type_info_of(type_of((^Mem_World)(nil).values.values[0])),offset=offset_of(Mem_World,values),place=.World,shared=false,replicated=.None,game=false,default=nil,description="",fields=nil,single=false,far=false,derived=false,was="",base=false,locks=nil}
+ storages[0]={name="Mem_Pools",library="core",type=typeid_of(Mem_Pools),info=type_info_of(Mem_Pools),offset=offset_of(Mem_World,pools),place=.World,setting=.None,default=nil,by_world=false,for_device=nil,persist=false,keep=false,plugin="",game=false,local=false,procs={}}
+ info.sizes={.World=size_of(Mem_World),.Shared=1,.Editor=1}
+ info.aligns={.World=align_of(Mem_World),.Shared=1,.Editor=1}
+ info.entities,info.revisions=offset_of(Mem_World,entities),offset_of(Mem_World,storage_revisions)
+ info.tables,info.storages=tables,storages
+ world_info_index(&info)
+ return info,true
+}
+
@(private="file")
test_info_run_world :: proc(allocator:=context.allocator) -> (info:World_Info,ok:bool) {
context.allocator=allocator
@@ -544,6 +563,7 @@ test_info :: proc(t:^testing.T,$W:typeid,allocator:=context.allocator,loc:=#call
else when W==Rev_World {info,ok=test_info_rev_world(allocator)}
else when W==Roll_World {info,ok=test_info_roll_world(allocator)}
else when W==Rewound_World {info,ok=test_info_rewound_world(allocator)}
+ else when W==Mem_World {info,ok=test_info_mem_world(allocator)}
else when W==Run_World {info,ok=test_info_run_world(allocator)}
else when W==Run_Kept_World {info,ok=test_info_run_kept_world(allocator)}
else when W==Indexed_World {info,ok=test_info_indexed_world(allocator)}
diff --git a/editor/api_profile.odin b/editor/api_profile.odin
index 1bdb7f57e..6a6249293 100644
--- a/editor/api_profile.odin
+++ b/editor/api_profile.odin
@@ -29,6 +29,7 @@ Api_Profile_Capture_Params :: struct {
label:[32]u8 `mirai:"optional,text,label=Name to tell the capture by"`,
top:int `mirai:"optional,min=1,max=64,clamp,label=Zones and GPU passes in the summary"`,
wait:int `mirai:"optional,min=0,max=900,unit=s,label=With advance: how long to queue for a compilation or another measurement that runs; past it the call fails"`,
+ memory:bool `mirai:"optional,label=Also sample the memory at the end of each frame, in a zone memory of the frame: what the tables and storages of the World hold (the one Play runs, else the scene's), the process and the GPU"`,
allow_limited:bool `mirai:"optional,label=Measure with VSync or a frame limit or graphics validation on; the call refuses otherwise and says how to turn them off. The summary says comparable:false"`,
}
Api_Profile_Id_Params :: struct {
@@ -72,7 +73,8 @@ Api_Profile_Frame_Stats :: struct {
wait_ms:f32 `mirai:"label=Mean wait for a frame slot of the GPU"`,
pacing_ms:f32 `mirai:"label=Mean wait for the frame limit or VSync"`,
between_ms:f32 `mirai:"label=Mean from the end of a frame to the start of the next"`,
- gpu_ms:f32 `mirai:"label=Mean of the GPU"`,
+ gpu_ms:f32 `mirai:"label=Mean of the GPU over the frames whose GPU times came back"`,
+ gpu_frames:int `mirai:"label=Frames whose every submission gave back its GPU times: gpu_ms and gpu count only them"`,
bound:Api_Profile_Bounds `mirai:"label=Frames by what they waited for"`,
spikes:int `mirai:"label=Frames over twice the median"`,
worst:[]int `mirai:"label=The slowest frames by index; the slowest first"`,
@@ -102,6 +104,18 @@ Api_Profile_Presentation :: struct {
latency_mean_ms:f32 `mirai:"label=From the start of a frame to its own image going to the display with its GPU work done; without frame generation the GPU is taken to start each frame once it is submitted and the one before is done"`,
latency_p95_ms:f32,
}
+// In MB. world: what the tables and storages of the World that ran hold
+// (core.world_memory); what game code allocates outside its storages is not in it.
+Api_Profile_Memory :: struct {
+ world_mb:f32 `mirai:"label=At the end of the last frame"`,
+ world_peak_mb:f32 `mirai:"label=The most at the end of a frame of the capture"`,
+ world_rise_mb:f32 `mirai:"label=From the end of the first frame to that of the last"`,
+ private_mb:f32 `mirai:"label=Of the process: what only it uses, at the end of the last frame"`,
+ private_rise_mb:f32 `mirai:"label=From the end of the first frame to that of the last"`,
+ resident_mb:f32 `mirai:"label=Of the process in physical memory, shared pages included"`,
+ gpu_mb:f32 `mirai:"label=Of the device memory the process holds"`,
+}
+Api_Profile_Frame_Memory :: struct {world_mb,private_mb,gpu_mb:f32}
Api_Profile_Summary :: struct {
id:int `mirai:"label=What the id of the other profile methods takes"`,
label:string,
@@ -116,6 +130,7 @@ Api_Profile_Summary :: struct {
zones:[]Api_Profile_Zone `mirai:"optional,label=The other zones that cost the most by their own time"`,
gpu:[]Api_Profile_Stat `mirai:"optional,label=The GPU passes that cost the most"`,
workers:Api_Profile_Workers `mirai:"optional"`,
+ memory:Api_Profile_Memory `mirai:"optional,label=Of a capture with memory"`,
lost_zones:u64 `mirai:"optional,label=Zones the recorder had no room for"`,
notes:[]string `mirai:"optional,label=What to know before reading the numbers"`,
}
@@ -129,6 +144,7 @@ Api_Profile_Tree :: struct {
}
Api_Profile_Pass :: struct {
name:string,
+ start_ms:f32 `mirai:"label=When it ran on the GPU, since the frame began on the CPU"`,
ms:f32,
}
Api_Profile_Frame :: struct {
@@ -138,13 +154,15 @@ Api_Profile_Frame :: struct {
wait_ms:f32 `mirai:"label=For a frame slot of the GPU"`,
pacing_ms:f32 `mirai:"label=For the frame limit or VSync"`,
between_ms:f32 `mirai:"label=From its end to the start of the next"`,
- gpu_ms:f32 `mirai:"label=Of the last frame the GPU finished"`,
+ gpu_ms:f32 `mirai:"label=Of its own submissions"`,
+ gpu_measured:bool `mirai:"label=Every submission of the frame gave back its GPU times; without them gpu_ms and gpu are partial"`,
bound:Profile_Bound `mirai:"label=What it waited for"`,
workers_busy_ms:f32,
jobs:int,
zones:[]Api_Profile_Tree `mirai:"label=Of the main thread by start"`,
hidden_zones:int `mirai:"label=Deeper or shorter than asked or past the most listed"`,
gpu:[]Api_Profile_Pass `mirai:"label=The passes that took the longest"`,
+ memory:Api_Profile_Frame_Memory `mirai:"optional,label=At its end, in MB, of a capture with memory"`,
}
Api_Profile_Frames :: struct {
id:int,
@@ -295,7 +313,7 @@ api_profile_capture :: proc(s:^Session,call:^api.Call) {
profile_collect(s)
warmup,settled:=0,true
if p.advance && s.profiles.recording==0 {warmup,settled=profile_settle(s,p.dt)}
- c,error:=profile_begin(s,p.frames,base.text_get(p.label[:]))
+ c,error:=profile_begin(s,p.frames,base.text_get(p.label[:]),p.memory)
if c==nil {api.call_fail(call,api.SERVER_ERROR,error);return}
c.warmup,c.unsettled=warmup,!settled
if !p.advance {
@@ -303,6 +321,8 @@ api_profile_capture :: proc(s:^Session,call:^api.Call) {
return
}
api_frames(s,p.frames,p.dt)
+ // The GPU times of the last frames come back in the frames after them.
+ for late:=0;s.app.profiler.recording && late (out:Api_Profile_Summary)
out.notes=notes
return
}
- totals,cpu,wait,pacing,between,gpu:=make([]f64,n),make([]f64,n),make([]f64,n),make([]f64,n),make([]f64,n),make([]f64,n)
+ totals,cpu,wait,pacing,between:=make([]f64,n),make([]f64,n),make([]f64,n),make([]f64,n),make([]f64,n)
for f,i in c.frames {
totals[i],cpu[i],wait[i]=profile_frame_ms(f),profile_frame_cpu_ms(f),f64(f.wait_ms)
- pacing[i],between[i],gpu[i]=f64(f.pacing_ns)/1e6,f64(f.between_ns)/1e6,f64(f.gpu_ms)
+ pacing[i],between[i]=f64(f.pacing_ns)/1e6,f64(f.between_ns)/1e6
switch profile_frame_bound(f) {
case .Cpu: out.frame.bound.cpu+=1
case .Gpu: out.frame.bound.gpu+=1
@@ -377,10 +397,12 @@ profile_summary :: proc(c:^Profile_Capture,top:int) -> (out:Api_Profile_Summary)
if spread.mean>0 {out.frame.fps=profile_ms(1000/spread.mean)}
out.frame.cpu_ms,out.frame.wait_ms=profile_ms(profile_spread(cpu).mean),profile_ms(profile_spread(wait).mean)
out.frame.pacing_ms,out.frame.between_ms=profile_ms(profile_spread(pacing).mean),profile_ms(profile_spread(between).mean)
- out.frame.gpu_ms=profile_ms(profile_spread(gpu).mean)
+ gpu:=profile_gpu_ms(c)
+ out.frame.gpu_ms,out.frame.gpu_frames=profile_ms(profile_spread(gpu).mean),len(gpu)
for t in totals {if t>2*spread.p50 {out.frame.spikes+=1}}
out.frame.worst=profile_worst(c,min(3,n))
out.presentation=profile_presentation(c,spread.mean*f64(n))
+ if c.memory {out.memory=profile_memory(c)}
aggregates:=profile_aggregate(c)
parts:=make([dynamic]Api_Profile_Stat)
@@ -527,6 +549,9 @@ profile_notes :: proc(c:^Profile_Capture,out:Api_Profile_Summary) -> []string {
append(¬es,fmt.tprintf("%d of %d frames wait for the GPU (wait_ms): CPU savings will not shorten them; the gpu passes say where the GPU goes",out.frame.bound.gpu,out.frame.count))
if k.vsync {append(¬es,"vsync is on: the wait for a frame slot includes the display; with VSync off (settings.set) it is only the GPU")}
}
+ drawn:=0
+ for f in c.frames {if f.drawn {drawn+=1}}
+ if k.backend!="" && out.frame.gpu_frames0 {append(¬es,fmt.tprintf("%d frames took more than twice the median: profile.frames shows the worst with their zones",out.frame.spikes))}
if c.lost>0 {append(¬es,fmt.tprintf("%d zones were lost: record fewer frames for an exact count",c.lost))}
@@ -557,11 +582,26 @@ api_profile_frames :: proc(s:^Session,call:^api.Call) {
api.call_result(call,Api_Profile_Frames)^=out
}
+profile_mb :: proc(bytes:i64) -> f32 {return f32(math.round(f64(bytes)/(1<<20)*100)/100)}
+
+profile_memory :: proc(c:^Profile_Capture) -> (out:Api_Profile_Memory) {
+ if len(c.frames)==0 {return}
+ first,last:=c.frames[0].memory,c.frames[len(c.frames)-1].memory
+ peak:i64
+ for f in c.frames {peak=max(peak,f.memory.world)}
+ out.world_mb,out.world_peak_mb,out.world_rise_mb=profile_mb(last.world),profile_mb(peak),profile_mb(last.world-first.world)
+ out.private_mb,out.private_rise_mb=profile_mb(i64(last.process.private)),profile_mb(i64(last.process.private)-i64(first.process.private))
+ out.resident_mb,out.gpu_mb=profile_mb(i64(last.process.resident)),profile_mb(i64(last.gpu))
+ return
+}
+
profile_frame_out :: proc(c:^Profile_Capture,index,depth:int,min_ms:f64) -> (out:Api_Profile_Frame) {
f:=c.frames[index]
out.index=index
out.ms,out.cpu_ms,out.wait_ms=profile_ms(profile_frame_ms(f)),profile_ms(profile_frame_cpu_ms(f)),profile_ms(f64(f.wait_ms))
out.pacing_ms,out.between_ms,out.gpu_ms=profile_ms(f64(f.pacing_ns)/1e6),profile_ms(f64(f.between_ns)/1e6),profile_ms(f64(f.gpu_ms))
+ out.gpu_measured=f.gpu_measured
+ if c.memory {out.memory={profile_mb(f.memory.world),profile_mb(i64(f.memory.process.private)),profile_mb(i64(f.memory.gpu))}}
out.bound=profile_frame_bound(f)
out.workers_busy_ms,out.jobs=profile_ms(f64(f.worker_ns)/1e6),f.jobs
zones:=make([dynamic]Api_Profile_Tree)
@@ -572,7 +612,7 @@ profile_frame_out :: proc(c:^Profile_Capture,index,depth:int,min_ms:f64) -> (out
}
out.zones=zones[:]
passes:=make([dynamic]Api_Profile_Pass)
- for pass in c.passes[f.pass_first:][:f.pass_count] {append(&passes,Api_Profile_Pass{c.pass_names[pass.name],profile_ms(f64(pass.ms))})}
+ for pass in c.passes[f.pass_first:][:f.pass_count] {append(&passes,Api_Profile_Pass{c.pass_names[pass.name],profile_ms(f64(pass.start_ns-f.start_ns)/1e6),profile_ms(f64(pass.ns)/1e6)})}
slice.sort_by(passes[:],proc(a,b:Api_Profile_Pass) -> bool {return a.ms>b.ms})
out.gpu=passes[:min(len(passes),8)]
return
@@ -688,7 +728,7 @@ profile_compare :: proc(a,b:^Profile_Capture,top:int) -> (out:Api_Profile_Compar
fa,fb:=profile_spread(frame_values(a,0)),profile_spread(frame_values(b,0))
out.mean_ms,out.p95_ms=delta(fa.mean,fb.mean),delta(fa.p95,fb.p95)
out.cpu_ms=delta(profile_spread(frame_values(a,1)).mean,profile_spread(frame_values(b,1)).mean)
- out.gpu_ms=delta(profile_spread(frame_values(a,2)).mean,profile_spread(frame_values(b,2)).mean)
+ out.gpu_ms=delta(profile_spread(profile_gpu_ms(a)).mean,profile_spread(profile_gpu_ms(b)).mean)
ma,mb:=means(a),means(b)
changes:=make([dynamic]Api_Profile_Change)
@@ -735,7 +775,6 @@ frame_values :: proc(c:^Profile_Capture,which:int) -> []f64 {
switch which {
case 0: values[i]=profile_frame_ms(f)
case 1: values[i]=profile_frame_cpu_ms(f)
- case 2: values[i]=f64(f.gpu_ms)
}
}
return values
@@ -811,7 +850,8 @@ api_profile_export :: proc(s:^Session,call:^api.Call) {
}
// The capture in the Trace Event Format: a complete event per zone, a thread
-// per ring, and counters with the time of each frame and of the GPU.
+// per ring, one per GPU pass where it ran, and counters with the time of
+// each frame and of the GPU.
profile_trace :: proc(c:^Profile_Capture) -> (text:string,events:int) {
b:=strings.builder_make(context.temp_allocator)
strings.write_string(&b,`{"displayTimeUnit":"ms","traceEvents":[`)
@@ -826,12 +866,30 @@ profile_trace :: proc(c:^Profile_Capture) -> (text:string,events:int) {
fmt.sbprintf(&b,`{{"name":"thread_name","ph":"M","pid":1,"tid":%d,"args":{{"name":"%s"}}}}`,thread,thread==0?"main":fmt.tprintf("worker %d",thread))
events+=1
}
+ gpu_thread:=max(c.threads,1)
+ if len(c.passes)>0 {
+ event(&b,&first)
+ fmt.sbprintf(&b,`{{"name":"thread_name","ph":"M","pid":1,"tid":%d,"args":{{"name":"GPU"}}}}`,gpu_thread)
+ events+=1
+ }
+ for pass in c.passes {
+ event(&b,&first)
+ strings.write_string(&b,`{"name":`)
+ strings.write_string(&b,serial.text_quote(c.pass_names[pass.name]))
+ fmt.sbprintf(&b,`,"ph":"X","pid":1,"tid":%d,"ts":%.3f,"dur":%.3f}}`,gpu_thread,f64(pass.start_ns)/1e3,f64(pass.ns)/1e3)
+ events+=1
+ }
for f,i in c.frames {
event(&b,&first)
fmt.sbprintf(&b,`{{"name":"frame %d","ph":"X","pid":1,"tid":0,"ts":%.3f,"dur":%.3f}}`,i,f64(f.start_ns)/1e3,f64(f.ns)/1e3)
event(&b,&first)
fmt.sbprintf(&b,`{{"name":"ms","ph":"C","pid":1,"ts":%.3f,"args":{{"frame":%.3f,"gpu":%.3f,"wait":%.3f}}}}`,f64(f.start_ns)/1e3,profile_frame_ms(f),f64(f.gpu_ms),f64(f.wait_ms))
events+=2
+ if c.memory {
+ event(&b,&first)
+ fmt.sbprintf(&b,`{{"name":"MB","ph":"C","pid":1,"ts":%.3f,"args":{{"world":%.2f,"private":%.2f,"gpu":%.2f}}}}`,f64(f.start_ns)/1e3,profile_mb(f.memory.world),profile_mb(i64(f.memory.process.private)),profile_mb(i64(f.memory.gpu)))
+ events+=1
+ }
}
for zone in c.zones {
event(&b,&first)
diff --git a/editor/profile.odin b/editor/profile.odin
index 3e7cd50db..6a611b5ae 100644
--- a/editor/profile.odin
+++ b/editor/profile.odin
@@ -22,7 +22,7 @@ import "mirai:std/jobs"
PROFILE_CAPTURES :: 8
PROFILE_DEPTH_MAX :: 64
// The zones of the frame itself, children of "frame" on the main thread.
-PROFILE_PARTS :: [?]string{"platform","watch","game","editor","audio","render","pacing"}
+PROFILE_PARTS :: [?]string{"platform","watch","game","editor","audio","render","pacing","memory"}
// A GPU that idled runs its first frames at a lower clock, in steps of a few
// hundred ms, and lowers it again after a second or two without frames: a
@@ -61,7 +61,8 @@ Profile_Frame_Record :: struct {
start_ns,ns:i64, // the frame zone, since the first frame began
between_ns:i64, // from its end to the start of the next one: what runs between frames
pacing_ns:i64,
- wait_ms,gpu_ms:f32, // the wait for a frame slot, and the last frame the GPU finished
+ wait_ms,gpu_ms:f32, // the wait for a frame slot, and the sum of its own GPU passes
+ gpu_measured:bool, // every submission of the frame gave back its passes
render_prepare_ms,render_record_ms,render_end_ms:f32,
drawn:bool,
generated:bool, // it drew an image shown before its own
@@ -72,6 +73,7 @@ Profile_Frame_Record :: struct {
pass_first,pass_count:int,
worker_ns:i64, // time of the other threads in jobs
jobs:int,
+ memory:host.Profile_Memory, // at its end, of a capture with memory
}
Profile_Zone_Record :: struct {
@@ -79,7 +81,10 @@ Profile_Zone_Record :: struct {
start_ns,ns,self_ns:i64,
}
-Profile_Pass_Record :: struct {name:int,ms:f32}
+Profile_Pass_Record :: struct {
+ name:int,
+ start_ns,ns:i64, // where it ran on the GPU, on the clock of the zones
+}
Profile_Capture :: struct {
arena:vmem.Arena,
@@ -87,6 +92,7 @@ Profile_Capture :: struct {
label:string,
state:Profile_State,
requested:int,
+ memory:bool, // it sampled the memory at the end of each frame
conditions:Profile_Conditions,
frames:[]Profile_Frame_Record,
zones:[]Profile_Zone_Record, // the main thread frame by frame, then the other threads
@@ -133,7 +139,7 @@ profile_find :: proc(s:^Session,id:int) -> ^Profile_Capture {
// Starts recording frames into a new capture, which replaces the oldest when
// all are taken. Fails while another records.
-profile_begin :: proc(s:^Session,frames:int,label:string) -> (c:^Profile_Capture,error:string) {
+profile_begin :: proc(s:^Session,frames:int,label:string,memory:=false) -> (c:^Profile_Capture,error:string) {
profile_collect(s)
ps:=&s.profiles
if ps.recording!=0 {return nil,fmt.tprintf("Capture %d is still recording; profile.stop ends it",ps.recording)}
@@ -145,11 +151,11 @@ profile_begin :: proc(s:^Session,frames:int,label:string) -> (c:^Profile_Capture
if vmem.arena_init_growing(&c.arena)!=nil {return nil,"No memory for a capture"}
ps.next_id+=1
c.id=ps.next_id
- c.requested=frames
+ c.requested,c.memory=frames,memory
context.allocator=vmem.arena_allocator(&c.arena)
c.label=strings.clone(label)
c.conditions=profile_conditions(s)
- if !host.profile_start(s.app,frames) {
+ if !host.profile_start(s.app,frames,memory) {
profile_capture_free(c)
return nil,"The recorder could not reserve its memory"
}
@@ -280,19 +286,20 @@ profile_build :: proc(c:^Profile_Capture,recording:host.Profile_Recording,app:^h
append(&pass_names,strings.clone(host.profile_pass_name(app,pass.name)))
pass_ids[pass.name]=index
}
- c.passes[i]={index,pass.ms}
+ c.passes[i]={index,pass.start_ns-epoch,max(pass.end_ns-pass.start_ns,0)}
}
c.pass_names=pass_names[:]
for frame,i in recording.frames {
// The size the scene was drawn at is known once a frame drew.
if c.conditions.render=={} && frame.render_width>0 {c.conditions.render={int(frame.render_width),int(frame.render_height)}}
record:=&c.frames[i]
- record.wait_ms,record.gpu_ms=frame.render_wait_ms,frame.gpu_ms
+ record.wait_ms,record.gpu_ms,record.gpu_measured=frame.render_wait_ms,frame.gpu_ms,host.profile_gpu_measured(frame)
record.render_prepare_ms,record.render_record_ms,record.render_end_ms=frame.render_prepare_ms,frame.render_record_ms,frame.render_end_ms
record.drawn=frame.drawn
record.generated,record.presented,record.intervals=frame.generated,int(frame.presented),int(frame.intervals)
record.interval_total_ms,record.interval_square,record.latency_ms=frame.interval_total_ms,frame.interval_square,frame.latency_ms
record.pass_first,record.pass_count=frame.pass_first,frame.pass_count
+ record.memory=frame.memory
}
// A manual editor waits for the next request between frames: that is not part of a frame.
if !c.conditions.manual {
@@ -439,13 +446,29 @@ profile_is_part :: proc(name:string) -> bool {
return false
}
-// The per frame time of each pass of the GPU.
+// The time of each pass of the GPU in each frame whose GPU times came back.
profile_passes_by_name :: proc(c:^Profile_Capture,allocator:=context.temp_allocator) -> [][]f64 {
context.allocator=allocator
+ measured:=profile_gpu_frames(c)
values:=make([][]f64,len(c.pass_names))
- for &v in values {v=make([]f64,len(c.frames))}
- for frame,i in c.frames {
- for pass in c.passes[frame.pass_first:][:frame.pass_count] {values[pass.name][i]+=f64(pass.ms)}
+ for &v in values {v=make([]f64,measured)}
+ i:=0
+ for frame in c.frames {
+ if !frame.gpu_measured {continue}
+ for pass in c.passes[frame.pass_first:][:frame.pass_count] {values[pass.name][i]+=f64(pass.ns)/1e6}
+ i+=1
}
return values
}
+
+profile_gpu_frames :: proc(c:^Profile_Capture) -> (measured:int) {
+ for frame in c.frames {if frame.gpu_measured {measured+=1}}
+ return
+}
+
+// The GPU time of each frame whose GPU times came back.
+profile_gpu_ms :: proc(c:^Profile_Capture,allocator:=context.temp_allocator) -> []f64 {
+ values:=make([dynamic]f64,0,len(c.frames),allocator)
+ for frame in c.frames {if frame.gpu_measured {append(&values,f64(frame.gpu_ms))}}
+ return values[:]
+}
diff --git a/editor/profile_test.odin b/editor/profile_test.odin
index 28130f6ca..4b215ff52 100644
--- a/editor/profile_test.odin
+++ b/editor/profile_test.odin
@@ -39,8 +39,9 @@ recording_fixture :: proc(a_ms:i64) -> host.Profile_Recording {
)
}
frames:=make([]host.Profile_Frame,2,context.temp_allocator)
- frames[0]={number=5,drawn=true,render_wait_ms=0.5,gpu_ms=3}
- frames[1]={number=6,drawn=true,render_wait_ms=0.5,gpu_ms=3}
+ // The second submitted twice and only one came back.
+ frames[0]={number=5,drawn=true,render_wait_ms=0.5,gpu_ms=3,device_first=1,device_end=2,gpu_submissions=1}
+ frames[1]={number=6,drawn=true,render_wait_ms=0.5,gpu_ms=1,device_first=2,device_end=4,gpu_submissions=1}
return {frames=frames,zones=zones[:],threads=2,complete=true}
}
@@ -102,6 +103,8 @@ the_summary_ranks_zones_by_their_own_time_and_reads_what_bounds_the_frames :: pr
for part in summary.parts {parts[part.name]=true}
testing.expect(t,parts["editor"] && parts["pacing"] && parts["other"] && parts["between"],"the parts of the frame, what they leave and what runs between frames")
testing.expect_value(t,summary.frame.bound.cpu,2)
+ testing.expect_value(t,summary.frame.gpu_frames,1)
+ testing.expect_value(t,summary.frame.gpu_ms,3.0) // the partial frame is left out
testing.expect_value(t,summary.workers.threads,1)
testing.expect_value(t,summary.workers.busy_ms,2.0)
testing.expect(t,len(summary.notes)>0,"two frames are too few for percentiles")
diff --git a/host/frame.odin b/host/frame.odin
index 7bebbf916..19b5f2472 100644
--- a/host/frame.odin
+++ b/host/frame.odin
@@ -255,6 +255,7 @@ app_game_frame :: proc(app:^App,world:rawptr,phases:=ALL_PHASES,step:=false,dt:=
defer app.stats.game_ms=f32(time.duration_milliseconds(time.tick_since(started)))
zone:=profile_part(app,"game")
defer base.profile_end(zone)
+ app.profiler.memory_world=world
loop:=core.Loop.Game
frame:=platform.input_frame(app.platform)
ref:=app_world_ref(app,world)
@@ -417,6 +418,7 @@ app_editor_frame :: proc(app:^App,world,editor:rawptr,played:=false) {
started:=time.tick_now()
defer app.stats.editor_ms=f32(time.duration_milliseconds(time.tick_since(started)))
zone:=profile_part(app,"editor")
+ if !played && app.profiler.memory_world==nil {app.profiler.memory_world=world}
defer base.profile_end(zone)
loop:=core.Loop.Editor
if played {
diff --git a/host/profile.odin b/host/profile.odin
index 34c6ddce5..317ac728d 100644
--- a/host/profile.odin
+++ b/host/profile.odin
@@ -2,6 +2,8 @@ package host
import "base:runtime"
import "core:time"
+import "mirai:core"
+import "mirai:platform"
import render "mirai:render"
import "mirai:rhi"
import "mirai:std/base"
@@ -11,10 +13,10 @@ import "mirai:std/jobs"
// methods of the editor): on the main thread a zone for the frame and one for
// each of its parts, and one for each function of the loops, which the world
// opens with profile_step_begin; on the ring of each worker of the job
-// system its jobs; and per frame what the
-// zones do not carry, the times of the
-// renderer and of the GPU. Rings are drained at the end of every frame, so a
-// ring only has to hold one frame. While nothing records a zone costs a
+// system its jobs; and per frame what the zones do not carry, the times of
+// the renderer and the GPU passes of every submission of the frame, which
+// come back rhi.MAX_FRAMES_IN_FLIGHT submissions later. Rings are drained at
+// the end of every frame, so a ring only has to hold one frame. While nothing records a zone costs a
// branch and the GPU reports only its whole frame. The first profile_start
// reserves the memory; a recording allocates nothing. Whoever reads the zones
// as they happen (a profiler plugin) asks for them every frame with
@@ -27,6 +29,7 @@ PROFILE_PASSES :: 1<<17 // GPU pass times of a whole recording
PROFILE_PASS_NAMES :: 128 // the last one names every pass that did not fit
PROFILE_PASS_NAME_BYTES :: 32
PROFILE_MAIN :: jobs.OWNER // the ring of the main thread, worker 0 of the job system
+PROFILE_GPU_LATE :: rhi.MAX_FRAMES_IN_FLIGHT+2 // frames a recording runs past its last one for the GPU times of that one
Profile_Frame :: struct {
number:u32, // the frame of base.Profile that the zones of this frame carry
@@ -35,7 +38,9 @@ Profile_Frame :: struct {
render_wait_ms:f32, // the wait for a frame slot of the GPU (and for the display with vsync)
render_record_ms:f32,
render_end_ms:f32,
- gpu_ms:f32, // the last frame the GPU finished
+ gpu_ms:f32, // the sum of its own passes
+ device_first,device_end:u64, // the rhi frames it submitted, [first,end)
+ gpu_submissions:u32, // of them, those whose passes came back
render_width,render_height:u32,
generated:bool, // it drew an image shown before its own (frame generation)
presented:u32, // images given to the display since the frame before
@@ -43,11 +48,26 @@ Profile_Frame :: struct {
interval_total_ms,interval_square:f64,
latency_ms:f32, // from the start of the last frame shown to its image going to the display
pass_first,pass_count:int,
+ memory:Profile_Memory, // of a recording with memory
+}
+
+// The memory at the end of a frame, in bytes. world: what the tables and
+// storages of the World that ran last in the frame hold (the game loop's,
+// else the editor's), as core.world_memory measures it.
+Profile_Memory :: struct {
+ world:i64,
+ process:platform.Process_Memory,
+ gpu:u64, // of the device, as its driver says
}
Profile_Pass :: struct {
name:int, // into the names of the pass of the Profiler
- ms:f32,
+ start_ns,end_ns:i64, // on the clock of the zones
+}
+
+// Whether every submission of the frame gave back its GPU passes.
+profile_gpu_measured :: proc "contextless" (f:Profile_Frame) -> bool {
+ return f.device_end>f.device_first && u64(f.gpu_submissions)==f.device_end-f.device_first
}
Profiler :: struct {
@@ -55,6 +75,9 @@ Profiler :: struct {
rings_ready:bool, // the base.Profile rings, which profile_request needs without the recording buffers
reserved:bool, // the recording buffers below
recording:bool,
+ memory:bool, // the recording samples the memory at the end of each frame, in the zone memory
+ memory_world:rawptr, // the World of the frame that ran last
+ late:int, // >0: the frames asked for were recorded and the recording waits for the GPU times of the last ones, this many frames at most
requested:u8, // frames profile_request keeps the zones and the GPU passes on
wanted:int, // frames the recording ends after
frames:[]Profile_Frame,
@@ -65,6 +88,8 @@ Profiler :: struct {
cursors:[]u64, // per ring: the next zone to drain
passes:[]Profile_Pass,
pass_count:int,
+ gpu_next:int, // the first frame that may still get GPU passes
+ device_first:u64, // rhi.frame_number when the frame being recorded began
pass_names:[][PROFILE_PASS_NAME_BYTES]u8, // the GPU reuses the memory of its names every frame
pass_name_lengths:[]u8,
pass_name_count:int,
@@ -83,14 +108,16 @@ Profile_Recording :: struct {
complete:bool, // it reached the frames asked for
}
-// Starts recording the next frames, at most PROFILE_FRAMES_MAX. False while
-// another recording runs, or when the memory cannot be reserved.
-profile_start :: proc(app:^App,frames:int) -> bool {
+// Starts recording the next frames, at most PROFILE_FRAMES_MAX, and with
+// memory what they hold at their end. False while another recording runs,
+// or when the memory cannot be reserved.
+profile_start :: proc(app:^App,frames:int,memory:=false) -> bool {
p:=&app.profiler
if p.recording || frames<=0 {return false}
if !p.reserved && !profile_reserve(app) {return false}
p.wanted=min(frames,PROFILE_FRAMES_MAX)
- p.frame_count,p.zone_count,p.pass_count,p.lost=0,0,0,0
+ p.memory=memory
+ p.frame_count,p.zone_count,p.pass_count,p.lost,p.gpu_next,p.late=0,0,0,0,0,0
p.frame_zone={}
if app.device!=nil {p.presented=rhi.present_stats(app.device)}
out:[0]base.Profile_Zone
@@ -105,7 +132,7 @@ profile_stop :: proc(app:^App) {
p:=&app.profiler
if !p.recording {return}
base.profile_set_enabled(&p.profile,false)
- p.recording=false
+ p.recording,p.late=false,0
}
profile_recording :: proc(app:^App) -> Profile_Recording {
@@ -129,7 +156,7 @@ profile_request :: proc(app:^App) -> bool {
// Whether the zones and the GPU passes are being recorded.
profile_active :: proc "contextless" (app:^App) -> bool {
p:=&app.profiler
- return p.rings_ready && (p.recording || p.requested>0)
+ return p.rings_ready && ((p.recording && p.late==0) || p.requested>0)
}
// The rings: one per thread, the main one first.
@@ -181,7 +208,9 @@ profile_frame_open :: proc(app:^App) {
p:=&app.profiler
active:=profile_active(app)
if p.rings_ready {base.profile_set_enabled(&p.profile,active)}
+ p.memory_world=nil
if !active {return}
+ if app.device!=nil {p.device_first=rhi.frame_number(app.device)}
base.profile_frame(&p.profile)
p.frame_zone=base.profile_begin(&p.profile,PROFILE_MAIN,"frame")
}
@@ -205,13 +234,23 @@ profile_frame_end :: proc(app:^App,drawn:bool) {
load_profile_frame(app,drawn)
p:=&app.profiler
opened:=p.frame_zone.profile!=nil
+ sample:Profile_Memory
+ if opened && p.recording && p.late==0 && p.memory {
+ zone:=profile_part(app,"memory")
+ sample=profile_memory_sample(app)
+ base.profile_end(zone)
+ }
if opened {profile_frame_close(app)}
if p.requested>0 {p.requested-=1}
- if !p.recording {return}
- if opened && p.frame_count=len(p.passes) {break}
- p.passes[p.pass_count]={profile_pass_intern(p,timing.name),timing.ms}
- p.pass_count+=1
- }
}
}
- frame.pass_count=p.pass_count-frame.pass_first
p.frame_count+=1
}
+ if r:=app.renderer;r!=nil {
+ epoch:=profile_epoch_ns(app)
+ for submission in render.renderer_gpu_submissions(r) {profile_gpu_add(p,submission.frame,submission.timings,epoch)}
+ render.renderer_gpu_clear(r)
+ }
for &cursor,thread in p.cursors {
+ if p.late>0 {
+ out:[0]base.Profile_Zone
+ _,cursor,_=base.profile_read_since(&p.profile,thread,0,out[:])
+ continue
+ }
count,next,lost:=base.profile_read_since(&p.profile,thread,cursor,p.zones[p.zone_count:])
p.zone_count+=count
p.lost+=lost
cursor=next
}
- if p.frame_count>=p.wanted {profile_stop(app)}
+ if p.frame_countf.device_first && !profile_gpu_measured(f) {waiting=true;break}
+ }
+ }
+ if !waiting || p.late>=PROFILE_GPU_LATE {profile_stop(app);return}
+ p.late+=1
+}
+
+@(private)
+profile_memory_sample :: proc(app:^App) -> (m:Profile_Memory) {
+ if world:=app.profiler.memory_world;world!=nil && app.info!=nil {
+ m.world=i64(core.world_memory(app.info,world))
+ }
+ m.process=platform.process_memory()
+ if app.device!=nil {m.gpu,_=rhi.device_memory(app.device)}
+ return
+}
+
+// Gives the GPU timings of the rhi frame to the recorded frame that
+// submitted it. Batches come in the order they were submitted, so the passes
+// of a frame stay together; those of a submission between frames, or of
+// one before the recording, belong to no frame and are left out.
+profile_gpu_add :: proc(p:^Profiler,frame:u64,timings:[]rhi.Gpu_Timing,epoch_ns:i64) {
+ for p.gpu_next=f.device_end {p.gpu_next+=1;continue}
+ if f.gpu_submissions==0 {f.pass_first=p.pass_count}
+ for timing in timings {
+ if p.pass_count>=len(p.passes) {break}
+ p.passes[p.pass_count]={profile_pass_intern(p,timing.name),timing.start_ns-epoch_ns,timing.end_ns-epoch_ns}
+ p.pass_count+=1
+ f.gpu_ms+=timing.ms
+ }
+ f.pass_count=p.pass_count-f.pass_first
+ f.gpu_submissions+=1
+ return
+ }
}
@(private)
diff --git a/host/profile_gpu_test.odin b/host/profile_gpu_test.odin
new file mode 100644
index 000000000..ebf910f15
--- /dev/null
+++ b/host/profile_gpu_test.odin
@@ -0,0 +1,42 @@
+package host
+
+import "core:testing"
+import render "mirai:render"
+import "mirai:rhi"
+import "mirai:rhi/shared_device"
+
+// A frame that submits twice (an offscreen capture, then its window) gets
+// the GPU passes of both submissions, though they come back in later frames.
+@(test)
+a_recorded_frame_keeps_the_gpu_passes_of_every_submission :: proc(t: ^testing.T) {
+ shared_device.hold(t)
+ app, error := app_create({gpu = true, gpu_validation = true, window_desc = {size = {64, 48}}, fixed_dt = 1.0 / 60, threads = 1})
+ if app == nil {
+ testing.expectf(t, rhi.gpu_skip_allowed(), "no application with a GPU: %v (set MIRAI_ALLOW_GPU_SKIP=1 to skip)", error)
+ return
+ }
+ defer app_destroy(app)
+ FRAMES :: 4
+ if !testing.expect(t, profile_start(app, FRAMES)) {return}
+ for _ in 0 ..< FRAMES + PROFILE_GPU_LATE {
+ if !app.profiler.recording {break}
+ if !testing.expect(t, app_frame_begin(app)) {return}
+ if app.profiler.late == 0 {testing.expect(t, render.renderer_frame(app.renderer, {offscreen = true, ui_only = true, time = app.time}), app.renderer.error)}
+ app_frame_end(app)
+ }
+ recording := profile_recording(app)
+ testing.expect(t, recording.complete, "the recording waited for the GPU times of its last frame")
+ testing.expect_value(t, len(recording.frames), FRAMES)
+ for frame, i in recording.frames {
+ testing.expectf(t, frame.drawn, "frame %d drew", i)
+ testing.expect_value(t, frame.device_end - frame.device_first, 2)
+ testing.expectf(t, profile_gpu_measured(frame), "frame %d got %d of its 2 submissions", i, frame.gpu_submissions)
+ total: f64
+ for pass in recording.passes[frame.pass_first:][:frame.pass_count] {
+ testing.expectf(t, pass.end_ns >= pass.start_ns, "frame %d: a pass ends before it starts", i)
+ total += f64(pass.end_ns - pass.start_ns) / 1e6
+ }
+ testing.expectf(t, abs(total - f64(frame.gpu_ms)) < 0.01, "frame %d: gpu_ms %.3f is not the sum of its passes %.3f", i, frame.gpu_ms, total)
+ }
+ testing.expectf(t, rhi.device_validation_errors(app.device) == 0, "validation: %s", rhi.device_validation_message(app.device))
+}
diff --git a/host/profile_test.odin b/host/profile_test.odin
index ebbdf97e3..afd346974 100644
--- a/host/profile_test.odin
+++ b/host/profile_test.odin
@@ -48,3 +48,30 @@ a_recording_adds_its_buffers_to_ready_rings :: proc(t:^testing.T) {
testing.expect_value(t, len(app.profiler.passes), PROFILE_PASSES)
testing.expect_value(t, len(app.profiler.cursors), 1)
}
+
+// Memory is sampled only by a recording that asks for it, inside the frame:
+// its zone memory is a part of the frame, not time between frames.
+@(test)
+a_recording_samples_the_memory_only_when_asked_inside_the_frame :: proc(t:^testing.T) {
+ app: App
+ app.allocator = context.allocator
+ defer profile_release(&app)
+ for memory in ([]bool{true, false}) {
+ if !testing.expect(t, profile_start(&app, 2, memory)) {return}
+ for _ in 0 ..< 2 {
+ profile_frame_open(&app)
+ profile_frame_end(&app, false)
+ }
+ recording := profile_recording(&app)
+ testing.expect_value(t, len(recording.frames), 2)
+ sampled := false
+ for zone in recording.zones {
+ if zone.name == "memory" {
+ sampled = true
+ testing.expect_value(t, zone.depth, u16(1))
+ }
+ }
+ testing.expect_value(t, sampled, memory)
+ testing.expect_value(t, recording.frames[1].memory.process.private > 0, memory)
+ }
+}
diff --git a/platform/process_memory.odin b/platform/process_memory.odin
new file mode 100644
index 000000000..6f2477b72
--- /dev/null
+++ b/platform/process_memory.odin
@@ -0,0 +1,9 @@
+package platform
+
+// The memory this process holds, in bytes, as its system counts it: resident,
+// the pages in physical memory (the working set, with what is shared with
+// other processes); private, what only this process uses and the system has
+// to back (Windows: the private commit; Linux: the anonymous resident pages
+// and the swapped ones; macOS: the physical footprint). Zeros when the system
+// does not say. Reading it allocates nothing.
+Process_Memory :: struct {resident,private:u64}
diff --git a/platform/process_memory_darwin.odin b/platform/process_memory_darwin.odin
new file mode 100644
index 000000000..b582afb64
--- /dev/null
+++ b/platform/process_memory_darwin.odin
@@ -0,0 +1,26 @@
+#+build darwin
+package platform
+
+import "core:sys/darwin"
+
+// TASK_VM_INFO up to phys_footprint, its first revision, as mach/task_info.h lays it out.
+@(private="file")
+Task_Vm_Info :: struct {
+ virtual_size:u64,
+ region_count,page_size:i32,
+ resident_size,resident_size_peak:u64,
+ device,device_peak,internal,internal_peak,external,external_peak:u64,
+ reusable,reusable_peak:u64,
+ purgeable_volatile_pmap,purgeable_volatile_resident,purgeable_volatile_virtual:u64,
+ compressed,compressed_peak,compressed_lifetime:u64,
+ phys_footprint:u64,
+}
+@(private="file") TASK_VM_INFO :: 22
+
+// The resident size, and the physical footprint.
+process_memory :: proc "contextless" () -> Process_Memory {
+ info:Task_Vm_Info
+ count:=u32(size_of(info)/size_of(i32))
+ if darwin.task_info(darwin.mach_task_self(),TASK_VM_INFO,darwin.task_info_t(&info),&count)!=.Success {return {}}
+ return {info.resident_size,info.phys_footprint}
+}
diff --git a/platform/process_memory_linux.odin b/platform/process_memory_linux.odin
new file mode 100644
index 000000000..d4f7de82e
--- /dev/null
+++ b/platform/process_memory_linux.odin
@@ -0,0 +1,39 @@
+#+build linux
+package platform
+
+import "core:sys/posix"
+
+// From the VmRSS, RssAnon and VmSwap lines of /proc/self/status, in kB.
+process_memory :: proc "contextless" () -> (m:Process_Memory) {
+ fd:=posix.open("/proc/self/status",{.CLOEXEC})
+ if fd<0 {return}
+ defer posix.close(fd)
+ buffer:[8192]u8
+ length:=0
+ for length0 {
+ end:=0
+ for end='0' && c<='9' {kilobytes=kilobytes*10+u64(c-'0')} else if kilobytes>0 {break}
+ }
+ switch line[:colon] {
+ case "VmRSS": m.resident=kilobytes*1024
+ case "RssAnon": anonymous=kilobytes*1024
+ case "VmSwap": swapped=kilobytes*1024
+ }
+ }
+ m.private=anonymous+swapped
+ return
+}
diff --git a/platform/process_memory_posix.odin b/platform/process_memory_posix.odin
deleted file mode 100644
index 3ed9d44e4..000000000
--- a/platform/process_memory_posix.odin
+++ /dev/null
@@ -1,24 +0,0 @@
-#+build linux, darwin
-package platform
-
-import "core:c"
-
-@(private="file")
-Rusage :: struct {
- user_time,system_time:[2]i64,
- max_rss:c.long, // kilobytes on Linux and bytes on macOS
- rest:[13]c.long,
-}
-
-foreign import libc "system:c"
-@(default_calling_convention="c",private="file")
-foreign libc {
- getrusage :: proc(who:c.int,usage:^Rusage) -> c.int ---
-}
-
-// The bytes of memory the process holds: the most it has held; 0 when the system does not say.
-process_memory_bytes :: proc "contextless" () -> u64 {
- usage:Rusage
- if getrusage(0,&usage)!=0 {return 0}
- when ODIN_OS==.Linux {return u64(usage.max_rss)*1024} else {return u64(usage.max_rss)}
-}
diff --git a/platform/process_memory_test.odin b/platform/process_memory_test.odin
new file mode 100644
index 000000000..2c2ca4bc7
--- /dev/null
+++ b/platform/process_memory_test.odin
@@ -0,0 +1,15 @@
+package platform
+
+import "core:testing"
+
+// What the system says this process holds includes memory it writes to and
+// keeps, whatever other threads allocate or free meanwhile.
+@(test)
+process_memory_counts_what_the_process_touches :: proc(t:^testing.T) {
+ block:=make([]u8,64<<20)
+ defer delete(block)
+ for i:=0;i0,"the system says how much of the process is resident")
+ testing.expectf(t,held.private>=u64(len(block)),"the private memory holds the %d bytes written: %d",len(block),held.private)
+}
diff --git a/platform/process_memory_windows.odin b/platform/process_memory_windows.odin
index 81553e56e..8b9bab14c 100644
--- a/platform/process_memory_windows.odin
+++ b/platform/process_memory_windows.odin
@@ -15,9 +15,9 @@ foreign kernel32 {
K32GetProcessMemoryInfo :: proc(process:win32.HANDLE,counters:^Process_Memory_Counters,size:u32) -> win32.BOOL ---
}
-// The bytes of memory the process holds: its working set; 0 when the system does not say.
-process_memory_bytes :: proc "contextless" () -> u64 {
+// The working set, and the private commit (pagefile).
+process_memory :: proc "contextless" () -> Process_Memory {
counters:=Process_Memory_Counters{cb=size_of(Process_Memory_Counters)}
- if !K32GetProcessMemoryInfo(win32.GetCurrentProcess(),&counters,counters.cb) {return 0}
- return u64(counters.working_set)
+ if !K32GetProcessMemoryInfo(win32.GetCurrentProcess(),&counters,counters.cb) {return {}}
+ return {u64(counters.working_set),u64(counters.pagefile)}
}
diff --git a/plugins/playtest/editor/qa.odin b/plugins/playtest/editor/qa.odin
index a771d4613..52fff658d 100644
--- a/plugins/playtest/editor/qa.odin
+++ b/plugins/playtest/editor/qa.odin
@@ -192,7 +192,7 @@ qa_arm :: proc(s:^editor.Session,r:^editor.Run,limits:Qa_Limits) -> ^Run_Qa {
q.stuck,q.fell=false,false
_,body:=editor.play_focused(w)
if problems:=host.app_world_storage(s.app,w.data,core.Problems);problems!=nil {q.serial=problems.serial}
- q.memory_base=platform.process_memory_bytes()
+ q.memory_base=platform.process_memory().private
q.memory_next=q.ran+QA_MEMORY_EVERY
if q.broken=="" {
if e:=qa_entry_next(q);e!=nil {e.kind,q.armed_at=.Monitors,q.log_count-1}
@@ -387,7 +387,7 @@ qa_tick :: proc(s:^editor.Session,r:^editor.Run) {
}
if limits.memory_mb>0 && q.ran>=q.memory_next {
q.memory_next=q.ran+QA_MEMORY_EVERY
- now:=platform.process_memory_bytes()
+ now:=platform.process_memory().private
grown:=now>q.memory_base?f32(now-q.memory_base)/(1024*1024):0
if grown>limits.memory_mb {qa_violation_add(q,{kind=.Memory,severity=.Warning,tick=tick,position=at,value=grown,limit=limits.memory_mb},true)}
}
diff --git a/plugins/profiler/editor/profiler.odin b/plugins/profiler/editor/profiler.odin
index 5fb10a824..5933073e6 100644
--- a/plugins/profiler/editor/profiler.odin
+++ b/plugins/profiler/editor/profiler.odin
@@ -2,6 +2,7 @@ package profiler_editor
import "core:fmt"
import "core:hash"
+import "mirai:editor/kit"
import "mirai:core"
import "mirai:editor"
import "mirai:host"
@@ -10,8 +11,10 @@ import "mirai:ui"
// A panel of the editor, under View > Profiler, that records frames into the
// captures of the profile.* methods and shows the last one: the time of each
-// frame, the zones of the threads and the GPU passes of the frame chosen, and
-// the zones that took most. An agent and the panel see the same captures.
+// frame, then a tab per track: the zones of the threads of the frame chosen
+// and the zones that took most; its GPU passes where they ran and the passes
+// that took most; the memory over the frames. An agent and the panel see the
+// same captures.
@(storage)
Profiler_Api :: struct {provider:editor.Api_Provider}
@@ -43,6 +46,15 @@ FRAMES_DEFAULT :: 120
ROW :: f32(16) // of a row of the timeline, in points
GRAPH :: f32(72) // height of the graph of the frames
+TABS :: [?]string{"CPU","GPU","Memory"}
+Tab :: enum int {Cpu,Gpu,Memory}
+TAB_GAP :: f32(8)
+
+Top_Pass :: struct {
+ name: int, // into the pass names of the capture
+ ms: f64, // per measured frame
+}
+
Top_Zone :: struct {
name: int, // into the names of the capture
worker: bool,
@@ -63,6 +75,10 @@ Profiler_Panel :: struct {
graph_ms: f64, // the top of the graph: above it a frame is cut and marked
top: [TOP_ZONES]Top_Zone,
top_count: int,
+ passes: [TOP_ZONES]Top_Pass,
+ pass_count: int,
+ tab: int,
+ memory_range: [3][2]f64, // of the World, the private memory and the GPU, in MB: the lowest and highest of the capture
error: [128]u8,
error_length: int,
capture: ^editor.Profile_Capture, // the one shown, for the drawings of this frame
@@ -97,13 +113,45 @@ profiler_panel :: proc(s:^editor.Session,p:^Profiler_Panel,app:^host.App) {
p.frame=clamp(int((ctx.pointer.x-r.x)/r.w*f32(len(c.frames))),0,len(c.frames)-1)
}
}
- ui.label(ctx,profiler_frame_text(p,c),ui.metric(ctx,"font_small"),ui.tone(ctx,"text"))
- rows:=f32(p.depth+p.thread_count+1)
- editor.drawing(g,ui.id(ctx,"timeline"),ui.GROW,ui.fixed(rows*(ROW+2)+ROW),timeline_draw,p)
- editor.drawing(g,ui.id(ctx,"zones"),ui.GROW,ui.fixed(f32(p.top_count)*ROW+ROW),zones_draw,p)
+ titles:=TABS
+ kit.tabs(ctx,ui.id(ctx,"tracks"),titles[:],&p.tab,ui.fixed(240),28)
+ small:=ui.metric(ctx,"font_small")
+ switch Tab(p.tab) {
+ case .Cpu: ui.label(ctx,profiler_frame_text(p,c),small,ui.tone(ctx,"text"))
+ case .Gpu: ui.label(ctx,gpu_frame_text(p,c),small,ui.tone(ctx,"text"))
+ case .Memory:
+ if c.memory {ui.label(ctx,memory_frame_text(p,c),small,ui.tone(ctx,"text"))} else {ui.label(ctx,"This capture did not sample the memory",small,ui.tone(ctx,"text_muted"))}
+ }
+ // Every tab is as tall as the tallest, the others keeping their place empty: the panel,
+ // held by its bottom, keeps its tabs under the pointer.
+ if ui.box(ctx,{width=ui.GROW,direction=.Stack}) {
+ for tab in Tab {
+ drawn:=tab==Tab(p.tab) && (tab!=.Memory || c.memory)
+ if ui.box(ctx,{width=ui.GROW,direction=.Column,gap=TAB_GAP}) {
+ for part in tab_parts(p,tab) {
+ if part.height==0 {continue}
+ if drawn {editor.drawing(g,ui.id(ctx,part.id),ui.GROW,ui.fixed(part.height),part.draw,p)} else if ui.box(ctx,{width=ui.GROW,height=ui.fixed(part.height)}) {}
+ }
+ }
+ }
+ }
}
}
+@(private="file")
+Tab_Part :: struct {id:string,height:f32,draw:editor.Drawing_Proc}
+
+// The drawings of a tab, one over the other.
+@(private="file")
+tab_parts :: proc(p:^Profiler_Panel,tab:Tab) -> [2]Tab_Part {
+ switch tab {
+ case .Cpu: return {{"timeline",f32(p.depth+p.thread_count)*(ROW+2)+ROW,timeline_draw},{"zones",f32(p.top_count)*ROW+ROW,zones_draw}}
+ case .Gpu: return {{"gpu_timeline",ROW+2+ROW,timeline_draw},{"passes",f32(p.pass_count)*ROW+ROW,passes_draw}}
+ case .Memory: return {{"memory",GRAPH,memory_draw},{}}
+ }
+ return {}
+}
+
@(private="file")
profiler_header :: proc(s:^editor.Session,p:^Profiler_Panel,app:^host.App) {
ctx:=s.gui.ctx
@@ -119,7 +167,7 @@ profiler_header :: proc(s:^editor.Session,p:^Profiler_Panel,app:^host.App) {
ui.number_field(ctx,ui.id(ctx,"frames_asked"),&p.frames,{width=ui.fixed(72),decimals=0,speed=1,has_min=true,min=2,has_max=true,max=f64(host.PROFILE_FRAMES_MAX),disabled=recording})
if ui.button(ctx,ui.id(ctx,"record"),{label="Record",variant="accent",size=ui.metric(ctx,"font_small"),disabled=recording}).clicked {
p.error_length=0
- if _,error:=editor.profile_begin(s,int(p.frames),"profiler panel");error!="" {p.error_length=copy(p.error[:],error)}
+ if _,error:=editor.profile_begin(s,int(p.frames),"profiler panel",memory=Tab(p.tab)==.Memory);error!="" {p.error_length=copy(p.error[:],error)}
}
}
}
@@ -129,13 +177,31 @@ profiler_header :: proc(s:^editor.Session,p:^Profiler_Panel,app:^host.App) {
// zones that took most, and the frame nearest the median as the one chosen.
@(private="file")
profiler_show :: proc(p:^Profiler_Panel,c:^editor.Profile_Capture) {
- p.shown,p.frame,p.workers,p.depth,p.thread_count,p.top_count=c.id,0,0,1,0,0
- frame,gpu:=make([]f64,len(c.frames),context.temp_allocator),make([]f64,len(c.frames),context.temp_allocator)
+ p.shown,p.frame,p.workers,p.depth,p.thread_count,p.top_count,p.pass_count=c.id,0,0,1,0,0,0
+ p.memory_range={{max(f64),0},{max(f64),0},{max(f64),0}}
+ for f in c.frames {
+ for value,k in memory_values(f) {p.memory_range[k]={min(p.memory_range[k][0],value),max(p.memory_range[k][1],value)}}
+ }
+ for values,name in editor.profile_passes_by_name(c) {
+ total:f64
+ for ms in values {total+=ms}
+ entry:=Top_Pass{name,total/f64(max(len(values),1))}
+ at:=p.pass_count
+ for at>0 && p.passes[at-1].ms string {
- frame,gpu:=make([]f64,len(c.frames),context.temp_allocator),make([]f64,len(c.frames),context.temp_allocator)
- for f,i in c.frames {frame[i],gpu[i]=editor.profile_frame_ms(f),f64(f.gpu_ms)}
- spread,gpu_spread:=editor.profile_spread(frame),editor.profile_spread(gpu)
+ frame:=make([]f64,len(c.frames),context.temp_allocator)
+ for f,i in c.frames {frame[i]=editor.profile_frame_ms(f)}
+ spread,gpu_spread:=editor.profile_spread(frame),editor.profile_spread(editor.profile_gpu_ms(c))
return fmt.tprintf("Capture %d · %d frames · frame %.2f ms mean, %.2f ms p95 · GPU %.2f ms · %s %s",
c.id,len(c.frames),spread.mean,spread.p95,gpu_spread.mean,c.conditions.backend,c.conditions.device)
}
@@ -184,10 +250,29 @@ profiler_frame_text :: proc(p:^Profiler_Panel,c:^editor.Profile_Capture) -> stri
if p.frame>=len(c.frames) {return ""}
f:=c.frames[p.frame]
bounds:=[editor.Profile_Bound]string{.Cpu="CPU",.Gpu="GPU",.Paced="pacing"}
- return fmt.tprintf("Frame %d · %.2f ms · CPU %.2f ms · GPU %.2f ms · waits for %s",
- p.frame+1,editor.profile_frame_ms(f),editor.profile_frame_cpu_ms(f),f.gpu_ms,bounds[editor.profile_frame_bound(f)])
+ return fmt.tprintf("Frame %d · %.2f ms · CPU %.2f ms · waits for %s",
+ p.frame+1,editor.profile_frame_ms(f),editor.profile_frame_cpu_ms(f),bounds[editor.profile_frame_bound(f)])
+}
+
+@(private="file")
+gpu_frame_text :: proc(p:^Profiler_Panel,c:^editor.Profile_Capture) -> string {
+ if p.frame>=len(c.frames) {return ""}
+ f:=c.frames[p.frame]
+ if !f.gpu_measured {return fmt.tprintf("Frame %d · GPU not measured: a submission of the frame did not come back",p.frame+1)}
+ return fmt.tprintf("Frame %d · GPU %.2f ms · %d passes",p.frame+1,f.gpu_ms,f.pass_count)
}
+@(private="file")
+memory_frame_text :: proc(p:^Profiler_Panel,c:^editor.Profile_Capture) -> string {
+ if p.frame>=len(c.frames) {return ""}
+ m:=c.frames[p.frame].memory
+ return fmt.tprintf("Frame %d · World %.1f MB · process private %.1f MB, resident %.1f MB · GPU %.1f MB",
+ p.frame+1,mb(m.world),mb(i64(m.process.private)),mb(i64(m.process.resident)),mb(i64(m.gpu)))
+}
+
+@(private="file")
+mb :: proc(bytes:i64) -> f64 {return f64(bytes)/(1<<20)}
+
// A color of its own for each name, among muted hues.
@(private="file")
zone_color :: proc(name:string) -> ui.Color {
@@ -217,6 +302,7 @@ frames_draw :: proc(ctx:^ui.Context,rect:ui.Rect,user:rawptr) {
x:=rect.x+f32(i)*step
ui.draw_rect(ctx,{x+step*0.12,rect.y+rect.h-2-h,max(step*0.76,1),h},color)
if ms>top {ui.draw_rect(ctx,{x,rect.y+2,step,3},ui.tone(ctx,"danger"))}
+ if !f.gpu_measured {continue}
gpu:=f32(min(f64(f.gpu_ms)/top,1))*(rect.h-4)
ui.draw_rect(ctx,{x,rect.y+rect.h-2-gpu,step,1.5},ui.tone(ctx,"text"))
}
@@ -227,16 +313,18 @@ frames_draw :: proc(ctx:^ui.Context,rect:ui.Rect,user:rawptr) {
ui.draw_text(ctx,text,rect.x+rect.w-ui.text_width(&ctx.font,text,ui.metric(ctx,"font_small"))-6,rect.y+6,ui.metric(ctx,"font_small"),ui.tone(ctx,"text_muted"))
}
-// The frame chosen: the zones of the main thread by depth, those of the
-// other threads, and the GPU passes one after another, on one time axis.
+// The frame chosen on one time axis, that of its CPU frame and what ran
+// after it: in the CPU tab the zones of the main thread by depth and those
+// of the other threads; in the GPU tab its passes where they ran.
@(private="file")
timeline_draw :: proc(ctx:^ui.Context,rect:ui.Rect,user:rawptr) {
p:=(^Profiler_Panel)(user)
c:=p.capture
if c==nil || p.frame>=len(c.frames) {return}
f:=c.frames[p.frame]
- gpu_ns:=i64(f64(f.gpu_ms)*1e6)
- span:=max(f.ns+f.between_ns,gpu_ns,1)
+ passes:=c.passes[f.pass_first:][:f.pass_count]
+ span:=max(f.ns+f.between_ns,1)
+ for pass in passes {span=max(span,pass.start_ns+pass.ns-f.start_ns)}
label:=f32(64)
x0:=rect.x+label
w:=rect.w-label
@@ -249,6 +337,15 @@ timeline_draw :: proc(ctx:^ui.Context,rect:ui.Rect,user:rawptr) {
if ui.text_width(&ctx.font,text,ui.metric(ctx,"font_small"))+60 {ui.draw_rect(ctx,{rect.x,top,rect.w,1},ui.color_alpha(ui.tone(ctx,"text_faint"),60))}
+ for f,i in c.frames {
+ at:=0.5 if high<=low else (memory_values(f)[k]-low)/(high-low)
+ y:=top+band-4-f32(at)*(band-8)
+ ui.draw_rect(ctx,{x0+f32(i)*step,y,max(step,1),1.5},ui.tone(ctx,"accent"))
+ }
}
+ ui.draw_rect(ctx,{x0+f32(p.frame)*step,rect.y,1,rect.h},ui.color_alpha(ui.tone(ctx,"text_faint"),120))
+}
+
+@(private="file")
+memory_values :: proc(f:editor.Profile_Frame_Record) -> [3]f64 {
+ return {mb(f.memory.world),mb(i64(f.memory.process.private)),mb(i64(f.memory.gpu))}
}
// The zones that took most per frame over the capture, the parts of the frame left out.
diff --git a/render/frame.odin b/render/frame.odin
index 954a33de1..0a00cb4f2 100644
--- a/render/frame.odin
+++ b/render/frame.odin
@@ -157,7 +157,7 @@ read_stats :: proc(r: ^Renderer, slot: int) {
r.stats.occluded_instances = stats.occluded_instances
r.stats.probes_traced = stats.probes_traced
}
- r.stats.timings = rhi.frame_timings(r.device)
+ r.stats.timings, _, _ = rhi.frame_timings(r.device)
total: f32
for t in r.stats.timings {total += t.ms}
r.stats.gpu_ms = total
@@ -457,6 +457,7 @@ renderer_frame :: proc(r:^Renderer,frame:Frame_Desc) -> bool {
}
prepared:=time.tick_now()
cmd,began:=rhi.frame_begin(d,!frame.offscreen)
+ gpu_submission_keep(r)
if !began {
set_error(r,"the device gave no frame to draw: %s",rhi.device_error(d)!=""?rhi.device_error(d):"the window is being resized or its image is not ready")
return false
@@ -1765,6 +1766,52 @@ update_stats :: proc(r: ^Renderer) {
renderer_stats :: proc(r: ^Renderer) -> ^Stats {return &r.stats}
+RENDER_GPU_SUBMISSIONS :: 8 // whose timings wait between two renderer_gpu_clear
+RENDER_GPU_TIMINGS :: 1024
+
+// The GPU timings of one submission of the device, copied out of it, which
+// reuses its own at the next frame.
+Gpu_Submission :: struct {
+ frame: u64, // the rhi.frame_number it was
+ timings: []rhi.Gpu_Timing,
+}
+
+Gpu_Submissions :: struct {
+ list: [RENDER_GPU_SUBMISSIONS]Gpu_Submission,
+ count: int,
+ timings: [RENDER_GPU_TIMINGS]rhi.Gpu_Timing,
+ names: [RENDER_GPU_TIMINGS][rhi.MAX_TIMESTAMP_NAME_BYTES]u8,
+ timing_count: int,
+ kept_end: u64, // one past the rhi frame of the last submission seen
+}
+
+// The submissions whose GPU timings came back since renderer_gpu_clear, in
+// the order they were submitted. A host frame may submit several (captures,
+// thumbnails); whoever accounts for each one takes them every frame and
+// clears them. A submission that does not fit is left out.
+renderer_gpu_submissions :: proc(r: ^Renderer) -> []Gpu_Submission {return r.submissions.list[:r.submissions.count]}
+
+renderer_gpu_clear :: proc(r: ^Renderer) {r.submissions.count, r.submissions.timing_count = 0, 0}
+
+@(private)
+gpu_submission_keep :: proc(r: ^Renderer) {
+ timings, frame, measured := rhi.frame_timings(r.device)
+ g := &r.submissions
+ // A frame_begin that fails before the device collects leaves the timings of the one before.
+ if !measured || frame < g.kept_end {return}
+ g.kept_end = frame + 1
+ if g.count >= len(g.list) || g.timing_count + len(timings) > len(g.timings) {return}
+ first := g.timing_count
+ for timing, i in timings {
+ k := first + i
+ g.timings[k] = timing
+ g.timings[k].name = string(g.names[k][:copy(g.names[k][:], timing.name)])
+ }
+ g.timing_count += len(timings)
+ g.list[g.count] = {frame, g.timings[first:g.timing_count]}
+ g.count += 1
+}
+
// Stats with the counters of the last frame, which it reads back by the time
// a later frame needs its slot: for whoever has just read an image of that
// frame (renderer_capture, view_texture_capture), so the GPU is idle.
diff --git a/render/renderer.odin b/render/renderer.odin
index 0b62d6f1f..4b7bfe0de 100644
--- a/render/renderer.odin
+++ b/render/renderer.odin
@@ -266,7 +266,7 @@ Stats :: struct {
probes_per_frame: u32,
probes_traced: u32, // in the frame two frames ago
rays_per_frame: u64,
- gpu_ms: f32,
+ gpu_ms: f32, // of the last frame the GPU finished
ev100: f32, // the main view is exposed at, before its compensation: what its meter took, as read back, or what its camera gives
timings: []rhi.Gpu_Timing,
// Time of the calling thread in the parts of the last frame, in ms.
@@ -669,6 +669,7 @@ Renderer :: struct {
pixel_density: f32, // device pixels per native window coordinate
frame: u64,
stats: Stats,
+ submissions: Gpu_Submissions,
error_buffer: [512]u8,
error: string,
problem_buffer: [1024]u8, // of Stats.problem
diff --git a/rhi/metal_device.odin b/rhi/metal_device.odin
index d580f9d25..219f29c78 100644
--- a/rhi/metal_device.odin
+++ b/rhi/metal_device.odin
@@ -103,6 +103,8 @@ Mtl_Frame :: struct {
query_bytes: [MAX_TIMESTAMPS][MAX_TIMESTAMP_NAME_BYTES]u8,
encoder_count: u32,
encoder_marks: [MAX_TIMESTAMPS]u16, // of each sampled encoder: the mark it runs after
+ number: u64, // the frame_number it committed
+ submitted: bool, // until frame_begin collects its timings
paced: bool, // the frame draws into a pair of the presenter
begun_ns: i64,
submitted_ns: i64,
@@ -238,6 +240,8 @@ Device :: struct {
timings: [MAX_TIMESTAMPS]Gpu_Timing,
timing_bytes: [MAX_TIMESTAMPS][MAX_TIMESTAMP_NAME_BYTES]u8,
timing_count: int,
+ timing_frame: u64, // the frame_number the timings measured
+ timing_measured: bool, // the timings are of a committed frame
timestamps_wanted: bool,
clock_cpu, clock_gpu: MTL.Timestamp, // sampled together when the device was made: the rate of the GPU clock
error_buffer: [512]u8,
@@ -798,7 +802,13 @@ mtl_flush_ranges :: proc(d: ^Device, f: ^Mtl_Frame) {
// ---------------------------------------------------------------- frames
-frame_timings :: proc(d: ^Device) -> []Gpu_Timing {return d.timings[:d.timing_count]}
+// The timings the last frame_begin collected and the frame_number of the
+// frame they measured, MAX_FRAMES_IN_FLIGHT before it; measured is false when
+// that slot had committed nothing since its timings were last collected, or
+// the device could not read its times.
+frame_timings :: proc(d: ^Device) -> (timings: []Gpu_Timing, frame: u64, measured: bool) {
+ return d.timings[:d.timing_count], d.timing_frame, d.timing_measured
+}
// Asks for one timing per cmd_timestamp interval in the frames that begin
// from now on; without it a frame reports only its whole GPU time.
@@ -878,8 +888,13 @@ frame_begin :: proc(d: ^Device, present := true) -> (cmd: ^Command_List, ok: boo
if d.in_frame {set_error(d, "frame_begin while a frame is being recorded: end it with frame_end first"); return nil, false}
f := &d.frames[d.slot]
d.timing_count = 0
+ d.timing_frame, d.timing_measured = f.number, false
if f.cmd != nil {
- if mtl_wait(d, f.cmd, "frame") {mtl_collect_timestamps(d, f)}
+ if mtl_wait(d, f.cmd, "frame") {
+ mtl_collect_timestamps(d, f)
+ d.timing_measured = f.submitted
+ }
+ f.submitted = false
mtl_release(f.cmd)
f.cmd = nil
}
@@ -961,6 +976,7 @@ frame_end :: proc(d: ^Device, cmd: ^Command_List, generated := false) -> bool {
}
MTL.CommandBuffer_commit(f.cmd)
f.submitted_ns = present_now_ns()
+ f.number, f.submitted = d.frame_number, true
if presented {present_count_direct(d)}
mtl_release_drawable(d)
if f.paced {
diff --git a/rhi/tests/rhi_test.odin b/rhi/tests/rhi_test.odin
index 4d5458e24..4c524dfc0 100644
--- a/rhi/tests/rhi_test.odin
+++ b/rhi/tests/rhi_test.odin
@@ -802,7 +802,11 @@ rhi_timestamps_report_ordered_nanoseconds :: proc(t: ^testing.T) {
cmd, ok := rhi.frame_begin(d, false)
if !testing.expect(t, ok) {return nil}
testing.expect(t, rhi.frame_end(d, cmd))
- return rhi.frame_timings(d)
+ timings, frame, measured := rhi.frame_timings(d)
+ // The last frame_begin collected the frame its slot submitted before it.
+ testing.expect(t, measured, "the slot had submitted a frame")
+ testing.expect_value(t, frame, rhi.frame_number(d) - 1 - rhi.MAX_FRAMES_IN_FLIGHT)
+ return timings
}
now := time.duration_nanoseconds(time.tick_diff({}, time.tick_now()))
frame := timings_of(t, d, buffer, false)
diff --git a/rhi/vulkan_device.odin b/rhi/vulkan_device.odin
index ae947e0f0..d67b347ff 100644
--- a/rhi/vulkan_device.odin
+++ b/rhi/vulkan_device.odin
@@ -128,6 +128,8 @@ Vk_Frame :: struct {
acquired: bool,
paced: bool, // the frame draws into a pair of the presenter
begun_ns: i64,
+ number: u64, // the frame_number it submitted
+ submitted: bool, // until frame_begin collects its timings
submitted_ns: i64,
marks: Vk_Marks, // where the GPU went (vulkan_marks.odin)
}
@@ -247,6 +249,8 @@ Device :: struct {
timings: [MAX_TIMESTAMPS]Gpu_Timing,
timing_bytes: [MAX_TIMESTAMPS][MAX_TIMESTAMP_NAME_BYTES]u8, // the names of timings, kept until the next ones
timing_count: int,
+ timing_frame: u64, // the frame_number the timings measured
+ timing_measured: bool, // the timings are of a submitted frame
timestamps_wanted: bool,
timestamp_bits: u32, // timestampValidBits of the queue: a GPU timestamp wraps past them
// VK_KHR or VK_EXT_calibrated_timestamps with the device and host domains; nil without them.
@@ -1168,11 +1172,13 @@ vk_collect_timestamps :: proc(d: ^Device, f: ^Vk_Frame) {
count := f.query_count
f.query_count = 0
d.timing_count = 0
+ d.timing_frame, d.timing_measured = f.number, f.submitted && f.queries != 0
+ f.submitted = false
if f.queries == 0 || count < 2 {return}
values: [MAX_TIMESTAMPS]u64
// The slot's submission already completed, so WAIT returns immediately.
result := d.dvk.GetQueryPoolResults(d.handle, f.queries, 0, count, size_of(values), &values, size_of(u64), {._64, .WAIT})
- if result != .SUCCESS {vk_lost(d, result, "vkGetQueryPoolResults"); return}
+ if result != .SUCCESS {d.timing_measured = false; vk_lost(d, result, "vkGetQueryPoolResults"); return}
gpu, now := values[count - 1], time.duration_nanoseconds(time.tick_diff({}, time.tick_now()))
if d.calibrate != nil {
infos := [2]vk.CalibratedTimestampInfoKHR{{sType = .CALIBRATED_TIMESTAMP_INFO_KHR, timeDomain = .DEVICE}, {sType = .CALIBRATED_TIMESTAMP_INFO_KHR, timeDomain = VK_HOST_TIME_DOMAIN}}
@@ -1197,7 +1203,13 @@ vk_collect_timestamps :: proc(d: ^Device, f: ^Vk_Frame) {
}
}
-frame_timings :: proc(d: ^Device) -> []Gpu_Timing {return d.timings[:d.timing_count]}
+// The timings the last frame_begin collected and the frame_number of the
+// frame they measured, MAX_FRAMES_IN_FLIGHT before it; measured is false when
+// that slot had submitted nothing since its timings were last collected, or
+// the device could not read its times.
+frame_timings :: proc(d: ^Device) -> (timings: []Gpu_Timing, frame: u64, measured: bool) {
+ return d.timings[:d.timing_count], d.timing_frame, d.timing_measured
+}
// Begins recording a frame. Without present it takes no image of the
// swapchain: the frame draws only into textures, for a capture.
@@ -1299,6 +1311,7 @@ frame_end :: proc(d: ^Device, cmd: ^Command_List, generated := false) -> bool {
f.marks.sent = submitted == .SUCCESS
ok := vk_check(d, submitted, "vkQueueSubmit2")
f.signal_value = d.timeline_value
+ f.number, f.submitted = d.frame_number, submitted == .SUCCESS
f.submitted_ns = present_now_ns()
if ok && f.acquired {
present := vk.PresentInfoKHR{