zig

commit 6cd3995754adcdcb1873c3fbfc0ec98ba95b68b5 (tree)
parent 516b5e649fa5f6c4043275b3dbe8e38273d79344
Author: Andrew Kelley <andrew@ziglang.org>
Date:   Thu, 27 Jun 2019 12:05:12 -0400

Merge branch 'daurnimator-logging-allocator'

Diffstat:
M
CMakeLists.txt
 | 
1
+
M
std/heap.zig
 | 
2
++
A
std/heap/logging_allocator.zig
 | 
53
+++++++++++++++++++++++++++++++++++++++++++++++++++++

3 files changed, 56 insertions(+), 0 deletions(-)
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -524,6 +524,7 @@ set(ZIG_STD_FILES
     "hash/siphash.zig"
     "hash_map.zig"
     "heap.zig"
+    "heap/logging_allocator.zig"
     "io.zig"
     "io/c_out_stream.zig"
     "io/seekable_stream.zig"
diff --git a/std/heap.zig b/std/heap.zig
@@ -8,6 +8,8 @@ const builtin = @import("builtin");
 const c = std.c;
 const maxInt = std.math.maxInt;
 
+pub const LoggingAllocator = @import("heap/logging_allocator.zig").LoggingAllocator;
+
 const Allocator = mem.Allocator;
 
 pub const c_allocator = &c_allocator_state;
diff --git a/std/heap/logging_allocator.zig b/std/heap/logging_allocator.zig
@@ -0,0 +1,53 @@
+const std = @import("../std.zig");
+const Allocator = std.mem.Allocator;
+
+const AnyErrorOutStream = std.io.OutStream(anyerror);
+
+/// This allocator is used in front of another allocator and logs to the provided stream
+/// on every call to the allocator. Stream errors are ignored.
+/// If https://github.com/ziglang/zig/issues/2586 is implemented, this API can be improved.
+pub const LoggingAllocator = struct {
+    allocator: Allocator,
+    parent_allocator: *Allocator,
+    out_stream: *AnyErrorOutStream,
+
+    const Self = @This();
+
+    pub fn init(parent_allocator: *Allocator, out_stream: *AnyErrorOutStream) Self {
+        return Self{
+            .allocator = Allocator{
+                .reallocFn = realloc,
+                .shrinkFn = shrink,
+            },
+            .parent_allocator = parent_allocator,
+            .out_stream = out_stream,
+        };
+    }
+
+    fn realloc(allocator: *Allocator, old_mem: []u8, old_align: u29, new_size: usize, new_align: u29) ![]u8 {
+        const self = @fieldParentPtr(Self, "allocator", allocator);
+        if (old_mem.len == 0) {
+            self.out_stream.print("allocation of {} ", new_size) catch {};
+        } else {
+            self.out_stream.print("resize from {} to {} ", old_mem.len, new_size) catch {};
+        }
+        const result = self.parent_allocator.reallocFn(self.parent_allocator, old_mem, old_align, new_size, new_align);
+        if (result) |buff| {
+            self.out_stream.print("success!\n") catch {};
+        } else |err| {
+            self.out_stream.print("failure!\n") catch {};
+        }
+        return result;
+    }
+
+    fn shrink(allocator: *Allocator, old_mem: []u8, old_align: u29, new_size: usize, new_align: u29) []u8 {
+        const self = @fieldParentPtr(Self, "allocator", allocator);
+        const result = self.parent_allocator.shrinkFn(self.parent_allocator, old_mem, old_align, new_size, new_align);
+        if (new_size == 0) {
+            self.out_stream.print("free of {} bytes success!\n", old_mem.len) catch {};
+        } else {
+            self.out_stream.print("shrink from {} bytes to {} bytes success!\n", old_mem.len, new_size) catch {};
+        }
+        return result;
+    }
+};