tigerbeetle-node 0.4.2 → 0.5.2

package/src/tigerbeetle/src/main.zig

@@ -20,12 +20,20 @@ const vsr = @import("vsr.zig");
 const Replica = vsr.Replica(StateMachine, MessageBus, Storage, Time);
 
 pub fn main() !void {
-    var arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-    const arena = &arena_allocator.allocator;
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
 
-    switch (cli.parse_args(arena)) {
-        .init => |args| try init(arena, args.cluster, args.replica, args.dir_fd),
-        .start => |args| try start(arena, args.cluster, args.replica, args.addresses, args.dir_fd),
+    const allocator = arena.allocator();
+
+    switch (cli.parse_args(allocator)) {
+        .init => |args| try init(args.cluster, args.replica, args.dir_fd),
+        .start => |args| try start(
+            allocator,
+            args.cluster,
+            args.replica,
+            args.addresses,
+            args.dir_fd,
+        ),
     }
 }
 
@@ -34,7 +42,7 @@ const filename_fmt = "cluster_{d:0>10}_replica_{d:0>3}.tigerbeetle";
 const filename_len = fmt.count(filename_fmt, .{ 0, 0 });
 
 /// Create a .tigerbeetle data file for the given args and exit
-fn init(arena: *mem.Allocator, cluster: u32, replica: u8, dir_fd: os.fd_t) !void {
+fn init(cluster: u32, replica: u8, dir_fd: os.fd_t) !void {
     // Add 1 for the terminating null byte
     var buffer: [filename_len + 1]u8 = undefined;
     const filename = fmt.bufPrintZ(&buffer, filename_fmt, .{ cluster, replica }) catch unreachable;
@@ -53,7 +61,7 @@ fn init(arena: *mem.Allocator, cluster: u32, replica: u8, dir_fd: os.fd_t) !void
 
 /// Run as a replica server defined by the given args
 fn start(
-    arena: *mem.Allocator,
+    allocator: mem.Allocator,
     cluster: u32,
     replica_index: u8,
     addresses: []std.net.Address,
@@ -75,14 +83,14 @@ fn start(
     );
     var io = try IO.init(128, 0);
     var state_machine = try StateMachine.init(
-        arena,
+        allocator,
         config.accounts_max,
         config.transfers_max,
         config.commits_max,
     );
     var storage = try Storage.init(config.journal_size_max, storage_fd, &io);
     var message_bus = try MessageBus.init(
-        arena,
+        allocator,
         cluster,
         addresses,
         replica_index,
@@ -90,7 +98,7 @@ fn start(
     );
     var time: Time = .{};
     var replica = try Replica.init(
-        arena,
+        allocator,
         cluster,
         @intCast(u8, addresses.len),
         replica_index,

package/src/tigerbeetle/src/message_bus.zig

@@ -1,10 +1,10 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const assert = std.debug.assert;
 const mem = std.mem;
 const os = std.os;
 
-const is_darwin = std.Target.current.isDarwin();
-const sock_flags = os.SOCK_CLOEXEC | (if (is_darwin) os.SOCK_NONBLOCK else 0);
+const is_linux = builtin.target.os.tag == .linux;
 
 const config = @import("config.zig");
 const log = std.log.scoped(.message_bus);
@@ -54,8 +54,8 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
 
         /// The callback to be called when a message is received. Use set_on_message() to set
         /// with type safety for the context pointer.
-        on_message_callback: ?fn (context: ?*c_void, message: *Message) void = null,
-        on_message_context: ?*c_void = null,
+        on_message_callback: ?fn (context: ?*anyopaque, message: *Message) void = null,
+        on_message_context: ?*anyopaque = null,
 
         /// This slice is allocated with a fixed size in the init function and never reallocated.
         connections: []Connection,
@@ -75,7 +75,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
 
         /// Initialize the MessageBus for the given cluster, configuration and replica/client process.
         pub fn init(
-            allocator: *mem.Allocator,
+            allocator: mem.Allocator,
             cluster: u32,
             configuration: []std.net.Address,
             process: switch (process_type) {
@@ -124,7 +124,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
 
             // Pre-allocate enough memory to hold all possible connections in the client map.
             if (process_type == .replica) {
-                try bus.process.clients.ensureCapacity(allocator, config.connections_max);
+                try bus.process.clients.ensureTotalCapacity(allocator, config.connections_max);
             }
 
             return bus;
@@ -140,7 +140,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
             assert(bus.on_message_context == null);
 
             bus.on_message_callback = struct {
-                fn wrapper(_context: ?*c_void, message: *Message) void {
+                fn wrapper(_context: ?*anyopaque, message: *Message) void {
                     on_message(@intToPtr(Context, @ptrToInt(_context)), message);
                 }
             }.wrapper;
@@ -148,13 +148,13 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
         }
 
         /// TODO This is required by the Client.
-        pub fn deinit(bus: *Self) void {}
+        pub fn deinit(_: *Self) void {}
 
         fn init_tcp(address: std.net.Address) !os.socket_t {
-            const fd = try os.socket(
+            const fd = try IO.openSocket(
                 address.any.family,
-                os.SOCK_STREAM | sock_flags,
-                os.IPPROTO_TCP,
+                os.SOCK.STREAM,
+                os.IPPROTO.TCP,
             );
             errdefer os.close(fd);
 
@@ -164,71 +164,55 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                 }
             }.set;
 
-            // darwin doesn't support os.MSG_NOSIGNAL, but instead a socket option to avoid SIGPIPE.
-            if (is_darwin) {
-                try set(fd, os.SOL_SOCKET, os.SO_NOSIGPIPE, 1);
-            }
-
-            // Set tcp recv buffer size
             if (config.tcp_rcvbuf > 0) rcvbuf: {
-                if (!is_darwin) {
+                if (is_linux) {
                     // Requires CAP_NET_ADMIN privilege (settle for SO_RCVBUF in case of an EPERM):
-                    if (set(fd, os.SOL_SOCKET, os.SO_RCVBUFFORCE, config.tcp_rcvbuf)) |_| {
+                    if (set(fd, os.SOL.SOCKET, os.SO.RCVBUFFORCE, config.tcp_rcvbuf)) |_| {
                         break :rcvbuf;
                     } else |err| switch (err) {
                         error.PermissionDenied => {},
                         else => |e| return e,
                     }
                 }
-                try set(fd, os.SOL_SOCKET, os.SO_RCVBUF, config.tcp_rcvbuf);
+                try set(fd, os.SOL.SOCKET, os.SO.RCVBUF, config.tcp_rcvbuf);
             }
 
-            // Set tcp send buffer size
             if (config.tcp_sndbuf > 0) sndbuf: {
-                if (!is_darwin) {
+                if (is_linux) {
                     // Requires CAP_NET_ADMIN privilege (settle for SO_SNDBUF in case of an EPERM):
-                    if (set(fd, os.SOL_SOCKET, os.SO_SNDBUFFORCE, config.tcp_sndbuf)) |_| {
+                    if (set(fd, os.SOL.SOCKET, os.SO.SNDBUFFORCE, config.tcp_sndbuf)) |_| {
                         break :sndbuf;
                     } else |err| switch (err) {
                         error.PermissionDenied => {},
                         else => |e| return e,
                     }
                 }
-                try set(fd, os.SOL_SOCKET, os.SO_SNDBUF, config.tcp_sndbuf);
+                try set(fd, os.SOL.SOCKET, os.SO.SNDBUF, config.tcp_sndbuf);
             }
 
-            // Set tcp keep alive
             if (config.tcp_keepalive) {
-                try set(fd, os.SOL_SOCKET, os.SO_KEEPALIVE, 1);
-                if (!is_darwin) {
-                    try set(fd, os.IPPROTO_TCP, os.TCP_KEEPIDLE, config.tcp_keepidle);
-                    try set(fd, os.IPPROTO_TCP, os.TCP_KEEPINTVL, config.tcp_keepintvl);
-                    try set(fd, os.IPPROTO_TCP, os.TCP_KEEPCNT, config.tcp_keepcnt);
+                try set(fd, os.SOL.SOCKET, os.SO.KEEPALIVE, 1);
+                if (is_linux) {
+                    try set(fd, os.IPPROTO.TCP, os.TCP.KEEPIDLE, config.tcp_keepidle);
+                    try set(fd, os.IPPROTO.TCP, os.TCP.KEEPINTVL, config.tcp_keepintvl);
+                    try set(fd, os.IPPROTO.TCP, os.TCP.KEEPCNT, config.tcp_keepcnt);
                 }
             }
 
-            // Set tcp user timeout
             if (config.tcp_user_timeout > 0) {
-                if (!is_darwin) {
-                    try set(fd, os.IPPROTO_TCP, os.TCP_USER_TIMEOUT, config.tcp_user_timeout);
+                if (is_linux) {
+                    try set(fd, os.IPPROTO.TCP, os.TCP.USER_TIMEOUT, config.tcp_user_timeout);
                 }
             }
 
             // Set tcp no-delay
             if (config.tcp_nodelay) {
-                const TCP_NODELAY: ?u32 = if (@hasDecl(os, "TCP_NODELAY"))
-                    @as(u32, os.TCP_NODELAY)
-                else if (is_darwin)
-                    @as(u32, 1)
-                else
-                    null;
-
-                if (TCP_NODELAY) |tcp_nodelay| {
-                    try set(fd, os.IPPROTO_TCP, tcp_nodelay, 1);
+                if (is_linux) {
+                    try set(fd, os.IPPROTO.TCP, os.TCP.NODELAY, 1);
                 }
             }
 
-            try set(fd, os.SOL_SOCKET, os.SO_REUSEADDR, 1);
+            try set(fd, os.SOL.SOCKET, os.SO.REUSEADDR, 1);
             try os.bind(fd, &address.any, address.getOsSockLen());
             try os.listen(fd, config.tcp_backlog);
 
@@ -289,7 +273,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                 if (connection.state == .terminating) return;
             }
 
-            log.notice("all connections in use but not all replicas are connected, " ++
+            log.info("all connections in use but not all replicas are connected, " ++
                 "attempting to disconnect a client", .{});
             for (bus.connections) |*connection| {
                 if (connection.peer == .client) {
@@ -298,7 +282,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                 }
             }
 
-            log.notice("failed to disconnect a client as no peer was a known client, " ++
+            log.info("failed to disconnect a client as no peer was a known client, " ++
                 "attempting to disconnect an unknown peer.", .{});
             for (bus.connections) |*connection| {
                 if (connection.peer == .unknown) {
@@ -332,7 +316,6 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                 on_accept,
                 &bus.process.accept_completion,
                 bus.process.accept_fd,
-                sock_flags,
             );
         }
 
@@ -341,6 +324,8 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
             completion: *IO.Completion,
             result: IO.AcceptError!os.socket_t,
         ) void {
+            _ = completion;
+
             comptime assert(process_type == .replica);
             assert(bus.process.accept_connection != null);
             defer bus.process.accept_connection = null;
@@ -459,7 +444,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                 // The first replica's network address family determines the
                 // family for all other replicas:
                 const family = bus.configuration[0].any.family;
-                connection.fd = os.socket(family, os.SOCK_STREAM | sock_flags, 0) catch return;
+                connection.fd = IO.openSocket(family, os.SOCK.STREAM, os.IPPROTO.TCP) catch return;
                 connection.peer = .{ .replica = replica };
                 connection.state = .connecting;
                 bus.connections_used += 1;
@@ -469,7 +454,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
 
                 var attempts = &bus.replicas_connect_attempts[replica];
                 const ms = vsr.exponential_backoff_with_jitter(
-                    &bus.prng,
+                    bus.prng.random(),
                     config.connection_delay_min_ms,
                     config.connection_delay_max_ms,
                     attempts.*,
@@ -600,7 +585,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                 connection.send_queue.push(message.ref()) catch |err| switch (err) {
                     error.NoSpaceLeft => {
                         bus.unref(message);
-                        log.notice("message queue for peer {} full, dropping message", .{
+                        log.info("message queue for peer {} full, dropping message", .{
                             connection.peer,
                         });
                         return;
@@ -633,12 +618,12 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                         //
                         // TODO: Investigate differences between shutdown() on Linux vs Darwin.
                         // Especially how this interacts with our assumptions around pending I/O.
-                        const rc = os.system.shutdown(connection.fd, os.SHUT_RDWR);
+                        const rc = os.system.shutdown(connection.fd, os.SHUT.RDWR);
                         switch (os.errno(rc)) {
-                            0 => {},
-                            os.EBADF => unreachable,
-                            os.EINVAL => unreachable,
-                            os.ENOTCONN => {
+                            .SUCCESS => {},
+                            .BADF => unreachable,
+                            .INVAL => unreachable,
+                            .NOTCONN => {
                                 // This should only happen if we for some reason decide to terminate
                                 // a connection while a connect operation is in progress.
                                 // This is fine though, we simply continue with the logic below and
@@ -653,7 +638,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                                 //assert(connection.recv_submitted);
                                 //assert(!connection.send_submitted);
                             },
-                            os.ENOTSOCK => unreachable,
+                            .NOTSOCK => unreachable,
                             else => |err| os.unexpectedErrno(err) catch {},
                         }
                     },
@@ -886,7 +871,6 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                     &connection.recv_completion,
                     connection.fd,
                     connection.recv_message.?.buffer[connection.recv_progress..config.message_size_max],
-                    if (is_darwin) 0 else os.MSG_NOSIGNAL,
                 );
             }
 
@@ -919,7 +903,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                 assert(connection.peer == .client or connection.peer == .replica);
                 assert(connection.state == .connected);
                 assert(connection.fd != -1);
-                const message = connection.send_queue.peek() orelse return;
+                const message = connection.send_queue.head() orelse return;
                 assert(!connection.send_submitted);
                 connection.send_submitted = true;
                 bus.io.send(
@@ -929,7 +913,6 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                     &connection.send_completion,
                     connection.fd,
                     message.buffer[connection.send_progress..message.header.size],
-                    if (is_darwin) 0 else os.MSG_NOSIGNAL,
                 );
             }
 
@@ -949,9 +932,9 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                     connection.terminate(bus, .shutdown);
                     return;
                 };
-                assert(connection.send_progress <= connection.send_queue.peek_ptr().?.*.header.size);
+                assert(connection.send_progress <= connection.send_queue.head().?.header.size);
                 // If the message has been fully sent, move on to the next one.
-                if (connection.send_progress == connection.send_queue.peek_ptr().?.*.header.size) {
+                if (connection.send_progress == connection.send_queue.head().?.header.size) {
                     connection.send_progress = 0;
                     const message = connection.send_queue.pop().?;
                     bus.unref(message);

package/src/tigerbeetle/src/message_pool.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const assert = std.debug.assert;
 const mem = std.mem;
 
@@ -51,7 +52,7 @@ pub const MessagePool = struct {
     /// List of currently usused header-sized messages
     header_only_free_list: ?*Message,
 
-    pub fn init(allocator: *mem.Allocator) error{OutOfMemory}!MessagePool {
+    pub fn init(allocator: mem.Allocator) error{OutOfMemory}!MessagePool {
         var ret: MessagePool = .{
             .free_list = null,
             .header_only_free_list = null,
@@ -119,7 +120,7 @@ pub const MessagePool = struct {
     pub fn unref(pool: *MessagePool, message: *Message) void {
         message.references -= 1;
         if (message.references == 0) {
-            if (std.builtin.mode == .Debug) mem.set(u8, message.buffer, undefined);
+            if (builtin.mode == .Debug) mem.set(u8, message.buffer, undefined);
             if (message.header_only()) {
                 message.next = pool.header_only_free_list;
                 pool.header_only_free_list = message;

package/src/tigerbeetle/src/ring_buffer.zig

@@ -14,51 +14,84 @@ pub fn RingBuffer(comptime T: type, comptime size: usize) type {
         /// The number of items in the buffer.
         count: usize = 0,
 
-        /// Add an element to the RingBuffer. Returns an error if the buffer
-        /// is already full and the element could not be added.
-        pub fn push(self: *Self, item: T) error{NoSpaceLeft}!void {
-            if (self.full()) return error.NoSpaceLeft;
-            self.buffer[(self.index + self.count) % self.buffer.len] = item;
-            self.count += 1;
+        // TODO add doc comments to these functions:
+        pub inline fn head(self: Self) ?T {
+            if (self.empty()) return null;
+            return self.buffer[self.index];
         }
 
-        /// Return, but do not remove, the next item, if any.
-        pub fn peek(self: *Self) ?T {
-            return (self.peek_ptr() orelse return null).*;
+        pub inline fn head_ptr(self: *Self) ?*T {
+            if (self.empty()) return null;
+            return &self.buffer[self.index];
         }
 
-        /// Return a pointer to, but do not remove, the next item, if any.
-        pub fn peek_ptr(self: *Self) ?*T {
+        pub inline fn tail(self: Self) ?T {
             if (self.empty()) return null;
-            return &self.buffer[self.index];
+            return self.buffer[(self.index + self.count - 1) % self.buffer.len];
         }
 
-        /// Remove and return the next item, if any.
-        pub fn pop(self: *Self) ?T {
+        pub inline fn tail_ptr(self: *Self) ?*T {
             if (self.empty()) return null;
-            defer {
-                self.index = (self.index + 1) % self.buffer.len;
-                self.count -= 1;
-            }
-            return self.buffer[self.index];
+            return &self.buffer[(self.index + self.count - 1) % self.buffer.len];
+        }
+
+        pub inline fn next_tail(self: Self) ?T {
+            if (self.full()) return null;
+            return self.buffer[(self.index + self.count) % self.buffer.len];
+        }
+
+        pub inline fn next_tail_ptr(self: *Self) ?*T {
+            if (self.full()) return null;
+            return &self.buffer[(self.index + self.count) % self.buffer.len];
+        }
+
+        pub inline fn advance_head(self: *Self) void {
+            self.index += 1;
+            self.index %= self.buffer.len;
+            self.count -= 1;
+        }
+
+        pub inline fn advance_tail(self: *Self) void {
+            assert(self.count < self.buffer.len);
+            self.count += 1;
         }
 
         /// Returns whether the ring buffer is completely full.
-        pub fn full(self: *const Self) bool {
+        pub inline fn full(self: Self) bool {
             return self.count == self.buffer.len;
         }
 
         /// Returns whether the ring buffer is completely empty.
-        pub fn empty(self: *const Self) bool {
+        pub inline fn empty(self: Self) bool {
             return self.count == 0;
         }
 
+        // Higher level, less error-prone wrappers:
+
+        /// Add an element to the RingBuffer. Returns an error if the buffer
+        /// is already full and the element could not be added.
+        pub fn push(self: *Self, item: T) error{NoSpaceLeft}!void {
+            const ptr = self.next_tail_ptr() orelse return error.NoSpaceLeft;
+            ptr.* = item;
+            self.advance_tail();
+        }
+
+        /// Remove and return the next item, if any.
+        pub fn pop(self: *Self) ?T {
+            const result = self.head() orelse return null;
+            self.advance_head();
+            return result;
+        }
+
         pub const Iterator = struct {
             ring: *Self,
             count: usize = 0,
 
             pub fn next(it: *Iterator) ?T {
-                return (it.next_ptr() orelse return null).*;
+                assert(it.count <= it.ring.count);
+                if (it.count == it.ring.count) return null;
+                defer it.count += 1;
+                return it.ring.buffer[(it.ring.index + it.count) % it.ring.buffer.len];
             }
 
             pub fn next_ptr(it: *Iterator) ?*T {
@@ -79,43 +112,6 @@ pub fn RingBuffer(comptime T: type, comptime size: usize) type {
 
 const testing = std.testing;
 
-test "push/peek/pop/full/empty" {
-    var fifo = RingBuffer(u32, 3){};
-
-    try testing.expect(!fifo.full());
-    try testing.expect(fifo.empty());
-
-    try fifo.push(1);
-    try testing.expectEqual(@as(?u32, 1), fifo.peek());
-
-    try testing.expect(!fifo.full());
-    try testing.expect(!fifo.empty());
-
-    try fifo.push(2);
-    try testing.expectEqual(@as(?u32, 1), fifo.peek());
-
-    try fifo.push(3);
-    try testing.expectError(error.NoSpaceLeft, fifo.push(4));
-
-    try testing.expect(fifo.full());
-    try testing.expect(!fifo.empty());
-
-    try testing.expectEqual(@as(?u32, 1), fifo.peek());
-    try testing.expectEqual(@as(?u32, 1), fifo.pop());
-
-    try testing.expect(!fifo.full());
-    try testing.expect(!fifo.empty());
-
-    fifo.peek_ptr().?.* += 1000;
-
-    try testing.expectEqual(@as(?u32, 1002), fifo.pop());
-    try testing.expectEqual(@as(?u32, 3), fifo.pop());
-    try testing.expectEqual(@as(?u32, null), fifo.pop());
-
-    try testing.expect(!fifo.full());
-    try testing.expect(fifo.empty());
-}
-
 fn test_iterator(comptime T: type, ring: *T, values: []const u32) !void {
     const ring_index = ring.index;
 
@@ -133,22 +129,41 @@ fn test_iterator(comptime T: type, ring: *T, values: []const u32) !void {
     try testing.expectEqual(ring_index, ring.index);
 }
 
-test "iterator" {
+test "RingBuffer: low level interface" {
     const Ring = RingBuffer(u32, 2);
 
     var ring = Ring{};
     try test_iterator(Ring, &ring, &[_]u32{});
 
-    try ring.push(0);
+    try testing.expectEqual(@as(?u32, null), ring.head());
+    try testing.expectEqual(@as(?*u32, null), ring.head_ptr());
+    try testing.expectEqual(@as(?u32, null), ring.tail());
+    try testing.expectEqual(@as(?*u32, null), ring.tail_ptr());
+
+    ring.next_tail_ptr().?.* = 0;
+    ring.advance_tail();
+    try testing.expectEqual(@as(?u32, 0), ring.tail());
+    try testing.expectEqual(@as(u32, 0), ring.tail_ptr().?.*);
     try test_iterator(Ring, &ring, &[_]u32{0});
 
-    try ring.push(1);
+    ring.next_tail_ptr().?.* = 1;
+    ring.advance_tail();
+    try testing.expectEqual(@as(?u32, 1), ring.tail());
+    try testing.expectEqual(@as(u32, 1), ring.tail_ptr().?.*);
     try test_iterator(Ring, &ring, &[_]u32{ 0, 1 });
 
-    try testing.expectEqual(@as(?u32, 0), ring.pop());
+    try testing.expectEqual(@as(?u32, null), ring.next_tail());
+    try testing.expectEqual(@as(?*u32, null), ring.next_tail_ptr());
+
+    try testing.expectEqual(@as(?u32, 0), ring.head());
+    try testing.expectEqual(@as(u32, 0), ring.head_ptr().?.*);
+    ring.advance_head();
     try test_iterator(Ring, &ring, &[_]u32{1});
 
-    try ring.push(2);
+    ring.next_tail_ptr().?.* = 2;
+    ring.advance_tail();
+    try testing.expectEqual(@as(?u32, 2), ring.tail());
+    try testing.expectEqual(@as(u32, 2), ring.tail_ptr().?.*);
     try test_iterator(Ring, &ring, &[_]u32{ 1, 2 });
 
     var iterator = ring.iterator();
@@ -156,15 +171,67 @@ test "iterator" {
         item_ptr.* += 1000;
     }
 
-    try testing.expectEqual(@as(?u32, 1001), ring.pop());
+    try testing.expectEqual(@as(?u32, 1001), ring.head());
+    try testing.expectEqual(@as(u32, 1001), ring.head_ptr().?.*);
+    ring.advance_head();
     try test_iterator(Ring, &ring, &[_]u32{1002});
 
-    try ring.push(3);
+    ring.next_tail_ptr().?.* = 3;
+    ring.advance_tail();
+    try testing.expectEqual(@as(?u32, 3), ring.tail());
+    try testing.expectEqual(@as(u32, 3), ring.tail_ptr().?.*);
     try test_iterator(Ring, &ring, &[_]u32{ 1002, 3 });
 
-    try testing.expectEqual(@as(?u32, 1002), ring.pop());
+    try testing.expectEqual(@as(?u32, 1002), ring.head());
+    try testing.expectEqual(@as(u32, 1002), ring.head_ptr().?.*);
+    ring.advance_head();
     try test_iterator(Ring, &ring, &[_]u32{3});
 
-    try testing.expectEqual(@as(?u32, 3), ring.pop());
+    try testing.expectEqual(@as(?u32, 3), ring.head());
+    try testing.expectEqual(@as(u32, 3), ring.head_ptr().?.*);
+    ring.advance_head();
     try test_iterator(Ring, &ring, &[_]u32{});
+
+    try testing.expectEqual(@as(?u32, null), ring.head());
+    try testing.expectEqual(@as(?*u32, null), ring.head_ptr());
+    try testing.expectEqual(@as(?u32, null), ring.tail());
+    try testing.expectEqual(@as(?*u32, null), ring.tail_ptr());
+}
+
+test "RingBuffer: push/pop high level interface" {
+    var fifo = RingBuffer(u32, 3){};
+
+    try testing.expect(!fifo.full());
+    try testing.expect(fifo.empty());
+
+    try fifo.push(1);
+    try testing.expectEqual(@as(?u32, 1), fifo.head());
+
+    try testing.expect(!fifo.full());
+    try testing.expect(!fifo.empty());
+
+    try fifo.push(2);
+    try testing.expectEqual(@as(?u32, 1), fifo.head());
+
+    try fifo.push(3);
+    try testing.expectError(error.NoSpaceLeft, fifo.push(4));
+
+    try testing.expect(fifo.full());
+    try testing.expect(!fifo.empty());
+
+    try testing.expectEqual(@as(?u32, 1), fifo.head());
+    try testing.expectEqual(@as(?u32, 1), fifo.pop());
+
+    try testing.expect(!fifo.full());
+    try testing.expect(!fifo.empty());
+
+    try fifo.push(4);
+
+    try testing.expectEqual(@as(?u32, 2), fifo.pop());
+    try testing.expectEqual(@as(?u32, 3), fifo.pop());
+    try testing.expectEqual(@as(?u32, 4), fifo.pop());
+    try testing.expectEqual(@as(?u32, null), fifo.pop());
+
+    try testing.expect(!fifo.full());
+    try testing.expect(fifo.empty());
 }