tiny.quic.sim

1/// A nanosecond counter a test owns and moves forward itself. A test holds a manual clock and2/// passes its reading wherever a connection or a link asks for the current time. The clock starts3/// at zero. A test alone moves the clock, so the test decides the exact instant of every step.4pub const Clock = struct {5    now_ns: u64 = 0,67    /// Moves the clock forward by a given number of nanoseconds so a test puts a chosen span of8    /// time between steps. At the largest representable instant the clock stops there, so the9    /// reading never goes backward.10    pub fn advance(self: *Clock, delta_ns: u64) void {11        const previous = self.now_ns;12        self.now_ns = std.math.add(u64, self.now_ns, delta_ns) catch13            std.math.maxInt(u64);14        std.debug.assert(self.now_ns >= previous);15        if (self.now_ns != std.math.maxInt(u64)) {16            std.debug.assert(self.now_ns - previous == delta_ns);17        }18    }19};

1/// The exact storage layout and byte total derived from one set of limits, so a caller learns the2/// exact byte count its storage must have. The total covers queue records and payload bytes for3/// both directions. Limits whose product overflows give `CapacityOverflow`.4pub const Capacity = struct {5    queue_capacity: u32,6    datagram_capacity: u16,7    entry_count: usize,8    entry_bytes: usize,9    direction_payload_bytes: usize,10    payload_bytes: usize,11    storage_bytes: usize,1213    pub const DeriveError: type = CapacityError;1415    pub fn derive(limits: Limits) DeriveError!Capacity {16        const queue_count: usize = @intCast(limits.queue_capacity);17        const datagram_bytes: usize = @intCast(limits.datagram_capacity);18        const entry_count = try alloc_phase.capacity.mul(usize, queue_count, 2);19        const entry_bytes = try alloc_phase.capacity.mul(20            usize,21            entry_count,22            @sizeOf(Entry),23        );24        const direction_payload_bytes = try alloc_phase.capacity.mul(25            usize,26            queue_count,27            datagram_bytes,28        );29        const payload_bytes = try alloc_phase.capacity.mul(30            usize,31            direction_payload_bytes,32            2,33        );34        const storage_bytes = try alloc_phase.capacity.add(35            usize,36            entry_bytes,37            payload_bytes,38        );39        return .{40            .queue_capacity = limits.queue_capacity,41            .datagram_capacity = limits.datagram_capacity,42            .entry_count = entry_count,43            .entry_bytes = entry_bytes,44            .direction_payload_bytes = direction_payload_bytes,45            .payload_bytes = payload_bytes,46            .storage_bytes = storage_bytes,47        };48    }49};

1pub const CapacityError = error{CapacityOverflow};

1/// One of the link's two endpoints, `a` and `b`, so every call that sends, receives, or reads2/// counters names the endpoint it speaks for. Naming an endpoint picks the queue: a send goes into3/// the queue that endpoint owns, and a receive takes from the other one.4pub const End = enum(u1) {5    a,6    b,7};

1/// The two capacities a caller chooses to set how much traffic the link must hold and derive its2/// storage size: the datagrams one direction may hold at once, and the bytes one datagram may3/// carry. Both directions get the same capacities.4pub const Limits = struct {5    queue_capacity: u32,6    datagram_capacity: u16,7};

