From 4723ec75adfc8bcea4477d46838f3b966c7ecea5 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Fri, 10 Oct 2025 09:47:31 +0100 Subject: [PATCH] Use `sync.Mutex` instead of a boolean-check for `log.Log_Allocator` --- core/log/log_allocator.odin | 141 ++++++++++++++++++------------------ 1 file changed, 70 insertions(+), 71 deletions(-) diff --git a/core/log/log_allocator.odin b/core/log/log_allocator.odin index 16f1abe31..3ef5b4e25 100644 --- a/core/log/log_allocator.odin +++ b/core/log/log_allocator.odin @@ -2,26 +2,30 @@ package log import "base:runtime" import "core:fmt" +import "core:sync" Log_Allocator_Format :: enum { Bytes, // Actual number of bytes. Human, // Bytes in human units like bytes, kibibytes, etc. as appropriate. } + +// Log_Allocator is an allocator which calls `context.logger` on each of its allocations operations. +// The format can be changed by setting the `size_fmt: Log_Allocator_Format` field to either `Bytes` or `Human`. Log_Allocator :: struct { allocator: runtime.Allocator, level: Level, prefix: string, - locked: bool, + lock: sync.Mutex, size_fmt: Log_Allocator_Format, } log_allocator_init :: proc(la: ^Log_Allocator, level: Level, size_fmt := Log_Allocator_Format.Bytes, allocator := context.allocator, prefix := "") { la.allocator = allocator - la.level = level - la.prefix = prefix - la.locked = false + la.level = level + la.prefix = prefix + la.lock = {} la.size_fmt = size_fmt } @@ -46,83 +50,78 @@ log_allocator_proc :: proc(allocator_data: rawptr, mode: runtime.Allocator_Mode, buf: [256]byte = --- - if !la.locked { - la.locked = true - defer la.locked = false + sync.lock(&la.lock) + switch mode { + case .Alloc: + format: string + switch la.size_fmt { + case .Bytes: format = "%s%s>>> ALLOCATOR(mode=.Alloc, size=%d, alignment=%d)" + case .Human: format = "%s%s>>> ALLOCATOR(mode=.Alloc, size=%m, alignment=%d)" + } + str := fmt.bprintf(buf[:], format, la.prefix, padding, size, alignment) + context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location) - switch mode { - case .Alloc: + case .Alloc_Non_Zeroed: + format: string + switch la.size_fmt { + case .Bytes: format = "%s%s>>> ALLOCATOR(mode=.Alloc_Non_Zeroed, size=%d, alignment=%d)" + case .Human: format = "%s%s>>> ALLOCATOR(mode=.Alloc_Non_Zeroed, size=%m, alignment=%d)" + } + str := fmt.bprintf(buf[:], format, la.prefix, padding, size, alignment) + context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location) + + case .Free: + if old_size != 0 { format: string switch la.size_fmt { - case .Bytes: format = "%s%s>>> ALLOCATOR(mode=.Alloc, size=%d, alignment=%d)" - case .Human: format = "%s%s>>> ALLOCATOR(mode=.Alloc, size=%m, alignment=%d)" + case .Bytes: format = "%s%s<<< ALLOCATOR(mode=.Free, ptr=%p, size=%d)" + case .Human: format = "%s%s<<< ALLOCATOR(mode=.Free, ptr=%p, size=%m)" } - str := fmt.bprintf(buf[:], format, la.prefix, padding, size, alignment) + str := fmt.bprintf(buf[:], format, la.prefix, padding, old_memory, old_size) context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location) - - case .Alloc_Non_Zeroed: - format: string - switch la.size_fmt { - case .Bytes: format = "%s%s>>> ALLOCATOR(mode=.Alloc_Non_Zeroed, size=%d, alignment=%d)" - case .Human: format = "%s%s>>> ALLOCATOR(mode=.Alloc_Non_Zeroed, size=%m, alignment=%d)" - } - str := fmt.bprintf(buf[:], format, la.prefix, padding, size, alignment) - context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location) - - case .Free: - if old_size != 0 { - format: string - switch la.size_fmt { - case .Bytes: format = "%s%s<<< ALLOCATOR(mode=.Free, ptr=%p, size=%d)" - case .Human: format = "%s%s<<< ALLOCATOR(mode=.Free, ptr=%p, size=%m)" - } - str := fmt.bprintf(buf[:], format, la.prefix, padding, old_memory, old_size) - context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location) - } else { - str := fmt.bprintf(buf[:], "%s%s<<< ALLOCATOR(mode=.Free, ptr=%p)", la.prefix, padding, old_memory) - context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location) - } - - case .Free_All: - str := fmt.bprintf(buf[:], "%s%s<<< ALLOCATOR(mode=.Free_All)", la.prefix, padding) - context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location) - - case .Resize: - format: string - switch la.size_fmt { - case .Bytes: format = "%s%s>>> ALLOCATOR(mode=.Resize, ptr=%p, old_size=%d, size=%d, alignment=%d)" - case .Human: format = "%s%s>>> ALLOCATOR(mode=.Resize, ptr=%p, old_size=%m, size=%m, alignment=%d)" - } - str := fmt.bprintf(buf[:], format, la.prefix, padding, old_memory, old_size, size, alignment) - context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location) - - case .Resize_Non_Zeroed: - format: string - switch la.size_fmt { - case .Bytes: format = "%s%s>>> ALLOCATOR(mode=.Resize_Non_Zeroed, ptr=%p, old_size=%d, size=%d, alignment=%d)" - case .Human: format = "%s%s>>> ALLOCATOR(mode=.Resize_Non_Zeroed, ptr=%p, old_size=%m, size=%m, alignment=%d)" - } - str := fmt.bprintf(buf[:], format, la.prefix, padding, old_memory, old_size, size, alignment) - context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location) - - case .Query_Features: - str := fmt.bprintf(buf[:], "%s%sALLOCATOR(mode=.Query_Features)", la.prefix, padding) - context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location) - - case .Query_Info: - str := fmt.bprintf(buf[:], "%s%sALLOCATOR(mode=.Query_Info)", la.prefix, padding) + } else { + str := fmt.bprintf(buf[:], "%s%s<<< ALLOCATOR(mode=.Free, ptr=%p)", la.prefix, padding, old_memory) context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location) } + + case .Free_All: + str := fmt.bprintf(buf[:], "%s%s<<< ALLOCATOR(mode=.Free_All)", la.prefix, padding) + context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location) + + case .Resize: + format: string + switch la.size_fmt { + case .Bytes: format = "%s%s>>> ALLOCATOR(mode=.Resize, ptr=%p, old_size=%d, size=%d, alignment=%d)" + case .Human: format = "%s%s>>> ALLOCATOR(mode=.Resize, ptr=%p, old_size=%m, size=%m, alignment=%d)" + } + str := fmt.bprintf(buf[:], format, la.prefix, padding, old_memory, old_size, size, alignment) + context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location) + + case .Resize_Non_Zeroed: + format: string + switch la.size_fmt { + case .Bytes: format = "%s%s>>> ALLOCATOR(mode=.Resize_Non_Zeroed, ptr=%p, old_size=%d, size=%d, alignment=%d)" + case .Human: format = "%s%s>>> ALLOCATOR(mode=.Resize_Non_Zeroed, ptr=%p, old_size=%m, size=%m, alignment=%d)" + } + str := fmt.bprintf(buf[:], format, la.prefix, padding, old_memory, old_size, size, alignment) + context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location) + + case .Query_Features: + str := fmt.bprintf(buf[:], "%s%sALLOCATOR(mode=.Query_Features)", la.prefix, padding) + context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location) + + case .Query_Info: + str := fmt.bprintf(buf[:], "%s%sALLOCATOR(mode=.Query_Info)", la.prefix, padding) + context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location) } + sync.unlock(&la.lock) data, err := la.allocator.procedure(la.allocator.data, mode, size, alignment, old_memory, old_size, location) - if !la.locked { - la.locked = true - defer la.locked = false - if err != nil { - str := fmt.bprintf(buf[:], "%s%sALLOCATOR ERROR=%v", la.prefix, padding, err) - context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location) - } + if err != nil { + sync.lock(&la.lock) + str := fmt.bprintf(buf[:], "%s%sALLOCATOR ERROR=%v", la.prefix, padding, err) + context.logger.procedure(context.logger.data, la.level, str, context.logger.options, location) + sync.unlock(&la.lock) } return data, err }