Initial project import

tools/v/vlib/v2_toberemoved/profiler/alloc.v

@@ -0,0 +1,127 @@
+// 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
+
+import time
+import sync
+
+// AllocRecord tracks a single allocation
+pub struct AllocRecord {
+pub:
+	ptr       voidptr
+	size      int
+	frame     u64
+	file      string // Source file
+	line      int    // Source line
+	timestamp i64    // Monotonic time in nanoseconds
+pub mut:
+	freed      bool
+	free_frame u64
+}
+
+// FrameData aggregates allocation info for a single frame
+pub struct FrameData {
+pub:
+	frame_num u64
+pub mut:
+	new_bytes   u64
+	freed_bytes u64
+	live_bytes  u64
+	new_allocs  []int // Indices into allocs array
+	freed_idxs  []int // Indices of allocations freed this frame
+}
+
+// ProfilerState holds all profiling data
+@[heap]
+pub struct ProfilerState {
+pub mut:
+	enabled       bool
+	current_frame u64
+	allocs        []AllocRecord
+	alloc_map     map[voidptr]int // ptr -> index in allocs
+	frames        []FrameData
+	peak_bytes    u64
+	live_bytes    u64
+	total_allocs  u64
+	total_frees   u64
+	mu            &sync.Mutex = unsafe { nil }
+}
+
+// Global profiler state singleton
+__global profiler_state = &ProfilerState{}
+
+// init_profiler_state initializes the global profiler state
+// Must be called before using the profiler
+pub fn init_profiler_state() {
+	profiler_state.mu = sync.new_mutex()
+	profiler_state.enabled = false
+	profiler_state.current_frame = 0
+	profiler_state.allocs = []AllocRecord{cap: 10000}
+	profiler_state.frames = []FrameData{cap: 1000}
+	profiler_state.peak_bytes = 0
+	profiler_state.live_bytes = 0
+	profiler_state.total_allocs = 0
+	profiler_state.total_frees = 0
+}
+
+// get_state returns the global profiler state
+pub fn get_state() &ProfilerState {
+	return profiler_state
+}
+
+// Statistics returns summary stats
+pub struct Statistics {
+pub:
+	live_bytes   u64
+	peak_bytes   u64
+	total_allocs u64
+	total_frees  u64
+	leak_count   int
+	frame_count  u64
+}
+
+// get_statistics returns current profiler statistics
+pub fn get_statistics() Statistics {
+	if profiler_state.mu == unsafe { nil } {
+		return Statistics{}
+	}
+	profiler_state.mu.lock()
+	defer {
+		profiler_state.mu.unlock()
+	}
+
+	mut leak_count := 0
+	for alloc in profiler_state.allocs {
+		if !alloc.freed {
+			leak_count++
+		}
+	}
+
+	return Statistics{
+		live_bytes:   profiler_state.live_bytes
+		peak_bytes:   profiler_state.peak_bytes
+		total_allocs: profiler_state.total_allocs
+		total_frees:  profiler_state.total_frees
+		leak_count:   leak_count
+		frame_count:  profiler_state.current_frame
+	}
+}
+
+// format_bytes converts bytes to a human-readable string
+pub fn format_bytes(bytes u64) string {
+	if bytes < 1024 {
+		return '${bytes} B'
+	} else if bytes < 1024 * 1024 {
+		return '${f64(bytes) / 1024.0:.1} KB'
+	} else if bytes < 1024 * 1024 * 1024 {
+		return '${f64(bytes) / (1024.0 * 1024.0):.1} MB'
+	} else {
+		return '${f64(bytes) / (1024.0 * 1024.0 * 1024.0):.2} GB'
+	}
+}
+
+// now_mono returns the current monotonic time in nanoseconds
+fn now_mono() i64 {
+	return time.sys_mono_now()
+}