1/// A two-ended path that carries opaque datagrams between its endpoints over caller-owned memory,2/// on a schedule the caller can reproduce, so a test holds one and drives both endpoints of a3/// simulated path through it. The link holds one policy per direction, a generator started from the4/// caller's seed, the counters, the send order, and the pending drop patterns. The same seed and5/// the same sequence of calls give the same outcome every run, so a failing test can be replayed.6/// The bytes the link carries are opaque to it, so QUIC packets remain outside its view.7pub const Link = struct {8    memory: *Memory,9    policies: [2]Policy,10    prng: std.Random.DefaultPrng,11    counts: [2]Stats = .{ .{}, .{} },12    next_sequence: [2]u64 = .{ 0, 0 },13    drops: [2]u64 = .{ 0, 0 },1415    pub const InitError: type = LinkInitError;16    pub const SendError: type = LinkSendError;1718    /// Starts a link once over memory the caller has already built, with one policy for each19    /// direction and a seed for the delays and the chances, so the caller receives the value it20    /// drives. The call moves the memory from its initialization phase into its steady phase, after21    /// which the partition is fixed. Memory already past initialization gives `StorageNotReady`.22    /// Limits that differ from the ones the memory was built with give `LimitsMismatch`. Each23    /// policy is checked against the datagram capacity before anything is sealed, so an invalid24    /// policy fails here.25    pub fn init(26        limits: Limits,27        storage: *Memory,28        seed: u64,29        policy_a_to_b: Policy,30        policy_b_to_a: Policy,31    ) InitError!Link {32        if (storage.phase != .initialization) return error.StorageNotReady;33        if (storage.capacity.queue_capacity != limits.queue_capacity) {34            return error.LimitsMismatch;35        }36        if (storage.capacity.datagram_capacity != limits.datagram_capacity) {37            return error.LimitsMismatch;38        }39        try policy_a_to_b.validate(limits.datagram_capacity);40        try policy_b_to_a.validate(limits.datagram_capacity);41        storage.activate();42        return .{43            .memory = storage,44            .policies = .{ policy_a_to_b, policy_b_to_a },45            .prng = std.Random.DefaultPrng.init(seed),46        };47    }4849    /// Marks which of the next datagrams one endpoint sends are thrown away, by bit position,50    /// starting from bit 0 and covering the next 64, so a test loses exactly the datagrams it51    /// chooses at the moment it chooses. Only datagrams that pass the MTU check are counted against52    /// the pattern, because the check comes first. A datagram dropped this way counts as sent and53    /// lost. A marked datagram draws nothing from the seeded generator, so marking a drop leaves54    /// the rest of the run unchanged. A subsequent call joins the new pattern with the bits still55    /// pending, and both are counted from the next datagram.56    pub fn dropNext(self: *Link, from: End, pattern: u64) void {57        const direction_index = outgoingIndex(from);58        std.debug.assert(direction_index < self.drops.len);59        self.drops[direction_index] |= pattern;60        std.debug.assert(self.drops[direction_index] & pattern == pattern);61    }6263    /// Takes one datagram from an endpoint at a given instant and applies that direction's policy64    /// to it, so the link decides what becomes of the datagram. A datagram above the MTU is refused65    /// with `Oversize` and counted. A datagram the drop pattern names, or that the loss chance66    /// catches, is counted as sent and lost and stops there. A direction without room for the67    /// copies is refused with `QueueFull` before anything is queued. Otherwise the bytes are copied68    /// into the queue with a delivery time drawn from the policy's delay range, and the duplication69    /// chance may add a second copy with its own delay. The reordering chance trades the new copy's70    /// delivery time and send order with the most recently queued one.71    pub fn send(self: *Link, from: End, bytes: []const u8, now_ns: u64) SendError!void {72        const direction_index = outgoingIndex(from);73        const policy = self.policies[direction_index];74        const mtu: usize = policy.effectiveMtu(self.memory.capacity.datagram_capacity);75        if (bytes.len > mtu) {76            increment(&self.counts[direction_index].oversize);77            return error.Oversize;78        }79        const dropped = self.takeDrop(direction_index);80        if (dropped or self.event(policy.loss_permille)) {81            increment(&self.counts[direction_index].sent);82            increment(&self.counts[direction_index].lost);83            return;84        }85        const duplicate = self.event(policy.duplicate_permille);86        const copies: u2 = if (duplicate) 2 else 1;87        self.memory.requireFree(from, copies) catch {88            increment(&self.counts[direction_index].queue_full);89            return error.QueueFull;90        };91        const reorder = self.event(policy.reorder_permille);92        const previous = if (reorder) self.previousIndex(direction_index) else null;93        const first_delay = self.delay(policy);94        const second_delay = if (duplicate) self.delay(policy) else 0;95        increment(&self.counts[direction_index].sent);96        const first = self.enqueue(direction_index, bytes, deliveryAt(now_ns, first_delay));97        if (duplicate) {98            _ = self.enqueue(direction_index, bytes, deliveryAt(now_ns, second_delay));99            increment(&self.counts[direction_index].duplicated);100        }101        if (previous) |previous_index| {102            self.swapDelivery(direction_index, first.index, previous_index);103            increment(&self.counts[direction_index].reordered);104        }105    }106107    /// Copies the earliest datagram due at one endpoint by a given instant into the caller's buffer108    /// and returns its length, so the destination endpoint receives whatever has arrived. The call109    /// yields null before any datagram becomes due. Ties between equal delivery times go to the110    /// earlier send order, so a reordered pair keeps a definite order. The caller's buffer holds at111    /// least the datagram capacity, which debug builds check. The buffer lies outside the link's112    /// own bytes, because the copy assumes they do not overlap. Taking a datagram frees its queue113    /// slot for the next send.114    pub fn receive(self: *Link, at: End, now_ns: u64, out: []u8) ?usize {115        const direction_index = incomingIndex(at);116        const entry_index = self.earliestIndex(direction_index) orelse return null;117        const direction = &self.memory.directions[direction_index];118        const entry = &direction.entries[entry_index];119        if (entry.delivery_at_ns > now_ns) return null;120        const length: usize = @intCast(entry.length);121        std.debug.assert(out.len >= self.memory.capacity.datagram_capacity);122        const payload = payloadAt(123            direction,124            entry_index,125            self.memory.capacity.datagram_capacity,126        );127        @memcpy(out[0..length], payload[0..length]);128        self.memory.release(direction_index, entry_index);129        increment(&self.counts[direction_index].delivered);130        return length;131    }132133    /// Returns the instant at which the earliest pending datagram becomes due at one endpoint, so a134    /// test driving a manual clock learns how far time may move before something arrives. An empty135    /// queue gives null.136    pub fn nextDeliveryAt(self: *const Link, at: End) ?u64 {137        const direction_index = incomingIndex(at);138        const entry_index = self.earliestIndex(direction_index) orelse return null;139        return self.memory.directions[direction_index].entries[entry_index].delivery_at_ns;140    }141142    /// Returns a copy of the counters for the datagrams one endpoint sent, so a test reads what the143    /// path did to those datagrams after a run. The delivery count belongs to the sending direction144    /// too, because the receiving endpoint's take is counted against the queue it came from.145    pub fn stats(self: *const Link, from: End) Stats {146        return self.counts[outgoingIndex(from)];147    }148149    fn event(self: *Link, permille: u16) bool {150        std.debug.assert(permille <= 1000);151        if (permille == 0) return false;152        if (permille == 1000) return true;153        return self.prng.random().uintLessThan(u16, 1000) < permille;154    }155156    fn takeDrop(self: *Link, direction_index: usize) bool {157        std.debug.assert(direction_index < self.drops.len);158        const pattern = self.drops[direction_index];159        self.drops[direction_index] = pattern >> 1;160        const dropped = pattern & 1 != 0;161        const remaining = @popCount(self.drops[direction_index]);162        std.debug.assert(remaining + @intFromBool(dropped) == @popCount(pattern));163        return dropped;164    }165166    fn delay(self: *Link, policy: Policy) u64 {167        std.debug.assert(policy.delay_min_ns <= policy.delay_max_ns);168        if (policy.delay_min_ns == policy.delay_max_ns) return policy.delay_min_ns;169        const span = policy.delay_max_ns - policy.delay_min_ns;170        const offset = if (span == std.math.maxInt(u64))171            self.prng.random().int(u64)172        else173            self.prng.random().uintLessThan(u64, span + 1);174        return policy.delay_min_ns + offset;175    }176177    fn enqueue(178        self: *Link,179        direction_index: usize,180        bytes: []const u8,181        delivery_at_ns: u64,182    ) EntryRef {183        const acquired = self.memory.acquire(direction_index) catch unreachable;184        std.debug.assert(bytes.len <= acquired.payload.len);185        const sequence = self.takeSequence(direction_index);186        @memcpy(acquired.payload[0..bytes.len], bytes);187        acquired.entry.* = .{188            .delivery_at_ns = delivery_at_ns,189            .sequence = sequence,190            .length = @intCast(bytes.len),191            .occupied = true,192        };193        return acquired;194    }195196    fn takeSequence(self: *Link, direction_index: usize) u64 {197        std.debug.assert(direction_index < self.next_sequence.len);198        std.debug.assert(self.next_sequence[direction_index] < std.math.maxInt(u64));199        const sequence = self.next_sequence[direction_index];200        self.next_sequence[direction_index] += 1;201        return sequence;202    }203204    fn previousIndex(self: *const Link, direction_index: usize) ?usize {205        const entries = self.memory.directions[direction_index].entries;206        var selected: ?usize = null;207        for (entries, 0..) |entry, index| {208            if (!entry.occupied) continue;209            if (selected == null) selected = index;210            if (selected) |current| {211                if (entry.sequence > entries[current].sequence) selected = index;212            }213        }214        return selected;215    }216217    fn earliestIndex(self: *const Link, direction_index: usize) ?usize {218        const entries = self.memory.directions[direction_index].entries;219        var selected: ?usize = null;220        for (entries, 0..) |entry, index| {221            if (!entry.occupied) continue;222            if (selected == null) selected = index;223            if (selected) |current| {224                if (entry.delivery_at_ns < entries[current].delivery_at_ns) selected = index;225                if (entry.delivery_at_ns != entries[current].delivery_at_ns) continue;226                if (entry.sequence < entries[current].sequence) selected = index;227            }228        }229        return selected;230    }231232    fn swapDelivery(self: *Link, direction_index: usize, first: usize, second: usize) void {233        const entries = self.memory.directions[direction_index].entries;234        std.debug.assert(first < entries.len);235        std.debug.assert(second < entries.len);236        std.mem.swap(u64, &entries[first].delivery_at_ns, &entries[second].delivery_at_ns);237        std.mem.swap(u64, &entries[first].sequence, &entries[second].sequence);238    }239};

