package core:prof/spall
Source

⌘K
Ctrl+K
or
/

    Overview

    Example: 
    package main

import "base:runtime"
import "core:prof/spall"
import "core:sync"

spall_ctx: spall.Context
@(thread_local) spall_buffer: spall.Buffer

foo :: proc() {
	spall.SCOPED_EVENT(&spall_ctx, &spall_buffer, #procedure)
}

main :: proc() {
	spall_ctx = spall.context_create("trace_test.spall")
	defer spall.context_destroy(&spall_ctx)

	buffer_backing := make([]u8, spall.BUFFER_DEFAULT_SIZE)
	defer delete(buffer_backing)

	spall_buffer = spall.buffer_create(buffer_backing, u32(sync.current_thread_id()))
	defer spall.buffer_destroy(&spall_ctx, &spall_buffer)

	spall.SCOPED_EVENT(&spall_ctx, &spall_buffer, #procedure)

	for i := 0; i < 9001; i += 1 {
		foo()
	}
}

// Automatic profiling of every procedure:

@(instrumentation_enter)
spall_enter :: proc "contextless" (proc_address, call_site_return_address: rawptr, loc: runtime.Source_Code_Location) {
	spall._buffer_begin(&spall_ctx, &spall_buffer, "", "", loc)
}

@(instrumentation_exit)
spall_exit :: proc "contextless" (proc_address, call_site_return_address: rawptr, loc: runtime.Source_Code_Location) {
	spall._buffer_end(&spall_ctx, &spall_buffer)
}

    Types

    Begin_Event ¶
    Source

    Begin_Event :: struct #packed {
	type:     Manual_Event_Type,
	category: u8,
	pid:      u32le,
	tid:      u32le,
	ts:       f64le,
	name_len: u8,
	args_len: u8,
}

    Buffer ¶
    Source

    Buffer :: struct {
	data: []u8,
	head: int,
	tid:  u32,
	pid:  u32,
}
    Related Procedures With Parameters
    Related Procedures With Returns

    Context ¶
    Source

    Context :: struct {
	precise_time:    bool,
	timestamp_scale: f64,
	fd:              os.Handle,
}
    Related Procedures With Parameters
    Related Procedures With Returns

    End_Event ¶
    Source

    End_Event :: struct #packed {
	type: Manual_Event_Type,
	pid:  u32le,
	tid:  u32le,
	ts:   f64le,
}

    Manual_Event_Type ¶
    Source

    Manual_Event_Type :: enum u8 {
	Invalid  = 0, 
	Begin    = 3, 
	End      = 4, 
	Instant  = 5, 
	Pad_Skip = 7, 
}

    Manual_Header ¶
    Source

    Manual_Header :: struct #packed {
	magic:           u64le,
	version:         u64le,
	timestamp_scale: f64le,
	reserved:        u64le,
}

    Pad_Skip ¶
    Source

    Pad_Skip :: struct #packed {
	type: Manual_Event_Type,
	size: u32le,
}

    Constants

    BEGIN_EVENT_MAX ¶
    Source

    BEGIN_EVENT_MAX: int : size_of(Begin_Event) + 255 + 255

    BUFFER_DEFAULT_SIZE ¶
    Source

    BUFFER_DEFAULT_SIZE: int : 0x10_0000

    MANUAL_MAGIC ¶
    Source

    MANUAL_MAGIC :: u64le(0x0BADF00D)

    Variables

    This section is empty.

    Procedures

    SCOPED_EVENT ¶
    Source

    SCOPED_EVENT :: proc(ctx: ^Context, buffer: ^Buffer, name: string, args: string = "", location := #caller_location) -> bool {…}

    buffer_create ¶
    Source

    buffer_create :: proc(data: []u8, tid: u32 = 0, pid: u32 = 0) -> (buffer: Buffer, ok: bool) #optional_ok {…}

    buffer_destroy ¶
    Source

    buffer_destroy :: proc(ctx: ^Context, buffer: ^Buffer) {…}

    buffer_flush ¶
    Source

    buffer_flush :: proc "contextless" (ctx: ^Context, buffer: ^Buffer) {…}

    context_create_with_scale ¶
    Source

    context_create_with_scale :: proc(filename: string, precise_time: bool, timestamp_scale: f64) -> (ctx: Context, ok: bool) #optional_ok {…}

    context_create_with_sleep ¶
    Source

    context_create_with_sleep :: proc(filename: string, sleep: time.Duration = 2 * time.Second) -> (ctx: Context, ok: bool) #optional_ok {…}

    context_destroy ¶
    Source

    context_destroy :: proc(ctx: ^Context) {…}

    tick_now ¶
    Source

    tick_now :: proc "contextless" () -> (ns: i64) {…}

    write ¶
    Source

    write :: proc "contextless" (fd: os.Handle, buf: []u8) -> (n: int, err: os.Error) {…}

    Procedure Groups

    context_create ¶
    Source

    Source Files

    Generation Information

    Generated with odin version dev-2025-05 (vendor "odin") Windows_amd64 @ 2025-05-08 21:12:59.932023100 +0000 UTC