runtime: Implement explicit object allocation

This commit implements the full allocation token API as described in
issue #13. The new API works by making all allocations explicit through
a new method on Heap called getAllocation. This method allows a user to
ask for a specific amount of bytes, which the heap will make available
on eden (garbage collecting if necessary) and then return a token object
which gives that piece of code a claim for the requested amount of
bytes.

The AllocationToken object returned by getAllocation allows a user to
allocate through it in either the object or the byte array segment. If
the requested amount of bytes are exceeded, the VM will immediately
crash. This is intended to significantly reduce the amount of problems
caused by implicit garbage collection being allowed anywhere an
allocation happens.

As a side effect, this commit removes a lot of try keywords from the
overall code due to the reduction of fallible API usage (through
heap.allocateInObjectSegment).

Closes #13.

Author: sin-ack

src/debug.zig

@@ -6,6 +6,8 @@ pub const LOOKUP_DEBUG = false;
 pub const SLOTS_LOOKUP_DEBUG = false;
 /// Debugging of garbage collections.
 pub const GC_DEBUG = false;
+/// Debugging of allocation token requests.
+pub const GC_TOKEN_DEBUG = false;
 /// Debugging of which addresses called track and then didn't untrack the object.
 pub const GC_TRACK_SOURCE_DEBUG = false;
 /// Debugging of functions related to older generation objects pointing to newer

src/runtime/Activation.zig