1/// The owner of the queue records and payload bytes a link runs on, so one aligned block handed2/// over by the caller becomes the only memory the link ever writes to. The owner takes one3/// caller-provided aligned byte block and partitions it into the two directions' records and4/// payload regions. A block whose length differs from the derived total gives5/// `StorageLengthMismatch`. The owner allocates nothing further, so the link's memory use is fixed6/// once the block is handed over. Teardown returns the block to the caller.7pub const Memory = struct {8    phase: alloc_phase.capacity.Phase,9    capacity: MemoryCapacity,10    storage: Storage,11    directions: [2]Direction,1213    pub const storage_alignment: usize = @alignOf(Entry);14    pub const Storage = []align(storage_alignment) u8;15    pub const Limits: type = MemoryLimits;16    pub const Capacity: type = MemoryCapacity;17    pub const Exhaustion = error{QueueFull};18    pub const InitError = MemoryCapacity.DeriveError || error{StorageLengthMismatch};19    pub const work_limits: alloc_phase.capacity.WorkLimits = .{20        .transition_steps_max = 1,21        .cleanup_steps_per_call_max = 0,22        .cleanup_calls_at_capacity_max = 0,23    };2425    pub const claim: alloc_phase.capacity.Declaration = .{26        .source = .{27            .id = "quic.sim_memory",28            .kind = .phase_static,29            .limit_source = .caller,30            .storage = .{31                .covered = &.{32                    .{33                        .id = "two_direction_queue_metadata",34                        .lifetime = .transferred,35                        .detail = "caller storage for two bounded datagram metadata queues",36                    },37                    .{38                        .id = "two_direction_datagram_payload_bytes",39                        .lifetime = .transferred,40                        .detail = "caller storage for two bounded datagram payload regions",41                    },42                },43                .excluded = &.{44                    "link policies, deterministic random state, statistics, and sequence counters",45                    "per-direction drop patterns",46                    "caller send slices and receive output slices",47                    "socket, thread, clock, and operating-system state",48                },49            },50            .capacity = .{51                .inputs = &.{52                    alloc_phase.capacity.bindInput(53                        MemoryLimits,54                        "queue_capacity",55                        "queue_capacity",56                    ),57                    alloc_phase.capacity.bindInput(58                        MemoryLimits,59                        "datagram_capacity",60                        "datagram_capacity",61                    ),62                },63                .type_selectors = &.{64                    alloc_phase.capacity.bindType(Entry, "entry"),65                },66                .nodes = &.{67                    .{ .input = 0 },68                    .{ .constant = 2 },69                    .{ .product = .{ .left = 0, .right = 1 } },70                    .{ .scale = .{71                        .node = 2,72                        .coefficient = .{ .size_of_concrete_type = 0 },73                    } },74                    .{ .input = 1 },75                    .{ .product = .{ .left = 2, .right = 4 } },76                    .{ .add = .{ .left = 3, .right = 5 } },77                },78                .assertions = &.{.{79                    .scope = .closure_total,80                    .measure = .retained,81                    .relation = .exact,82                    .expression = 6,83                }},84            },85            .overload = .{86                .kind = .reject_before_mutation,87                .detail = "full direction admission preserves queue metadata and payload bytes",88            },89            .risks = .{90                .transitive = .{91                    .status = .witnessed,92                    .detail = "link operations use only fixed scans and caller-owned byte slices",93                },94                .foreign = .{95                    .status = .excluded,96                    .detail = "simulator memory crosses no operating-system or foreign boundary",97                },98            },99            .work = .{100                .equation = "send and receive scan at most queue_capacity entries per direction",101            },102            .obligations = &.{103                .{ .key = "quic_sim_memory_capacity", .role = .capacity_model },104                .{ .key = "quic_sim_memory_overload", .role = .overload },105                .{ .key = "quic_sim_memory_transitive", .role = .transitive_risk },106                .{ .key = "quic_sim_memory_work", .role = .work_bound },107            },108        },109        .bindings = .{110            .owner = @This(),111            .seal = .{112                .family = alloc_phase.capacity.selector(@This().activate),113                .premise = .{114                    .class = .checked_semantic_fact,115                    .authority = .checker,116                },117            },118            .teardown = .{119                .family = alloc_phase.capacity.selector(@This().deinit),120                .premise = .{121                    .class = .checked_semantic_fact,122                    .authority = .checker,123                },124            },125        },126    };127128    pub fn init(storage: Storage, limits: MemoryLimits) InitError!Memory {129        const capacity = try MemoryCapacity.derive(limits);130        if (storage.len != capacity.storage_bytes) return error.StorageLengthMismatch;131        const entries = std.mem.bytesAsSlice(Entry, storage[0..capacity.entry_bytes]);132        for (entries) |*entry| entry.* = .{};133        const queue_count: usize = @intCast(capacity.queue_capacity);134        const payload = storage[capacity.entry_bytes..];135        return .{136            .phase = .initialization,137            .capacity = capacity,138            .storage = storage,139            .directions = .{140                .{141                    .entries = entries[0..queue_count],142                    .payload = payload[0..capacity.direction_payload_bytes],143                },144                .{145                    .entries = entries[queue_count..],146                    .payload = payload[capacity.direction_payload_bytes..],147                },148            },149        };150    }151152    pub fn activate(self: *Memory) void {153        std.debug.assert(self.phase == .initialization);154        std.debug.assert(self.storage.len == self.capacity.storage_bytes);155        std.debug.assert(self.directions[0].used == 0);156        std.debug.assert(self.directions[1].used == 0);157        self.phase = .steady;158    }159160    fn freeCount(self: *const Memory, direction_index: usize) u32 {161        std.debug.assert(self.phase == .steady);162        std.debug.assert(direction_index < self.directions.len);163        const direction = &self.directions[direction_index];164        std.debug.assert(direction.used <= self.capacity.queue_capacity);165        return self.capacity.queue_capacity - direction.used;166    }167168    /// Reports whether one direction has room for a given number of further datagrams before the169    /// link queues anything, so a full direction is refused before any byte moves. Too little room170    /// gives `QueueFull`. The check reads the queue and changes nothing, so a refusal leaves the171    /// queued datagrams as they were.172    pub fn requireFree(self: *const Memory, from: End, copies: u2) Exhaustion!void {173        std.debug.assert(copies > 0);174        if (self.freeCount(outgoingIndex(from)) < copies) return error.QueueFull;175    }176177    fn acquire(self: *Memory, direction_index: usize) Exhaustion!EntryRef {178        std.debug.assert(self.phase == .steady);179        std.debug.assert(direction_index < self.directions.len);180        var direction = &self.directions[direction_index];181        if (direction.used == self.capacity.queue_capacity) return error.QueueFull;182        for (direction.entries, 0..) |*entry, index| {183            if (entry.occupied) continue;184            entry.occupied = true;185            direction.used += 1;186            return .{187                .index = index,188                .entry = entry,189                .payload = payloadAt(direction, index, self.capacity.datagram_capacity),190            };191        }192        unreachable;193    }194195    fn release(self: *Memory, direction_index: usize, entry_index: usize) void {196        std.debug.assert(self.phase == .steady);197        std.debug.assert(direction_index < self.directions.len);198        var direction = &self.directions[direction_index];199        std.debug.assert(entry_index < direction.entries.len);200        std.debug.assert(direction.entries[entry_index].occupied);201        std.debug.assert(direction.used > 0);202        direction.entries[entry_index].occupied = false;203        direction.used -= 1;204    }205206    pub fn deinit(self: *Memory) Storage {207        std.debug.assert(self.phase == .steady);208        self.phase = .teardown;209        const storage = self.storage;210        self.* = undefined;211        return storage;212    }213};

