Commit be6d022257d8d7e99bd080823d4d8f0175f320c5 | zig

author	John Schmidt <john.schmidt.h@gmail.com> 2019-02-07 21:28:37+01:00
committer	Andrew Kelley <andrew@ziglang.org> 2019-02-07 23:21:37-05:00
log	be6d022257d8d7e99bd080823d4d8f0175f320c5
tree	e4bafc487c702e65bf18fb95ab2df21509a68e8a
parent	f330eebe4bc6a036846cf05706f72855627c705a

Make ThreadSafeFixedBufferAllocator alias FixedBufferAllocator when --single-threaded

Fixes #1910

1 files changed, 46 insertions(+), 40 deletions(-)

std
- heap.zig

std/heap.zig+46-40

 @@ -321,51 +321,57 @@ pub const FixedBufferAllocator = struct {
     fn free(allocator: *Allocator, bytes: []u8) void {}
 };
-/// lock free
+pub const ThreadSafeFixedBufferAllocator = blk: {
-pub const ThreadSafeFixedBufferAllocator = struct {
+    if (builtin.single_threaded) {
-    allocator: Allocator,
+        break :blk FixedBufferAllocator;
-    end_index: usize,
+    } else {
-    buffer: []u8,
+        /// lock free
+        break :blk struct {
+            allocator: Allocator,
+            end_index: usize,
+            buffer: []u8,
+            pub fn init(buffer: []u8) ThreadSafeFixedBufferAllocator {
+                return ThreadSafeFixedBufferAllocator{
+                    .allocator = Allocator{
+                        .allocFn = alloc,
+                        .reallocFn = realloc,
+                        .freeFn = free,
+                    },
+                    .buffer = buffer,
+                    .end_index = 0,
+                };
+            }
-    pub fn init(buffer: []u8) ThreadSafeFixedBufferAllocator {
+            fn alloc(allocator: *Allocator, n: usize, alignment: u29) ![]u8 {
-        return ThreadSafeFixedBufferAllocator{
+                const self = @fieldParentPtr(ThreadSafeFixedBufferAllocator, "allocator", allocator);
-            .allocator = Allocator{
+                var end_index = @atomicLoad(usize, &self.end_index, builtin.AtomicOrder.SeqCst);
-                .allocFn = alloc,
+                while (true) {
-                .reallocFn = realloc,
+                    const addr = @ptrToInt(self.buffer.ptr) + end_index;
-                .freeFn = free,
+                    const rem = @rem(addr, alignment);
-            },
+                    const march_forward_bytes = if (rem == 0) 0 else (alignment - rem);
-            .buffer = buffer,
+                    const adjusted_index = end_index + march_forward_bytes;
-            .end_index = 0,
+                    const new_end_index = adjusted_index + n;
-        };
+                    if (new_end_index > self.buffer.len) {
-    }
+                        return error.OutOfMemory;
+                    }
+                    end_index = @cmpxchgWeak(usize, &self.end_index, end_index, new_end_index, builtin.AtomicOrder.SeqCst, builtin.AtomicOrder.SeqCst) orelse return self.buffer[adjusted_index..new_end_index];
+                }
+            }
-    fn alloc(allocator: *Allocator, n: usize, alignment: u29) ![]u8 {
+            fn realloc(allocator: *Allocator, old_mem: []u8, new_size: usize, alignment: u29) ![]u8 {
-        const self = @fieldParentPtr(ThreadSafeFixedBufferAllocator, "allocator", allocator);
+                if (new_size <= old_mem.len) {
-        var end_index = @atomicLoad(usize, &self.end_index, builtin.AtomicOrder.SeqCst);
+                    return old_mem[0..new_size];
-        while (true) {
+                } else {
-            const addr = @ptrToInt(self.buffer.ptr) + end_index;
+                    const result = try alloc(allocator, new_size, alignment);
-            const rem = @rem(addr, alignment);
+                    mem.copy(u8, result, old_mem);
-            const march_forward_bytes = if (rem == 0) 0 else (alignment - rem);
+                    return result;
-            const adjusted_index = end_index + march_forward_bytes;
+                }
-            const new_end_index = adjusted_index + n;
-            if (new_end_index > self.buffer.len) {
-                return error.OutOfMemory;
             }
-            end_index = @cmpxchgWeak(usize, &self.end_index, end_index, new_end_index, builtin.AtomicOrder.SeqCst, builtin.AtomicOrder.SeqCst) orelse return self.buffer[adjusted_index..new_end_index];
-        }
-    }
-    fn realloc(allocator: *Allocator, old_mem: []u8, new_size: usize, alignment: u29) ![]u8 {
+            fn free(allocator: *Allocator, bytes: []u8) void {}
-        if (new_size <= old_mem.len) {
+        };
-            return old_mem[0..new_size];
-        } else {
-            const result = try alloc(allocator, new_size, alignment);
-            mem.copy(u8, result, old_mem);
-            return result;
-        }
     }
-    fn free(allocator: *Allocator, bytes: []u8) void {}
 };
 pub fn stackFallback(comptime size: usize, fallback_allocator: *Allocator) StackFallbackAllocator(size) {