lib/bumpalo/src/profiling/allocator.zig

daab053ee43316e1809a84551d573ddd1e5bf3d2

  1 const std = @import("std");
  2 const bumpalo = @import("bumpalo");
  3 const context = @import("context.zig");
  4 
  5 const allocation_count = context.allocation_count;
  6 
  7 fn backingAllocator(sample_allocator: std.mem.Allocator) std.mem.Allocator {
  8     return context.benchBackingAllocator(sample_allocator);
  9 }
 10 
 11 pub fn lifo(sample_allocator: std.mem.Allocator) void {
 12     var arena = bumpalo.Bump.initCapacity(backingAllocator(sample_allocator), 512) catch
 13         @panic("arena allocation failed");
 14     defer arena.deinit();
 15     const allocator_instance = arena.allocator();
 16     var checksum: usize = 0;
 17     var index: usize = 0;
 18     while (index < allocation_count) : (index += 1) {
 19         const bytes = allocator_instance.alloc(u8, 32) catch @panic("allocation failed");
 20         checksum +%= @intFromPtr(bytes.ptr) & 0xff;
 21         allocator_instance.free(bytes);
 22     }
 23     std.mem.doNotOptimizeAway(checksum);
 24 }
 25 
 26 pub fn realloc(sample_allocator: std.mem.Allocator) void {
 27     var arena = bumpalo.Bump.initCapacity(backingAllocator(sample_allocator), 512) catch
 28         @panic("arena allocation failed");
 29     defer arena.deinit();
 30     const allocator_instance = arena.allocator();
 31     var bytes = allocator_instance.alloc(u8, 8) catch @panic("allocation failed");
 32     @memset(bytes, 0xaa);
 33     var checksum: usize = 0;
 34     var index: usize = 0;
 35     while (index < allocation_count) : (index += 1) {
 36         bytes = allocator_instance.realloc(bytes, 16) catch @panic("allocation failed");
 37         checksum +%= bytes[0];
 38         bytes = allocator_instance.realloc(bytes, 8) catch @panic("allocation failed");
 39         checksum +%= bytes[0];
 40     }
 41     allocator_instance.free(bytes);
 42     std.mem.doNotOptimizeAway(checksum);
 43 }
 44 
 45 pub fn remapFootprint(sample_allocator: std.mem.Allocator) void {
 46     var arena = bumpalo.Bump.initCapacity(backingAllocator(sample_allocator), allocation_count * 256) catch
 47         @panic("arena allocation failed");
 48     defer arena.deinit();
 49     const allocator_instance = arena.allocator();
 50     var bytes = allocator_instance.alignedAlloc(u8, .@"64", 65) catch
 51         @panic("allocation failed");
 52     @memset(bytes, 0xaa);
 53     var checksum: usize = 0;
 54     var index: usize = 0;
 55     while (index < allocation_count) : (index += 1) {
 56         bytes = allocator_instance.remap(bytes, 127) orelse @panic("remap failed");
 57         checksum +%= @intFromPtr(bytes.ptr) & 0xff;
 58         bytes = allocator_instance.remap(bytes, 65) orelse @panic("remap failed");
 59         checksum +%= bytes[0];
 60     }
 61     allocator_instance.free(bytes);
 62     std.mem.doNotOptimizeAway(checksum);
 63 }
 64 
 65 pub fn resizeLength(sample_allocator: std.mem.Allocator) void {
 66     var arena = bumpalo.Bump.initCapacity(backingAllocator(sample_allocator), 512) catch
 67         @panic("arena allocation failed");
 68     defer arena.deinit();
 69     const allocator_instance = arena.allocator();
 70     const bytes = allocator_instance.alloc(u8, 64) catch @panic("allocation failed");
 71     var checksum: usize = 0;
 72     var index: usize = 0;
 73     while (index < allocation_count) : (index += 1) {
 74         if (!allocator_instance.resize(bytes, 64)) @panic("resize failed");
 75         checksum +%= bytes.len;
 76     }
 77     allocator_instance.free(bytes);
 78     std.mem.doNotOptimizeAway(checksum);
 79 }
 80 
 81 pub fn remapLength(sample_allocator: std.mem.Allocator) void {
 82     var arena = bumpalo.Bump.initCapacity(backingAllocator(sample_allocator), 512) catch
 83         @panic("arena allocation failed");
 84     defer arena.deinit();
 85     const allocator_instance = arena.allocator();
 86     const bytes = allocator_instance.alloc(u8, 64) catch @panic("allocation failed");
 87     var checksum: usize = 0;
 88     var index: usize = 0;
 89     while (index < allocation_count) : (index += 1) {
 90         const remapped = allocator_instance.remap(bytes, 64) orelse @panic("remap failed");
 91         checksum +%= @intFromPtr(remapped.ptr) & 0xff;
 92     }
 93     allocator_instance.free(bytes);
 94     std.mem.doNotOptimizeAway(checksum);
 95 }
 96 
 97 pub fn list(sample_allocator: std.mem.Allocator) void {
 98     var arena = bumpalo.Bump.init(backingAllocator(sample_allocator));
 99     defer arena.deinit();
100     const allocator_instance = arena.allocator();
101     var values: std.ArrayList(u64) = .empty;
102     defer values.deinit(allocator_instance);
103     var index: u64 = 0;
104     while (index < allocation_count) : (index += 1) {
105         values.append(allocator_instance, index) catch @panic("append failed");
106     }
107     std.mem.doNotOptimizeAway(values.items.ptr);
108     std.mem.doNotOptimizeAway(values.items[values.items.len - 1]);
109 }