1/// Impairments one direction of a simulated link applies, so a test builds one per direction and2/// hands both to the link at startup. The link consults the policy on every send in that direction,3/// and the two directions carry their own values. The default policy is a clean path: no loss, no4/// duplication, no reordering, no delay, and the caller's full datagram capacity.5pub const Policy = struct {6    /// The chance out of one thousand, or permille, that the link drops a datagram it has accepted,7    /// so a test makes the link throw datagrams away. A dropped datagram raises the sent count and8    /// the lost count together.9    loss_permille: u16 = 0,10    /// The chance out of one thousand that the link queues a second copy of a datagram, so a test11    /// makes the peer see a datagram twice. The two copies draw their delivery delays separately.12    duplicate_permille: u16 = 0,13    /// The chance out of one thousand that a newly queued copy trades delivery times with the most14    /// recently queued one, so a test makes datagrams arrive out of order. The swap covers the15    /// delivery time and the send order together, so the two copies exchange places in the queue.16    reorder_permille: u16 = 0,17    /// The smallest delivery delay in nanoseconds, which is itself a possible draw, so a test gives18    /// the path a floor on its latency.19    delay_min_ns: u64 = 0,20    /// The largest delivery delay in nanoseconds, which is itself a possible draw, so a test gives21    /// the path a ceiling on its latency. Each datagram takes a delay drawn uniformly between the22    /// two bounds.23    delay_max_ns: u64 = 0,24    /// The largest datagram in bytes the link will accept in this direction, or MTU, so a test25    /// makes the path refuse datagrams above a chosen size. Zero selects the caller's datagram26    /// capacity. A larger send is refused with `Oversize` and counted.27    mtu: u16 = 0,2829    pub const ValidationError: type = PolicyValidationError;3031    /// Checks one policy against the caller's datagram capacity for the link at startup so a32    /// nonsensical policy fails before any datagram moves. A loss, duplication, or reordering33    /// chance above one thousand gives `InvalidPermille`. A smallest delay above the largest gives34    /// `InvalidDelayBounds`. An MTU above the caller's datagram capacity gives35    /// `MtuExceedsCapacity`.36    pub fn validate(self: Policy, datagram_capacity: u16) PolicyValidationError!void {37        if (self.loss_permille > 1000) return error.InvalidPermille;38        if (self.duplicate_permille > 1000) return error.InvalidPermille;39        if (self.reorder_permille > 1000) return error.InvalidPermille;40        if (self.delay_min_ns > self.delay_max_ns) return error.InvalidDelayBounds;41        if (self.mtu > datagram_capacity) return error.MtuExceedsCapacity;42        std.debug.assert(self.loss_permille <= 1000);43        std.debug.assert(self.duplicate_permille <= 1000);44        std.debug.assert(self.reorder_permille <= 1000);45        std.debug.assert(self.delay_min_ns <= self.delay_max_ns);46        std.debug.assert(self.mtu <= datagram_capacity);47    }4849    /// Returns the policy's own MTU, or the caller's datagram capacity when the policy leaves it at50    /// zero, so the link gets the size it must compare against on every send. The result is at most51    /// the caller's datagram capacity.52    pub fn effectiveMtu(self: Policy, datagram_capacity: u16) u16 {53        std.debug.assert(self.mtu <= datagram_capacity);54        const result = if (self.mtu == 0) datagram_capacity else self.mtu;55        std.debug.assert(result <= datagram_capacity);56        return result;57    }58};