@@ -63,7 +63,7 @@ pub fn initInPlace(
     stack_snapshot: Actor.StackSnapshot,
     creator_message: Value,
     created_from: SourceRange,
-) !void {
+) void {
     self.* = .{
         .activation_id = newActivationID(),
         .activation_object = activation_object,

src/runtime/Actor.zig

@@ -5,6 +5,7 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
 
+const Heap = @import("./Heap.zig");
 const Slot = @import("./slot.zig").Slot;
 const debug = @import("../debug.zig");
 const Value = value_import.Value;
@@ -145,34 +146,15 @@ pub const Message = struct {
     }
 };
 
-/// Spawn a new actor, activating the given method on it.
-pub fn spawn(
-    vm: *VirtualMachine,
-    actor_context: Value,
-    method: *Object.Method,
-    source_range: SourceRange,
-    target_location: RegisterLocation,
-) !*Self {
-    std.debug.assert(method.getArgumentSlotCount() == 0);
-
-    const self = try create(vm, actor_context);
-    errdefer self.destroy(vm.allocator);
-
-    const new_activation = try self.activation_stack.getNewActivationSlot(vm.allocator);
-    try method.activateMethod(vm, self.id, actor_context, &.{}, target_location, source_range, new_activation);
-
-    return self;
-}
-
-pub fn create(vm: *VirtualMachine, actor_context: Value) !*Self {
+pub fn create(vm: *VirtualMachine, token: *Heap.AllocationToken, actor_context: Value) !*Self {
     const self = try vm.allocator.create(Self);
     errdefer vm.allocator.destroy(self);
 
     // NOTE: If we're not in actor mode, then we belong to the global actor (which is this actor for the
     //       first call to create); otherwise, we are always owned by the genesis actor.
     const owning_actor_id = if (vm.isInActorMode()) vm.genesis_actor.?.id else 0;
 
-    const actor_object = try Object.Actor.create(vm.heap, owning_actor_id, self, actor_context);
+    const actor_object = try Object.Actor.create(token, owning_actor_id, self, actor_context);
 
     self.init(actor_object);
     return self;
@@ -205,6 +187,18 @@ fn deinit(self: *Self, allocator: Allocator) void {
     self.activation_stack.deinit(allocator);
 }
 
+pub fn activateMethod(
+    self: *Self,
+    vm: *VirtualMachine,
+    token: *Heap.AllocationToken,
+    method: *Object.Method,
+    target_location: RegisterLocation,
+    source_range: SourceRange,
+) !void {
+    const activation_slot = try self.activation_stack.getNewActivationSlot(vm.allocator);
+    method.activateMethod(vm, token, self.id, self.actor_object.get().context, &.{}, target_location, source_range, activation_slot);
+}
+
 pub fn execute(self: *Self, vm: *VirtualMachine) !ActorResult {
     const current_activation_ref = self.activation_stack.getCurrent().takeRef(self.activation_stack);
 
@@ -213,13 +207,14 @@ pub fn execute(self: *Self, vm: *VirtualMachine) !ActorResult {
     {
         var it = self.mailbox.first;
         while (it) |node| : (it = node.next) {
-            const method = node.data.method.get();
+            var method = node.data.method.get();
 
-            try vm.heap.ensureSpaceInEden(method.requiredSizeForActivation());
+            var token = try vm.heap.getAllocation(method.requiredSizeForActivation());
+            method = node.data.method.get();
 
             const actor_context = self.actor_object.get().context;
             const new_activation = try self.activation_stack.getNewActivationSlot(vm.allocator);
-            try method.activateMethod(vm, self.id, actor_context, node.data.arguments, .zero, node.data.source_range, new_activation);
+            method.activateMethod(vm, &token, self.id, actor_context, node.data.arguments, .zero, node.data.source_range, new_activation);
 
             self.message_sender = node.data.sender;
 

src/runtime/ByteArray.zig

@@ -13,14 +13,14 @@ const Self = @This();
 
 header: *align(@alignOf(u64)) Header,
 
-pub fn createFromString(heap: *Heap, string: []const u8) !Self {
-    var self = try createUninitialized(heap, string.len);
+pub fn createFromString(token: *Heap.AllocationToken, string: []const u8) Self {
+    var self = createUninitialized(token, string.len);
     std.mem.copy(u8, self.getValues(), string);
     return self;
 }
 
-pub fn createUninitialized(heap: *Heap, size: usize) !Self {
-    var memory_area = try heap.allocateInByteVectorSegment(requiredSizeForAllocation(size));
+pub fn createUninitialized(token: *Heap.AllocationToken, size: usize) Self {
+    var memory_area = token.allocate(.ByteArray, requiredSizeForAllocation(size));
     var header = @ptrCast(*Header, memory_area);
 
     header.init(size);

src/runtime/Heap.zig

@@ -11,13 +11,14 @@ const hash = @import("../utility/hash.zig");
 const debug = @import("../debug.zig");
 const Value = @import("./value.zig").Value;
 const Object = @import("./Object.zig");
-const ByteVector = @import("./ByteArray.zig");
+const ByteArray = @import("./ByteArray.zig");
 const Activation = @import("./Activation.zig");
 const HandleArea = @import("./HandleArea.zig");
 const VirtualMachine = @import("./VirtualMachine.zig");
 const ActivationStack = Activation.ActivationStack;
 
 const GC_DEBUG = debug.GC_DEBUG;
+const GC_TOKEN_DEBUG = debug.GC_TOKEN_DEBUG;
 const GC_TRACK_SOURCE_DEBUG = debug.GC_TRACK_SOURCE_DEBUG;
 const REMEMBERED_SET_DEBUG = debug.REMEMBERED_SET_DEBUG;
 
@@ -58,6 +59,27 @@ const EdenSize = 1 * 1024 * 1024;
 const NewSpaceSize = 4 * 1024 * 1024;
 const InitialOldSpaceSize = 16 * 1024 * 1024;
 
+const Segment = enum { Object, ByteArray };
+pub const AllocationToken = struct {
+    heap: *Self,
+    total_bytes: usize,
+    bytes_left: usize,
+
+    pub fn allocate(self: *@This(), segment: Segment, bytes: usize) [*]u64 {
+        if (self.bytes_left < bytes) {
+            std.debug.panic(
+                "!!! Attempted to allocate {} bytes from {} byte-sized allocation token with {} bytes remaining!",
+                .{ bytes, self.total_bytes, self.bytes_left },
+            );
+        }
+
+        self.bytes_left -= bytes;
+        // NOTE: The only error this can raise is allocation failure during lazy allocation
+        //       which eden does not do.
+        return self.heap.eden.allocateInSegment(self.heap.allocator, segment, bytes) catch unreachable;
+    }
+};
+
 pub fn create(allocator: Allocator, vm: *VirtualMachine) !*Self {
     const self = try allocator.create(Self);
     errdefer allocator.destroy(self);
@@ -115,15 +137,14 @@ fn deinit(self: *Self) void {
     }
 }
 
-// Attempts to allocate `size` bytes in the object segment of the eden. If
-// necessary, garbage collection is performed in the process.
-// The given size must be a multiple of `@sizeOf(u64)`.
-pub fn allocateInObjectSegment(self: *Self, size: usize) ![*]u64 {
-    return try self.eden.allocateInObjectSegment(self.allocator, size);
-}
+pub fn getAllocation(self: *Self, bytes: usize) !AllocationToken {
+    if (GC_TOKEN_DEBUG) std.debug.print("Heap.getAllocation: Attempting to get a token of size {}\n", .{bytes});
+    try self.eden.collectGarbage(self.allocator, bytes);
+
+    if (bytes % @sizeOf(u64) != 0)
+        std.debug.panic("!!! Attempted to allocate {} bytes which is not a multiple of @sizeOf(u64)!", .{bytes});
 
-pub fn allocateInByteVectorSegment(self: *Self, size: usize) ![*]u64 {
-    return try self.eden.allocateInByteVectorSegment(self.allocator, size);
+    return AllocationToken{ .heap = self, .total_bytes = bytes, .bytes_left = bytes };
 }
 
 /// Mark the given address within the heap as an object which needs to know when
@@ -174,13 +195,6 @@ pub fn untrack(self: *Self, tracked: Tracked) void {
     }
 }
 
-/// Ensures that the given amount of bytes are immediately available in eden, so
-/// garbage collection won't happen. Performs a pre-emptive garbage collection
-/// if there isn't enough space.
-pub fn ensureSpaceInEden(self: *Self, required_memory: usize) !void {
-    try self.eden.collectGarbage(self.allocator, required_memory);
-}
-
 /// Go through the whole heap, updating references to the given value with the
 /// new value.
 pub fn updateAllReferencesTo(self: *Self, old_value: Value, new_value: Value) !void {
@@ -434,15 +448,15 @@ const Space = struct {
         return new_address;
     }
 
-    /// Same as copyObjectTo, but for byte vectors.
-    fn copyByteVectorTo(allocator: Allocator, address: [*]u64, target_space: *Space) [*]u64 {
-        const byte_array = ByteVector.fromAddress(address);
+    /// Same as copyObjectTo, but for byte arrays.
+    fn copyByteArrayTo(allocator: Allocator, address: [*]u64, target_space: *Space) [*]u64 {
+        const byte_array = ByteArray.fromAddress(address);
         const byte_array_size = byte_array.getSizeInMemory();
         std.debug.assert(byte_array_size % @sizeOf(u64) == 0);
 
         const byte_array_size_in_words = byte_array_size / @sizeOf(u64);
         // We must have enough space at this point.
-        const new_address = target_space.allocateInByteVectorSegment(allocator, byte_array_size) catch unreachable;
+        const new_address = target_space.allocateInByteArraySegment(allocator, byte_array_size) catch unreachable;
         std.mem.copy(u64, new_address[0..byte_array_size_in_words], address[0..byte_array_size_in_words]);
 
         return new_address;
@@ -454,7 +468,7 @@ const Space = struct {
         if (self.objectSegmentContains(address)) {
             return self.copyObjectTo(allocator, address, target_space);
         } else if (self.byteArraySegmentContains(address)) {
-            return copyByteVectorTo(allocator, address, target_space);
+            return copyByteArrayTo(allocator, address, target_space);
         } else if (require_copy) {
             std.debug.panic("!!! copyAddress called with an address that's not allocated in this space!", .{});
         }
@@ -568,8 +582,8 @@ const Space = struct {
             .{ target_object_segment_index, target_space.object_segment.len },
         );
 
-        // Try to catch up to the target space's object and byte vector cursors,
-        // copying any other objects/byte vectors that still exist in this
+        // Try to catch up to the target space's object and byte array cursors,
+        // copying any other objects/byte arrays that still exist in this
         // space.
         while (target_object_segment_index < target_space.object_segment.len) : (target_object_segment_index += 1) {
             const word_ptr = &target_space.object_segment[target_object_segment_index];
@@ -581,7 +595,7 @@ const Space = struct {
                 if (self.objectSegmentContains(address)) {
                     word_ptr.* = Value.fromObjectAddress(try self.copyObjectTo(allocator, address, target_space)).data;
                 } else if (self.byteArraySegmentContains(address)) {
-                    word_ptr.* = Value.fromObjectAddress(copyByteVectorTo(allocator, address, target_space)).data;
+                    word_ptr.* = Value.fromObjectAddress(copyByteArrayTo(allocator, address, target_space)).data;
                 }
             }
         }
@@ -753,13 +767,11 @@ const Space = struct {
     }
 
     /// Allocates the requested amount in bytes in the object segment of this
-    /// space, garbage collecting if there is not enough space.
-    pub fn allocateInObjectSegment(self: *Space, allocator: Allocator, size: usize) ![*]u64 {
+    /// space. Panics if there isn't enough memory.
+    fn allocateInObjectSegment(self: *Space, allocator: Allocator, size: usize) ![*]u64 {
         if (self.lazy_allocate)
             try self.allocateMemory(allocator);
 
-        if (self.freeMemory() < size) try self.collectGarbage(allocator, size);
-
         const size_in_words = @divExact(size, @sizeOf(u64));
         const current_object_segment_offset = self.object_segment.len;
         self.object_segment.len += size_in_words;
@@ -771,14 +783,12 @@ const Space = struct {
         return start_of_object;
     }
 
-    /// Allocates the requested amount in bytes in the byte vector segment of
-    /// this space, garbage collecting if there is not enough space.
-    pub fn allocateInByteVectorSegment(self: *Space, allocator: Allocator, size: usize) ![*]u64 {
+    /// Allocates the requested amount in bytes in the byte array segment of
+    /// this space. Panics if there isn't enough memory.
+    fn allocateInByteArraySegment(self: *Space, allocator: Allocator, size: usize) ![*]u64 {
         if (self.lazy_allocate)
             try self.allocateMemory(allocator);
 
-        if (self.freeMemory() < size) try self.collectGarbage(allocator, size);
-
         const size_in_words = @divExact(size, @sizeOf(u64));
         self.byte_array_segment.ptr -= size_in_words;
         self.byte_array_segment.len += size_in_words;
@@ -789,6 +799,15 @@ const Space = struct {
         return self.byte_array_segment.ptr;
     }
 
+    pub fn allocateInSegment(self: *Space, allocator: Allocator, segment: Segment, size: usize) Allocator.Error![*]u64 {
+        return switch (segment) {
+            .Object => self.allocateInObjectSegment(allocator, size),
+            .ByteArray => self.allocateInByteArraySegment(allocator, size),
+        };
+    }
+
+    /// Allocates the requested amount of bytes in the appropriate segment of
+    /// this space.
     /// Adds the given address to the finalization set of this space.
     pub fn addToFinalizationSet(self: *Space, allocator: Allocator, address: [*]u64) !void {
         try self.finalization_set.put(allocator, address, {});
@@ -1019,14 +1038,14 @@ test "link an object to another and perform scavenge" {
 
     // The object being referenced
     var referenced_object_map = try Object.Map.Slots.create(heap, 1);
-    var actual_name = try ByteVector.createFromString(heap, "actual");
+    var actual_name = try ByteArray.createFromString(heap, "actual");
     referenced_object_map.getSlots()[0].initConstant(actual_name, .NotParent, Value.fromUnsignedInteger(0xDEADBEEF));
     var referenced_object = try Object.Slots.create(heap, referenced_object_map, &[_]Value{});
 
     // The "activation object", which is how we get a reference to the object in
     // the from space after the tenure is done
     var activation_object_map = try Object.Map.Slots.create(heap, 1);
-    var reference_name = try ByteVector.createFromString(heap, "reference");
+    var reference_name = try ByteArray.createFromString(heap, "reference");
     activation_object_map.getSlots()[0].initMutable(Object.Map.Slots, activation_object_map, reference_name, .NotParent);
     var activation_object = try Object.Slots.create(heap, activation_object_map, &[_]Value{referenced_object.asValue()});
 
@@ -1042,15 +1061,15 @@ test "link an object to another and perform scavenge" {
     var new_activation_object_map = new_activation_object.getMap();
     try std.testing.expect(activation_object_map != new_activation_object_map);
     try std.testing.expect(activation_object_map.getSlots()[0].name.asObjectAddress() != new_activation_object_map.getSlots()[0].name.asObjectAddress());
-    try std.testing.expectEqualStrings("reference", new_activation_object_map.getSlots()[0].name.asByteVector().getValues());
+    try std.testing.expectEqualStrings("reference", new_activation_object_map.getSlots()[0].name.asByteArray().getValues());
 
     // Find the new referenced object
     var new_referenced_object = new_activation_object.getAssignableSlotValueByName("reference").?.asObject().asSlotsObject();
     try std.testing.expect(referenced_object != new_referenced_object);
     var new_referenced_object_map = new_referenced_object.getMap();
     try std.testing.expect(referenced_object_map != new_referenced_object_map);
     try std.testing.expect(referenced_object_map.getSlots()[0].name.asObjectAddress() != new_referenced_object_map.getSlots()[0].name.asObjectAddress());
-    try std.testing.expectEqualStrings("actual", new_referenced_object_map.getSlots()[0].name.asByteVector().getValues());
+    try std.testing.expectEqualStrings("actual", new_referenced_object_map.getSlots()[0].name.asByteArray().getValues());
 
     // Verify that the map map is shared (aka forwarding addresses work)
     try std.testing.expectEqual(

src/runtime/Object.zig

@@ -104,17 +104,17 @@ pub fn asValue(self: Self) Value {
     return Value.fromObjectAddress(self.getAddress());
 }
 
-pub fn clone(self: Self, heap: *Heap, actor_id: u31) !Self {
+pub fn clone(self: Self, token: *Heap.AllocationToken, actor_id: u31) Self {
     return switch (self.header.getObjectType()) {
         .ForwardingReference, .Activation, .Method, .Map => unreachable,
-        .Slots => fromAddress((try self.asSlotsObject().clone(heap, actor_id)).asObjectAddress()),
-        .Block => fromAddress((try self.asBlockObject().clone(heap, actor_id)).asObjectAddress()),
-        .ByteArray => fromAddress((try self.asByteArrayObject().clone(heap, actor_id)).asObjectAddress()),
-        .Array => fromAddress((try self.asArrayObject().clone(heap, actor_id)).asObjectAddress()),
+        .Slots => fromAddress(self.asSlotsObject().clone(token, actor_id).asObjectAddress()),
+        .Block => fromAddress(self.asBlockObject().clone(token, actor_id).asObjectAddress()),
+        .ByteArray => fromAddress(self.asByteArrayObject().clone(token, actor_id).asObjectAddress()),
+        .Array => fromAddress(self.asArrayObject().clone(token, actor_id).asObjectAddress()),
         // Managed values are not clonable. Instead we return the same (immutable) reference.
         .Managed => self,
         .Actor => @panic("TODO Handle cloning of actor object"),
-        .ActorProxy => fromAddress((try self.asActorProxyObject().clone(heap, actor_id)).asObjectAddress()),
+        .ActorProxy => fromAddress(self.asActorProxyObject().clone(token, actor_id).asObjectAddress()),
     };
 }