Initial project import

tools/v/vlib/v2_toberemoved/profiler/context.v

@@ -0,0 +1,76 @@
+// 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 context
+
+// Allocator interface - can be swapped at runtime
+// Similar to Jai's context.allocator design
+pub struct Allocator {
+pub:
+	alloc_fn   fn (size int, ctx voidptr) voidptr                  = default_alloc
+	free_fn    fn (ptr voidptr, ctx voidptr)                       = default_free
+	realloc_fn fn (ptr voidptr, new_size int, ctx voidptr) voidptr = default_realloc
+	ctx        voidptr // User data for allocator implementation
+}
+
+// Thread-local context (implicit parameter)
+// This allows all allocations in a scope to be tracked without explicit annotations
+
+@[thread_local]
+__global context = Context{}
+
+pub struct Context {
+pub mut:
+	allocator Allocator = default_allocator
+}
+
+// Default allocator - just wraps malloc/free/realloc
+pub const default_allocator = Allocator{
+	alloc_fn:   default_alloc
+	free_fn:    default_free
+	realloc_fn: default_realloc
+	ctx:        unsafe { nil }
+}
+
+fn default_alloc(size int, ctx voidptr) voidptr {
+	return unsafe { C.malloc(size) }
+}
+
+fn default_free(ptr voidptr, ctx voidptr) {
+	unsafe { C.free(ptr) }
+}
+
+fn default_realloc(ptr voidptr, new_size int, ctx voidptr) voidptr {
+	return unsafe { C.realloc(ptr, new_size) }
+}
+
+// User code calls these - they use context.allocator implicitly
+// This provides the Jai-like implicit allocation tracking
+pub fn alloc(size int) voidptr {
+	return context.allocator.alloc_fn(size, context.allocator.ctx)
+}
+
+pub fn free(ptr voidptr) {
+	context.allocator.free_fn(ptr, context.allocator.ctx)
+}
+
+pub fn realloc(ptr voidptr, new_size int) voidptr {
+	return context.allocator.realloc_fn(ptr, new_size, context.allocator.ctx)
+}
+
+// Scoped allocator helper - saves and restores the allocator
+// Usage:
+//   old := profiler.push_allocator(my_allocator)
+//   defer { profiler.pop_allocator(old) }
+//   // ... all allocations here use my_allocator
+pub fn push_allocator(a Allocator) Allocator {
+	old := context.allocator
+	context.allocator = a
+	return old
+}
+
+pub fn pop_allocator(old Allocator) {
+	context.allocator = old
+}