1pub const ValidationError = error{2    InvalidDelayBounds,3    InvalidPermille,4    MtuExceedsCapacity,5};

1/// The counters one direction of a simulated link keeps. A test reads one after a run to check how2/// many datagrams the link dropped, duplicated, or reordered. It counts datagrams the caller sent,3/// datagrams delivered, datagrams lost, extra copies made, copies whose delivery time was swapped,4/// sends refused for a full queue, and sends refused for exceeding the MTU. Every counter starts at5/// zero.6pub const Stats = struct {7    sent: u64 = 0,8    delivered: u64 = 0,9    lost: u64 = 0,10    duplicated: u64 = 0,11    reordered: u64 = 0,12    queue_full: u64 = 0,13    oversize: u64 = 0,14};

1pub const sim = @import("sim/root.zig");

1const clock = @import("clock.zig");2const link = @import("link.zig");3const policy = @import("policy.zig");4const stats = @import("stats.zig");56pub const Clock = clock.Clock;7pub const Capacity = link.Capacity;8pub const CapacityError = link.CapacityError;9pub const End = link.End;10pub const Limits = link.Limits;11pub const Link = link.Link;12pub const Memory = link.Memory;13pub const Policy = policy.Policy;14pub const PolicyError = policy.ValidationError;15pub const Stats = stats.Stats;