Initial project import

tools/v/vlib/v2_toberemoved/profiler/runtime.v

@@ -0,0 +1,215 @@
+// Copyright (c) 2026 Alexander Medvednikov. All rights reserved.
+// Use of this source code is governed by an MIT license
+// that can be found in the LICENSE file.
+module profiler
+
+// profiler_init initializes the profiler system
+// Must be called before enabling profiling
+pub fn profiler_init() {
+	init_profiler_state()
+}
+
+// profiler_enable enables allocation tracking
+pub fn profiler_enable() {
+	if profiler_state.mu == unsafe { nil } {
+		init_profiler_state()
+	}
+	profiler_state.mu.lock()
+	defer {
+		profiler_state.mu.unlock()
+	}
+	profiler_state.enabled = true
+	// Start first frame
+	if profiler_state.frames.len == 0 {
+		profiler_state.frames << FrameData{
+			frame_num:   0
+			new_bytes:   0
+			freed_bytes: 0
+			live_bytes:  profiler_state.live_bytes
+		}
+	}
+}
+
+// profiler_disable disables allocation tracking
+pub fn profiler_disable() {
+	if profiler_state.mu == unsafe { nil } {
+		return
+	}
+	profiler_state.mu.lock()
+	defer {
+		profiler_state.mu.unlock()
+	}
+	profiler_state.enabled = false
+}
+
+// profiler_is_enabled returns whether profiling is active
+pub fn profiler_is_enabled() bool {
+	if profiler_state.mu == unsafe { nil } {
+		return false
+	}
+	profiler_state.mu.lock()
+	defer {
+		profiler_state.mu.unlock()
+	}
+	return profiler_state.enabled
+}
+
+// frame_end signals the end of a frame and collects frame data
+// Call this at the end of each game/application frame
+pub fn frame_end() {
+	if profiler_state.mu == unsafe { nil } || !profiler_state.enabled {
+		return
+	}
+
+	profiler_state.mu.lock()
+	defer {
+		profiler_state.mu.unlock()
+	}
+
+	// Finalize current frame's live bytes
+	if profiler_state.frames.len > 0 {
+		profiler_state.frames[profiler_state.frames.len - 1].live_bytes = profiler_state.live_bytes
+	}
+
+	// Increment frame counter
+	profiler_state.current_frame++
+
+	// Start new frame
+	profiler_state.frames << FrameData{
+		frame_num:   profiler_state.current_frame
+		new_bytes:   0
+		freed_bytes: 0
+		live_bytes:  profiler_state.live_bytes
+	}
+}
+
+// get_frame_count returns the current frame number
+pub fn get_frame_count() u64 {
+	if profiler_state.mu == unsafe { nil } {
+		return 0
+	}
+	profiler_state.mu.lock()
+	defer {
+		profiler_state.mu.unlock()
+	}
+	return profiler_state.current_frame
+}
+
+// get_frames returns a copy of all frame data
+pub fn get_frames() []FrameData {
+	if profiler_state.mu == unsafe { nil } {
+		return []
+	}
+	profiler_state.mu.lock()
+	defer {
+		profiler_state.mu.unlock()
+	}
+	return profiler_state.frames.clone()
+}
+
+// get_allocs returns a copy of all allocation records
+pub fn get_allocs() []AllocRecord {
+	if profiler_state.mu == unsafe { nil } {
+		return []
+	}
+	profiler_state.mu.lock()
+	defer {
+		profiler_state.mu.unlock()
+	}
+	return profiler_state.allocs.clone()
+}
+
+// get_leaks returns allocations that were never freed
+pub fn get_leaks() []AllocRecord {
+	if profiler_state.mu == unsafe { nil } {
+		return []
+	}
+	profiler_state.mu.lock()
+	defer {
+		profiler_state.mu.unlock()
+	}
+
+	mut leaks := []AllocRecord{}
+	for alloc in profiler_state.allocs {
+		if !alloc.freed {
+			leaks << alloc
+		}
+	}
+	return leaks
+}
+
+// get_allocs_for_frame returns allocations made in a specific frame
+pub fn get_allocs_for_frame(frame_num u64) []AllocRecord {
+	if profiler_state.mu == unsafe { nil } {
+		return []
+	}
+	profiler_state.mu.lock()
+	defer {
+		profiler_state.mu.unlock()
+	}
+
+	mut frame_allocs := []AllocRecord{}
+	for alloc in profiler_state.allocs {
+		if alloc.frame == frame_num {
+			frame_allocs << alloc
+		}
+	}
+	return frame_allocs
+}
+
+// get_live_allocs returns currently live (not freed) allocations
+pub fn get_live_allocs() []AllocRecord {
+	if profiler_state.mu == unsafe { nil } {
+		return []
+	}
+	profiler_state.mu.lock()
+	defer {
+		profiler_state.mu.unlock()
+	}
+
+	mut live := []AllocRecord{}
+	for alloc in profiler_state.allocs {
+		if !alloc.freed {
+			live << alloc
+		}
+	}
+	return live
+}
+
+// reset clears all profiler data
+pub fn reset() {
+	if profiler_state.mu == unsafe { nil } {
+		return
+	}
+	profiler_state.mu.lock()
+	defer {
+		profiler_state.mu.unlock()
+	}
+
+	profiler_state.allocs.clear()
+	profiler_state.alloc_map.clear()
+	profiler_state.frames.clear()
+	profiler_state.current_frame = 0
+	profiler_state.live_bytes = 0
+	profiler_state.peak_bytes = 0
+	profiler_state.total_allocs = 0
+	profiler_state.total_frees = 0
+
+	// Start fresh frame
+	if profiler_state.enabled {
+		profiler_state.frames << FrameData{
+			frame_num: 0
+		}
+	}
+}
+
+// use_profiler_allocator enables the profiler allocator in the current context
+// Returns the old allocator for restoration
+pub fn use_profiler_allocator() Allocator {
+	return push_allocator(profiler_allocator())
+}
+
+// restore_allocator restores the previous allocator
+pub fn restore_allocator(old Allocator) {
+	pop_allocator(old)
+}