tiny.memtrace.IntervalSink

1/// A pair of borrowed callbacks that report the beginning and the end of a2/// phase, identified by a category byte. A caller with its own profiler uses3/// them to report memtrace's phase boundaries into that profiler. `begin` takes4/// the category and answers with a token, `end` takes that token back, and5/// neither call can fail. The owner keeps `context` alive for as long as the6/// sink is in use, because both callbacks receive it unchanged. A token is7/// closed from the thread that opened it, before any token opened after it,8/// which is the order `Context.enterInterval` and `IntervalSpan.exit` produce9/// when the spans nest lexically. The callbacks carry no synchronization of10/// their own, so one thread at a time uses a sink. `begin` answers with11/// `invalid_token` to decline a span, and the matching exit then calls nothing.12pub const IntervalSink = struct {13    pub const invalid_token = std.math.maxInt(u16);1415    context: *anyopaque,16    begin_fn: *const fn (*anyopaque, u8) u16,17    end_fn: *const fn (*anyopaque, u16) void,1819    pub fn begin(self: IntervalSink, category: u8) u16 {20        return self.begin_fn(self.context, category);21    }2223    pub fn end(self: IntervalSink, token: u16) void {24        self.end_fn(self.context, token);25    }26};

1pub const IntervalSink = context_mod.IntervalSink;