From 7acdc54473b5c9f54582b5d3c465e89b92daf886 Mon Sep 17 00:00:00 2001 From: Jonathan Regan-Beasley <197533392+jregan-beasley-smc@users.noreply.github.com> Date: Sun, 11 Oct 2026 11:48:00 +1100 Subject: [PATCH 1/4] perf(qwen3_5 cuda): emit first tokens before initial drafts --- zig/src/core/lane_host.zig | 13 +- zig/src/core/lane_host_first_test.zig | 111 ++++++++++++++++ zig/src/core/lanes/admit_first.zig | 124 ++++++++++++++++++ zig/src/core/lanes/admit_first_test.zig | 165 ++++++++++++++++++++++++ zig/src/core/lanes/backend.zig | 7 + zig/src/core/lanes/engine.zig | 6 + zig/src/core/lanes/lanes.zig | 1 + zig/src/families/qwen27/cuda/lanes.zig | 4 +- zig/src/native/cuda.zig | 5 +- 9 files changed, 431 insertions(+), 5 deletions(-) create mode 100644 zig/src/core/lane_host_first_test.zig create mode 100644 zig/src/core/lanes/admit_first.zig create mode 100644 zig/src/core/lanes/admit_first_test.zig diff --git a/zig/src/core/lane_host.zig b/zig/src/core/lane_host.zig index 27dedfdc7..c6d2aaaa4 100644 --- a/zig/src/core/lane_host.zig +++ b/zig/src/core/lane_host.zig @@ -344,17 +344,25 @@ pub const LaneHost = struct { const errs = h.gpa.alloc(?anyerror, batch.items.len) catch return h.dropAll(batch.items, "out of memory"); defer h.gpa.free(errs); for (streams, batch.items) |*s, job| s.* = &job.stream; - h.core.addStreams(streams, errs) catch |e| return h.dropAll(batch.items, h.words(e)); + h.core.addStreamsCommitted(streams, errs, .{ .ptr = &batch, .call = firstCommitted }) catch |e| return h.dropAll(batch.items, h.words(e)); for (batch.items, errs) |job, err| { if (err) |e| { _ = if (e == error.Cancelled) h.cancel(job) else h.drop(job, h.words(e)); continue; } - h.prefilled(job, job.began); + if (!job.prefill_sent) h.prefilled(job, job.began); if (h.deliver(job)) h.remove(job); } } + fn firstCommitted(ptr: *anyopaque, index: usize) void { + const batch: *std.ArrayList(*Job) = @ptrCast(@alignCast(ptr)); + const job = batch.items[index]; + job.prefill_sent = true; + job.host.prefilled(job, job.began); + job.host.send(job); // finish only after admission returns: the core still owns its stream pointers + } + fn dropAll(h: *LaneHost, jobs: []const *Job, message: []const u8) void { for (jobs) |job| _ = h.drop(job, message); } @@ -587,4 +595,5 @@ pub const LaneHost = struct { test { _ = @import("lane_host_test.zig"); + _ = @import("lane_host_first_test.zig"); } diff --git a/zig/src/core/lane_host_first_test.zig b/zig/src/core/lane_host_first_test.zig new file mode 100644 index 000000000..1947f7985 --- /dev/null +++ b/zig/src/core/lane_host_first_test.zig @@ -0,0 +1,111 @@ +//! A committed admission handoff sends each token and row once and keeps terminal jobs owned until return. +const std = @import("std"); +const lanes = @import("lanes"); +const api = @import("engine_api.zig"); +const LaneHost = @import("lane_host.zig").LaneHost; +const gpa = std.testing.allocator; + +const Box = struct { + mutex: std.Io.Mutex = .init, + tokens: usize = 0, + rows: usize = 0, + prefills: usize = 0, + finishes: usize = 0, + reason: ?api.Reason = null, + + fn event(ptr: *anyopaque, _: api.Id, e: *const api.Event) void { + const x: *Box = @ptrCast(@alignCast(ptr)); + x.mutex.lockUncancelable(std.testing.io); + defer x.mutex.unlock(std.testing.io); + switch (e.*) { + .tokens => |t| x.tokens += t.len, + .logprobs => |r| x.rows += r.len, + .prefilled => x.prefills += 1, + .finished => |done| { + x.finishes += 1; + x.reason = done.reason; + }, + } + } + + fn wait(x: *Box) !void { + const deadline = std.Io.Clock.awake.now(std.testing.io).toNanoseconds() + 5 * std.time.ns_per_s; + while (std.Io.Clock.awake.now(std.testing.io).toNanoseconds() < deadline) { + x.mutex.lockUncancelable(std.testing.io); + const done = x.reason != null; + x.mutex.unlock(std.testing.io); + if (done) return; + try std.Io.sleep(std.testing.io, .fromMilliseconds(1), .awake); + } + return error.HostDeadline; + } +}; + +const Target = struct { + fake: lanes.fake.Fake = .{ .gpa = gpa }, + table: lanes.backend.Backend.VTable = undefined, + boxes: [2]*Box, + fail: bool, + initial_calls: usize = 0, + + fn backend(x: *Target) lanes.backend.Backend { + var b = x.fake.backend(); + x.table = b.vtable.*; + x.table.draft = draft; + b.vtable = &x.table; + b.first_before_draft = true; + return b; + } + + fn draft(ptr: *anyopaque, requests: []const lanes.backend.DraftRequest) !void { + const f: *lanes.fake.Fake = @ptrCast(@alignCast(ptr)); + const x: *Target = @fieldParentPtr("fake", f); + if (requests.len > 0 and requests[0].first != null) { + x.initial_calls += 1; + try std.testing.expectEqual(@as(usize, 1), requests.len); + for (x.boxes) |box| { + try std.testing.expectEqual(@as(usize, 1), box.tokens); + try std.testing.expectEqual(@as(usize, 1), box.rows); + try std.testing.expectEqual(@as(usize, 0), box.finishes); + } + if (x.fail) return error.InitialDraftFailed; + } + return x.fake.backend().draft(requests); + } +}; + +test "host handoff delivers first rows once and preserves terminal success across draft failure" { + for ([_]bool{ false, true }) |fail| { + var cfg = try lanes.Config.init(gpa, .{ .exact_width = 8, .mtp = true, .speculate = true, .speculate_early = false, .drafts = 4, .hidden_rows = true, .draft_streams = true }, 8, 4); + defer cfg.deinit(gpa); + var terminal: Box = .{}; + var live: Box = .{}; + var target: Target = .{ .boxes = .{ &terminal, &live }, .fail = fail }; + defer target.fake.deinit(); + var clock: lanes.fake.FixedClock = .{}; + var core = lanes.Engine.init(gpa, &cfg, target.backend(), clock.clock()); + defer core.deinit(); + var host = LaneHost.init(gpa, std.testing.io, &core, .{ .lanes = 2 }); + const e = host.engine(); + const one: api.Request = .{ .prompt = &.{ 2, 7 }, .max_tokens = 1, .logprobs = 2 }; + const many: api.Request = .{ .prompt = &.{ 1, 8 }, .max_tokens = 4, .logprobs = 2 }; + try e.submit(1, &one, .{ .ctx = &terminal, .event = Box.event }); + try e.submit(2, &many, .{ .ctx = &live, .event = Box.event }); + try host.start(); + defer host.stop(); + try terminal.wait(); + try live.wait(); + try std.testing.expectEqual(@as(usize, 1), terminal.tokens); + try std.testing.expectEqual(@as(usize, 1), terminal.rows); + try std.testing.expectEqual(api.Reason.length, terminal.reason.?); + try std.testing.expectEqual(@as(usize, if (fail) 1 else 4), live.tokens); + try std.testing.expectEqual(live.tokens, live.rows); + try std.testing.expectEqual(if (fail) api.Reason.failed else api.Reason.length, live.reason.?); + try std.testing.expectEqual(@as(usize, 1), target.initial_calls); + for ([_]*Box{ &terminal, &live }) |box| { + try std.testing.expectEqual(@as(usize, 1), box.prefills); + try std.testing.expectEqual(@as(usize, 1), box.finishes); + } + try std.testing.expectEqual(@as(usize, 0), target.fake.lanes.count()); + } +} diff --git a/zig/src/core/lanes/admit_first.zig b/zig/src/core/lanes/admit_first.zig new file mode 100644 index 000000000..3bf73b05a --- /dev/null +++ b/zig/src/core/lanes/admit_first.zig @@ -0,0 +1,124 @@ +//! Commit and hand off first tokens before a capable backend prepares its initial proposals. +const std = @import("std"); +const be = @import("backend.zig"); +const ev = @import("events.zig"); +const win = @import("windows.zig"); +const trail = @import("trail.zig"); +const Engine = @import("engine.zig").Engine; +const Stream = @import("stream.zig").Stream; +const Row = @import("logprob.zig").Row; +const f = ev.f; +const str = trail.str; +const int = trail.int; + +/// No batch-wide failure is returned after the first handoff; later failures belong to still-live streams. +pub fn streams(e: *Engine, list: []const *Stream, errs: []?anyerror, hook: ?be.Committed) !void { + _ = e.arena.reset(.retain_capacity); + const a = e.arena.allocator(); + const requests = try a.alloc(be.DraftRequest, list.len); + const indices = try a.alloc(usize, list.len); + try e.live.ensureUnusedCapacity(e.gpa, list.len); + @memset(errs, null); + for (list) |s| try trail.event(e, &.{ f("ev", str("add")), f("stream", str(s.id)) }); + if (list.len > 1 and e.backend.vtable.prefill_many != null) { + try e.backend.vtable.prefill_many.?(e.backend.ptr, list, errs); + } else for (list, errs) |s, *err| e.backend.prefill(s) catch |x| { + err.* = x; + }; + var n: usize = 0; + for (list, errs, 0..) |s, *err, i| { + if (err.*) |x| { + if (x == error.Cancelled) e.release(s); + continue; + } + const depth = first(e, s) catch |x| { + err.* = x; + if (x == error.Cancelled or s.finished) e.release(s); + continue; + }; + if (hook) |h| h.call(h.ptr, i); + if (s.finished) continue; + if (s.isCancelled()) { + e.release(s); + err.* = error.Cancelled; + continue; + } + if (depth) |d| { + requests[n] = .{ .stream = s, .follow = &.{}, .first = .{ .value = s.pending.? }, .rows = null, .start = s.prompt_len, .position = s.prompt_len + 1, .depth = d }; + indices[n] = i; + n += 1; + } + } + var kept: usize = 0; + for (requests[0..n], indices[0..n]) |r, i| { + if (r.stream.isCancelled()) { + e.release(r.stream); + errs[i] = error.Cancelled; + continue; + } + requests[kept] = r; + indices[kept] = i; + kept += 1; + } + n = kept; + if (n > 0) { + e.backend.draft(requests[0..n]) catch |x| { + for (indices[0..n]) |i| { + errs[i] = x; + if (x == error.Cancelled) e.release(list[i]); + } + }; + for (requests[0..n], indices[0..n]) |r, i| { + if (errs[i] != null) continue; + ready(e, r) catch |x| { + errs[i] = x; + if (x == error.Cancelled) e.release(r.stream); + }; + } + } + for (list, errs) |s, err| { + if (err == null and !s.finished) e.live.appendAssumeCapacity(s); + } +} + +/// Draw and commit exactly the selected first token, computing depth against the precommit budget. +fn first(e: *Engine, s: *Stream) !?u32 { + if (s.isCancelled()) return error.Cancelled; + s.context.shrinkRetainingCapacity(s.prompt_len); + s.rows.clearRetainingCapacity(); + s.pending = null; + s.cache_len = s.prompt_len; + const position: u64 = s.prompt_len; + const handle = try e.backend.first(s, position); + var feed: be.Feed = .{ .handle = handle }; + if (try e.forcedNext(s)) |token| feed = .{ .value = token }; + const depth: ?u32 = if (e.cfg.family_mtp and s.drafts) @intCast(try e.rule.depth(win.who(s))) else null; + const value = try e.readFeed(feed); + if (e.log != null) { + const drawn = if (feed == .handle) value else try e.backend.read(handle); + try trail.event(e, &.{ f("ev", str("first")), f("stream", str(s.id)), f("position", int(position)), f("drawn", int(drawn)), f("token", int(value)) }); + } + var row: [1]Row = undefined; + if (s.logprobs != null) row[0] = (try e.backend.firstRow(s)).forToken(value); + _ = try s.commit(e.gpa, &.{value}, if (s.logprobs != null) &row else &.{}); + s.pending = value; + if (!s.finished and depth == null and e.cfg.pipelined and s.logprobs == null) try e.queueNext(s, feed); + try trail.resolve(e); + if (s.finished) { + try trail.finish(e, s); + e.release(s); + } + return depth; +} + +/// Make successful initial proposals visible to the next verifier round, before admission returns. +fn ready(e: *Engine, r: be.DraftRequest) !void { + const s = r.stream; + if (s.isCancelled()) return error.Cancelled; + s.dropHeld(e.gpa); + s.next = .{ .count = r.depth }; + if (e.backend.vtable.tree) |tree| if (try tree(e.backend.ptr, s, e.gpa)) |held| { + s.next = held; + }; + try trail.event(e, &.{ f("ev", str("draft")), f("stream", str(s.id)), f("depth", int(r.depth)), f("position", int(r.position)), f("follow", .{ .u32s = &.{s.pending.?} }), f("rows", .null) }); +} diff --git a/zig/src/core/lanes/admit_first_test.zig b/zig/src/core/lanes/admit_first_test.zig new file mode 100644 index 000000000..04a6bb734 --- /dev/null +++ b/zig/src/core/lanes/admit_first_test.zig @@ -0,0 +1,165 @@ +//! First-token handoff precedes drafting without changing tokens or transferring stream ownership. +const std = @import("std"); +const be = @import("backend.zig"); +const sm = @import("stream.zig"); +const fake = @import("fake.zig"); +const Engine = @import("engine.zig").Engine; +const Config = @import("config.zig").Config; +const gpa = std.testing.allocator; + +const Probe = struct { + target: fake.Fake = .{ .gpa = gpa }, + vtable: be.Backend.VTable = undefined, + calls: usize = 0, + handoffs: usize = 0, + releases: usize = 0, + fail: bool = false, + early: bool = true, + cancel: bool = false, + last_first: ?u32 = null, + list: []const *sm.Stream = &.{}, + + fn backend(x: *Probe) be.Backend { + var b = x.target.backend(); + x.vtable = b.vtable.*; + x.vtable.draft = draft; + x.vtable.release = release; + b.vtable = &x.vtable; + b.first_before_draft = x.early; + return b; + } + + fn from(ptr: *anyopaque) *Probe { + const target: *fake.Fake = @ptrCast(@alignCast(ptr)); + return @fieldParentPtr("target", target); + } + + fn draft(ptr: *anyopaque, requests: []const be.DraftRequest) !void { + const x = from(ptr); + x.calls += 1; + for (requests) |r| { + if (x.early and r.first != null) { + try std.testing.expectEqual(@as(usize, 1), r.stream.emitted().len); + try std.testing.expect(!r.stream.finished); + try std.testing.expectEqual(r.stream.pending.?, r.first.?.value); + try std.testing.expect(x.handoffs > 0 or x.list.len == 0); + x.last_first = r.first.?.value; + } + } + if (x.fail) return error.InitialDraftFailed; + return x.target.backend().draft(requests); + } + + fn release(ptr: *anyopaque, s: *sm.Stream) void { + const x = from(ptr); + x.releases += 1; + x.target.backend().release(s); + } + + fn handoff(ptr: *anyopaque, index: usize) void { + const x: *Probe = @ptrCast(@alignCast(ptr)); + std.debug.assert(x.calls == 0 and x.list[index].emitted().len == 1); + x.handoffs += 1; + } + + fn cancelled(ptr: *anyopaque) bool { + const x: *Probe = @ptrCast(@alignCast(ptr)); + return x.cancel; + } + + fn cancelHandoff(ptr: *anyopaque, index: usize) void { + handoff(ptr, index); + const x: *Probe = @ptrCast(@alignCast(ptr)); + x.cancel = true; + } +}; + +fn config() !Config { + return Config.init(gpa, .{ .exact_width = 8, .mtp = true, .speculate = true, .speculate_early = false, .drafts = 4, .window_costs = &.{ .{ .width = 1, .ms = 5 }, .{ .width = 8, .ms = 10 } }, .mtp_step_ms = 0.5, .hidden_rows = true, .draft_streams = true }, 8, 4); +} + +test "first handoff is committed and terminal streams survive another stream's initial draft failure" { + var cfg = try config(); + defer cfg.deinit(gpa); + var x: Probe = .{ .fail = true }; + defer x.target.deinit(); + var clock: fake.FixedClock = .{}; + var e = Engine.init(gpa, &cfg, x.backend(), clock.clock()); + defer e.deinit(); + var terminal = try sm.Stream.init(gpa, .{ .id = "terminal", .prompt = &.{ 2, 7 }, .max_new = 1 }); + defer terminal.deinit(gpa); + var live = try sm.Stream.init(gpa, .{ .id = "live", .prompt = &.{ 1, 8 }, .max_new = 20 }); + defer live.deinit(gpa); + x.list = &.{ &terminal, &live }; + var errs: [2]?anyerror = undefined; + try e.addStreamsCommitted(x.list, &errs, .{ .ptr = &x, .call = Probe.handoff }); + try std.testing.expectEqual(@as(usize, 2), x.handoffs); + try std.testing.expectEqual(@as(?anyerror, null), errs[0]); + try std.testing.expectEqual(error.InitialDraftFailed, errs[1].?); + try std.testing.expect(terminal.finished); + try std.testing.expectEqual(@as(usize, 1), live.emitted().len); + try std.testing.expectEqual(@as(usize, 1), x.releases); + e.discard(&live); + try std.testing.expectEqual(@as(usize, 2), x.releases); + try std.testing.expectEqual(@as(usize, 0), x.target.lanes.count()); +} + +test "cancellation after first handoff releases once and never prepares proposals" { + var cfg = try config(); + defer cfg.deinit(gpa); + var x: Probe = .{}; + defer x.target.deinit(); + var clock: fake.FixedClock = .{}; + var e = Engine.init(gpa, &cfg, x.backend(), clock.clock()); + defer e.deinit(); + var s = try sm.Stream.init(gpa, .{ .id = "cancel", .prompt = &.{2}, .max_new = 20, .cancel_check = .{ .ptr = &x, .check = Probe.cancelled } }); + defer s.deinit(gpa); + x.list = &.{&s}; + var errs: [1]?anyerror = undefined; + try e.addStreamsCommitted(x.list, &errs, .{ .ptr = &x, .call = Probe.cancelHandoff }); + try std.testing.expectEqual(error.Cancelled, errs[0].?); + try std.testing.expectEqual(@as(usize, 0), x.calls); + try std.testing.expectEqual(@as(usize, 1), x.releases); + try std.testing.expectEqual(@as(usize, 0), e.activeCount()); +} + +test "forced first and logprobs match default admission and subsequent exact tokens" { + var cfg = try config(); + defer cfg.deinit(gpa); + var a: Probe = .{ .early = false }; + defer a.target.deinit(); + var b: Probe = .{}; + defer b.target.deinit(); + var clock: fake.FixedClock = .{}; + var old = Engine.init(gpa, &cfg, a.backend(), clock.clock()); + defer old.deinit(); + var new = Engine.init(gpa, &cfg, b.backend(), clock.clock()); + defer new.deinit(); + const spec: sm.Spec = .{ .id = "forced", .prompt = &.{ 2, 7, 1 }, .max_new = 20, .logprobs = 3 }; + var left = try sm.Stream.init(gpa, spec); + defer left.deinit(gpa); + var right = try sm.Stream.init(gpa, spec); + defer right.deinit(gpa); + try left.force.append(gpa, 45); + try right.force.append(gpa, 45); + a.list = &.{&left}; + b.list = &.{&right}; + var errs: [1]?anyerror = undefined; + try old.addStreamsCommitted(a.list, &errs, .{ .ptr = &a, .call = Probe.handoff }); + try new.addStreamsCommitted(b.list, &errs, .{ .ptr = &b, .call = Probe.handoff }); + try std.testing.expectEqual(@as(usize, 0), a.handoffs); + try std.testing.expectEqual(@as(usize, 1), b.handoffs); + try std.testing.expectEqual(@as(u32, 45), b.last_first.?); + while (old.activeCount() > 0) try old.step(); + while (new.activeCount() > 0) try new.step(); + try std.testing.expectEqualSlices(u32, left.emitted(), right.emitted()); + try std.testing.expectEqual(left.rows.items.len, right.rows.items.len); + for (left.rows.items, right.rows.items) |l, r| { + try std.testing.expectEqual(l.token, r.token); + try std.testing.expectEqual(@as(u32, @bitCast(l.logprob)), @as(u32, @bitCast(r.logprob))); + try std.testing.expectEqual(l.count, r.count); + try std.testing.expectEqualSlices(u32, l.ids[0..l.count], r.ids[0..r.count]); + for (l.logprobs[0..l.count], r.logprobs[0..r.count]) |lp, rp| + try std.testing.expectEqual(@as(u32, @bitCast(lp)), @as(u32, @bitCast(rp))); + } +} diff --git a/zig/src/core/lanes/backend.zig b/zig/src/core/lanes/backend.zig index c50ca6b10..158ae34c8 100644 --- a/zig/src/core/lanes/backend.zig +++ b/zig/src/core/lanes/backend.zig @@ -58,9 +58,16 @@ pub const DraftRequest = struct { ranks: bool = false, // also keep each chained level's best tokens (alternatives(), for grafts) }; +/// A host handoff after a stream's first token is committed; it must not release the stream. +pub const Committed = struct { + ptr: *anyopaque, + call: *const fn (ptr: *anyopaque, index: usize) void, +}; + pub const Backend = struct { ptr: *anyopaque, vtable: *const VTable, + first_before_draft: bool = false, // initial drafting accepts the already committed first token pub const VTable = struct { /// Prefill the stream's prompt into its caches (and its draft head's). diff --git a/zig/src/core/lanes/engine.zig b/zig/src/core/lanes/engine.zig index f2ad1fd57..e7895d910 100644 --- a/zig/src/core/lanes/engine.zig +++ b/zig/src/core/lanes/engine.zig @@ -86,6 +86,12 @@ pub const Engine = struct { /// addStream for several streams, their prompt passes shared (admit.zig). pub fn addStreams(e: *Engine, streams: []const *Stream, errs: []?anyerror) !void { + return e.addStreamsCommitted(streams, errs, null); + } + + /// Admit streams, handing committed first tokens to the host before initial drafting when supported. + pub fn addStreamsCommitted(e: *Engine, streams: []const *Stream, errs: []?anyerror, hook: ?be.Committed) !void { + if (e.backend.first_before_draft) return @import("admit_first.zig").streams(e, streams, errs, hook); return admit.streams(e, streams, errs); } diff --git a/zig/src/core/lanes/lanes.zig b/zig/src/core/lanes/lanes.zig index 6531f81ca..0696f5193 100644 --- a/zig/src/core/lanes/lanes.zig +++ b/zig/src/core/lanes/lanes.zig @@ -37,6 +37,7 @@ pub const LogprobRow = logprob.Row; test { std.testing.refAllDecls(@This()); _ = @import("engine_test.zig"); + _ = @import("admit_first_test.zig"); _ = @import("gpu_full_test.zig"); _ = @import("drafted_test.zig"); } diff --git a/zig/src/families/qwen27/cuda/lanes.zig b/zig/src/families/qwen27/cuda/lanes.zig index 8a5f86fad..9f4f4a63e 100644 --- a/zig/src/families/qwen27/cuda/lanes.zig +++ b/zig/src/families/qwen27/cuda/lanes.zig @@ -130,7 +130,7 @@ pub const Cuda = struct { } pub fn backend(x: *Cuda) be.Backend { - return .{ .ptr = x, .vtable = &.{ .prefill = prefill, .first = first, .queue = queue, .read = read, .verify = verify, .keep = keep, .draft = draft, .probabilities = probabilities, .tree = tree, .release = release, .prefill_many = prefillMany } }; + return .{ .ptr = x, .first_before_draft = true, .vtable = &.{ .prefill = prefill, .first = first, .queue = queue, .read = read, .verify = verify, .keep = keep, .draft = draft, .probabilities = probabilities, .tree = tree, .release = release, .prefill_many = prefillMany } }; } /// The stream's drafting (its DFlash2 context and copy index), made on first use. @@ -463,7 +463,7 @@ pub const Cuda = struct { .value => |v| v, .handle => |h| try read(p, h), }; - try firsts[na].appendSlice(x.gpa, context); + try firsts[na].appendSlice(x.gpa, r.stream.prompt()); try firsts[na].append(x.gpa, token); context = firsts[na].items; } diff --git a/zig/src/native/cuda.zig b/zig/src/native/cuda.zig index 032f64c60..70a09454d 100644 --- a/zig/src/native/cuda.zig +++ b/zig/src/native/cuda.zig @@ -328,7 +328,7 @@ const Host = struct { } }.f, }; - return .{ .ptr = h, .vtable = &h.vtable }; + return .{ .ptr = h, .vtable = &h.vtable, .first_before_draft = h.inner.first_before_draft }; } }; @@ -524,12 +524,15 @@ test "a cancel during a long prompt stops it, and the next request's reply is un const h = try gpa.create(Host); defer gpa.destroy(h); h.* = .{ .gpa = gpa, .gpu = null, .family = &target, .release = Nothing.release, .inner = target.backend(), .vtable = undefined, .cfg = undefined, .clock = undefined, .core = undefined, .host = undefined }; + try std.testing.expect(!h.backend().first_before_draft); + h.inner.first_before_draft = true; try h.serve(std.testing.io, .{ .exact_width = 8, .mtp = true, .speculate = true, .drafts = 7, .hidden_rows = true }, 8, .{ .lanes = 2 }, null); defer { h.host.stop(); h.core.deinit(); h.cfg.deinit(gpa); } + try std.testing.expect(h.core.backend.first_before_draft); const e = h.host.engine(); try std.testing.expect(e.memory(false) == null); // no device to count const Box = struct { From 474bd89b68dee96149898ad303626d5d9dce0291 Mon Sep 17 00:00:00 2001 From: Jonathan Regan-Beasley <197533392+jregan-beasley-smc@users.noreply.github.com> Date: Sun, 11 Oct 2026 21:42:41 +1100 Subject: [PATCH 2/4] feat(qwen27 cuda): cache exact prompts and reuse request state --- zig/src/families/qwen27/cuda/draft_pool.zig | 147 +++++++ .../families/qwen27/cuda/draft_pool_test.zig | 105 +++++ zig/src/families/qwen27/cuda/drafts.zig | 41 ++ zig/src/families/qwen27/cuda/engine.zig | 5 + .../qwen27/cuda/exact_cache_policy.zig | 58 +++ .../families/qwen27/cuda/exact_cache_test.zig | 390 ++++++++++++++++++ .../qwen27/cuda/exact_draft_reuse.zig | 173 ++++++++ .../qwen27/cuda/exact_first_logits.zig | 31 ++ .../qwen27/cuda/exact_logits_policy.zig | 75 ++++ .../qwen27/cuda/exact_prompt_cache.zig | 337 +++++++++++++++ .../families/qwen27/cuda/exact_seq_reuse.zig | 172 ++++++++ zig/src/families/qwen27/cuda/lanes.zig | 138 ++++--- zig/src/families/qwen27/cuda/reset_skip.zig | 58 +++ .../qwen27/cuda/reset_skip_factory_test.zig | 157 +++++++ .../families/qwen27/cuda/reset_skip_test.zig | 105 +++++ .../families/qwen27/cuda/restore_proof.zig | 76 ++++ zig/src/families/qwen27/cuda/seq_pool.zig | 120 ++++++ .../families/qwen27/cuda/seq_pool_test.zig | 172 ++++++++ zig/src/families/qwen27/cuda/state.zig | 15 +- 19 files changed, 2327 insertions(+), 48 deletions(-) create mode 100644 zig/src/families/qwen27/cuda/draft_pool.zig create mode 100644 zig/src/families/qwen27/cuda/draft_pool_test.zig create mode 100644 zig/src/families/qwen27/cuda/exact_cache_policy.zig create mode 100644 zig/src/families/qwen27/cuda/exact_cache_test.zig create mode 100644 zig/src/families/qwen27/cuda/exact_draft_reuse.zig create mode 100644 zig/src/families/qwen27/cuda/exact_first_logits.zig create mode 100644 zig/src/families/qwen27/cuda/exact_logits_policy.zig create mode 100644 zig/src/families/qwen27/cuda/exact_prompt_cache.zig create mode 100644 zig/src/families/qwen27/cuda/exact_seq_reuse.zig create mode 100644 zig/src/families/qwen27/cuda/reset_skip.zig create mode 100644 zig/src/families/qwen27/cuda/reset_skip_factory_test.zig create mode 100644 zig/src/families/qwen27/cuda/reset_skip_test.zig create mode 100644 zig/src/families/qwen27/cuda/restore_proof.zig create mode 100644 zig/src/families/qwen27/cuda/seq_pool.zig create mode 100644 zig/src/families/qwen27/cuda/seq_pool_test.zig diff --git a/zig/src/families/qwen27/cuda/draft_pool.zig b/zig/src/families/qwen27/cuda/draft_pool.zig new file mode 100644 index 000000000..7b2da57e8 --- /dev/null +++ b/zig/src/families/qwen27/cuda/draft_pool.zig @@ -0,0 +1,147 @@ +//! Detached fixed-class draft Context ownership; no CUDA allocation, copy or fence occurs in this policy. +const std = @import("std"); +pub const max_slots: usize = 16; +pub const max_capacity: usize = 512; +pub const max_bytes: usize = 1536 * 1024 * 1024; + +pub const Stats = struct { + enabled: bool = false, + failed: bool = false, + driver_creations: u64 = 0, + reuse_hits: u64 = 0, + evictions: u64 = 0, + discarded: u64 = 0, + initialized: u64 = 0, + retained_slots: usize = 0, + retained_bytes: usize = 0, + quarantined_slots: usize = 0, + quarantined_bytes: usize = 0, + fence_failures: u64 = 0, +}; + +pub fn enabled(raw: ?[]const u8, cache_enabled: bool) !bool { + const text = raw orelse return false; + if (std.mem.eql(u8, text, "0")) return false; + if (!std.mem.eql(u8, text, "1")) return error.InvalidDraftReuseFlag; + if (!cache_enabled) return error.DraftReuseRequiresExactCache; + return true; +} + +pub fn configured(cache_enabled: bool) !bool { + const env = std.c.getenv("TF_PR608_EXACT_CACHE_DRAFT_REUSE"); + return enabled(if (env) |v| std.mem.span(v) else null, cache_enabled); +} + +pub fn eligible(drafted: bool, drafter: bool, tokens: usize, capacity: usize, fresh: bool, cancelled: bool) bool { + return drafted and drafter and tokens > 0 and tokens <= max_capacity and capacity <= max_capacity and + tokens < capacity and fresh and !cancelled; +} + +/// A completed request authorizes storage recycling only when every independent success gate holds. +pub fn completed(initialized: bool, terminal: bool, uncancelled: bool, settled: bool, cache_ok: bool, cache_failed: bool) bool { + return initialized and terminal and uncancelled and settled and cache_ok and !cache_failed; +} + +pub const Proof = struct { + stream: *const anyopaque, + seq: *const anyopaque, + wrapper: *const anyopaque, + arena: u64, + tokens: usize, + capacity: usize, +}; + +pub const Proofs = struct { + items: [max_slots]?Proof = @splat(null), + pub fn mark(p: *Proofs, proof: Proof) !void { + if (proof.arena == 0 or proof.tokens == 0 or proof.tokens >= proof.capacity or proof.capacity > max_capacity) + return error.InvalidDraftInitialization; + for (p.items) |slot| if (slot) |old| { + if (old.stream == proof.stream) return error.DuplicateDraftInitialization; + }; + for (&p.items) |*slot| if (slot.* == null) { + slot.* = proof; + return; + }; + return error.DraftInitializationLimit; + } + pub fn remove(p: *Proofs, stream: *const anyopaque) ?Proof { + for (&p.items) |*slot| if (slot.*) |proof| { + if (proof.stream != stream) continue; + slot.* = null; + return proof; + }; + return null; + } +}; + +/// Idle entries were fenced; quarantined entries must not be freed or taken until a new successful fence. +pub fn Pool(comptime T: type) type { + return struct { + const Self = @This(); + entries: [max_slots]*T = undefined, + quarantine: [max_slots]*T = undefined, + limit: usize, + item_bytes: usize, + stats: Stats, + + pub fn init(on: bool, slots: usize, item_bytes: usize) Self { + return .{ .limit = @min(slots, max_slots), .item_bytes = item_bytes, .stats = .{ .enabled = on } }; + } + pub fn active(p: *const Self) bool { + return p.stats.enabled and !p.stats.failed; + } + pub fn hasRoom(p: *const Self, live: usize) bool { + return live < p.limit and p.stats.retained_slots + p.stats.quarantined_slots < p.limit - live; + } + fn duplicate(p: *const Self, ptr: *T) bool { + for (p.entries[0..p.stats.retained_slots]) |old| if (old == ptr) return true; + for (p.quarantine[0..p.stats.quarantined_slots]) |old| if (old == ptr) return true; + return false; + } + pub fn take(p: *Self) ?*T { + if (!p.active() or p.stats.retained_slots == 0) return null; + p.stats.retained_slots -= 1; + p.stats.retained_bytes -= p.item_bytes; + p.stats.reuse_hits += 1; + return p.entries[p.stats.retained_slots]; + } + pub fn evict(p: *Self) ?*T { + if (p.stats.retained_slots == 0) return null; + p.stats.retained_slots -= 1; + p.stats.retained_bytes -= p.item_bytes; + p.stats.evictions += 1; + return p.entries[p.stats.retained_slots]; + } + pub fn retain(p: *Self, ptr: *T, live: usize) bool { + if (!p.active() or !p.hasRoom(live) or p.item_bytes > max_bytes or + p.stats.retained_bytes > max_bytes - p.item_bytes) return false; + if (p.duplicate(ptr)) @panic("duplicate draft pool owner"); + p.entries[p.stats.retained_slots] = ptr; + p.stats.retained_slots += 1; + p.stats.retained_bytes += p.item_bytes; + return true; + } + pub fn fail(p: *Self) void { + if (p.stats.enabled) p.stats.failed = true; + } + pub fn park(p: *Self, ptr: *T, live: usize) void { + p.fail(); + if (!p.hasRoom(live) or p.duplicate(ptr)) @panic("draft quarantine ownership limit"); + p.quarantine[p.stats.quarantined_slots] = ptr; + p.stats.quarantined_slots += 1; + p.stats.quarantined_bytes += p.item_bytes; + p.stats.fence_failures += 1; + } + pub fn reap(p: *Self, fenced: bool) ?*T { + if (!fenced or p.stats.quarantined_slots == 0) return null; + p.stats.quarantined_slots -= 1; + p.stats.quarantined_bytes -= p.item_bytes; + return p.quarantine[p.stats.quarantined_slots]; + } + }; +} + +test { + _ = @import("draft_pool_test.zig"); +} diff --git a/zig/src/families/qwen27/cuda/draft_pool_test.zig b/zig/src/families/qwen27/cuda/draft_pool_test.zig new file mode 100644 index 000000000..e1fc92575 --- /dev/null +++ b/zig/src/families/qwen27/cuda/draft_pool_test.zig @@ -0,0 +1,105 @@ +//! Host-only Context storage ownership and initialization provenance regressions. +const std = @import("std"); +const p = @import("draft_pool.zig"); +const expect = std.testing.expect; +const equal = std.testing.expectEqual; + +test "strict flag is default off and requires exact cache" { + try expect(!try p.enabled(null, false)); + try expect(!try p.enabled("0", false)); + try expect(try p.enabled("1", true)); + try std.testing.expectError(error.DraftReuseRequiresExactCache, p.enabled("1", false)); + try std.testing.expectError(error.InvalidDraftReuseFlag, p.enabled("yes", true)); +} + +test "fresh small drafted requests include cross-key and capacity changes" { + try expect(p.eligible(true, true, 14, 286, true, false)); + try expect(p.eligible(true, true, 31, 303, true, false)); + try expect(p.eligible(true, true, 1, 512, true, false)); + try expect(!p.eligible(false, true, 14, 286, true, false)); + try expect(!p.eligible(true, false, 14, 286, true, false)); + try expect(!p.eligible(true, true, 31, 513, true, false)); + try expect(!p.eligible(true, true, 0, 286, true, false)); + try expect(!p.eligible(true, true, 31, 31, true, false)); + try expect(!p.eligible(true, true, 31, 303, false, false)); + try expect(!p.eligible(true, true, 31, 303, true, true)); +} + +test "detached storage transfers once and total ownership is bounded" { + var owners = [_]u8{ 1, 2, 3 }; + var pool = p.Pool(u8).init(true, 2, 80); + try expect(pool.retain(&owners[0], 1)); + try expect(!pool.retain(&owners[1], 1)); + try expect(!pool.hasRoom(1)); + try expect(pool.take().? == &owners[0]); + try expect(pool.take() == null); + try equal(@as(u64, 1), pool.stats.reuse_hits); + try expect(pool.retain(&owners[0], 0)); + try expect(pool.retain(&owners[1], 0)); + try expect(!pool.retain(&owners[2], 0)); + try equal(@as(usize, 160), pool.stats.retained_bytes); + try expect(pool.evict().? == &owners[1]); + try expect(pool.evict().? == &owners[0]); + try equal(@as(usize, 0), pool.stats.retained_bytes); + try equal(@as(u64, 2), pool.stats.evictions); +} + +test "retained bytes and backend configured ownership cap are enforced" { + var owners = [_]u8{ 1, 2, 3 }; + var pool = p.Pool(u8).init(true, 32, p.max_bytes / 2); + try equal(@as(usize, 16), pool.limit); + try expect(pool.retain(&owners[0], 0)); + try expect(pool.retain(&owners[1], 0)); + try expect(!pool.retain(&owners[2], 0)); + try equal(p.max_bytes, pool.stats.retained_bytes); + var disabled = p.Pool(u8).init(false, 16, 1); + try expect(!disabled.retain(&owners[0], 0)); + var zero = p.Pool(u8).init(true, 0, 1); + try expect(!zero.hasRoom(0)); +} + +test "failed fence quarantines without reuse or free until successful fence" { + var owners = [_]u8{ 1, 2 }; + var pool = p.Pool(u8).init(true, 2, 80); + pool.park(&owners[0], 1); + try expect(pool.stats.failed); + try expect(!pool.hasRoom(1)); + try expect(pool.take() == null); + try expect(pool.reap(false) == null); + try equal(@as(usize, 1), pool.stats.quarantined_slots); + try equal(@as(usize, 80), pool.stats.quarantined_bytes); + try expect(pool.reap(true).? == &owners[0]); + try expect(pool.reap(true) == null); + try equal(@as(usize, 0), pool.stats.quarantined_bytes); + try expect(!pool.retain(&owners[1], 0)); + try equal(@as(u64, 1), pool.stats.fence_failures); +} + +test "initialization proof binds independent request target wrapper and arena" { + var owners = [_]u8{ 1, 2, 3, 4 }; + const proof: p.Proof = .{ .stream = &owners[0], .seq = &owners[1], .wrapper = &owners[2], .arena = 4096, .tokens = 31, .capacity = 303 }; + var proofs: p.Proofs = .{}; + try proofs.mark(proof); + try std.testing.expectError(error.DuplicateDraftInitialization, proofs.mark(proof)); + try expect(proofs.remove(&owners[3]) == null); + const taken = proofs.remove(&owners[0]).?; + try expect(taken.seq == @as(*const anyopaque, &owners[1]) and taken.wrapper == @as(*const anyopaque, &owners[2])); + try equal(@as(u64, 4096), taken.arena); + try expect(proofs.remove(&owners[0]) == null); + var invalid = proof; + invalid.capacity = 513; + try std.testing.expectError(error.InvalidDraftInitialization, proofs.mark(invalid)); + invalid = proof; + invalid.arena = 0; + try std.testing.expectError(error.InvalidDraftInitialization, proofs.mark(invalid)); +} + +test "retention requires every independent clean completion gate" { + try expect(p.completed(true, true, true, true, true, false)); + try expect(!p.completed(false, true, true, true, true, false)); + try expect(!p.completed(true, false, true, true, true, false)); + try expect(!p.completed(true, true, false, true, true, false)); + try expect(!p.completed(true, true, true, false, true, false)); + try expect(!p.completed(true, true, true, true, false, false)); + try expect(!p.completed(true, true, true, true, true, true)); +} diff --git a/zig/src/families/qwen27/cuda/drafts.zig b/zig/src/families/qwen27/cuda/drafts.zig index 02e365952..c8360a097 100644 --- a/zig/src/families/qwen27/cuda/drafts.zig +++ b/zig/src/families/qwen27/cuda/drafts.zig @@ -31,12 +31,27 @@ pub const Stream = struct { pub fn deinit(x: *Stream) void { x.ctx.deinit(); + x.deinitHost(); + } + + fn deinitHost(x: *Stream) void { x.copies.deinit(); x.tokens.deinit(x.gpa); x.parents.deinit(x.gpa); x.scores.deinit(x.gpa); } + /// Reconstruct every request-specific host field around exclusively owned, already-fenced storage. + pub fn resetStorage(x: *Stream) void { + const gpa = x.gpa; + var ctx = x.ctx; + x.deinitHost(); + ctx.cur = 0; + ctx.len = 0; + ctx.end = 0; + x.* = init(gpa, ctx); + } + fn clear(x: *Stream) void { x.kind = .none; x.tokens.clearRetainingCapacity(); @@ -101,3 +116,29 @@ pub fn absorb(d: *dr.DFlash2, ops: kern.Ops, taps: u64, copy_items: u64, kept: [ try ops.copies(copy_items, items.items.len); try d.absorbMany(absorbs[0..kept.len], gathered); } + +test "storage reset reconstructs CopyIndex and arrays without replacing Context geometry" { + const gpa = std.testing.allocator; + const ctx: dr.Context = .{ .arena = .{ .buf = null }, .keys = @splat(@splat(4096)), .values = @splat(@splat(8192)), .cur = 1, .len = 31, .end = 47 }; + var x = Stream.init(gpa, ctx); + defer x.deinit(); + const tokens = [_]u32{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8 }; + _ = try x.copies.propose(&tokens, 15); + try std.testing.expect(x.copies.positions.count() > 0 and x.copies.indexed > 0); + x.kind = .tree; + try x.tokens.append(gpa, 43); + try x.parents.append(gpa, -1); + try x.scores.append(gpa, -0.5); + x.resetStorage(); + try std.testing.expectEqual(@as(u1, 0), x.ctx.cur); + try std.testing.expectEqual(@as(usize, 0), x.ctx.len); + try std.testing.expectEqual(@as(usize, 0), x.ctx.end); + try std.testing.expectEqual(ctx.keys, x.ctx.keys); + try std.testing.expectEqual(ctx.values, x.ctx.values); + try std.testing.expectEqual(@as(usize, 0), x.copies.positions.count()); + try std.testing.expectEqual(@as(usize, 0), x.copies.indexed); + try std.testing.expectEqual(Kind.none, x.kind); + try std.testing.expectEqual(@as(usize, 0), x.tokens.items.len); + try std.testing.expectEqual(@as(usize, 0), x.parents.items.len); + try std.testing.expectEqual(@as(usize, 0), x.scores.items.len); +} diff --git a/zig/src/families/qwen27/cuda/engine.zig b/zig/src/families/qwen27/cuda/engine.zig index 52576d7cd..250738148 100644 --- a/zig/src/families/qwen27/cuda/engine.zig +++ b/zig/src/families/qwen27/cuda/engine.zig @@ -71,6 +71,11 @@ pub const Engine = struct { return st.Seq.init(e.gpa, e.ops(), e.w.g, capacity); } + /// Private prefill transaction only; public sequence still returns initialized state. + pub fn sequenceForRestore(e: *Engine, capacity: usize) !st.Seq { + return st.Seq.initRestoreDestination(e.gpa, e.ops(), e.w.g, capacity); + } + /// prefill_state from an empty state: the prompt in even chunks of at most `prompt_rows`, its last row normed. pub fn prefill(e: *Engine, seq: *st.Seq, prompt: []const u32) !void { if (prompt.len == 0) return error.EmptyPrompt; diff --git a/zig/src/families/qwen27/cuda/exact_cache_policy.zig b/zig/src/families/qwen27/cuda/exact_cache_policy.zig new file mode 100644 index 000000000..3aa664485 --- /dev/null +++ b/zig/src/families/qwen27/cuda/exact_cache_policy.zig @@ -0,0 +1,58 @@ +//! Private full-prompt cache eligibility and bounded ownership decisions. +const std = @import("std"); +pub const max_tokens = 512; +pub const max_bytes = 256 * 1024 * 1024; + +pub fn enabled(value: ?[]const u8) !bool { + const text = value orelse return false; + if (std.mem.eql(u8, text, "0")) return false; + if (std.mem.eql(u8, text, "1")) return true; + return error.InvalidExactPromptCacheFlag; +} + +pub fn eligible(tokens: usize, chunks: usize, fresh: bool, cancelled: bool) bool { + return tokens > 0 and tokens <= max_tokens and chunks <= max_tokens and fresh and !cancelled; +} + +pub fn clean(finished: bool, normal_reason: bool, cancelled: bool, settled: bool) bool { + return finished and normal_reason and !cancelled and settled; +} + +pub const Decision = enum { refuse, busy, retain, evict }; +pub fn admission(active_bytes: usize, pending_bytes: usize, requested: usize) Decision { + if (requested == 0 or requested > max_bytes) return .refuse; + if (pending_bytes != 0) return .busy; + return if (active_bytes > max_bytes - requested) .evict else .retain; +} + +test "flag is strict and disabled by default" { + try std.testing.expect(!try enabled(null)); + try std.testing.expect(!try enabled("0")); + try std.testing.expect(try enabled("1")); + try std.testing.expectError(error.InvalidExactPromptCacheFlag, enabled("true")); +} + +test "only bounded fresh uncancelled prompts can enter" { + try std.testing.expect(eligible(1, 0, true, false)); + try std.testing.expect(eligible(512, 512, true, false)); + try std.testing.expect(!eligible(0, 0, true, false)); + try std.testing.expect(!eligible(513, 0, true, false)); + try std.testing.expect(!eligible(14, 0, false, false)); + try std.testing.expect(!eligible(14, 0, true, true)); +} + +test "clean completion never includes uncertain settle or cancellation" { + try std.testing.expect(clean(true, true, false, true)); + try std.testing.expect(!clean(true, true, false, false)); + try std.testing.expect(!clean(true, true, true, true)); + try std.testing.expect(!clean(true, false, false, true)); + try std.testing.expect(!clean(false, true, false, true)); +} + +test "one pending owner and total byte bound include replacement with room" { + try std.testing.expectEqual(.busy, admission(0, 1, 100)); + try std.testing.expectEqual(.refuse, admission(0, 0, max_bytes + 1)); + try std.testing.expectEqual(.retain, admission(100, 0, 100)); + try std.testing.expectEqual(.evict, admission(197995008, 0, 197995008)); + try std.testing.expectEqual(.retain, admission(0, 0, 197995008)); +} diff --git a/zig/src/families/qwen27/cuda/exact_cache_test.zig b/zig/src/families/qwen27/cuda/exact_cache_test.zig new file mode 100644 index 000000000..f62fa65f3 --- /dev/null +++ b/zig/src/families/qwen27/cuda/exact_cache_test.zig @@ -0,0 +1,390 @@ +//! Host-only CUDA-driver mocks exercise snapshot ownership and failure paths. +const std = @import("std"); +const cuda = @import("cuda"); +const lanes = @import("lanes"); +const cache_mod = @import("exact_prompt_cache.zig"); +const st = @import("state.zig"); +const shape = @import("shape.zig"); +const kern = @import("kernels.zig"); +const dr = @import("draft.zig"); +const g = shape.the_27b; +const a = std.testing.allocator; + +const Mock = struct { + var live: usize = 0; + var freed: usize = 0; + const Copy = struct { dst: u64, src: u64, bytes: usize }; + var copy_rows: [512]Copy = undefined; + var copies: usize = 0; + var fences: usize = 0; + var fail_copy = false; + var fail_fence = false; + var next: u64 = 0x100000000; + fn alloc(ptr: *cuda.abi.DevicePtr, _: usize) callconv(.c) cuda.abi.Result { + ptr.* = next; + next += 0x100000000; + live += 1; + return cuda.abi.success; + } + fn free(_: cuda.abi.DevicePtr) callconv(.c) cuda.abi.Result { + live -= 1; + freed += 1; + return cuda.abi.success; + } + fn copy(dst: cuda.abi.DevicePtr, src: cuda.abi.DevicePtr, bytes: usize, _: cuda.abi.Stream) callconv(.c) cuda.abi.Result { + if (fail_copy) return cuda.abi.error_not_ready; + std.debug.assert(copies < copy_rows.len); + copy_rows[copies] = .{ .dst = dst, .src = src, .bytes = bytes }; + copies += 1; + return cuda.abi.success; + } + fn fence(_: cuda.abi.Stream) callconv(.c) cuda.abi.Result { + if (fail_fence) return cuda.abi.error_not_ready; + fences += 1; + return cuda.abi.success; + } + fn reset() void { + live = 0; + freed = 0; + copies = 0; + fences = 0; + fail_copy = false; + fail_fence = false; + } +}; + +const Fixture = struct { + driver: cuda.Driver = undefined, + kernels: kern.Kernels = undefined, + rec: [64]u64 = @splat(0x1000), + conv: [64]u64 = @splat(0x2000), + keys: [64]u64 = @splat(0x3000), + values: [64]u64 = @splat(0x4000), + fn ops(f: *Fixture) kern.Ops { + f.driver.api.cuMemAlloc_v2 = Mock.alloc; + f.driver.api.cuMemFree_v2 = Mock.free; + f.driver.api.cuMemcpyDtoDAsync_v2 = Mock.copy; + f.driver.api.cuStreamSynchronize = Mock.fence; + f.kernels.d = &f.driver; + return .{ .k = &f.kernels, .s = .{ .d = &f.driver, .handle = null } }; + } + fn seq(f: *Fixture, n: usize) st.Seq { + return .{ .gpa = a, .arena = .{ .buf = null }, .rec = &f.rec, .conv = &f.conv, .keys = &f.keys, .values = &f.values, .head_in = 0x5000, .head_xs = 0x6000, .pos = n, .capacity = n + 256 }; + } +}; + +fn stream(ids: []const u32, drafted: bool) !lanes.Stream { + return lanes.Stream.init(a, .{ .id = "cache-test", .prompt = ids, .max_new = 256, .drafts = drafted }); +} +fn finish(s: *lanes.Stream) void { + s.finished = true; + s.reason = .length; +} + +test "actual snapshot owner replacement and hit copy never alias a live destination" { + Mock.reset(); + var f: Fixture = .{}; + const ops = f.ops(); + var cache = cache_mod.Cache.init(a, true); + defer cache.deinit(ops) catch unreachable; + var seed = try stream(&.{ 1, 2, 3 }, false); + defer seed.deinit(a); + var seq = f.seq(3); + try cache.capture(&seed, &seq, null, ops, g); + try std.testing.expectEqual(@as(usize, 1), Mock.live); + finish(&seed); + try cache.release(&seed, true, ops); + const saved = cache.active.?; + var hit = try stream(&.{ 1, 2, 3 }, false); + defer hit.deinit(a); + var dest = f.seq(0); + try std.testing.expect(try cache.lookup(&hit, &dest, null, ops, g)); + try std.testing.expectEqual(@as(u32, 3), hit.cached); + try std.testing.expectEqual(@as(usize, 3), dest.pos); + try std.testing.expect(saved.head_in != dest.head_in); + var miss = try stream(&.{ 4, 5, 6 }, false); + defer miss.deinit(a); + try cache.capture(&miss, &seq, null, ops, g); + try std.testing.expectEqual(@as(u64, 1), cache.stats.evictions); + try std.testing.expectEqual(@as(usize, 1), Mock.live); + try std.testing.expect(Mock.fences >= 2); + finish(&miss); + try cache.release(&miss, true, ops); + try std.testing.expectEqual(@as(u64, 2), cache.stats.promotions); +} + +test "pending is never hit and error or cancellation cannot promote" { + Mock.reset(); + var f: Fixture = .{}; + const ops = f.ops(); + var cache = cache_mod.Cache.init(a, true); + defer cache.deinit(ops) catch unreachable; + var s = try stream(&.{ 1, 2 }, false); + defer s.deinit(a); + var seq = f.seq(2); + try cache.capture(&s, &seq, null, ops, g); + var other = try stream(&.{ 1, 2 }, false); + defer other.deinit(a); + try std.testing.expect(!try cache.lookup(&other, &seq, null, ops, g)); + try cache.capture(&other, &seq, null, ops, g); + try std.testing.expectEqual(@as(usize, 1), Mock.live); + s.finished = true; + s.reason = .cancelled; + try cache.release(&s, true, ops); + try std.testing.expect(cache.active == null and cache.pending == null); + s.finished = false; + s.reason = .none; + try cache.capture(&s, &seq, null, ops, g); + finish(&s); + try cache.release(&other, false, ops); + try std.testing.expect(cache.failed and cache.active == null and Mock.live == 0); + try cache.release(&s, true, ops); + try std.testing.expectEqual(@as(u64, 0), cache.stats.promotions); +} + +test "copy failure purges and failed fence defers freeing in-flight source" { + Mock.reset(); + var f: Fixture = .{}; + const ops = f.ops(); + var cache = cache_mod.Cache.init(a, true); + defer cache.deinit(ops) catch unreachable; + var s = try stream(&.{1}, false); + defer s.deinit(a); + var seq = f.seq(1); + Mock.fail_copy = true; + try std.testing.expectError(error.NotReady, cache.capture(&s, &seq, null, ops, g)); + Mock.fail_copy = false; + Mock.fail_fence = true; + try std.testing.expectError(error.NotReady, cache.abandon(&s, ops)); + try std.testing.expectEqual(@as(usize, 1), Mock.live); + Mock.fail_fence = false; + try cache.abandon(&s, ops); + try std.testing.expectEqual(@as(usize, 0), Mock.live); +} + +test "allocation refusal and disabled path perform no CUDA copy or fence" { + Mock.reset(); + var f: Fixture = .{}; + const ops = f.ops(); + var s = try stream(&.{1}, false); + defer s.deinit(a); + var seq = f.seq(1); + var off = cache_mod.Cache.init(a, false); + defer off.deinit(ops) catch unreachable; + try off.capture(&s, &seq, null, ops, g); + try std.testing.expect(!try off.lookup(&s, &seq, null, ops, g)); + var failing = std.testing.FailingAllocator.init(a, .{ .fail_index = 0 }); + var refused = cache_mod.Cache.init(failing.allocator(), true); + defer refused.deinit(ops) catch unreachable; + try refused.capture(&s, &seq, null, ops, g); + try std.testing.expectEqual(@as(u64, 1), refused.stats.refusals); + try std.testing.expect(Mock.copies == 0 and Mock.fences == 0 and Mock.live == 0); +} + +test "draft active-bank compact copies preserve metadata and bound maximum snapshot" { + Mock.reset(); + var f: Fixture = .{}; + const ops = f.ops(); + var cache = cache_mod.Cache.init(a, true); + defer cache.deinit(ops) catch unreachable; + var s = try stream(&.{ 1, 2 }, true); + defer s.deinit(a); + var seq = f.seq(2); + var ctx: dr.Context = .{ .arena = .{ .buf = null }, .keys = @splat(@splat(0x10000)), .values = @splat(@splat(0x20000)), .cur = 1, .len = 2, .end = 2 }; + try cache.capture(&s, &seq, &ctx, ops, g); + // absorbMany and _block_attention pack each head at len*128 BF16 values, not the allocation window. + const head_bytes = 2 * 128 * 2; + const target_copies = 2 + 48 * 2 + 16 * 2; + const saved = cache.pending.?; + for (0..5) |layer| for (0..8) |head| { + const pair = Mock.copy_rows[target_copies + layer * 16 + head * 2 ..][0..2]; + try std.testing.expectEqual(0x10000 + head * head_bytes, pair[0].src); + try std.testing.expectEqual(0x20000 + head * head_bytes, pair[1].src); + try std.testing.expectEqual(saved.draft_keys[layer] + head * head_bytes, pair[0].dst); + try std.testing.expectEqual(saved.draft_values[layer] + head * head_bytes, pair[1].dst); + try std.testing.expectEqual(head_bytes, pair[0].bytes); + try std.testing.expectEqual(head_bytes, pair[1].bytes); + }; + const capture_copies = Mock.copies; + finish(&s); + try cache.release(&s, true, ops); + var hit = try stream(&.{ 1, 2 }, true); + defer hit.deinit(a); + ctx.cur = 0; + ctx.len = 0; + ctx.end = 0; + try std.testing.expect(try cache.lookup(&hit, &seq, &ctx, ops, g)); + try std.testing.expect(ctx.cur == 1 and ctx.len == 2 and ctx.end == 2); + for (0..5) |layer| for (0..8) |head| { + const pair = Mock.copy_rows[capture_copies + target_copies + layer * 16 + head * 2 ..][0..2]; + try std.testing.expectEqual(0x10000 + head * head_bytes, pair[0].dst); + try std.testing.expectEqual(0x20000 + head * head_bytes, pair[1].dst); + try std.testing.expectEqual(saved.draft_keys[layer] + head * head_bytes, pair[0].src); + try std.testing.expectEqual(saved.draft_values[layer] + head * head_bytes, pair[1].src); + }; + try std.testing.expectEqual(@as(usize, 197995008), cache_mod.Snapshot.bytes(g, 512, true)); + try std.testing.expect(cache_mod.Snapshot.bytes(g, 512, true) <= cache_mod.policy.max_bytes); +} + +test "acquisition hint shares exact eligibility but never copies or reports a hit" { + Mock.reset(); + var f: Fixture = .{}; + const ops = f.ops(); + var cache = cache_mod.Cache.init(a, true); + defer cache.deinit(ops) catch unreachable; + var seed = try stream(&.{ 1, 2, 3 }, false); + defer seed.deinit(a); + var seq = f.seq(3); + try cache.capture(&seed, &seq, null, ops, g); + finish(&seed); + try cache.release(&seed, true, ops); + var hit = try stream(&.{ 1, 2, 3 }, false); + defer hit.deinit(a); + const before = cache.stats; + const copies = Mock.copies; + const fences = Mock.fences; + const active = cache.active; + try std.testing.expect(cache.canRestore(&hit, false)); + try std.testing.expect(!cache.canRestore(&hit, true)); + hit.cached = 1; + try std.testing.expect(!cache.canRestore(&hit, false)); + hit.cached = 0; + cache.failed = true; + try std.testing.expect(!cache.canRestore(&hit, false)); + cache.failed = false; + var miss = try stream(&.{ 1, 2, 4 }, false); + defer miss.deinit(a); + try std.testing.expect(!cache.canRestore(&miss, false)); + try std.testing.expect(std.meta.eql(before, cache.stats)); + try std.testing.expectEqual(copies, Mock.copies); + try std.testing.expectEqual(fences, Mock.fences); + try std.testing.expect(cache.active == active and hit.cached == 0); +} + +test "enabled first logits add one bounded row and absent marker prevents promotion" { + Mock.reset(); + var f: Fixture = .{}; + const ops = f.ops(); + var cache = cache_mod.Cache.init(a, true); + cache.logits_enabled = true; + defer cache.deinit(ops) catch unreachable; + var seed = try stream(&.{ 1, 2, 3 }, false); + defer seed.deinit(a); + var seq = f.seq(3); + try cache.capture(&seed, &seq, null, ops, g); + const snap = cache.pending.?; + try std.testing.expect(!snap.logits_valid and snap.first_logits != 0); + try std.testing.expectEqual(cache_mod.Snapshot.bytes(g, 3, false) + 496640, snap.device_bytes); + try std.testing.expectEqual(@as(usize, 198491648), cache_mod.Snapshot.bytesWithLogits(g, 512, true, true)); + try std.testing.expect(cache_mod.Snapshot.bytesWithLogits(g, 512, true, true) < cache_mod.policy.max_bytes); + finish(&seed); + try cache.release(&seed, true, ops); + try std.testing.expect(cache.active == null and cache.pending == null and Mock.live == 0); + try std.testing.expectEqual(@as(u64, 1), cache.stats.purges); +} + +test "actual raw capture and proven current-active copy preserve direction and eviction fallback" { + Mock.reset(); + var f: Fixture = .{}; + const ops = f.ops(); + var cache = cache_mod.Cache.init(a, true); + cache.logits_enabled = true; + defer cache.deinit(ops) catch unreachable; + var seed = try stream(&.{ 1, 2, 3 }, false); + defer seed.deinit(a); + var seq = f.seq(3); + try cache.capture(&seed, &seq, null, ops, g); + const saved_logits = cache.pending.?.first_logits; + const before = Mock.copies; + try std.testing.expect(try cache.captureFirstLogits(&seed, &seq, ops, 0x7770)); + try std.testing.expectEqual(before + 1, Mock.copies); + try std.testing.expectEqual(saved_logits, Mock.copy_rows[before].dst); + try std.testing.expectEqual(@as(u64, 0x7770), Mock.copy_rows[before].src); + try std.testing.expectEqual(@as(usize, 496640), Mock.copy_rows[before].bytes); + finish(&seed); + try cache.release(&seed, true, ops); + var hit = try stream(&.{ 1, 2, 3 }, false); + defer hit.deinit(a); + var dest = f.seq(0); + try std.testing.expect(try cache.lookup(&hit, &dest, null, ops, g)); + const copied = Mock.copies; + try std.testing.expect(!try cache.restoreFirstLogits(&hit, &dest, ops, 0x8880, false)); + try std.testing.expectEqual(copied, Mock.copies); + dest.pos = 4; + try std.testing.expect(!try cache.restoreFirstLogits(&hit, &dest, ops, 0x8880, true)); + dest.pos = 3; + try std.testing.expect(try cache.restoreFirstLogits(&hit, &dest, ops, 0x8880, true)); + try std.testing.expectEqual(saved_logits, Mock.copy_rows[copied].src); + try std.testing.expectEqual(@as(u64, 0x8880), Mock.copy_rows[copied].dst); + try std.testing.expectEqual(@as(usize, 496640), Mock.copy_rows[copied].bytes); + try std.testing.expect(cache.active.?.logits_valid); + try std.testing.expectEqual(@as(u64, 1), cache.stats.first_logits_hits); + Mock.copies = 0; + var miss = try stream(&.{ 4, 5, 6 }, false); + defer miss.deinit(a); + try cache.capture(&miss, &seq, null, ops, g); + try std.testing.expect(cache.active == null and cache.pending != null); + const after_eviction = Mock.copies; + try std.testing.expect(!try cache.restoreFirstLogits(&hit, &dest, ops, 0x8880, true)); + try std.testing.expectEqual(after_eviction, Mock.copies); + try std.testing.expect(Mock.fences > 0); +} + +test "raw capture error clears validity and hit copy error disables future use" { + Mock.reset(); + var f: Fixture = .{}; + const ops = f.ops(); + var cache = cache_mod.Cache.init(a, true); + cache.logits_enabled = true; + defer cache.deinit(ops) catch unreachable; + var seed = try stream(&.{1}, false); + defer seed.deinit(a); + var seq = f.seq(1); + try cache.capture(&seed, &seq, null, ops, g); + Mock.fail_copy = true; + try std.testing.expectError(error.NotReady, cache.captureFirstLogits(&seed, &seq, ops, 0x7770)); + try std.testing.expect(cache.failed and !cache.pending.?.logits_valid); + Mock.fail_copy = false; + finish(&seed); + try cache.release(&seed, true, ops); + try std.testing.expect(cache.active == null and cache.pending == null); + cache.failed = false; + seed.finished = false; + seed.reason = .none; + try cache.capture(&seed, &seq, null, ops, g); + try std.testing.expect(try cache.captureFirstLogits(&seed, &seq, ops, 0x7770)); + finish(&seed); + try cache.release(&seed, true, ops); + var hit = try stream(&.{1}, false); + defer hit.deinit(a); + var dest = f.seq(0); + try std.testing.expect(try cache.lookup(&hit, &dest, null, ops, g)); + Mock.fail_copy = true; + try std.testing.expectError(error.NotReady, cache.restoreFirstLogits(&hit, &dest, ops, 0x8880, true)); + try std.testing.expect(cache.failed); + Mock.fail_copy = false; + try std.testing.expect(!try cache.restoreFirstLogits(&hit, &dest, ops, 0x8880, true)); +} + +test "logits-off capture and first-logit methods add no row copy or fence" { + Mock.reset(); + var f: Fixture = .{}; + const ops = f.ops(); + var cache = cache_mod.Cache.init(a, true); + defer cache.deinit(ops) catch unreachable; + var seed = try stream(&.{1}, false); + defer seed.deinit(a); + var seq = f.seq(1); + try cache.capture(&seed, &seq, null, ops, g); + try std.testing.expectEqual(cache_mod.Snapshot.bytes(g, 1, false), cache.pending.?.device_bytes); + try std.testing.expectEqual(@as(u64, 0), cache.pending.?.first_logits); + const copied = Mock.copies; + const fenced = Mock.fences; + try std.testing.expect(!try cache.captureFirstLogits(&seed, &seq, ops, 0x7770)); + try std.testing.expect(!try cache.restoreFirstLogits(&seed, &seq, ops, 0x8880, true)); + try std.testing.expectEqual(copied, Mock.copies); + try std.testing.expectEqual(fenced, Mock.fences); + finish(&seed); + try cache.release(&seed, true, ops); + try std.testing.expect(cache.active != null); +} diff --git a/zig/src/families/qwen27/cuda/exact_draft_reuse.zig b/zig/src/families/qwen27/cuda/exact_draft_reuse.zig new file mode 100644 index 000000000..e2fa9d8f2 --- /dev/null +++ b/zig/src/families/qwen27/cuda/exact_draft_reuse.zig @@ -0,0 +1,173 @@ +//! Private cold-capable Context storage recycling; uncertain in-flight ownership is quarantined, never reused. +const std = @import("std"); +const Cuda = @import("lanes.zig").Cuda; +const lanes = @import("lanes"); +const drafts = @import("drafts.zig"); +const dr = @import("draft.zig"); +const seq_reuse = @import("exact_seq_reuse.zig"); +pub const policy = @import("draft_pool.zig"); +pub const Storage = policy.Pool(drafts.Stream); + +fn destroy(x: *Cuda, ds: *drafts.Stream) void { + ds.deinit(); + x.gpa.destroy(ds); +} + +fn clearIdle(x: *Cuda) void { + while (x.draft_pool.evict()) |ds| destroy(x, ds); +} + +/// Only already-fenced idle storage can be freed without another fence. +pub fn fail(x: *Cuda) void { + if (!x.draft_pool.stats.enabled) return; + x.draft_pool.fail(); + clearIdle(x); +} + +fn fresh(s: *lanes.Stream) bool { + return s.chunks.len == 0 and !s.reuse_failed and s.reuse.saved == null and s.reuse.at == 0 and + s.reuse.marks.len == 0 and s.reuse.hook == null; +} + +fn eligible(x: *Cuda, s: *lanes.Stream, capacity: usize) bool { + return policy.eligible(s.drafts, x.drafter != null, s.prompt().len, capacity, fresh(s), s.isCancelled()); +} + +fn reap(x: *Cuda) !void { + if (x.draft_pool.stats.quarantined_slots == 0) return; + try x.e.s.synchronize(); + while (x.draft_pool.reap(true)) |ds| destroy(x, ds); +} + +/// Misses within the fixed small class may take storage; unsupported admissions drain before target allocation. +pub fn beforeOpen(x: *Cuda, s: *lanes.Stream, capacity: usize) !void { + if (!x.draft_pool.stats.enabled) return; + try reap(x); + if (x.seqs.count() >= x.draft_pool.limit) return error.DraftPoolOwnershipLimit; + if (!x.draft_pool.active() or !eligible(x, s, capacity)) clearIdle(x); +} + +pub fn obtain(x: *Cuda, s: *lanes.Stream) !*drafts.Stream { + errdefer seq_reuse.fail(x); + if (x.drafting.get(s)) |ds| return ds; + var ds: *drafts.Stream = undefined; + if (x.draft_pool.stats.enabled) { + try reap(x); + const seq = x.seqs.get(s) orelse return error.UnknownQwenStream; + if (x.draft_pool.active() and eligible(x, s, seq.capacity)) { + if (x.draft_pool.take()) |saved| { + ds = saved; + errdefer destroy(x, ds); + ds.resetStorage(); + try x.drafting.put(x.gpa, s, ds); + return ds; + } + } else clearIdle(x); + if (!x.draft_pool.hasRoom(x.drafting.count())) return error.DraftPoolOwnershipLimit; + } + ds = try x.gpa.create(drafts.Stream); + errdefer x.gpa.destroy(ds); + const ctx = dr.Context.init(x.e.ctx.d) catch |err| return if (err == error.OutOfMemory) err else error.OutOfDeviceMemory; + if (x.draft_pool.stats.enabled) x.draft_pool.stats.driver_creations += 1; + ds.* = drafts.Stream.init(x.gpa, ctx); + errdefer ds.deinit(); + try x.drafting.put(x.gpa, s, ds); + return ds; +} + +/// The tag authorizes recycling empty storage later, not reuse of prior request state now. +pub fn initialized(x: *Cuda, s: *lanes.Stream) !void { + if (!x.draft_pool.active()) return; + errdefer fail(x); + const seq = x.seqs.get(s) orelse return error.UnknownQwenStream; + if (!eligible(x, s, seq.capacity)) return; + const ds = x.drafting.get(s) orelse return error.UnknownDraftStream; + const buf = ds.ctx.arena.buf orelse return error.InvalidDraftInitialization; + if (seq.pos != s.prompt_len or ds.ctx.len != s.prompt_len or ds.ctx.end != s.prompt_len) + return error.InvalidDraftInitialization; + try x.draft_initialized.mark(.{ .stream = s, .seq = seq, .wrapper = ds, .arena = buf.ptr, .tokens = s.prompt_len, .capacity = seq.capacity }); + x.draft_pool.stats.initialized += 1; +} + +fn detach(x: *Cuda, s: *lanes.Stream) ?*drafts.Stream { + if (x.drafting.fetchRemove(s)) |entry| return entry.value; + return null; +} + +/// Error ownership never enters the reusable pool, even when a later fence succeeds. +pub fn drop(x: *Cuda, s: *lanes.Stream) void { + _ = x.draft_initialized.remove(s); + const ds = detach(x, s) orelse return; + if (!x.draft_pool.stats.enabled) return destroy(x, ds); + fail(x); + x.e.s.synchronize() catch |err| { + std.log.err("quarantining failed draft Context: {s}", .{@errorName(err)}); + x.draft_pool.park(ds, x.drafting.count()); + return; + }; + x.draft_pool.stats.discarded += 1; + destroy(x, ds); +} + +/// Target release has already happened; pointer comparison does not dereference that former Seq owner. +pub fn release(x: *Cuda, s: *lanes.Stream, seq: ?*const anyopaque, settled: bool, cache_ok: bool) void { + const proof = x.draft_initialized.remove(s); + const ds = detach(x, s) orelse return; + if (!x.draft_pool.stats.enabled) return destroy(x, ds); + const normal = s.finished and (s.reason == .stop or s.reason == .length); + const valid = if (proof) |p| p.seq == seq and p.wrapper == @as(*const anyopaque, ds) and + p.arena == (if (ds.ctx.arena.buf) |buf| buf.ptr else 0) and p.tokens == s.prompt_len and + eligible(x, s, p.capacity) else false; + const clean = policy.completed(valid, normal, !s.isCancelled(), settled, cache_ok, x.exact_cache.failed); + if (!settled or !cache_ok or x.exact_cache.failed) fail(x); + x.e.s.synchronize() catch |err| { + std.log.err("quarantining released draft Context: {s}", .{@errorName(err)}); + fail(x); + x.draft_pool.park(ds, x.drafting.count()); + return; + }; + if (clean and !s.isCancelled() and x.draft_pool.active()) { + ds.resetStorage(); + if (x.draft_pool.retain(ds, x.drafting.count())) return; + } + x.draft_pool.stats.discarded += 1; + destroy(x, ds); +} + +fn shutdownFence(stream: anytype) !void { + stream.synchronize() catch |first_err| { + std.log.warn("draft teardown fence, retrying once: {s}", .{@errorName(first_err)}); + try stream.synchronize(); + }; +} + +/// One bounded retry precedes a fatal caller exit; no uncertain Context is freed on either failed fence. +pub fn shutdown(x: *Cuda) !void { + if (!x.draft_pool.stats.enabled) return; + if (x.draft_pool.stats.quarantined_slots > 0 or x.drafting.count() > 0) { + try shutdownFence(&x.e.s); + } + while (x.draft_pool.reap(true)) |ds| destroy(x, ds); + clearIdle(x); + std.debug.print("PR608_EXACT_CACHE_DRAFT_POOL {f}\n", .{std.json.fmt(x.draft_pool.stats, .{})}); +} + +test "shutdown fence has one bounded retry and propagates persistent failure" { + const Mock = struct { + calls: usize = 0, + failures: usize, + pub fn synchronize(x: *@This()) !void { + x.calls += 1; + if (x.calls <= x.failures) return error.MockFenceFailed; + } + }; + var good: Mock = .{ .failures = 0 }; + try shutdownFence(&good); + try std.testing.expectEqual(@as(usize, 1), good.calls); + var recovered: Mock = .{ .failures = 1 }; + try shutdownFence(&recovered); + try std.testing.expectEqual(@as(usize, 2), recovered.calls); + var failed: Mock = .{ .failures = 3 }; + try std.testing.expectError(error.MockFenceFailed, shutdownFence(&failed)); + try std.testing.expectEqual(@as(usize, 2), failed.calls); +} diff --git a/zig/src/families/qwen27/cuda/exact_first_logits.zig b/zig/src/families/qwen27/cuda/exact_first_logits.zig new file mode 100644 index 000000000..5b709a7bf --- /dev/null +++ b/zig/src/families/qwen27/cuda/exact_first_logits.zig @@ -0,0 +1,31 @@ +//! First-head substitution only; the core forced-token selection and every sampling operation remain unchanged. +const std = @import("std"); +const lanes = @import("lanes"); +const Cuda = @import("lanes.zig").Cuda; +const reuse = @import("exact_seq_reuse.zig"); + +pub fn first(p: *anyopaque, s: *lanes.Stream, position: u64) !u64 { + const x: *Cuda = @ptrCast(@alignCast(p)); + errdefer { + reuse.fail(x); + if (x.exact_cache.logits_enabled) { + _ = x.restored.remove(s); + x.exact_cache.failed = true; + x.exact_cache.abandon(s, x.e.ops()) catch |err| std.log.err("first-logits purge: {s}", .{@errorName(err)}); + } + } + const seq = try x.settled(s); + if (position != seq.pos) return error.InvalidQwenPosition; + var f = x.e.forward(); + if (x.exact_cache.logits_enabled) { + const proven = x.seqs.get(s) == seq and x.restored.matches(s, seq, s.prompt().len); + if (!try x.exact_cache.restoreFirstLogits(s, seq, f.ops, f.s.logits, proven)) { + x.exact_cache.stats.first_logits_fallbacks += 1; + try f.head(seq); + _ = try x.exact_cache.captureFirstLogits(s, seq, f.ops, f.s.logits); + } + } else try f.head(seq); + var out: [1]u32 = undefined; + try x.drawRows(&.{s.sampling}, &.{position}, &out); + return out[0]; +} diff --git a/zig/src/families/qwen27/cuda/exact_logits_policy.zig b/zig/src/families/qwen27/cuda/exact_logits_policy.zig new file mode 100644 index 000000000..f4dc1f6d3 --- /dev/null +++ b/zig/src/families/qwen27/cuda/exact_logits_policy.zig @@ -0,0 +1,75 @@ +//! Bounded raw first-logit cache policy; decisions never cache sampling or a selected token. +const std = @import("std"); +pub const row_bytes: usize = 248320 * 2; // shape.zig's fixed BF16 vocabulary row, already 256-byte aligned + +pub fn enabled(text: ?[]const u8, cache_enabled: bool) !bool { + const value = text orelse return false; + if (std.mem.eql(u8, value, "0")) return false; + if (!std.mem.eql(u8, value, "1")) return error.InvalidExactCacheLogitsFlag; + if (!cache_enabled) return error.FirstLogitsRequireExactCache; + return true; +} + +pub fn configured(cache_enabled: bool) !bool { + const env = std.c.getenv("TF_PR608_EXACT_CACHE_LOGITS"); + return enabled(if (env) |v| std.mem.span(v) else null, cache_enabled); +} + +pub fn canUse(healthy: bool, proven: bool, key_matches: bool, valid: bool, position_matches: bool, cancelled: bool) bool { + return healthy and proven and key_matches and valid and position_matches and !cancelled; +} + +pub fn promotable(on: bool, valid: bool) bool { + return !on or valid; +} + +/// Only successful submission grants validity; the existing promotion fence supplies completion. +pub fn capture(valid: *bool, copier: anytype, dst: u64, src: u64) !void { + valid.* = false; + try copier.copy(dst, src, row_bytes); + valid.* = true; +} + +test "raw logits are off by default and strictly require the full-prompt cache" { + try std.testing.expect(!try enabled(null, false)); + try std.testing.expect(!try enabled("0", false)); + try std.testing.expect(try enabled("1", true)); + try std.testing.expectError(error.FirstLogitsRequireExactCache, enabled("1", false)); + try std.testing.expectError(error.InvalidExactCacheLogitsFlag, enabled("true", true)); + try std.testing.expectError(error.InvalidExactCacheLogitsFlag, enabled("", true)); +} + +test "current active key and actual stream restore proof are both required" { + try std.testing.expect(canUse(true, true, true, true, true, false)); + try std.testing.expect(!canUse(false, true, true, true, true, false)); + try std.testing.expect(!canUse(true, false, true, true, true, false)); + try std.testing.expect(!canUse(true, true, false, true, true, false)); + try std.testing.expect(!canUse(true, true, true, false, true, false)); + try std.testing.expect(!canUse(true, true, true, true, false, false)); + try std.testing.expect(!canUse(true, true, true, true, true, true)); + try std.testing.expect(!promotable(true, false)); + try std.testing.expect(promotable(true, true)); + try std.testing.expect(promotable(false, false)); +} + +test "copy submission failure cannot create a valid raw row or promotion" { + const Copier = struct { + fail: bool, + calls: usize = 0, + fn copy(self: *@This(), dst: u64, src: u64, n: usize) !void { + self.calls += 1; + try std.testing.expectEqual(@as(u64, 256), dst); + try std.testing.expectEqual(@as(u64, 512), src); + try std.testing.expectEqual(@as(usize, 496640), n); + if (self.fail) return error.InjectedCopyFailure; + } + }; + var valid = true; + var copier: Copier = .{ .fail = true }; + try std.testing.expectError(error.InjectedCopyFailure, capture(&valid, &copier, 256, 512)); + try std.testing.expect(!valid and !promotable(true, valid)); + copier.fail = false; + try capture(&valid, &copier, 256, 512); + try std.testing.expect(valid and promotable(true, valid)); + try std.testing.expectEqual(@as(usize, 2), copier.calls); +} diff --git a/zig/src/families/qwen27/cuda/exact_prompt_cache.zig b/zig/src/families/qwen27/cuda/exact_prompt_cache.zig new file mode 100644 index 000000000..51187ed76 --- /dev/null +++ b/zig/src/families/qwen27/cuda/exact_prompt_cache.zig @@ -0,0 +1,337 @@ +//! Default-off full-prompt snapshots into independent normal Qwen allocations. +const std = @import("std"); +const lanes = @import("lanes"); +const st = @import("state.zig"); +const c = @import("shape.zig"); +const dr = @import("draft.zig"); +const dl = @import("draft_load.zig"); +const kern = @import("kernels.zig"); +pub const policy = @import("exact_cache_policy.zig"); +pub const logits_policy = @import("exact_logits_policy.zig"); +const roundedBytes = struct { + fn bytes(n: usize) usize { + return std.mem.alignForward(usize, n, 256); + } +}.bytes; + +pub const Snapshot = struct { + gpa: std.mem.Allocator, + arena: st.Arena, + prompt: []u32, + chunks: []u32, + drafted: bool, + pos: usize, + cur: u1 = 0, + len: usize = 0, + end: usize = 0, + rec: [64]u64 = @splat(0), + conv: [64]u64 = @splat(0), + keys: [64]u64 = @splat(0), + values: [64]u64 = @splat(0), + head_in: u64, + head_xs: u64, + draft_keys: [dl.layers]u64 = @splat(0), + draft_values: [dl.layers]u64 = @splat(0), + device_bytes: usize, + first_logits: u64 = 0, + logits_valid: bool = false, + + pub fn bytes(g: c.Geometry, n: usize, drafted: bool) usize { + return bytesWithLogits(g, n, drafted, false); + } + + pub fn bytesWithLogits(g: c.Geometry, n: usize, drafted: bool, logits: bool) usize { + return st.Seq.bytes(g, n) + (if (drafted) 2 * dl.layers * roundedBytes(dl.kv_heads * n * dl.head_dim * 2) else 0) + + (if (logits) logits_policy.row_bytes else 0); + } + + pub fn init(gpa: std.mem.Allocator, ops: kern.Ops, g: c.Geometry, s: *lanes.Stream) !*Snapshot { + return initWithLogits(gpa, ops, g, s, false); + } + + pub fn initWithLogits(gpa: std.mem.Allocator, ops: kern.Ops, g: c.Geometry, s: *lanes.Stream, logits: bool) !*Snapshot { + if (g.layers != 64) return error.UnsupportedExactCacheGeometry; + const n = s.prompt().len; + const total = bytesWithLogits(g, n, s.drafts, logits); + if (total > policy.max_bytes) return error.ExactCacheBudget; + const out = try gpa.create(Snapshot); + errdefer gpa.destroy(out); + const prompt = try gpa.dupe(u32, s.prompt()); + errdefer gpa.free(prompt); + const chunks = try gpa.dupe(u32, s.chunks); + errdefer gpa.free(chunks); + out.* = .{ .gpa = gpa, .arena = try st.Arena.init(ops.k.d, total), .prompt = prompt, .chunks = chunks, .drafted = s.drafts, .pos = n, .head_in = 0, .head_xs = 0, .device_bytes = total }; + errdefer out.arena.deinit(); + out.head_in = try out.arena.take(g.hidden * 2); + out.head_xs = try out.arena.take(g.hidden / 64 * 4); + for (0..g.layers) |i| { + if (c.linear(i)) { + out.rec[i] = try out.arena.take(g.deltaBytes()); + out.conv[i] = try out.arena.take(g.convBytes()); + } else { + out.keys[i] = try out.arena.take(n * g.kvInner() * 2); + out.values[i] = try out.arena.take(n * g.kvInner() * 2); + } + } + if (s.drafts) for (0..dl.layers) |i| { + out.draft_keys[i] = try out.arena.take(dl.kv_heads * n * dl.head_dim * 2); + out.draft_values[i] = try out.arena.take(dl.kv_heads * n * dl.head_dim * 2); + }; + if (logits) out.first_logits = try out.arena.take(logits_policy.row_bytes); + return out; + } + + fn target(snap: *const Snapshot, ops: kern.Ops, g: c.Geometry, seq: *st.Seq, restoring: bool) !void { + if (seq.capacity < snap.pos) return error.ExactCacheCapacity; + const pair = struct { + fn run(o: kern.Ops, saved: u64, live: u64, n: usize, restored: bool) !void { + try o.copy(if (restored) live else saved, if (restored) saved else live, n); + } + }.run; + try pair(ops, snap.head_in, seq.head_in, g.hidden * 2, restoring); + try pair(ops, snap.head_xs, seq.head_xs, g.hidden / 64 * 4, restoring); + for (0..g.layers) |i| if (c.linear(i)) { + try pair(ops, snap.rec[i], seq.rec[i], g.deltaBytes(), restoring); + try pair(ops, snap.conv[i], seq.conv[i], g.convBytes(), restoring); + } else { + try pair(ops, snap.keys[i], seq.keys[i], snap.pos * g.kvInner() * 2, restoring); + try pair(ops, snap.values[i], seq.values[i], snap.pos * g.kvInner() * 2, restoring); + }; + } + + fn context(snap: *const Snapshot, ops: kern.Ops, ctx: *dr.Context, restoring: bool) !void { + const n = snap.len * dl.head_dim * 2; + const live_stride = n; + for (0..dl.layers) |i| for (0..dl.kv_heads) |h| { + const k = ctx.keys[i][snap.cur] + h * live_stride; + const v = ctx.values[i][snap.cur] + h * live_stride; + const sk = snap.draft_keys[i] + h * n; + const sv = snap.draft_values[i] + h * n; + try ops.copy(if (restoring) k else sk, if (restoring) sk else k, n); + try ops.copy(if (restoring) v else sv, if (restoring) sv else v, n); + }; + } + + pub fn save(snap: *Snapshot, ops: kern.Ops, g: c.Geometry, seq: *st.Seq, ctx: ?*dr.Context) !void { + if (seq.pos != snap.pos or (snap.drafted != (ctx != null))) return error.InvalidExactCacheState; + if (ctx) |x| { + if (x.len != snap.pos or x.end != snap.pos) return error.InvalidExactCacheContext; + snap.cur = x.cur; + snap.len = x.len; + snap.end = x.end; + } + try snap.target(ops, g, seq, false); + if (ctx) |x| try snap.context(ops, x, false); + } + + pub fn restore(snap: *const Snapshot, ops: kern.Ops, g: c.Geometry, seq: *st.Seq, ctx: ?*dr.Context) !void { + if (snap.drafted != (ctx != null)) return error.InvalidExactCacheState; + try snap.target(ops, g, seq, true); + if (ctx) |x| { + try snap.context(ops, x, true); + x.cur = snap.cur; + x.len = snap.len; + x.end = snap.end; + } + seq.pos = snap.pos; + } + + pub fn matches(snap: *const Snapshot, s: *lanes.Stream) bool { + return snap.drafted == s.drafts and std.mem.eql(u32, snap.prompt, s.prompt()) and std.mem.eql(u32, snap.chunks, s.chunks); + } + + fn deinit(snap: *Snapshot) void { + snap.arena.deinit(); + snap.gpa.free(snap.prompt); + snap.gpa.free(snap.chunks); + snap.gpa.destroy(snap); + } +}; + +pub const Stats = struct { + lookups: u64 = 0, + hits: u64 = 0, + misses: u64 = 0, + captures: u64 = 0, + promotions: u64 = 0, + purges: u64 = 0, + evictions: u64 = 0, + refusals: u64 = 0, + active_bytes: usize = 0, + pending_bytes: usize = 0, + first_logits_captures: u64 = 0, + first_logits_hits: u64 = 0, + first_logits_fallbacks: u64 = 0, +}; + +pub const Cache = struct { + gpa: std.mem.Allocator, + enabled: bool, + logits_enabled: bool = false, + failed: bool = false, + active: ?*Snapshot = null, + pending: ?*Snapshot = null, + owner: ?*lanes.Stream = null, + stats: Stats = .{}, + + pub fn init(gpa: std.mem.Allocator, on: bool) Cache { + return .{ .gpa = gpa, .enabled = on }; + } + + fn eligible(cache: *const Cache, s: *lanes.Stream) bool { + const fresh = s.reuse.saved == null and s.reuse.at == 0 and s.reuse.marks.len == 0 and s.cached == 0; + return cache.enabled and !cache.failed and policy.eligible(s.prompt().len, s.chunks.len, fresh, s.isCancelled()); + } + + /// Pure acquisition hint; successful lookup, not this hint, proves restoration. + pub fn canRestore(cache: *const Cache, s: *lanes.Stream, drafted: bool) bool { + if (!cache.eligible(s) or s.drafts != drafted) return false; + const snap = cache.active orelse return false; + return snap.matches(s); + } + + fn fence(cache: *Cache, ops: kern.Ops) !void { + ops.s.synchronize() catch |err| { + cache.failed = true; + return err; + }; + } + + fn freeActive(cache: *Cache, ops: kern.Ops) !void { + if (cache.active) |snap| { + try cache.fence(ops); + snap.deinit(); + cache.active = null; + cache.stats.active_bytes = 0; + } + } + + fn freePending(cache: *Cache, ops: kern.Ops) !void { + if (cache.pending) |snap| { + try cache.fence(ops); + snap.deinit(); + cache.pending = null; + cache.owner = null; + cache.stats.pending_bytes = 0; + } + } + + pub fn lookup(cache: *Cache, s: *lanes.Stream, seq: *st.Seq, ctx: ?*dr.Context, ops: kern.Ops, g: c.Geometry) !bool { + if (!cache.eligible(s) or s.drafts != (ctx != null)) return false; + cache.stats.lookups += 1; + if (cache.active) |snap| if (snap.matches(s)) { + snap.restore(ops, g, seq, ctx) catch |err| { + cache.failed = true; + return err; + }; + s.cached = @intCast(snap.pos); + cache.stats.hits += 1; + return true; + }; + cache.stats.misses += 1; + return false; + } + + pub fn capture(cache: *Cache, s: *lanes.Stream, seq: *st.Seq, ctx: ?*dr.Context, ops: kern.Ops, g: c.Geometry) !void { + if (!cache.eligible(s) or s.drafts != (ctx != null) or (cache.active != null and cache.active.?.matches(s))) return; + const size = Snapshot.bytesWithLogits(g, s.prompt().len, s.drafts, cache.logits_enabled); + switch (policy.admission(cache.stats.active_bytes, cache.stats.pending_bytes, size)) { + .refuse, .busy => { + cache.stats.refusals += 1; + return; + }, + .evict => { + try cache.freeActive(ops); + cache.stats.evictions += 1; + }, + .retain => {}, + } + const snap = Snapshot.initWithLogits(cache.gpa, ops, g, s, cache.logits_enabled) catch { + cache.stats.refusals += 1; + return; + }; + cache.pending = snap; + cache.owner = s; + cache.stats.pending_bytes = snap.device_bytes; + snap.save(ops, g, seq, ctx) catch |err| { + cache.failed = true; + return err; + }; + cache.stats.captures += 1; + } + + /// Copy only from the current matching immutable entry; eviction means an ordinary head fallback. + pub fn restoreFirstLogits(cache: *Cache, s: *lanes.Stream, seq: *st.Seq, ops: kern.Ops, raw: u64, proven: bool) !bool { + if (!cache.logits_enabled) return false; + const snap = cache.active orelse return false; + if (!logits_policy.canUse(cache.enabled and !cache.failed, proven, snap.matches(s), snap.logits_valid, seq.pos == snap.pos and s.prompt().len == snap.pos and s.cached == snap.pos, s.isCancelled())) return false; + if (snap.first_logits == 0) return error.InvalidFirstLogitsStorage; + ops.copy(raw, snap.first_logits, logits_policy.row_bytes) catch |err| { + cache.failed = true; + return err; + }; + cache.stats.first_logits_hits += 1; + return true; + } + + /// Preserve the cold owner's raw row before any draw; the normal promotion fence completes this copy. + pub fn captureFirstLogits(cache: *Cache, s: *lanes.Stream, seq: *st.Seq, ops: kern.Ops, raw: u64) !bool { + if (!cache.logits_enabled or cache.failed or cache.owner != s) return false; + const snap = cache.pending orelse return false; + if (snap.logits_valid) return false; + if (!snap.matches(s) or seq.pos != snap.pos or snap.first_logits == 0) return error.InvalidFirstLogitsCapture; + logits_policy.capture(&snap.logits_valid, ops, snap.first_logits, raw) catch |err| { + cache.failed = true; + snap.logits_valid = false; + return err; + }; + cache.stats.first_logits_captures += 1; + return true; + } + + pub fn release(cache: *Cache, s: *lanes.Stream, settled: bool, ops: kern.Ops) !void { + if (!settled) { + cache.failed = true; + if (cache.pending != null) { + try cache.freePending(ops); + cache.stats.purges += 1; + } + return; + } + if (cache.owner != s) return; + const normal = s.reason == .stop or s.reason == .length; + const logits_ready = if (cache.pending) |snap| logits_policy.promotable(cache.logits_enabled, snap.logits_valid) else false; + if (cache.failed or !logits_ready or !policy.clean(s.finished, normal, s.isCancelled(), settled)) { + try cache.freePending(ops); + cache.stats.purges += 1; + return; + } + try cache.fence(ops); + try cache.freeActive(ops); + cache.active = cache.pending; + cache.pending = null; + cache.owner = null; + cache.stats.active_bytes = cache.stats.pending_bytes; + cache.stats.pending_bytes = 0; + cache.stats.promotions += 1; + } + + pub fn abandon(cache: *Cache, s: *lanes.Stream, ops: kern.Ops) !void { + if (cache.owner == s) { + try cache.freePending(ops); + cache.stats.purges += 1; + } + } + + pub fn deinit(cache: *Cache, ops: kern.Ops) !void { + if (cache.enabled) std.debug.print("PR608_EXACT_CACHE {{\"hits\":{d},\"misses\":{d},\"captures\":{d},\"promotions\":{d},\"purges\":{d},\"evictions\":{d},\"refusals\":{d},\"active_bytes\":{d},\"pending_bytes\":{d},\"failed\":{}}}\n", .{ cache.stats.hits, cache.stats.misses, cache.stats.captures, cache.stats.promotions, cache.stats.purges, cache.stats.evictions, cache.stats.refusals, cache.stats.active_bytes, cache.stats.pending_bytes, cache.failed }); + if (cache.logits_enabled) std.debug.print("PR608_EXACT_CACHE_LOGITS {f}\n", .{std.json.fmt(.{ + .captures = cache.stats.first_logits_captures, + .hits = cache.stats.first_logits_hits, + .fallbacks = cache.stats.first_logits_fallbacks, + .failed = cache.failed, + }, .{})}); + try cache.freePending(ops); + try cache.freeActive(ops); + } +}; diff --git a/zig/src/families/qwen27/cuda/exact_seq_reuse.zig b/zig/src/families/qwen27/cuda/exact_seq_reuse.zig new file mode 100644 index 000000000..31cbd27e4 --- /dev/null +++ b/zig/src/families/qwen27/cuda/exact_seq_reuse.zig @@ -0,0 +1,172 @@ +//! Private target-only allocation reuse after proven full-N cache restore; reset and draft lifecycle are unchanged. +const std = @import("std"); +const st = @import("state.zig"); +const dr = @import("draft.zig"); +const lanes = @import("lanes"); +const Cuda = @import("lanes.zig").Cuda; +const draft_reuse = @import("exact_draft_reuse.zig"); +pub const policy = @import("seq_pool.zig"); +pub const Proofs = @import("restore_proof.zig").Proofs; +pub const Storage = policy.Pool(st.Seq); +pub const reset_skip = @import("reset_skip.zig"); +pub const Opened = struct { seq: *st.Seq, deferred_reset: bool = false, pooled: bool = false }; + +fn destroy(x: *Cuda, seq: *st.Seq) void { + seq.deinit(); + x.gpa.destroy(seq); +} + +pub fn clear(x: *Cuda) void { + while (x.seq_pool.evict()) |seq| destroy(x, seq); +} + +pub fn fail(x: *Cuda) void { + draft_reuse.fail(x); + if (!x.seq_pool.stats.enabled) return; + x.seq_pool.fail(); + clear(x); +} + +pub fn shutdown(x: *Cuda) void { + if (x.reset_skip.enabled) std.debug.print("PR608_EXACT_CACHE_RESET_SKIP {f}\n", .{std.json.fmt(x.reset_skip, .{})}); + if (x.seq_pool.stats.enabled) std.debug.print("PR608_EXACT_CACHE_SEQ_POOL {f}\n", .{std.json.fmt(x.seq_pool.stats, .{})}); + clear(x); +} + +/// A peek permits acquisition only; a separate successful lookup records restore provenance. +pub fn obtain(x: *Cuda, s: *lanes.Stream, capacity: usize) !*st.Seq { + return (try obtainState(x, s, capacity, false)).seq; +} + +fn obtainState(x: *Cuda, s: *lanes.Stream, capacity: usize, defer_reset: bool) !Opened { + errdefer fail(x); + if (x.seq_pool.active()) { + if (x.seqs.count() >= x.seq_pool.limit) return error.SeqReuseOwnershipLimit; + if (!s.reuse_failed and s.reuse.hook == null and + x.exact_cache.canRestore(s, x.drafter != null and s.drafts) and capacity <= x.e.context) + { + if (x.seq_pool.take(capacity)) |seq| { + errdefer destroy(x, seq); + if (seq.capacity != capacity) return error.SeqReuseCapacityMismatch; + if (defer_reset) seq.pos = 0 else try seq.reset(x.e.ops(), x.e.w.g); + try x.seqs.put(x.gpa, s, seq); + if (defer_reset) x.reset_skip.deferred_pool += 1; + return .{ .seq = seq, .deferred_reset = defer_reset, .pooled = true }; + } + } + // Every fresh creation drains retained ownership, including a prompt-key miss with room. + x.seq_pool.beforeCreate(x, destroy); + if (!x.seq_pool.hasRoom(x.seqs.count())) return error.SeqReuseOwnershipLimit; + } + const seq = try x.gpa.create(st.Seq); + errdefer x.gpa.destroy(seq); + x.seq_pool.stats.create_attempts += 1; + seq.* = (if (defer_reset) x.e.sequenceForRestore(capacity) else x.e.sequence(capacity)) catch |err| return if (err == error.OutOfMemory) err else error.OutOfDeviceMemory; + x.seq_pool.stats.driver_creations += 1; + errdefer seq.deinit(); + try x.seqs.put(x.gpa, s, seq); + if (defer_reset) x.reset_skip.deferred_fresh += 1; + return .{ .seq = seq, .deferred_reset = defer_reset }; +} + +/// Private admission only; public Cuda.open always initializes the target. +pub fn openPrefill(x: *Cuda, s: *lanes.Stream) !Opened { + if (!x.reset_skip.enabled) return .{ .seq = try x.open(s) }; + errdefer fail(x); + try x.settle(); + const ids = s.prompt(); + if (ids.len == 0 or x.seqs.contains(s)) return error.InvalidQwenPrompt; + const capacity = @min(x.e.context, ids.len + s.max_new + st.max_rows); + if (ids.len >= capacity) return error.PromptTooLong; + try draft_reuse.beforeOpen(x, s, capacity); + const hint = capacity <= reset_skip.max_capacity and !s.reuse_failed and s.reuse.hook == null and + x.exact_cache.canRestore(s, x.drafter != null and s.drafts); + return obtainState(x, s, capacity, hint); +} + +const Resolve = struct { + x: *Cuda, + stream: *lanes.Stream, + seq: *st.Seq, + ctx: ?*dr.Context, + pub fn cancelled(a: Resolve) bool { + return a.stream.isCancelled(); + } + pub fn lookup(a: Resolve) !bool { + return @import("exact_seq_reuse.zig").lookup(a.x, a.stream, a.seq, a.ctx); + } + pub fn reset(a: Resolve) !void { + try a.seq.reset(a.x.e.ops(), a.x.e.w.g); + } +}; + +/// No target call may precede resolution; restore errors abort, never fall back from a partial copy. +pub fn lookupPrefill(x: *Cuda, s: *lanes.Stream, opened: *Opened, ctx: ?*dr.Context) !bool { + errdefer fail(x); + if (!opened.deferred_reset) return lookup(x, s, opened.seq, ctx); + const action: Resolve = .{ .x = x, .stream = s, .seq = opened.seq, .ctx = ctx }; + return reset_skip.resolve(action, &opened.deferred_reset, opened.pooled, &x.reset_skip, reset_skip.resetWork(x.e.w.g)); +} + +pub fn lookup(x: *Cuda, s: *lanes.Stream, seq: *st.Seq, ctx: ?*dr.Context) !bool { + errdefer fail(x); + const hit = try x.exact_cache.lookup(s, seq, ctx, x.e.ops(), x.e.w.g); + if (hit and (x.seq_pool.active() or x.exact_cache.logits_enabled)) { + if (x.seqs.get(s) != seq or seq.pos != s.prompt().len or s.cached != s.prompt().len) + return error.InvalidSeqRestoreProof; + try x.restored.mark(s, seq, s.prompt().len); + } + if (hit) try draft_reuse.initialized(x, s); + return hit; +} + +fn retainOrDestroy(x: *Cuda, s: *lanes.Stream, seq: *st.Seq, restored: bool, settled: bool, cache_ok: bool) void { + const bytes = st.Seq.bytes(x.e.w.g, seq.capacity); + const safe = cache_ok and !x.exact_cache.failed and seq.capacity <= x.e.context and + seq.pos >= s.prompt_len and seq.pos <= seq.capacity; + if (safe and policy.completed(s, settled, restored, cache_ok, x.exact_cache.failed) and x.seq_pool.canRetain(x.seqs.count(), seq.capacity, bytes)) { + x.e.s.synchronize() catch |err| { + std.log.err("synchronizing before exact-cache Seq retention: {s}", .{@errorName(err)}); + fail(x); + x.seq_pool.stats.discarded += 1; + destroy(x, seq); + return; + }; + if (policy.completed(s, settled, restored, cache_ok, x.exact_cache.failed) and !x.exact_cache.failed and + x.seq_pool.retain(seq, x.seqs.count(), seq.capacity, bytes)) return; + } + x.seq_pool.stats.discarded += 1; + destroy(x, seq); +} + +/// Release retains only detached, synchronized ownership after actual settle and cache-release success. +pub fn release(ptr: *anyopaque, s: *lanes.Stream) void { + const x: *Cuda = @ptrCast(@alignCast(ptr)); + const settled_ok = blk: { + x.settle() catch |err| { + std.log.err("committing the last round before a release: {s}", .{@errorName(err)}); + break :blk false; + }; + break :blk true; + }; + const cache_ok = blk: { + x.exact_cache.release(s, settled_ok, x.e.ops()) catch |err| { + std.log.err("exact cache release: {s}", .{@errorName(err)}); + fail(x); + break :blk false; + }; + break :blk true; + }; + const draft_seq: ?*const anyopaque = if (x.seqs.get(s)) |seq| seq else null; + const proof = x.restored.remove(s); + if (x.seqs.fetchRemove(s)) |entry| { + const restored = if (proof) |p| p.seq == @as(*const anyopaque, entry.value) and p.tokens == s.prompt_len else false; + retainOrDestroy(x, s, entry.value, restored, settled_ok, cache_ok); + } + draft_reuse.release(x, s, draft_seq, settled_ok, cache_ok); +} + +test { + _ = policy; + _ = @import("restore_proof.zig"); +} diff --git a/zig/src/families/qwen27/cuda/lanes.zig b/zig/src/families/qwen27/cuda/lanes.zig index 9f4f4a63e..5844a63d7 100644 --- a/zig/src/families/qwen27/cuda/lanes.zig +++ b/zig/src/families/qwen27/cuda/lanes.zig @@ -14,6 +14,9 @@ const drafts = @import("drafts.zig"); const lone = @import("lone.zig"); const trees = @import("tree.zig"); const be = lanes.backend; +const exact = @import("exact_prompt_cache.zig"); +const reuse = @import("exact_seq_reuse.zig"); +const draft_reuse = @import("exact_draft_reuse.zig"); /// The row counts calibrate times (calibration_rows without the tile steps a GB10 skips), to 16 a stream. const calibration = [_]usize{ 1, 2, 4, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256 }; @@ -44,12 +47,29 @@ pub const Cuda = struct { drafting: std.AutoHashMapUnmanaged(*lanes.Stream, *drafts.Stream) = .empty, costs: [calibration.len + 1]lanes.config.Cost = undefined, // the forward's ms by a round's rows (calibrate) cost_count: usize = 0, + exact_cache: exact.Cache, + seq_pool: reuse.Storage, + restored: reuse.Proofs = .{}, + draft_pool: draft_reuse.Storage, + draft_initialized: draft_reuse.policy.Proofs = .{}, + reset_skip: reuse.reset_skip.Stats, + pub const openPrefill = reuse.openPrefill; + const release = reuse.release; + const first = @import("exact_first_logits.zig").first; pub fn init(gpa: std.mem.Allocator, e: *Engine, streams: u32) !Cuda { + const env = std.c.getenv("TF_PR608_EXACT_PROMPT_CACHE"); + const on = try exact.policy.enabled(if (env) |v| std.mem.span(v) else null); + var cache = exact.Cache.init(gpa, on); + cache.logits_enabled = try exact.logits_policy.configured(on); return .{ .gpa = gpa, .e = e, .streams = streams, + .exact_cache = cache, + .reset_skip = .{ .enabled = try reuse.reset_skip.configured(on) }, + .seq_pool = reuse.Storage.init(try reuse.policy.configured(on), streams), + .draft_pool = draft_reuse.Storage.init(try draft_reuse.policy.configured(on), streams, dr.Context.bytes()), .logits = try gpa.alloc(u16, c.vocab), .cand_values = try gpa.alloc(f32, st.round_rows * st.max_candidates), .cand_ids = try gpa.alloc(i64, st.round_rows * st.max_candidates), @@ -58,6 +78,12 @@ pub const Cuda = struct { } pub fn deinit(x: *Cuda) void { + draft_reuse.shutdown(x) catch |err| { + std.log.err("fatal unresolved draft Context fence; terminating before device frees: {s}", .{@errorName(err)}); + std.process.exit(1); + }; + reuse.shutdown(x); + x.exact_cache.deinit(x.e.ops()) catch |err| std.log.err("exact cache shutdown: {s}", .{@errorName(err)}); var it = x.seqs.valueIterator(); while (it.next()) |seq| { seq.*.deinit(); @@ -135,14 +161,7 @@ pub const Cuda = struct { /// The stream's drafting (its DFlash2 context and copy index), made on first use. pub fn draftingOf(x: *Cuda, s: *lanes.Stream) !*drafts.Stream { - if (x.drafting.get(s)) |ds| return ds; - const ds = try x.gpa.create(drafts.Stream); - errdefer x.gpa.destroy(ds); - const ctx = dr.Context.init(x.e.ctx.d) catch |err| return if (err == error.OutOfMemory) err else error.OutOfDeviceMemory; - ds.* = drafts.Stream.init(x.gpa, ctx); - errdefer ds.deinit(); - try x.drafting.put(x.gpa, s, ds); - return ds; + return draft_reuse.obtain(x, s); } fn cast(p: *anyopaque) *Cuda { @@ -154,7 +173,8 @@ pub const Cuda = struct { } /// Commits the last verified round: every stream its kept rows (its whole window unless keep cut it). - fn settle(x: *Cuda) !void { + pub fn settle(x: *Cuda) !void { + errdefer reuse.fail(x); const p = &x.pending; if (p.n == 0) return; const n = p.n; @@ -164,13 +184,14 @@ pub const Cuda = struct { } /// The stream's state, the last round committed first. - fn settled(x: *Cuda, s: *lanes.Stream) !*st.Seq { + pub fn settled(x: *Cuda, s: *lanes.Stream) !*st.Seq { try x.settle(); return x.seqOf(s); } /// The round's logits rows drawn: greedy by one argmax, sampled from top (top_k + 8) GPU candidates or whole rows. pub fn drawRows(x: *Cuda, rules: []const ?lanes.Sampling, positions: []const u64, out: []u32) !void { + errdefer reuse.fail(x); const rows = positions.len; var f = x.e.forward(); const s = f.s; @@ -206,33 +227,37 @@ pub const Cuda = struct { /// A new stream's state, sized for its prompt and reply. pub fn open(x: *Cuda, s: *lanes.Stream) !*st.Seq { + errdefer reuse.fail(x); try x.settle(); const ids = s.prompt(); if (ids.len == 0 or x.seqs.contains(s)) return error.InvalidQwenPrompt; const capacity = @min(x.e.context, ids.len + s.max_new + st.max_rows); if (ids.len >= capacity) return error.PromptTooLong; - const seq = try x.gpa.create(st.Seq); - errdefer x.gpa.destroy(seq); - seq.* = x.e.sequence(capacity) catch |err| return if (err == error.OutOfMemory) err else error.OutOfDeviceMemory; - errdefer seq.deinit(); - try x.seqs.put(x.gpa, s, seq); - return seq; + try draft_reuse.beforeOpen(x, s, capacity); + return reuse.obtain(x, s, capacity); } fn prefill(p: *anyopaque, s: *lanes.Stream) !void { const x = cast(p); - const seq = try x.open(s); + var opened = try x.openPrefill(s); errdefer x.dropSeq(s); - try x.prefillOpened(s, seq); + try x.prefillOpened(s, &opened); } /// prefill_state into an opened stream: the prompt in chunks, a drafting stream's last window of taps absorbed. - fn prefillOpened(x: *Cuda, s: *lanes.Stream, seq: *st.Seq) !void { + fn prefillOpened(x: *Cuda, s: *lanes.Stream, opened: *reuse.Opened) !void { + errdefer reuse.fail(x); + const seq = opened.seq; if (x.drafter) |d| if (s.drafts) { const ds = try x.draftingOf(s); - return lone.prefill(x.e, seq, &ds.ctx, d, s.prompt()); + if (try reuse.lookupPrefill(x, s, opened, &ds.ctx)) return; + try lone.prefill(x.e, seq, &ds.ctx, d, s.prompt()); + try x.exact_cache.capture(s, seq, &ds.ctx, x.e.ops(), x.e.w.g); + return draft_reuse.initialized(x, s); }; + if (try reuse.lookupPrefill(x, s, opened, null)) return; try x.e.prefill(seq, s.prompt()); + try x.exact_cache.capture(s, seq, null, x.e.ops(), x.e.w.g); } /// prefill_batch: prompts in shared passes of at most a chunk's rows (a longer one alone, in its chunks). @@ -243,13 +268,27 @@ pub const Cuda = struct { var n: usize = 0; var rows: usize = 0; for (streams, errs, 0..) |s, *err, i| { - const seq = x.open(s) catch |e| { + var opened = x.openPrefill(s) catch |e| { err.* = e; continue; }; + const seq = opened.seq; const ids = s.prompt(); + if (x.exact_cache.enabled) { + const ctx = if (x.drafter != null and s.drafts) &(x.draftingOf(s) catch |e| { + x.dropSeq(s); + err.* = e; + continue; + }).ctx else null; + const hit = reuse.lookupPrefill(x, s, &opened, ctx) catch |e| { + x.dropSeq(s); + err.* = e; + continue; + }; + if (hit) continue; + } if (ids.len > prompt_rows) { - x.prefillOpened(s, seq) catch |e| { + x.prefillOpened(s, &opened) catch |e| { x.dropSeq(s); err.* = e; }; @@ -277,8 +316,15 @@ pub const Cuda = struct { } fn passPieces(x: *Cuda, streams: []const *lanes.Stream, pieces: []const Forward.Piece, which: []const usize) !void { + errdefer reuse.fail(x); var f = x.e.forward(); - const d = x.drafter orelse return f.chunks(pieces); + const d = x.drafter orelse { + try f.chunks(pieces); + if (x.exact_cache.enabled) for (pieces, which) |pc, i| { + try x.exact_cache.capture(streams[i], pc.seq, null, x.e.ops(), x.e.w.g); + }; + return; + }; f.taps = x.e.scratch.taps; try f.chunks(pieces); // each drafting stream's last window of taps, consecutive whole prompts absorbed together @@ -311,28 +357,28 @@ pub const Cuda = struct { g_rows += taken; } if (g > 0) try d.absorbMany(group[0..g], x.e.scratch.taps + g_from * row); + if (x.exact_cache.enabled) for (pieces, which) |pc, i| { + const s = streams[i]; + const ctx = if (s.drafts) &(try x.draftingOf(s)).ctx else null; + try x.exact_cache.capture(s, pc.seq, ctx, x.e.ops(), x.e.w.g); + }; + for (which) |i| try draft_reuse.initialized(x, streams[i]); } fn dropSeq(x: *Cuda, s: *lanes.Stream) void { + if (x.draft_pool.stats.enabled) draft_reuse.drop(x, s); + reuse.fail(x); + _ = x.restored.remove(s); + x.exact_cache.abandon(s, x.e.ops()) catch |err| std.log.err("exact cache abandon: {s}", .{@errorName(err)}); if (x.seqs.fetchRemove(s)) |entry| { entry.value.deinit(); x.gpa.destroy(entry.value); } } - fn first(p: *anyopaque, s: *lanes.Stream, position: u64) !u64 { - const x = cast(p); - const seq = try x.settled(s); - if (position != seq.pos) return error.InvalidQwenPosition; - var f = x.e.forward(); - try f.head(seq); - var out: [1]u32 = undefined; - try x.drawRows(&.{s.sampling}, &.{position}, &out); - return out[0]; - } - fn queue(p: *anyopaque, s: *lanes.Stream, feed: be.Feed, position: u64) !u64 { const x = cast(p); + errdefer reuse.fail(x); const seq = try x.settled(s); if (position != seq.pos + 1) return error.InvalidQwenPosition; const token: u32 = switch (feed) { @@ -356,6 +402,7 @@ pub const Cuda = struct { /// One forward over every window (one stream: tree_forward's, several: multi_tree_forward's), each row drawn. fn verify(p: *anyopaque, windows: []const be.Window, out: []be.Verified) !void { const x = cast(p); + errdefer reuse.fail(x); if (windows.len != out.len or windows.len == 0 or windows.len > st.max_streams) return error.InvalidQwenWindows; try x.settle(); const pend = &x.pending; @@ -413,6 +460,7 @@ pub const Cuda = struct { /// A window keeps its accepted path (a chain's prefix, or a tree's root-to-node rows); verify keeps all of it. fn keep(p: *anyopaque, windows: []const be.Window, paths: []const []const u32) !void { const x = cast(p); + errdefer reuse.fail(x); const pend = &x.pending; for (windows, paths) |w, path| { const k = for (pend.streams[0..pend.n], 0..) |s, k| { @@ -432,6 +480,7 @@ pub const Cuda = struct { /// The kept rows' taps into each stream's drafter context, then each stream's next drafts. fn draft(p: *anyopaque, requests: []const be.DraftRequest) !void { const x = cast(p); + errdefer reuse.fail(x); const d = x.drafter orelse { for (requests) |r| if (r.depth != 0) return error.QwenCheckpointHasNoDraftHead; return; @@ -478,6 +527,7 @@ pub const Cuda = struct { /// The drafts a stream holds as host tokens and parents (a copy's as a chain). fn tree(p: *anyopaque, s: *lanes.Stream, gpa: std.mem.Allocator) !?lanes.stream.Held { const x = cast(p); + errdefer reuse.fail(x); const ds = x.drafting.get(s) orelse return null; const tokens = try gpa.dupe(u32, ds.tokens.items); errdefer gpa.free(tokens); @@ -493,19 +543,6 @@ pub const Cuda = struct { for (out, ds.scores.items[0..out.len]) |*o, score| o.* = @exp(-score); return true; } - - fn release(p: *anyopaque, s: *lanes.Stream) void { - const x = cast(p); - x.settle() catch |err| std.log.err("committing the last round before a release: {s}", .{@errorName(err)}); - if (x.seqs.fetchRemove(s)) |entry| { - entry.value.deinit(); - x.gpa.destroy(entry.value); - } - if (x.drafting.fetchRemove(s)) |entry| { - entry.value.deinit(); - x.gpa.destroy(entry.value); - } - } }; fn value(word: u16) f64 { @@ -547,3 +584,10 @@ pub fn draw(gpa: std.mem.Allocator, logits: []const u16, settings: ?lanes.Sampli } return @intCast(try lanes.sampling.choose(gpa, values, ids, position, sampling)); } + +test { + _ = @import("exact_cache_test.zig"); + _ = reuse; + _ = draft_reuse; + _ = drafts; +} diff --git a/zig/src/families/qwen27/cuda/reset_skip.zig b/zig/src/families/qwen27/cuda/reset_skip.zig new file mode 100644 index 000000000..fc625e710 --- /dev/null +++ b/zig/src/families/qwen27/cuda/reset_skip.zig @@ -0,0 +1,58 @@ +//! Private prefill reset transaction: only actual full-state restoration resolves uninitialized target state. +const std = @import("std"); +pub const max_capacity: usize = 512; +pub const Stats = struct { + enabled: bool = false, + deferred_fresh: u64 = 0, + deferred_pool: u64 = 0, + restored_fresh: u64 = 0, + restored_pool: u64 = 0, + avoided_fill_calls: u64 = 0, + avoided_fill_bytes: u64 = 0, + fallback_resets: u64 = 0, + failed_deferred_transactions: u64 = 0, +}; + +pub fn compatible(raw: ?[]const u8, cache_enabled: bool) !bool { + const value = raw orelse return false; + if (std.mem.eql(u8, value, "0")) return false; + if (!std.mem.eql(u8, value, "1")) return error.InvalidResetSkip; + if (!cache_enabled) return error.ResetSkipNeedsExactCache; + return true; +} + +pub fn configured(cache_enabled: bool) !bool { + const raw = std.c.getenv("TF_PR608_EXACT_CACHE_SKIP_RESET"); + return compatible(if (raw) |value| std.mem.span(value) else null, cache_enabled); +} + +/// Counts the actual reset domains, excluding attention KV, heads and alignment padding. +pub fn resetWork(g: anytype) struct { calls: u64, bytes: u64 } { + var linear_layers: u64 = 0; + for (0..g.layers) |i| if (i % 4 != 3) { + linear_layers += 1; + }; + return .{ .calls = linear_layers * 2, .bytes = linear_layers * @as(u64, @intCast(g.deltaBytes() + g.convBytes())) }; +} + +/// A hint never resolves deferred state: actual hit or original reset must happen before target work. +pub fn resolve(action: anytype, deferred: *bool, pooled: bool, stats: *Stats, work: anytype) !bool { + if (!deferred.*) return action.lookup(); + errdefer stats.failed_deferred_transactions += 1; + if (action.cancelled()) return error.Cancelled; + const hit = try action.lookup(); + if (hit) { + if (pooled) stats.restored_pool += 1 else stats.restored_fresh += 1; + stats.avoided_fill_calls += work.calls; + stats.avoided_fill_bytes += work.bytes; + } else { + try action.reset(); + stats.fallback_resets += 1; + } + deferred.* = false; + return hit; +} + +test { + _ = @import("reset_skip_test.zig"); +} diff --git a/zig/src/families/qwen27/cuda/reset_skip_factory_test.zig b/zig/src/families/qwen27/cuda/reset_skip_factory_test.zig new file mode 100644 index 000000000..0d1bbc4af --- /dev/null +++ b/zig/src/families/qwen27/cuda/reset_skip_factory_test.zig @@ -0,0 +1,157 @@ +//! Real Seq factories and Ops.fill32 wired to synthetic CUDA driver calls; no device or model is used. +const std = @import("std"); +const cuda = @import("cuda"); +const st = @import("state.zig"); +const shape = @import("shape.zig"); +const kern = @import("kernels.zig"); +const policy = @import("reset_skip.zig"); +const Call = struct { dst: u64, value: c_uint, words: usize }; +var calls: [96]Call = undefined; +var call_count: usize = 0; +var allocations: usize = 0; +var frees: usize = 0; +var fail_alloc: bool = false; +var fail_fill: bool = false; + +fn allocate(ptr: *u64, bytes: usize) callconv(.c) c_int { + if (fail_alloc) return cuda.abi.error_not_ready; + if (bytes == 0) return 1; + allocations += 1; + ptr.* = 0x100000000; + return 0; +} +fn freeDevice(ptr: u64) callconv(.c) c_int { + if (ptr == 0x100000000) frees += 1; + return 0; +} +fn fill(dst: u64, value: c_uint, words: usize, stream: cuda.abi.Stream) callconv(.c) c_int { + _ = stream; + if (fail_fill) return cuda.abi.error_not_ready; + if (call_count >= calls.len) return 1; + calls[call_count] = .{ .dst = dst, .value = value, .words = words }; + call_count += 1; + return 0; +} +fn errorText(code: c_int, out: *?[*:0]const u8) callconv(.c) c_int { + _ = code; + out.* = "synthetic reset failure"; + return 0; +} +fn setup(driver: *cuda.Driver, kernels: *kern.Kernels) kern.Ops { + call_count = 0; + allocations = 0; + frees = 0; + fail_alloc = false; + fail_fill = false; + driver.* = undefined; + driver.api.cuMemAlloc_v2 = allocate; + driver.api.cuMemFree_v2 = freeDevice; + driver.api.cuMemsetD32Async = fill; + driver.api.cuGetErrorName = errorText; + driver.api.cuGetErrorString = errorText; + kernels.* = undefined; + kernels.d = driver; + return .{ .k = kernels, .s = .{ .d = driver, .handle = null } }; +} +fn checkReset(seq: *const st.Seq) !void { + const g = shape.the_27b; + var index: usize = 0; + var bytes: u64 = 0; + for (0..g.layers) |layer| if (shape.linear(layer)) { + try std.testing.expectEqual(seq.rec[layer], calls[index].dst); + try std.testing.expectEqual(g.deltaBytes() / 4, calls[index].words); + try std.testing.expectEqual(seq.conv[layer], calls[index + 1].dst); + try std.testing.expectEqual(g.convBytes() / 4, calls[index + 1].words); + try std.testing.expectEqual(@as(c_uint, 0), calls[index].value | calls[index + 1].value); + bytes += (calls[index].words + calls[index + 1].words) * 4; + index += 2; + }; + try std.testing.expectEqual(@as(usize, 96), index); + try std.testing.expectEqual(index, call_count); + try std.testing.expectEqual(@as(u64, 153944064), bytes); + const actual = policy.resetWork(g); + try std.testing.expectEqual(@as(u64, @intCast(index)), actual.calls); + try std.testing.expectEqual(bytes, actual.bytes); +} + +test "public Seq factory calls all original driver fills and owns one arena" { + var d: cuda.Driver = undefined; + var k: kern.Kernels = undefined; + const ops = setup(&d, &k); + var seq = try st.Seq.init(std.testing.allocator, ops, shape.the_27b, 303); + try checkReset(&seq); + try std.testing.expectEqual(@as(usize, 303), seq.capacity); + try std.testing.expectEqual(@as(usize, 0), seq.pos); + seq.deinit(); + try std.testing.expectEqual(@as(usize, 1), allocations); + try std.testing.expectEqual(allocations, frees); +} + +test "restore destination preserves capacity and layout while omitting only initial fills" { + var d: cuda.Driver = undefined; + var k: kern.Kernels = undefined; + const ops = setup(&d, &k); + var seq = try st.Seq.initRestoreDestination(std.testing.allocator, ops, shape.the_27b, 303); + defer seq.deinit(); + try std.testing.expectEqual(@as(usize, 0), call_count); + try std.testing.expectEqual(@as(usize, 303), seq.capacity); + try std.testing.expectEqual(st.Seq.bytes(shape.the_27b, 303), seq.arena.buf.?.len); + var layout: st.Arena = .{ .buf = null }; + _ = try layout.take(shape.the_27b.hidden * 2); + _ = try layout.take(shape.the_27b.hidden / 64 * 4); + try std.testing.expectEqual(@as(u64, 0x100000000), seq.head_in); + try std.testing.expectEqual(@as(u64, 0x100000000 + 10240), seq.head_xs); + for (0..shape.the_27b.layers) |layer| { + if (shape.linear(layer)) { + const rec_at = std.mem.alignForward(usize, layout.used, 256); + _ = try layout.take(shape.the_27b.deltaBytes()); + const conv_at = std.mem.alignForward(usize, layout.used, 256); + _ = try layout.take(shape.the_27b.convBytes()); + try std.testing.expectEqual(0x100000000 + @as(u64, @intCast(rec_at)), seq.rec[layer]); + try std.testing.expectEqual(0x100000000 + @as(u64, @intCast(conv_at)), seq.conv[layer]); + } else { + _ = try layout.take(303 * shape.the_27b.kvInner() * 2); + _ = try layout.take(303 * shape.the_27b.kvInner() * 2); + } + } + try seq.reset(ops, shape.the_27b); + try checkReset(&seq); +} + +test "restore factory allocation failure owns no device buffer" { + var d: cuda.Driver = undefined; + var k: kern.Kernels = undefined; + const ops = setup(&d, &k); + fail_alloc = true; + try std.testing.expectError(error.NotReady, st.Seq.initRestoreDestination(std.testing.allocator, ops, shape.the_27b, 303)); + try std.testing.expectEqual(@as(usize, 0), allocations + frees + call_count); +} + +test "public factory reset error frees the allocated arena and host arrays" { + var d: cuda.Driver = undefined; + var k: kern.Kernels = undefined; + const ops = setup(&d, &k); + fail_fill = true; + try std.testing.expectError(error.NotReady, st.Seq.init(std.testing.allocator, ops, shape.the_27b, 303)); + try std.testing.expectEqual(@as(usize, 1), allocations); + try std.testing.expectEqual(allocations, frees); +} + +test "public Engine sequence stays initialized and private restore factory omits fills" { + var d: cuda.Driver = undefined; + var engine: @import("engine.zig").Engine = undefined; + const ops = setup(&d, &engine.k); + engine.gpa = std.testing.allocator; + engine.s = ops.s; + engine.w.g = shape.the_27b; + var safe = try engine.sequence(303); + try checkReset(&safe); + safe.deinit(); + call_count = 0; + var deferred = try engine.sequenceForRestore(303); + try std.testing.expectEqual(@as(usize, 0), call_count); + try std.testing.expectEqual(@as(usize, 303), deferred.capacity); + deferred.deinit(); + try std.testing.expectEqual(@as(usize, 2), allocations); + try std.testing.expectEqual(allocations, frees); +} diff --git a/zig/src/families/qwen27/cuda/reset_skip_test.zig b/zig/src/families/qwen27/cuda/reset_skip_test.zig new file mode 100644 index 000000000..732303ae8 --- /dev/null +++ b/zig/src/families/qwen27/cuda/reset_skip_test.zig @@ -0,0 +1,105 @@ +//! Host transaction checks prove deferred target state never reaches work after a miss or failed restore. +const std = @import("std"); +const policy = @import("reset_skip.zig"); +const work = .{ .calls = @as(u64, 96), .bytes = @as(u64, 153944064) }; +const Mock = struct { + hit: bool = true, + cancel: bool = false, + copy_error: bool = false, + reset_error: bool = false, + copies: usize = 0, + resets: usize = 0, + initialized: bool = false, + pub fn cancelled(a: *Mock) bool { + return a.cancel; + } + pub fn lookup(a: *Mock) !bool { + a.copies += 1; + if (a.copy_error) return error.PartialCopy; + if (a.hit) a.initialized = true; + return a.hit; + } + pub fn reset(a: *Mock) !void { + a.resets += 1; + if (a.reset_error) return error.ResetFailed; + a.initialized = true; + } + fn target(a: *Mock) !void { + if (!a.initialized) return error.UninitializedTarget; + } +}; + +test "strict opt-in requires exact cache and rejects malformed flags" { + try std.testing.expect(!try policy.compatible(null, true)); + try std.testing.expect(!try policy.compatible("0", false)); + try std.testing.expect(try policy.compatible("1", true)); + try std.testing.expectError(error.ResetSkipNeedsExactCache, policy.compatible("1", false)); + try std.testing.expectError(error.InvalidResetSkip, policy.compatible("true", true)); +} + +test "actual hit resolves fresh and retained state without reset" { + for ([_]bool{ false, true }) |pooled| { + var m: Mock = .{}; + var deferred = true; + var stats: policy.Stats = .{ .enabled = true }; + try std.testing.expect(try policy.resolve(&m, &deferred, pooled, &stats, work)); + try m.target(); + try std.testing.expect(!deferred); + try std.testing.expectEqual(@as(usize, 0), m.resets); + try std.testing.expectEqual(@as(u64, 96), stats.avoided_fill_calls); + try std.testing.expectEqual(work.bytes, stats.avoided_fill_bytes); + try std.testing.expectEqual(@as(u64, 1), stats.restored_fresh + stats.restored_pool); + } +} + +test "positive hint then actual miss resets before target work" { + var m: Mock = .{ .hit = false }; + var deferred = true; + var stats: policy.Stats = .{}; + try std.testing.expectError(error.UninitializedTarget, m.target()); + try std.testing.expect(!try policy.resolve(&m, &deferred, false, &stats, work)); + try m.target(); + try std.testing.expectEqual(@as(usize, 1), m.copies); + try std.testing.expectEqual(@as(usize, 1), m.resets); + try std.testing.expectEqual(@as(u64, 1), stats.fallback_resets); + try std.testing.expectEqual(@as(u64, 0), stats.avoided_fill_calls); +} + +test "partial copy aborts without reset fallback or resolved admission" { + var m: Mock = .{ .copy_error = true }; + var deferred = true; + var stats: policy.Stats = .{}; + try std.testing.expectError(error.PartialCopy, policy.resolve(&m, &deferred, false, &stats, work)); + try std.testing.expect(deferred); + try std.testing.expectEqual(@as(usize, 0), m.resets); + try std.testing.expectEqual(@as(u64, 1), stats.failed_deferred_transactions); +} + +test "cancelled deferred destination aborts before copying or resetting" { + var m: Mock = .{ .cancel = true }; + var deferred = true; + var stats: policy.Stats = .{}; + try std.testing.expectError(error.Cancelled, policy.resolve(&m, &deferred, true, &stats, work)); + try std.testing.expect(deferred); + try std.testing.expectEqual(@as(usize, 0), m.copies + m.resets); +} + +test "reset failure on actual miss remains unresolved and propagates" { + var m: Mock = .{ .hit = false, .reset_error = true }; + var deferred = true; + var stats: policy.Stats = .{}; + try std.testing.expectError(error.ResetFailed, policy.resolve(&m, &deferred, false, &stats, work)); + try std.testing.expect(deferred); + try std.testing.expectEqual(@as(u64, 0), stats.fallback_resets + stats.avoided_fill_calls); +} + +test "ordinary initialized path retains original lookup with no extra reset or cancel check" { + var m: Mock = .{ .hit = false, .cancel = true, .initialized = true }; + var deferred = false; + var stats: policy.Stats = .{}; + try std.testing.expect(!try policy.resolve(&m, &deferred, false, &stats, work)); + try m.target(); + try std.testing.expectEqual(@as(usize, 1), m.copies); + try std.testing.expectEqual(@as(usize, 0), m.resets); + try std.testing.expectEqual(@as(u64, 0), stats.failed_deferred_transactions); +} diff --git a/zig/src/families/qwen27/cuda/restore_proof.zig b/zig/src/families/qwen27/cuda/restore_proof.zig new file mode 100644 index 000000000..455e1ed9b --- /dev/null +++ b/zig/src/families/qwen27/cuda/restore_proof.zig @@ -0,0 +1,76 @@ +//! Bounded provenance binds a successful full-N restore to one stream and its exclusively owned Seq. +const std = @import("std"); +pub const Proof = struct { stream: *const anyopaque, seq: *const anyopaque, tokens: usize }; +pub const Proofs = struct { + items: [16]?Proof = @splat(null), + + pub fn mark(p: *Proofs, stream: *const anyopaque, seq: *const anyopaque, tokens: usize) !void { + if (tokens == 0 or tokens > 512) return error.InvalidSeqRestoreProof; + for (&p.items) |*slot| if (slot.*) |existing| { + if (existing.stream == stream) return error.DuplicateSeqRestoreProof; + }; + for (&p.items) |*slot| if (slot.* == null) { + slot.* = .{ .stream = stream, .seq = seq, .tokens = tokens }; + return; + }; + return error.SeqRestoreProofCapacity; + } + + /// A read-only binding check leaves the release-time pool proof intact. + pub fn matches(p: *const Proofs, stream: *const anyopaque, seq: *const anyopaque, tokens: usize) bool { + for (p.items) |slot| if (slot) |proof| { + if (proof.stream == stream) return proof.seq == seq and proof.tokens == tokens; + }; + return false; + } + + pub fn remove(p: *Proofs, stream: *const anyopaque) ?Proof { + for (&p.items) |*slot| if (slot.*) |existing| { + if (existing.stream != stream) continue; + slot.* = null; + return existing; + }; + return null; + } +}; + +test "provenance binds stream and Seq once and is cleared before pointer reuse" { + var p: Proofs = .{}; + var streams: [2]u8 = @splat(0); + var seqs: [2]u8 = @splat(0); + try p.mark(&streams[0], &seqs[0], 14); + try std.testing.expect(p.remove(&streams[1]) == null); + try std.testing.expectError(error.DuplicateSeqRestoreProof, p.mark(&streams[0], &seqs[1], 14)); + const proof = p.remove(&streams[0]).?; + try std.testing.expect(proof.seq == @as(*const anyopaque, &seqs[0]) and proof.seq != @as(*const anyopaque, &seqs[1]) and proof.tokens == 14); + try std.testing.expect(p.remove(&streams[0]) == null); + try p.mark(&streams[0], &seqs[1], 31); + const next = p.remove(&streams[0]).?; + try std.testing.expect(next.seq == @as(*const anyopaque, &seqs[1]) and next.tokens == 31); +} + +test "fixed proof ownership refuses overflow and unsupported restoration lengths" { + var p: Proofs = .{}; + var streams: [17]u8 = @splat(0); + var seqs: [17]u8 = @splat(0); + try std.testing.expectError(error.InvalidSeqRestoreProof, p.mark(&streams[0], &seqs[0], 0)); + try std.testing.expectError(error.InvalidSeqRestoreProof, p.mark(&streams[0], &seqs[0], 513)); + for (0..16) |i| try p.mark(&streams[i], &seqs[i], 14); + try std.testing.expectError(error.SeqRestoreProofCapacity, p.mark(&streams[16], &seqs[16], 14)); + _ = p.remove(&streams[0]); + try p.mark(&streams[16], &seqs[16], 31); +} + +test "read-only first-logit proof rejects another owner, Seq and position without consuming release authority" { + var proofs: Proofs = .{}; + var streams: [2]u8 = @splat(0); + var seqs: [2]u8 = @splat(0); + try proofs.mark(&streams[0], &seqs[0], 14); + try std.testing.expect(proofs.matches(&streams[0], &seqs[0], 14)); + try std.testing.expect(!proofs.matches(&streams[1], &seqs[0], 14)); + try std.testing.expect(!proofs.matches(&streams[0], &seqs[1], 14)); + try std.testing.expect(!proofs.matches(&streams[0], &seqs[0], 31)); + try std.testing.expect(proofs.matches(&streams[0], &seqs[0], 14)); + _ = proofs.remove(&streams[0]); + try std.testing.expect(!proofs.matches(&streams[0], &seqs[0], 14)); +} diff --git a/zig/src/families/qwen27/cuda/seq_pool.zig b/zig/src/families/qwen27/cuda/seq_pool.zig new file mode 100644 index 000000000..2a20f88ef --- /dev/null +++ b/zig/src/families/qwen27/cuda/seq_pool.zig @@ -0,0 +1,120 @@ +//! Fixed ownership storage for the private exact-capacity short Seq experiment; no allocator or device work. +const std = @import("std"); +pub const max_slots = 16; +pub const max_capacity = 512; +pub const max_bytes = 3 * 1024 * 1024 * 1024; + +pub const Stats = struct { + enabled: bool = false, + failed: bool = false, + create_attempts: u64 = 0, + driver_creations: u64 = 0, + reuse_hits: u64 = 0, + evictions: u64 = 0, + discarded: u64 = 0, + retained_bytes: usize = 0, + retained_slots: usize = 0, +}; + +pub fn parse(raw: ?[]const u8) !bool { + const value = raw orelse return false; + if (std.mem.eql(u8, value, "0")) return false; + if (std.mem.eql(u8, value, "1")) return true; + return error.InvalidSeqReuse; +} + +pub fn configured(cache_enabled: bool) !bool { + const raw = std.c.getenv("TF_PR608_EXACT_CACHE_SEQ_REUSE"); + return compatible(if (raw) |value| std.mem.span(value) else null, cache_enabled); +} + +pub fn compatible(raw: ?[]const u8, cache_enabled: bool) !bool { + const on = try parse(raw); + if (on and !cache_enabled) return error.SeqReuseNeedsExactCache; + return on; +} + +/// Normal completion requires proven full-N restoration, never a cached count alone. +pub fn completed(s: anytype, settled: bool, restored: bool, cache_ok: bool, cache_failed: bool) bool { + return cache_ok and !cache_failed and restored and settled and s.finished and (s.reason == .stop or s.reason == .length) and + !s.isCancelled() and s.cached == s.prompt_len and !s.reuse_failed and s.reuse.saved == null and + s.reuse.at == 0 and s.reuse.marks.len == 0 and s.reuse.hook == null; +} + +/// A taken item is caller-owned immediately; a retained item is pool-owned until take/pop. +pub fn Pool(comptime T: type) type { + return struct { + const Self = @This(); + const Entry = struct { ptr: *T, capacity: usize, bytes: usize }; + entries: [max_slots]Entry = undefined, + limit: usize = 0, + stats: Stats = .{}, + + pub fn init(enabled: bool, slots: usize) Self { + return .{ .limit = @min(slots, max_slots), .stats = .{ .enabled = enabled } }; + } + + pub fn active(p: *const Self) bool { + return p.stats.enabled and !p.stats.failed; + } + + fn remove(p: *Self, index: usize) *T { + const entry = p.entries[index]; + p.stats.retained_slots -= 1; + p.stats.retained_bytes -= entry.bytes; + for (index..p.stats.retained_slots) |i| p.entries[i] = p.entries[i + 1]; + return entry.ptr; + } + + pub fn take(p: *Self, capacity: usize) ?*T { + if (!p.active() or capacity > max_capacity) return null; + for (p.entries[0..p.stats.retained_slots], 0..) |entry, i| { + if (entry.capacity != capacity) continue; + p.stats.reuse_hits += 1; + return p.remove(i); + } + return null; + } + + /// Eviction detaches ownership; the caller frees exactly this item. + pub fn evict(p: *Self) ?*T { + if (p.stats.retained_slots == 0) return null; + p.stats.evictions += 1; + return p.remove(0); + } + + /// An exact-capacity miss drains all retained bytes, even when a count slot remains available. + pub fn beforeCreate(p: *Self, context: anytype, comptime free: anytype) void { + while (p.evict()) |ptr| free(context, ptr); + } + + pub fn hasRoom(p: *const Self, active_count: usize) bool { + return active_count < p.limit and p.stats.retained_slots < p.limit - active_count; + } + + pub fn canRetain(p: *const Self, active_count: usize, capacity: usize, bytes: usize) bool { + return p.active() and capacity <= max_capacity and bytes <= max_bytes and + p.stats.retained_bytes <= max_bytes - bytes and p.hasRoom(active_count); + } + + pub fn retain(p: *Self, ptr: *T, active_count: usize, capacity: usize, bytes: usize) bool { + if (!p.active()) return false; + for (p.entries[0..p.stats.retained_slots]) |entry| + if (entry.ptr == ptr) @panic("duplicate Seq pool ownership"); + if (!p.canRetain(active_count, capacity, bytes)) return false; + p.entries[p.stats.retained_slots] = .{ .ptr = ptr, .capacity = capacity, .bytes = bytes }; + p.stats.retained_slots += 1; + p.stats.retained_bytes += bytes; + return true; + } + + /// Failure disables future take/retain; the caller must evict and free outstanding ownership. + pub fn fail(p: *Self) void { + if (p.stats.enabled) p.stats.failed = true; + } + }; +} + +test { + _ = @import("seq_pool_test.zig"); +} diff --git a/zig/src/families/qwen27/cuda/seq_pool_test.zig b/zig/src/families/qwen27/cuda/seq_pool_test.zig new file mode 100644 index 000000000..9ffe37881 --- /dev/null +++ b/zig/src/families/qwen27/cuda/seq_pool_test.zig @@ -0,0 +1,172 @@ +//! Exact-capacity ownership, footprint and failure checks independent of CUDA or model allocation. +const std = @import("std"); +const policy = @import("seq_pool.zig"); +const Object = struct { alive: bool = true }; +const Pool = policy.Pool(Object); + +fn free(object: *Object) !void { + try std.testing.expect(object.alive); + object.alive = false; +} + +test "default-off and invalid settings cannot silently enable retention" { + try std.testing.expect(!try policy.parse(null)); + try std.testing.expect(!try policy.parse("0")); + try std.testing.expect(try policy.parse("1")); + for ([_][]const u8{ "", "2", "true", "-1" }) |value| + try std.testing.expectError(error.InvalidSeqReuse, policy.parse(value)); + var p = Pool.init(false, 16); + var object: Object = .{}; + try std.testing.expect(!p.retain(&object, 0, 158, 100)); + try std.testing.expect(p.take(158) == null); + try std.testing.expect(object.alive); +} + +test "take transfers exclusive ownership and does not round capacity or change the object" { + var p = Pool.init(true, 2); + var first: Object = .{}; + var second: Object = .{}; + try std.testing.expect(p.retain(&first, 0, 158, 100)); + try std.testing.expect(p.retain(&second, 0, 272, 120)); + try std.testing.expect(p.take(157) == null); + try std.testing.expect(p.take(159) == null); + const taken = p.take(158).?; + try std.testing.expect(taken == &first and taken.alive); + try std.testing.expect(p.take(158) == null); + try std.testing.expectEqual(@as(usize, 1), p.stats.retained_slots); + try std.testing.expectEqual(@as(usize, 120), p.stats.retained_bytes); + try free(taken); + try free(p.evict().?); + try std.testing.expect(p.evict() == null); + try std.testing.expect(!first.alive and !second.alive); +} + +test "capacity miss must evict unused ownership before a fresh active slot fits" { + var p = Pool.init(true, 2); + var retained: Object = .{}; + var active: Object = .{}; + var replacement: Object = .{}; + try std.testing.expect(p.retain(&retained, 1, 158, 100)); + try std.testing.expect(!p.hasRoom(1)); + try std.testing.expect(p.take(272) == null); + try free(p.evict().?); + try std.testing.expect(p.hasRoom(1)); + // The caller can now own active and replacement, never active+retained+replacement. + try std.testing.expect(!p.retain(&active, 2, 158, 100)); + try std.testing.expectEqual(@as(u64, 1), p.stats.evictions); + try free(&active); + try free(&replacement); + try std.testing.expect(!retained.alive); +} + +test "capacity miss drains every retained byte even with room for a fresh large allocation" { + const Ledger = struct { + freed: usize = 0, + fn release(x: *@This(), object: *Object) void { + std.debug.assert(object.alive); + object.alive = false; + x.freed += 1; + } + }; + var p = Pool.init(true, 16); + var objects: [2]Object = @splat(.{}); + var ledger: Ledger = .{}; + try std.testing.expect(p.retain(&objects[0], 0, 158, 100)); + try std.testing.expect(p.retain(&objects[1], 0, 272, 120)); + try std.testing.expect(p.hasRoom(1)); + try std.testing.expect(p.take(16384) == null); + p.beforeCreate(&ledger, Ledger.release); + try std.testing.expectEqual(@as(usize, 2), ledger.freed); + try std.testing.expectEqual(@as(usize, 0), p.stats.retained_bytes); + try std.testing.expectEqual(@as(usize, 0), p.stats.retained_slots); + for (objects) |object| try std.testing.expect(!object.alive); +} + +test "total ownership byte cap short-capacity cap and configured stream bound are enforced" { + var p = Pool.init(true, 20); + var objects: [16]Object = @splat(.{}); + try std.testing.expectEqual(@as(usize, 16), p.limit); + try std.testing.expect(!p.retain(&objects[0], 0, 513, 1)); + try std.testing.expect(!p.retain(&objects[0], 0, 512, policy.max_bytes + 1)); + try std.testing.expect(p.retain(&objects[0], 15, 512, policy.max_bytes)); + try std.testing.expect(!p.retain(&objects[1], 14, 158, 1)); + try free(p.evict().?); + p = Pool.init(true, 2); + try std.testing.expect(!p.retain(&objects[1], 2, 158, 1)); + try std.testing.expect(p.retain(&objects[1], 1, 158, 1)); + try std.testing.expect(!p.retain(&objects[2], 1, 158, 1)); + try free(p.evict().?); + try std.testing.expectEqual(@as(usize, 0), p.stats.retained_bytes); +} + +test "failure disables reuse and shutdown drains each detached object once" { + var p = Pool.init(true, 3); + var objects: [3]Object = @splat(.{}); + for (&objects, 0..) |*object, i| try std.testing.expect(p.retain(object, 0, 158, i + 1)); + p.fail(); + try std.testing.expect(p.stats.failed); + try std.testing.expect(p.take(158) == null); + try std.testing.expect(!p.retain(&objects[0], 0, 158, 1)); + while (p.evict()) |object| try free(object); + for (objects) |object| try std.testing.expect(!object.alive); + try std.testing.expectEqual(@as(usize, 0), p.stats.retained_slots); + try std.testing.expectEqual(@as(usize, 0), p.stats.retained_bytes); + try std.testing.expect(p.evict() == null); +} + +const Stream = struct { + finished: bool = true, + reason: enum { none, stop, length, cancelled } = .length, + cancelled: bool = false, + cached: u32 = 14, + prompt_len: u32 = 14, + reuse_failed: bool = false, + reuse: struct { + saved: ?*anyopaque = null, + at: u32 = 0, + marks: []const u32 = &.{}, + hook: ?u8 = null, + } = .{}, + pub fn isCancelled(s: *Stream) bool { + return s.cancelled; + } +}; + +test "only normally completed settled uncancelled proven full-N restored streams may transfer to the pool" { + var s: Stream = .{}; + try std.testing.expect(policy.completed(&s, true, true, true, false)); + try std.testing.expect(!policy.completed(&s, false, true, true, false)); + try std.testing.expect(!policy.completed(&s, true, false, true, false)); + try std.testing.expect(!policy.completed(&s, true, true, false, false)); + try std.testing.expect(!policy.completed(&s, true, true, true, true)); + for (0..9) |case| { + s = .{}; + switch (case) { + 0 => s.finished = false, + 1 => s.reason = .cancelled, + 2 => s.reason = .none, + 3 => s.cancelled = true, + 4 => s.cached = 1, + 5 => s.reuse_failed = true, + 6 => s.reuse.at = 1, + 7 => s.reuse.marks = &.{1}, + 8 => s.reuse.hook = 1, + else => unreachable, + } + try std.testing.expect(!policy.completed(&s, true, true, true, false)); + } + s = .{}; + var sentinel: u8 = 0; + s.reuse.saved = &sentinel; + try std.testing.expect(!policy.completed(&s, true, true, true, false)); + s = .{ .reason = .stop }; + try std.testing.expect(policy.completed(&s, true, true, true, false)); +} + +test "independent pool flag requires the exact cache and remains strict" { + try std.testing.expect(!try policy.compatible(null, false)); + try std.testing.expect(!try policy.compatible("0", true)); + try std.testing.expect(try policy.compatible("1", true)); + try std.testing.expectError(error.SeqReuseNeedsExactCache, policy.compatible("1", false)); + try std.testing.expectError(error.InvalidSeqReuse, policy.compatible("yes", true)); +} diff --git a/zig/src/families/qwen27/cuda/state.zig b/zig/src/families/qwen27/cuda/state.zig index 4cbe06c07..5202e245e 100644 --- a/zig/src/families/qwen27/cuda/state.zig +++ b/zig/src/families/qwen27/cuda/state.zig @@ -63,6 +63,15 @@ pub const Seq = struct { /// A fresh stream: zero recurrences and conv windows, caches for `capacity` positions. pub fn init(gpa: std.mem.Allocator, ops: kern.Ops, g: c.Geometry, capacity: usize) !Seq { + return initState(gpa, ops, g, capacity, true); + } + + /// Private restore destination: it must be restored or reset before any target work. + pub fn initRestoreDestination(gpa: std.mem.Allocator, ops: kern.Ops, g: c.Geometry, capacity: usize) !Seq { + return initState(gpa, ops, g, capacity, false); + } + + fn initState(gpa: std.mem.Allocator, ops: kern.Ops, g: c.Geometry, capacity: usize, initialize: bool) !Seq { var s: Seq = .{ .gpa = gpa, .arena = try Arena.init(ops.k.d, bytes(g, capacity)), .rec = &.{}, .conv = &.{}, .keys = &.{}, .values = &.{}, .head_in = 0, .head_xs = 0, .capacity = capacity }; errdefer s.arena.deinit(); s.rec = try gpa.alloc(u64, g.layers); @@ -90,7 +99,7 @@ pub const Seq = struct { s.values[i] = try A.take(capacity * g.kvInner() * bf); } } - try s.reset(ops, g); + if (initialize) try s.reset(ops, g); return s; } @@ -302,3 +311,7 @@ pub const Scratch = struct { s.* = undefined; } }; + +test { + _ = @import("reset_skip_factory_test.zig"); +} From 92201503f6ee37e692e813fde9e1aee5c7778172 Mon Sep 17 00:00:00 2001 From: Jonathan Regan-Beasley <197533392+jregan-beasley-smc@users.noreply.github.com> Date: Sun, 11 Oct 2026 21:58:14 +1100 Subject: [PATCH 3/4] test(qwen27 cuda): publish exact-prompt TTFT receipts --- validation/pr608-exact-cache/README.md | 87 ++ .../pr608-exact-cache/bench_concurrent.py | 275 +++++ .../pr608-exact-cache/bench_evidence.py | 54 + .../pr608-exact-cache/bundle-manifest.json | 29 + .../pr608-exact-cache/evidence-forward.json | 113 ++ .../pr608-exact-cache/evidence-reverse.json | 113 ++ validation/pr608-exact-cache/provenance.json | 97 ++ .../pr608-exact-cache/qualification.json | 34 + .../pr608-exact-cache/requests-forward.jsonl | 312 ++++++ .../pr608-exact-cache/requests-reverse.jsonl | 312 ++++++ validation/pr608-exact-cache/run_http.py | 375 +++++++ validation/pr608-exact-cache/summary.json | 979 ++++++++++++++++++ validation/pr608-exact-cache/test_verify.py | 114 ++ validation/pr608-exact-cache/verify.py | 229 ++++ 14 files changed, 3123 insertions(+) create mode 100644 validation/pr608-exact-cache/README.md create mode 100644 validation/pr608-exact-cache/bench_concurrent.py create mode 100644 validation/pr608-exact-cache/bench_evidence.py create mode 100644 validation/pr608-exact-cache/bundle-manifest.json create mode 100644 validation/pr608-exact-cache/evidence-forward.json create mode 100644 validation/pr608-exact-cache/evidence-reverse.json create mode 100644 validation/pr608-exact-cache/provenance.json create mode 100644 validation/pr608-exact-cache/qualification.json create mode 100644 validation/pr608-exact-cache/requests-forward.jsonl create mode 100644 validation/pr608-exact-cache/requests-reverse.jsonl create mode 100644 validation/pr608-exact-cache/run_http.py create mode 100644 validation/pr608-exact-cache/summary.json create mode 100644 validation/pr608-exact-cache/test_verify.py create mode 100644 validation/pr608-exact-cache/verify.py diff --git a/validation/pr608-exact-cache/README.md b/validation/pr608-exact-cache/README.md new file mode 100644 index 000000000..9eef733b8 --- /dev/null +++ b/validation/pr608-exact-cache/README.md @@ -0,0 +1,87 @@ +## What this changes + +This contribution builds on Philip's [Qwen27 CUDA engine, PR608](https://github.com/ashhart/TensorFold/pull/608) and the earlier [first-token handoff fix, 7acdc544](https://github.com/jregan-beasley-smc/TensorFold/commit/7acdc54473b5c9f54582b5d3c465e89b92daf886). Runtime commit `474bd89b68dee96149898ad303626d5d9dce0291` contains 19 pinned files: four existing files modified and 15 helpers/tests added. The tested parent `311de580` differs from publication parent `7acdc544` only by earlier validation material. The runtime bytes are unchanged. + +Five independent diagnostic flags accept `0` or `1` and default to `0`. The latter four require the exact-prompt cache: + +| Flag | Mechanism | +| --- | --- | +| `TF_PR608_EXACT_PROMPT_CACHE` | Snapshot the full identical prompt's target, head and packed DFlash state; restore into independently owned normal allocations. | +| `TF_PR608_EXACT_CACHE_SEQ_REUSE` | Reuse settled target Seq storage after a proven full-prompt restore, at exactly the requested capacity. | +| `TF_PR608_EXACT_CACHE_LOGITS` | Cache the unchanged first BF16 logits before sampling; recheck the active key or run the ordinary head. | +| `TF_PR608_EXACT_CACHE_DRAFT_REUSE` | Reuse fixed Context storage across eligible small prompts, with fresh wrapper/CopyIndex state. | +| `TF_PR608_EXACT_CACHE_SKIP_RESET` | Defer initialization fills in a private prefill transaction; a successful full-state restore replaces them, a miss performs the original reset before target work. | + +The cache has one active and one pending entry under a combined 256 MiB cap, including the 496,640-byte logits row. Target retention is capped at 3 GiB; Context retention at 1.5 GiB. Active plus retained owners stay within configured streams, at most 16. Pool/reset eligibility also requires normal capacity at most 512. Capacity remains `min(context, prompt_length + max_tokens + 16)`. Public initialized factories, sampling, target/draft arithmetic and planner behavior remain unchanged. Clean completion, successful settle/cache release and fences gate ownership transfer. Cancellation and errors invalidate pending state; uncertain CUDA use cannot enter a reusable pool. + +## Receipt + +`provenance.json` pins all runtime files, model revisions, Python v0.6.6 (`cb2ebf0540f42604e2759b2ddef497861e928248`), native binary and build attestations. The retained environment is DGX Spark GB10 `sm_121`, Linux aarch64, Zig 0.17.0 and NVIDIA's PyTorch 26.07 container (image hash retained). Driver/library versions were not independently retained. Both native arms used the same 49-kernel AOT/native assets. CPU checks passed 334 host tests, six native build steps and five qualifier build steps. + +`qualification.json` is a sanitized actual-CUDA gate attestation, not a distributed device checker. It records poisoned fresh/pooled state restoration, immutable snapshots, 16 nonaliasing owners, raw first logits, direct continuation and hint-to-miss fallback. Three resolved restores avoided 288 initialization fills / 461,832,192 bytes; public factories still reset. The 968-line device checker, model weights, compiled binaries and operational logs are not included. + +Each order has 312 retained requests: three fresh server arms, each with two 16-output prompt warmups and 102 measured 256-output requests. Order 1 is reset-off / Python / candidate; order 2 is candidate / Python / reset-off. Both native arms enable the preceding four flags; only the final reset flag differs. Literal bodies and output fingerprints match for 104 native pairs and 104 native/Python pairs per order, including two untimed warmups. Work counters differ and remain visible. + +These are client TTFT medians and slowest values in milliseconds, and complete burst wall time in seconds. Each cell averages the two orders. “First” means the first measured burst after warmup; “warm” averages bursts 1 and 2, not process cold. `verify.py` reconstructs every repetition and table from the sanitized request evidence. + +| Prompt / streams / phase | Python median / slowest TTFT | Candidate median / slowest TTFT | Python / candidate wall | +| --- | ---: | ---: | ---: | +| Code / 1 / first | 111.0 / 111.0 | 9.6 / 9.6 | 3.869 / 3.683 | +| Code / 1 / warm | 113.7 / 113.7 | 3.1 / 3.1 | 3.865 / 3.678 | +| Chat / 1 / first | 113.9 / 113.9 | 9.2 / 9.2 | 5.188 / 5.169 | +| Chat / 1 / warm | 114.8 / 114.8 | 3.6 / 3.6 | 5.192 / 5.165 | +| Code / 16 / first | 302.6 / 304.4 | 245.0 / 246.5 | 10.561 / 10.200 | +| Code / 16 / warm | 220.3 / 222.3 | 128.6 / 130.2 | 10.468 / 10.182 | +| Chat / 16 / first | 215.4 / 217.9 | 201.6 / 203.8 | 13.635 / 13.823 | +| Chat / 16 / warm | 237.1 / 239.4 | 130.7 / 132.0 | 13.703 / 13.797 | + +Recheck the bundled evidence offline with Python 3.11+ and no third-party packages: + +```sh +python3 validation/pr608-exact-cache/verify.py --source-root . +python3 -B -m unittest discover -s validation/pr608-exact-cache -p 'test_verify.py' +zig build test-cuda-host -j2 --summary all +``` + +For a new GPU run, independently prepare the pinned models and upstream Qwen27 AOT assets. Start each arm in a fresh server process. Supply your own model directories, binary, address and port; this client does not start services or download models. The native candidate configuration is: + +```sh +export TF_PR608_EXACT_PROMPT_CACHE=1 +export TF_PR608_EXACT_CACHE_SEQ_REUSE=1 +export TF_PR608_EXACT_CACHE_LOGITS=1 +export TF_PR608_EXACT_CACHE_DRAFT_REUSE=1 +export TF_PR608_EXACT_CACHE_SKIP_RESET=1 +export TENSORFOLD_CUDA_KERNELS="$AOT_DIR" +export TENSORFOLD_MEMORY_RESERVE_GIB=8 +"$NATIVE_BIN" serve "$TARGET_DIR" --backend cuda --drafter "$DRAFTER_DIR" \ + --host "$BIND_HOST" --port "$PORT" --name qwen27-pr608 \ + --parallel 16 --context 32768 --prompt-cache-gib 0 \ + --temperature 0 --no-thinking --no-update-check +python3 validation/pr608-exact-cache/run_http.py --base "$BASE_URL" \ + --model qwen27-pr608 --label on --output candidate.json --max-seconds 1200 +``` + +Use reset flag `0`, the same preceding four flags, and client label `on` for reset-off. That label denotes full-N cache expectations, not reset policy. For the pinned Python reference use its upstream CUDA serving CLI with the same models, geometry and alias: + +```sh +PYTHONPATH="$PYTHON_SOURCE/src" python3 -m tensorfold serve "$TARGET_DIR" \ + --backend cuda --drafter "$DRAFTER_DIR" --drafter-bits 4 \ + --host "$BIND_HOST" --port "$PORT" --name qwen27-pr608 \ + --parallel 16 --context 32768 --prompt-cache-gib 0 \ + --temperature 0 --no-thinking --no-update-check \ + --kv-dtype bf16 --no-prefill-fp8 +python3 validation/pr608-exact-cache/run_http.py --base "$BASE_URL" \ + --model qwen27-pr608 --label python --output python.json --max-seconds 1200 +``` + +The Python source and dependencies must already be installed separately; the bundled client imports no engine code. Python's actual prefix cache retains N−1 tokens; native retains N. The client requires observed counts 13/30 versus 14/31 after uncached warmups. Do not assume matching cache internals from matching CLI flags. Run both process orders above. Live client reports contain the endpoint you supply; the bundled JSONL removes endpoints and preserves routes, bodies, usage/work, SSE clocks and hashes. + +## Limits + +This is an exact full-prompt experiment for fresh short text, not generic prefix matching, resume/vision support or Flash Next qualification. HTTP qualification is greedy, two short prompts, 1/16 streams and fixed 256 outputs. Long-context, sampled HTTP and diverse prompts remain outside the measured scope. Direct device continuation does not substitute for every speculative verify/keep path. + +TTFT is send to first nonempty SSE content; full wall ends at final `[DONE]`. There is no capture-time subtraction. Responses in a burst are correlated; two process orders are point estimates, not confidence intervals. The five-feature/Python comparison does not isolate each feature. Full-wall changes are much smaller than TTFT changes; chat wall is slightly slower here. No throughput or universal speedup claim is made. + +`output_sha256` combines content/reasoning digests independently of chunk boundaries; `token_sha` is the server's retained token fingerprint (12 hex digits here), not a distributed full token-ID sequence. Sanitized receipts are derived evidence, not raw operational logs. Hash attestations cannot independently reconstruct absent binaries or the omitted device checker. + +Philip's engine and Python reference provide the baseline implementation. Jonathan Regan-Beasley contributed this validation and cache work in a personal capacity. diff --git a/validation/pr608-exact-cache/bench_concurrent.py b/validation/pr608-exact-cache/bench_concurrent.py new file mode 100644 index 000000000..398d8d7b9 --- /dev/null +++ b/validation/pr608-exact-cache/bench_concurrent.py @@ -0,0 +1,275 @@ +"""Decode speed of an OpenAI-compatible server under concurrent requests (bench_openai's prompts and settings). + +Default: four cells (code and chat prompts, sampled and greedy). In each cell N requests of the same prompt start +at once, stream i with seed ``seed + i`` (greedy: all ``seed``), each ``--tokens`` long with ignore_eos. Per stream: decode tok/s = +(tokens - 1) / (last token - first token) and time to first token. Aggregate tok/s = the streams' tokens after +their first / (last token of any stream - first token of any stream). Medians over ``--reps``. + +``--mixed``: request i takes prompt i % 2 and seed seed + i // 2; also reports the steady aggregate, over the time +every stream is live (tokens split by the characters each stream delivered inside that window). +``--alone``: runs every request alone first and checks each concurrent reply's token-id hash (``token_sha``) +against it; ``--serial`` checks the alone runs against ``"draft": false``. ``--no-seed``: sampled requests carry +no seed (mlx_lm's server batches only those), for measuring a standard; no hash checks then. Run a standard with its +prompt cache off (mlx_lm: ``--prompt-cache-size 0``): a cached reply can arrive as one text piece. Tokens come from +the reply's usage. A request that fails to connect or errors counts in ``failed``; one whose text came in fewer than +``MIN_PIECES`` pieces counts in ``unmeasured``; neither enters the rates. ``--stagger-ms`` spaces the starts (a +server with a small listen backlog resets simultaneous connections; those resets are reported, not hidden). +Standard library only. + + python3 tools/bench_concurrent.py $BASE_URL MODEL --levels 1,2,4,8 --alone --output out.json +""" + +import argparse +import hashlib +import json +import statistics +import sys +import threading +import time +import urllib.request + +from bench_evidence import Evidence, token_equal + +if sys.version_info < (3, 11): + sys.exit(f"Python 3.11+ is required (this is {sys.version.split()[0]}); " + "TensorFold's tools use PEP 604 unions. Try: python3.12 tools/bench_concurrent.py ...") + +REQUEST_TIMEOUT = 180 + +MIN_PIECES = 4 # text pieces a reply needs before its span is timed + +PROMPTS = [ + {"name": "code", "kind": "completion", + "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it."}, + {"name": "chat", "kind": "chat", + "prompt": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example."}, +] + + +def stream(base: str, model: str, item: dict, tokens: int, temperature: float, seed: int | None, + draft: bool = True, gate: threading.Barrier | None = None) -> dict: + try: + return _stream(base, model, item, tokens, temperature, seed, draft, gate) + except Exception as exc: # noqa: BLE001 - a failed request is reported, not fatal + if gate is not None: + gate.abort() + return {"prompt": item["name"], "seed": seed, "sent": None, "first": None, "last": None, "tokens": None, + "pieces": [], "ttft_s": None, "decode_tps": None, "token_sha": None, + "error": type(exc).__name__, "complete": False, "prompt_tokens": None, + "cached_tokens": None, "cache_state": "unverified", "output_sha256": None} + + +def _stream(base: str, model: str, item: dict, tokens: int, temperature: float, seed: int | None, draft: bool, + gate: threading.Barrier | None) -> dict: + body = {"model": model, "max_tokens": tokens, "temperature": temperature, "stream": True, + "stream_options": {"include_usage": True}, "ignore_eos": True} + if seed is not None: + body["seed"] = seed + if not draft: + body["draft"] = False + if temperature > 0: + body.update(top_k=20, top_p=0.95) + if item["kind"] == "chat": + url = base + "/v1/chat/completions" + body["messages"] = [{"role": "user", "content": item["prompt"]}] + body["chat_template_kwargs"] = {"enable_thinking": False} + else: + url = base + "/v1/completions" + body["prompt"] = item["prompt"] + body_bytes = json.dumps(body).encode() + body_sha = hashlib.sha256(body_bytes).hexdigest() + req = urllib.request.Request(url, data=body_bytes, headers={"Content-Type": "application/json"}) + if gate is not None: + gate.wait(timeout=30) + sent = time.perf_counter() + response_id: str | None = None + pieces: list[tuple[float, int]] = [] # (arrival, characters) of every text chunk + usage: dict = {} + runtime: dict = {} + evidence = Evidence() + complete = False + done = None + finish_reason = None + speculative = {} + with urllib.request.urlopen(req, timeout=REQUEST_TIMEOUT) as resp: + for raw in resp: + line = raw.decode().strip() + if line == "data: [DONE]": + done = time.perf_counter() + complete = True + break + if not line.startswith("data:"): + continue + chunk = json.loads(line[5:]) + if "error" in chunk: + raise RuntimeError("server_stream_error") + usage = chunk.get("usage") or usage + runtime = chunk.get("tensorfold") or runtime + speculative = chunk.get("speculative") or speculative + for choice in chunk.get("choices", []): + evidence.add(choice) + reason = choice.get("finish_reason") + if reason is not None: + if finish_reason is not None and finish_reason != reason: + raise ValueError("finish reason changed within a stream") + finish_reason = reason + delta = choice.get("delta") or {} + # reasoning counts: its tokens are in completion_tokens, so the clock starts with them + piece = choice.get("text") or delta.get("content") or delta.get("reasoning_content") or "" + if piece: + pieces.append((time.perf_counter(), len(piece))) + if chunk.get("id") is not None: + if response_id is not None and response_id != chunk["id"]: + raise ValueError("response ID changed within a stream") + response_id = chunk["id"] + observed = evidence.finish(usage, runtime, complete) + n = observed["tokens"] + work_source = speculative if speculative else runtime + work = {k: work_source.get(k) for k in ("rounds", "accepted", "drafted")} + out = {"prompt": item["name"], "seed": seed, "sent": sent, "first": None, "last": None, "tokens": n, + "pieces": pieces, "ttft_s": None, "decode_tps": None, "response_id": response_id, + "case_id": item.get("case_id"), "request_body": body, "request_body_sha256": body_sha, "request_url": url, + "usage": usage, "runtime": runtime, "speculative": speculative, "finish_reason": finish_reason, + "work": work, "work_source": "speculative" if speculative else "tensorfold", + "done": done, "full_response_s": done - sent if done is not None else None, **observed} + if not complete: + out["error"] = "incomplete_stream" + if pieces: + first, last = pieces[0][0], pieces[-1][0] + out.update(first=first, last=last, ttft_s=first - sent if complete else None) + if complete and n is not None and n > 1 and last > first and len(pieces) >= MIN_PIECES: + out["decode_tps"] = (n - 1) / (last - first) + else: + out["unmeasured"] = True + else: + out["unmeasured"] = True + return out + + +def together(base: str, model: str, specs: list[tuple[dict, int | None]], tokens: int, temperature: float, + stagger_ms: float = 0.0) -> list[dict]: + gate = threading.Barrier(len(specs)) + out: list[dict | None] = [None] * len(specs) + + def run(i: int) -> None: + if stagger_ms: + gate.wait(timeout=30) + time.sleep(i * stagger_ms / 1e3) + out[i] = stream(base, model, specs[i][0], tokens, temperature, specs[i][1]) + else: + out[i] = stream(base, model, specs[i][0], tokens, temperature, specs[i][1], gate=gate) + + threads = [threading.Thread(target=run, args=(i,)) for i in range(len(specs))] + for t in threads: + t.start() + for t in threads: + t.join() + return [r for r in out if r is not None] + + +def aggregates(runs: list[dict]) -> dict: + done = [r for r in runs if r["decode_tps"] is not None] + out: dict = {"failed": sum(1 for r in runs if r.get("error")), "unmeasured": sum(1 for r in runs if r.get("unmeasured")), + "aggregate_tps": 0.0} + if not done: + return out + first = min(r["first"] for r in done) + last = max(r["last"] for r in done) + if last > first: + out["aggregate_tps"] = sum(r["tokens"] - 1 for r in done) / (last - first) + lo, hi = max(r["first"] for r in done), min(r["last"] for r in done) # every stream live + if len(done) > 1 and hi > lo: + share = 0.0 + for r in done: + chars = sum(c for _, c in r["pieces"]) or 1 + share += r["tokens"] * sum(c for t, c in r["pieces"] if lo <= t <= hi) / chars + out["steady_tps"] = share / (hi - lo) + return out + + +def main() -> None: + p = argparse.ArgumentParser() + p.add_argument("base") + p.add_argument("model") + p.add_argument("--levels", default="4", help="concurrent requests, a comma list") + p.add_argument("--tokens", type=int, default=256) + p.add_argument("--reps", type=int, default=3) + p.add_argument("--seed", type=int, default=1234) + p.add_argument("--temperatures", default="1.0,0") + p.add_argument("--mixed", action="store_true", help="request i takes prompt i %% 2 (sampled only)") + p.add_argument("--alone", action="store_true", help="check each reply's token_sha against its request alone") + p.add_argument("--serial", action="store_true", help="check the alone runs against \"draft\": false") + p.add_argument("--no-seed", action="store_true", help="sampled requests without a seed (standards; no checks)") + p.add_argument("--stagger-ms", type=float, default=0.0, help="start request i this many ms after request i - 1") + p.add_argument("--label", default="") + p.add_argument("--output") + args = p.parse_args() + if args.no_seed: + args.alone = args.serial = False + levels = [int(x) for x in args.levels.split(",")] + temps = [1.0] if args.mixed else [float(t) for t in args.temperatures.split(",")] + cells = [None] if args.mixed else PROMPTS + report: dict = {"label": args.label, "tokens": args.tokens, "mixed": args.mixed, "cells": []} + for temp in temps: + for item in cells: + specs: list[tuple[dict, int | None]] + if args.mixed or item is None: + specs = [(PROMPTS[i % 2], args.seed + i // 2) for i in range(max(levels))] + else: + specs = [(item, args.seed + i if temp > 0 else args.seed) for i in range(max(levels))] + if args.no_seed: + specs = [(spec[0], None) for spec in specs] + together(args.base, args.model, specs[:1], 16, temp) # warm-up + alone: dict[tuple[str, int | None], dict] = {} + if args.alone or args.serial: + for spec in specs: + key = (spec[0]["name"], spec[1]) + if key not in alone: + alone[key] = stream(args.base, args.model, spec[0], args.tokens, temp, spec[1]) + if args.serial: + for key, ref in alone.items(): + serial = stream(args.base, args.model, next(q for q in PROMPTS if q["name"] == key[0]), + args.tokens, temp, key[1], draft=False) + ref["serial_equal"] = token_equal(serial, ref) + for n in levels: + reps = [] + for _ in range(args.reps): + runs = together(args.base, args.model, specs[:n], args.tokens, temp, args.stagger_ms) + rep = aggregates(runs) + rep["per_stream_tps"] = [round(r["decode_tps"], 1) for r in runs if r["decode_tps"] is not None] + rep["ttft_s"] = [round(r["ttft_s"], 2) if r["ttft_s"] is not None else None for r in runs] + rep["errors"] = [r["error"] for r in runs if r.get("error")] + rep["evidence"] = [{k: r.get(k) for k in ("prompt_tokens", "cached_tokens", "tokens", + "cache_state", "complete", "token_sha", "output_sha256")} for r in runs] + if alone: + # None: the request or its solo run failed (not an exactness result) + rep["equal_alone"] = [token_equal(alone[(r["prompt"], r["seed"])], r) for r in runs] + reps.append(rep) + cell = {"prompt": "mixed" if args.mixed or item is None else item["name"], "temperature": temp, + "streams": n, "failed": sum(r["failed"] for r in reps), + "unmeasured": sum(r["unmeasured"] for r in reps), + "aggregate_tps": round(statistics.median(r["aggregate_tps"] for r in reps), 1), + "per_stream_tps": round(statistics.median([v for r in reps for v in r["per_stream_tps"]] or [0.0]), 1), + "ttft_s_max": max((t for r in reps for t in r["ttft_s"] if t is not None), default=None)} + if all("steady_tps" in r for r in reps): + cell["steady_tps"] = round(statistics.median(r["steady_tps"] for r in reps), 1) + if alone: + checks = [v for r in reps for v in r["equal_alone"]] + cell["alone"] = {"equal": checks.count(True), "unequal": checks.count(False), + "failed": checks.count(None)} + if args.serial: + checks = [v.get("serial_equal") for v in alone.values()] + cell["serial"] = {"equal": checks.count(True), "unequal": checks.count(False), + "failed": checks.count(None)} + errors = sorted({e for r in reps for e in r["errors"]}) + if errors: + cell["errors"] = errors[:3] + print(json.dumps({"label": args.label, **cell}), flush=True) + report["cells"].append({**cell, "reps": reps}) + if args.output: + with open(args.output, "w") as f: + json.dump(report, f, indent=1) + + +if __name__ == "__main__": + main() diff --git a/validation/pr608-exact-cache/bench_evidence.py b/validation/pr608-exact-cache/bench_evidence.py new file mode 100644 index 000000000..a9fe6c257 --- /dev/null +++ b/validation/pr608-exact-cache/bench_evidence.py @@ -0,0 +1,54 @@ +"""Validated usage and output fingerprints shared by the HTTP benchmark clients.""" +import hashlib +import re + + +def count(value): + """A server-reported nonnegative integer; missing, boolean and coerced numbers stay unknown.""" + return value if type(value) is int and value >= 0 else None + + +class Evidence: + """Hash content and reasoning independently so network chunk boundaries cannot alter the fingerprint.""" + + def __init__(self): + self.content = hashlib.sha256() + self.reasoning = hashlib.sha256() + + def add(self, choice): + delta = choice.get("delta") or {} + content = choice.get("text") or delta.get("content") or "" + reasoning = delta.get("reasoning_content") or "" + if not isinstance(content, str) or not isinstance(reasoning, str): + raise ValueError("invalid_text_chunk") + self.content.update(content.encode("utf-8")) + self.reasoning.update(reasoning.encode("utf-8")) + + def finish(self, usage, runtime, complete): + usage = usage if isinstance(usage, dict) else {} + runtime = runtime if isinstance(runtime, dict) else {} + details = usage.get("prompt_tokens_details") + details = details if isinstance(details, dict) else {} + prompt = count(usage.get("prompt_tokens")) + cached = count(details.get("cached_tokens")) + tokens = count(usage.get("completion_tokens")) + valid = prompt is not None and cached is not None and cached <= prompt + state = "cold" if valid and cached == 0 else "reused" if valid else "unverified" + if not complete: + state = "unverified" + token_sha = runtime.get("token_sha") + if not isinstance(token_sha, str) or not re.fullmatch(r"(?:[0-9a-f]{12}|[0-9a-f]{64})", token_sha): + token_sha = None + digest = hashlib.sha256(self.content.digest() + self.reasoning.digest()).hexdigest() + return {"prompt_tokens": prompt, "cached_tokens": cached, "tokens": tokens, "cache_state": state, + "complete": complete, "token_sha": token_sha if complete else None, + "output_sha256": digest if complete else None} + + +def token_equal(left, right): + """Missing token hashes or failed/incomplete streams are unverified, never an equality pass.""" + if left.get("error") or right.get("error") or not left.get("complete") or not right.get("complete"): + return None + if not left.get("token_sha") or not right.get("token_sha"): + return None + return left["token_sha"] == right["token_sha"] diff --git a/validation/pr608-exact-cache/bundle-manifest.json b/validation/pr608-exact-cache/bundle-manifest.json new file mode 100644 index 000000000..31d7de8b7 --- /dev/null +++ b/validation/pr608-exact-cache/bundle-manifest.json @@ -0,0 +1,29 @@ +{ + "schema": "pr608_exact_cache_validation_bundle_v1", + "runtime_commit": "474bd89b68dee96149898ad303626d5d9dce0291", + "runtime_parent": "7acdc54473b5c9f54582b5d3c465e89b92daf886", + "sanitized": true, + "host_checks": { + "mutation_tests_passed": 9, + "python_ast_target": "3.11", + "independent_metric_ratio_values_reconciled": 184, + "runtime_source_hashes_rechecked": 19, + "privacy_scan": "No private filesystem roots, physical host addresses, operational IDs or private email matches in bundled files." + }, + "client_delta": "run_http.py and bench_evidence.py are byte-exact copied from the tested client. bench_concurrent.py only substitutes the documentation example address with $BASE_URL; request/timing/concurrency code is unchanged.", + "files_sha256": { + "README.md": "114a74fd7d8ece9b962dc9d5f2f27a8c55ed712b93b15b664d114383f595c9de", + "bench_concurrent.py": "4e336cb213fe55ca5879a51a99dc4185de0ed17fc9096949c9c9bd6f107f7d53", + "bench_evidence.py": "119c396f24f3c13e181429bc69acff39f34254efd4789c5673a3dcbc54738d93", + "evidence-forward.json": "a7b62a93cea579cd332479071e9a0f66cf17b2e8f37c03f379d22941fbe799bd", + "evidence-reverse.json": "a5ab6713b96feadfda4ef94c3cdf73e675a14cd852d6141315dc0f319a6772dd", + "provenance.json": "9486da3178372c2e08a45c17ce3fc5bf8aafbbd65ba70656721bcbbcb46d3ce4", + "qualification.json": "13bf795f292e1014424dabcc5b55776e935de32379c2af1eb85b637882b041c9", + "requests-forward.jsonl": "754123deb031e118e67be698bd5d907151681a602a8cd4bbda2931cc849faf74", + "requests-reverse.jsonl": "4edc22d61c3c9c4c9cb02606b25928634b78438a1c307e61cbb3a59c9349424b", + "run_http.py": "92e597b391b67486008a098e26a545d1427afe42956339e5f2f72f5ca9d3131b", + "summary.json": "a43e486aee08bab0e94e8b4b8da7204482919083155a87a4a29351a388af7427", + "test_verify.py": "e4e9f7f783f759678146cc4272759af728ea60e88bc18e9ed79aaa7d767c0848", + "verify.py": "a45e2623fec2d867514374813c3ea4f8f30cdfbc1a4e5b91c8a6e28b2f383ce0" + } +} diff --git a/validation/pr608-exact-cache/evidence-forward.json b/validation/pr608-exact-cache/evidence-forward.json new file mode 100644 index 000000000..835ee2a5f --- /dev/null +++ b/validation/pr608-exact-cache/evidence-forward.json @@ -0,0 +1,113 @@ +{ + "schema": "pr608_exact_cache_public_order_v1", + "complete": true, + "order_name": "forward", + "process_order": [ + "reset_off", + "python", + "candidate" + ], + "sanitized": true, + "sanitization": "Endpoint URLs and operational state omitted; paths, literal request bodies, original body/output/token hashes, usage/runtime/work and SSE clocks retained. This is a derived structured receipt, not a raw log.", + "reports": { + "reset_off": { + "source_report_sha256": "6b58c849e2c7daf41b63466723cb854541415667908518341e44f6b0ba9eb992", + "source_report_schema": "pr608_exact_cache_http_v1", + "source_client_sha256": { + "bench_concurrent.py": "1bdd080554bb236532843f5f9490db97fbfd414c8e8618b3c2a1b582fd66e882", + "bench_evidence.py": "119c396f24f3c13e181429bc69acff39f34254efd4789c5673a3dcbc54738d93", + "run_http.py": "92e597b391b67486008a098e26a545d1427afe42956339e5f2f72f5ca9d3131b" + }, + "model": "qwen27-pr608", + "parameters": { + "levels": [ + 1, + 16 + ], + "measured_tokens": 256, + "prompts": [ + "code", + "chat" + ], + "repetitions": 3, + "seed": 1234, + "temperature": 0.0, + "warmup_tokens": 16 + }, + "health_totals": { + "output_tokens": 26144, + "prompt_tokens": 2340, + "requests": 104 + }, + "reported_cache_label": "on" + }, + "python": { + "source_report_sha256": "6237d86b56c28528ec14309633380729358d2b0c34c01a464b993cd20dfd7131", + "source_report_schema": "pr608_exact_cache_http_v1", + "source_client_sha256": { + "bench_concurrent.py": "1bdd080554bb236532843f5f9490db97fbfd414c8e8618b3c2a1b582fd66e882", + "bench_evidence.py": "119c396f24f3c13e181429bc69acff39f34254efd4789c5673a3dcbc54738d93", + "run_http.py": "92e597b391b67486008a098e26a545d1427afe42956339e5f2f72f5ca9d3131b" + }, + "model": "qwen27-pr608", + "parameters": { + "levels": [ + 1, + 16 + ], + "measured_tokens": 256, + "prompts": [ + "code", + "chat" + ], + "repetitions": 3, + "seed": 1234, + "temperature": 0.0, + "warmup_tokens": 16 + }, + "health_totals": { + "output_tokens": 26144, + "prompt_tokens": 2340, + "requests": 104 + }, + "reported_cache_label": "python" + }, + "candidate": { + "source_report_sha256": "95da884e7e7996b6f80897c988c729ad66880c040f223601303fb6072f9c8dfe", + "source_report_schema": "pr608_exact_cache_http_v1", + "source_client_sha256": { + "bench_concurrent.py": "1bdd080554bb236532843f5f9490db97fbfd414c8e8618b3c2a1b582fd66e882", + "bench_evidence.py": "119c396f24f3c13e181429bc69acff39f34254efd4789c5673a3dcbc54738d93", + "run_http.py": "92e597b391b67486008a098e26a545d1427afe42956339e5f2f72f5ca9d3131b" + }, + "model": "qwen27-pr608", + "parameters": { + "levels": [ + 1, + 16 + ], + "measured_tokens": 256, + "prompts": [ + "code", + "chat" + ], + "repetitions": 3, + "seed": 1234, + "temperature": 0.0, + "warmup_tokens": 16 + }, + "health_totals": { + "output_tokens": 26144, + "prompt_tokens": 2340, + "requests": 104 + }, + "reported_cache_label": "on" + } + }, + "requests": { + "file": "requests-forward.jsonl", + "sha256": "754123deb031e118e67be698bd5d907151681a602a8cd4bbda2931cc849faf74", + "count": 312 + }, + "original_verification_sha256": "17845b0c9a7a7bd310b77a733975c94e57ec32d5ea84030f81321a0f4c6571ec" +} diff --git a/validation/pr608-exact-cache/evidence-reverse.json b/validation/pr608-exact-cache/evidence-reverse.json new file mode 100644 index 000000000..a43a70502 --- /dev/null +++ b/validation/pr608-exact-cache/evidence-reverse.json @@ -0,0 +1,113 @@ +{ + "schema": "pr608_exact_cache_public_order_v1", + "complete": true, + "order_name": "reverse", + "process_order": [ + "candidate", + "python", + "reset_off" + ], + "sanitized": true, + "sanitization": "Endpoint URLs and operational state omitted; paths, literal request bodies, original body/output/token hashes, usage/runtime/work and SSE clocks retained. This is a derived structured receipt, not a raw log.", + "reports": { + "reset_off": { + "source_report_sha256": "5c544015276c1f293b7073e528fd96929b11f1376b9907b6d91fffbe7c027b1f", + "source_report_schema": "pr608_exact_cache_http_v1", + "source_client_sha256": { + "bench_concurrent.py": "1bdd080554bb236532843f5f9490db97fbfd414c8e8618b3c2a1b582fd66e882", + "bench_evidence.py": "119c396f24f3c13e181429bc69acff39f34254efd4789c5673a3dcbc54738d93", + "run_http.py": "92e597b391b67486008a098e26a545d1427afe42956339e5f2f72f5ca9d3131b" + }, + "model": "qwen27-pr608", + "parameters": { + "levels": [ + 1, + 16 + ], + "measured_tokens": 256, + "prompts": [ + "code", + "chat" + ], + "repetitions": 3, + "seed": 1234, + "temperature": 0.0, + "warmup_tokens": 16 + }, + "health_totals": { + "output_tokens": 26144, + "prompt_tokens": 2340, + "requests": 104 + }, + "reported_cache_label": "on" + }, + "python": { + "source_report_sha256": "54cb8c13acde338eec24cf1181e348bdde8ca656ab3c31773323c9802bf4df5d", + "source_report_schema": "pr608_exact_cache_http_v1", + "source_client_sha256": { + "bench_concurrent.py": "1bdd080554bb236532843f5f9490db97fbfd414c8e8618b3c2a1b582fd66e882", + "bench_evidence.py": "119c396f24f3c13e181429bc69acff39f34254efd4789c5673a3dcbc54738d93", + "run_http.py": "92e597b391b67486008a098e26a545d1427afe42956339e5f2f72f5ca9d3131b" + }, + "model": "qwen27-pr608", + "parameters": { + "levels": [ + 1, + 16 + ], + "measured_tokens": 256, + "prompts": [ + "code", + "chat" + ], + "repetitions": 3, + "seed": 1234, + "temperature": 0.0, + "warmup_tokens": 16 + }, + "health_totals": { + "output_tokens": 26144, + "prompt_tokens": 2340, + "requests": 104 + }, + "reported_cache_label": "python" + }, + "candidate": { + "source_report_sha256": "3e7373c6facfb64fe3dcb153dc39369a679b6049e9f72b036ecc2b57d3f5ab08", + "source_report_schema": "pr608_exact_cache_http_v1", + "source_client_sha256": { + "bench_concurrent.py": "1bdd080554bb236532843f5f9490db97fbfd414c8e8618b3c2a1b582fd66e882", + "bench_evidence.py": "119c396f24f3c13e181429bc69acff39f34254efd4789c5673a3dcbc54738d93", + "run_http.py": "92e597b391b67486008a098e26a545d1427afe42956339e5f2f72f5ca9d3131b" + }, + "model": "qwen27-pr608", + "parameters": { + "levels": [ + 1, + 16 + ], + "measured_tokens": 256, + "prompts": [ + "code", + "chat" + ], + "repetitions": 3, + "seed": 1234, + "temperature": 0.0, + "warmup_tokens": 16 + }, + "health_totals": { + "output_tokens": 26144, + "prompt_tokens": 2340, + "requests": 104 + }, + "reported_cache_label": "on" + } + }, + "requests": { + "file": "requests-reverse.jsonl", + "sha256": "4edc22d61c3c9c4c9cb02606b25928634b78438a1c307e61cbb3a59c9349424b", + "count": 312 + }, + "original_verification_sha256": "339c56b05ac97893d9e3acb08308a91e1bc0579c929eba906ef33f49f79ef881" +} diff --git a/validation/pr608-exact-cache/provenance.json b/validation/pr608-exact-cache/provenance.json new file mode 100644 index 000000000..d5c203878 --- /dev/null +++ b/validation/pr608-exact-cache/provenance.json @@ -0,0 +1,97 @@ +{ + "schema": "pr608_exact_cache_public_provenance_v1", + "sanitized": true, + "tested_shipping_base": "311de5800f06612969eb87ccc45617f3ede38d3c", + "runtime_prerequisite": "7acdc54473b5c9f54582b5d3c465e89b92daf886", + "pr608_head": "99bcc5b29805e29a4baf2cd4beade0f7fe1a5fe8", + "python_commit": "cb2ebf0540f42604e2759b2ddef497861e928248", + "environment": { + "hardware": "DGX Spark NVIDIA GB10 sm_121", + "os": "Linux aarch64", + "zig": "0.17.0", + "native_backend": "CUDA", + "capture_container_release": "NVIDIA's PyTorch 26.07 container", + "capture_image_sha256": "15b8de8baabe68e46afc51e88f3ccad5042013bafe8f244ec082ce0bb06d47e3", + "driver_library_versions": "not independently retained in this public bundle" + }, + "models": [ + { + "name": "target", + "repo": "Vontra/Qwen3.8-27B-MLX-4bit", + "revision": "70ae7fac63274ff2eac54152031433374cb80f2f" + }, + { + "name": "drafter", + "repo": "z-lab/Qwen3.8-27B-DFlash2", + "revision": "50307d4c4cde6860d4eee73e2547cd786fe8e8a4" + } + ], + "model_manifest_sha256": "1a556f5bd87c302a86cec21e437e58cede87e7492492b78bf24df5c2882633e4", + "source_count": 19, + "source_sha256": { + "zig/src/families/qwen27/cuda/draft_pool.zig": "3ca8a67b16ff5d019998c5242caea5a351dff94ddeaa461027108dcac0b8fff5", + "zig/src/families/qwen27/cuda/draft_pool_test.zig": "2e5792ccd7c8fbef33c50644fa721be9af284cdfcf2bedb78e920330fb28b88c", + "zig/src/families/qwen27/cuda/drafts.zig": "fcbc5ffcc643104380f2289d4f9a64444a31627719467f259dedbc31204c1c86", + "zig/src/families/qwen27/cuda/engine.zig": "f674145954a3dd59b08b99b5f884ce32b53f7b5d10c282305d65f83e4e19117f", + "zig/src/families/qwen27/cuda/exact_cache_policy.zig": "5e550ddcbdd1db0ca50dbc543488b88516809945b8665820a06a0bc3150ca4ab", + "zig/src/families/qwen27/cuda/exact_cache_test.zig": "16becde3ec100dec1abeeedb1827181265d8ea1d3a93c30b4eaec2e357b8635a", + "zig/src/families/qwen27/cuda/exact_draft_reuse.zig": "2274324c29765e9f425e6d2fa045d1cc6596681c16999fc5a79e58ac599b2ad3", + "zig/src/families/qwen27/cuda/exact_first_logits.zig": "eb99f17648837d5026238ee9270cd30895b39a32c9646597fff5953ef511b103", + "zig/src/families/qwen27/cuda/exact_logits_policy.zig": "c12f1d89bedfeb9192330c9eca0967abf7fe44886c9e736b09be9747f1ed57ca", + "zig/src/families/qwen27/cuda/exact_prompt_cache.zig": "79a88a49ff0908651b8126569b54c15cb4708f003583d1a7755ad6bc35d66d01", + "zig/src/families/qwen27/cuda/exact_seq_reuse.zig": "1452fdfc4d1407e1fee62828aff4cb0c5a033f9d637ac124da86a2642d8fb261", + "zig/src/families/qwen27/cuda/lanes.zig": "eb3b6539c806a12a83370455785e1468430d0098bc8e4c0c97b784788a32535d", + "zig/src/families/qwen27/cuda/reset_skip.zig": "715816eddb923dbada206179405e8863fd0d82da66fa6db5050b44c9d88e46e2", + "zig/src/families/qwen27/cuda/reset_skip_factory_test.zig": "003658aae413decc868f5aa4792d23aec9fe6000df903afc613d518a0425e239", + "zig/src/families/qwen27/cuda/reset_skip_test.zig": "5386b56c2191d840d216d160deac31705f2b4ff5df6fec4f7ef0f7cbe2bbf058", + "zig/src/families/qwen27/cuda/restore_proof.zig": "73357234268ab6c7a5f0fb72bb8fdc980be08743144a5364c56a0c9b8fd2e7bb", + "zig/src/families/qwen27/cuda/seq_pool.zig": "88978229ebd42339041992ea489c4cdf82f7cf64ff99295039d8f75508b6ca95", + "zig/src/families/qwen27/cuda/seq_pool_test.zig": "362733783b4bd6e5f647eee93f6eab44c34bd94c136398c1c8bcfc382a0819ef", + "zig/src/families/qwen27/cuda/state.zig": "b0bb5a6d24c661b72909c1e4c9c89e1125971d01c17c8b2e22238cd5bfdf9caf" + }, + "source_manifest_sha256": "a045512152eabdd1c8a21f3120b822a96f92a3caa0a603dc93c3a4d9eb6bd276", + "native_binary_sha256": "469b917ca87959fbf3f38964cd91388da433e1395a5773556560d4982fc7d761", + "build_receipt_sha256": "eebf47b460876917d742cb88a442233e996c2cb508a9e8e2e2b6d96b1c737213", + "cpu_checks": { + "host_tests": 334, + "native_build_steps": 6, + "qualifier_build_steps": 5 + }, + "server_settings": { + "parallel": 16, + "context": 32768, + "generic_prompt_cache_gib": 0, + "temperature": 0, + "thinking": false, + "kv": "BF16", + "prefill": "BF16" + }, + "flag_values": { + "reset_off": { + "TF_PR608_EXACT_PROMPT_CACHE": "1", + "TF_PR608_EXACT_CACHE_SEQ_REUSE": "1", + "TF_PR608_EXACT_CACHE_LOGITS": "1", + "TF_PR608_EXACT_CACHE_DRAFT_REUSE": "1", + "TF_PR608_EXACT_CACHE_SKIP_RESET": "0" + }, + "candidate": { + "TF_PR608_EXACT_PROMPT_CACHE": "1", + "TF_PR608_EXACT_CACHE_SEQ_REUSE": "1", + "TF_PR608_EXACT_CACHE_LOGITS": "1", + "TF_PR608_EXACT_CACHE_DRAFT_REUSE": "1", + "TF_PR608_EXACT_CACHE_SKIP_RESET": "1" + } + }, + "all_runtime_flags_default_off": true, + "qualifier_included": false, + "raw_operational_receipts_included": false, + "two_order_acceptance_sha256": "339c56b05ac97893d9e3acb08308a91e1bc0579c929eba906ef33f49f79ef881", + "original_client_sha256": { + "run_http.py": "92e597b391b67486008a098e26a545d1427afe42956339e5f2f72f5ca9d3131b", + "bench_concurrent.py": "1bdd080554bb236532843f5f9490db97fbfd414c8e8618b3c2a1b582fd66e882", + "bench_evidence.py": "119c396f24f3c13e181429bc69acff39f34254efd4789c5673a3dcbc54738d93" + }, + "runtime_commit": "474bd89b68dee96149898ad303626d5d9dce0291", + "publication_parent": "7acdc54473b5c9f54582b5d3c465e89b92daf886", + "parent_note": "The tested 311de580 commit adds validation only to 7acdc544. Publication omits that previous validation commit; all nineteen tested runtime hashes are unchanged." +} diff --git a/validation/pr608-exact-cache/qualification.json b/validation/pr608-exact-cache/qualification.json new file mode 100644 index 000000000..ecf0c19c9 --- /dev/null +++ b/validation/pr608-exact-cache/qualification.json @@ -0,0 +1,34 @@ +{ + "schema": "pr608_exact_cache_public_qualification_v1", + "sanitized": true, + "passed": true, + "source_receipt_sha256": "bd2778db23c4d4a69cf16b3792cf81b9197c2c3da3b5abac6a058b1500dea554", + "qualifier_source_sha256": "b6fe9373d6f6b0b9c24e08afb8e8feacd6d534005acc554fffb22c01566b47a3", + "qualification_binary_sha256": "ebbc73e0ffa97ee31b18ab6c426568a883ade108128278d246448bf4b96b4772", + "qualification_log_sha256": "dbee317d06bfc51c7c86529e337b644e341e3d758989c841556882bb643f0bfd", + "qualification_audit_sha256": "7053754523ed26f726d0c187ecbb3117985df026da9515f0018fc971add18186", + "source_pins_sha256": "a045512152eabdd1c8a21f3120b822a96f92a3caa0a603dc93c3a4d9eb6bd276", + "primitive_hashes_match_previous": true, + "integrated_snapshot_hash_matches_previous": true, + "reset_skip": { + "avoided_fill_bytes": 461832192, + "avoided_fill_calls": 288, + "failed_deferred_transactions": 0, + "fallback_resets": 1, + "fresh_poisoned_full_state_raw_and_continuation_equal": true, + "pooled_poisoned_full_state_raw_and_continuation_equal": true, + "positive_hint_actual_miss_reset_before_target": true, + "public_open_reset_domains_zero": true, + "reset_domain_bytes": 153944064, + "reset_domain_calls": 96, + "restored_fresh": 2, + "restored_pool": 1, + "schema": "pr608_exact_cache_reset_skip_v1" + }, + "earlier_state_gates": "Code 14 plain/drafted, chat 31 drafted, full-N packed target/draft/head state, immutable snapshot, 16 independent live owners, first/raw logits and direct 8-token continuation; target/draft reuse and cold cross-key Context poison gates.", + "limits": [ + "This is a sanitized gate attestation; the 968-line device checker and raw logs are not distributed here.", + "Direct 8-token continuation is not the full speculative verify/keep loop; HTTP evidence is separate.", + "Structural avoided-fill counters are not phase timing." + ] +} diff --git a/validation/pr608-exact-cache/requests-forward.jsonl b/validation/pr608-exact-cache/requests-forward.jsonl new file mode 100644 index 000000000..b41dfd66d --- /dev/null +++ b/validation/pr608-exact-cache/requests-forward.jsonl @@ -0,0 +1,312 @@ +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":1,"burst":null,"stream":0,"phase":"warmup","request":{"cache_state":"cold","cached_tokens":0,"case_id":null,"complete":true,"decode_tps":59.774539519953585,"done":970472.803363876,"finish_reason":"length","first":970472.552392187,"full_response_s":0.4010802030097693,"last":970472.803335149,"output_sha256":"26fc9e1892da6e23aa1a0cb06681c20c4a62f7257e19635806de87234b9035bb","pieces":[[970472.552392187,2],[970472.640096818,7],[970472.719968165,4],[970472.803335149,73]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":16,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"e9df2e35a58091c749bae4e1446600aeb669237cc39db72a41d5cae938d5620a","response_id":"cmpl-b1737573d88d47f70555283f3c795f69","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.123908448,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":0.251442385,"time_to_first_token":0.124502579,"token_sha":"41b4449e1b18","tokens_per_second":59.655813398365595},"seed":1234,"sent":970472.402283673,"speculative":{"acceptance_rate":0.26666666666666666,"accepted":12,"drafted":45,"rounds":3,"tokens_per_round":5.333333333333333},"token_sha":"41b4449e1b18","tokens":16,"ttft_s":0.15010851400438696,"usage":{"completion_tokens":16,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":0},"total_tokens":30},"work":{"accepted":12,"drafted":45,"rounds":3},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":1,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":69.53705564520448,"done":970476.481249475,"finish_reason":"length","first":970472.814074307,"full_response_s":3.6764963960740715,"last":970476.481183845,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970472.814074307,2],[970472.902524859,7],[970472.982375224,4],[970473.063262506,73],[970473.143300928,51],[970473.223768917,21],[970473.310942515,14],[970473.393065093,20],[970473.473465564,16],[970473.553624509,15],[970473.6335591,23],[970473.713601043,23],[970473.794533103,25],[970473.874451569,36],[970473.954823951,14],[970474.034955481,6],[970474.116694821,18],[970474.1991001,18],[970474.285221429,19],[970474.368808136,8],[970474.449039368,11],[970474.529254884,18],[970474.60932336,15],[970474.689233993,39],[970474.769383766,30],[970474.850332259,14],[970474.930658182,15],[970475.01090348,8],[970475.091752958,6],[970475.171860993,15],[970475.255860012,23],[970475.341973593,22],[970475.422221611,26],[970475.502986542,35],[970475.583204986,31],[970475.663383997,12],[970475.744595315,13],[970475.82551717,38],[970475.90575981,47],[970475.985973707,25],[970476.06710587,11],[970476.14751221,34],[970476.230528802,12],[970476.317918739,36],[970476.399520557,60],[970476.481183845,48]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-5b094ba1971115cee6830c39bae50c15","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.00858697,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":3.667068233,"time_to_first_token":0.008857846,"token_sha":"2b28aa2108de","tokens_per_second":69.53783889409291},"seed":1234,"sent":970472.804753079,"speculative":{"acceptance_rate":0.31555555555555553,"accepted":213,"drafted":675,"rounds":45,"tokens_per_round":5.688888888888889},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.009321228018961847,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":213,"drafted":675,"rounds":45},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":1,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":69.79239434945589,"done":970480.142213839,"finish_reason":"length","first":970476.48836182,"full_response_s":3.659726492012851,"last":970480.142055068,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970476.48836182,2],[970476.574915622,7],[970476.654534556,4],[970476.734237509,73],[970476.815551566,51],[970476.895622567,21],[970476.975685342,14],[970477.056248163,20],[970477.136223575,16],[970477.215869891,15],[970477.303493218,23],[970477.386508416,23],[970477.466659883,25],[970477.546842828,36],[970477.62704517,14],[970477.707137343,6],[970477.78780838,18],[970477.86793921,18],[970477.948068303,19],[970478.028138055,8],[970478.108980647,11],[970478.190174965,18],[970478.275989236,15],[970478.360510554,39],[970478.441219405,30],[970478.520622227,14],[970478.602618272,15],[970478.682378435,8],[970478.762970093,6],[970478.843812704,15],[970478.923978444,23],[970479.004154842,22],[970479.084612261,26],[970479.165544536,35],[970479.247695525,31],[970479.333668276,12],[970479.416034528,13],[970479.496321286,38],[970479.576589496,47],[970479.657020893,25],[970479.73734001,11],[970479.818170164,34],[970479.898193663,12],[970479.979380393,36],[970480.060286036,60],[970480.142055068,48]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-b84caa3705738cb3e32a4b69099d3fea","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.003258299,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":3.653473008,"time_to_first_token":0.005481364,"token_sha":"2b28aa2108de","tokens_per_second":69.79660160116886},"seed":1234,"sent":970476.482487347,"speculative":{"acceptance_rate":0.31555555555555553,"accepted":213,"drafted":675,"rounds":45,"tokens_per_round":5.688888888888889},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.005874473019503057,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":213,"drafted":675,"rounds":45},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":1,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":69.53955533546059,"done":970483.815144135,"finish_reason":"length","first":970480.147894741,"full_response_s":3.6714752269908786,"last":970483.81487246,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970480.147894741,2],[970480.237969486,7],[970480.324839262,4],[970480.407073163,73],[970480.487077859,51],[970480.566884687,21],[970480.647574572,14],[970480.727565376,20],[970480.808069301,16],[970480.888320978,15],[970480.968338651,23],[970481.048997889,23],[970481.12939174,25],[970481.208719055,36],[970481.296543451,14],[970481.380131597,6],[970481.460442166,18],[970481.540239024,18],[970481.619996529,19],[970481.700802294,8],[970481.780808125,11],[970481.861764414,18],[970481.941710375,15],[970482.021139104,39],[970482.102787547,30],[970482.183115671,14],[970482.269732184,15],[970482.354504441,8],[970482.435241838,6],[970482.515392948,15],[970482.595166808,23],[970482.675933219,22],[970482.756903595,26],[970482.838205599,35],[970482.918606794,31],[970482.998672189,12],[970483.080715468,13],[970483.160881972,38],[970483.241511217,47],[970483.328379125,25],[970483.411379892,11],[970483.491626078,34],[970483.571926627,12],[970483.651619013,36],[970483.732302301,60],[970483.81487246,48]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-1d61713c58eab7db096be829d67b57b7","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.003290285,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":3.66680461,"time_to_first_token":0.003739215,"token_sha":"2b28aa2108de","tokens_per_second":69.54283828065766},"seed":1234,"sent":970480.143668908,"speculative":{"acceptance_rate":0.31555555555555553,"accepted":213,"drafted":675,"rounds":45,"tokens_per_round":5.688888888888889},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.004225832992233336,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":213,"drafted":675,"rounds":45},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.595540959491277,"done":970494.02864309,"finish_reason":"length","first":970484.06594757,"full_response_s":10.210395804024301,"last":970494.028620381,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970484.06594757,2],[970484.215092047,7],[970484.371313973,4],[970484.581697596,63],[970484.810787535,10],[970484.992272243,31],[970485.174522476,29],[970485.362241937,22],[970485.543888008,14],[970485.72620808,24],[970485.903828299,4],[970486.050590397,13],[970486.233058699,21],[970486.424133991,2],[970486.602433186,18],[970486.783340304,29],[970487.015561673,27],[970487.253694879,24],[970487.406957115,4],[970487.58037967,16],[970487.813269731,10],[970487.994644706,31],[970488.142199831,8],[970488.331709048,11],[970488.514446268,16],[970488.695948151,12],[970488.880970073,39],[970489.053769634,18],[970489.233597725,11],[970489.427572926,16],[970489.604045883,16],[970489.752488882,11],[970489.935963416,6],[970490.119239099,9],[970490.309425332,29],[970490.492300947,22],[970490.673267304,8],[970490.821601641,18],[970491.002876504,18],[970491.184439092,34],[970491.375162675,10],[970491.556347535,14],[970491.737841053,13],[970491.91930148,2],[970492.103452867,36],[970492.295847946,42],[970492.478530428,26],[970492.626507837,17],[970492.81138237,34],[970493.047932424,12],[970493.23015107,36],[970493.519202415,50],[970493.706051854,2],[970494.028620381,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-cfe90fafa24b7059633a34e1b03a45e8","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.1544353,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.964584218,"time_to_first_token":0.239699963,"token_sha":"2b28aa2108de","tokens_per_second":25.590631221658864},"seed":1234,"sent":970483.818247286,"speculative":{"acceptance_rate":0.5607734806629834,"accepted":203,"drafted":362,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.24770028400234878,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":362,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":1,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":24.9897685981882,"done":970494.029355561,"finish_reason":"length","first":970483.824939773,"full_response_s":10.210756807005964,"last":970494.029115894,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970483.824939773,2],[970483.910233338,7],[970484.213144073,4],[970484.369063854,72],[970484.583201361,1],[970484.80982568,27],[970484.993765845,30],[970485.173052959,15],[970485.363882979,14],[970485.543994831,20],[970485.723585978,14],[970485.904615029,4],[970486.050690162,13],[970486.232359812,21],[970486.421155301,2],[970486.601614066,18],[970486.782317572,29],[970487.0143642,27],[970487.25177541,24],[970487.406657674,4],[970487.578425905,16],[970487.812275117,10],[970487.994970136,31],[970488.14099122,8],[970488.332471932,11],[970488.515130047,16],[970488.695726744,12],[970488.881270841,39],[970489.051847398,18],[970489.234225859,11],[970489.424784329,16],[970489.604154834,16],[970489.752226378,11],[970489.936555798,6],[970490.120277625,9],[970490.307969373,29],[970490.491393937,22],[970490.6753606,8],[970490.821630383,18],[970491.002183508,18],[970491.185398737,34],[970491.374418709,10],[970491.558031399,14],[970491.737527386,13],[970491.919126451,2],[970492.104951026,36],[970492.294757586,42],[970492.479311122,26],[970492.626884702,17],[970492.809925884,34],[970493.048573696,12],[970493.229916509,36],[970493.519363585,50],[970493.704600585,2],[970494.029115894,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-51c1096bb40812c8d37acc5840816519","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.003336513,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.204368407,"time_to_first_token":0.003805495,"token_sha":"2b28aa2108de","tokens_per_second":24.989297703626114},"seed":1234,"sent":970483.818598754,"speculative":{"acceptance_rate":0.5459459459459459,"accepted":202,"drafted":370,"rounds":54,"tokens_per_round":4.7407407407407405},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.006341018946841359,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":202,"drafted":370,"rounds":54},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":2,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.594643940707027,"done":970494.028817927,"finish_reason":"length","first":970484.065765515,"full_response_s":10.207921843975782,"last":970494.028787489,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970484.065765515,2],[970484.214809873,7],[970484.368586311,4],[970484.582548644,63],[970484.811228911,10],[970484.992688909,31],[970485.172987313,29],[970485.366913089,22],[970485.544166516,14],[970485.726540839,24],[970485.907109006,4],[970486.051814724,13],[970486.232503011,21],[970486.420795896,2],[970486.603534864,18],[970486.78250486,29],[970487.016764668,27],[970487.252142481,24],[970487.407343758,4],[970487.579227614,16],[970487.814424346,10],[970487.994898089,31],[970488.1433982,8],[970488.333935366,11],[970488.514105571,16],[970488.696891746,12],[970488.880664327,39],[970489.054110907,18],[970489.233782484,11],[970489.425183679,16],[970489.605308361,16],[970489.752155371,11],[970489.936741102,6],[970490.120467954,9],[970490.308613415,29],[970490.49053897,22],[970490.673069294,8],[970490.82030738,18],[970491.001433684,18],[970491.184085753,34],[970491.373727953,10],[970491.555698933,14],[970491.737438519,13],[970491.91942325,2],[970492.105046326,36],[970492.294597824,42],[970492.478470975,26],[970492.627651329,17],[970492.810709507,34],[970493.047113386,12],[970493.228989623,36],[970493.520121266,50],[970493.703733441,2],[970494.028787489,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-089981276fe018e8ca69091056631fcb","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.15432038,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.964660859,"time_to_first_token":0.241389351,"token_sha":"2b28aa2108de","tokens_per_second":25.590434396940474},"seed":1234,"sent":970483.820896083,"speculative":{"acceptance_rate":0.5576923076923077,"accepted":203,"drafted":364,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.24486943194642663,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":364,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":3,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.594036392929173,"done":970494.030817695,"finish_reason":"length","first":970484.065011912,"full_response_s":10.20725701993797,"last":970494.028270387,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970484.065011912,2],[970484.214138816,7],[970484.371943357,4],[970484.581895078,63],[970484.811544707,10],[970484.991476135,31],[970485.174810826,29],[970485.364761745,22],[970485.542606755,14],[970485.724657665,24],[970485.904412169,4],[970486.049681033,13],[970486.233592894,21],[970486.421564765,2],[970486.601311073,18],[970486.783105117,29],[970487.015485753,27],[970487.251893276,24],[970487.407526885,4],[970487.578079303,16],[970487.812594594,10],[970487.995924213,31],[970488.141170698,8],[970488.333198248,11],[970488.51435937,16],[970488.696955855,12],[970488.878335812,39],[970489.05156641,18],[970489.234672467,11],[970489.423839455,16],[970489.60639701,16],[970489.752326912,11],[970489.937237464,6],[970490.12072801,9],[970490.307520125,29],[970490.491689136,22],[970490.67564274,8],[970490.820705993,18],[970491.001951826,18],[970491.185825468,34],[970491.3758421,10],[970491.556434018,14],[970491.738474468,13],[970491.920339701,2],[970492.106055245,36],[970492.296089966,42],[970492.48032321,26],[970492.626704903,17],[970492.812113342,34],[970493.047381539,12],[970493.230215868,36],[970493.519761446,50],[970493.703995945,2],[970494.028270387,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-578d99506e25a00bb809daa1b408422d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.154507796,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.964630468,"time_to_first_token":0.238898413,"token_sha":"2b28aa2108de","tokens_per_second":25.590512444881565},"seed":1234,"sent":970483.823560675,"speculative":{"acceptance_rate":0.5623268698060941,"accepted":203,"drafted":361,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.24145123700145632,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":361,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":4,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.594888847624745,"done":970494.028552047,"finish_reason":"length","first":970484.065429795,"full_response_s":10.206676919944584,"last":970494.028356437,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970484.065429795,2],[970484.213061671,7],[970484.368709538,4],[970484.583105164,63],[970484.810370341,10],[970484.99360994,31],[970485.173898709,29],[970485.36321658,22],[970485.545482736,14],[970485.72326154,24],[970485.905493778,4],[970486.050239905,13],[970486.232675832,21],[970486.422712949,2],[970486.602359587,18],[970486.782537859,29],[970487.015709737,27],[970487.252893987,24],[970487.407139266,4],[970487.578930398,16],[970487.813404928,10],[970487.994405231,31],[970488.143221026,8],[970488.331773238,11],[970488.516050165,16],[970488.696483162,12],[970488.879095591,39],[970489.050982445,18],[970489.234318343,11],[970489.42431434,16],[970489.604559369,16],[970489.753145119,11],[970489.936803595,6],[970490.118576926,9],[970490.308848761,29],[970490.49044631,22],[970490.672971529,8],[970490.820998504,18],[970491.002103315,18],[970491.184718015,34],[970491.372353244,10],[970491.557575317,14],[970491.738855765,13],[970491.920051864,2],[970492.105852546,36],[970492.293925616,42],[970492.479015731,26],[970492.628300939,17],[970492.810058312,34],[970493.046701746,12],[970493.229255808,36],[970493.519980372,50],[970493.704502356,2],[970494.028356437,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-46a43c589438454aa6761f47acfff60d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.154473676,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.964470162,"time_to_first_token":0.2389498,"token_sha":"2b28aa2108de","tokens_per_second":25.590924138892515},"seed":1234,"sent":970483.821875127,"speculative":{"acceptance_rate":0.5607734806629834,"accepted":203,"drafted":362,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.24355466791894287,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":362,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":5,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.586156800601117,"done":970494.030946427,"finish_reason":"length","first":970484.064599551,"full_response_s":10.212610146030784,"last":970494.030926342,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970484.064599551,2],[970484.214338396,7],[970484.372408834,4],[970484.582285051,63],[970484.812026251,10],[970484.991875261,31],[970485.174664779,29],[970485.363770811,22],[970485.542730398,14],[970485.724355136,24],[970485.907211988,4],[970486.049366949,13],[970486.23279701,21],[970486.422633059,2],[970486.60083225,18],[970486.782161858,29],[970487.014792996,27],[970487.253654614,24],[970487.406735067,4],[970487.577937592,16],[970487.814739502,10],[970487.995998917,31],[970488.142682879,8],[970488.332620428,11],[970488.516699152,16],[970488.695884345,12],[970488.87942635,39],[970489.052139077,18],[970489.233679854,11],[970489.425284212,16],[970489.604731614,16],[970489.751957568,11],[970489.936386578,6],[970490.118194236,9],[970490.307346936,29],[970490.491139834,22],[970490.674419311,8],[970490.821271554,18],[970491.00299957,18],[970491.187062436,34],[970491.374247456,10],[970491.556027451,14],[970491.737710065,13],[970491.920133241,2],[970492.104395228,36],[970492.295141476,42],[970492.478170959,26],[970492.628021488,17],[970492.810187492,34],[970493.046839232,12],[970493.229790482,36],[970493.520722898,50],[970493.705647528,2],[970494.030926342,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-4d2df8208a468ff095979b911c8775bf","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.154795778,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.966431921,"time_to_first_token":0.236170239,"token_sha":"2b28aa2108de","tokens_per_second":25.585886907298928},"seed":1234,"sent":970483.818336281,"speculative":{"acceptance_rate":0.5638888888888889,"accepted":203,"drafted":360,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.24626327003352344,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":360,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":6,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.59355503680906,"done":970494.029893147,"finish_reason":"length","first":970484.06453192,"full_response_s":10.210468197939917,"last":970494.027977781,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970484.06453192,2],[970484.213408931,7],[970484.369285966,4],[970484.583693051,63],[970484.809134298,10],[970484.993204988,31],[970485.175695977,29],[970485.36581482,22],[970485.543299049,14],[970485.724931612,24],[970485.90562571,4],[970486.050411942,13],[970486.23336126,21],[970486.422066297,2],[970486.600752168,18],[970486.783710208,29],[970487.014501606,27],[970487.252553386,24],[970487.407199903,4],[970487.579041334,16],[970487.813986845,10],[970487.993338762,31],[970488.142751261,8],[970488.33268409,11],[970488.514518508,16],[970488.697176575,12],[970488.880053652,39],[970489.050784915,18],[970489.233965388,11],[970489.423980493,16],[970489.604228546,16],[970489.752593913,11],[970489.935659671,6],[970490.11955371,9],[970490.307653002,29],[970490.489729869,22],[970490.672885175,8],[970490.821558687,18],[970491.002804728,18],[970491.186766037,34],[970491.372618468,10],[970491.556473402,14],[970491.7389422,13],[970491.92017589,2],[970492.104995292,36],[970492.294684418,42],[970492.478967481,26],[970492.627581506,17],[970492.810927586,34],[970493.046648423,12],[970493.229760395,36],[970493.520027598,50],[970493.704192626,2],[970494.027977781,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-84d47ae5a632d64ec715cd53ecc83b2f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.154358724,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.964553988,"time_to_first_token":0.240737035,"token_sha":"2b28aa2108de","tokens_per_second":25.590708857324522},"seed":1234,"sent":970483.819424949,"speculative":{"acceptance_rate":0.5576923076923077,"accepted":203,"drafted":364,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2451069710077718,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":364,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":7,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.596700497362647,"done":970494.028115586,"finish_reason":"length","first":970484.065860192,"full_response_s":10.206784800975583,"last":970494.028081691,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970484.065860192,2],[970484.215205047,7],[970484.369810352,4],[970484.582015312,63],[970484.81045564,10],[970484.990715539,31],[970485.175390535,29],[970485.364592012,22],[970485.545079097,14],[970485.724096024,24],[970485.90625399,4],[970486.05118198,13],[970486.2337717,21],[970486.422169199,2],[970486.600609434,18],[970486.782684259,29],[970487.015286334,27],[970487.253490515,24],[970487.407030955,4],[970487.578824951,16],[970487.813079274,10],[970487.995427978,31],[970488.142801,8],[970488.332024172,11],[970488.514668012,16],[970488.696657791,12],[970488.879335258,39],[970489.050628129,18],[970489.234734848,11],[970489.424507358,16],[970489.605227256,16],[970489.751887601,11],[970489.935467037,6],[970490.11996543,9],[970490.30787913,29],[970490.49178546,22],[970490.675492612,8],[970490.819615793,18],[970491.003498412,18],[970491.185514489,34],[970491.373060227,10],[970491.557150187,14],[970491.73867347,13],[970491.92173275,2],[970492.103907876,36],[970492.294360493,42],[970492.478824235,26],[970492.628083597,17],[970492.811309651,34],[970493.047598049,12],[970493.2293328,36],[970493.520301336,50],[970493.704948659,2],[970494.028081691,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-386f75804a4fcf684d4a0118c5351af7","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.154397179,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.964519324,"time_to_first_token":0.239958786,"token_sha":"2b28aa2108de","tokens_per_second":25.590797880819085},"seed":1234,"sent":970483.821330785,"speculative":{"acceptance_rate":0.5576923076923077,"accepted":203,"drafted":364,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.24452940688934177,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":364,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":8,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.595357500695304,"done":970494.030533043,"finish_reason":"length","first":970484.065288628,"full_response_s":10.211466540000401,"last":970494.028032848,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970484.065288628,2],[970484.214712732,7],[970484.370307851,4],[970484.583402813,63],[970484.809549492,10],[970484.991937659,31],[970485.173175225,29],[970485.367145684,22],[970485.542955406,14],[970485.723867943,24],[970485.907494097,4],[970486.052169089,13],[970486.23259023,21],[970486.425428174,2],[970486.603601534,18],[970486.782386754,29],[970487.015250983,27],[970487.253413619,24],[970487.40740766,4],[970487.58078963,16],[970487.813803141,10],[970487.993235348,31],[970488.142979422,8],[970488.33369333,11],[970488.516410178,16],[970488.69651032,12],[970488.879579439,39],[970489.052950787,18],[970489.233873128,11],[970489.424257928,16],[970489.605650258,16],[970489.75266716,11],[970489.935392365,6],[970490.120189398,9],[970490.308210305,29],[970490.490244603,22],[970490.672311708,8],[970490.820948509,18],[970491.002509849,18],[970491.18385612,34],[970491.373530839,10],[970491.556391769,14],[970491.737906539,13],[970491.920875927,2],[970492.106768885,36],[970492.29412001,42],[970492.477935229,26],[970492.627274977,17],[970492.810592474,34],[970493.046594028,12],[970493.229948451,36],[970493.520657796,50],[970493.703651247,2],[970494.028032848,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-61319d26a4fd448bca08f75b211b18f6","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.15454526,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.96445171,"time_to_first_token":0.238306621,"token_sha":"2b28aa2108de","tokens_per_second":25.59097152772493},"seed":1234,"sent":970483.819066503,"speculative":{"acceptance_rate":0.5623268698060941,"accepted":203,"drafted":361,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.24622212501708418,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":361,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":9,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.590210754473276,"done":970494.030211935,"finish_reason":"length","first":970484.064665165,"full_response_s":10.211509702028707,"last":970494.029413109,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970484.064665165,2],[970484.214065841,7],[970484.372107104,4],[970484.583458265,63],[970484.810129905,10],[970484.991700232,31],[970485.172709461,29],[970485.361805059,22],[970485.545276595,14],[970485.72540333,24],[970485.905212117,4],[970486.050366316,13],[970486.233108165,21],[970486.420597629,2],[970486.602040718,18],[970486.783631855,29],[970487.016256575,27],[970487.252826228,24],[970487.405977656,4],[970487.580110092,16],[970487.813887431,10],[970487.993871484,31],[970488.14159719,8],[970488.332783807,11],[970488.516101232,16],[970488.695275639,12],[970488.879964097,39],[970489.054204751,18],[970489.234837831,11],[970489.425342849,16],[970489.60516561,16],[970489.753082449,11],[970489.935267283,6],[970490.120869752,9],[970490.308962097,29],[970490.491730713,22],[970490.673329702,8],[970490.820467815,18],[970491.00164208,18],[970491.184366356,34],[970491.376223078,10],[970491.555601408,14],[970491.737768061,13],[970491.921465477,2],[970492.105805576,36],[970492.293650598,42],[970492.478290553,26],[970492.626764324,17],[970492.811222496,34],[970493.045977432,12],[970493.229193107,36],[970493.520785343,50],[970493.705331989,2],[970494.029413109,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-580d0ffb28cd37c14c5a9846ad1e9948","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.154719377,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.964357145,"time_to_first_token":0.236385917,"token_sha":"2b28aa2108de","tokens_per_second":25.59121439439333},"seed":1234,"sent":970483.818702233,"speculative":{"acceptance_rate":0.5638888888888889,"accepted":203,"drafted":360,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.24596293200738728,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":360,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":10,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.591270586025487,"done":970494.028716898,"finish_reason":"length","first":970484.06434676,"full_response_s":10.207705510081723,"last":970494.028682026,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970484.06434676,2],[970484.213617168,7],[970484.371820274,4],[970484.581487758,63],[970484.808951203,10],[970484.992961416,31],[970485.174179314,29],[970485.366754031,22],[970485.54243675,14],[970485.724794655,24],[970485.905368103,4],[970486.051280401,13],[970486.233849477,21],[970486.425977444,2],[970486.601829088,18],[970486.783997454,29],[970487.015779336,27],[970487.252332506,24],[970487.406157167,4],[970487.581756654,16],[970487.814131756,10],[970487.99394326,31],[970488.143443874,8],[970488.332559007,11],[970488.514238288,16],[970488.695642101,12],[970488.88072186,39],[970489.050865828,18],[970489.234775785,11],[970489.424684004,16],[970489.605879411,16],[970489.753036583,11],[970489.936509084,6],[970490.119903833,9],[970490.307192951,29],[970490.491344678,22],[970490.674168585,8],[970490.821402958,18],[970491.001529608,18],[970491.184253068,34],[970491.373271904,10],[970491.555308898,14],[970491.737601162,13],[970491.920723943,2],[970492.106482632,36],[970492.293753276,42],[970492.478683565,26],[970492.62748651,17],[970492.809707774,34],[970493.046447884,12],[970493.229102431,36],[970493.519678676,50],[970493.705132218,2],[970494.028682026,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-24961e3aaa8e452cc12328bcd4bf5eb2","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.154682505,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.964582233,"time_to_first_token":0.236644853,"token_sha":"2b28aa2108de","tokens_per_second":25.59063631945442},"seed":1234,"sent":970483.821011388,"speculative":{"acceptance_rate":0.5623268698060941,"accepted":203,"drafted":361,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.24333537206985056,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":361,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":11,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.58847287702914,"done":970494.029573287,"finish_reason":"length","first":970484.064103716,"full_response_s":10.210629577981308,"last":970494.02952843,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970484.064103716,2],[970484.214225747,7],[970484.371226098,4],[970484.581757609,63],[970484.811850629,10],[970484.990411937,31],[970485.175794702,29],[970485.365944736,22],[970485.545164347,14],[970485.726117836,24],[970485.904937418,4],[970486.052033156,13],[970486.233249572,21],[970486.421926299,2],[970486.603458207,18],[970486.783420945,29],[970487.014866004,27],[970487.252046445,24],[970487.407308886,4],[970487.578726082,16],[970487.814065101,10],[970487.994519895,31],[970488.142479827,8],[970488.33285395,11],[970488.515873215,16],[970488.696108233,12],[970488.881366158,39],[970489.053388176,18],[970489.234382069,11],[970489.426726105,16],[970489.606447309,16],[970489.752070361,11],[970489.935158668,6],[970490.118732575,9],[970490.309359606,29],[970490.4924931,22],[970490.672701023,8],[970490.820622264,18],[970491.003072818,18],[970491.184828727,34],[970491.374146026,10],[970491.555496218,14],[970491.738035302,13],[970491.919891062,2],[970492.103688021,36],[970492.294430796,42],[970492.480033004,26],[970492.62792049,17],[970492.810875911,34],[970493.047051437,12],[970493.229645651,36],[970493.520199571,50],[970493.704423091,2],[970494.02952843,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-32f702834f7a178d34e20ed1fb86d32b","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.154220118,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.964713959,"time_to_first_token":0.242481764,"token_sha":"2b28aa2108de","tokens_per_second":25.590298030550827},"seed":1234,"sent":970483.818943709,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.24516000703442842,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":12,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.589451700534692,"done":970494.030014549,"finish_reason":"length","first":970484.064916179,"full_response_s":10.210646349005401,"last":970494.029959705,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970484.064916179,2],[970484.214758454,7],[970484.371112874,4],[970484.583509684,63],[970484.80961645,10],[970484.992839021,31],[970485.173622714,29],[970485.363492543,22],[970485.544730926,14],[970485.725279751,24],[970485.907357507,4],[970486.049593766,13],[970486.233672799,21],[970486.422491029,2],[970486.601487671,18],[970486.782848598,29],[970487.014432679,27],[970487.252277806,24],[970487.406442924,4],[970487.581344693,16],[970487.815929582,10],[970487.993613653,31],[970488.141902487,8],[970488.331617765,11],[970488.5154312,16],[970488.696924633,12],[970488.879015574,39],[970489.054298883,18],[970489.233731594,11],[970489.425971063,16],[970489.604849879,16],[970489.752725861,11],[970489.937015769,6],[970490.120796584,9],[970490.307419272,29],[970490.49064184,22],[970490.673681185,8],[970490.821347314,18],[970491.001715376,18],[970491.184965396,34],[970491.37535422,10],[970491.555064765,14],[970491.737222793,13],[970491.919954099,2],[970492.104493057,36],[970492.294940553,42],[970492.48085678,26],[970492.628247536,17],[970492.809589765,34],[970493.04820573,12],[970493.229850302,36],[970493.518999572,50],[970493.705400259,2],[970494.029959705,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-a60e7104f0e6dd1cb32bd325304e8b06","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.154281427,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.96471343,"time_to_first_token":0.241567614,"token_sha":"2b28aa2108de","tokens_per_second":25.590299389071344},"seed":1234,"sent":970483.8193682,"speculative":{"acceptance_rate":0.5576923076923077,"accepted":203,"drafted":364,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.24554797902237624,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":364,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":13,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.588463345288897,"done":970494.029711877,"finish_reason":"length","first":970484.064241666,"full_response_s":10.206978772999719,"last":970494.029670092,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970484.064241666,2],[970484.215371243,7],[970484.370038257,4],[970484.5811063,63],[970484.809079838,10],[970484.99209182,31],[970485.175296451,29],[970485.362879787,22],[970485.542177014,14],[970485.725807705,24],[970485.903969306,4],[970486.050500937,13],[970486.232061828,21],[970486.423112763,2],[970486.601571065,18],[970486.782919429,29],[970487.016927423,27],[970487.252971075,24],[970487.405598535,4],[970487.579379455,16],[970487.814820608,10],[970487.993460244,31],[970488.141319626,8],[970488.333455183,11],[970488.515037691,16],[970488.697251791,12],[970488.878892524,39],[970489.051111353,18],[970489.235106272,11],[970489.426391761,16],[970489.606333525,16],[970489.752918542,11],[970489.935781617,6],[970490.118470887,9],[970490.308420334,29],[970490.491305742,22],[970490.672571716,8],[970490.819880825,18],[970491.002942374,18],[970491.184569872,34],[970491.374581943,10],[970491.555794681,14],[970491.738144318,13],[970491.921820593,2],[970492.10412389,36],[970492.294252342,42],[970492.47975805,26],[970492.627728897,17],[970492.811639529,34],[970493.04612636,12],[970493.230264054,36],[970493.519630762,50],[970493.704688316,2],[970494.029670092,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-c6d8757ac9f41015f2fa33ccf68c6607","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.154757754,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.964439578,"time_to_first_token":0.236345813,"token_sha":"2b28aa2108de","tokens_per_second":25.591002685489915},"seed":1234,"sent":970483.822733104,"speculative":{"acceptance_rate":0.5638888888888889,"accepted":203,"drafted":360,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2415085620013997,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":360,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":14,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.59139771393406,"done":970494.030136143,"finish_reason":"length","first":970484.064460865,"full_response_s":10.211698447936215,"last":970494.028746632,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970484.064460865,2],[970484.213251633,7],[970484.37065215,4],[970484.581270447,63],[970484.809454463,10],[970484.990567011,31],[970485.172913761,29],[970485.364062282,22],[970485.54426108,14],[970485.726299299,24],[970485.906325525,4],[970486.049779854,13],[970486.232432676,21],[970486.425017397,2],[970486.603190422,18],[970486.782753505,29],[970487.016988092,27],[970487.253052965,24],[970487.407253355,4],[970487.58165428,16],[970487.812909813,10],[970487.996316905,31],[970488.142323026,8],[970488.332380233,11],[970488.515180922,16],[970488.69538491,12],[970488.878556644,39],[970489.05328433,18],[970489.234268205,11],[970489.427717517,16],[970489.605713248,16],[970489.752979803,11],[970489.936179926,6],[970490.119031487,9],[970490.309544046,29],[970490.489944571,22],[970490.673903745,8],[970490.820894498,18],[970491.003344235,18],[970491.185302684,34],[970491.374825275,10],[970491.556750869,14],[970491.739070403,13],[970491.921053613,2],[970492.103161845,36],[970492.295383959,42],[970492.478635906,26],[970492.627402108,17],[970492.811729644,34],[970493.046960137,12],[970493.230489462,36],[970493.519565196,50],[970493.705836592,2],[970494.028746632,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-f9d9e15a3e01d6763c0f7e581c2c15ac","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.154586533,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.964431578,"time_to_first_token":0.238101537,"token_sha":"2b28aa2108de","tokens_per_second":25.59102323137052},"seed":1234,"sent":970483.818437695,"speculative":{"acceptance_rate":0.5623268698060941,"accepted":203,"drafted":361,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2460231699515134,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":361,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":15,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.594746920872645,"done":970494.029819308,"finish_reason":"length","first":970484.065081895,"full_response_s":10.211647589923814,"last":970494.028063783,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970484.065081895,2],[970484.213567237,7],[970484.371434815,4],[970484.582158687,63],[970484.808688026,10],[970484.990820186,31],[970485.174852531,29],[970485.366304222,22],[970485.545382618,14],[970485.723953785,24],[970485.904243717,4],[970486.050947306,13],[970486.234045471,21],[970486.42404562,2],[970486.602275328,18],[970486.782590494,29],[970487.016622398,27],[970487.253245006,24],[970487.405801602,4],[970487.582057998,16],[970487.815234168,10],[970487.994051683,31],[970488.143740338,8],[970488.333798985,11],[970488.51574189,16],[970488.69601607,12],[970488.880897177,39],[970489.052243259,18],[970489.234889874,11],[970489.426822846,16],[970489.604889263,16],[970489.753237843,11],[970489.936269753,6],[970490.119729652,9],[970490.308129583,29],[970490.490855854,22],[970490.673570217,8],[970490.820111659,18],[970491.0035719,18],[970491.186235027,34],[970491.375238308,10],[970491.556124576,14],[970491.738558934,13],[970491.919542219,2],[970492.102818492,36],[970492.29565104,42],[970492.479528865,26],[970492.626637545,17],[970492.811804172,34],[970493.047669184,12],[970493.230028804,36],[970493.520922813,50],[970493.703412477,2],[970494.028063783,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-6f4311546d199ae7c7a74ba1c6e0d0c2","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.154626797,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.964400483,"time_to_first_token":0.237696569,"token_sha":"2b28aa2108de","tokens_per_second":25.591103090953514},"seed":1234,"sent":970483.818171718,"speculative":{"acceptance_rate":0.5623268698060941,"accepted":203,"drafted":361,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.24691017693839967,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":361,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.4023841751316,"done":970504.223422698,"finish_reason":"length","first":970494.184932609,"full_response_s":10.184056099969894,"last":970504.223360429,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970494.184932609,2],[970494.375853941,7],[970494.519868903,4],[970494.733255435,63],[970494.966433576,10],[970495.149041168,31],[970495.33899846,29],[970495.521465237,22],[970495.702840551,14],[970495.885619733,24],[970496.066424342,4],[970496.214887314,13],[970496.407808117,21],[970496.587217359,2],[970496.767830152,18],[970496.948976282,29],[970497.184845816,27],[970497.427101096,24],[970497.575254872,4],[970497.746904405,16],[970497.9845469,10],[970498.166852226,31],[970498.326323654,8],[970498.508316066,11],[970498.688648064,16],[970498.870632898,12],[970499.057123528,39],[970499.22625622,18],[970499.416890281,11],[970499.599341357,16],[970499.783313745,16],[970499.930560733,11],[970500.114631213,6],[970500.304905363,9],[970500.486835266,29],[970500.672488046,22],[970500.85520208,8],[970501.001019356,18],[970501.188864042,18],[970501.376959389,34],[970501.560437448,10],[970501.741544611,14],[970501.924574356,13],[970502.110437513,2],[970502.296810442,36],[970502.483621846,42],[970502.669897794,26],[970502.817497158,17],[970502.997928101,34],[970503.236246403,12],[970503.42913577,36],[970503.714423408,50],[970503.896800211,2],[970504.223360429,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-f5b5d86ee75091ccd76e3e55a50dae07","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.051624923,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.03997663,"time_to_first_token":0.141708968,"token_sha":"2b28aa2108de","tokens_per_second":25.398465494236913},"seed":1234,"sent":970494.039366598,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14556601096410304,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.398682871042524,"done":970504.224677551,"finish_reason":"length","first":970494.184763629,"full_response_s":10.185166987008415,"last":970504.224654331,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970494.184763629,2],[970494.375908785,7],[970494.519924019,4],[970494.733338797,63],[970494.966811192,10],[970495.149513892,31],[970495.337398745,29],[970495.521710713,22],[970495.701482087,14],[970495.88475563,24],[970496.068460405,4],[970496.214543961,13],[970496.40565627,21],[970496.588584,2],[970496.767218838,18],[970496.949547923,29],[970497.185912153,27],[970497.427734158,24],[970497.575142944,4],[970497.750126973,16],[970497.985630184,10],[970498.168210368,31],[970498.326270187,8],[970498.5099772,11],[970498.691524206,16],[970498.871771762,12],[970499.055345778,39],[970499.225791307,18],[970499.416785091,11],[970499.599299285,16],[970499.784233187,16],[970499.929893041,11],[970500.115927597,6],[970500.305215396,9],[970500.49115126,29],[970500.671499759,22],[970500.857479949,8],[970501.001350657,18],[970501.19069761,18],[970501.380885427,34],[970501.559778574,10],[970501.741120842,14],[970501.929267177,13],[970502.112035111,2],[970502.299647931,36],[970502.484373539,42],[970502.667976688,26],[970502.815661847,17],[970502.998687332,34],[970503.236965177,12],[970503.430461839,36],[970503.712224789,50],[970503.896095105,2],[970504.224654331,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-34745ec3acd59166e3f319fcc1bc82e7","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.051743637,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.041118003,"time_to_first_token":0.141468214,"token_sha":"2b28aa2108de","tokens_per_second":25.3955784528987},"seed":1234,"sent":970494.039510564,"speculative":{"acceptance_rate":0.5561643835616439,"accepted":203,"drafted":365,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1452530650421977,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":365,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.399618819351705,"done":970504.222785621,"finish_reason":"length","first":970494.18322431,"full_response_s":10.182673488976434,"last":970504.222745053,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970494.18322431,2],[970494.37537936,7],[970494.520575421,4],[970494.733047439,63],[970494.969103534,10],[970495.149622523,31],[970495.339191925,29],[970495.521598897,22],[970495.701947514,14],[970495.88656398,24],[970496.067995634,4],[970496.21508614,13],[970496.406722095,21],[970496.588259355,2],[970496.769416439,18],[970496.950200349,29],[970497.183203117,27],[970497.426683088,24],[970497.575889294,4],[970497.747063287,16],[970497.986622489,10],[970498.16867829,31],[970498.325939029,8],[970498.511308936,11],[970498.688793823,16],[970498.871824909,12],[970499.056364744,39],[970499.224830081,18],[970499.416468224,11],[970499.600122274,16],[970499.782057321,16],[970499.930913911,11],[970500.114147896,6],[970500.303715882,9],[970500.490347859,29],[970500.671598148,22],[970500.856754565,8],[970501.001103886,18],[970501.186975487,18],[970501.379755254,34],[970501.560087903,10],[970501.741346169,14],[970501.930231346,13],[970502.112474707,2],[970502.296936468,36],[970502.486507473,42],[970502.672025775,26],[970502.815574325,17],[970502.999668945,34],[970503.236899595,12],[970503.431015506,36],[970503.712872957,50],[970503.895303292,2],[970504.222745053,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-5e4301a8d56a900d5a4a225414d8b344","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.051263006,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.037958451,"time_to_first_token":0.14183802,"token_sha":"2b28aa2108de","tokens_per_second":25.403571975793188},"seed":1234,"sent":970494.040112132,"speculative":{"acceptance_rate":0.5501355013550135,"accepted":203,"drafted":369,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14311217807698995,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":369,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.395866807848147,"done":970504.225331464,"finish_reason":"length","first":970494.184096047,"full_response_s":10.185893442947417,"last":970504.225100039,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970494.184096047,2],[970494.375777989,7],[970494.519451135,4],[970494.732718073,63],[970494.968246392,10],[970495.151412438,31],[970495.33717601,29],[970495.52142214,22],[970495.702881504,14],[970495.884539809,24],[970496.067680336,4],[970496.214149398,13],[970496.405895616,21],[970496.585913659,2],[970496.768563779,18],[970496.950989811,29],[970497.186261346,27],[970497.427353534,24],[970497.576507504,4],[970497.748817145,16],[970497.984668941,10],[970498.167608033,31],[970498.325407077,8],[970498.508051418,11],[970498.689648083,16],[970498.870104915,12],[970499.057633459,39],[970499.227038097,18],[970499.418422731,11],[970499.599549801,16],[970499.782740137,16],[970499.931189361,11],[970500.115178592,6],[970500.304161031,9],[970500.488772377,29],[970500.671900915,22],[970500.854858456,8],[970501.001919113,18],[970501.186380258,18],[970501.378205874,34],[970501.558619659,10],[970501.740807672,14],[970501.930551557,13],[970502.111920287,2],[970502.299014791,36],[970502.486140948,42],[970502.669549017,26],[970502.816133465,17],[970502.997466421,34],[970503.237113256,12],[970503.430228366,36],[970503.712549929,50],[970503.897480497,2],[970504.225100039,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-da67e9e292d0cf116b4df322ff97f404","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.051792303,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.041610793,"time_to_first_token":0.141252584,"token_sha":"2b28aa2108de","tokens_per_second":25.3943321700698},"seed":1234,"sent":970494.039438021,"speculative":{"acceptance_rate":0.5561643835616439,"accepted":203,"drafted":365,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14465802593622357,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":365,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.407388073618662,"done":970504.221238499,"finish_reason":"length","first":970494.184660103,"full_response_s":10.18120199907571,"last":970504.221110889,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970494.184660103,2],[970494.376335515,7],[970494.52115524,4],[970494.733457334,63],[970494.965978856,10],[970495.150039235,31],[970495.338546156,29],[970495.52074526,22],[970495.70247577,14],[970495.885423083,24],[970496.067400452,4],[970496.214449909,13],[970496.407007547,21],[970496.585436646,2],[970496.766558939,18],[970496.949224735,29],[970497.183563193,27],[970497.426149008,24],[970497.576699817,4],[970497.748157134,16],[970497.986796318,10],[970498.168732205,31],[970498.325739515,8],[970498.511199345,11],[970498.689093902,16],[970498.870397361,12],[970499.057526973,39],[970499.225365457,18],[970499.418827744,11],[970499.599184332,16],[970499.783235729,16],[970499.9298474,11],[970500.113639725,6],[970500.303596481,9],[970500.487253418,29],[970500.6700166,22],[970500.853542901,8],[970501.000131426,18],[970501.18689507,18],[970501.379175197,34],[970501.558189521,10],[970501.741278747,14],[970501.928617937,13],[970502.109527051,2],[970502.298191082,36],[970502.484209105,42],[970502.66836725,26],[970502.817636467,17],[970502.999896032,34],[970503.237618529,12],[970503.429534733,36],[970503.711503183,50],[970503.895347445,2],[970504.221110889,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-3f68c80d861f9a85c58bcf216ea1a709","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.051436228,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.037974261,"time_to_first_token":0.141791243,"token_sha":"2b28aa2108de","tokens_per_second":25.40353196468512},"seed":1234,"sent":970494.0400365,"speculative":{"acceptance_rate":0.553133514986376,"accepted":203,"drafted":367,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14462360308971256,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":367,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.402723369833826,"done":970504.222126492,"finish_reason":"length","first":970494.183795968,"full_response_s":10.18249145289883,"last":970504.222089748,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970494.183795968,2],[970494.373776236,7],[970494.519373198,4],[970494.732208269,63],[970494.967692435,10],[970495.149719983,31],[970495.338449607,29],[970495.520980286,22],[970495.702942925,14],[970495.885039066,24],[970496.068292961,4],[970496.215194787,13],[970496.405314053,21],[970496.58762735,2],[970496.766729103,18],[970496.951311559,29],[970497.183627319,27],[970497.426573145,24],[970497.576743794,4],[970497.748695359,16],[970497.985037115,10],[970498.168321431,31],[970498.326749216,8],[970498.508910031,11],[970498.688978102,16],[970498.871277706,12],[970499.053051184,39],[970499.225111756,18],[970499.419440657,11],[970499.598852519,16],[970499.78358409,16],[970499.931458602,11],[970500.11526365,6],[970500.304541399,9],[970500.488351904,29],[970500.670891039,22],[970500.857848779,8],[970501.003335649,18],[970501.189604693,18],[970501.377243592,34],[970501.557259102,10],[970501.739997311,14],[970501.930611778,13],[970502.111490053,2],[970502.297306626,36],[970502.484520466,42],[970502.671643951,26],[970502.81677704,17],[970502.999478505,34],[970503.237771249,12],[970503.430701825,36],[970503.711751875,50],[970503.895168848,2],[970504.222089748,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-19880d915a0afda832bf746b208f0e34","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.05139926,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.03794131,"time_to_first_token":0.141737551,"token_sha":"2b28aa2108de","tokens_per_second":25.403615355467743},"seed":1234,"sent":970494.039635039,"speculative":{"acceptance_rate":0.5501355013550135,"accepted":203,"drafted":369,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14416092890314758,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":369,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.3999097733278,"done":970504.223397237,"finish_reason":"length","first":970494.183750966,"full_response_s":10.183045390062034,"last":970504.223156707,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970494.183750966,2],[970494.372937546,7],[970494.520972801,4],[970494.732424491,63],[970494.966307582,10],[970495.150227611,31],[970495.337684517,29],[970495.520400163,22],[970495.702253035,14],[970495.885295072,24],[970496.06664362,4],[970496.214615544,13],[970496.404630837,21],[970496.587852965,2],[970496.767127139,18],[970496.950123613,29],[970497.183994676,27],[970497.427166422,24],[970497.577344993,4],[970497.747929374,16],[970497.985703271,10],[970498.16813696,31],[970498.326548261,8],[970498.510119422,11],[970498.691095012,16],[970498.871713029,12],[970499.057061371,39],[970499.224916755,18],[970499.417015923,11],[970499.5998868,16],[970499.784266058,16],[970499.931138759,11],[970500.114244092,6],[970500.303638922,9],[970500.488999672,29],[970500.674019552,22],[970500.854698471,8],[970500.999938186,18],[970501.185923154,18],[970501.378347615,34],[970501.559350836,10],[970501.740475299,14],[970501.930481766,13],[970502.109351654,2],[970502.298813885,36],[970502.483665679,42],[970502.672509172,26],[970502.816014481,17],[970502.998121438,34],[970503.23767667,12],[970503.428253858,36],[970503.712087913,50],[970503.897815175,2],[970504.223156707,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-f49fec8494c1ca1395e593f62636462b","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.051551676,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.039919417,"time_to_first_token":0.141691701,"token_sha":"2b28aa2108de","tokens_per_second":25.39861022870598},"seed":1234,"sent":970494.040351847,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14339911902789026,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.407374256302695,"done":970504.220982046,"finish_reason":"length","first":970494.184468222,"full_response_s":10.18123381503392,"last":970504.220924466,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970494.184468222,2],[970494.373346433,7],[970494.520009653,4],[970494.733183308,63],[970494.968857338,10],[970495.150831979,31],[970495.337255018,29],[970495.520075407,22],[970495.701370976,14],[970495.884174387,24],[970496.06795873,4],[970496.215032993,13],[970496.407890806,21],[970496.586642917,2],[970496.766174762,18],[970496.948755292,29],[970497.184249706,27],[970497.426255798,24],[970497.574854675,4],[970497.749254501,16],[970497.984325733,10],[970498.167463474,31],[970498.326395285,8],[970498.509437902,11],[970498.689908522,16],[970498.871225215,12],[970499.055985033,39],[970499.226967874,18],[970499.41734268,11],[970499.600063237,16],[970499.782244353,16],[970499.929758533,11],[970500.115600969,6],[970500.302920579,9],[970500.490844171,29],[970500.670105914,22],[970500.853211791,8],[970501.003611771,18],[970501.185223296,18],[970501.378650559,34],[970501.557592852,10],[970501.741077377,14],[970501.923670503,13],[970502.10795077,2],[970502.29866859,36],[970502.483245207,42],[970502.666467125,26],[970502.817447436,17],[970503.000473384,34],[970503.236131627,12],[970503.430093314,36],[970503.713314985,50],[970503.896861984,2],[970504.220924466,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-a117a5ca04511a7c8713b49bf6c1f56d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.051228456,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.037985192,"time_to_first_token":0.142234744,"token_sha":"2b28aa2108de","tokens_per_second":25.40350430116474},"seed":1234,"sent":970494.039748231,"speculative":{"acceptance_rate":0.5471698113207547,"accepted":203,"drafted":371,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14471999101806432,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":371,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.399248814942034,"done":970504.223536914,"finish_reason":"length","first":970494.183857821,"full_response_s":10.183824194944464,"last":970504.223524815,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970494.183857821,2],[970494.375185095,7],[970494.521409134,4],[970494.733794221,63],[970494.967567257,10],[970495.150370825,31],[970495.339432023,29],[970495.521137968,22],[970495.701613395,14],[970495.885567258,24],[970496.06840028,4],[970496.214927818,13],[970496.406343135,21],[970496.585273012,2],[970496.766451236,18],[970496.950678402,29],[970497.184659312,27],[970497.426513436,24],[970497.576215539,4],[970497.747289223,16],[970497.986257532,10],[970498.166308063,31],[970498.325212956,8],[970498.509621861,11],[970498.688551404,16],[970498.871922946,12],[970499.053157926,39],[970499.225686645,18],[970499.420713309,11],[970499.598940217,16],[970499.783358011,16],[970499.931054293,11],[970500.116254754,6],[970500.305383464,9],[970500.48812112,29],[970500.672833415,22],[970500.856044017,8],[970501.000305575,18],[970501.189241673,18],[970501.38166263,34],[970501.556930425,10],[970501.740279978,14],[970501.930148801,13],[970502.111157216,2],[970502.299493627,36],[970502.485851592,42],[970502.666169655,26],[970502.814544574,17],[970502.998423741,34],[970503.236841631,12],[970503.427888822,36],[970503.711276127,50],[970503.89505732,2],[970504.223524815,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-1e6788042cf0b0753bd2a37de2d1cbc3","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.051588852,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.039968451,"time_to_first_token":0.141463141,"token_sha":"2b28aa2108de","tokens_per_second":25.39848618494429},"seed":1234,"sent":970494.039712719,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14414510200731456,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.057050632142964,"done":970504.222202332,"finish_reason":"length","first":970494.044744683,"full_response_s":10.181997011997737,"last":970504.221521022,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970494.044744683,2],[970494.133110956,7],[970494.376038044,4],[970494.520733887,72],[970494.73311691,1],[970494.967317508,27],[970495.149135172,30],[970495.336976015,15],[970495.520872519,14],[970495.702198543,20],[970495.8848388,14],[970496.068530963,4],[970496.214833703,13],[970496.406255773,21],[970496.584873247,2],[970496.768744169,18],[970496.948441033,29],[970497.183692148,27],[970497.427686372,24],[970497.575662142,4],[970497.747201108,16],[970497.984779701,10],[970498.166598716,31],[970498.324897786,8],[970498.510656399,11],[970498.689455674,16],[970498.870347238,12],[970499.056139225,39],[970499.225471399,18],[970499.417272217,11],[970499.598986995,16],[970499.784960476,16],[970499.929971842,11],[970500.115099344,6],[970500.302801754,9],[970500.489409326,29],[970500.673228538,22],[970500.853898767,8],[970501.002072585,18],[970501.187694469,18],[970501.37667232,34],[970501.55711424,10],[970501.740217133,14],[970501.928682558,13],[970502.112191928,2],[970502.297438045,36],[970502.483751761,42],[970502.670452134,26],[970502.816552113,17],[970502.997720186,34],[970503.236349465,12],[970503.431730887,36],[970503.714489966,50],[970503.895710096,2],[970504.221521022,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-3828a7de4630bcc33493259d46ed472d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.00338059,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.17610588,"time_to_first_token":0.00404601,"token_sha":"2b28aa2108de","tokens_per_second":25.058701531513545},"seed":1234,"sent":970494.04020532,"speculative":{"acceptance_rate":0.5386666666666666,"accepted":202,"drafted":375,"rounds":54,"tokens_per_round":4.7407407407407405},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.0045393629698082805,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":202,"drafted":375,"rounds":54},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.39904314679995,"done":970504.224158819,"finish_reason":"length","first":970494.184358791,"full_response_s":10.183645881945267,"last":970504.224107081,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970494.184358791,2],[970494.376116237,7],[970494.520628264,4],[970494.732783543,63],[970494.968314791,10],[970495.149276722,31],[970495.338338368,29],[970495.521220161,22],[970495.701138399,14],[970495.887237691,24],[970496.066911197,4],[970496.215241037,13],[970496.404896605,21],[970496.588863691,2],[970496.767324445,18],[970496.950329736,29],[970497.185343393,27],[970497.427016487,24],[970497.576278128,4],[970497.747755561,16],[970497.986328347,10],[970498.16601685,31],[970498.325280938,8],[970498.510055712,11],[970498.689690028,16],[970498.870026979,12],[970499.057176211,39],[970499.225841941,18],[970499.417706821,11],[970499.600460297,16],[970499.782576374,16],[970499.931094045,11],[970500.114068439,6],[970500.305564061,9],[970500.488900003,29],[970500.670611332,22],[970500.855628794,8],[970501.001860412,18],[970501.184635412,18],[970501.378914326,34],[970501.561440762,10],[970501.740926289,14],[970501.928906653,13],[970502.110162,2],[970502.297828639,36],[970502.48517401,42],[970502.668774119,26],[970502.815726549,17],[970502.998526114,34],[970503.237041177,12],[970503.42856301,36],[970503.714140373,50],[970503.896209496,2],[970504.224107081,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-104c30f54705cb758c5f41d1d176f99a","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.051698155,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.040694907,"time_to_first_token":0.141328264,"token_sha":"2b28aa2108de","tokens_per_second":25.396648574813625},"seed":1234,"sent":970494.040512937,"speculative":{"acceptance_rate":0.5561643835616439,"accepted":203,"drafted":365,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14384585397783667,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":365,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.398213770399263,"done":970504.223642504,"finish_reason":"length","first":970494.183492927,"full_response_s":10.183759028906934,"last":970504.223569064,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970494.183492927,2],[970494.374519498,7],[970494.520067505,4],[970494.731860547,63],[970494.966916783,10],[970495.148678531,31],[970495.338230793,29],[970495.51963773,22],[970495.700897452,14],[970495.884927923,24],[970496.06670645,4],[970496.21435829,13],[970496.406107501,21],[970496.586270503,2],[970496.766341421,18],[970496.94965721,29],[970497.18302964,27],[970497.426361388,24],[970497.577666821,4],[970497.74852646,16],[970497.985208431,10],[970498.168607315,31],[970498.326832369,8],[970498.5077575,11],[970498.689314333,16],[970498.870812072,12],[970499.053746274,39],[970499.226475355,18],[970499.416031476,11],[970499.599611062,16],[970499.783524974,16],[970499.930180894,11],[970500.113094635,6],[970500.305813778,9],[970500.487432415,29],[970500.670404841,22],[970500.857141943,8],[970501.003698525,18],[970501.186565129,18],[970501.377919302,34],[970501.55747966,10],[970501.740339574,14],[970501.924368697,13],[970502.108244623,2],[970502.29887721,36],[970502.485217091,42],[970502.667047582,26],[970502.81475369,17],[970503.000188845,34],[970503.23658521,12],[970503.428999662,36],[970503.711394296,50],[970503.897104323,2],[970504.223569064,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-6840681b38da903e2e07d4550e4fa752","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.051661988,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.040087772,"time_to_first_token":0.141524162,"token_sha":"2b28aa2108de","tokens_per_second":25.398184337705608},"seed":1234,"sent":970494.039883475,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1436094519449398,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.398847874015168,"done":970504.223120363,"finish_reason":"length","first":970494.183271632,"full_response_s":10.183270831010304,"last":970504.22309711,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970494.183271632,2],[970494.375522031,7],[970494.519284555,4],[970494.733715949,63],[970494.968565836,10],[970495.14879742,31],[970495.337976675,29],[970495.521644235,22],[970495.702793021,14],[970495.886909525,24],[970496.066832348,4],[970496.215324526,13],[970496.407258593,21],[970496.588966097,2],[970496.768238782,18],[970496.94813316,29],[970497.183914595,27],[970497.427415643,24],[970497.577911449,4],[970497.749687137,16],[970497.986144916,10],[970498.16727934,31],[970498.325785797,8],[970498.509256904,11],[970498.6895198,16],[970498.871361308,12],[970499.056663175,39],[970499.225925991,18],[970499.419869627,11],[970499.60016281,16],[970499.783110087,16],[970499.930850986,11],[970500.113396746,6],[970500.303160005,9],[970500.487701656,29],[970500.67029413,22],[970500.854461493,8],[970501.00299561,18],[970501.186022087,18],[970501.376195677,34],[970501.557761207,10],[970501.741161266,14],[970501.923837033,13],[970502.110099459,2],[970502.299225923,36],[970502.485113486,42],[970502.670710316,26],[970502.817784562,17],[970502.999420957,34],[970503.237393186,12],[970503.431330852,36],[970503.712725246,50],[970503.897574261,2],[970504.22309711,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-160a5ae0fa9a531caa8f3771acc1a03c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.051513796,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.038534506,"time_to_first_token":0.14145069,"token_sha":"2b28aa2108de","tokens_per_second":25.40211420776482},"seed":1234,"sent":970494.039849532,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1434220999944955,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.40191745582515,"done":970504.223220496,"finish_reason":"length","first":970494.184583895,"full_response_s":10.182976703974418,"last":970504.223196155,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970494.184583895,2],[970494.374280551,7],[970494.52031423,4],[970494.732621156,63],[970494.967075312,10],[970495.148933433,31],[970495.338674855,29],[970495.521064992,22],[970495.702082086,14],[970495.886183116,24],[970496.067834704,4],[970496.215153674,13],[970496.407553407,21],[970496.585119251,2],[970496.767391083,18],[970496.948578454,29],[970497.184906276,27],[970497.427628664,24],[970497.575715593,4],[970497.747492706,16],[970497.985982162,10],[970498.1680427,31],[970498.325858484,8],[970498.509506909,11],[970498.690514601,16],[970498.871874775,12],[970499.05569606,39],[970499.22502689,18],[970499.416660425,11],[970499.598902129,16],[970499.781854287,16],[970499.931391532,11],[970500.113816162,6],[970500.303418747,9],[970500.489934044,29],[970500.669906817,22],[970500.856507106,8],[970501.001485502,18],[970501.191091869,18],[970501.377595106,34],[970501.560892919,10],[970501.740983437,14],[970501.929894572,13],[970502.109758043,2],[970502.297371151,36],[970502.485510369,42],[970502.67081469,26],[970502.814315502,17],[970503.000400745,34],[970503.236645126,12],[970503.429275847,36],[970503.71360871,50],[970503.895865377,2],[970504.223196155,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-c277f0afec46cc6c58095084c773d6e1","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.051476412,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.038507252,"time_to_first_token":0.141837733,"token_sha":"2b28aa2108de","tokens_per_second":25.40218317312025},"seed":1234,"sent":970494.040243792,"speculative":{"acceptance_rate":0.553133514986376,"accepted":203,"drafted":367,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14434010302647948,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":367,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.40307489020869,"done":970504.221598014,"finish_reason":"length","first":970494.183419792,"full_response_s":10.181132622994483,"last":970504.221574665,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970494.183419792,2],[970494.375580267,7],[970494.51919444,4],[970494.733374644,63],[970494.967186168,10],[970495.150190387,31],[970495.337835141,29],[970495.521901777,22],[970495.702421934,14],[970495.884636197,24],[970496.066566788,4],[970496.215289831,13],[970496.405748929,21],[970496.585704367,2],[970496.769102501,18],[970496.949056507,29],[970497.183343451,27],[970497.42835901,24],[970497.575942729,4],[970497.749874584,16],[970497.985775766,10],[970498.167086723,31],[970498.324600443,8],[970498.508667788,11],[970498.689758346,16],[970498.871044265,12],[970499.057822875,39],[970499.22542787,18],[970499.416337573,11],[970499.598483337,16],[970499.783643111,16],[970499.931535306,11],[970500.113494015,6],[970500.303025177,9],[970500.486676033,29],[970500.670794667,22],[970500.853082644,8],[970501.000887424,18],[970501.188194766,18],[970501.380332751,34],[970501.557188367,10],[970501.740635044,14],[970501.928493623,13],[970502.1087104,2],[970502.297687761,36],[970502.483459364,42],[970502.669143364,26],[970502.817228574,17],[970502.999280063,34],[970503.237302559,12],[970503.42876366,36],[970503.711974961,50],[970503.896654037,2],[970504.221574665,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-39dea052b4f22880aea39e93dd74cdbf","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.051336078,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.037968452,"time_to_first_token":0.141997526,"token_sha":"2b28aa2108de","tokens_per_second":25.40354666577906},"seed":1234,"sent":970494.040465391,"speculative":{"acceptance_rate":0.5501355013550135,"accepted":203,"drafted":369,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1429544009733945,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":369,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.402907954512024,"done":970504.221700627,"finish_reason":"length","first":970494.183464777,"full_response_s":10.182449877960607,"last":970504.221685616,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970494.183464777,2],[970494.373925212,7],[970494.520666464,4],[970494.731950038,63],[970494.967253574,10],[970495.149471899,31],[970495.338756312,29],[970495.521170134,22],[970495.702532918,14],[970495.885659677,24],[970496.067136269,4],[970496.213936713,13],[970496.406596052,21],[970496.585215976,2],[970496.767758264,18],[970496.949155616,29],[970497.182802457,27],[970497.426763201,24],[970497.575353053,4],[970497.747894038,16],[970497.984873833,10],[970498.16587538,31],[970498.325065757,8],[970498.511822292,11],[970498.691897789,16],[970498.870196839,12],[970499.056824841,39],[970499.226833382,18],[970499.417148831,11],[970499.600393851,16],[970499.782520139,16],[970499.930964546,11],[970500.114797984,6],[970500.304045903,9],[970500.488209219,29],[970500.673615291,22],[970500.853710504,8],[970501.002618251,18],[970501.184347784,18],[970501.378051169,34],[970501.561806599,10],[970501.740131547,14],[970501.929584571,13],[970502.110777184,2],[970502.297026359,36],[970502.484055136,42],[970502.667490459,26],[970502.815022226,17],[970502.998828961,34],[970503.236743115,12],[970503.429436537,36],[970503.711811407,50],[970503.895744055,2],[970504.221685616,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-c1390b97e22eabda476acabc92f8c902","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.051299846,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.037949137,"time_to_first_token":0.141897776,"token_sha":"2b28aa2108de","tokens_per_second":25.403595547228562},"seed":1234,"sent":970494.039250749,"speculative":{"acceptance_rate":0.5501355013550135,"accepted":203,"drafted":369,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14421402791049331,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":369,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.36780173619506,"done":970514.437508476,"finish_reason":"length","first":970504.385362008,"full_response_s":10.203622014960274,"last":970514.437474629,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970504.385362008,2],[970504.566963652,7],[970504.714266217,4],[970504.928216761,63],[970505.163729189,10],[970505.352806796,31],[970505.535174001,29],[970505.719337643,22],[970505.903306248,14],[970506.083106257,24],[970506.270649504,4],[970506.421262657,13],[970506.6024965,21],[970506.784777135,2],[970506.967559878,18],[970507.149738517,29],[970507.391099796,27],[970507.630096154,24],[970507.775242628,4],[970507.948439418,16],[970508.187143606,10],[970508.380119894,31],[970508.524226689,8],[970508.706721547,11],[970508.890148054,16],[970509.073827406,12],[970509.258027809,39],[970509.436951715,18],[970509.617438279,11],[970509.801764628,16],[970509.982156515,16],[970510.129921439,11],[970510.319639083,6],[970510.50678863,9],[970510.688515748,29],[970510.870863067,22],[970511.052839766,8],[970511.201968226,18],[970511.393040874,18],[970511.577540188,34],[970511.758250003,10],[970511.942955772,14],[970512.127025407,13],[970512.319631032,2],[970512.502803394,36],[970512.687560626,42],[970512.871639486,26],[970513.019917897,17],[970513.204028333,34],[970513.450608729,12],[970513.631663195,36],[970513.916944994,50],[970514.103091903,2],[970514.437474629,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-a9621a57b41dce7b8215586d94f63f59","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.053112085,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.051264083,"time_to_first_token":0.149591362,"token_sha":"2b28aa2108de","tokens_per_second":25.369943312034657},"seed":1234,"sent":970504.233886461,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15147554699797183,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.372061721340362,"done":970514.436786249,"finish_reason":"length","first":970504.386327633,"full_response_s":10.20325278909877,"last":970514.436752498,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970504.386327633,2],[970504.569972999,7],[970504.716719288,4],[970504.929577316,63],[970505.163562578,10],[970505.354492395,31],[970505.534897624,29],[970505.719296226,22],[970505.90316926,14],[970506.085523687,24],[970506.269138343,4],[970506.421460715,13],[970506.602415411,21],[970506.786379308,2],[970506.966515421,18],[970507.149981319,29],[970507.390125931,27],[970507.626758455,24],[970507.775846257,4],[970507.950528169,16],[970508.187570126,10],[970508.379152638,31],[970508.524681487,8],[970508.709793782,11],[970508.890433361,16],[970509.075569973,12],[970509.25857629,39],[970509.435178821,18],[970509.618157164,11],[970509.799104367,16],[970509.982933603,16],[970510.129833277,11],[970510.320705815,6],[970510.507305952,9],[970510.690909777,29],[970510.871356528,22],[970511.055327765,8],[970511.200852989,18],[970511.392670766,18],[970511.579232312,34],[970511.758889286,10],[970511.941930154,14],[970512.126275877,13],[970512.318816865,2],[970512.503447831,36],[970512.689099902,42],[970512.870660166,26],[970513.022543699,17],[970513.20606555,34],[970513.451631482,12],[970513.631093174,36],[970513.918741585,50],[970514.102984857,2],[970514.436752498,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-346c3f4b61462092c33d830b59d316cc","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.053226749,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.051274485,"time_to_first_token":0.149325019,"token_sha":"2b28aa2108de","tokens_per_second":25.36991705684177},"seed":1234,"sent":970504.23353346,"speculative":{"acceptance_rate":0.5561643835616439,"accepted":203,"drafted":365,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1527941731037572,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":365,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.370281335587958,"done":970514.43701788,"finish_reason":"length","first":970504.385851053,"full_response_s":10.203633330995217,"last":970514.436981217,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970504.385851053,2],[970504.567561377,7],[970504.715578699,4],[970504.929362423,63],[970505.163601706,10],[970505.354646859,31],[970505.534637297,29],[970505.71780518,22],[970505.900200292,14],[970506.08328295,24],[970506.270941053,4],[970506.422628285,13],[970506.601918236,21],[970506.786579461,2],[970506.966862341,18],[970507.148991834,29],[970507.389816171,27],[970507.627174781,24],[970507.775775699,4],[970507.950158941,16],[970508.186395899,10],[970508.377178582,31],[970508.524646392,8],[970508.707949849,11],[970508.89019664,16],[970509.074039209,12],[970509.258486079,39],[970509.434394675,18],[970509.616598554,11],[970509.801444242,16],[970509.98248335,16],[970510.128948487,11],[970510.320376099,6],[970510.507470194,9],[970510.689396393,29],[970510.869848842,22],[970511.054034188,8],[970511.203840915,18],[970511.395243295,18],[970511.576681196,34],[970511.759175649,10],[970511.942576222,14],[970512.126100609,13],[970512.320292672,2],[970512.507397745,36],[970512.689505441,42],[970512.872028494,26],[970513.020713372,17],[970513.204192799,34],[970513.449334324,12],[970513.633380042,36],[970513.915765697,50],[970514.104137205,2],[970514.436981217,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-8c7618eef311acfc59ae78f033af399e","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.053153661,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.051036549,"time_to_first_token":0.149796332,"token_sha":"2b28aa2108de","tokens_per_second":25.370517633364937},"seed":1234,"sent":970504.233384549,"speculative":{"acceptance_rate":0.5561643835616439,"accepted":203,"drafted":365,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1524665040196851,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":365,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.372549234642914,"done":970514.436466935,"finish_reason":"length","first":970504.386223723,"full_response_s":10.2033463770058,"last":970514.436455477,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970504.386223723,2],[970504.568946241,7],[970504.715813468,4],[970504.928927533,63],[970505.162592329,10],[970505.355205231,31],[970505.536296906,29],[970505.718089688,22],[970505.901950879,14],[970506.083795632,24],[970506.270049188,4],[970506.423332239,13],[970506.602162606,21],[970506.784586456,2],[970506.969169027,18],[970507.150048085,29],[970507.393119591,27],[970507.630488379,24],[970507.774187898,4],[970507.949102131,16],[970508.186741491,10],[970508.378934817,31],[970508.524084404,8],[970508.708128622,11],[970508.889018669,16],[970509.073288287,12],[970509.257313261,39],[970509.434534576,18],[970509.617212121,11],[970509.798169119,16],[970509.984564323,16],[970510.130383135,11],[970510.319064261,6],[970510.505694341,9],[970510.691322886,29],[970510.873348202,22],[970511.053501662,8],[970511.201469227,18],[970511.393749916,18],[970511.57787208,34],[970511.759603449,10],[970511.941754614,14],[970512.125458253,13],[970512.318496607,2],[970512.503537385,36],[970512.688113715,42],[970512.870952818,26],[970513.019058121,17],[970513.20310344,34],[970513.448811801,12],[970513.632611229,36],[970513.916616559,50],[970514.103745941,2],[970514.436455477,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-5e0df5e452b0a9a9f69b537c0854b63e","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.052958229,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.051174849,"time_to_first_token":0.149633579,"token_sha":"2b28aa2108de","tokens_per_second":25.370168545557654},"seed":1234,"sent":970504.233120558,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1531031649792567,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.371170094896307,"done":970514.43826247,"finish_reason":"length","first":970504.387445385,"full_response_s":10.205222376971506,"last":970514.438223455,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970504.387445385,2],[970504.569315598,7],[970504.715400422,4],[970504.928545613,63],[970505.163454748,10],[970505.354417003,31],[970505.537069899,29],[970505.721537972,22],[970505.900850667,14],[970506.083970997,24],[970506.269066504,4],[970506.422917929,13],[970506.603485585,21],[970506.785230797,2],[970506.968079553,18],[970507.148917931,29],[970507.390412358,27],[970507.628846887,24],[970507.775000034,4],[970507.948142092,16],[970508.187387801,10],[970508.378477235,31],[970508.527177363,8],[970508.707189644,11],[970508.889603814,16],[970509.075951412,12],[970509.257226395,39],[970509.434479701,18],[970509.61790692,11],[970509.800122289,16],[970509.983280426,16],[970510.129255606,11],[970510.319580031,6],[970510.507040858,9],[970510.689265422,29],[970510.874052986,22],[970511.05421344,8],[970511.202233912,18],[970511.394193255,18],[970511.57817323,34],[970511.757152802,10],[970511.943798553,14],[970512.126025922,13],[970512.317940237,2],[970512.503216247,36],[970512.686491095,42],[970512.871114067,26],[970513.019575731,17],[970513.20459248,34],[970513.448508875,12],[970513.632908026,36],[970513.917595671,50],[970514.105592542,2],[970514.438223455,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-3d31246c216e0876cb3fb45ffba876b4","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.052995405,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.051604521,"time_to_first_token":0.149819489,"token_sha":"2b28aa2108de","tokens_per_second":25.369084056903475},"seed":1234,"sent":970504.233040093,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15440529200714082,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.374613923502572,"done":970514.436701799,"finish_reason":"length","first":970504.386782848,"full_response_s":10.203394338022918,"last":970514.436196832,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970504.386782848,2],[970504.569534443,7],[970504.714727946,4],[970504.928785327,63],[970505.162799156,10],[970505.354691652,31],[970505.536070859,29],[970505.721135169,22],[970505.900796432,14],[970506.082748775,24],[970506.270572512,4],[970506.422171406,13],[970506.602719186,21],[970506.785077197,2],[970506.967644775,18],[970507.148408866,29],[970507.391266983,27],[970507.627085771,24],[970507.775297152,4],[970507.948258452,16],[970508.186151225,10],[970508.380597753,31],[970508.524304689,8],[970508.709005811,11],[970508.892801514,16],[970509.074325541,12],[970509.259236938,39],[970509.436248066,18],[970509.617540765,11],[970509.799427906,16],[970509.9838327,16],[970510.13027508,11],[970510.319841077,6],[970510.503880975,9],[970510.690037918,29],[970510.87395391,22],[970511.05338623,8],[970511.202301062,18],[970511.395958482,18],[970511.575920799,34],[970511.758799028,10],[970511.941411279,14],[970512.125809269,13],[970512.318411966,2],[970512.506800022,36],[970512.686813001,42],[970512.870339588,26],[970513.019420867,17],[970513.204942056,34],[970513.451331309,12],[970513.632316432,36],[970513.918216678,50],[970514.105088183,2],[970514.436196832,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-3790c7df85997c2e5c8e76c2fdda9048","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.05277928,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.051767899,"time_to_first_token":0.149678981,"token_sha":"2b28aa2108de","tokens_per_second":25.368671716481703},"seed":1234,"sent":970504.233307461,"speculative":{"acceptance_rate":0.5501355013550135,"accepted":203,"drafted":369,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15347538702189922,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":369,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.376548809969208,"done":970514.435964209,"finish_reason":"length","first":970504.387293146,"full_response_s":10.201783349970356,"last":970514.435940892,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970504.387293146,2],[970504.56881647,7],[970504.71438389,4],[970504.927805748,63],[970505.163252402,10],[970505.353867641,31],[970505.535353846,29],[970505.719445713,22],[970505.900901813,14],[970506.083627741,24],[970506.26996165,4],[970506.420773532,13],[970506.60264413,21],[970506.784096658,2],[970506.965991761,18],[970507.149463068,29],[970507.393420373,27],[970507.626661907,24],[970507.775366398,4],[970507.948606092,16],[970508.186296727,10],[970508.379994476,31],[970508.524780532,8],[970508.707419707,11],[970508.889232554,16],[970509.072630775,12],[970509.259459976,39],[970509.434245316,18],[970509.617039797,11],[970509.801159704,16],[970509.983549314,16],[970510.129120459,11],[970510.320838738,6],[970510.505621606,9],[970510.687779709,29],[970510.869992456,22],[970511.052279379,8],[970511.200947216,18],[970511.395739221,18],[970511.577307404,34],[970511.761023677,10],[970511.943035085,14],[970512.125278856,13],[970512.318643358,2],[970512.505070452,36],[970512.68802008,42],[970512.870523882,26],[970513.01972477,17],[970513.203932505,34],[970513.45199114,12],[970513.631586123,36],[970513.917364312,50],[970514.103553486,2],[970514.435940892,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-06956531568e0c8bb71b8cfd79823a95","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.053190501,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.051017345,"time_to_first_token":0.149733488,"token_sha":"2b28aa2108de","tokens_per_second":25.370566107604304},"seed":1234,"sent":970504.234180859,"speculative":{"acceptance_rate":0.5561643835616439,"accepted":203,"drafted":365,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15311228693462908,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":365,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.36499894299512,"done":970514.437827966,"finish_reason":"length","first":970504.384580453,"full_response_s":10.203818454989232,"last":970514.437803817,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970504.384580453,2],[970504.567390445,7],[970504.715949112,4],[970504.929620925,63],[970505.16380959,10],[970505.354950394,31],[970505.534554912,29],[970505.72188414,22],[970505.90177217,14],[970506.085175406,24],[970506.269893812,4],[970506.423602503,13],[970506.602911114,21],[970506.786032964,2],[970506.968848273,18],[970507.150950336,29],[970507.391510713,27],[970507.62891943,24],[970507.775146865,4],[970507.949961492,16],[970508.187497231,10],[970508.378339094,31],[970508.525474771,8],[970508.708062656,11],[970508.89155028,16],[970509.074731064,12],[970509.258898644,39],[970509.434958152,18],[970509.617667719,11],[970509.799467818,16],[970509.982538754,16],[970510.130753979,11],[970510.320297299,6],[970510.505088872,9],[970510.687473854,29],[970510.872362815,22],[970511.054408264,8],[970511.205138621,18],[970511.394337573,18],[970511.577819462,34],[970511.759964035,10],[970511.942044241,14],[970512.125349575,13],[970512.319070565,2],[970512.505280607,36],[970512.688424243,42],[970512.870994522,26],[970513.02285029,17],[970513.204085113,34],[970513.448124604,12],[970513.632127018,36],[970513.918502352,50],[970514.103159437,2],[970514.437803817,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-c9fb1534ed7e4b3189ccb4a60092d4dc","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.052808438,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.051765002,"time_to_first_token":0.149506064,"token_sha":"2b28aa2108de","tokens_per_second":25.368679027938143},"seed":1234,"sent":970504.234009511,"speculative":{"acceptance_rate":0.5501355013550135,"accepted":203,"drafted":369,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1505709420889616,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":369,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.37219621860568,"done":970514.437877,"finish_reason":"length","first":970504.386949218,"full_response_s":10.204671144951135,"last":970514.437320806,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970504.386949218,2],[970504.568176049,7],[970504.716040363,4],[970504.928859471,63],[970505.162270134,10],[970505.353187115,31],[970505.53678536,29],[970505.720512879,22],[970505.902779899,14],[970506.084818388,24],[970506.269708413,4],[970506.422113858,13],[970506.603756377,21],[970506.784391551,2],[970506.968777202,18],[970507.150788622,29],[970507.392030309,27],[970507.628139125,24],[970507.776188648,4],[970507.949383181,16],[970508.186353619,10],[970508.377595308,31],[970508.523773812,8],[970508.708957225,11],[970508.889658673,16],[970509.07285879,12],[970509.258151146,39],[970509.437064842,18],[970509.61691566,11],[970509.798266531,16],[970509.98331773,16],[970510.129565222,11],[970510.319210515,6],[970510.503997223,9],[970510.690569147,29],[970510.871281745,22],[970511.055171957,8],[970511.201666996,18],[970511.393279083,18],[970511.578521078,34],[970511.758745689,10],[970511.942089627,14],[970512.126568529,13],[970512.320055215,2],[970512.506089093,36],[970512.68763765,42],[970512.870574068,26],[970513.019639056,17],[970513.205296945,34],[970513.450286775,12],[970513.633086846,36],[970513.916537503,50],[970514.104015212,2],[970514.437320806,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-c2537a3f888dc0a4881515e21b6156cf","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.05288327,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.051458828,"time_to_first_token":0.150003048,"token_sha":"2b28aa2108de","tokens_per_second":25.369451774468335},"seed":1234,"sent":970504.233205855,"speculative":{"acceptance_rate":0.553133514986376,"accepted":203,"drafted":367,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15374336298555136,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":367,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.00716188684478,"done":970514.437675519,"finish_reason":"length","first":970504.238804605,"full_response_s":10.204403441981412,"last":970514.435883392,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970504.238804605,2],[970504.331906571,7],[970504.569039876,4],[970504.716337881,72],[970504.928467853,1],[970505.162065963,27],[970505.355047694,30],[970505.535847901,15],[970505.721979104,14],[970505.90213058,20],[970506.084483343,14],[970506.269813411,4],[970506.419842315,13],[970506.604346323,21],[970506.78650791,2],[970506.967351243,18],[970507.148819879,29],[970507.393588168,27],[970507.629777432,24],[970507.774815612,4],[970507.949531484,16],[970508.187226887,10],[970508.379682284,31],[970508.526430505,8],[970508.707618709,11],[970508.891224757,16],[970509.073491512,12],[970509.257362167,39],[970509.43473681,18],[970509.61712143,11],[970509.799950606,16],[970509.981959883,16],[970510.130675291,11],[970510.318819842,6],[970510.50412941,9],[970510.690272926,29],[970510.873173654,22],[970511.05293721,8],[970511.20275882,18],[970511.393590251,18],[970511.577156941,34],[970511.758323922,10],[970511.941867405,14],[970512.125760171,13],[970512.318045379,2],[970512.504714651,36],[970512.687668808,42],[970512.871074763,26],[970513.019268372,17],[970513.203825587,34],[970513.450183794,12],[970513.631263465,36],[970513.917717008,50],[970514.103600087,2],[970514.435883392,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-28853f37dd198a4868c5d29c2ec61875","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.003570903,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.196809756,"time_to_first_token":0.004144335,"token_sha":"2b28aa2108de","tokens_per_second":25.007821671866836},"seed":1234,"sent":970504.233272077,"speculative":{"acceptance_rate":0.5386666666666666,"accepted":202,"drafted":375,"rounds":54,"tokens_per_round":4.7407407407407405},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.005532527924515307,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":202,"drafted":375,"rounds":54},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.36546236622581,"done":970514.440657072,"finish_reason":"length","first":970504.384886261,"full_response_s":10.206330263055861,"last":970514.437925954,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970504.384886261,2],[970504.567776573,7],[970504.714649641,4],[970504.929314461,63],[970505.163525739,10],[970505.354745007,31],[970505.536559745,29],[970505.719119486,22],[970505.901027712,14],[970506.085447607,24],[970506.270249373,4],[970506.423725824,13],[970506.602546238,21],[970506.785528155,2],[970506.967941765,18],[970507.148537484,29],[970507.391654071,27],[970507.629553274,24],[970507.776359372,4],[970507.949844556,16],[970508.185848458,10],[970508.380722435,31],[970508.524742124,8],[970508.709697282,11],[970508.893616434,16],[970509.074919023,12],[970509.258657427,39],[970509.436647028,18],[970509.617369465,11],[970509.798754103,16],[970509.984814934,16],[970510.130050282,11],[970510.321122204,6],[970510.504782729,9],[970510.688657281,29],[970510.874604828,22],[970511.054750815,8],[970511.202367188,18],[970511.394519883,18],[970511.57735519,34],[970511.758125193,10],[970511.9441609,14],[970512.125873586,13],[970512.318083547,2],[970512.507146606,36],[970512.687125993,42],[970512.871368023,26],[970513.020251229,17],[970513.205631797,34],[970513.449641187,12],[970513.631416792,36],[970513.917299883,50],[970514.105516271,2],[970514.437925954,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-de00a049bfdcb9748648e04f2a480639","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.05284531,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.051759017,"time_to_first_token":0.14949555,"token_sha":"2b28aa2108de","tokens_per_second":25.368694132910687},"seed":1234,"sent":970504.234326809,"speculative":{"acceptance_rate":0.5501355013550135,"accepted":203,"drafted":369,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1505594520131126,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":369,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.371216867750626,"done":970514.437241814,"finish_reason":"length","first":970504.386439512,"full_response_s":10.203580519999377,"last":970514.437199053,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970504.386439512,2],[970504.569763707,7],[970504.715143456,4],[970504.928299226,63],[970505.163678586,10],[970505.355316454,31],[970505.534407634,29],[970505.721719018,22],[970505.899887635,14],[970506.084395196,24],[970506.270346337,4],[970506.422317964,13],[970506.60341477,21],[970506.78675657,2],[970506.966163893,18],[970507.149274133,29],[970507.390880791,27],[970507.63017537,24],[970507.775406774,4],[970507.950443144,16],[970508.186665027,10],[970508.376558262,31],[970508.523687138,8],[970508.709119739,11],[970508.893673006,16],[970509.076519353,12],[970509.258076299,39],[970509.4352517,18],[970509.618517366,11],[970509.798450521,16],[970509.981734444,16],[970510.130151439,11],[970510.31892692,6],[970510.505369714,9],[970510.689091307,29],[970510.874370012,22],[970511.054094568,8],[970511.201775386,18],[970511.394588377,18],[970511.578912774,34],[970511.75775899,10],[970511.943389301,14],[970512.126460955,13],[970512.319941544,2],[970512.503974275,36],[970512.687313615,42],[970512.871291735,26],[970513.02210124,17],[970513.202852268,34],[970513.450997736,12],[970513.633751398,36],[970513.915837536,50],[970514.104693687,2],[970514.437199053,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-1f3894de3ed93779c08b0f80a7424496","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.053069132,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.051089247,"time_to_first_token":0.14958384,"token_sha":"2b28aa2108de","tokens_per_second":25.370384615389934},"seed":1234,"sent":970504.233661294,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15277821803465486,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.369386542833364,"done":970514.436936119,"finish_reason":"length","first":970504.384543085,"full_response_s":10.203202745993622,"last":970514.436027758,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970504.384543085,2],[970504.568484625,7],[970504.715057502,4],[970504.928372553,63],[970505.162417652,10],[970505.354082278,31],[970505.536031619,29],[970505.719377139,22],[970505.900725969,14],[970506.084323118,24],[970506.270478509,4],[970506.421563424,13],[970506.603674408,21],[970506.784833243,2],[970506.967066047,18],[970507.150324478,29],[970507.392782017,27],[970507.628054131,24],[970507.774289439,4],[970507.949916923,16],[970508.186028432,10],[970508.380472975,31],[970508.524014806,8],[970508.707344252,11],[970508.889421537,16],[970509.073632053,12],[970509.257957986,39],[970509.435752763,18],[970509.616969239,11],[970509.799585571,16],[970509.984112374,16],[970510.129876422,11],[970510.319747617,6],[970510.507557028,9],[970510.688188593,29],[970510.873872901,22],[970511.05239305,8],[970511.201226361,18],[970511.394814999,18],[970511.576925214,34],[970511.757372095,10],[970511.941963921,14],[970512.125683755,13],[970512.320201229,2],[970512.502647058,36],[970512.688818372,42],[970512.871700955,26],[970513.018465312,17],[970513.203344417,34],[970513.448930897,12],[970513.631912478,36],[970513.916118361,50],[970514.104620184,2],[970514.436027758,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-6b7ce4bca4ede8a383f34afea2f59b1a","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.052921293,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.051212553,"time_to_first_token":0.149732431,"token_sha":"2b28aa2108de","tokens_per_second":25.370073377255345},"seed":1234,"sent":970504.233733373,"speculative":{"acceptance_rate":0.553133514986376,"accepted":203,"drafted":367,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15080971200950444,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":367,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.368141216944565,"done":970514.436651005,"finish_reason":"length","first":970504.384635904,"full_response_s":10.203301551984623,"last":970514.436614006,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970504.384635904,2],[970504.567091039,7],[970504.714869863,4],[970504.929395118,63],[970505.163053,10],[970505.353516352,31],[970505.535646531,29],[970505.720226484,22],[970505.902015709,14],[970506.082531834,24],[970506.268946767,4],[970506.421999562,13],[970506.602077453,21],[970506.783823577,2],[970506.968283067,18],[970507.148730868,29],[970507.391933473,27],[970507.627646111,24],[970507.775950167,4],[970507.948700576,16],[970508.185984646,10],[970508.37980703,31],[970508.526572742,8],[970508.709189401,11],[970508.893534273,16],[970509.074448974,12],[970509.259032112,39],[970509.43742314,18],[970509.618236396,11],[970509.799286773,16],[970509.982808665,16],[970510.128460691,11],[970510.319453333,6],[970510.503762119,9],[970510.687358934,29],[970510.871870618,22],[970511.055228129,8],[970511.201040659,18],[970511.396311883,18],[970511.577039413,34],[970511.761365875,10],[970511.941633165,14],[970512.125937696,13],[970512.318561757,2],[970512.50434992,36],[970512.687844796,42],[970512.871786813,26],[970513.018599835,17],[970513.202937918,34],[970513.447795225,12],[970513.632656502,36],[970513.918010924,50],[970514.104353329,2],[970514.436614006,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-caf993498f259efea20cb165ce4b0233","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.052728213,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.051558433,"time_to_first_token":0.149880831,"token_sha":"2b28aa2108de","tokens_per_second":25.36920037820368},"seed":1234,"sent":970504.233349453,"speculative":{"acceptance_rate":0.5501355013550135,"accepted":203,"drafted":369,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15128645102959126,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":369,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.370198885465168,"done":970514.436233272,"finish_reason":"length","first":970504.385060057,"full_response_s":10.202457553939894,"last":970514.436222886,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970504.385060057,2],[970504.568092207,7],[970504.715362574,4],[970504.929100433,63],[970505.162963046,10],[970505.353994467,31],[970505.534291738,29],[970505.718441297,22],[970505.899639375,14],[970506.08392185,24],[970506.271087707,4],[970506.421064152,13],[970506.601701727,21],[970506.784513832,2],[970506.966742428,18],[970507.149069979,29],[970507.39243953,27],[970507.626876623,24],[970507.774095255,4],[970507.949464046,16],[970508.185587508,10],[970508.379540319,31],[970508.523913857,8],[970508.708453825,11],[970508.889735617,16],[970509.072760866,12],[970509.25742506,39],[970509.43560787,18],[970509.616826233,11],[970509.798978053,16],[970509.984483954,16],[970510.128720904,11],[970510.318983236,6],[970510.505921315,9],[970510.689815984,29],[970510.870104447,22],[970511.053961213,8],[970511.201403486,18],[970511.397246507,18],[970511.576365595,34],[970511.756876585,10],[970511.942303767,14],[970512.125972183,13],[970512.319251658,2],[970512.506450767,36],[970512.686149873,42],[970512.870451995,26],[970513.019154397,17],[970513.204685636,34],[970513.453021079,12],[970513.63363499,36],[970513.918820753,50],[970514.102823384,2],[970514.436222886,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-75ed9d5e9da012c614e3787b2e14c731","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.052680155,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.051467726,"time_to_first_token":0.149863963,"token_sha":"2b28aa2108de","tokens_per_second":25.36942931631714},"seed":1234,"sent":970504.233775718,"speculative":{"acceptance_rate":0.5471698113207547,"accepted":203,"drafted":371,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15128433902282268,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":371,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.3739535055537,"done":970514.43606967,"finish_reason":"length","first":970504.38638134,"full_response_s":10.203164068982005,"last":970514.436056884,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970504.38638134,2],[970504.56908707,7],[970504.715223665,4],[970504.927695917,63],[970505.162717139,10],[970505.354576476,31],[970505.537497524,29],[970505.719220835,22],[970505.899536842,14],[970506.083035058,24],[970506.269769994,4],[970506.420338034,13],[970506.602776686,21],[970506.785121671,2],[970506.966966795,18],[970507.148128968,29],[970507.390735817,27],[970507.628392585,24],[970507.775886586,4],[970507.949025363,16],[970508.18574775,10],[970508.377981772,31],[970508.524603231,8],[970508.707695588,11],[970508.890078248,16],[970509.074539265,12],[970509.25769414,39],[970509.435295069,18],[970509.617487938,11],[970509.799507987,16],[970509.982445679,16],[970510.12974998,11],[970510.321353692,6],[970510.504471881,9],[970510.689145878,29],[970510.870708699,22],[970511.054468453,8],[970511.204569608,18],[970511.397693591,18],[970511.575661066,34],[970511.757494472,10],[970511.942673314,14],[970512.127177854,13],[970512.319786248,2],[970512.505569802,36],[970512.688732642,42],[970512.870217915,26],[970513.02138583,17],[970513.203205652,34],[970513.451754563,12],[970513.63349429,36],[970513.916689518,50],[970514.10395824,2],[970514.436056884,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-18495248e39bc3ffc9275d26c0bd40ea","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.053032741,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.051097649,"time_to_first_token":0.149685525,"token_sha":"2b28aa2108de","tokens_per_second":25.370363407559804},"seed":1234,"sent":970504.232905601,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1534757389454171,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":1,"burst":null,"stream":0,"phase":"warmup","request":{"cache_state":"cold","cached_tokens":0,"case_id":null,"complete":true,"decode_tps":59.523719528214315,"done":970514.861657402,"finish_reason":"length","first":970514.609617045,"full_response_s":0.4128892159787938,"last":970514.861617426,"output_sha256":"6bffe2c2436146ed3af0e8c4e21d88b3dddfbe4a47910e8940f3039340788c85","pieces":[[970514.609617045,3],[970514.696823892,26],[970514.777417148,15],[970514.861617426,30]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":16,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"c81230cadd07c8b22d2a507aa18b8b00964a157b29ba5c65c8fdf55148cf2238","response_id":"chatcmpl-2ffc1d05d7b02f969a8bca4a0b661e3b","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.158968715,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":0.252856108,"time_to_first_token":0.159789347,"token_sha":"a9100b9c265b","tokens_per_second":59.322276683939144},"seed":1234,"sent":970514.448768186,"speculative":{"acceptance_rate":0.28888888888888886,"accepted":13,"drafted":45,"rounds":3,"tokens_per_round":5.333333333333333},"token_sha":"a9100b9c265b","tokens":16,"ttft_s":0.1608488589990884,"usage":{"completion_tokens":16,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":0},"total_tokens":47},"work":{"accepted":13,"drafted":45,"rounds":3},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":1,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":49.52427465361714,"done":970520.031640666,"finish_reason":"length","first":970514.88259945,"full_response_s":5.1614946679910645,"last":970520.031589552,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970514.88259945,3],[970514.969897851,26],[970515.050983256,15],[970515.131838999,34],[970515.212769813,21],[970515.298370203,25],[970515.382731445,14],[970515.46377553,14],[970515.544301397,18],[970515.624858903,26],[970515.705391331,13],[970515.786195383,13],[970515.867443152,13],[970515.948014646,23],[970516.028981612,32],[970516.110479006,7],[970516.191134325,23],[970516.277983961,9],[970516.36432495,13],[970516.445928029,15],[970516.526816628,19],[970516.607532039,12],[970516.688257164,5],[970516.768668321,23],[970516.850116634,9],[970516.930726601,17],[970517.010542502,3],[970517.092888454,21],[970517.173256803,10],[970517.255551721,24],[970517.343041662,19],[970517.425120903,14],[970517.505824617,13],[970517.586377004,5],[970517.66676979,22],[970517.747416485,13],[970517.82880457,51],[970517.909824685,15],[970517.990460083,6],[970518.071951061,8],[970518.152787379,9],[970518.23529434,16],[970518.323359484,16],[970518.407050685,9],[970518.487825679,32],[970518.568785558,18],[970518.649773235,13],[970518.729915348,11],[970518.81144939,15],[970518.892023993,8],[970518.973016135,18],[970519.047617016,25],[970519.128807407,19],[970519.209790572,8],[970519.295785359,40],[970519.380757844,16],[970519.46189672,64],[970519.542788539,6],[970519.623610551,6],[970519.705366272,11],[970519.786964586,15],[970519.868858105,17],[970519.949154748,21],[970520.031589552,14]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-0da08d2e1fe35a88e0bd491863149142","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.010049986,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":5.149538103,"time_to_first_token":0.011241205,"token_sha":"8a91591c94a3","tokens_per_second":49.519004403801375},"seed":1234,"sent":970514.870145998,"speculative":{"acceptance_rate":0.2052910052910053,"accepted":194,"drafted":945,"rounds":63,"tokens_per_round":4.063492063492063},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.012453451985493302,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":194,"drafted":945,"rounds":63},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":1,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":49.51497347447652,"done":970525.193857037,"finish_reason":"length","first":970520.043846765,"full_response_s":5.154151172959246,"last":970525.193804083,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970520.043846765,3],[970520.132016615,26],[970520.214718273,15],[970520.301209064,34],[970520.385711309,21],[970520.466459132,25],[970520.547068974,14],[970520.628151056,14],[970520.708815358,18],[970520.78915289,26],[970520.870839295,13],[970520.951255565,13],[970521.031681772,13],[970521.113237166,23],[970521.193854484,32],[970521.278381326,7],[970521.364666715,23],[970521.445840513,9],[970521.526333262,13],[970521.606901641,15],[970521.68723895,19],[970521.768059797,12],[970521.849459882,5],[970521.930044203,23],[970522.010264882,9],[970522.092067528,17],[970522.172060401,3],[970522.25670994,21],[970522.343988856,10],[970522.42807801,24],[970522.508811897,19],[970522.589390136,14],[970522.669159989,13],[970522.750663038,5],[970522.832513221,22],[970522.91311305,13],[970522.993410322,51],[970523.075046344,15],[970523.155710218,6],[970523.235701797,8],[970523.323541641,9],[970523.4078755,16],[970523.488593497,16],[970523.569413947,9],[970523.650062602,32],[970523.730968781,18],[970523.812790326,13],[970523.893168608,11],[970523.973866283,15],[970524.054651383,8],[970524.135882524,18],[970524.211604288,25],[970524.297758577,19],[970524.382783376,8],[970524.464249252,40],[970524.545160665,16],[970524.625752111,64],[970524.706803024,6],[970524.787474709,6],[970524.869060556,11],[970524.949808066,15],[970525.030738892,17],[970525.112983262,21],[970525.193804083,14]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-eb7ab8fe09c500cd46ac2065f42eb8eb","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.003303563,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":5.149834094,"time_to_first_token":0.003661492,"token_sha":"8a91591c94a3","tokens_per_second":49.51615825781591},"seed":1234,"sent":970520.039705864,"speculative":{"acceptance_rate":0.2052910052910053,"accepted":194,"drafted":945,"rounds":63,"tokens_per_round":4.063492063492063},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.004140900913625956,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":194,"drafted":945,"rounds":63},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":1,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":49.377063220444285,"done":970530.371400297,"finish_reason":"length","first":970525.207015816,"full_response_s":5.168879957054742,"last":970530.371356977,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970525.207015816,3],[970525.300354503,26],[970525.38463224,15],[970525.465819694,34],[970525.547122883,21],[970525.628111321,25],[970525.710192858,14],[970525.790947122,14],[970525.872158046,18],[970525.952687914,26],[970526.032713793,13],[970526.114470163,13],[970526.194807672,13],[970526.281807249,23],[970526.367412996,32],[970526.44885191,7],[970526.529199662,23],[970526.609895083,9],[970526.69041138,13],[970526.77063842,15],[970526.851869469,19],[970526.932802587,12],[970527.012759895,5],[970527.095109744,23],[970527.175406928,9],[970527.255910265,17],[970527.343839578,3],[970527.425819738,21],[970527.50693174,10],[970527.587657489,24],[970527.668338381,19],[970527.748966335,14],[970527.830200258,13],[970527.912070588,5],[970527.994078947,22],[970528.074849282,13],[970528.156022274,51],[970528.238821606,15],[970528.326301726,6],[970528.410148754,8],[970528.491149648,9],[970528.571874567,16],[970528.653834083,16],[970528.735156065,9],[970528.816441109,32],[970528.897958251,18],[970528.978781607,13],[970529.059670432,11],[970529.140842738,15],[970529.221289587,8],[970529.308391423,18],[970529.385824089,25],[970529.46715361,19],[970529.548736861,8],[970529.629414508,40],[970529.71043928,16],[970529.790856716,64],[970529.872549854,6],[970529.953221966,6],[970530.03372963,11],[970530.115988216,15],[970530.196485334,17],[970530.284888243,21],[970530.371356977,14]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-1009c35c3a6e4e0c2b86750fa2bfe049","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.003312103,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":5.164197116,"time_to_first_token":0.003771203,"token_sha":"8a91591c94a3","tokens_per_second":49.378440495608686},"seed":1234,"sent":970525.20252034,"speculative":{"acceptance_rate":0.2052910052910053,"accepted":194,"drafted":945,"rounds":63,"tokens_per_round":4.063492063492063},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.004495476023294032,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":194,"drafted":945,"rounds":63},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.609502028021275,"done":970544.300437605,"finish_reason":"length","first":970530.597627086,"full_response_s":13.91932970203925,"last":970544.300304332,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970530.597627086,3],[970530.749654246,11],[970530.930095926,30],[970531.112794317,19],[970531.29851009,21],[970531.482239806,15],[970531.627934392,19],[970531.773493047,17],[970531.956953887,12],[970532.138752513,5],[970532.314988936,5],[970532.497714449,18],[970532.678957286,21],[970532.861406677,13],[970533.042887093,5],[970533.224640074,16],[970533.417284084,5],[970533.597461939,14],[970533.780912647,9],[970533.962426309,27],[970534.111080612,11],[970534.300196112,8],[970534.45083727,16],[970534.598549691,5],[970534.748505467,9],[970534.933817244,14],[970535.076060617,20],[970535.259683383,12],[970535.415461671,8],[970535.563483267,5],[970535.710575,14],[970535.893201749,14],[970536.075586685,8],[970536.260462334,13],[970536.442054507,3],[970536.621030471,10],[970536.769160241,11],[970536.952705129,9],[970537.136697561,10],[970537.325367773,20],[970537.515077372,14],[970537.693428508,14],[970537.921814805,13],[970538.10674028,5],[970538.294376492,22],[970538.528067271,3],[970538.762927302,32],[970538.95011496,33],[970539.132611365,11],[970539.320112458,6],[970539.494386252,8],[970539.642643181,9],[970539.7914104,13],[970539.940201482,8],[970540.087749034,20],[970540.237912823,17],[970540.431296001,20],[970540.580831364,13],[970540.753221383,6],[970540.937198412,13],[970541.086535106,9],[970541.272797982,11],[970541.425884301,8],[970541.60999343,15],[970541.795963481,16],[970542.006183245,27],[970542.247311061,4],[970542.405758939,8],[970542.590956709,25],[970542.772896775,18],[970542.922684901,13],[970543.107960874,55],[970543.257365457,11],[970543.449474753,10],[970543.635436891,11],[970543.784951719,15],[970543.932993913,17],[970544.082285124,14],[970544.300304332,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-0d989f573d31fe649e937b972f46968e","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.122455471,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.703456873,"time_to_first_token":0.211082969,"token_sha":"8a91591c94a3","tokens_per_second":18.608443282835292},"seed":1234,"sent":970530.381107903,"speculative":{"acceptance_rate":0.4022727272727273,"accepted":177,"drafted":440,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2165191830135882,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":440,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":1,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.612582770488007,"done":970544.298726875,"finish_reason":"length","first":970530.598263244,"full_response_s":13.918031982029788,"last":970544.298672432,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970530.598263244,3],[970530.748690055,11],[970530.931481192,30],[970531.112938954,19],[970531.297492465,21],[970531.482867434,15],[970531.627302971,19],[970531.773348187,17],[970531.959509064,12],[970532.139904149,5],[970532.316174147,5],[970532.496442342,27],[970532.679322158,12],[970532.863617481,13],[970533.043129124,5],[970533.226149444,16],[970533.415750646,5],[970533.599439945,14],[970533.778123809,9],[970533.962969152,27],[970534.110328752,11],[970534.30023612,8],[970534.451569558,16],[970534.599050142,5],[970534.749453749,9],[970534.933109297,14],[970535.077326385,20],[970535.260887364,12],[970535.417566869,8],[970535.563647843,5],[970535.712410705,14],[970535.894241521,14],[970536.076815262,8],[970536.261731655,13],[970536.440366848,3],[970536.622612557,10],[970536.770476451,11],[970536.951081275,9],[970537.136865034,10],[970537.324897729,20],[970537.511086879,14],[970537.694558521,14],[970537.922392214,13],[970538.105613163,5],[970538.294449754,22],[970538.527017322,3],[970538.763526219,32],[970538.947330192,33],[970539.131929616,11],[970539.32024178,6],[970539.494594197,8],[970539.641882984,9],[970539.790807963,13],[970539.938962376,8],[970540.089825182,20],[970540.23805293,17],[970540.433267105,20],[970540.58131389,13],[970540.753364995,6],[970540.937711392,13],[970541.086674253,9],[970541.272716735,11],[970541.428235717,8],[970541.613396139,15],[970541.794433728,16],[970542.007080043,27],[970542.245922903,4],[970542.403403298,8],[970542.590628981,25],[970542.773048852,18],[970542.922908032,13],[970543.107270741,55],[970543.257494554,11],[970543.448751461,10],[970543.636384867,11],[970543.785077391,15],[970543.934477704,17],[970544.084896172,14],[970544.298672432,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-b5a9b328e7511b7227802bbf13cf30de","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.122300257,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.701995455,"time_to_first_token":0.212220106,"token_sha":"8a91591c94a3","tokens_per_second":18.61042800937055},"seed":1234,"sent":970530.380694893,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21756835107225925,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":2,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.610744492619,"done":970544.299090337,"finish_reason":"length","first":970530.597236529,"full_response_s":13.917680197977461,"last":970544.298998976,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970530.597236529,3],[970530.747156567,11],[970530.932251024,30],[970531.112610601,19],[970531.296764609,21],[970531.480982805,15],[970531.630063485,19],[970531.774694229,17],[970531.956574292,12],[970532.1396951,5],[970532.315358769,5],[970532.496363862,27],[970532.684187071,12],[970532.860979265,13],[970533.042426282,5],[970533.225838087,16],[970533.420016303,5],[970533.59879817,14],[970533.779935543,9],[970533.962530186,27],[970534.110442871,11],[970534.29960542,8],[970534.451090904,16],[970534.598858152,5],[970534.749264384,9],[970534.93165866,14],[970535.075970663,20],[970535.259852665,12],[970535.416377771,8],[970535.5632421,5],[970535.711920832,14],[970535.893538183,14],[970536.075345678,8],[970536.262039331,13],[970536.439108761,3],[970536.621742882,10],[970536.771299557,11],[970536.951647066,9],[970537.136190342,10],[970537.325274539,20],[970537.51452632,14],[970537.691513365,14],[970537.922857441,13],[970538.1059648,5],[970538.294764488,22],[970538.526444506,3],[970538.762086114,32],[970538.949436651,33],[970539.131798871,11],[970539.321088265,6],[970539.49351381,8],[970539.643182806,9],[970539.792617036,13],[970539.939778935,8],[970540.090113462,20],[970540.237548176,17],[970540.432060566,20],[970540.579921667,13],[970540.755158433,6],[970540.938199567,13],[970541.086021262,9],[970541.273119181,11],[970541.426674742,8],[970541.611348606,15],[970541.797393007,16],[970542.006926461,27],[970542.247026781,4],[970542.402754644,8],[970542.590275841,25],[970542.773754717,18],[970542.92240123,13],[970543.108195368,55],[970543.25639967,11],[970543.448836469,10],[970543.633346471,11],[970543.782286851,15],[970543.933788819,17],[970544.084125367,14],[970544.298998976,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-d88a86155ebb01c9ccdd21d5c02612ce","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.122338119,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.702292168,"time_to_first_token":0.211537923,"token_sha":"8a91591c94a3","tokens_per_second":18.610025014319927},"seed":1234,"sent":970530.381410139,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21582638996187598,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":3,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.61698538746495,"done":970544.296285683,"finish_reason":"length","first":970530.599068796,"full_response_s":13.915412515052594,"last":970544.296238058,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970530.599068796,3],[970530.74853236,11],[970530.93005443,30],[970531.113058018,19],[970531.29788515,21],[970531.48081674,15],[970531.627221227,19],[970531.774983742,17],[970531.957596046,12],[970532.140367937,5],[970532.315671135,5],[970532.497652389,27],[970532.683444988,12],[970532.863190645,13],[970533.044901138,5],[970533.225035864,16],[970533.419600397,5],[970533.59885919,14],[970533.78008442,9],[970533.961754385,27],[970534.110658721,11],[970534.30013626,8],[970534.451311059,16],[970534.598991971,5],[970534.746964139,9],[970534.930589282,14],[970535.079358577,20],[970535.260093992,12],[970535.418169691,8],[970535.563742454,5],[970535.711341919,14],[970535.893512786,14],[970536.076065035,8],[970536.261307252,13],[970536.439476161,3],[970536.623349374,10],[970536.77004331,11],[970536.954671658,9],[970537.136097348,10],[970537.326566808,20],[970537.510055541,14],[970537.693802869,14],[970537.922516238,13],[970538.105733315,5],[970538.295428746,22],[970538.526536748,3],[970538.763890786,32],[970538.948540092,33],[970539.131864595,11],[970539.320015687,6],[970539.494174963,8],[970539.643279929,9],[970539.791740673,13],[970539.939206008,8],[970540.088423053,20],[970540.238774175,17],[970540.431164183,20],[970540.580034409,13],[970540.755336851,6],[970540.938096971,13],[970541.087531748,9],[970541.274597404,11],[970541.427533933,8],[970541.611263677,15],[970541.795290583,16],[970542.008163261,27],[970542.246537423,4],[970542.403839879,8],[970542.58961488,25],[970542.772730598,18],[970542.925028794,13],[970543.107840003,55],[970543.257402712,11],[970543.449386064,10],[970543.634330677,11],[970543.783167726,15],[970543.933260973,17],[970544.082962694,14],[970544.296238058,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-2d36210f38678d80f5c921aa92d2f133","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.122187114,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.699443346,"time_to_first_token":0.212491873,"token_sha":"8a91591c94a3","tokens_per_second":18.61389499993484},"seed":1234,"sent":970530.380873168,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21819562802556902,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":4,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.612844212001402,"done":970544.299216298,"finish_reason":"length","first":970530.598922383,"full_response_s":13.916159705026075,"last":970544.299139131,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970530.598922383,3],[970530.747440287,11],[970530.931213155,30],[970531.114651245,19],[970531.297439014,21],[970531.482330272,15],[970531.629606483,19],[970531.773153316,17],[970531.95779439,12],[970532.137243223,5],[970532.314933341,5],[970532.496511092,27],[970532.679537368,12],[970532.863499458,13],[970533.043847378,5],[970533.226087256,16],[970533.417576382,5],[970533.596821701,14],[970533.779568974,9],[970533.962331587,27],[970534.111706383,11],[970534.299780894,8],[970534.451152628,16],[970534.59878745,5],[970534.745795381,9],[970534.933759313,14],[970535.078594875,20],[970535.259902706,12],[970535.418487946,8],[970535.563418982,5],[970535.713274554,14],[970535.893455879,14],[970536.076615255,8],[970536.261201951,13],[970536.441440947,3],[970536.621505988,10],[970536.770575543,11],[970536.953411027,9],[970537.134802934,10],[970537.325568676,20],[970537.511612374,14],[970537.691695448,14],[970537.92346868,13],[970538.105109337,5],[970538.29548274,22],[970538.527118221,3],[970538.762682118,32],[970538.950050323,33],[970539.131290499,11],[970539.320589207,6],[970539.494079024,8],[970539.641230697,9],[970539.791471596,13],[970539.938654204,8],[970540.088476455,20],[970540.238189309,17],[970540.431506058,20],[970540.57936111,13],[970540.753121236,6],[970540.937502055,13],[970541.087167101,9],[970541.274403494,11],[970541.425352325,8],[970541.614505923,15],[970541.795731772,16],[970542.007394392,27],[970542.246933787,4],[970542.403175814,8],[970542.588498584,25],[970542.773540659,18],[970542.923234527,13],[970543.107657023,55],[970543.256495224,11],[970543.448230464,10],[970543.633815842,11],[970543.782073018,15],[970543.933915195,17],[970544.082242603,14],[970544.299139131,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-48189cdcdbbcc61528931cc1ee01f955","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.122417336,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.702297032,"time_to_first_token":0.210748806,"token_sha":"8a91591c94a3","tokens_per_second":18.610018408189475},"seed":1234,"sent":970530.383056593,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21586579002905637,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":5,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.614617016893476,"done":970544.296016607,"finish_reason":"length","first":970530.597052316,"full_response_s":13.914691140991636,"last":970544.295964293,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970530.597052316,3],[970530.747766144,11],[970530.930796272,30],[970531.114404652,19],[970531.298070931,21],[970531.480879889,15],[970531.62851265,19],[970531.774200339,17],[970531.957101677,12],[970532.139428023,5],[970532.315511792,5],[970532.498021966,27],[970532.67991301,12],[970532.862551191,13],[970533.04447739,5],[970533.226338473,16],[970533.418186006,5],[970533.597859729,14],[970533.779991682,9],[970533.963942832,27],[970534.111020633,11],[970534.299692701,8],[970534.44998347,16],[970534.597434272,5],[970534.747115833,9],[970534.929219525,14],[970535.07574185,20],[970535.259602552,12],[970535.417354123,8],[970535.56153346,5],[970535.710060467,14],[970535.892680751,14],[970536.076763556,8],[970536.261471588,13],[970536.439308176,3],[970536.622349065,10],[970536.769607817,11],[970536.95458132,9],[970537.13560802,10],[970537.325487924,20],[970537.512897425,14],[970537.694935715,14],[970537.921430314,13],[970538.106078758,5],[970538.294572274,22],[970538.525677972,3],[970538.763596585,32],[970538.945960005,33],[970539.130992665,11],[970539.320455693,6],[970539.493355923,8],[970539.641828318,9],[970539.790603507,13],[970539.937920366,8],[970540.08745056,20],[970540.237848218,17],[970540.430821557,20],[970540.579252416,13],[970540.752958132,6],[970540.938263947,13],[970541.085139907,9],[970541.27166213,11],[970541.425799548,8],[970541.609737861,15],[970541.795479179,16],[970542.005844651,27],[970542.24546427,4],[970542.404183161,8],[970542.591702645,25],[970542.773710692,18],[970542.924329091,13],[970543.108772151,55],[970543.256593515,11],[970543.449114315,10],[970543.633132285,11],[970543.782757246,15],[970543.934849856,17],[970544.08235981,14],[970544.295964293,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-99ccf39dd3b621637746541da4fb5f35","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.121969022,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.699514945,"time_to_first_token":0.213338056,"token_sha":"8a91591c94a3","tokens_per_second":18.613797716470902},"seed":1234,"sent":970530.381325466,"speculative":{"acceptance_rate":0.3950892857142857,"accepted":177,"drafted":448,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21572684997227043,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":448,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":6,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.612149833457206,"done":970544.300000209,"finish_reason":"length","first":970530.598326697,"full_response_s":13.917193184955977,"last":970544.29905457,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970530.598326697,3],[970530.747831165,11],[970530.929585153,30],[970531.112319151,19],[970531.298715123,21],[970531.481962599,15],[970531.627030645,19],[970531.775448426,17],[970531.958456712,12],[970532.140562487,5],[970532.316451913,5],[970532.497406821,27],[970532.678868596,12],[970532.861133807,13],[970533.043221623,5],[970533.224943846,16],[970533.415258468,5],[970533.598327518,14],[970533.777899893,9],[970533.961979133,27],[970534.111541903,11],[970534.299975173,8],[970534.452491228,16],[970534.598265604,5],[970534.748822041,9],[970534.932321622,14],[970535.077831717,20],[970535.260518475,12],[970535.417040349,8],[970535.562258802,5],[970535.712878429,14],[970535.892516014,14],[970536.075657547,8],[970536.261132706,13],[970536.440738617,3],[970536.623641959,10],[970536.769672406,11],[970536.951961431,9],[970537.136025718,10],[970537.326905994,20],[970537.513346729,14],[970537.690807611,14],[970537.922917692,13],[970538.104983616,5],[970538.295135744,22],[970538.527903607,3],[970538.763044381,32],[970538.947139403,33],[970539.131518432,11],[970539.321919595,6],[970539.494885518,8],[970539.641989613,9],[970539.79133837,13],[970539.940543948,8],[970540.089355122,20],[970540.238647414,17],[970540.433141816,20],[970540.581723217,13],[970540.754115077,6],[970540.937326341,13],[970541.088586001,9],[970541.273323108,11],[970541.42502743,8],[970541.611546468,15],[970541.797029336,16],[970542.005761627,27],[970542.247255242,4],[970542.405929052,8],[970542.589679069,25],[970542.773615746,18],[970542.922959338,13],[970543.106852532,55],[970543.25655498,11],[970543.451445726,10],[970543.634157812,11],[970543.782923374,15],[970543.933301797,17],[970544.082462822,14],[970544.29905457,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-e3638aa533f8eadcba7619a14beb745f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.122378128,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.702298633,"time_to_first_token":0.211042497,"token_sha":"8a91591c94a3","tokens_per_second":18.610016233763105},"seed":1234,"sent":970530.382807024,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2155196729581803,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":7,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.3316980864908,"done":970544.297634888,"finish_reason":"length","first":970530.387197303,"full_response_s":13.916106469929218,"last":970544.297528948,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970530.387197303,3],[970530.474767375,26],[970530.749290574,15],[970530.930612684,19],[970531.111765282,21],[970531.296694371,15],[970531.482797308,19],[970531.627140443,17],[970531.774361027,6],[970531.95555073,11],[970532.139156193,5],[970532.313376186,18],[970532.49624067,21],[970532.679819104,5],[970532.861316611,8],[970533.042342233,5],[970533.226606206,16],[970533.415635711,5],[970533.598690245,14],[970533.779066299,9],[970533.96143477,27],[970534.109992878,11],[970534.29944198,8],[970534.452353632,16],[970534.597298805,5],[970534.747481665,9],[970534.928569461,14],[970535.078863759,20],[970535.260159125,12],[970535.418853058,8],[970535.562834163,5],[970535.711738621,14],[970535.893160957,14],[970536.076523477,8],[970536.260647842,13],[970536.442705691,3],[970536.623028783,10],[970536.76880966,11],[970536.95382282,9],[970537.135690916,10],[970537.325736693,20],[970537.508787741,14],[970537.691839333,14],[970537.921869039,13],[970538.10771687,5],[970538.295560339,22],[970538.526325715,3],[970538.762282488,32],[970538.947652511,33],[970539.133065918,11],[970539.321699248,6],[970539.495715456,8],[970539.642137802,9],[970539.790924626,13],[970539.938906958,8],[970540.087829673,20],[970540.237406132,17],[970540.431058915,20],[970540.579978334,13],[970540.753528435,6],[970540.938910201,13],[970541.085665177,9],[970541.271565135,11],[970541.426818114,8],[970541.613025411,15],[970541.795104787,16],[970542.006998411,27],[970542.245355241,4],[970542.402606696,8],[970542.59132446,25],[970542.773672237,18],[970542.924617787,13],[970543.109448154,55],[970543.256129009,11],[970543.450588985,10],[970543.633568642,11],[970543.781926798,15],[970543.932866769,17],[970544.08351813,14],[970544.297528948,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-d66560e35ea36145ee6516df376f90e9","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.0033888,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.9087483,"time_to_first_token":0.004017501,"token_sha":"8a91591c94a3","tokens_per_second":18.333784931603084},"seed":1234,"sent":970530.381528418,"speculative":{"acceptance_rate":0.38095238095238093,"accepted":176,"drafted":462,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.005668884958140552,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":462,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":8,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.61463668606205,"done":970544.297699781,"finish_reason":"length","first":970530.598773105,"full_response_s":13.91690768499393,"last":970544.297670607,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970530.598773105,3],[970530.748085631,11],[970530.931929185,30],[970531.113401686,19],[970531.296965224,21],[970531.481774498,15],[970531.626880151,19],[970531.773860656,17],[970531.954580875,12],[970532.14159802,5],[970532.314848973,5],[970532.496601317,27],[970532.678741419,12],[970532.86076367,13],[970533.042828009,5],[970533.224842338,16],[970533.418632014,5],[970533.599307711,14],[970533.779472075,9],[970533.961856741,27],[970534.111311698,11],[970534.300049331,8],[970534.451232996,16],[970534.598931975,5],[970534.746393643,9],[970534.933244428,14],[970535.07618128,20],[970535.260239221,12],[970535.417847564,8],[970535.563896996,5],[970535.713760026,14],[970535.892224901,14],[970536.077921159,8],[970536.262587295,13],[970536.439217118,3],[970536.62358526,10],[970536.769415811,11],[970536.951867909,9],[970537.13498457,10],[970537.325430473,20],[970537.508903555,14],[970537.691159648,14],[970537.92376597,13],[970538.107557271,5],[970538.29471251,22],[970538.526265879,3],[970538.763140079,32],[970538.948044172,33],[970539.131740219,11],[970539.321159847,6],[970539.493227178,8],[970539.641158603,9],[970539.791684566,13],[970539.939468107,8],[970540.087694399,20],[970540.238154854,17],[970540.430945549,20],[970540.580411538,13],[970540.754644829,6],[970540.937948398,13],[970541.088852853,9],[970541.272265799,11],[970541.427883697,8],[970541.610508154,15],[970541.794139255,16],[970542.005994824,27],[970542.246169735,4],[970542.404982612,8],[970542.590715094,25],[970542.772194542,18],[970542.922025765,13],[970543.107911985,55],[970543.256023917,11],[970543.450982437,10],[970543.635255992,11],[970543.784694693,15],[970543.933482296,17],[970544.084243262,14],[970544.297670607,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-908ee4de00f23ae8d7288990ba167c57","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.122053664,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.699497245,"time_to_first_token":0.213776031,"token_sha":"8a91591c94a3","tokens_per_second":18.613821765836633},"seed":1234,"sent":970530.380792096,"speculative":{"acceptance_rate":0.3968609865470852,"accepted":177,"drafted":446,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21798100892920047,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":446,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":9,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.613580905368273,"done":970544.298149851,"finish_reason":"length","first":970530.598391574,"full_response_s":13.916883885045536,"last":970544.298066091,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970530.598391574,3],[970530.749550562,11],[970530.932365031,30],[970531.11352707,19],[970531.299194914,21],[970531.481306901,15],[970531.628048863,19],[970531.775084834,17],[970531.956660405,12],[970532.138257248,5],[970532.313712844,5],[970532.496918084,27],[970532.680224704,12],[970532.862898459,13],[970533.044982274,5],[970533.225655283,16],[970533.41906706,5],[970533.597678206,14],[970533.778769681,9],[970533.963103019,27],[970534.110953755,11],[970534.299079332,8],[970534.452071337,16],[970534.599331813,5],[970534.74687721,9],[970534.930309883,14],[970535.077607657,20],[970535.259966639,12],[970535.417494791,8],[970535.563296222,5],[970535.710967061,14],[970535.891816741,14],[970536.075130804,8],[970536.261899352,13],[970536.441167629,3],[970536.622403828,10],[970536.769854377,11],[970536.953717135,9],[970537.138534417,10],[970537.326276447,20],[970537.510510014,14],[970537.691394862,14],[970537.924299482,13],[970538.107477672,5],[970538.295912744,22],[970538.527662888,3],[970538.76217834,32],[970538.946531141,33],[970539.130785969,11],[970539.320781709,6],[970539.495063344,8],[970539.641420878,9],[970539.79205683,13],[970539.939854822,8],[970540.088310615,20],[970540.238608014,17],[970540.432180237,20],[970540.579760195,13],[970540.755241329,6],[970540.939168731,13],[970541.085468371,9],[970541.273416439,11],[970541.428899254,8],[970541.612665549,15],[970541.796526183,16],[970542.007853249,27],[970542.247665033,4],[970542.4048985,8],[970542.58894211,25],[970542.773272447,18],[970542.922195814,13],[970543.107456025,55],[970543.25705434,11],[970543.448644176,10],[970543.636571015,11],[970543.782172189,15],[970543.933733624,17],[970544.084566204,14],[970544.298066091,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-f03b6de97c2b46c56f7dd970e7bf5223","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.122262281,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.70142008,"time_to_first_token":0.212108836,"token_sha":"8a91591c94a3","tokens_per_second":18.611209532377174},"seed":1234,"sent":970530.381265966,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2171256080036983,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":10,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.614248029989213,"done":970544.297384904,"finish_reason":"length","first":970530.598179388,"full_response_s":13.915741374948993,"last":970544.297362916,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970530.598179388,3],[970530.748765766,11],[970530.929851573,30],[970531.111896924,19],[970531.299283219,21],[970531.481084025,15],[970531.629757569,19],[970531.774140471,17],[970531.958799836,12],[970532.141215304,5],[970532.315728875,5],[970532.496697128,27],[970532.681414075,12],[970532.861988504,13],[970533.044394206,5],[970533.226551875,16],[970533.413780657,5],[970533.598137304,14],[970533.781548101,9],[970533.961173167,27],[970534.10970903,11],[970534.30028661,8],[970534.45069489,16],[970534.5980667,5],[970534.746433091,9],[970534.927870508,14],[970535.079896554,20],[970535.260664888,12],[970535.416636782,8],[970535.561742109,5],[970535.714148022,14],[970535.892583451,14],[970536.075961815,8],[970536.260767418,13],[970536.441859141,3],[970536.622490309,10],[970536.771228439,11],[970536.950877011,9],[970537.136325472,10],[970537.327180544,20],[970537.508972209,14],[970537.69262251,14],[970537.921342793,13],[970538.105187992,5],[970538.295190827,22],[970538.526209356,3],[970538.762517142,32],[970538.946923185,33],[970539.131701251,11],[970539.320206541,6],[970539.493848963,8],[970539.643084979,9],[970539.792274777,13],[970539.938070491,8],[970540.088864131,20],[970540.237976083,17],[970540.432244794,20],[970540.582509434,13],[970540.754698519,6],[970540.936731442,13],[970541.085858911,9],[970541.273182569,11],[970541.428519565,8],[970541.611600094,15],[970541.795678354,16],[970542.006793635,27],[970542.247527759,4],[970542.403785052,8],[970542.58826417,25],[970542.77382353,18],[970542.922996721,13],[970543.107190613,55],[970543.256259419,11],[970543.44895374,10],[970543.636490231,11],[970543.782667821,15],[970543.932708034,17],[970544.083178512,14],[970544.297362916,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-f2a16f7e4b93eef76d7bb61661c74bee","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.12201564,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.699572092,"time_to_first_token":0.21373119,"token_sha":"8a91591c94a3","tokens_per_second":18.61372007005312},"seed":1234,"sent":970530.381643529,"speculative":{"acceptance_rate":0.3959731543624161,"accepted":177,"drafted":447,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2165358589263633,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":447,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":11,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.61068657328784,"done":970544.300336466,"finish_reason":"length","first":970530.598452098,"full_response_s":13.917184414109215,"last":970544.300257187,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970530.598452098,3],[970530.747344892,11],[970530.929224313,30],[970531.112569329,19],[970531.29647884,21],[970531.481401752,15],[970531.628585881,19],[970531.774798586,17],[970531.956136142,12],[970532.13751851,5],[970532.313912116,5],[970532.49775761,18],[970532.681922575,21],[970532.861737206,9],[970533.043758641,9],[970533.226924685,16],[970533.414924019,5],[970533.596557521,14],[970533.779853286,9],[970533.964421518,27],[970534.11148322,11],[970534.300097581,8],[970534.45241166,16],[970534.597990829,5],[970534.74840135,9],[970534.93123248,14],[970535.080029557,20],[970535.260965667,12],[970535.416253203,8],[970535.561596304,5],[970535.7120217,14],[970535.892104686,14],[970536.077704493,8],[970536.261068549,13],[970536.442145549,3],[970536.623814265,10],[970536.771698915,11],[970536.95493867,9],[970537.135307193,10],[970537.325069874,20],[970537.510745756,14],[970537.6941466,14],[970537.922023085,13],[970538.107268543,5],[970538.294306622,22],[970538.526915062,3],[970538.762592132,32],[970538.948354632,33],[970539.132784375,11],[970539.320508344,6],[970539.495372189,8],[970539.641712615,9],[970539.791163968,13],[970539.938155099,8],[970540.089223513,20],[970540.237707071,17],[970540.432491258,20],[970540.58225076,13],[970540.756031162,6],[970540.937386833,13],[970541.086605504,9],[970541.27403219,11],[970541.426168468,8],[970541.611718597,15],[970541.796305388,16],[970542.006638229,27],[970542.24673983,4],[970542.403637488,8],[970542.588423561,25],[970542.774366468,18],[970542.922836834,13],[970543.108801853,55],[970543.25713322,11],[970543.44955456,10],[970543.634411173,11],[970543.785163872,15],[970543.933830907,17],[970544.083456374,14],[970544.300257187,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-b19515d035f0d59fd277156baea9252d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.122493175,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.703399965,"time_to_first_token":0.209002444,"token_sha":"8a91591c94a3","tokens_per_second":18.60852056068554},"seed":1234,"sent":970530.383152052,"speculative":{"acceptance_rate":0.40503432494279173,"accepted":177,"drafted":437,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21530004602391273,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":437,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":12,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.613469156673908,"done":970544.296898842,"finish_reason":"length","first":970530.59710455,"full_response_s":13.914334681932814,"last":970544.296861315,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970530.59710455,3],[970530.747653754,11],[970530.931075672,30],[970531.112024133,19],[970531.297103924,21],[970531.48240211,15],[970531.628932894,19],[970531.774611765,17],[970531.958097585,12],[970532.138381992,5],[970532.314735318,5],[970532.497090614,27],[970532.679732127,12],[970532.86227312,13],[970533.042498888,5],[970533.225068815,16],[970533.415398928,5],[970533.598244461,14],[970533.781246105,9],[970533.962482817,27],[970534.111893364,11],[970534.300353583,8],[970534.450929896,16],[970534.598342547,5],[970534.748071253,9],[970534.932729671,14],[970535.078224962,20],[970535.260611214,12],[970535.416842198,8],[970535.563545663,5],[970535.709926088,14],[970535.893877529,14],[970536.075692514,8],[970536.262527619,13],[970536.440485703,3],[970536.622881714,10],[970536.769761687,11],[970536.953068352,9],[970537.138266156,10],[970537.325863102,20],[970537.512506213,14],[970537.692289565,14],[970537.923202084,13],[970538.107117249,5],[970538.296076072,22],[970538.527971172,3],[970538.763480482,32],[970538.949654118,33],[970539.132113348,11],[970539.320867214,6],[970539.494553741,8],[970539.642567134,9],[970539.792405874,13],[970539.938328621,8],[970540.089267361,20],[970540.238284591,17],[970540.431849405,20],[970540.579108949,13],[970540.753790374,6],[970540.938034703,13],[970541.085922475,9],[970541.272978497,11],[970541.428718995,8],[970541.614893198,15],[970541.795406477,16],[970542.007932016,27],[970542.246370574,4],[970542.405468211,8],[970542.589315334,25],[970542.774062921,18],[970542.922594963,13],[970543.108140541,55],[970543.255482852,11],[970543.4501702,10],[970543.634987956,11],[970543.78281625,15],[970543.933427245,17],[970544.085261667,14],[970544.296861315,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-e9d3178bfc758c166bda220e1db8ddf3","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.122136191,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.699617796,"time_to_first_token":0.2128285,"token_sha":"8a91591c94a3","tokens_per_second":18.61365797186361},"seed":1234,"sent":970530.38256416,"speculative":{"acceptance_rate":0.39954853273137697,"accepted":177,"drafted":443,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21454038994852453,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":443,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":13,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.60919024384041,"done":970544.302588741,"finish_reason":"length","first":970530.597842297,"full_response_s":13.918123147916049,"last":970544.300749122,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970530.597842297,3],[970530.746993895,11],[970530.929437859,30],[970531.111544294,19],[970531.297963262,21],[970531.482596596,15],[970531.628680524,19],[970531.773651591,17],[970531.956334645,12],[970532.139792079,5],[970532.314396691,5],[970532.498090828,18],[970532.67854418,21],[970532.862680096,9],[970533.043679249,9],[970533.226799812,16],[970533.414638314,5],[970533.599017878,14],[970533.778509101,9],[970533.961661647,27],[970534.111748392,11],[970534.300590654,8],[970534.450373227,16],[970534.598417857,5],[970534.74829741,9],[970534.93351288,14],[970535.077110695,20],[970535.2609279,12],[970535.415041685,8],[970535.562400846,5],[970535.712764806,14],[970535.89359781,14],[970536.077626141,8],[970536.262086333,13],[970536.439897652,3],[970536.621325137,10],[970536.770298832,11],[970536.952332432,9],[970537.136760309,10],[970537.326057492,20],[970537.509634659,14],[970537.695463434,14],[970537.924037415,13],[970538.10615967,5],[970538.294212332,22],[970538.527773837,3],[970538.762800413,32],[970538.946734988,33],[970539.132287782,11],[970539.320363355,6],[970539.494310782,8],[970539.641765761,9],[970539.792509127,13],[970539.938389513,8],[970540.088127219,20],[970540.238247624,17],[970540.43270093,20],[970540.578942836,13],[970540.756412117,6],[970540.937440908,13],[970541.086099774,9],[970541.273046079,11],[970541.427084326,8],[970541.612362323,15],[970541.794693539,16],[970542.006867762,27],[970542.245563714,4],[970542.404347881,8],[970542.588709457,25],[970542.774316266,18],[970542.923350726,13],[970543.109364874,55],[970543.256317254,11],[970543.448375052,10],[970543.634071219,11],[970543.783747102,15],[970543.933092204,17],[970544.082825788,14],[970544.300749122,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-31686f6d17fdccf9bfe52f696144243a","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.122548018,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.70381963,"time_to_first_token":0.20880194,"token_sha":"8a91591c94a3","tokens_per_second":18.607950694400667},"seed":1234,"sent":970530.384465593,"speculative":{"acceptance_rate":0.40503432494279173,"accepted":177,"drafted":437,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.213376704021357,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":437,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":14,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.616527929667402,"done":970544.296699491,"finish_reason":"length","first":970530.599162719,"full_response_s":13.913215468986891,"last":970544.296668557,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970530.599162719,3],[970530.749015016,11],[970530.931775106,30],[970531.114574414,19],[970531.296611858,21],[970531.480747286,15],[970531.6277754,19],[970531.773946081,17],[970531.95938512,12],[970532.140640902,5],[970532.316247473,5],[970532.497354378,27],[970532.680712496,12],[970532.862451219,13],[970533.044089858,5],[970533.22555147,16],[970533.41662333,5],[970533.598065962,14],[970533.779399309,9],[970533.964617893,27],[970534.111971092,11],[970534.298901569,8],[970534.451834682,16],[970534.598173825,5],[970534.747769098,9],[970534.930997506,14],[970535.079087675,20],[970535.260349226,12],[970535.414653656,8],[970535.561070393,5],[970535.711453349,14],[970535.893105154,14],[970536.077322834,8],[970536.260835815,13],[970536.442396254,3],[970536.621864698,10],[970536.770523677,11],[970536.954170968,9],[970537.137659813,10],[970537.327448548,20],[970537.509067636,14],[970537.692399506,14],[970537.923516257,13],[970538.106287567,5],[970538.295047775,22],[970538.527840923,3],[970538.762965501,32],[970538.950347981,33],[970539.131625797,11],[970539.321521709,6],[970539.49361791,8],[970539.640988538,9],[970539.792019543,13],[970539.938483963,8],[970540.088747116,20],[970540.237783838,17],[970540.431962899,20],[970540.579426562,13],[970540.754041927,6],[970540.938807781,13],[970541.086789876,9],[970541.273942381,11],[970541.426428038,8],[970541.613836913,15],[970541.79625677,16],[970542.007498396,27],[970542.245989908,4],[970542.405630834,8],[970542.590065384,25],[970542.772967124,18],[970542.923288553,13],[970543.109282186,55],[970543.256664393,11],[970543.451296882,10],[970543.633666933,11],[970543.783266193,15],[970543.935441426,17],[970544.083758,14],[970544.296668557,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-745f7fd5a047de43abf0decf7f41d448","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.122224465,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.6997371,"time_to_first_token":0.212336194,"token_sha":"8a91591c94a3","tokens_per_second":18.61349587504128},"seed":1234,"sent":970530.383484022,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21567869698628783,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":15,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.613946408995133,"done":970544.296982138,"finish_reason":"length","first":970530.597540509,"full_response_s":13.916368604986928,"last":970544.296946019,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970530.597540509,3],[970530.747620483,11],[970530.931417595,30],[970531.11209874,19],[970531.297548924,21],[970531.481675342,15],[970531.626611618,19],[970531.774321339,17],[970531.954681678,12],[970532.13787666,5],[970532.313988035,5],[970532.497825511,27],[970532.680357594,12],[970532.862630502,13],[970533.043089661,5],[970533.224984398,16],[970533.414159644,5],[970533.597206513,14],[970533.778291538,9],[970533.961274899,27],[970534.110205048,11],[970534.299350298,8],[970534.450551966,16],[970534.597553655,5],[970534.746115636,9],[970534.927787563,14],[970535.079730154,20],[970535.261053141,12],[970535.416112311,8],[970535.563352105,5],[970535.711830239,14],[970535.894381212,14],[970536.077120298,8],[970536.262317114,13],[970536.439268232,3],[970536.622553153,10],[970536.770894485,11],[970536.950963556,9],[970537.136920405,10],[970537.325687067,20],[970537.513473874,14],[970537.692459902,14],[970537.921606524,13],[970538.104888014,5],[970538.295650117,22],[970538.526759303,3],[970538.762864442,32],[970538.947720428,33],[970539.131568858,11],[970539.320303952,6],[970539.49391456,8],[970539.641493612,9],[970539.791818976,13],[970539.938818572,8],[970540.088541252,20],[970540.23870901,17],[970540.433082861,20],[970540.580090836,13],[970540.754541688,6],[970540.939061014,13],[970541.0862579,9],[970541.273870975,11],[970541.429075433,8],[970541.610795874,15],[970541.796733263,16],[970542.007796838,27],[970542.246987862,4],[970542.403523161,8],[970542.58902675,25],[970542.77281167,18],[970542.922767013,13],[970543.107061388,55],[970543.256906488,11],[970543.448892096,10],[970543.635957088,11],[970543.783857427,15],[970543.932519742,17],[970544.082103857,14],[970544.296946019,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-f1c489c35a122be9911a6f369151a8f0","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.122091831,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.699606803,"time_to_first_token":0.21298693,"token_sha":"8a91591c94a3","tokens_per_second":18.613672908054482},"seed":1234,"sent":970530.380613533,"speculative":{"acceptance_rate":0.39954853273137697,"accepted":177,"drafted":443,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2169269759906456,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":443,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.52932226793004,"done":970558.224158438,"finish_reason":"length","first":970544.462091908,"full_response_s":13.907625163090415,"last":970558.22406314,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970544.462091908,3],[970544.612707487,11],[970544.793675809,30],[970544.977726586,19],[970545.159714352,21],[970545.351632384,15],[970545.499802316,19],[970545.646149961,17],[970545.830149451,12],[970546.013363547,5],[970546.183040093,5],[970546.375517891,27],[970546.560459264,12],[970546.741919774,13],[970546.925760957,5],[970547.110329022,16],[970547.29575823,5],[970547.483187405,14],[970547.667047191,9],[970547.851564704,27],[970547.999484684,11],[970548.184798282,8],[970548.339179421,16],[970548.49267559,5],[970548.639045081,9],[970548.821917855,14],[970548.970572499,20],[970549.155351336,12],[970549.306029615,8],[970549.45849502,5],[970549.606906193,14],[970549.790575042,14],[970549.973017038,8],[970550.158655381,13],[970550.339969491,3],[970550.522424042,10],[970550.671470947,11],[970550.853781168,9],[970551.037755079,10],[970551.223416705,20],[970551.416276999,14],[970551.596045901,14],[970551.830796383,13],[970552.012120893,5],[970552.198273154,22],[970552.438770942,3],[970552.674477754,32],[970552.859759959,33],[970553.044720855,11],[970553.22934804,6],[970553.413658972,8],[970553.562387001,9],[970553.709317185,13],[970553.856596666,8],[970554.007025125,20],[970554.155778962,17],[970554.347187639,20],[970554.497471462,13],[970554.671232921,6],[970554.854129536,13],[970555.005172522,9],[970555.191076873,11],[970555.347601488,8],[970555.534415964,15],[970555.719061245,16],[970555.931665838,27],[970556.171093242,4],[970556.328388123,8],[970556.516719011,25],[970556.700976329,18],[970556.849157235,13],[970557.032741946,55],[970557.18298685,11],[970557.377670549,10],[970557.562574932,11],[970557.710304194,15],[970557.86126099,17],[970558.011142093,14],[970558.22406314,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-bf369ae6624d0a30ae9782588da2113c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050472695,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.763516714,"time_to_first_token":0.141997033,"token_sha":"8a91591c94a3","tokens_per_second":18.527241641710553},"seed":1234,"sent":970544.316533275,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14555863302666694,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.531137900364296,"done":970558.22197902,"finish_reason":"length","first":970544.46133437,"full_response_s":13.905898408032954,"last":970558.22195724,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970544.46133437,3],[970544.612280028,11],[970544.792953541,30],[970544.976802952,19],[970545.162363198,21],[970545.352918776,15],[970545.499245409,19],[970545.647651882,17],[970545.830915374,12],[970546.0126247,5],[970546.182764024,5],[970546.375904974,27],[970546.559799056,12],[970546.740899081,13],[970546.925489481,5],[970547.111478235,16],[970547.294884718,5],[970547.483047154,14],[970547.666605394,9],[970547.851712828,27],[970547.999435122,11],[970548.183939365,8],[970548.338453954,16],[970548.492950011,5],[970548.638721611,9],[970548.822223482,14],[970548.971724847,20],[970549.155629181,12],[970549.305756331,8],[970549.459525025,5],[970549.608086659,14],[970549.790241346,14],[970549.972429197,8],[970550.157904262,13],[970550.339370576,3],[970550.523730339,10],[970550.672046657,11],[970550.854992278,9],[970551.037151972,10],[970551.225648426,20],[970551.416893725,14],[970551.597667154,14],[970551.831118797,13],[970552.012242404,5],[970552.198732169,22],[970552.436872276,3],[970552.675158363,32],[970552.860195066,33],[970553.04525006,11],[970553.231043146,6],[970553.414277362,8],[970553.561608182,9],[970553.710307389,13],[970553.856851531,8],[970554.006000179,20],[970554.15494434,17],[970554.348075007,20],[970554.497416412,13],[970554.670091665,6],[970554.854784764,13],[970555.004907928,9],[970555.191025727,11],[970555.348061975,8],[970555.531517687,15],[970555.718090453,16],[970555.931289639,27],[970556.171213505,4],[970556.327124381,8],[970556.514559323,25],[970556.701554263,18],[970556.849537931,13],[970557.033446975,55],[970557.183703129,11],[970557.376710944,10],[970557.562811569,11],[970557.710863452,15],[970557.85918492,17],[970558.012029588,14],[970558.22195724,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-1d49e400e7bfaa72c5126e3e7d1990fa","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.05027024,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.759972208,"time_to_first_token":0.142740745,"token_sha":"8a91591c94a3","tokens_per_second":18.53201417454491},"seed":1234,"sent":970544.316080612,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14525375794619322,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.52745896193089,"done":970558.224491205,"finish_reason":"length","first":970544.461097364,"full_response_s":13.907119320007041,"last":970558.224452637,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970544.461097364,3],[970544.613053841,11],[970544.796054444,30],[970544.977476362,19],[970545.162053059,21],[970545.350953917,15],[970545.498318462,19],[970545.648200708,17],[970545.829907196,12],[970546.011102007,5],[970546.182531195,5],[970546.376799242,18],[970546.557546799,21],[970546.741961734,13],[970546.924523551,5],[970547.110960696,16],[970547.295649697,5],[970547.485610447,14],[970547.668482731,9],[970547.850726271,27],[970547.997996975,11],[970548.183330769,8],[970548.340075641,16],[970548.489561553,5],[970548.638946662,9],[970548.824241868,14],[970548.970767512,20],[970549.153451341,12],[970549.30541641,8],[970549.458269313,5],[970549.607986624,14],[970549.78865565,14],[970549.971872419,8],[970550.158724194,13],[970550.338576456,3],[970550.521620832,10],[970550.671689805,11],[970550.854136899,9],[970551.037948556,10],[970551.224368342,20],[970551.413871356,14],[970551.595710637,14],[970551.828935661,13],[970552.013892959,5],[970552.196879209,22],[970552.437643191,3],[970552.673100708,32],[970552.861353174,33],[970553.046086138,11],[970553.229131183,6],[970553.411896446,8],[970553.560665875,9],[970553.70766103,13],[970553.856746551,8],[970554.005961435,20],[970554.154699653,17],[970554.348646812,20],[970554.496058282,13],[970554.669915391,6],[970554.854362284,13],[970555.003481146,9],[970555.190338269,11],[970555.346916686,8],[970555.531110362,15],[970555.716250633,16],[970555.930783143,27],[970556.169938336,4],[970556.32827823,8],[970556.515985369,25],[970556.702164394,18],[970556.849442057,13],[970557.034177608,55],[970557.183372539,11],[970557.377623692,10],[970557.561569175,11],[970557.709957745,15],[970557.859335076,17],[970558.011262676,14],[970558.224452637,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-c7bf5e3d63f3cb87e14a1702582a1795","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050509534,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.763836934,"time_to_first_token":0.141471331,"token_sha":"8a91591c94a3","tokens_per_second":18.526810599600207},"seed":1234,"sent":970544.317371885,"speculative":{"acceptance_rate":0.4022727272727273,"accepted":177,"drafted":440,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14372547902166843,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":440,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.53110750992407,"done":970558.221463083,"finish_reason":"length","first":970544.460776854,"full_response_s":13.905509616015479,"last":970558.221422291,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970544.460776854,3],[970544.611225488,11],[970544.793241741,30],[970544.977508752,19],[970545.158704749,21],[970545.350778795,15],[970545.498104213,19],[970545.645610161,17],[970545.82881585,12],[970546.010834948,5],[970546.182432728,5],[970546.375182051,27],[970546.560544096,12],[970546.741306264,13],[970546.925192544,5],[970547.108520787,16],[970547.295865082,5],[970547.482869248,14],[970547.667476761,9],[970547.851644959,27],[970547.997618022,11],[970548.184215018,8],[970548.341253803,16],[970548.490483906,5],[970548.63990355,9],[970548.821271331,14],[970548.97080832,20],[970549.153906436,12],[970549.305499498,8],[970549.459112882,5],[970549.606544524,14],[970549.788495348,14],[970549.972897543,8],[970550.156216147,13],[970550.340485365,3],[970550.522304659,10],[970550.670081482,11],[970550.855688587,9],[970551.036596714,10],[970551.222174116,20],[970551.413548111,14],[970551.595956524,14],[970551.830553857,13],[970552.012779275,5],[970552.198060073,22],[970552.438075577,3],[970552.67357771,32],[970552.859592759,33],[970553.045133734,11],[970553.229059697,6],[970553.41299187,8],[970553.559943657,9],[970553.710598708,13],[970553.856944412,8],[970554.00568852,20],[970554.154240606,17],[970554.347460251,20],[970554.495639611,13],[970554.671154138,6],[970554.854931096,13],[970555.003578588,9],[970555.190767182,11],[970555.347070812,8],[970555.533318908,15],[970555.716350428,16],[970555.93299028,27],[970556.171314884,4],[970556.32747267,8],[970556.516890579,25],[970556.701297718,18],[970556.850864821,13],[970557.033243384,55],[970557.184476123,11],[970557.37604109,10],[970557.561487063,11],[970557.710911813,15],[970557.859085013,17],[970558.011715833,14],[970558.221422291,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-fa1b29697e33d277fd9c4634fa67c8b2","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.050091822,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.759830758,"time_to_first_token":0.143079226,"token_sha":"8a91591c94a3","tokens_per_second":18.532204682222734},"seed":1234,"sent":970544.315953467,"speculative":{"acceptance_rate":0.3959731543624161,"accepted":177,"drafted":447,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14482338691595942,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":447,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.5314414051316,"done":970558.221371353,"finish_reason":"length","first":970544.460929092,"full_response_s":13.905017248005606,"last":970558.221326593,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970544.460929092,3],[970544.614472163,11],[970544.797024616,30],[970544.976590831,19],[970545.162427883,21],[970545.350557953,15],[970545.498743728,19],[970545.646926446,17],[970545.82927013,12],[970546.011644,5],[970546.183609498,5],[970546.373883241,27],[970546.558311602,12],[970546.741816442,13],[970546.925306869,5],[970547.109406685,16],[970547.29508146,5],[970547.482296738,14],[970547.666478121,9],[970547.850823314,27],[970547.998357876,11],[970548.183445239,8],[970548.339441167,16],[970548.491786396,5],[970548.639597971,9],[970548.821401612,14],[970548.97063139,20],[970549.154816738,12],[970549.306435325,8],[970549.460145576,5],[970549.605714589,14],[970549.789898048,14],[970549.972371458,8],[970550.159860731,13],[970550.338408776,3],[970550.522850667,10],[970550.670208866,11],[970550.854060261,9],[970551.036347787,10],[970551.222293531,20],[970551.417560876,14],[970551.596242178,14],[970551.829813812,13],[970552.013289964,5],[970552.19672846,22],[970552.438272895,3],[970552.673356708,32],[970552.859492116,33],[970553.047486292,11],[970553.229311185,6],[970553.410176727,8],[970553.559792157,9],[970553.709157555,13],[970553.85652238,8],[970554.004716799,20],[970554.15736275,17],[970554.348708743,20],[970554.496266434,13],[970554.669974506,6],[970554.854888656,13],[970555.00447567,9],[970555.19055367,11],[970555.346659614,8],[970555.531596966,15],[970555.717176776,16],[970555.930331842,27],[970556.170253948,4],[970556.327331636,8],[970556.515559384,25],[970556.700707287,18],[970556.849230593,13],[970557.033884721,55],[970557.182700748,11],[970557.376579831,10],[970557.563062032,11],[970557.710195454,15],[970557.859243011,17],[970558.010862073,14],[970558.221326593,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-687c8114986e2d0c0542fd167035058d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050362258,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.759911908,"time_to_first_token":0.142189246,"token_sha":"8a91591c94a3","tokens_per_second":18.532095387307184},"seed":1234,"sent":970544.316354105,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14457498700357974,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.53089770307942,"done":970558.223147912,"finish_reason":"length","first":970544.462193272,"full_response_s":13.906220144941472,"last":970558.222994507,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970544.462193272,3],[970544.611778587,11],[970544.795661232,30],[970544.977678353,19],[970545.160631857,21],[970545.350659028,15],[970545.498813021,19],[970545.649737276,17],[970545.830231819,12],[970546.01311249,5],[970546.18298165,5],[970546.374697189,27],[970546.559381968,12],[970546.741588542,13],[970546.92619672,5],[970547.110067916,16],[970547.296044909,5],[970547.482613039,14],[970547.667530772,9],[970547.849754709,27],[970547.999182562,11],[970548.183668129,8],[970548.338589116,16],[970548.488193291,5],[970548.638250065,9],[970548.820736749,14],[970548.970690425,20],[970549.156271688,12],[970549.306312325,8],[970549.459388519,5],[970549.608716763,14],[970549.791015286,14],[970549.972214949,8],[970550.159359228,13],[970550.340767963,3],[970550.520820552,10],[970550.669112192,11],[970550.855370783,9],[970551.037377327,10],[970551.223890107,20],[970551.413319283,14],[970551.59628153,14],[970551.828519518,13],[970552.012591223,5],[970552.195907936,22],[970552.438473221,3],[970552.673713592,32],[970552.858907413,33],[970553.044825531,11],[970553.228961646,6],[970553.412620327,8],[970553.559142641,9],[970553.707048306,13],[970553.856886817,8],[970554.005188425,20],[970554.155874164,17],[970554.348367207,20],[970554.497136887,13],[970554.669457272,6],[970554.854703805,13],[970555.003745276,9],[970555.190085293,11],[970555.347531363,8],[970555.53097352,15],[970555.717895168,16],[970555.930706217,27],[970556.169598784,4],[970556.328592962,8],[970556.515743451,25],[970556.699711434,18],[970556.848550241,13],[970557.03382471,55],[970557.18278542,11],[970557.376394964,10],[970557.561668393,11],[970557.710511769,15],[970557.859423077,17],[970558.009929913,14],[970558.222994507,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-29970443918644c28a2b54ec891ab83c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050398889,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.762475655,"time_to_first_token":0.142248442,"token_sha":"8a91591c94a3","tokens_per_second":18.528643130231934},"seed":1234,"sent":970544.316927767,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1452655049506575,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.533790407691722,"done":970558.220939,"finish_reason":"length","first":970544.462237425,"full_response_s":13.904919472057372,"last":970558.220890911,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970544.462237425,3],[970544.614210897,11],[970544.797259605,30],[970544.976939314,19],[970545.160798545,21],[970545.352840249,15],[970545.499461194,19],[970545.649492365,17],[970545.829573852,12],[970546.011813344,5],[970546.183399138,5],[970546.374993054,27],[970546.558604363,12],[970546.74095674,13],[970546.925588156,5],[970547.110891691,16],[970547.296205596,5],[970547.484612383,14],[970547.666983963,9],[970547.85111657,27],[970547.998770691,11],[970548.183393101,8],[970548.33883902,16],[970548.490598296,5],[970548.638474796,9],[970548.82438996,14],[970548.97050847,20],[970549.154883663,12],[970549.306092667,8],[970549.459304231,5],[970549.60768615,14],[970549.790800685,14],[970549.973742264,8],[970550.160056321,13],[970550.338093772,3],[970550.52148479,10],[970550.670700464,11],[970550.856616732,9],[970551.038237235,10],[970551.225113764,20],[970551.414860297,14],[970551.59716341,14],[970551.82906279,13],[970552.013429462,5],[970552.198637399,22],[970552.437827018,3],[970552.674559577,32],[970552.862000033,33],[970553.044671182,11],[970553.230353975,6],[970553.410937655,8],[970553.55967407,9],[970553.709950537,13],[970553.856448734,8],[970554.005880108,20],[970554.154344018,17],[970554.347511188,20],[970554.496703301,13],[970554.669839809,6],[970554.85457378,13],[970555.004623026,9],[970555.191156776,11],[970555.346541495,8],[970555.534488057,15],[970555.718049549,16],[970555.931175362,27],[970556.171121632,4],[970556.326818819,8],[970556.515599936,25],[970556.702455233,18],[970556.850765683,13],[970557.032604896,55],[970557.18477021,11],[970557.378433813,10],[970557.562890064,11],[970557.711575218,15],[970557.860194886,17],[970558.010399217,14],[970558.220890911,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-8a6f098753bb10cb8ad75bdc6bea22f5","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.050052998,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.75987115,"time_to_first_token":0.144200867,"token_sha":"8a91591c94a3","tokens_per_second":18.532150281072944},"seed":1234,"sent":970544.316019528,"speculative":{"acceptance_rate":0.3950892857142857,"accepted":177,"drafted":448,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14621789706870914,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":448,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.528937793799873,"done":970558.22389434,"finish_reason":"length","first":970544.461484479,"full_response_s":13.90684157202486,"last":970558.223741271,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970544.461484479,3],[970544.614143316,11],[970544.79470676,30],[970544.978665151,19],[970545.159600634,21],[970545.351089239,15],[970545.498493168,19],[970545.649647739,17],[970545.831536182,12],[970546.012814625,5],[970546.183687865,5],[970546.374272404,27],[970546.559887297,12],[970546.742153675,13],[970546.925272031,5],[970547.111617382,16],[970547.295985201,5],[970547.485256331,14],[970547.66580316,9],[970547.850058463,27],[970547.997829871,11],[970548.182201688,8],[970548.33980847,16],[970548.488901315,5],[970548.637553227,9],[970548.820982156,14],[970548.969256503,20],[970549.153738484,12],[970549.305075784,8],[970549.457727113,5],[970549.605306047,14],[970549.789730944,14],[970549.974404967,8],[970550.158066261,13],[970550.339097116,3],[970550.522053891,10],[970550.668958099,11],[970550.853985494,9],[970551.036897812,10],[970551.222834658,20],[970551.415908817,14],[970551.597272775,14],[970551.831215247,13],[970552.013806382,5],[970552.197680865,22],[970552.435750223,3],[970552.672983133,32],[970552.859194972,33],[970553.047186988,11],[970553.228640865,6],[970553.413253823,8],[970553.562038455,9],[970553.708836582,13],[970553.856811683,8],[970554.006728301,20],[970554.155718631,17],[970554.348227356,20],[970554.496795734,13],[970554.670503695,6],[970554.854218129,13],[970555.004128788,9],[970555.192729298,11],[970555.346426866,8],[970555.532676946,15],[970555.716958863,16],[970555.932148649,27],[970556.170957665,4],[970556.327286603,8],[970556.515320779,25],[970556.70043173,18],[970556.849943191,13],[970557.034420086,55],[970557.185712036,11],[970557.378336563,10],[970557.563455834,11],[970557.710654676,15],[970557.860274469,17],[970558.010808575,14],[970558.223741271,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-8b2474d35f6061d7acfe0c9a76674cad","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050436609,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.763204751,"time_to_first_token":0.142276047,"token_sha":"8a91591c94a3","tokens_per_second":18.52766158851719},"seed":1234,"sent":970544.317052768,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14443171105813235,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.52675504697557,"done":970558.224768073,"finish_reason":"length","first":970544.460811325,"full_response_s":13.908607413992286,"last":970558.22468953,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970544.460811325,3],[970544.612148659,11],[970544.795346132,30],[970544.976160156,19],[970545.161869439,21],[970545.351789662,15],[970545.497856101,19],[970545.648932129,17],[970545.829042326,12],[970546.011515463,5],[970546.182503926,5],[970546.375360485,18],[970546.557892433,21],[970546.742213654,9],[970546.924793171,9],[970547.108760465,16],[970547.295708812,5],[970547.481821559,14],[970547.666358162,9],[970547.849901377,27],[970547.999590496,11],[970548.18503804,8],[970548.341086363,16],[970548.49118348,5],[970548.637688165,9],[970548.821084544,14],[970548.969548559,20],[970549.154987651,12],[970549.305666602,8],[970549.457424831,5],[970549.60730787,14],[970549.788787308,14],[970549.973681261,8],[970550.158311428,13],[970550.339564693,3],[970550.523339753,10],[970550.670500842,11],[970550.854470995,9],[970551.037063331,10],[970551.224299161,20],[970551.415322993,14],[970551.59710972,14],[970551.831526346,13],[970552.013347367,5],[970552.196144733,22],[970552.438413242,3],[970552.674231947,32],[970552.860452619,33],[970553.045594301,11],[970553.23015917,6],[970553.413415518,8],[970553.561254738,9],[970553.708095385,13],[970553.856991317,8],[970554.005268712,20],[970554.154811211,17],[970554.348504961,20],[970554.497218038,13],[970554.670864851,6],[970554.854265882,13],[970555.003848191,9],[970555.19218169,11],[970555.347195811,8],[970555.531665571,15],[970555.719141468,16],[970555.932931565,27],[970556.170778895,4],[970556.327723406,8],[970556.517275388,25],[970556.701641831,18],[970556.850364327,13],[970557.032491515,55],[970557.18307365,11],[970557.377436665,10],[970557.563545355,11],[970557.710968815,15],[970557.86004801,17],[970558.011098469,14],[970558.22468953,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-39db0156be7f1a3d5c1e527b7bf20151","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050547525,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.764029195,"time_to_first_token":0.141718836,"token_sha":"8a91591c94a3","tokens_per_second":18.52655181032548},"seed":1234,"sent":970544.316160659,"speculative":{"acceptance_rate":0.40503432494279173,"accepted":177,"drafted":437,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14465066604316235,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":437,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.53216589072033,"done":970558.22080027,"finish_reason":"length","first":970544.460866264,"full_response_s":13.904411854920909,"last":970558.220725824,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970544.460866264,3],[970544.613423545,11],[970544.793550569,30],[970544.976728026,19],[970545.161960353,21],[970545.351162853,15],[970545.500584931,19],[970545.649114964,17],[970545.830393594,12],[970546.013196491,5],[970546.18308999,5],[970546.375455912,27],[970546.559497174,12],[970546.741067322,13],[970546.925660409,5],[970547.111430754,16],[970547.29592647,5],[970547.482136083,14],[970547.669583838,9],[970547.851280185,27],[970547.998959479,11],[970548.183730829,8],[970548.339308758,16],[970548.491436617,5],[970548.638653694,9],[970548.82369602,14],[970548.971760982,20],[970549.155898993,12],[970549.305217876,8],[970549.460448146,5],[970549.606439784,14],[970549.790036187,14],[970549.973230102,8],[970550.1576863,13],[970550.338865584,3],[970550.522234358,10],[970550.672266171,11],[970550.85418094,9],[970551.03683868,10],[970551.223994479,20],[970551.41596694,14],[970551.596916755,14],[970551.829689485,13],[970552.013646064,5],[970552.19623539,22],[970552.437308808,3],[970552.67477565,32],[970552.862886441,33],[970553.04581215,11],[970553.230901055,6],[970553.412263267,8],[970553.562773347,9],[970553.710882282,13],[970553.856079432,8],[970554.006497665,20],[970554.15521948,17],[970554.347778327,20],[970554.497312264,13],[970554.671200723,6],[970554.85441111,13],[970555.005032799,9],[970555.191320711,11],[970555.346215354,8],[970555.532788472,15],[970555.717363259,16],[970555.932371219,27],[970556.170514365,4],[970556.327373116,8],[970556.515683696,25],[970556.700858067,18],[970556.84949922,13],[970557.033941964,55],[970557.185284131,11],[970557.376884545,10],[970557.563204987,11],[970557.710355324,15],[970557.86050216,17],[970558.010989937,14],[970558.220725824,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-72082201e0d4fa46c0fad10881a824c5","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.050129477,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.760228561,"time_to_first_token":0.143559143,"token_sha":"8a91591c94a3","tokens_per_second":18.531668923199074},"seed":1234,"sent":970544.316388415,"speculative":{"acceptance_rate":0.3968609865470852,"accepted":177,"drafted":446,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14447784889489412,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":446,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.53298260827117,"done":970558.221019847,"finish_reason":"length","first":970544.461734255,"full_response_s":13.904794198926538,"last":970558.220987441,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970544.461734255,3],[970544.611962783,11],[970544.794618327,30],[970544.978131416,19],[970545.162693502,21],[970545.351246501,15],[970545.500888541,19],[970545.648626614,17],[970545.830356787,12],[970546.011717998,5],[970546.184030299,5],[970546.374461464,27],[970546.558737124,12],[970546.740828908,13],[970546.925708595,5],[970547.111293384,16],[970547.295293388,5],[970547.482559396,14],[970547.667799255,9],[970547.850591125,27],[970547.998821053,11],[970548.183501009,8],[970548.34131127,16],[970548.489715007,5],[970548.638543657,9],[970548.822158189,14],[970548.971156626,20],[970549.154211422,12],[970549.304657368,8],[970549.459618019,5],[970549.607357127,14],[970549.790624059,14],[970549.973610559,8],[970550.159072053,13],[970550.337858175,3],[970550.521993432,10],[970550.670824344,11],[970550.854428523,9],[970551.038476145,10],[970551.224708775,20],[970551.417226876,14],[970551.596587012,14],[970551.830477635,13],[970552.012530923,5],[970552.1984718,22],[970552.436639592,3],[970552.674979849,32],[970552.862301338,33],[970553.045519247,11],[970553.230641518,6],[970553.411114729,8],[970553.560232208,9],[970553.708378047,13],[970553.856256346,8],[970554.006430452,20],[970554.155835229,17],[970554.347914977,20],[970554.497566776,13],[970554.670679376,6],[970554.854439243,13],[970555.004982486,9],[970555.19189418,11],[970555.346102932,8],[970555.532094164,15],[970555.718470589,16],[970555.931440292,27],[970556.170443231,4],[970556.327244547,8],[970556.516061735,25],[970556.700218266,18],[970556.849588821,13],[970557.032902968,55],[970557.184261426,11],[970557.377376942,10],[970557.56314728,11],[970557.711368939,15],[970557.861643046,17],[970558.011421842,14],[970558.220987441,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-c388919a03089baf4b38ecc504eea785","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050234185,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.760202059,"time_to_first_token":0.143162906,"token_sha":"8a91591c94a3","tokens_per_second":18.53170461499253},"seed":1234,"sent":970544.316225648,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14550860691815615,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.532571704363306,"done":970558.220357018,"finish_reason":"length","first":970544.460736367,"full_response_s":13.90407708811108,"last":970558.220294623,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970544.460736367,3],[970544.611144065,11],[970544.794414512,30],[970544.977332014,19],[970545.15890778,21],[970545.350454909,15],[970545.500789722,19],[970545.648424927,17],[970545.830502127,12],[970546.01220694,5],[970546.18186353,5],[970546.374920224,27],[970546.557999894,12],[970546.741178223,13],[970546.926295619,5],[970547.110503168,16],[970547.295152145,5],[970547.483292385,14],[970547.666873589,9],[970547.851199738,27],[970547.999546296,11],[970548.181473309,8],[970548.338743786,16],[970548.489084102,5],[970548.6372476,9],[970548.82314529,14],[970548.970841318,20],[970549.155575491,12],[970549.305579817,8],[970549.45924726,5],[970549.607141518,14],[970549.788235746,14],[970549.974774878,8],[970550.157044385,13],[970550.33870757,3],[970550.520923515,10],[970550.671088394,11],[970550.853213475,9],[970551.037113565,10],[970551.223315662,20],[970551.413457245,14],[970551.596845749,14],[970551.828734487,13],[970552.011983315,5],[970552.198544422,22],[970552.438156361,3],[970552.675022625,32],[970552.860724958,33],[970553.044383735,11],[970553.229653202,6],[970553.410302783,8],[970553.558384321,9],[970553.706835514,13],[970553.856707903,8],[970554.004890976,20],[970554.154401261,17],[970554.347568415,20],[970554.496475257,13],[970554.670177441,6],[970554.854629343,13],[970555.005107005,9],[970555.191241912,11],[970555.346475371,8],[970555.533909164,15],[970555.717813728,16],[970555.93124043,27],[970556.170722404,4],[970556.328200808,8],[970556.515812248,25],[970556.699930068,18],[970556.848858811,13],[970557.032686479,55],[970557.182070309,11],[970557.377162613,10],[970557.562042144,11],[970557.711032155,15],[970557.858965951,17],[970558.011210602,14],[970558.220294623,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-adfd12e37951d3f013aecb9133601d3f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.05016614,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.760008056,"time_to_first_token":0.142961427,"token_sha":"8a91591c94a3","tokens_per_second":18.53196589436648},"seed":1234,"sent":970544.31627993,"speculative":{"acceptance_rate":0.39954853273137697,"accepted":177,"drafted":443,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14445643709041178,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":443,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.532264310791504,"done":970558.221851716,"finish_reason":"length","first":970544.462018486,"full_response_s":13.905419292044826,"last":970558.221804971,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970544.462018486,3],[970544.613569045,11],[970544.793792311,30],[970544.9779847,19],[970545.159500166,21],[970545.351479602,15],[970545.500413234,19],[970545.647554487,17],[970545.831736716,12],[970546.011271464,5],[970546.181751509,5],[970546.374594146,27],[970546.558165174,12],[970546.741378517,13],[970546.925147255,5],[970547.112146732,16],[970547.29518812,5],[970547.483629938,14],[970547.665966551,9],[970547.850478896,27],[970547.999800937,11],[970548.182389772,8],[970548.340213828,16],[970548.489786877,5],[970548.638614199,9],[970548.821807562,14],[970548.971507446,20],[970549.155063857,12],[970549.305289953,8],[970549.459012383,5],[970549.607024119,14],[970549.789827603,14],[970549.974519597,8],[970550.156852301,13],[970550.339762107,3],[970550.52122106,10],[970550.67087925,11],[970550.853557765,9],[970551.036403413,10],[970551.222641885,20],[970551.414385934,14],[970551.597505779,14],[970551.829745127,13],[970552.012847848,5],[970552.196765603,22],[970552.436981881,3],[970552.673819708,32],[970552.861034889,33],[970553.044296454,11],[970553.229234562,6],[970553.414388135,8],[970553.560342373,9],[970553.708503751,13],[970553.85637592,8],[970554.00612441,20],[970554.156616273,17],[970554.346660403,20],[970554.497075579,13],[970554.670627078,6],[970554.854518874,13],[970555.004278913,9],[970555.191522205,11],[970555.348153032,8],[970555.530750838,15],[970555.717707612,16],[970555.931922511,27],[970556.170983749,4],[970556.32720886,8],[970556.515158236,25],[970556.700913581,18],[970556.849893294,13],[970557.032989096,55],[970557.182210384,11],[970557.377501045,10],[970557.563498002,11],[970557.710943595,15],[970557.859701241,17],[970558.010516696,14],[970558.221804971,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-cee698ffdefe9e74848a1d7f95c809bd","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.050198194,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.760013432,"time_to_first_token":0.143101919,"token_sha":"8a91591c94a3","tokens_per_second":18.531958653977572},"seed":1234,"sent":970544.316432424,"speculative":{"acceptance_rate":0.39954853273137697,"accepted":177,"drafted":443,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14558606198988855,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":443,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.525761858618417,"done":970558.226408205,"finish_reason":"length","first":970544.460970716,"full_response_s":13.909636419964954,"last":970558.225586819,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970544.460970716,3],[970544.613223874,11],[970544.794036855,30],[970544.975918189,19],[970545.162129297,21],[970545.352064739,15],[970545.497695398,19],[970545.645705491,17],[970545.829681297,12],[970546.012296941,5],[970546.181968847,5],[970546.376222395,18],[970546.558418631,21],[970546.741107649,9],[970546.925817256,9],[970547.111957975,16],[970547.295402033,5],[970547.483534608,14],[970547.668129783,9],[970547.852333955,27],[970547.998301065,11],[970548.182673715,8],[970548.34071442,16],[970548.492349272,5],[970548.638984286,9],[970548.823610707,14],[970548.972130973,20],[970549.15518404,12],[970549.306373713,8],[970549.460036403,5],[970549.608359415,14],[970549.789057455,14],[970549.973883907,8],[970550.156554404,13],[970550.338330521,3],[970550.52174468,10],[970550.671354269,11],[970550.855259801,9],[970551.036247192,10],[970551.222493681,20],[970551.415702361,14],[970551.596348022,14],[970551.831278571,13],[970552.012331141,5],[970552.196597171,22],[970552.435928097,3],[970552.675282291,32],[970552.861866615,33],[970553.046450992,11],[970553.229782522,6],[970553.413613652,8],[970553.560818768,9],[970553.707846778,13],[970553.856304227,8],[970554.005424437,20],[970554.156181342,17],[970554.347864311,20],[970554.497518383,13],[970554.67092003,6],[970554.854176633,13],[970555.003657931,9],[970555.19142902,11],[970555.347850655,8],[970555.533997756,15],[970555.718726925,16],[970555.931879559,27],[970556.171723441,4],[970556.326716687,8],[970556.516331386,25],[970556.700051643,18],[970556.849038125,13],[970557.034224833,55],[970557.183796235,11],[970557.378049981,10],[970557.563774454,11],[970557.71078899,15],[970557.860127129,17],[970558.011657054,14],[970558.225586819,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-d0d1189eb08f7e51c35cb320cdd3d4d3","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050582572,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.764921394,"time_to_first_token":0.141659928,"token_sha":"8a91591c94a3","tokens_per_second":18.5253509773875},"seed":1234,"sent":970544.316771785,"speculative":{"acceptance_rate":0.40503432494279173,"accepted":177,"drafted":437,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14419893093872815,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":437,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.345348698621308,"done":970558.221751009,"finish_reason":"length","first":970544.321745418,"full_response_s":13.905431631021202,"last":970558.221726508,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970544.321745418,3],[970544.411283692,26],[970544.614075991,15],[970544.792493676,19],[970544.979484269,21],[970545.159090695,15],[970545.350325044,19],[970545.498631706,17],[970545.648330333,6],[970545.830027508,11],[970546.012363658,5],[970546.18235825,18],[970546.374857988,21],[970546.55883287,5],[970546.741244028,8],[970546.924901672,5],[970547.109856916,16],[970547.294993747,5],[970547.483947023,14],[970547.669030788,9],[970547.851759477,27],[970547.998730155,11],[970548.183018165,8],[970548.341422091,16],[970548.488033612,5],[970548.637899886,9],[970548.824182273,14],[970548.971437208,20],[970549.15411718,12],[970549.304871185,8],[970549.459783122,5],[970549.606736816,14],[970549.789168837,14],[970549.973555301,8],[970550.1579797,13],[970550.340271132,3],[970550.522155751,10],[970550.669416747,11],[970550.856351402,9],[970551.036702607,10],[970551.221456347,20],[970551.414066945,14],[970551.59616858,14],[970551.831404691,13],[970552.012726785,5],[970552.195809869,22],[970552.437489674,3],[970552.675216294,32],[970552.863182065,33],[970553.045948912,11],[970553.230286474,6],[970553.410367931,8],[970553.558272732,9],[970553.70777318,13],[970553.856179723,8],[970554.005017768,20],[970554.15534528,17],[970554.346514999,20],[970554.496627302,13],[970554.670977753,6],[970554.854852153,13],[970555.004386117,9],[970555.191360975,11],[970555.346603011,8],[970555.533478042,15],[970555.717976447,16],[970555.930970139,27],[970556.171655572,4],[970556.326901826,8],[970556.514810059,25],[970556.700341009,18],[970556.850594322,13],[970557.033645172,55],[970557.183740736,11],[970557.377263976,10],[970557.562159254,11],[970557.71072557,15],[970557.86087351,17],[970558.010212382,14],[970558.221726508,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-f195cdc523bee9d2820dc81f7412f4ca","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.004498357,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.898279842,"time_to_first_token":0.004921367,"token_sha":"8a91591c94a3","tokens_per_second":18.347594299360775},"seed":1234,"sent":970544.316319378,"speculative":{"acceptance_rate":0.38095238095238093,"accepted":176,"drafted":462,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.005426040035672486,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":462,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.531348216374436,"done":970558.221618648,"finish_reason":"length","first":970544.46112945,"full_response_s":13.905728760990314,"last":970558.221596148,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970544.46112945,3],[970544.612788222,11],[970544.793904957,30],[970544.977820076,19],[970545.161517851,21],[970545.352557202,15],[970545.500136844,19],[970545.647321755,17],[970545.832091649,12],[970546.011779946,5],[970546.182562225,5],[970546.37585514,27],[970546.558262649,12],[970546.74185917,13],[970546.926382468,5],[970547.111152125,16],[970547.295796845,5],[970547.482491591,14],[970547.669329949,9],[970547.852627468,27],[970547.998896123,11],[970548.18165736,8],[970548.340922123,16],[970548.490341111,5],[970548.638874681,9],[970548.822369174,14],[970548.970078612,20],[970549.15513211,12],[970549.304759324,8],[970549.459709556,5],[970549.607580722,14],[970549.789309248,14],[970549.974675275,8],[970550.157235894,13],[970550.337718677,3],[970550.521899382,10],[970550.669777136,11],[970550.856057009,9],[970551.037440027,10],[970551.222575888,20],[970551.414467998,14],[970551.597967995,14],[970551.829131875,13],[970552.013385038,5],[970552.197284598,22],[970552.437753612,3],[970552.673937427,32],[970552.859930888,33],[970553.047252648,11],[970553.230735791,6],[970553.411389005,8],[970553.561059613,9],[970553.709728863,13],[970553.856641219,8],[970554.005094343,20],[970554.157024878,17],[970554.347364825,20],[970554.497035508,13],[970554.67056537,6],[970554.854990627,13],[970555.003983897,9],[970555.19180205,11],[970555.347458341,8],[970555.532583233,15],[970555.718374011,16],[970555.932724742,27],[970556.171559858,4],[970556.328468362,8],[970556.516244281,25],[970556.700796343,18],[970556.849656417,13],[970557.033976627,55],[970557.183178774,11],[970557.376789711,10],[970557.563271351,11],[970557.711190377,15],[970557.86039814,17],[970558.011049244,14],[970558.221596148,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-f70822ba2f240d2fe37f88873631f3bb","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050306439,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.760136111,"time_to_first_token":0.142766349,"token_sha":"8a91591c94a3","tokens_per_second":18.53179343161804},"seed":1234,"sent":970544.315889887,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14523956296034157,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.51449156826619,"done":970572.170742437,"finish_reason":"length","first":970558.397726606,"full_response_s":13.927524731960148,"last":970572.170721617,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970558.397726606,3],[970558.548766327,11],[970558.729981839,30],[970558.913150786,19],[970559.097550592,21],[970559.284676286,15],[970559.438744299,19],[970559.586274235,17],[970559.769191363,12],[970559.94872579,5],[970560.119860133,5],[970560.310413652,27],[970560.497092412,12],[970560.680558074,13],[970560.863311649,5],[970561.046496522,16],[970561.231888849,5],[970561.422966415,14],[970561.606669209,9],[970561.790790018,27],[970561.938968679,11],[970562.124583686,8],[970562.277624929,16],[970562.429694086,5],[970562.580628583,9],[970562.76335249,14],[970562.911286984,20],[970563.097271051,12],[970563.243834137,8],[970563.401154155,5],[970563.551234697,14],[970563.733833893,14],[970563.919209184,8],[970564.103484117,13],[970564.282672422,3],[970564.469113437,10],[970564.615120128,11],[970564.797098249,9],[970564.982744368,10],[970565.167689665,20],[970565.357820469,14],[970565.540738893,14],[970565.772395394,13],[970565.958747285,5],[970566.145451291,22],[970566.384577257,3],[970566.623486062,32],[970566.806434076,33],[970566.993094235,11],[970567.179932554,6],[970567.360915005,8],[970567.5111638,9],[970567.659367674,13],[970567.805182657,8],[970567.95597872,20],[970568.107431158,17],[970568.297121699,20],[970568.448944765,13],[970568.622941415,6],[970568.807868068,13],[970568.956349683,9],[970569.143508492,11],[970569.296528335,8],[970569.484469719,15],[970569.66922114,16],[970569.882602006,27],[970570.120608171,4],[970570.27299098,8],[970570.464761245,25],[970570.65020993,18],[970570.797594539,13],[970570.984117619,55],[970571.132679497,11],[970571.323238337,10],[970571.511760132,11],[970571.661547403,15],[970571.808344894,17],[970571.960092699,14],[970572.170721617,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-23281693836ddc98caeb267f65df3016","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.054369496,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.771128061,"time_to_first_token":0.152537427,"token_sha":"8a91591c94a3","tokens_per_second":18.517001575358453},"seed":1234,"sent":970558.243217705,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.15450890094507486,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.31972216261316,"done":970572.168830806,"finish_reason":"length","first":970558.249365006,"full_response_s":13.925536559079774,"last":970572.168790079,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970558.249365006,3],[970558.343856452,26],[970558.548663284,15],[970558.72983658,19],[970558.914737788,21],[970559.097763384,15],[970559.283702039,19],[970559.436135745,17],[970559.584602065,6],[970559.767362043,11],[970559.948465758,5],[970560.120346448,18],[970560.310099257,21],[970560.497596091,5],[970560.678661559,8],[970560.862533775,5],[970561.046685405,16],[970561.231713408,5],[970561.423871448,14],[970561.607106635,9],[970561.78985285,27],[970561.938329664,11],[970562.125685028,8],[970562.276067982,16],[970562.431304787,5],[970562.579491283,9],[970562.762656136,14],[970562.914947506,20],[970563.097396883,12],[970563.242348211,8],[970563.402116767,5],[970563.550013445,14],[970563.734617335,14],[970563.919545295,8],[970564.105380821,13],[970564.281200788,3],[970564.469433577,10],[970564.613747329,11],[970564.797487106,9],[970564.981321912,10],[970565.166987743,20],[970565.356528277,14],[970565.542486418,14],[970565.773428978,13],[970565.960544578,5],[970566.144488793,22],[970566.384062809,3],[970566.62273101,32],[970566.80835552,33],[970566.993839429,11],[970567.180411474,6],[970567.360767873,8],[970567.511426505,9],[970567.657718889,13],[970567.805560535,8],[970567.956094277,20],[970568.107348903,17],[970568.297305525,20],[970568.449496259,13],[970568.623809192,6],[970568.809713113,13],[970568.958455879,9],[970569.142663856,11],[970569.296139991,8],[970569.484174417,15],[970569.667723808,16],[970569.881234042,27],[970570.119708613,4],[970570.272187296,8],[970570.463326821,25],[970570.648851072,18],[970570.79784921,13],[970570.982967055,55],[970571.133954835,11],[970571.323141712,10],[970571.512598478,11],[970571.660304311,15],[970571.80851747,17],[970571.960366029,14],[970572.168790079,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-1e26c6451114be014e37d36a76e13bc9","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.003691334,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.919327999,"time_to_first_token":0.004479307,"token_sha":"8a91591c94a3","tokens_per_second":18.31984992510557},"seed":1234,"sent":970558.243294247,"speculative":{"acceptance_rate":0.38095238095238093,"accepted":176,"drafted":462,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.0060707590309903026,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":462,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.516577991960595,"done":970572.170303972,"finish_reason":"length","first":970558.398838512,"full_response_s":13.927187917986885,"last":970572.1702816,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970558.398838512,3],[970558.548940808,11],[970558.729705467,30],[970558.913930309,19],[970559.098854533,21],[970559.28359826,15],[970559.436269258,19],[970559.583779815,17],[970559.767555168,12],[970559.94807458,5],[970560.120455716,5],[970560.309351981,27],[970560.495938868,12],[970560.680799144,13],[970560.863464525,5],[970561.047154053,16],[970561.231596842,5],[970561.424162351,14],[970561.606294883,9],[970561.792705192,27],[970561.938413743,11],[970562.12376054,8],[970562.276787236,16],[970562.430651689,5],[970562.578147944,9],[970562.76493733,14],[970562.91468773,20],[970563.096020082,12],[970563.242467306,8],[970563.401287908,5],[970563.550074064,14],[970563.734226574,14],[970563.920361143,8],[970564.105728214,13],[970564.282267003,3],[970564.466142213,10],[970564.613650895,11],[970564.797518743,9],[970564.982013017,10],[970565.167923805,20],[970565.356967686,14],[970565.539707518,14],[970565.772590294,13],[970565.958306611,5],[970566.144779006,22],[970566.384172461,3],[970566.623413104,32],[970566.806509194,33],[970566.995822884,11],[970567.180708473,6],[970567.362482879,8],[970567.510841181,9],[970567.659096728,13],[970567.805233482,8],[970567.956223997,20],[970568.106409193,17],[970568.2955681,20],[970568.450495308,13],[970568.623457623,6],[970568.809455514,13],[970568.957021871,9],[970569.144697847,11],[970569.295103192,8],[970569.483476192,15],[970569.669615261,16],[970569.881301287,27],[970570.120250281,4],[970570.272790815,8],[970570.464584732,25],[970570.650096613,18],[970570.798913662,13],[970570.984200674,55],[970571.133087172,11],[970571.322994997,10],[970571.512102178,11],[970571.66193269,15],[970571.809943908,17],[970571.959267795,14],[970572.1702816,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-e4c91681de9c315c0a71ca4275bbcbeb","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.054518996,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.771423907,"time_to_first_token":0.152492634,"token_sha":"8a91591c94a3","tokens_per_second":18.51660378200861},"seed":1234,"sent":970558.243116054,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.15572245803195983,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.516129701153382,"done":970572.171411663,"finish_reason":"length","first":970558.399622755,"full_response_s":13.927405393915251,"last":970572.171399261,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970558.399622755,3],[970558.548412293,11],[970558.729924436,30],[970558.913733264,19],[970559.098397935,21],[970559.283809164,15],[970559.437188199,19],[970559.584525443,17],[970559.7679173,12],[970559.949371191,5],[970560.121834791,5],[970560.310309648,18],[970560.494294912,21],[970560.680512802,9],[970560.864444309,9],[970561.048314494,16],[970561.230556087,5],[970561.426525481,14],[970561.606061751,9],[970561.792776805,27],[970561.939827559,11],[970562.124290639,8],[970562.277319752,16],[970562.430778176,5],[970562.580194518,9],[970562.764101622,14],[970562.912184015,20],[970563.10069673,12],[970563.245188117,8],[970563.401074077,5],[970563.551476598,14],[970563.735352768,14],[970563.919668806,8],[970564.106909314,13],[970564.281383638,3],[970564.467496113,10],[970564.613874216,11],[970564.797021115,9],[970564.982091879,10],[970565.166523352,20],[970565.357541297,14],[970565.540638154,14],[970565.773996107,13],[970565.959683554,5],[970566.14561937,22],[970566.385739504,3],[970566.622256698,32],[970566.807135854,33],[970566.992993704,11],[970567.181419917,6],[970567.362549035,8],[970567.509764854,9],[970567.658491768,13],[970567.806426327,8],[970567.955921509,20],[970568.105799193,17],[970568.296810441,20],[970568.450286069,13],[970568.625231086,6],[970568.807762769,13],[970568.956588143,9],[970569.144794201,11],[970569.297218046,8],[970569.485563777,15],[970569.668965221,16],[970569.882477727,27],[970570.120783643,4],[970570.273145712,8],[970570.465436553,25],[970570.649990962,18],[970570.796968088,13],[970570.983050943,55],[970571.133211243,11],[970571.323714217,10],[970571.51339704,11],[970571.660808804,15],[970571.8089017,17],[970571.959187461,14],[970572.171399261,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-6092bcee3abb55be9aa04b5cfeab4a77","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.054651693,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.772140453,"time_to_first_token":0.151981578,"token_sha":"8a91591c94a3","tokens_per_second":18.515640387943698},"seed":1234,"sent":970558.244006269,"speculative":{"acceptance_rate":0.40503432494279173,"accepted":177,"drafted":437,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.15561648597940803,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":437,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.51465661518414,"done":970572.171369207,"finish_reason":"length","first":970558.398475483,"full_response_s":13.927466780995019,"last":970572.171347716,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970558.398475483,3],[970558.549110584,11],[970558.730133003,30],[970558.913546557,19],[970559.099434082,21],[970559.283304461,15],[970559.436387744,19],[970559.585534512,17],[970559.768056414,12],[970559.949062734,5],[970560.12140415,5],[970560.308956547,18],[970560.496844718,21],[970560.680182708,13],[970560.865668634,5],[970561.047037599,16],[970561.2318438,5],[970561.422671448,14],[970561.605427041,9],[970561.791522587,27],[970561.938624727,11],[970562.124734658,8],[970562.277129012,16],[970562.432364505,5],[970562.580043786,9],[970562.764183765,14],[970562.912953807,20],[970563.096399865,12],[970563.242696596,8],[970563.400479886,5],[970563.550250833,14],[970563.734020536,14],[970563.918758764,8],[970564.104339508,13],[970564.281932364,3],[970564.467055183,10],[970564.614756637,11],[970564.796501258,9],[970564.981660311,10],[970565.168559747,20],[970565.358600662,14],[970565.540823821,14],[970565.773629703,13],[970565.959244513,5],[970566.143283465,22],[970566.383653629,3],[970566.623560924,32],[970566.806563876,33],[970566.994089379,11],[970567.178981834,6],[970567.36360355,8],[970567.510078896,9],[970567.659889546,13],[970567.806098506,8],[970567.956364071,20],[970568.105581472,17],[970568.297240393,20],[970568.449856838,13],[970568.624017102,6],[970568.808214596,13],[970568.958807576,9],[970569.144883289,11],[970569.296086509,8],[970569.486620068,15],[970569.666967605,16],[970569.881031253,27],[970570.121209034,4],[970570.272223975,8],[970570.462871937,25],[970570.649676088,18],[970570.798292044,13],[970570.982432653,55],[970571.133014375,11],[970571.323983802,10],[970571.511620634,11],[970571.660042359,15],[970571.811086549,17],[970571.959117304,14],[970572.171347716,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-2fc08582cb3c66aab94d6917edd923f8","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.054638027,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.771318574,"time_to_first_token":0.152078717,"token_sha":"8a91591c94a3","tokens_per_second":18.516745410380338},"seed":1234,"sent":970558.243902426,"speculative":{"acceptance_rate":0.4022727272727273,"accepted":177,"drafted":440,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1545730569632724,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":440,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.51384921683105,"done":970572.171054414,"finish_reason":"length","first":970558.3975447,"full_response_s":13.92756758700125,"last":970572.171017575,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970558.3975447,3],[970558.549287689,11],[970558.730078353,30],[970558.914367143,19],[970559.098194633,21],[970559.282716878,15],[970559.43511965,19],[970559.584567019,17],[970559.768129964,12],[970559.948531082,5],[970560.121354973,5],[970560.309637042,27],[970560.495348325,12],[970560.680901291,13],[970560.863398401,5],[970561.048676514,16],[970561.230676942,5],[970561.423458795,14],[970561.60600006,9],[970561.790573001,27],[970561.940124591,11],[970562.12492311,8],[970562.276339601,16],[970562.430033061,5],[970562.57887736,9],[970562.764026792,14],[970562.913225841,20],[970563.098158433,12],[970563.24285477,8],[970563.400573567,5],[970563.549929509,14],[970563.736142611,14],[970563.918673853,8],[970564.106046721,13],[970564.281758284,3],[970564.466476883,10],[970564.615050755,11],[970564.7963198,9],[970564.98280806,10],[970565.165766028,20],[970565.356798903,14],[970565.540692677,14],[970565.772210688,13],[970565.957915418,5],[970566.144605054,22],[970566.385162101,3],[970566.6232621,32],[970566.807381595,33],[970566.993216418,11],[970567.180200955,6],[970567.363094224,8],[970567.51014558,9],[970567.658070874,13],[970567.806596023,8],[970567.95553475,20],[970568.105400463,17],[970568.296587008,20],[970568.450103955,13],[970568.624068248,6],[970568.808995621,13],[970568.957800367,9],[970569.143037013,11],[970569.295268902,8],[970569.485993616,15],[970569.667806159,16],[970569.88112015,27],[970570.120182061,4],[970570.272203971,8],[970570.464186019,25],[970570.648975655,18],[970570.798704263,13],[970570.984025042,55],[970571.132563892,11],[970571.32525626,10],[970571.511441161,11],[970571.661758626,15],[970571.809660544,17],[970571.959814055,14],[970572.171017575,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-74944e537531c22faa711a618c18ec42","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.054158641,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.77152399,"time_to_first_token":0.152049287,"token_sha":"8a91591c94a3","tokens_per_second":18.516469214675492},"seed":1234,"sent":970558.243486827,"speculative":{"acceptance_rate":0.3950892857142857,"accepted":177,"drafted":448,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.15405787294730544,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":448,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.516350705616475,"done":970572.169682466,"finish_reason":"length","first":970558.398054444,"full_response_s":13.926307243993506,"last":970572.169666575,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970558.398054444,3],[970558.549377098,11],[970558.731266977,30],[970558.91380126,19],[970559.098783528,21],[970559.283922465,15],[970559.43951694,19],[970559.584308042,17],[970559.769130664,12],[970559.948162965,5],[970560.120061722,5],[970560.310459644,27],[970560.495187319,12],[970560.680020566,13],[970560.865820166,5],[970561.047838277,16],[970561.230907769,5],[970561.424817689,14],[970561.608248897,9],[970561.790947263,27],[970561.939528768,11],[970562.126182689,8],[970562.277573063,16],[970562.432101784,5],[970562.579650432,9],[970562.763203182,14],[970562.915520893,20],[970563.100321076,12],[970563.243277089,8],[970563.401768142,5],[970563.550824028,14],[970563.735931244,14],[970563.919042289,8],[970564.104654958,13],[970564.282433482,3],[970564.467152785,10],[970564.614860352,11],[970564.797768182,9],[970564.982393151,10],[970565.167155326,20],[970565.357239561,14],[970565.541402104,14],[970565.773845007,13],[970565.960648133,5],[970566.143769379,22],[970566.383927408,3],[970566.622419448,32],[970566.808580666,33],[970566.993393666,11],[970567.17986014,6],[970567.362023162,8],[970567.509515831,9],[970567.659744063,13],[970567.805614433,8],[970567.957979265,20],[970568.105127244,17],[970568.296384075,20],[970568.451217585,13],[970568.624652131,6],[970568.808305941,13],[970568.958139021,9],[970569.143992549,11],[970569.296208868,8],[970569.485308898,15],[970569.668569036,16],[970569.882843395,27],[970570.11963796,4],[970570.272312519,8],[970570.463408884,25],[970570.649587127,18],[970570.797059625,13],[970570.983865924,55],[970571.133542312,11],[970571.322922503,10],[970571.513158036,11],[970571.661435783,15],[970571.810793824,17],[970571.959575532,14],[970572.169666575,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-53c059e3abf5f1441aa9c149a82fcd8e","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.054406447,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.771337924,"time_to_first_token":0.152449698,"token_sha":"8a91591c94a3","tokens_per_second":18.516719392645122},"seed":1234,"sent":970558.243375222,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1546792220324278,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.515688226893495,"done":970572.171711174,"finish_reason":"length","first":970558.399569673,"full_response_s":13.92828368593473,"last":970572.171674543,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970558.399569673,3],[970558.547928249,11],[970558.730565309,30],[970558.914199351,19],[970559.098686662,21],[970559.284031189,15],[970559.437012198,19],[970559.58496927,17],[970559.766926121,12],[970559.949433331,5],[970560.120749051,5],[970560.310665603,27],[970560.494732402,12],[970560.6790094,13],[970560.862819045,5],[970561.046395191,16],[970561.232172342,5],[970561.422345483,14],[970561.605251024,9],[970561.791217298,27],[970561.938234014,11],[970562.126391544,8],[970562.277056455,16],[970562.431586903,5],[970562.577979256,9],[970562.764545465,14],[970562.912430189,20],[970563.097012843,12],[970563.242806761,8],[970563.40185283,5],[970563.548973987,14],[970563.735651656,14],[970563.918109396,8],[970564.103119921,13],[970564.281980886,3],[970564.466941593,10],[970564.616208491,11],[970564.796573047,9],[970564.982249877,10],[970565.165669642,20],[970565.358679156,14],[970565.539788445,14],[970565.772045297,13],[970565.958214402,5],[970566.143703991,22],[970566.384474101,3],[970566.623183366,32],[970566.806354749,33],[970566.994338641,11],[970567.182153301,6],[970567.361024177,8],[970567.51050107,9],[970567.659163572,13],[970567.805113956,8],[970567.956869684,20],[970568.104651348,17],[970568.29609943,20],[970568.45070197,13],[970568.624245384,6],[970568.809340932,13],[970568.956866818,9],[970569.142898395,11],[970569.297355895,8],[970569.48308116,15],[970569.667637552,16],[970569.881838538,27],[970570.120326071,4],[970570.272919975,8],[970570.463944694,25],[970570.649489013,18],[970570.798209868,13],[970570.9825352,55],[970571.133590545,11],[970571.324039333,10],[970571.511230338,11],[970571.661718075,15],[970571.809291068,17],[970571.959713765,14],[970572.171674543,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-37809ed607889ea48777055c6cef0c6d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.05459205,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.77129001,"time_to_first_token":0.152215686,"token_sha":"8a91591c94a3","tokens_per_second":18.516783817262738},"seed":1234,"sent":970558.243427488,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.15614218497648835,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.515733830121494,"done":970572.170459473,"finish_reason":"length","first":970558.398353636,"full_response_s":13.926350961090066,"last":970572.170424586,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970558.398353636,3],[970558.548273034,11],[970558.731108307,30],[970558.914564508,19],[970559.099810521,21],[970559.282829924,15],[970559.437587666,19],[970559.584250159,17],[970559.767476465,12],[970559.949316669,5],[970560.120808102,5],[970560.309123026,27],[970560.497187694,12],[970560.678808963,13],[970560.86389595,5],[970561.048451592,16],[970561.231153255,5],[970561.425185838,14],[970561.607939335,9],[970561.792346229,27],[970561.939224295,11],[970562.128668209,8],[970562.276862818,16],[970562.430924908,5],[970562.579318866,9],[970562.764691956,14],[970562.912881921,20],[970563.096799027,12],[970563.244933894,8],[970563.399978432,5],[970563.550529093,14],[970563.73571634,14],[970563.919154326,8],[970564.103240327,13],[970564.280568047,3],[970564.470404958,10],[970564.61496658,11],[970564.796248539,9],[970564.982330083,10],[970565.165823318,20],[970565.357590634,14],[970565.540070241,14],[970565.774254491,13],[970565.958611611,5],[970566.143549434,22],[970566.384655975,3],[970566.62198007,32],[970566.808774014,33],[970566.992898055,11],[970567.180897244,6],[970567.361353342,8],[970567.509838771,9],[970567.660019746,13],[970567.806175433,8],[970567.957792575,20],[970568.106979746,17],[970568.296523284,20],[970568.451312691,13],[970568.62449543,6],[970568.809902284,13],[970568.957692107,9],[970569.144464348,11],[970569.29765363,8],[970569.485804269,15],[970569.66804766,16],[970569.881752698,27],[970570.121161793,4],[970570.272670297,8],[970570.464370997,25],[970570.650391916,18],[970570.798524806,13],[970570.983751599,55],[970571.133764769,11],[970571.323896186,10],[970571.511555742,11],[970571.660453266,15],[970571.810897251,17],[970571.959857487,14],[970572.170424586,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-60be2ded96a0c26e8971ee9160355860","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.054236238,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.771431317,"time_to_first_token":0.152256158,"token_sha":"8a91591c94a3","tokens_per_second":18.516593818771614},"seed":1234,"sent":970558.244108512,"speculative":{"acceptance_rate":0.3968609865470852,"accepted":177,"drafted":446,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.15424512408208102,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":446,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.516632550347946,"done":970572.170135909,"finish_reason":"length","first":970558.397585684,"full_response_s":13.925992670003325,"last":970572.168988195,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970558.397585684,3],[970558.548828227,11],[970558.729386463,30],[970558.913405874,19],[970559.098025786,21],[970559.284468039,15],[970559.435496441,19],[970559.584467672,17],[970559.766830952,12],[970559.948331156,5],[970560.12291813,5],[970560.308878948,27],[970560.494563842,12],[970560.679605336,13],[970560.864976952,5],[970561.047986001,16],[970561.23145944,5],[970561.425606061,14],[970561.607620011,9],[970561.790475607,27],[970561.938494414,11],[970562.125842785,8],[970562.276413374,16],[970562.431639393,5],[970562.579743218,9],[970562.764456184,14],[970562.914413023,20],[970563.100027165,12],[970563.244656706,8],[970563.400129933,5],[970563.550456328,14],[970563.734721002,14],[970563.919263834,8],[970564.105026628,13],[970564.281875074,3],[970564.468818695,10],[970564.614261537,11],[970564.797153331,9],[970564.982528584,10],[970565.167744619,20],[970565.3581834,14],[970565.541093039,14],[970565.774347725,13],[970565.958404245,5],[970566.144146905,22],[970566.385341814,3],[970566.623625111,32],[970566.807220542,33],[970566.993685576,11],[970567.181797075,6],[970567.361618511,8],[970567.508893284,9],[970567.65904299,13],[970567.806029438,8],[970567.9569312,20],[970568.105965559,17],[970568.296429075,20],[970568.451370093,13],[970568.625149167,6],[970568.807906603,13],[970568.957551425,9],[970569.143455826,11],[970569.296464035,8],[970569.483838563,15],[970569.668893064,16],[970569.883015058,27],[970570.1204174,4],[970570.272562645,8],[970570.464116566,25],[970570.649173611,18],[970570.79847923,13],[970570.983231584,55],[970571.133632328,11],[970571.323636843,10],[970571.512865855,11],[970571.661188793,15],[970571.808452498,17],[970571.960133394,14],[970572.168988195,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-228be9fce70c2f451d37b59e1865f53c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.05427335,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.771518629,"time_to_first_token":0.152231001,"token_sha":"8a91591c94a3","tokens_per_second":18.51647642279786},"seed":1234,"sent":970558.244143239,"speculative":{"acceptance_rate":0.39954853273137697,"accepted":177,"drafted":443,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.15344244497828186,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":443,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.512269085649137,"done":970572.174109614,"finish_reason":"length","first":970558.399194115,"full_response_s":13.930420076940209,"last":970572.173842637,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970558.399194115,3],[970558.548043663,11],[970558.730383611,30],[970558.914318445,19],[970559.097429017,21],[970559.284847887,15],[970559.437485951,19],[970559.584111525,17],[970559.769041495,12],[970559.948595254,5],[970560.12020967,5],[970560.310367579,18],[970560.494810832,21],[970560.679213742,9],[970560.865322105,9],[970561.046870544,16],[970561.230400666,5],[970561.424720327,14],[970561.608457352,9],[970561.791341097,27],[970561.93816096,11],[970562.127286847,8],[970562.276715591,16],[970562.431882943,5],[970562.578796401,9],[970562.763268331,14],[970562.912095215,20],[970563.099625042,12],[970563.244478625,8],[970563.400441079,5],[970563.550993788,14],[970563.735889252,14],[970563.919592824,8],[970564.106344617,13],[970564.280929634,3],[970564.466670311,10],[970564.615937224,11],[970564.797194379,9],[970564.982146497,10],[970565.16590655,20],[970565.357157754,14],[970565.539989058,14],[970565.774534095,13],[970565.958018141,5],[970566.144554533,22],[970566.385387855,3],[970566.621647097,32],[970566.806616846,33],[970566.993753621,11],[970567.181211286,6],[970567.362735726,8],[970567.510401611,9],[970567.658768267,13],[970567.805347119,8],[970567.955383794,20],[970568.106463075,17],[970568.295414839,20],[970568.449991887,13],[970568.624939656,6],[970568.808685163,13],[970568.9577405,9],[970569.14456035,11],[970569.297081237,8],[970569.486275252,15],[970569.667408342,16],[970569.88309232,27],[970570.121261763,4],[970570.272138871,8],[970570.465246006,25],[970570.648100502,18],[970570.796604853,13],[970570.984446975,55],[970571.134203041,11],[970571.324109826,10],[970571.511993807,11],[970571.662090255,15],[970571.809367738,17],[970571.960204543,14],[970572.173842637,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-686c78c179e55a2f4407af830dc23c9d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.054689572,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.775905688,"time_to_first_token":0.152025891,"token_sha":"8a91591c94a3","tokens_per_second":18.51057968712191},"seed":1234,"sent":970558.243689537,"speculative":{"acceptance_rate":0.40503432494279173,"accepted":177,"drafted":437,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.15550457790959626,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":437,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.513257631519988,"done":970572.171943617,"finish_reason":"length","first":970558.397991456,"full_response_s":13.92815860605333,"last":970572.171904458,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970558.397991456,3],[970558.548882701,11],[970558.729522008,30],[970558.913475471,19],[970559.09766591,21],[970559.283869319,15],[970559.438142842,19],[970559.583874633,17],[970559.769303672,12],[970559.948787914,5],[970560.120856303,5],[970560.30879498,27],[970560.495741071,12],[970560.680613973,13],[970560.863962875,5],[970561.046985814,16],[970561.231780716,5],[970561.424087281,14],[970561.605046793,9],[970561.791387954,27],[970561.938928656,11],[970562.125296635,8],[970562.277201346,16],[970562.430719525,5],[970562.578646261,9],[970562.76347709,14],[970562.911346867,20],[970563.097902369,12],[970563.244292638,8],[970563.39969726,5],[970563.549820545,14],[970563.734359223,14],[970563.919843062,8],[970564.103862235,13],[970564.280879161,3],[970564.470635769,10],[970564.61410005,11],[970564.79739192,9],[970564.981261133,10],[970565.166193547,20],[970565.35634165,14],[970565.542040575,14],[970565.774190751,13],[970565.95853923,5],[970566.143630281,22],[970566.38510153,3],[970566.623114889,32],[970566.807800921,33],[970566.994907531,11],[970567.179653734,6],[970567.361573975,8],[970567.508797907,9],[970567.658235416,13],[970567.805731895,8],[970567.95498548,20],[970568.105706679,17],[970568.295718208,20],[970568.449783336,13],[970568.624573765,6],[970568.808393109,13],[970568.957618013,9],[970569.143245259,11],[970569.295771395,8],[970569.484333678,15],[970569.667909746,16],[970569.883270945,27],[970570.119538326,4],[970570.273655166,8],[970570.463044097,25],[970570.64781581,18],[970570.797456258,13],[970570.983105193,55],[970571.134016383,11],[970571.323550251,10],[970571.512914248,11],[970571.659864534,15],[970571.808825414,17],[970571.959652554,14],[970572.171904458,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-c7f0e37777ecb740bd1f1d0c651ceaa3","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.054311773,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.771335956,"time_to_first_token":0.152620291,"token_sha":"8a91591c94a3","tokens_per_second":18.516722038786636},"seed":1234,"sent":970558.243785011,"speculative":{"acceptance_rate":0.39954853273137697,"accepted":177,"drafted":443,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1542064449749887,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":443,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.51725566855754,"done":970572.169363832,"finish_reason":"length","first":970558.398397821,"full_response_s":13.925769591936842,"last":970572.169336915,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970558.398397821,3],[970558.548479649,11],[970558.730910974,30],[970558.914257842,19],[970559.098315504,21],[970559.283426692,15],[970559.439091004,19],[970559.584389049,17],[970559.766534512,12],[970559.94885191,5],[970560.121609757,5],[970560.308475256,27],[970560.495066144,12],[970560.680335809,13],[970560.863831298,5],[970561.048759602,16],[970561.230190243,5],[970561.424312651,14],[970561.606175645,9],[970561.791290367,27],[970561.940430696,11],[970562.123943727,8],[970562.275791594,16],[970562.430375717,5],[970562.580392635,9],[970562.764611877,14],[970562.911840799,20],[970563.098319711,12],[970563.244178809,8],[970563.400991581,5],[970563.550291577,14],[970563.735062218,14],[970563.920081955,8],[970564.106595336,13],[970564.280675715,3],[970564.469805166,10],[970564.615327607,11],[970564.79615785,9],[970564.981057911,10],[970565.165990261,20],[970565.357868126,14],[970565.540225774,14],[970565.772941047,13],[970565.960211108,5],[970566.144701904,22],[970566.386123015,3],[970566.621878548,32],[970566.808910503,33],[970566.995459505,11],[970567.179366769,6],[970567.361414537,8],[970567.508696416,9],[970567.657489342,13],[970567.806459773,8],[970567.956826428,20],[970568.106513388,17],[970568.295656196,20],[970568.451479649,13],[970568.623150846,6],[970568.807413088,13],[970568.956436307,9],[970569.144070307,11],[970569.296793311,8],[970569.485129233,15],[970569.667143525,16],[970569.88267882,27],[970570.121349955,4],[970570.272489976,8],[970570.4646936,25],[970570.648769681,18],[970570.796727724,13],[970570.982693533,55],[970571.133130428,11],[970571.324175582,10],[970571.51190507,11],[970571.661493665,15],[970571.810335083,17],[970571.960424583,14],[970572.169336915,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-7f83b7fa01d51c772b2f3a67366e9d1f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.054444679,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.771450487,"time_to_first_token":0.152365715,"token_sha":"8a91591c94a3","tokens_per_second":18.516568043483538},"seed":1234,"sent":970558.24359424,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.15480358095373958,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.513047680245805,"done":970572.171774786,"finish_reason":"length","first":970558.397682566,"full_response_s":13.927319679991342,"last":970572.171751774,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970558.397682566,3],[970558.547816997,11],[970558.730798521,30],[970558.913856023,19],[970559.099886711,21],[970559.283961112,15],[970559.437835504,19],[970559.585213924,17],[970559.766703408,12],[970559.948692904,5],[970560.120659018,5],[970560.310852198,27],[970560.497486822,12],[970560.680270485,13],[970560.863571137,5],[970561.047461359,16],[970561.230968836,5],[970561.423100472,14],[970561.60661139,9],[970561.791997636,27],[970561.939069706,11],[970562.12800935,8],[970562.277266142,16],[970562.431059669,5],[970562.580759311,9],[970562.765123941,14],[970562.912345197,20],[970563.097653138,12],[970563.243146136,8],[970563.400201322,5],[970563.549339479,14],[970563.735603695,14],[970563.919887903,8],[970564.104178854,13],[970564.28261998,3],[970564.468579546,10],[970564.615620862,11],[970564.797979693,9],[970564.981845658,10],[970565.168230822,20],[970565.358875401,14],[970565.54057259,14],[970565.773781155,13],[970565.959732971,5],[970566.143424163,22],[970566.385683702,3],[970566.622103725,32],[970566.807442039,33],[970566.993885341,11],[970567.180079925,6],[970567.362925425,8],[970567.511514281,9],[970567.657943762,13],[970567.805783952,8],[970567.955857225,20],[970568.104537663,17],[970568.296171667,20],[970568.450941486,13],[970568.625048957,6],[970568.808620351,13],[970568.958404622,9],[970569.143755385,11],[970569.297288235,8],[970569.484941246,15],[970569.667249753,16],[970569.881710514,27],[970570.121432275,4],[970570.27261355,8],[970570.465380815,25],[970570.650453527,18],[970570.798824654,13],[970570.983390125,55],[970571.133454344,11],[970571.324216293,10],[970571.512515582,11],[970571.660937803,15],[970571.810519117,17],[970571.960290095,14],[970572.171751774,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-cf48fd559e9942b5a7e1be25d0f700d6","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.054198408,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.771371435,"time_to_first_token":0.152516783,"token_sha":"8a91591c94a3","tokens_per_second":18.516674334403355},"seed":1234,"sent":970558.244455106,"speculative":{"acceptance_rate":0.3959731543624161,"accepted":177,"drafted":447,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1532274599885568,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":447,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.517189613618886,"done":970572.170529598,"finish_reason":"length","first":970558.39950819,"full_response_s":13.926280098967254,"last":970572.170496408,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970558.39950819,3],[970558.549335314,11],[970558.730872407,30],[970558.913333524,19],[970559.098261622,21],[970559.282918468,15],[970559.435807155,19],[970559.583951607,17],[970559.766758618,12],[970559.948271529,5],[970560.122585075,5],[970560.309707183,27],[970560.495860805,12],[970560.679440009,13],[970560.864189717,5],[970561.047779962,16],[970561.230632821,5],[970561.426885788,14],[970561.605695635,9],[970561.791695867,27],[970561.938702117,11],[970562.124041793,8],[970562.276598945,16],[970562.431463904,5],[970562.58108382,9],[970562.763942873,14],[970562.913528058,20],[970563.101334017,12],[970563.244602456,8],[970563.399563587,5],[970563.5491734,14],[970563.734684499,14],[970563.919924741,8],[970564.107601523,13],[970564.281331933,3],[970564.468148906,10],[970564.614193396,11],[970564.797349208,9],[970564.982570544,10],[970565.166834018,20],[970565.35835452,14],[970565.540342563,14],[970565.774434445,13],[970565.959115305,5],[970566.143886745,22],[970566.385479312,3],[970566.623679602,32],[970566.807889498,33],[970566.994604483,11],[970567.181085359,6],[970567.363533553,8],[970567.509443466,9],[970567.659533768,13],[970567.80651804,8],[970567.95723732,20],[970568.104829573,17],[970568.296318286,20],[970568.450387784,13],[970568.623900857,6],[970568.809650654,13],[970568.958081842,9],[970569.143668521,11],[970569.297164116,8],[970569.48506122,15],[970569.66863644,16],[970569.881629955,27],[970570.120066455,4],[970570.272086333,8],[970570.464839691,25],[970570.649292849,18],[970570.79837193,13],[970570.982788286,55],[970571.133364087,11],[970571.324496216,10],[970571.512052649,11],[970571.662027764,15],[970571.80918236,17],[970571.959775392,14],[970572.170496408,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-179d2534bec3fc265cd3b368cc178e96","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.054482253,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.771398862,"time_to_first_token":0.152255534,"token_sha":"8a91591c94a3","tokens_per_second":18.516637456753376},"seed":1234,"sent":970558.244249499,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.15525869093835354,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.513802526111572,"done":970572.172450078,"finish_reason":"length","first":970558.398903612,"full_response_s":13.929503623978235,"last":970572.172411223,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970558.398903612,3],[970558.54765559,11],[970558.730838896,30],[970558.91324466,19],[970559.09920764,21],[970559.283534792,15],[970559.436583781,19],[970559.585973859,17],[970559.768643932,12],[970559.948652513,5],[970560.120917195,5],[970560.309860588,27],[970560.496408764,12],[970560.679689352,13],[970560.86471916,5],[970561.0472132,16],[970561.232481183,5],[970561.424877332,14],[970561.606901909,9],[970561.790896598,27],[970561.939613936,11],[970562.123371572,8],[970562.27596049,16],[970562.432674707,5],[970562.580690451,9],[970562.762767501,14],[970562.913687079,20],[970563.098403998,12],[970563.243392982,8],[970563.400049886,5],[970563.550125914,14],[970563.735252573,14],[970563.91831657,8],[970564.104388941,13],[970564.280796889,3],[970564.470690243,10],[970564.61460136,11],[970564.796937611,9],[970564.981717458,10],[970565.168494807,20],[970565.357319976,14],[970565.540927184,14],[970565.772788091,13],[970565.958976143,5],[970566.144266095,22],[970566.383839008,3],[970566.622594488,32],[970566.806752039,33],[970566.995762777,11],[970567.181477864,6],[970567.361836775,8],[970567.50894699,9],[970567.658967088,13],[970567.805675452,8],[970567.956762321,20],[970568.106275568,17],[970568.295836485,20],[970568.450639862,13],[970568.623667582,6],[970568.807300764,13],[970568.957492902,9],[970569.1435947,11],[970569.295956293,8],[970569.484990968,15],[970569.668178564,16],[970569.882232562,27],[970570.120715551,4],[970570.273383628,8],[970570.463560432,25],[970570.648460632,18],[970570.79901016,13],[970570.984548178,55],[970571.1336969,11],[970571.3249708,10],[970571.512454099,11],[970571.661978459,15],[970571.808974402,17],[970571.958550032,14],[970572.172411223,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-03aa00040e69ccfcee8abac0bc8b520e","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.054554891,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.771247746,"time_to_first_token":0.152445794,"token_sha":"8a91591c94a3","tokens_per_second":18.516840645326955},"seed":1234,"sent":970558.242946454,"speculative":{"acceptance_rate":0.4013605442176871,"accepted":177,"drafted":441,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1559571580728516,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":441,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":1,"burst":null,"stream":0,"phase":"warmup","request":{"cache_state":"cold","cached_tokens":0,"case_id":null,"complete":true,"decode_tps":46.46259366543466,"done":970594.923823428,"finish_reason":"length","first":970594.600733354,"full_response_s":0.5214800520334393,"last":970594.923573704,"output_sha256":"26fc9e1892da6e23aa1a0cb06681c20c4a62f7257e19635806de87234b9035bb","pieces":[[970594.600733354,2],[970594.756535615,7],[970594.840375493,4],[970594.923573704,73]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":16,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"e9df2e35a58091c749bae4e1446600aeb669237cc39db72a41d5cae938d5620a","response_id":"cmpl-d0a39deedf114aeabbb5fc0b","runtime":{"accepted":12,"cached":0,"decode_s":0.3287,"drafted":45,"drafts":true,"min_rows":16,"prefill_s":0.1731,"rounds":3,"token_sha":"41b4449e1b18"},"seed":1234,"sent":970594.402343376,"speculative":{},"token_sha":"41b4449e1b18","tokens":16,"ttft_s":0.19838997803162783,"usage":{"completion_tokens":16,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":0},"total_tokens":30},"work":{"accepted":12,"drafted":45,"rounds":3},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":1,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":67.82200590284896,"done":970598.797962055,"finish_reason":"length","first":970595.037044623,"full_response_s":3.8725799859967083,"last":970598.796886235,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970595.037044623,2],[970595.123251555,7],[970595.205045327,4],[970595.285656668,73],[970595.373901574,51],[970595.458089206,21],[970595.538191962,14],[970595.617778659,20],[970595.698315331,16],[970595.778799993,15],[970595.858952806,23],[970595.940103655,23],[970596.021030016,25],[970596.102213927,36],[970596.182697699,14],[970596.265082829,6],[970596.352359295,18],[970596.436055967,18],[970596.51703837,19],[970596.597173345,8],[970596.677463067,11],[970596.757394806,18],[970596.838021762,15],[970596.918975174,39],[970596.999389148,30],[970597.081437439,14],[970597.161864823,15],[970597.242345865,8],[970597.327540643,6],[970597.412759793,12],[970597.494478971,26],[970597.574571256,22],[970597.654724592,18],[970597.735076619,38],[970597.815488686,22],[970597.897020765,10],[970597.977404227,14],[970598.058483106,15],[970598.138941349,38],[970598.219526831,47],[970598.305574594,25],[970598.391933435,11],[970598.47242514,34],[970598.55349653,12],[970598.633808604,36],[970598.717554173,60],[970598.796886235,48]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-9a7e64234eee4d9d8e80de8c","runtime":{"accepted":209,"cached":13,"decode_s":3.7597,"drafted":690,"drafts":true,"min_rows":16,"prefill_s":0.1091,"rounds":46,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970594.925382069,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.11166255408897996,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":209,"drafted":690,"rounds":46},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":1,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":67.87906090811644,"done":970602.667446623,"finish_reason":"length","first":970598.909775406,"full_response_s":3.867910148925148,"last":970602.666456724,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970598.909775406,2],[970598.992620903,7],[970599.075131141,4],[970599.15526903,73],[970599.236070907,51],[970599.321460063,21],[970599.407764579,14],[970599.488018777,20],[970599.568347275,16],[970599.648761452,15],[970599.728831121,23],[970599.809373305,23],[970599.890560983,25],[970599.971421244,36],[970600.052843682,14],[970600.133316979,6],[970600.21381132,18],[970600.298813198,18],[970600.38577476,19],[970600.466385281,8],[970600.546937104,11],[970600.62746958,18],[970600.707294604,15],[970600.78741088,39],[970600.868566261,30],[970600.949272101,14],[970601.029870338,15],[970601.110848225,8],[970601.190995951,6],[970601.27129444,12],[970601.358396975,26],[970601.441872415,22],[970601.522143027,18],[970601.603203457,38],[970601.683969995,22],[970601.764114089,10],[970601.844245914,14],[970601.925599472,15],[970602.005898639,38],[970602.088322478,47],[970602.168849349,25],[970602.251941352,11],[970602.33802997,34],[970602.422885543,12],[970602.505177616,36],[970602.585577872,60],[970602.666456724,48]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-7e6a70dd77d84c65b335900d","runtime":{"accepted":209,"cached":13,"decode_s":3.7562,"drafted":690,"drafts":true,"min_rows":16,"prefill_s":0.1077,"rounds":46,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970598.799536474,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.11023893195670098,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":209,"drafted":690,"rounds":46},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":1,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":67.86541047576974,"done":970606.539500097,"finish_reason":"length","first":970602.781056748,"full_response_s":3.8701736440416425,"last":970606.538493684,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970602.781056748,2],[970602.861616376,7],[970602.943960863,4],[970603.023858574,73],[970603.105132796,51],[970603.185385401,21],[970603.265417792,14],[970603.351933785,20],[970603.435544347,16],[970603.516077209,15],[970603.596566238,23],[970603.676856306,23],[970603.757312034,25],[970603.837740373,36],[970603.919540275,14],[970603.999675938,6],[970604.080823904,18],[970604.161113369,18],[970604.243686813,19],[970604.329817127,8],[970604.414382723,11],[970604.495323277,18],[970604.576032464,15],[970604.656643953,39],[970604.738460594,30],[970604.819212936,14],[970604.90215949,15],[970604.984070873,8],[970605.065160835,6],[970605.145281174,12],[970605.22558316,26],[970605.309597929,22],[970605.396242977,18],[970605.477897644,38],[970605.558159847,22],[970605.638979106,10],[970605.719270482,14],[970605.79954331,15],[970605.880906385,38],[970605.961463077,47],[970606.043050666,25],[970606.123850312,11],[970606.203967744,34],[970606.288182409,12],[970606.374787518,36],[970606.456949078,60],[970606.538493684,48]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-866de20870884c0ab086d785","runtime":{"accepted":209,"cached":13,"decode_s":3.7572,"drafted":690,"drafts":true,"min_rows":16,"prefill_s":0.1087,"rounds":46,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970602.669326453,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.11173029500059783,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":209,"drafted":690,"rounds":46},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.396621160543955,"done":970617.31206117,"finish_reason":"length","first":970606.844182507,"full_response_s":10.762231552042067,"last":970617.296449578,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970606.844182507,2],[970607.008180591,7],[970607.154821582,4],[970607.401136329,63],[970607.679100929,10],[970607.849044085,31],[970608.03487197,29],[970608.186899181,13],[970608.380098761,13],[970608.528239162,20],[970608.714598386,14],[970608.898685401,4],[970609.044794079,13],[970609.237197669,21],[970609.432584874,2],[970609.612546929,18],[970609.79796206,29],[970610.031612269,27],[970610.287194507,22],[970610.481530719,6],[970610.632519416,16],[970610.815133432,10],[970610.99658881,31],[970611.148256375,8],[970611.354182276,8],[970611.493476019,8],[970611.641652749,18],[970611.826344161,24],[970612.011934633,25],[970612.166359419,13],[970612.360357369,11],[970612.51147172,16],[970612.661713473,13],[970612.847026207,8],[970612.99972593,12],[970613.180075085,9],[970613.375498625,29],[970613.562441892,22],[970613.746873532,8],[970613.897034045,18],[970614.080453135,18],[970614.26564339,34],[970614.467370848,10],[970614.647555294,14],[970614.833081919,13],[970614.986543931,2],[970615.16592244,36],[970615.360328659,42],[970615.550026802,26],[970615.70783547,17],[970615.889952097,34],[970616.079741332,12],[970616.266223352,36],[970616.57428552,50],[970616.759502318,2],[970617.046047002,54],[970617.296449578,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-439fa3853692441c8136c495","runtime":{"accepted":199,"cached":13,"decode_s":10.4528,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.2548,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970606.549829618,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2943528890609741,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":1,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.394458858943278,"done":970617.312017739,"finish_reason":"length","first":970606.843331721,"full_response_s":10.764260478084907,"last":970617.296525271,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970606.843331721,2],[970607.008268302,7],[970607.15445299,4],[970607.398459438,63],[970607.678405993,10],[970607.850607633,31],[970608.037241512,29],[970608.184880467,13],[970608.379539129,13],[970608.527662311,20],[970608.712255281,14],[970608.897670907,4],[970609.043736986,13],[970609.241420536,21],[970609.43125087,2],[970609.612375507,18],[970609.796580431,29],[970610.031870425,27],[970610.287465274,22],[970610.482938959,6],[970610.630586269,16],[970610.815947187,10],[970610.997074237,31],[970611.148847115,8],[970611.353885489,8],[970611.492853401,8],[970611.642582667,18],[970611.828866334,24],[970612.012568981,25],[970612.165818575,13],[970612.359261471,11],[970612.509856213,16],[970612.662960022,13],[970612.846811034,8],[970612.999366653,12],[970613.181779487,9],[970613.37628351,29],[970613.56073757,22],[970613.746237312,8],[970613.898333609,18],[970614.080911661,18],[970614.267767654,34],[970614.469440399,10],[970614.649073328,14],[970614.835498423,13],[970614.986635738,2],[970615.167335527,36],[970615.363778091,42],[970615.550183917,26],[970615.707926701,17],[970615.890888223,34],[970616.079480247,12],[970616.266136745,36],[970616.576653135,50],[970616.758687588,2],[970617.046377042,54],[970617.296525271,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-6b3bf01976d14b7ea19fc003","runtime":{"accepted":199,"cached":13,"decode_s":10.4528,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.2548,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970606.547757261,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.29557446006219834,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":2,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.395521856520396,"done":970617.308891948,"finish_reason":"length","first":970606.842667991,"full_response_s":10.762498424970545,"last":970617.295406059,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970606.842667991,2],[970607.007820769,7],[970607.152802771,4],[970607.397154254,63],[970607.678443024,10],[970607.848711884,31],[970608.033285058,29],[970608.1841895,13],[970608.380009402,13],[970608.526300318,20],[970608.710720202,14],[970608.89705885,4],[970609.043277435,13],[970609.23537875,21],[970609.430701176,2],[970609.609309031,18],[970609.794702734,29],[970610.029436873,27],[970610.285249039,22],[970610.48119855,6],[970610.628313113,16],[970610.815664883,10],[970610.995167016,31],[970611.147692982,8],[970611.352663665,8],[970611.492706144,8],[970611.642971165,18],[970611.826236847,24],[970612.011792593,25],[970612.164754922,13],[970612.361940919,11],[970612.509303335,16],[970612.659476885,13],[970612.845945447,8],[970612.996965606,12],[970613.179906993,9],[970613.378339171,29],[970613.560459107,22],[970613.746195193,8],[970613.897334192,18],[970614.079305453,18],[970614.26684841,34],[970614.465323685,10],[970614.64645514,14],[970614.833815739,13],[970614.986152905,2],[970615.165859085,36],[970615.360237588,42],[970615.549265297,26],[970615.707713737,17],[970615.889779108,34],[970616.077914159,12],[970616.267109437,36],[970616.573183125,50],[970616.757159282,2],[970617.045786703,54],[970617.295406059,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-8becd0b71636425e89e51989","runtime":{"accepted":199,"cached":13,"decode_s":10.4526,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.2548,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970606.546393523,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2962744679534808,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":3,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.394679079320465,"done":970617.311669312,"finish_reason":"length","first":970606.842627536,"full_response_s":10.764427354908548,"last":970617.295726721,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970606.842627536,2],[970607.007164048,7],[970607.154242058,4],[970607.402489858,63],[970607.679624683,10],[970607.851346799,31],[970608.035887696,29],[970608.183831295,13],[970608.380180407,13],[970608.530044512,20],[970608.71213486,14],[970608.897298219,4],[970609.043633448,13],[970609.235586258,21],[970609.433341372,2],[970609.609218183,18],[970609.795538333,29],[970610.029950913,27],[970610.285088388,22],[970610.485754528,6],[970610.629176173,16],[970610.81641157,10],[970610.994962485,31],[970611.148647161,8],[970611.353615427,8],[970611.493879432,8],[970611.64090014,18],[970611.826711232,24],[970612.011456904,25],[970612.164338835,13],[970612.361642692,11],[970612.509597113,16],[970612.660936093,13],[970612.84793028,8],[970612.997092011,12],[970613.180650783,9],[970613.377746462,29],[970613.560675672,22],[970613.746619553,8],[970613.897551925,18],[970614.079185593,18],[970614.265513464,34],[970614.471040254,10],[970614.6473539,14],[970614.832209627,13],[970614.986051575,2],[970615.165577885,36],[970615.359518762,42],[970615.549112824,26],[970615.710226242,17],[970615.89009084,34],[970616.077304376,12],[970616.265256276,36],[970616.574347354,50],[970616.758432745,2],[970617.045172215,54],[970617.295726721,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-83126ef9e33c4395b933cdca","runtime":{"accepted":199,"cached":13,"decode_s":10.4526,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.2548,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970606.547241957,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.29538557899650186,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":4,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.39548664529345,"done":970617.310476167,"finish_reason":"length","first":970606.843616602,"full_response_s":10.763340116012841,"last":970617.296369757,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970606.843616602,2],[970607.007985805,7],[970607.153973756,4],[970607.398838671,63],[970607.679135319,10],[970607.852700664,31],[970608.035587292,29],[970608.185887359,13],[970608.380337986,13],[970608.529360699,20],[970608.711846555,14],[970608.898350223,4],[970609.046265434,13],[970609.236325376,21],[970609.431947165,2],[970609.610985157,18],[970609.796093708,29],[970610.03089165,27],[970610.286327655,22],[970610.483565962,6],[970610.631269906,16],[970610.816035858,10],[970610.996072434,31],[970611.148468395,8],[970611.352765698,8],[970611.494083067,8],[970611.643302806,18],[970611.828976177,24],[970612.011870254,25],[970612.169323763,13],[970612.359490086,11],[970612.511158802,16],[970612.660463645,13],[970612.846745695,8],[970612.998219291,12],[970613.18143066,9],[970613.375320242,29],[970613.560613261,22],[970613.745429991,8],[970613.898878982,18],[970614.08006787,18],[970614.266299965,34],[970614.465475535,10],[970614.648066821,14],[970614.834383259,13],[970614.986213539,2],[970615.165707651,36],[970615.361410314,42],[970615.550251752,26],[970615.709811468,17],[970615.891445405,34],[970616.078887683,12],[970616.265955786,36],[970616.576015588,50],[970616.758631227,2],[970617.04840596,54],[970617.296369757,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-8f3d35ae5a5e4b07aa5becda","runtime":{"accepted":199,"cached":13,"decode_s":10.4527,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.2548,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970606.547136051,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2964805510127917,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":5,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.394680910997756,"done":970617.312290248,"finish_reason":"length","first":970606.842718784,"full_response_s":10.764453068957664,"last":970617.295817184,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970606.842718784,2],[970607.007345407,7],[970607.152925624,4],[970607.397976619,63],[970607.679992218,10],[970607.848817422,31],[970608.03511966,29],[970608.185711825,13],[970608.381486839,13],[970608.526643449,20],[970608.711205581,14],[970608.897501742,4],[970609.044378215,13],[970609.237706892,21],[970609.431169736,2],[970609.609985722,18],[970609.795361823,29],[970610.03028369,27],[970610.28706695,22],[970610.481591513,6],[970610.629574417,16],[970610.814710272,10],[970610.995715381,31],[970611.150183503,8],[970611.352528746,8],[970611.493402599,8],[970611.641529496,18],[970611.826428352,24],[970612.011229809,25],[970612.1656163,13],[970612.361117003,11],[970612.509927425,16],[970612.661852617,13],[970612.848149165,8],[970612.998821537,12],[970613.180522457,9],[970613.375985331,29],[970613.560319243,22],[970613.745958625,8],[970613.897416766,18],[970614.079963548,18],[970614.265881078,34],[970614.466751303,10],[970614.646911201,14],[970614.833350732,13],[970614.986765744,2],[970615.166113064,36],[970615.360540647,42],[970615.548791809,26],[970615.70813024,17],[970615.890810194,34],[970616.081619073,12],[970616.265473769,36],[970616.575514719,50],[970616.760653056,2],[970617.045481931,54],[970617.295817184,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-9d15bd57d7c84ff8803bf31d","runtime":{"accepted":199,"cached":13,"decode_s":10.4526,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.2548,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970606.547837179,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2948816049611196,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":6,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.391208912398877,"done":970617.31023331,"finish_reason":"length","first":970606.843435659,"full_response_s":10.761639297008514,"last":970617.298022019,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970606.843435659,2],[970607.007401545,7],[970607.157810479,4],[970607.400203577,63],[970607.67835328,10],[970607.848954613,31],[970608.036418891,29],[970608.186984812,13],[970608.382712601,13],[970608.526946461,20],[970608.714845725,14],[970608.899438697,4],[970609.04452024,13],[970609.236854571,21],[970609.431075672,2],[970609.61285823,18],[970609.798487509,29],[970610.031304664,27],[970610.285326076,22],[970610.484145517,6],[970610.62891208,16],[970610.815460496,10],[970610.996933253,31],[970611.149127451,8],[970611.353019726,8],[970611.493794905,8],[970611.641459644,18],[970611.828377755,24],[970612.011023438,25],[970612.164924199,13],[970612.359193379,11],[970612.511586123,16],[970612.66067,13],[970612.846234616,8],[970612.998140237,12],[970613.181207886,9],[970613.376341248,29],[970613.561166299,22],[970613.745267851,8],[970613.896878979,18],[970614.080653393,18],[970614.266437989,34],[970614.468452903,10],[970614.647071644,14],[970614.833397812,13],[970614.987191832,2],[970615.167764575,36],[970615.361706748,42],[970615.550341784,26],[970615.708063188,17],[970615.891727981,34],[970616.079060144,12],[970616.266311927,36],[970616.576155771,50],[970616.758737709,2],[970617.049076089,54],[970617.298022019,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-d4cbefc5efe24f078ae782c8","runtime":{"accepted":199,"cached":13,"decode_s":10.4527,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.2548,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970606.548594013,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2948416459839791,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":7,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.387816009674303,"done":970617.309685954,"finish_reason":"length","first":970606.842802286,"full_response_s":10.76136112306267,"last":970617.298843118,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970606.842802286,2],[970607.008440219,7],[970607.155285021,4],[970607.397483606,63],[970607.679945714,10],[970607.849242535,31],[970608.034073993,29],[970608.186508042,13],[970608.37985432,13],[970608.526413361,20],[970608.711606209,14],[970608.897175878,4],[970609.043395103,13],[970609.236645847,21],[970609.432690253,2],[970609.610058375,18],[970609.795282113,29],[970610.030192458,27],[970610.284486621,22],[970610.482339481,6],[970610.62946499,16],[970610.816278523,10],[970610.996334703,31],[970611.148540087,8],[970611.352409029,8],[970611.493729406,8],[970611.643077391,18],[970611.827324152,24],[970612.013793078,25],[970612.164841689,13],[970612.361744053,11],[970612.511071075,16],[970612.660558973,13],[970612.846580339,8],[970612.999162507,12],[970613.18111387,9],[970613.375396511,29],[970613.561541787,22],[970613.747112356,8],[970613.89863102,18],[970614.080363152,18],[970614.267332284,34],[970614.466920708,10],[970614.646655158,14],[970614.833535499,13],[970614.986444346,2],[970615.166915008,36],[970615.361148894,42],[970615.549169521,26],[970615.709586278,17],[970615.891042729,34],[970616.07821813,12],[970616.265878637,36],[970616.573421214,50],[970616.76042585,2],[970617.048762964,54],[970617.298843118,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-73c6c6b14d294f98b78b0e77","runtime":{"accepted":199,"cached":13,"decode_s":10.4527,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.2548,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970606.548324831,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.29447745508514345,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":8,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.39612913549074,"done":970617.309138421,"finish_reason":"length","first":970606.844394464,"full_response_s":10.760641559958458,"last":970617.296872338,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970606.844394464,2],[970607.008249819,7],[970607.154996876,4],[970607.398699687,63],[970607.678230699,10],[970607.849338279,31],[970608.033424009,29],[970608.190068476,13],[970608.382183471,13],[970608.527099095,20],[970608.71196976,14],[970608.89906689,4],[970609.045714364,13],[970609.237438607,21],[970609.430939729,2],[970609.613459773,18],[970609.795113716,29],[970610.032214259,27],[970610.285625519,22],[970610.483048946,6],[970610.628792203,16],[970610.815299364,10],[970610.997140168,31],[970611.150838527,8],[970611.352861731,8],[970611.493605817,8],[970611.640709804,18],[970611.826057425,24],[970612.011566939,25],[970612.165215752,13],[970612.36026561,11],[970612.513857758,16],[970612.660163626,13],[970612.847470122,8],[970612.99734663,12],[970613.18098652,9],[970613.376197079,29],[970613.560952631,22],[970613.746011066,8],[970613.897192936,18],[970614.0813514,18],[970614.268655821,34],[970614.466488635,10],[970614.646288519,14],[970614.833463487,13],[970614.986381743,2],[970615.166024905,36],[970615.364671314,42],[970615.551415693,26],[970615.708422801,17],[970615.890191945,34],[970616.079797069,12],[970616.268539999,36],[970616.575100249,50],[970616.763699971,2],[970617.045299468,54],[970617.296872338,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-97a719fa17734dd2836a31e1","runtime":{"accepted":199,"cached":13,"decode_s":10.4527,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.2548,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970606.548496861,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.29589760303497314,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":9,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.39642210552378,"done":970617.310051551,"finish_reason":"length","first":970606.843252299,"full_response_s":10.760448419954628,"last":970617.295604652,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970606.843252299,2],[970607.008298931,7],[970607.154926016,4],[970607.398901818,63],[970607.679813499,10],[970607.852610632,31],[970608.035415983,29],[970608.185951946,13],[970608.382810186,13],[970608.526787505,20],[970608.712651173,14],[970608.900458552,4],[970609.045916159,13],[970609.238400067,21],[970609.431610532,2],[970609.610445913,18],[970609.79617505,29],[970610.03067326,27],[970610.285769096,22],[970610.488397331,6],[970610.628425276,16],[970610.816334117,10],[970610.996671608,31],[970611.149658069,8],[970611.353676445,8],[970611.494852366,8],[970611.644510436,18],[970611.826787277,24],[970612.011411488,25],[970612.164513553,13],[970612.359740896,11],[970612.510042148,16],[970612.662204421,13],[970612.84650239,8],[970612.998720752,12],[970613.179796078,9],[970613.376098614,29],[970613.561055016,22],[970613.746384569,8],[970613.897115563,18],[970614.080407528,18],[970614.267026057,34],[970614.467686694,10],[970614.646184342,14],[970614.834746088,13],[970614.985645411,2],[970615.16806109,36],[970615.360064967,42],[970615.550078155,26],[970615.70900738,17],[970615.89185485,34],[970616.078310002,12],[970616.266038504,36],[970616.57457512,50],[970616.760942481,2],[970617.047238403,54],[970617.295604652,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-f99287271ab54b37931ea286","runtime":{"accepted":199,"cached":13,"decode_s":10.4527,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.2548,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970606.549603131,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2936491679865867,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":10,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.38786248299049,"done":970617.310995374,"finish_reason":"length","first":970606.843290114,"full_response_s":10.764092514989898,"last":970617.299311021,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970606.843290114,2],[970607.007482775,7],[970607.154541902,4],[970607.400793855,63],[970607.6782817,10],[970607.8502541,31],[970608.033791064,29],[970608.184811143,13],[970608.38228272,13],[970608.527051167,20],[970608.711476747,14],[970608.899865266,4],[970609.044671258,13],[970609.23730588,21],[970609.43465166,2],[970609.611482218,18],[970609.794961274,29],[970610.033567963,27],[970610.28517157,22],[970610.482267821,6],[970610.630536501,16],[970610.816500977,10],[970610.997284369,31],[970611.148589439,8],[970611.352438234,8],[970611.493061948,8],[970611.641020449,18],[970611.828636311,24],[970612.012419852,25],[970612.16516688,13],[970612.358925734,11],[970612.514905184,16],[970612.659595945,13],[970612.847093402,8],[970612.998886268,12],[970613.181259655,9],[970613.376741124,29],[970613.560885099,22],[970613.746308028,8],[970613.900388406,18],[970614.081150374,18],[970614.265782758,34],[970614.465607893,10],[970614.646972459,14],[970614.832561383,13],[970614.986266924,2],[970615.168385288,36],[970615.361353345,42],[970615.54950753,26],[970615.708603984,17],[970615.89264532,34],[970616.078591921,12],[970616.270350225,36],[970616.573952647,50],[970616.759022413,2],[970617.045409311,54],[970617.299311021,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-e613e07650634426a85771c8","runtime":{"accepted":199,"cached":13,"decode_s":10.4526,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.2548,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970606.546902859,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.29638725495897233,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":11,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.393185494289018,"done":970617.311411876,"finish_reason":"length","first":970606.843747681,"full_response_s":10.764957846957259,"last":970617.297486905,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970606.843747681,2],[970607.008393491,7],[970607.155072729,4],[970607.398763346,63],[970607.678564597,10],[970607.850362023,31],[970608.033487908,29],[970608.184940013,13],[970608.380753066,13],[970608.527169811,20],[970608.713978744,14],[970608.897849018,4],[970609.04407562,13],[970609.236440484,21],[970609.431667133,2],[970609.610513445,18],[970609.796780113,29],[970610.032098496,27],[970610.284699489,22],[970610.486462025,6],[970610.629703015,16],[970610.815589238,10],[970610.99765944,31],[970611.147438571,8],[970611.352323575,8],[970611.494584448,8],[970611.641124947,18],[970611.828118447,24],[970612.011510065,25],[970612.165915327,13],[970612.359299701,11],[970612.510644907,16],[970612.659833778,13],[970612.846892888,8],[970612.997246181,12],[970613.180916492,9],[970613.375893844,29],[970613.560804701,22],[970613.74511669,8],[970613.89795953,18],[970614.079520721,18],[970614.266957917,34],[970614.46503594,10],[970614.6477576,14],[970614.832105769,13],[970614.987609615,2],[970615.166590217,36],[970615.360166536,42],[970615.548902116,26],[970615.70835463,17],[970615.891313303,34],[970616.080235319,12],[970616.266378706,36],[970616.574856992,50],[970616.759265782,2],[970617.049586767,54],[970617.297486905,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-336dbb4a7f8540268ac9905b","runtime":{"accepted":199,"cached":13,"decode_s":10.4526,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.2548,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970606.546454029,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.29729365196544677,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":12,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.39950010663173,"done":970617.31133996,"finish_reason":"length","first":970606.84564423,"full_response_s":10.760713884956203,"last":970617.296678017,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970606.84564423,2],[970607.007854551,7],[970607.153107383,4],[970607.39763656,63],[970607.678954872,10],[970607.849166938,31],[970608.037546988,29],[970608.185529746,13],[970608.380985201,13],[970608.527774891,20],[970608.712066,14],[970608.897565049,4],[970609.044579466,13],[970609.23795948,21],[970609.433113893,2],[970609.611214397,18],[970609.79549815,29],[970610.030553288,27],[970610.284623972,22],[970610.483367352,6],[970610.629096831,16],[970610.814331423,10],[970610.995346438,31],[970611.148704083,8],[970611.352709497,8],[970611.493192515,8],[970611.640465538,18],[970611.826490458,24],[970612.010772388,25],[970612.165293365,13],[970612.360162712,11],[970612.510764207,16],[970612.659763814,13],[970612.846664769,8],[970612.997407697,12],[970613.180319959,9],[970613.376399177,29],[970613.563847602,22],[970613.74564902,8],[970613.897645541,18],[970614.079865308,18],[970614.267403913,34],[970614.466628722,10],[970614.647265373,14],[970614.83387146,13],[970614.986954608,2],[970615.169486419,36],[970615.360405504,42],[970615.549442511,26],[970615.708222095,17],[970615.890475481,34],[970616.079127644,12],[970616.267736087,36],[970616.573782539,50],[970616.758325639,2],[970617.04596262,54],[970617.296678017,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-44201d2b3f1c4ef28223ec53","runtime":{"accepted":199,"cached":13,"decode_s":10.4527,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.2548,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970606.550626075,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2950181550113484,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":13,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.3975811407349,"done":970617.311461389,"finish_reason":"length","first":970606.844068872,"full_response_s":10.764090418000706,"last":970617.295924674,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970606.844068872,2],[970607.008211796,7],[970607.153333582,4],[970607.398285632,63],[970607.679237736,10],[970607.850674876,31],[970608.03478069,29],[970608.185598654,13],[970608.37940469,13],[970608.529776626,20],[970608.714737082,14],[970608.899540299,4],[970609.044467111,13],[970609.23783245,21],[970609.432032076,2],[970609.610915705,18],[970609.795968951,29],[970610.030961341,27],[970610.284387724,22],[970610.486397678,6],[970610.631724688,16],[970610.816773071,10],[970610.996283606,31],[970611.149899311,8],[970611.352239561,8],[970611.494150486,8],[970611.641690131,18],[970611.830433401,24],[970612.012641666,25],[970612.165342814,13],[970612.359422074,11],[970612.510558812,16],[970612.660617383,13],[970612.846378593,8],[970612.999422775,12],[970613.180159452,9],[970613.376566726,29],[970613.561470174,22],[970613.744889083,8],[970613.897494523,18],[970614.080783223,18],[970614.26880367,34],[970614.465984709,10],[970614.646523999,14],[970614.832949496,13],[970614.987779372,2],[970615.166727376,36],[970615.360852428,42],[970615.551025771,26],[970615.708846553,17],[970615.890672315,34],[970616.079904351,12],[970616.26576097,36],[970616.573267012,50],[970616.757665336,2],[970617.0458659,54],[970617.295924674,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-5cbb6e0fd4c14572869c11bd","runtime":{"accepted":199,"cached":13,"decode_s":10.4526,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.2548,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970606.547370971,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.296697901096195,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":14,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.39337316532253,"done":970617.308751988,"finish_reason":"length","first":970606.842960905,"full_response_s":10.760656796046533,"last":970617.296619703,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970606.842960905,2],[970607.007632625,7],[970607.153230684,4],[970607.397035145,63],[970607.678743059,10],[970607.850307901,31],[970608.037856321,29],[970608.183927407,13],[970608.379928012,13],[970608.526696002,20],[970608.712565766,14],[970608.899295873,4],[970609.04608806,13],[970609.235484608,21],[970609.434965698,2],[970609.609625821,18],[970609.795434491,29],[970610.030091225,27],[970610.286206307,22],[970610.481404409,6],[970610.62865538,16],[970610.816691153,10],[970610.995522196,31],[970611.147917869,8],[970611.353413137,8],[970611.494315698,8],[970611.641594515,18],[970611.828564651,24],[970612.011653786,25],[970612.164975439,13],[970612.359095907,11],[970612.511350979,16],[970612.661515344,13],[970612.847727654,8],[970612.998971306,12],[970613.180452158,9],[970613.375740634,29],[970613.560567797,22],[970613.745744828,8],[970613.896472398,18],[970614.08070209,18],[970614.270175982,34],[970614.46857198,10],[970614.646383768,14],[970614.8326618,13],[970614.986878003,2],[970615.171026999,36],[970615.359429963,42],[970615.549355745,26],[970615.708537573,17],[970615.890404397,34],[970616.07930601,12],[970616.268838545,36],[970616.573882635,50],[970616.75921827,2],[970617.046175504,54],[970617.296619703,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-71f71c294c454df0b9e2d3c3","runtime":{"accepted":199,"cached":13,"decode_s":10.4526,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.2548,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970606.548095192,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.294865713105537,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":15,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.396189899286767,"done":970617.311069243,"finish_reason":"length","first":970606.843568754,"full_response_s":10.764748021028936,"last":970617.296020594,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970606.843568754,2],[970607.007932404,7],[970607.153823858,4],[970607.399137426,63],[970607.679045975,10],[970607.853120543,31],[970608.035929159,29],[970608.190190833,13],[970608.380470841,13],[970608.529614182,20],[970608.712337935,14],[970608.89898902,4],[970609.043910455,13],[970609.23776271,21],[970609.432960843,2],[970609.610666351,18],[970609.7956018,29],[970610.032257323,27],[970610.284292876,22],[970610.481779257,6],[970610.633263975,16],[970610.81806518,10],[970610.99583649,31],[970611.150643405,8],[970611.352374608,8],[970611.49312924,8],[970611.642330864,18],[970611.827483235,24],[970612.011721349,25],[970612.165407353,13],[970612.359357407,11],[970612.512848498,16],[970612.662516282,13],[970612.84613924,8],[970613.001163583,12],[970613.182577414,9],[970613.375825816,29],[970613.561256234,22],[970613.745502867,8],[970613.898070573,18],[970614.079620658,18],[970614.265709705,34],[970614.467227288,10],[970614.647934174,14],[970614.833151898,13],[970614.987028141,2],[970615.168176021,36],[970615.363993503,42],[970615.549841539,26],[970615.710134467,17],[970615.894972705,34],[970616.077814494,12],[970616.270112008,36],[970616.57449946,50],[970616.758520008,2],[970617.046479139,54],[970617.296020594,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-a03f644adfc341809d59e690","runtime":{"accepted":199,"cached":13,"decode_s":10.4526,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.2548,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970606.546321222,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.29724753205664456,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.59222554542119,"done":970627.934052782,"finish_reason":"length","first":970617.547711595,"full_response_s":10.61615397199057,"last":970627.916842259,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970617.547711595,2],[970617.689438829,7],[970617.835257544,4],[970618.065384407,63],[970618.34839127,10],[970618.532686277,31],[970618.714754861,29],[970618.867456711,13],[970619.048595786,13],[970619.196986898,20],[970619.392462765,14],[970619.572069935,4],[970619.730377097,13],[970619.912710468,21],[970620.096996671,2],[970620.283670681,18],[970620.473509302,29],[970620.711290152,27],[970620.947214055,22],[970621.135446908,6],[970621.282793048,16],[970621.477620989,10],[970621.66064281,31],[970621.808410269,8],[970621.961396746,8],[970622.114024331,8],[970622.262464896,18],[970622.453446518,24],[970622.638194954,25],[970622.789372441,13],[970622.975336965,11],[970623.126251321,16],[970623.274326707,13],[970623.471638573,8],[970623.619074684,12],[970623.801934925,9],[970623.99201905,29],[970624.182716329,22],[970624.376394105,8],[970624.524827233,18],[970624.71120325,18],[970624.897880234,34],[970625.084246191,10],[970625.268680356,14],[970625.465619685,13],[970625.615317073,2],[970625.797730567,36],[970625.989251117,42],[970626.177949307,26],[970626.339669314,17],[970626.524240532,34],[970626.709835936,12],[970626.894861332,36],[970627.18706883,50],[970627.387736191,2],[970627.670977486,54],[970627.916842259,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-4c821ce7f340470ca627b0d4","runtime":{"accepted":199,"cached":13,"decode_s":10.369,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1939,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970617.31789881,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.22981278493534774,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.59037281022095,"done":970627.935084808,"finish_reason":"length","first":970617.547147036,"full_response_s":10.617261051083915,"last":970627.917058951,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970617.547147036,2],[970617.686558695,7],[970617.836045309,4],[970618.064361082,63],[970618.346801162,10],[970618.531489755,31],[970618.715320652,29],[970618.865608769,13],[970619.047655533,13],[970619.197519724,20],[970619.391014394,14],[970619.572119912,4],[970619.726753912,13],[970619.912472797,21],[970620.096343729,2],[970620.281774652,18],[970620.474111275,29],[970620.708757663,27],[970620.945090115,22],[970621.131272001,6],[970621.280091236,16],[970621.478317025,10],[970621.659785083,31],[970621.809096096,8],[970621.960971379,8],[970622.113069147,8],[970622.261883887,18],[970622.45229034,24],[970622.637949185,25],[970622.788076704,13],[970622.977034576,11],[970623.124971476,16],[970623.274173834,13],[970623.471711545,8],[970623.622202374,12],[970623.802285319,9],[970623.992984202,29],[970624.180340494,22],[970624.377226884,8],[970624.524358579,18],[970624.710175847,18],[970624.895998529,34],[970625.083702757,10],[970625.26826115,14],[970625.465183117,13],[970625.614676823,2],[970625.796866919,36],[970625.987501307,42],[970626.177442759,26],[970626.336913769,17],[970626.523056208,34],[970626.711261245,12],[970626.894597785,36],[970627.186954827,50],[970627.383079789,2],[970627.669948691,54],[970627.917058951,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-455d5f1558724b5b9d891409","runtime":{"accepted":199,"cached":13,"decode_s":10.369,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1939,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970617.317823757,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.22932327899616212,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.58764021573536,"done":970627.933572222,"finish_reason":"length","first":970617.546637366,"full_response_s":10.615180977038108,"last":970627.917701761,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970617.546637366,2],[970617.686780013,7],[970617.835661997,4],[970618.064260538,63],[970618.348895835,10],[970618.531341522,31],[970618.71537599,29],[970618.865712482,13],[970619.049474366,13],[970619.197126714,20],[970619.390425959,14],[970619.571433717,4],[970619.725105187,13],[970619.912629271,21],[970620.096822738,2],[970620.281676187,18],[970620.473594437,29],[970620.710726297,27],[970620.945346622,22],[970621.130865037,6],[970621.280213817,16],[970621.477224442,10],[970621.658926507,31],[970621.808461222,8],[970621.961051008,8],[970622.11195176,8],[970622.261582461,18],[970622.453050851,24],[970622.638996944,25],[970622.789580603,13],[970622.974830929,11],[970623.124562255,16],[970623.273935138,13],[970623.472913873,8],[970623.620311995,12],[970623.801703318,9],[970623.992532911,29],[970624.182439355,22],[970624.377185277,8],[970624.529357395,18],[970624.71064162,18],[970624.89668794,34],[970625.085314033,10],[970625.27236524,14],[970625.464853398,13],[970625.616216135,2],[970625.796267812,36],[970625.985682365,42],[970626.176040927,26],[970626.3364499,17],[970626.52341846,34],[970626.709893002,12],[970626.895362183,36],[970627.187317351,50],[970627.3827638,2],[970627.668726841,54],[970627.917701761,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-769a630c9adb4764945b65e4","runtime":{"accepted":199,"cached":13,"decode_s":10.3689,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1939,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970617.318391245,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.22824612096883357,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.591378492203148,"done":970627.935986109,"finish_reason":"length","first":970617.546795585,"full_response_s":10.617552120937034,"last":970627.916283415,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970617.546795585,2],[970617.686842087,7],[970617.838477846,4],[970618.063991692,63],[970618.350556738,10],[970618.533360534,31],[970618.714244087,29],[970618.868284738,13],[970619.047537625,13],[970619.19674745,20],[970619.392071676,14],[970619.571131282,4],[970619.724599166,13],[970619.913287989,21],[970620.097797365,2],[970620.282097954,18],[970620.473398612,29],[970620.707871691,27],[970620.946699088,22],[970621.132070087,6],[970621.28102112,16],[970621.477921279,10],[970621.65876744,31],[970621.807602678,8],[970621.960170493,8],[970622.110763786,8],[970622.262528507,18],[970622.452367057,24],[970622.636765836,25],[970622.787633142,13],[970622.974168146,11],[970623.12387222,16],[970623.27409446,13],[970623.471780964,8],[970623.619680561,12],[970623.801984965,9],[970623.991929243,29],[970624.181948778,22],[970624.37773324,8],[970624.524718479,18],[970624.71166019,18],[970624.89494133,34],[970625.084840274,10],[970625.273502789,14],[970625.464045584,13],[970625.612821235,2],[970625.796157105,36],[970625.986052346,42],[970626.176916896,26],[970626.336836828,17],[970626.52471149,34],[970626.710584253,12],[970626.89396496,36],[970627.189595072,50],[970627.383707396,2],[970627.668657102,54],[970627.916283415,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-9a056faa020f47408722c75a","runtime":{"accepted":199,"cached":13,"decode_s":10.3689,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1939,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970617.318433988,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.22836159693542868,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.59179942414096,"done":970627.932697982,"finish_reason":"length","first":970617.548779583,"full_response_s":10.614156951894984,"last":970627.918089921,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970617.548779583,2],[970617.687025878,7],[970617.836308585,4],[970618.065294503,63],[970618.3476707,10],[970618.53186329,31],[970618.71490223,29],[970618.866049963,13],[970619.04940005,13],[970619.197721758,20],[970619.391957704,14],[970619.571306351,4],[970619.724423345,13],[970619.912114305,21],[970620.097313156,2],[970620.283229263,18],[970620.473705607,29],[970620.708932428,27],[970620.94644527,22],[970621.131076401,6],[970621.280569252,16],[970621.479822861,10],[970621.659374502,31],[970621.808340961,8],[970621.962305698,8],[970622.112472055,8],[970622.26204345,18],[970622.452500968,24],[970622.637286018,25],[970622.787840985,13],[970622.974455986,11],[970623.124453885,16],[970623.274402304,13],[970623.471918091,8],[970623.619577504,12],[970623.802077781,9],[970623.993285692,29],[970624.180032251,22],[970624.376469285,8],[970624.525430581,18],[970624.711878354,18],[970624.895089466,34],[970625.086955377,10],[970625.272880622,14],[970625.46469286,13],[970625.614790586,2],[970625.79715207,36],[970625.986995943,42],[970626.175430314,26],[970626.338517731,17],[970626.524386284,34],[970626.710438756,12],[970626.894671493,36],[970627.189712404,50],[970627.387492871,2],[970627.670320001,54],[970627.918089921,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-07b190499e194da49f719387","runtime":{"accepted":199,"cached":13,"decode_s":10.3691,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1939,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970617.31854103,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2302385529037565,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.59014406303864,"done":970627.935049282,"finish_reason":"length","first":970617.546682094,"full_response_s":10.616110425093211,"last":970627.916690474,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970617.546682094,2],[970617.686197258,7],[970617.8351819,4],[970618.064808102,63],[970618.349178602,10],[970618.533479322,31],[970618.716015569,29],[970618.866524939,13],[970619.048073907,13],[970619.196842602,20],[970619.390707623,14],[970619.571217504,4],[970619.724679404,13],[970619.914256904,21],[970620.099969969,2],[970620.284525529,18],[970620.474021036,29],[970620.708339017,27],[970620.94498677,22],[970621.131338492,6],[970621.280418251,16],[970621.477467587,10],[970621.658639339,31],[970621.807978421,8],[970621.960055706,8],[970622.112397899,8],[970622.262966116,18],[970622.452910364,24],[970622.638752087,25],[970622.788969765,13],[970622.974043166,11],[970623.124649854,16],[970623.274233348,13],[970623.471293747,8],[970623.621897699,12],[970623.805911188,9],[970623.991787075,29],[970624.181473403,22],[970624.379508367,8],[970624.529166835,18],[970624.711492562,18],[970624.896909305,34],[970625.084374229,10],[970625.272158454,14],[970625.466030906,13],[970625.61437042,2],[970625.796466021,36],[970625.985913539,42],[970626.176429727,26],[970626.33733099,17],[970626.523235966,34],[970626.709373028,12],[970626.895053396,36],[970627.186645608,50],[970627.384366481,2],[970627.669533343,54],[970627.916690474,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-86301a793090476cbbffb0f3","runtime":{"accepted":199,"cached":13,"decode_s":10.369,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1939,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970617.318938857,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.22774323704652488,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.59408895654454,"done":970627.931273027,"finish_reason":"length","first":970617.5478348,"full_response_s":10.613293307018466,"last":970627.91617983,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970617.5478348,2],[970617.689372546,7],[970617.837098926,4],[970618.06672508,63],[970618.347413249,10],[970618.53299356,31],[970618.714575583,29],[970618.865550487,13],[970619.048780377,13],[970619.197814269,20],[970619.39138404,14],[970619.571785472,4],[970619.72484972,13],[970619.916242837,21],[970620.100543745,2],[970620.28470079,18],[970620.474754039,29],[970620.708124789,27],[970620.945932592,22],[970621.136453812,6],[970621.281436357,16],[970621.47837902,10],[970621.658503844,31],[970621.809496003,8],[970621.960671089,8],[970622.112541091,8],[970622.26310966,18],[970622.454290691,24],[970622.639198306,25],[970622.788482708,13],[970622.974557235,11],[970623.124014292,16],[970623.274514931,13],[970623.472490907,8],[970623.619841436,12],[970623.80287937,9],[970623.992802284,29],[970624.183344402,22],[970624.375636491,8],[970624.526975718,18],[970624.712308138,18],[970624.898503761,34],[970625.085361049,10],[970625.272318608,14],[970625.46969433,13],[970625.614422573,2],[970625.797248711,36],[970625.986764865,42],[970626.180119251,26],[970626.337264547,17],[970626.525773426,34],[970626.710102653,12],[970626.894810556,36],[970627.186349463,50],[970627.384698696,2],[970627.670701488,54],[970627.91617983,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-0c3ab806a299465380807f9a","runtime":{"accepted":199,"cached":13,"decode_s":10.369,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1939,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970617.31797972,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.22985508001875132,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.583983843275835,"done":970627.936077404,"finish_reason":"length","first":970617.548740105,"full_response_s":10.617425842909142,"last":970627.921346987,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970617.548740105,2],[970617.687406694,7],[970617.835817063,4],[970618.064525558,63],[970618.347984209,10],[970618.532776148,31],[970618.714981507,29],[970618.86659391,13],[970619.049036709,13],[970619.197461794,20],[970619.392173853,14],[970619.571931304,4],[970619.726197035,13],[970619.91666694,21],[970620.097637002,2],[970620.284260556,18],[970620.474820178,29],[970620.710176189,27],[970620.946174297,22],[970621.133527163,6],[970621.281722101,16],[970621.477369203,10],[970621.660462284,31],[970621.80916886,8],[970621.962189198,8],[970622.112265829,8],[970622.261310079,18],[970622.452732638,24],[970622.637444957,25],[970622.789863787,13],[970622.974269587,11],[970623.125332384,16],[970623.274783999,13],[970623.471425721,8],[970623.619467166,12],[970623.801130743,9],[970623.993350343,29],[970624.185633103,22],[970624.378292133,8],[970624.527171383,18],[970624.712434639,18],[970624.897395289,34],[970625.084174691,10],[970625.268841839,14],[970625.46929876,13],[970625.614302233,2],[970625.797445975,36],[970625.986425944,42],[970626.17721877,26],[970626.337529999,17],[970626.52557909,34],[970626.709309641,12],[970626.894293798,36],[970627.186766444,50],[970627.383433911,2],[970627.670501823,54],[970627.921346987,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-42e085e22c924cfe9360d31d","runtime":{"accepted":199,"cached":13,"decode_s":10.369,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1939,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970617.318651561,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.23008854396175593,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.59479896323448,"done":970627.935020702,"finish_reason":"length","first":970617.548406608,"full_response_s":10.616695403936319,"last":970627.916452323,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970617.548406608,2],[970617.686357013,7],[970617.838337199,4],[970618.06618691,63],[970618.347325458,10],[970618.532060283,31],[970618.715515629,29],[970618.866123079,13],[970619.048699324,13],[970619.197249903,20],[970619.391083062,14],[970619.572730238,4],[970619.726108732,13],[970619.915195845,21],[970620.098794732,2],[970620.283471448,18],[970620.475520808,29],[970620.709239616,27],[970620.944727703,22],[970621.131866981,6],[970621.280641984,16],[970621.47769977,10],[970621.661830705,31],[970621.808766153,8],[970621.961260067,8],[970622.111618617,8],[970622.262245771,18],[970622.45437224,24],[970622.638348372,25],[970622.789952025,13],[970622.975730439,11],[970623.124307477,16],[970623.274576317,13],[970623.471988983,8],[970623.619349754,12],[970623.802371558,9],[970623.99449983,29],[970624.18103973,22],[970624.37678737,8],[970624.526559729,18],[970624.71281635,18],[970624.897107594,34],[970625.08551509,10],[970625.268533068,14],[970625.464589658,13],[970625.613655726,2],[970625.796672519,36],[970625.985557336,42],[970626.174748825,26],[970626.337779016,17],[970626.523774727,34],[970626.709229308,12],[970626.896110915,36],[970627.186503825,50],[970627.384798713,2],[970627.668810663,54],[970627.916452323,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-f5738b374f7f41a891ee51bb","runtime":{"accepted":199,"cached":13,"decode_s":10.369,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1939,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970617.318325298,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.23008131003007293,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.593183747435496,"done":970627.93569174,"finish_reason":"length","first":970617.547898827,"full_response_s":10.617637400049716,"last":970627.916625488,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970617.547898827,2],[970617.686621666,7],[970617.835746267,4],[970618.0647005,63],[970618.347755739,10],[970618.5342728,31],[970618.715052719,29],[970618.865888992,13],[970619.047353162,13],[970619.197385285,20],[970619.390289024,14],[970619.571859148,4],[970619.72632512,13],[970619.912258377,21],[970620.096883868,2],[970620.28494808,18],[970620.475463902,29],[970620.709199577,27],[970620.946074936,22],[970621.132683838,6],[970621.2812646,16],[970621.478561242,10],[970621.659555444,31],[970621.808097513,8],[970621.959939879,8],[970622.111286881,8],[970622.261462489,18],[970622.452172737,24],[970622.636964397,25],[970622.787717236,13],[970622.975050966,11],[970623.124862529,16],[970623.274910036,13],[970623.471840478,8],[970623.621469036,12],[970623.802059986,9],[970623.992455906,29],[970624.180510922,22],[970624.376155633,8],[970624.525280044,18],[970624.711438537,18],[970624.89652196,34],[970625.083855454,10],[970625.27223261,14],[970625.464761367,13],[970625.614525614,2],[970625.798626779,36],[970625.989345484,42],[970626.174228066,26],[970626.336559454,17],[970626.525227592,34],[970626.709480742,12],[970626.894736063,36],[970627.18813099,50],[970627.384295286,2],[970627.669042365,54],[970627.916625488,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-0c82d0485fe542b481afd0bb","runtime":{"accepted":199,"cached":13,"decode_s":10.369,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1939,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970617.31805434,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.22984448703937232,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.59792041312346,"done":970627.934585558,"finish_reason":"length","first":970617.549788073,"full_response_s":10.61642329604365,"last":970627.916518094,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970617.549788073,2],[970617.686417552,7],[970617.835047829,4],[970618.065921057,63],[970618.349887649,10],[970618.5319683,31],[970618.716284158,29],[970618.866660465,13],[970619.048910127,13],[970619.197762789,20],[970619.390870994,14],[970619.571363945,4],[970619.724259525,13],[970619.914773006,21],[970620.097441257,2],[970620.283323407,18],[970620.477246569,29],[970620.711493017,27],[970620.94662274,22],[970621.132574491,6],[970621.280285125,16],[970621.478128674,10],[970621.65884971,31],[970621.808958169,8],[970621.961841076,8],[970622.111058699,8],[970622.262648255,18],[970622.4541342,24],[970622.637658593,25],[970622.787521636,13],[970622.974925553,11],[970623.126394065,16],[970623.276369128,13],[970623.473347834,8],[970623.619220197,12],[970623.802332463,9],[970623.991520247,29],[970624.181100124,22],[970624.378512569,8],[970624.525942106,18],[970624.713982912,18],[970624.896462975,34],[970625.088529383,10],[970625.273590644,14],[970625.469193687,13],[970625.61458564,2],[970625.797024833,36],[970625.987343024,42],[970626.174521363,26],[970626.337597098,17],[970626.524124865,34],[970626.709537903,12],[970626.895147732,36],[970627.187647758,50],[970627.38326814,2],[970627.671113508,54],[970627.916518094,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-81eeeb8cb5df40119c1cf047","runtime":{"accepted":199,"cached":13,"decode_s":10.369,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1939,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970617.318162262,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.23162581108044833,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.59346189639861,"done":970627.933951293,"finish_reason":"length","first":970617.548363689,"full_response_s":10.615730028948747,"last":970627.916973081,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970617.548363689,2],[970617.686510895,7],[970617.835904021,4],[970618.065196231,63],[970618.346664467,10],[970618.532300276,31],[970618.716203793,29],[970618.865803905,13],[970619.048457075,13],[970619.198610243,20],[970619.390774082,14],[970619.574985753,4],[970619.726678796,13],[970619.913853828,21],[970620.098281126,2],[970620.281904049,18],[970620.474663128,29],[970620.709683658,27],[970620.946259655,22],[970621.136892974,6],[970621.281602225,16],[970621.480038113,10],[970621.659012729,31],[970621.807821787,8],[970621.960563727,8],[970622.11170836,8],[970622.261972974,18],[970622.453278169,24],[970622.638280568,25],[970622.788775989,13],[970622.975434662,11],[970623.124715145,16],[970623.274458281,13],[970623.473706069,8],[970623.621661724,12],[970623.801036855,9],[970623.994163134,29],[970624.17968016,22],[970624.375831739,8],[970624.524483288,18],[970624.710439779,18],[970624.896220342,34],[970625.083349434,10],[970625.26813777,14],[970625.464515038,13],[970625.613909688,2],[970625.798459696,36],[970625.988535782,42],[970626.175499413,26],[970626.33629085,17],[970626.524964524,34],[970626.708919929,12],[970626.896401155,36],[970627.186857979,50],[970627.384870869,2],[970627.6689636,54],[970627.916973081,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-63c312f87bc1485b892e9dec","runtime":{"accepted":199,"cached":13,"decode_s":10.369,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1939,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970617.318221264,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.23014242493081838,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.57986827605239,"done":970627.936664589,"finish_reason":"length","first":970617.548451896,"full_response_s":10.618406918947585,"last":970627.922795531,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970617.548451896,2],[970617.687481811,7],[970617.836527006,4],[970618.064449033,63],[970618.3485006,10],[970618.53155247,31],[970618.715260402,29],[970618.865321744,13],[970619.048966217,13],[970619.197319626,20],[970619.39013527,14],[970619.572662019,4],[970619.726010731,13],[970619.913972584,21],[970620.096715872,2],[970620.281473673,18],[970620.475597636,29],[970620.709863416,27],[970620.946847017,22],[970621.13095606,6],[970621.281335124,16],[970621.478474572,10],[970621.659222108,31],[970621.808543939,8],[970621.961181238,8],[970622.112325551,8],[970622.261679437,18],[970622.453210302,24],[970622.639243961,25],[970622.78906879,13],[970622.975500481,11],[970623.124500357,16],[970623.276313614,13],[970623.472859784,8],[970623.61897406,12],[970623.802023228,9],[970623.992603547,29],[970624.179913207,22],[970624.377299488,8],[970624.524643586,18],[970624.710813105,18],[970624.896288722,34],[970625.086413687,10],[970625.267957868,14],[970625.465429014,13],[970625.61588752,2],[970625.799009755,36],[970625.986115349,42],[970626.174875886,26],[970626.3371713,17],[970626.52349052,34],[970626.710528979,12],[970626.894925823,36],[970627.18843104,50],[970627.383164363,2],[970627.669836273,54],[970627.922795531,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-dbec7f41ea4a4f5fbb204bd5","runtime":{"accepted":199,"cached":13,"decode_s":10.369,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1939,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970617.31825767,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.23019422590732574,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.592021658946653,"done":970627.93307558,"finish_reason":"length","first":970617.54734851,"full_response_s":10.614584366092458,"last":970627.916565142,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970617.54734851,2],[970617.68628929,7],[970617.835986195,4],[970618.064884002,63],[970618.347893538,10],[970618.532469904,31],[970618.714465789,29],[970618.865463752,13],[970619.047755229,13],[970619.197049789,20],[970619.390943694,14],[970619.572298998,4],[970619.7279693,13],[970619.91312753,21],[970620.096940965,2],[970620.28184892,18],[970620.473922716,29],[970620.707787868,27],[970620.946784959,22],[970621.133120423,6],[970621.281065591,16],[970621.478033362,10],[970621.659868809,31],[970621.808630658,8],[970621.960222822,8],[970622.111512871,8],[970622.261165383,18],[970622.453674716,24],[970622.639739308,25],[970622.787777566,13],[970622.975133395,11],[970623.124381377,16],[970623.274830871,13],[970623.472094649,8],[970623.618889998,12],[970623.801277503,9],[970623.991868721,29],[970624.181267608,22],[970624.376261843,8],[970624.525552778,18],[970624.710557094,18],[970624.89473632,34],[970625.084449985,10],[970625.272943528,14],[970625.464382296,13],[970625.615616083,2],[970625.79654829,36],[970625.987080837,42],[970626.175555086,26],[970626.33703843,17],[970626.52362427,34],[970626.708801765,12],[970626.894228619,36],[970627.18899979,50],[970627.382927347,2],[970627.670120768,54],[970627.916565142,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-824c817a82104e20924b1cee","runtime":{"accepted":199,"cached":13,"decode_s":10.369,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1939,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970617.318491214,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.22885729605332017,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.5911460603062,"done":970627.93548609,"finish_reason":"length","first":970617.548314993,"full_response_s":10.61672060599085,"last":970627.917900834,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970617.548314993,2],[970617.686102811,7],[970617.834760117,4],[970618.064212353,63],[970618.350367698,10],[970618.534348764,31],[970618.716099967,29],[970618.86622396,13],[970619.048352514,13],[970619.196893043,20],[970619.391845174,14],[970619.571500672,4],[970619.724498477,13],[970619.914116016,21],[970620.096639715,2],[970620.282516136,18],[970620.475938414,29],[970620.709606221,27],[970620.947343916,22],[970621.13114246,6],[970621.280502505,16],[970621.479568131,10],[970621.661020073,31],[970621.809659534,8],[970621.960304916,8],[970622.11210425,8],[970622.262316311,18],[970622.45479303,24],[970622.637049291,25],[970622.790274127,13],[970622.975974928,11],[970623.125518223,16],[970623.27518333,13],[970623.473035878,8],[970623.618725762,12],[970623.801541051,9],[970623.991709062,29],[970624.184380814,22],[970624.377111968,8],[970624.525628374,18],[970624.710908961,18],[970624.895749368,34],[970625.085040771,10],[970625.273311749,14],[970625.469864934,13],[970625.615786223,2],[970625.7976422,36],[970625.987690202,42],[970626.175143178,26],[970626.337956534,17],[970626.523551762,34],[970626.709761748,12],[970626.893854237,36],[970627.189881888,50],[970627.383656428,2],[970627.670603952,54],[970627.917900834,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-cd289cabf19249e4b2b1545d","runtime":{"accepted":199,"cached":13,"decode_s":10.369,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1939,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970617.318765484,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.22954950900748372,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.583422050646913,"done":970627.934611434,"finish_reason":"length","first":970617.546584717,"full_response_s":10.616852535982616,"last":970627.919428639,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970617.546584717,2],[970617.687149131,7],[970617.836855333,4],[970618.064616005,63],[970618.349264056,10],[970618.534412071,31],[970618.717103736,29],[970618.867156117,13],[970619.048861671,13],[970619.198549209,20],[970619.391436513,14],[970619.572866037,4],[970619.729939391,13],[970619.912551338,21],[970620.099523718,2],[970620.282261053,18],[970620.47603587,29],[970620.709012826,27],[970620.94541737,22],[970621.134535491,6],[970621.280712572,16],[970621.477532878,10],[970621.658704502,31],[970621.808833124,8],[970621.960746605,8],[970622.112663799,8],[970622.261379291,18],[970622.452986857,24],[970622.637555871,25],[970622.789313967,13],[970622.97627549,11],[970623.12787708,16],[970623.275356751,13],[970623.471534539,8],[970623.619525272,12],[970623.801420679,9],[970623.994847408,29],[970624.180782184,22],[970624.376724976,8],[970624.525023826,18],[970624.712628015,18],[970624.896986389,34],[970625.085166216,10],[970625.271863237,14],[970625.465100751,13],[970625.615380892,2],[970625.796757637,36],[970625.98683254,42],[970626.175925676,26],[970626.336637643,17],[970626.522934604,34],[970626.709132012,12],[970626.893641658,36],[970627.186572028,50],[970627.383013666,2],[970627.670384476,54],[970627.919428639,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-1b84cd0e319743a583560ff0","runtime":{"accepted":199,"cached":13,"decode_s":10.369,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1939,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970617.317758898,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.22882581898011267,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.400950512033074,"done":970638.628236565,"finish_reason":"length","first":970628.160213267,"full_response_s":10.684113864088431,"last":970638.610625839,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970628.160213267,2],[970628.298242125,7],[970628.454261539,4],[970628.686947726,63],[970628.965279611,10],[970629.151062331,31],[970629.344322987,29],[970629.495285135,13],[970629.674523368,13],[970629.826916884,20],[970630.011803879,14],[970630.197667932,4],[970630.35586444,13],[970630.542714158,21],[970630.726323824,2],[970630.911336697,18],[970631.095983004,29],[970631.337523215,27],[970631.579671206,22],[970631.765111052,6],[970631.914514708,16],[970632.106491729,10],[970632.288953606,31],[970632.453617653,8],[970632.600871375,8],[970632.748927724,8],[970632.898368418,18],[970633.082882687,24],[970633.271442818,25],[970633.431619665,13],[970633.620767733,11],[970633.765590036,16],[970633.921480708,13],[970634.108105698,8],[970634.259535484,12],[970634.452898422,9],[970634.636468065,29],[970634.823531923,22],[970635.007402151,8],[970635.16354442,18],[970635.353226491,18],[970635.544602487,34],[970635.728472091,10],[970635.914469179,14],[970636.100085235,13],[970636.253490483,2],[970636.497787687,36],[970636.667941756,42],[970636.854515283,26],[970637.007862059,17],[970637.195567263,34],[970637.400305201,12],[970637.581756925,36],[970637.868130215,50],[970638.062063924,2],[970638.359229151,54],[970638.610625839,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-7c46428e758744df8f980bac","runtime":{"accepted":199,"cached":13,"decode_s":10.4498,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1924,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970627.944122701,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21609056601300836,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.40052624689555,"done":970638.628075787,"finish_reason":"length","first":970628.160943403,"full_response_s":10.683056217967533,"last":970638.611537682,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970628.160943403,2],[970628.300612005,7],[970628.455085259,4],[970628.688492237,63],[970628.964134334,10],[970629.149978152,31],[970629.344244606,29],[970629.498621077,13],[970629.67571142,13],[970629.825750676,20],[970630.012489432,14],[970630.196053026,4],[970630.357253596,13],[970630.543999634,21],[970630.725681926,2],[970630.910244438,18],[970631.096728599,29],[970631.340188709,27],[970631.575888713,22],[970631.764386517,6],[970631.915708151,16],[970632.107481507,10],[970632.290048281,31],[970632.456098188,8],[970632.60072924,8],[970632.749217532,8],[970632.901555579,18],[970633.084314585,24],[970633.27677145,25],[970633.435984636,13],[970633.619536667,11],[970633.766649089,16],[970633.921375203,13],[970634.106589258,8],[970634.261266887,12],[970634.455825812,9],[970634.636649023,29],[970634.82405428,22],[970635.008229662,8],[970635.167798073,18],[970635.354753252,18],[970635.543371934,34],[970635.727440035,10],[970635.915466861,14],[970636.102221055,13],[970636.254333628,2],[970636.498946004,36],[970636.668807305,42],[970636.854608034,26],[970637.007573948,17],[970637.196874963,34],[970637.398503884,12],[970637.584393929,36],[970637.869087875,50],[970638.061530638,2],[970638.361349255,54],[970638.611537682,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-43c2cb2ec5f9405daa276117","runtime":{"accepted":199,"cached":13,"decode_s":10.45,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1924,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970627.945019569,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21592383401002735,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.401841291192106,"done":970638.628883406,"finish_reason":"length","first":970628.160710373,"full_response_s":10.684586645103991,"last":970638.610741457,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970628.160710373,2],[970628.299014269,7],[970628.456222423,4],[970628.688977421,63],[970628.962252152,10],[970629.151647467,31],[970629.343068156,29],[970629.496013287,13],[970629.676105117,13],[970629.829956456,20],[970630.011713176,14],[970630.196382344,4],[970630.357892549,13],[970630.541600823,21],[970630.727343015,2],[970630.90902659,18],[970631.096251753,29],[970631.339682418,27],[970631.576753159,22],[970631.764099638,6],[970631.914836216,16],[970632.106352378,10],[970632.290372174,31],[970632.454771474,8],[970632.6009748,8],[970632.748816442,8],[970632.898304327,18],[970633.083251563,24],[970633.27195591,25],[970633.431813825,13],[970633.621543876,11],[970633.766979031,16],[970633.921313113,13],[970634.106063428,8],[970634.258913095,12],[970634.452678755,9],[970634.63764781,29],[970634.82331744,22],[970635.00870814,8],[970635.163906431,18],[970635.354833665,18],[970635.544480419,34],[970635.731146879,10],[970635.914251543,14],[970636.100386612,13],[970636.253362446,2],[970636.497690407,36],[970636.668467154,42],[970636.854334182,26],[970637.006588956,17],[970637.19672894,34],[970637.399755752,12],[970637.581608149,36],[970637.869152589,50],[970638.062712893,2],[970638.359872535,54],[970638.610741457,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-83c16a27ae8b4a8daccd19ea","runtime":{"accepted":199,"cached":13,"decode_s":10.4499,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1924,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970627.944296761,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21641361201182008,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.401673510915955,"done":970638.626030048,"finish_reason":"length","first":970628.16085126,"full_response_s":10.681620307965204,"last":970638.610954196,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970628.16085126,2],[970628.298016056,7],[970628.456408965,4],[970628.687537039,63],[970628.961445603,10],[970629.151377327,31],[970629.345876699,29],[970629.500659525,13],[970629.674985605,13],[970629.82560886,20],[970630.0112246,14],[970630.199237102,4],[970630.358566996,13],[970630.542968776,21],[970630.724283056,2],[970630.910840231,18],[970631.097109654,29],[970631.341027535,27],[970631.576311102,22],[970631.771265919,6],[970631.91439304,16],[970632.108680679,10],[970632.289157383,31],[970632.453960621,8],[970632.601298309,8],[970632.750846375,8],[970632.90081829,18],[970633.083039961,24],[970633.275072388,25],[970633.431558487,13],[970633.618318692,11],[970633.772309167,16],[970633.924215955,13],[970634.109424505,8],[970634.260631455,12],[970634.452411047,9],[970634.638223152,29],[970634.825373839,22],[970635.008445297,8],[970635.163666696,18],[970635.353523964,18],[970635.54311218,34],[970635.729063836,10],[970635.915031686,14],[970636.102559158,13],[970636.253885843,2],[970636.498258948,36],[970636.669362019,42],[970636.853520434,26],[970637.008660589,17],[970637.197687159,34],[970637.397739408,12],[970637.581231912,36],[970637.86842812,50],[970638.062847731,2],[970638.359380199,54],[970638.610954196,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-31c960a2d3c1431e9bb4251a","runtime":{"accepted":199,"cached":13,"decode_s":10.4499,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1924,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970627.94440974,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21644151990767568,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.39838217134209,"done":970638.628468155,"finish_reason":"length","first":970628.160365548,"full_response_s":10.684238524991088,"last":970638.611878202,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970628.160365548,2],[970628.299477897,7],[970628.454913551,4],[970628.689381167,63],[970628.962617044,10],[970629.149897883,31],[970629.344101895,29],[970629.495211699,13],[970629.676153285,13],[970629.827224934,20],[970630.012412955,14],[970630.200404862,4],[970630.356176507,13],[970630.541497382,21],[970630.724900933,2],[970630.908127786,18],[970631.096436471,29],[970631.338481325,27],[970631.57562691,22],[970631.768193302,6],[970631.919183041,16],[970632.108468405,10],[970632.290220757,31],[970632.458825931,8],[970632.602746562,8],[970632.7492665,8],[970632.900227202,18],[970633.084752289,24],[970633.271765127,25],[970633.435852598,13],[970633.617339588,11],[970633.767790844,16],[970633.920521736,13],[970634.107376571,8],[970634.258973696,12],[970634.455455064,9],[970634.637710028,29],[970634.822438641,22],[970635.010133332,8],[970635.165625847,18],[970635.353834798,18],[970635.543671535,34],[970635.727837268,10],[970635.914338229,14],[970636.101210394,13],[970636.25396112,2],[970636.497739807,36],[970636.66763057,42],[970636.854827894,26],[970637.008768846,17],[970637.195778705,34],[970637.39987806,12],[970637.581450187,36],[970637.870209048,50],[970638.063323328,2],[970638.361873084,54],[970638.611878202,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-708c7fc21254440d9222af0b","runtime":{"accepted":199,"cached":13,"decode_s":10.45,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1924,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970627.94422963,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21613591792993248,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.395903227062337,"done":970638.626663622,"finish_reason":"length","first":970628.160797139,"full_response_s":10.681435890961438,"last":970638.613371804,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970628.160797139,2],[970628.298604537,7],[970628.454022059,4],[970628.687842465,63],[970628.964553395,10],[970629.150379706,31],[970629.343618887,29],[970629.49765279,13],[970629.67714452,13],[970629.827888564,20],[970630.014304035,14],[970630.196861943,4],[970630.356329204,13],[970630.541760865,21],[970630.726435042,2],[970630.908959251,18],[970631.097420153,29],[970631.337756566,27],[970631.577454698,22],[970631.764603705,6],[970631.915120695,16],[970632.107625146,10],[970632.289953641,31],[970632.456299949,8],[970632.600353978,8],[970632.74982736,8],[970632.898846336,18],[970633.083326743,24],[970633.273445818,25],[970633.431495949,13],[970633.616931041,11],[970633.768746408,16],[970633.921624796,13],[970634.109354638,8],[970634.259312072,12],[970634.452206725,9],[970634.63671513,29],[970634.824442711,22],[970635.008602587,8],[970635.164339781,18],[970635.354063028,18],[970635.545071651,34],[970635.728109408,10],[970635.913644148,14],[970636.100818699,13],[970636.254062336,2],[970636.49756834,36],[970636.668208023,42],[970636.853586284,26],[970637.006892446,17],[970637.198224127,34],[970637.39796002,12],[970637.582161071,36],[970637.869414616,50],[970638.061110282,2],[970638.360455478,54],[970638.613371804,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-492cfb928778413ea4b4dfaa","runtime":{"accepted":199,"cached":13,"decode_s":10.4501,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1924,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970627.945227731,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21556940802838653,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.404540257108216,"done":970638.627525938,"finish_reason":"length","first":970628.163059065,"full_response_s":10.682419299031608,"last":970638.611934451,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970628.163059065,2],[970628.298749457,7],[970628.454330926,4],[970628.688269512,63],[970628.961569959,10],[970629.151444266,31],[970629.343204115,29],[970629.495124821,13],[970629.67475051,13],[970629.825297497,20],[970630.011316839,14],[970630.196316253,4],[970630.355759414,13],[970630.541041547,21],[970630.725068609,2],[970630.910938728,18],[970631.098054369,29],[970631.338174506,27],[970631.575291319,22],[970631.767172846,6],[970631.917181193,16],[970632.107332298,10],[970632.289749656,31],[970632.455738145,8],[970632.602683752,8],[970632.749177381,8],[970632.899555428,18],[970633.084044093,24],[970633.271886507,25],[970633.432021411,13],[970633.618161995,11],[970633.766759011,16],[970633.921157951,13],[970634.106204411,8],[970634.259057534,12],[970634.452841645,9],[970634.636798775,29],[970634.822844979,22],[970635.008814605,8],[970635.166320904,18],[970635.355504895,18],[970635.543816263,34],[970635.728055511,10],[970635.915351338,14],[970636.099957406,13],[970636.254179891,2],[970636.497441151,36],[970636.667543067,42],[970636.854941801,26],[970637.006804143,17],[970637.198424575,34],[970637.398431057,12],[970637.581683105,36],[970637.86872868,50],[970638.06307524,2],[970638.36049574,54],[970638.611934451,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-63accd67a0be4f019ee2d71a","runtime":{"accepted":199,"cached":13,"decode_s":10.45,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1924,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970627.945106639,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2179524260573089,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.39608254887795,"done":970638.627139091,"finish_reason":"length","first":970628.161737006,"full_response_s":10.681653556996025,"last":970638.61423484,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970628.161737006,2],[970628.298323579,7],[970628.454175093,4],[970628.696115928,63],[970628.961320606,10],[970629.149779975,31],[970629.343693027,29],[970629.495031878,13],[970629.675201288,13],[970629.825832161,20],[970630.012095815,14],[970630.196126366,4],[970630.35687395,13],[970630.543217633,21],[970630.724196065,2],[970630.909400379,18],[970631.096317283,29],[970631.338967773,27],[970631.577610692,22],[970631.767930027,6],[970631.914664316,16],[970632.107935917,10],[970632.290147369,31],[970632.454599718,8],[970632.60197826,8],[970632.750559304,8],[970632.898101382,18],[970633.08412273,24],[970633.276864249,25],[970633.433648269,13],[970633.619396212,11],[970633.768945337,16],[970633.922647523,13],[970634.106669239,8],[970634.259256799,12],[970634.451932761,9],[970634.639303824,29],[970634.823866874,22],[970635.00827751,8],[970635.165956237,18],[970635.355278458,18],[970635.544534332,34],[970635.72790435,10],[970635.914710034,14],[970636.101681287,13],[970636.254984038,2],[970636.497490183,36],[970636.667240122,42],[970636.853633684,26],[970637.006654711,17],[970637.196081458,34],[970637.398189881,12],[970637.583225708,36],[970637.86796374,50],[970638.061766468,2],[970638.360360358,54],[970638.61423484,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-5ae96574999b484e9fe23114","runtime":{"accepted":199,"cached":13,"decode_s":10.45,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1924,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970627.945485534,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21625147201120853,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.40204369218059,"done":970638.628645415,"finish_reason":"length","first":970628.162932308,"full_response_s":10.683337254915386,"last":970638.612876715,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970628.162932308,2],[970628.298497735,7],[970628.454488408,4],[970628.686372447,63],[970628.961144977,10],[970629.150429795,31],[970629.34518857,29],[970629.49607629,13],[970629.674687155,13],[970629.827753885,20],[970630.012344384,14],[970630.196797868,4],[970630.356091325,13],[970630.542616686,21],[970630.724366109,2],[970630.908201734,18],[970631.097814425,29],[970631.340267506,27],[970631.576225632,22],[970631.763819784,6],[970631.914595649,16],[970632.108984025,10],[970632.290905606,31],[970632.454252045,8],[970632.601386051,8],[970632.750215903,8],[970632.898175714,18],[970633.083642187,24],[970633.272309728,25],[970633.435912192,13],[970633.618620742,11],[970633.768304976,16],[970633.923073768,13],[970634.105835407,8],[970634.259487748,12],[970634.45275051,9],[970634.637282502,29],[970634.823977372,22],[970635.008112715,8],[970635.164645159,18],[970635.356873422,18],[970635.544337052,34],[970635.728600992,10],[970635.914654089,14],[970636.102705374,13],[970636.25425992,2],[970636.497534238,36],[970636.668121753,42],[970636.853968539,26],[970637.009074288,17],[970637.196429003,34],[970637.397425341,12],[970637.581306532,36],[970637.868812326,50],[970638.061992281,2],[970638.361640246,54],[970638.612876715,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-6f2294101ffb413c932ed0af","runtime":{"accepted":199,"cached":13,"decode_s":10.45,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1924,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970627.94530816,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21762414800468832,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.40228825783847,"done":970638.628383421,"finish_reason":"length","first":970628.161278643,"full_response_s":10.68386611097958,"last":970638.611118318,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970628.161278643,2],[970628.299869418,7],[970628.455324802,4],[970628.686647164,63],[970628.961405052,10],[970629.149433566,31],[970629.342727012,29],[970629.497724818,13],[970629.675427998,13],[970629.825686169,20],[970630.012709212,14],[970630.198822842,4],[970630.356722373,13],[970630.541328842,21],[970630.725297303,2],[970630.908827597,18],[970631.09554218,29],[970631.339329512,27],[970631.575721725,22],[970631.764853538,6],[970631.915275088,16],[970632.107036282,10],[970632.289548823,31],[970632.456521697,8],[970632.600462828,8],[970632.74898815,8],[970632.898927869,18],[970633.086496158,24],[970633.272560905,25],[970633.431700383,13],[970633.62104405,11],[970633.769714039,16],[970633.922069956,13],[970634.110085589,8],[970634.259796007,12],[970634.452340267,9],[970634.637017323,29],[970634.825986163,22],[970635.009061558,8],[970635.165228742,18],[970635.35454285,18],[970635.546942484,34],[970635.72948248,10],[970635.914169722,14],[970636.100621899,13],[970636.253658766,2],[970636.498141361,36],[970636.670198939,42],[970636.854098128,26],[970637.006482827,17],[970637.19625147,34],[970637.397534399,12],[970637.583532045,36],[970637.870144926,50],[970638.061696105,2],[970638.360050836,54],[970638.611118318,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-2b0c38af49dd4ef7b8598042","runtime":{"accepted":199,"cached":13,"decode_s":10.4499,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1924,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970627.94451731,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21676133293658495,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.399991319630168,"done":970638.626751973,"finish_reason":"length","first":970628.16053772,"full_response_s":10.681816993979737,"last":970638.61136111,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970628.16053772,2],[970628.299241298,7],[970628.455396302,4],[970628.687047742,63],[970628.962403425,10],[970629.150188859,31],[970629.343272526,29],[970629.498522293,13],[970629.676014526,13],[970629.827022005,20],[970630.011080848,14],[970630.195683365,4],[970630.357763456,13],[970630.541877172,21],[970630.725967781,2],[970630.90839623,18],[970631.09867255,29],[970631.338055671,27],[970631.579201417,22],[970631.768095846,6],[970631.916470532,16],[970632.106819654,10],[970632.290506068,31],[970632.458585124,8],[970632.602148496,8],[970632.751143656,8],[970632.898528316,18],[970633.083373695,24],[970633.275026829,25],[970633.433214166,13],[970633.619651662,11],[970633.767028367,16],[970633.920288834,13],[970634.106506621,8],[970634.2588234,12],[970634.452466704,9],[970634.637095832,29],[970634.824881919,22],[970635.008346849,8],[970635.164797424,18],[970635.357111749,18],[970635.545497033,34],[970635.7285293,10],[970635.915303954,14],[970636.101831455,13],[970636.253746685,2],[970636.497906683,36],[970636.668909626,42],[970636.854458666,26],[970637.010115177,17],[970637.197186534,34],[970637.398066949,12],[970637.581959406,36],[970637.868892147,50],[970638.061915324,2],[970638.361204591,54],[970638.61136111,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-de23587fccc8488ba8a56096","runtime":{"accepted":199,"cached":13,"decode_s":10.4499,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1924,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970627.944934979,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2156027409946546,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.393277432374425,"done":970638.626424047,"finish_reason":"length","first":970628.160293312,"full_response_s":10.68180275207851,"last":970638.613993136,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970628.160293312,2],[970628.298169617,7],[970628.45482768,4],[970628.688183866,63],[970628.961230255,10],[970629.151725208,31],[970629.34335806,29],[970629.495477183,13],[970629.677238808,13],[970629.825532832,20],[970630.012577255,14],[970630.196592235,4],[970630.359576762,13],[970630.543037475,21],[970630.729070291,2],[970630.907972881,18],[970631.098128061,29],[970631.341575001,27],[970631.576371144,22],[970631.770058296,6],[970631.914082205,16],[970632.107120168,10],[970632.28962682,31],[970632.455519773,8],[970632.602083254,8],[970632.750069639,8],[970632.898630668,18],[970633.084405832,24],[970633.273390481,25],[970633.431375722,13],[970633.616995228,11],[970633.767980939,16],[970633.921238237,13],[970634.108233159,8],[970634.260114651,12],[970634.453975398,9],[970634.638138274,29],[970634.822253219,22],[970635.012227866,8],[970635.168336689,18],[970635.354646035,18],[970635.544233995,34],[970635.73006163,10],[970635.916756207,14],[970636.100147741,13],[970636.2543829,2],[970636.497832223,36],[970636.668604648,42],[970636.85417246,26],[970637.007391535,17],[970637.197761475,34],[970637.399516721,12],[970637.58069384,36],[970637.869821258,50],[970638.062408796,2],[970638.359953236,54],[970638.613993136,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-fe271bdd51f44a84a7a70702","runtime":{"accepted":199,"cached":13,"decode_s":10.4499,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1924,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970627.944621295,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2156720170751214,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.401123587305165,"done":970638.624773188,"finish_reason":"length","first":970628.160174188,"full_response_s":10.68007005599793,"last":970638.610512636,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970628.160174188,2],[970628.300833529,7],[970628.453663312,4],[970628.686267101,63],[970628.961035583,10],[970629.149273332,31],[970629.344655602,29],[970629.494879196,13],[970629.674407797,13],[970629.825200745,20],[970630.014381615,14],[970630.195795687,4],[970630.356664027,13],[970630.541184851,21],[970630.724071517,2],[970630.908308712,18],[970631.095879628,29],[970631.338868204,27],[970631.575432638,22],[970631.763949789,6],[970631.913938053,16],[970632.107831596,10],[970632.290428775,31],[970632.453861965,8],[970632.600802772,8],[970632.74835219,8],[970632.90122138,18],[970633.082793856,24],[970633.271699372,25],[970633.434973446,13],[970633.616378583,11],[970633.766442815,16],[970633.921049694,13],[970634.106414126,8],[970634.258669887,12],[970634.454269254,9],[970634.637214971,29],[970634.823749046,22],[970635.007738238,8],[970635.164551768,18],[970635.353397207,18],[970635.543536441,34],[970635.727316143,10],[970635.913436147,14],[970636.099802549,13],[970636.254642574,2],[970636.497295591,36],[970636.667091586,42],[970636.856247293,26],[970637.006399806,17],[970637.196992294,34],[970637.399093836,12],[970637.580533494,36],[970637.867871581,50],[970638.061330765,2],[970638.359676167,54],[970638.610512636,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-a426fbb4bd2040d6bbda7364","runtime":{"accepted":199,"cached":13,"decode_s":10.4498,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1924,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970627.944703132,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2154710559407249,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.39948773290179,"done":970638.627839877,"finish_reason":"length","first":970628.161106886,"full_response_s":10.682313377037644,"last":970638.612145973,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970628.161106886,2],[970628.299170054,7],[970628.456083248,4],[970628.687957796,63],[970628.961728738,10],[970629.151209539,31],[970629.343423847,29],[970629.495744667,13],[970629.675113146,13],[970629.82607737,20],[970630.011498517,14],[970630.195862322,4],[970630.355547668,13],[970630.543649176,21],[970630.727585919,2],[970630.909094233,18],[970631.096798786,29],[970631.338333652,27],[970631.578789445,22],[970631.769525713,6],[970631.914155657,16],[970632.106604851,10],[970632.289284236,31],[970632.454857232,8],[970632.602956949,8],[970632.749761301,8],[970632.899770295,18],[970633.083727577,24],[970633.272757609,25],[970633.432251737,13],[970633.618054633,11],[970633.766810076,16],[970633.921684293,13],[970634.10726148,8],[970634.25965952,12],[970634.452068831,9],[970634.63849222,29],[970634.824676782,22],[970635.007557665,8],[970635.164203343,18],[970635.353751953,18],[970635.54360626,34],[970635.728353608,10],[970635.916827818,14],[970636.101274389,13],[970636.255450322,2],[970636.49849113,36],[970636.667871649,42],[970636.85535422,26],[970637.007482318,17],[970637.19742102,34],[970637.401538697,12],[970637.581026695,36],[970637.871801402,50],[970638.061456178,2],[970638.362502177,54],[970638.612145973,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-06b5a8cc9e7843289e5f9e2d","runtime":{"accepted":199,"cached":13,"decode_s":10.4501,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1924,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970627.9455265,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2155803859932348,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.40093235791885,"done":970638.627766201,"finish_reason":"length","first":970628.161035594,"full_response_s":10.682387453038245,"last":970638.611455941,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970628.161035594,2],[970628.299342083,7],[970628.455012815,4],[970628.68655987,63],[970628.965854762,10],[970629.150746055,31],[970629.345415327,29],[970629.497122686,13],[970629.677328439,13],[970629.827383841,20],[970630.011413127,14],[970630.195953281,4],[970630.35659784,13],[970630.543083227,21],[970630.725586054,2],[970630.908884694,18],[970631.098973912,29],[970631.341515279,27],[970631.578494821,22],[970631.766139093,6],[970631.914769854,16],[970632.107186418,10],[970632.290301603,31],[970632.454688053,8],[970632.601067855,8],[970632.748870275,8],[970632.899999965,18],[970633.083773393,24],[970633.271233616,25],[970633.434908315,13],[970633.617184363,11],[970633.767256245,16],[970633.920184352,13],[970634.105945425,8],[970634.259185971,12],[970634.452274961,9],[970634.637786809,29],[970634.822077574,22],[970635.008169156,8],[970635.168673704,18],[970635.35505759,18],[970635.543749228,34],[970635.727955175,10],[970635.913904543,14],[970636.100722811,13],[970636.253816232,2],[970636.498807181,36],[970636.667712983,42],[970636.854228005,26],[970637.008585825,17],[970637.197096855,34],[970637.397885336,12],[970637.582970498,36],[970637.868486337,50],[970638.062219789,2],[970638.359751252,54],[970638.611455941,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-3d25e87167d744a4abbc60bc","runtime":{"accepted":199,"cached":13,"decode_s":10.45,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1924,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970627.945378748,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21565684594679624,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":24.401240359320777,"done":970638.627256742,"finish_reason":"length","first":970628.160760333,"full_response_s":10.683237049961463,"last":970638.611048771,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970628.160760333,2],[970628.29906106,7],[970628.457802828,4],[970628.689966848,63],[970628.961833027,10],[970629.153577577,31],[970629.34290797,29],[970629.495652332,13],[970629.674815016,13],[970629.825951605,20],[970630.011546429,14],[970630.197480365,4],[970630.355661958,13],[970630.54378619,21],[970630.724985603,2],[970630.912054751,18],[970631.099922083,29],[970631.338257464,27],[970631.57603216,22],[970631.764047597,6],[970631.914933704,16],[970632.108817566,10],[970632.290716839,31],[970632.454481475,8],[970632.600627735,8],[970632.748611753,8],[970632.898462241,18],[970633.082955387,24],[970633.272488141,25],[970633.432690241,13],[970633.616503771,11],[970633.768224419,16],[970633.921824988,13],[970634.105671156,8],[970634.258537529,12],[970634.455221986,9],[970634.638041666,29],[970634.822377959,22],[970635.009360422,8],[970635.165467581,18],[970635.35392134,18],[970635.543465486,34],[970635.728662858,10],[970635.913271496,14],[970636.102393371,13],[970636.256363719,2],[970636.498313485,36],[970636.669202009,42],[970636.856542156,26],[970637.006732596,17],[970637.195975265,34],[970637.400418627,12],[970637.582315336,36],[970637.869316792,50],[970638.062327055,2],[970638.359481544,54],[970638.611048771,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-7075084fa2f345ca9bcf7ac0","runtime":{"accepted":199,"cached":13,"decode_s":10.4499,"drafted":353,"drafts":true,"min_rows":4,"prefill_s":0.1924,"rounds":56,"token_sha":"2b28aa2108de"},"seed":1234,"sent":970627.944019692,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21674064092803746,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":199,"drafted":353,"rounds":56},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":1,"burst":null,"stream":0,"phase":"warmup","request":{"cache_state":"cold","cached_tokens":0,"case_id":null,"complete":true,"decode_tps":60.92182866976525,"done":970639.004527792,"finish_reason":"length","first":970638.757039636,"full_response_s":0.36765393894165754,"last":970639.003256802,"output_sha256":"6bffe2c2436146ed3af0e8c4e21d88b3dddfbe4a47910e8940f3039340788c85","pieces":[[970638.757039636,3],[970638.838901777,26],[970638.922056096,15],[970639.003256802,30]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":16,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"c81230cadd07c8b22d2a507aa18b8b00964a157b29ba5c65c8fdf55148cf2238","response_id":"chatcmpl-8447d8c6f9374d24bf196b4b","runtime":{"accepted":12,"cached":0,"decode_s":0.2462,"drafted":45,"drafts":true,"min_rows":16,"prefill_s":0.1135,"rounds":3,"token_sha":"a9100b9c265b"},"seed":1234,"sent":970638.636873853,"speculative":{},"token_sha":"a9100b9c265b","tokens":16,"ttft_s":0.12016578298062086,"usage":{"completion_tokens":16,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":0},"total_tokens":47},"work":{"accepted":12,"drafted":45,"rounds":3},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":1,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":50.29074298417386,"done":970644.19862564,"finish_reason":"length","first":970639.127071651,"full_response_s":5.185942225041799,"last":970644.197587314,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970639.127071651,3],[970639.208528975,26],[970639.289523152,15],[970639.376381334,34],[970639.4621579,21],[970639.542827384,25],[970639.623475249,14],[970639.704070786,14],[970639.785383126,18],[970639.865957362,26],[970639.947732041,13],[970640.028985163,13],[970640.110374787,13],[970640.191058313,23],[970640.274634211,32],[970640.361030788,7],[970640.445772026,23],[970640.526736813,9],[970640.607252937,13],[970640.687775349,15],[970640.768232471,19],[970640.848995198,17],[970640.930232662,23],[970641.011132055,9],[970641.092395026,17],[970641.17312308,3],[970641.254244444,21],[970641.33989742,10],[970641.426903205,24],[970641.508100854,19],[970641.588723034,14],[970641.669509737,13],[970641.750093751,5],[970641.830636985,22],[970641.911895003,13],[970641.99254782,51],[970642.074677835,15],[970642.155607848,6],[970642.237620948,8],[970642.321813871,9],[970642.409295371,16],[970642.490971505,16],[970642.571933875,9],[970642.652444222,32],[970642.73360192,18],[970642.814642302,13],[970642.895587446,11],[970642.976849009,15],[970643.058105947,8],[970643.138957716,18],[970643.220042258,25],[970643.294706569,19],[970643.381917807,8],[970643.466173003,40],[970643.547254073,16],[970643.627969484,64],[970643.709090848,6],[970643.789763148,6],[970643.872248457,11],[970643.954075894,15],[970644.035101923,17],[970644.116765014,21],[970644.197587314,14]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-5ebcdad40510426f85dcba97","runtime":{"accepted":193,"cached":30,"decode_s":5.0702,"drafted":930,"drafts":true,"min_rows":16,"prefill_s":0.1114,"rounds":62,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970639.012683415,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.11438823607750237,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":193,"drafted":930,"rounds":62},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":1,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":50.083615617884185,"done":970649.420225079,"finish_reason":"length","first":970644.327722543,"full_response_s":5.212914303061552,"last":970649.419207989,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970644.327722543,3],[970644.413782995,26],[970644.496899247,15],[970644.57954099,34],[970644.662148152,21],[970644.743073861,25],[970644.823834595,14],[970644.905530883,14],[970644.986171578,18],[970645.067384973,26],[970645.148311393,13],[970645.228949432,13],[970645.311318115,13],[970645.398231174,23],[970645.481574221,32],[970645.562460268,7],[970645.6428322,23],[970645.723884833,9],[970645.80574033,13],[970645.887737251,15],[970645.969127834,19],[970646.05082789,17],[970646.131399606,23],[970646.212490461,9],[970646.295415561,17],[970646.383328497,3],[970646.466825608,21],[970646.547658454,10],[970646.628892052,24],[970646.711415632,19],[970646.792939628,14],[970646.874594057,13],[970646.95599393,5],[970647.036580712,22],[970647.118386521,13],[970647.199085801,51],[970647.280084282,15],[970647.367957954,6],[970647.453335084,8],[970647.535028123,9],[970647.61589255,16],[970647.696936141,16],[970647.777964162,9],[970647.85883664,32],[970647.940436328,18],[970648.021646097,13],[970648.103100274,11],[970648.183856564,15],[970648.266831526,8],[970648.354155133,18],[970648.440135646,25],[970648.514644638,19],[970648.595998655,8],[970648.676856704,40],[970648.757921795,16],[970648.83881013,64],[970648.920325668,6],[970649.002959544,6],[970649.084825394,11],[970649.165919762,15],[970649.246972971,17],[970649.331129249,21],[970649.419207989,14]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-81daaac6241d417abcb5a558","runtime":{"accepted":193,"cached":30,"decode_s":5.0914,"drafted":930,"drafts":true,"min_rows":16,"prefill_s":0.117,"rounds":62,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970644.207310776,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12041176704224199,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":193,"drafted":930,"rounds":62},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":1,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":50.25379053096415,"done":970654.615515425,"finish_reason":"length","first":970649.540355502,"full_response_s":5.187262702966109,"last":970654.6145996,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970649.540355502,3],[970649.622744491,26],[970649.704469343,15],[970649.785928857,34],[970649.867234537,21],[970649.948916782,25],[970650.030229304,14],[970650.111901403,14],[970650.192715095,18],[970650.275391689,26],[970650.362279847,13],[970650.446930786,13],[970650.527616361,13],[970650.608205857,23],[970650.689210058,32],[970650.769965564,7],[970650.850448839,23],[970650.932197294,9],[970651.012747688,13],[970651.094143624,15],[970651.174643177,19],[970651.255497107,17],[970651.340798012,23],[970651.427310421,9],[970651.508042988,17],[970651.588866353,3],[970651.669319419,21],[970651.750207738,10],[970651.830825209,24],[970651.912453253,19],[970651.993193845,14],[970652.075429969,13],[970652.155920874,5],[970652.236770219,22],[970652.32186822,13],[970652.40906628,51],[970652.491363918,15],[970652.572066504,6],[970652.652787189,8],[970652.73379019,9],[970652.814834365,16],[970652.895664339,16],[970652.977273077,9],[970653.058561892,32],[970653.139597947,18],[970653.220764246,13],[970653.301784027,11],[970653.389230868,15],[970653.473927356,8],[970653.554956514,18],[970653.635852707,25],[970653.709515152,19],[970653.790580828,8],[970653.871497022,40],[970653.953326266,16],[970654.034328292,64],[970654.116237405,6],[970654.197051418,6],[970654.280474993,11],[970654.367218018,15],[970654.452532258,17],[970654.533694166,21],[970654.6145996,14]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-59fb22114adc460b86bcd4a2","runtime":{"accepted":193,"cached":30,"decode_s":5.0741,"drafted":930,"drafts":true,"min_rows":16,"prefill_s":0.1091,"rounds":62,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970649.428252722,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.11210278002545238,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":193,"drafted":930,"rounds":62},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.076641945033614,"done":970668.232593119,"finish_reason":"length","first":970654.849397064,"full_response_s":13.597697301069275,"last":970668.216529536,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970654.849397064,3],[970654.989268024,11],[970655.168058825,30],[970655.352111781,19],[970655.502907353,21],[970655.688440878,15],[970655.835302513,19],[970655.985101053,17],[970656.136716022,6],[970656.289830938,11],[970656.449861402,5],[970656.629047733,27],[970656.813895703,12],[970656.997898304,13],[970657.148239717,5],[970657.294997962,16],[970657.488673212,5],[970657.675608784,16],[970657.858785001,7],[970658.006204811,22],[970658.158646957,10],[970658.349311073,7],[970658.536609111,23],[970658.689766009,5],[970658.844046992,9],[970659.012852685,14],[970659.164979106,20],[970659.31959569,8],[970659.478160299,12],[970659.625341516,5],[970659.773885651,14],[970659.925872192,11],[970660.078650238,7],[970660.226892187,9],[970660.38816213,8],[970660.560987808,3],[970660.741777813,10],[970660.892561861,11],[970661.077861299,9],[970661.266229309,10],[970661.460306509,20],[970661.607301149,14],[970661.793458672,14],[970662.024946518,13],[970662.177213164,5],[970662.361100233,14],[970662.596512587,11],[970662.832199921,32],[970663.021719713,33],[970663.174566133,11],[970663.367548029,6],[970663.516637756,8],[970663.671474405,9],[970663.822578392,13],[970663.973072486,8],[970664.123023056,20],[970664.27440471,17],[970664.434720321,20],[970664.592365487,13],[970664.745088389,2],[970664.890429216,16],[970665.078708996,6],[970665.227376029,15],[970665.390966418,8],[970665.576732195,15],[970665.759771407,16],[970665.995334232,27],[970666.285064691,4],[970666.441050936,8],[970666.58727171,25],[970666.738308649,18],[970666.888641137,13],[970667.076383575,55],[970667.232129035,11],[970667.424382054,10],[970667.575865434,11],[970667.72568912,15],[970667.877552924,17],[970668.028956057,14],[970668.216529536,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-2fe431999b904c95bc2dd1c3","runtime":{"accepted":176,"cached":30,"decode_s":13.3681,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1905,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970654.634895818,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21450124599505216,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":1,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.07613189935667,"done":970668.230021141,"finish_reason":"length","first":970654.848539073,"full_response_s":13.5977345489664,"last":970668.216028947,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970654.848539073,3],[970654.986966446,11],[970655.16745049,30],[970655.35082233,19],[970655.503842204,21],[970655.687483831,15],[970655.836121633,19],[970655.985718238,17],[970656.137494976,6],[970656.290243099,11],[970656.450232548,5],[970656.628875914,27],[970656.813794871,12],[970656.996161808,13],[970657.149477607,5],[970657.294577448,16],[970657.488986285,5],[970657.67279756,16],[970657.858656053,7],[970658.007099815,22],[970658.159129304,10],[970658.348472222,7],[970658.53711503,23],[970658.691507977,5],[970658.843786023,9],[970659.014468953,14],[970659.166111202,20],[970659.320318507,8],[970659.477570847,12],[970659.625631402,5],[970659.779920895,14],[970659.926328327,11],[970660.078483524,7],[970660.224922536,9],[970660.388776322,8],[970660.558772855,3],[970660.743951383,10],[970660.890827128,11],[970661.078075476,9],[970661.26675651,10],[970661.462317654,20],[970661.608817144,14],[970661.795720991,14],[970662.025956498,13],[970662.178389715,5],[970662.362767628,14],[970662.596876211,11],[970662.832146744,32],[970663.019567908,33],[970663.175231196,11],[970663.365975082,6],[970663.516941179,8],[970663.672534681,9],[970663.82242032,13],[970663.971514517,8],[970664.123201979,20],[970664.275641077,17],[970664.431768825,20],[970664.590153306,13],[970664.742140686,2],[970664.891250558,16],[970665.079935217,6],[970665.229052719,15],[970665.391098919,8],[970665.577937261,15],[970665.760759447,16],[970665.996806283,27],[970666.284483689,4],[970666.44133826,8],[970666.58630196,25],[970666.737195581,18],[970666.889269842,13],[970667.077241659,55],[970667.23043367,11],[970667.427641386,10],[970667.576896409,11],[970667.724500057,15],[970667.877427753,17],[970668.028513317,14],[970668.216028947,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-869fb7f0effa479a82da8184","runtime":{"accepted":176,"cached":30,"decode_s":13.3681,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1905,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970654.632286592,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2162524809828028,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":2,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.075923313408452,"done":970668.232055293,"finish_reason":"length","first":970654.848683479,"full_response_s":13.602327856002375,"last":970668.21631952,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970654.848683479,3],[970654.988491838,11],[970655.168875498,30],[970655.351439499,19],[970655.502982245,21],[970655.691065194,15],[970655.836195213,19],[970655.986399257,17],[970656.136925319,6],[970656.291226565,11],[970656.450578811,5],[970656.632060958,27],[970656.81727436,12],[970656.996764814,13],[970657.148749221,5],[970657.293898814,16],[970657.489969735,5],[970657.672272278,16],[970657.857292448,7],[970658.008127415,22],[970658.15938464,10],[970658.351095928,7],[970658.535552594,23],[970658.690159158,5],[970658.84068842,9],[970659.014170906,14],[970659.166550951,20],[970659.319197756,8],[970659.476978179,12],[970659.624260964,5],[970659.774646441,14],[970659.926842231,11],[970660.078697718,7],[970660.225918083,9],[970660.388501575,8],[970660.559047346,3],[970660.743443304,10],[970660.890334683,11],[970661.078404871,9],[970661.265200333,10],[970661.459704448,20],[970661.611910377,14],[970661.794477934,14],[970662.025869013,13],[970662.179181598,5],[970662.361559265,14],[970662.59628852,11],[970662.831280594,32],[970663.019655697,33],[970663.173754056,11],[970663.364830936,6],[970663.516086727,8],[970663.67323783,9],[970663.821621557,13],[970663.971820597,8],[970664.122387918,20],[970664.273790808,17],[970664.431888412,20],[970664.588623709,13],[970664.744216942,2],[970664.891425193,16],[970665.077353475,6],[970665.22891617,15],[970665.390270247,8],[970665.575818454,15],[970665.760247528,16],[970665.994861872,27],[970666.286937187,4],[970666.440611684,8],[970666.589714854,25],[970666.738567088,18],[970666.889632921,13],[970667.07988981,55],[970667.233096223,11],[970667.425456107,10],[970667.577758205,11],[970667.725760315,15],[970667.875578669,17],[970668.027854929,14],[970668.21631952,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-cdb4fd43e9af436a8752ce54","runtime":{"accepted":176,"cached":30,"decode_s":13.368,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1905,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970654.629727437,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2189560419647023,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":3,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.075914982458492,"done":970668.23186536,"finish_reason":"length","first":970654.849267539,"full_response_s":13.600293393013999,"last":970668.216909418,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970654.849267539,3],[970654.986135596,11],[970655.167296209,30],[970655.349852706,19],[970655.502656706,21],[970655.687773381,15],[970655.83526774,19],[970655.985497739,17],[970656.137122838,6],[970656.288616475,11],[970656.451901978,5],[970656.628291375,27],[970656.814406759,12],[970656.995650336,13],[970657.147796992,5],[970657.294479241,16],[970657.489353767,5],[970657.673122795,16],[970657.857814034,7],[970658.006254755,22],[970658.158517833,10],[970658.348609939,7],[970658.535655522,23],[970658.689358857,5],[970658.840283717,9],[970659.014533827,14],[970659.166664328,20],[970659.319098765,8],[970659.477988432,12],[970659.623422001,5],[970659.773292246,14],[970659.927417873,11],[970660.075397076,7],[970660.22412502,9],[970660.3895089,8],[970660.558201454,3],[970660.743764842,10],[970660.892070361,11],[970661.076392606,9],[970661.264963192,10],[970661.45886795,20],[970661.607238003,14],[970661.794946295,14],[970662.025521727,13],[970662.177260948,5],[970662.36347809,14],[970662.595608735,11],[970662.833611771,32],[970663.021569849,33],[970663.173517395,11],[970663.366322591,6],[970663.515742738,8],[970663.671349042,9],[970663.821545929,13],[970663.971657996,8],[970664.124427593,20],[970664.273519902,17],[970664.432173976,20],[970664.589974078,13],[970664.741970227,2],[970664.889826131,16],[970665.077539103,6],[970665.228543505,15],[970665.390340178,8],[970665.575484194,15],[970665.760984426,16],[970665.99422723,27],[970666.284163304,4],[970666.439401098,8],[970666.586134703,25],[970666.736787358,18],[970666.88905096,13],[970667.07606327,55],[970667.231997606,11],[970667.42411142,10],[970667.575111526,11],[970667.725238475,15],[970667.87679372,17],[970668.029359223,14],[970668.216909418,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-eb81e9a4fd384d40b86eaaa7","runtime":{"accepted":176,"cached":30,"decode_s":13.368,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1905,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970654.631571967,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21769557194784284,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":4,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.07396556615393,"done":970668.230763575,"finish_reason":"length","first":970654.848162118,"full_response_s":13.598599482909776,"last":970668.21717021,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970654.848162118,3],[970654.988299168,11],[970655.167645288,30],[970655.351635594,19],[970655.503428299,21],[970655.689151885,15],[970655.834734232,19],[970655.985659829,17],[970656.137390112,6],[970656.289681282,11],[970656.450391405,5],[970656.630732445,27],[970656.813064693,12],[970656.996017337,13],[970657.14931771,5],[970657.294693786,16],[970657.489753413,5],[970657.672190713,16],[970657.858610574,7],[970658.006507914,22],[970658.158420922,10],[970658.348916275,7],[970658.535716348,23],[970658.69123691,5],[970658.840609304,9],[970659.014408463,14],[970659.165813028,20],[970659.318444391,8],[970659.476796726,12],[970659.624971875,5],[970659.773967599,14],[970659.92621767,11],[970660.077553396,7],[970660.225030985,9],[970660.38865131,8],[970660.560562542,3],[970660.743129463,10],[970660.891842389,11],[970661.077144595,9],[970661.265145588,10],[970661.458707077,20],[970661.609013815,14],[970661.794249098,14],[970662.02404689,13],[970662.17793582,5],[970662.359462796,14],[970662.596029456,11],[970662.833023792,32],[970663.02240329,33],[970663.177495146,11],[970663.366798937,6],[970663.519560769,8],[970663.67179023,9],[970663.822972149,13],[970663.972809309,8],[970664.122843156,20],[970664.274087541,17],[970664.431661705,20],[970664.588722669,13],[970664.742721063,2],[970664.891820278,16],[970665.077999446,6],[970665.227862856,15],[970665.390530127,8],[970665.576438886,15],[970665.762709124,16],[970665.994466467,27],[970666.28440979,4],[970666.439542079,8],[970666.586735579,25],[970666.739427189,18],[970666.888837487,13],[970667.076948606,55],[970667.230637542,11],[970667.425376926,10],[970667.575166591,11],[970667.725886894,15],[970667.875895854,17],[970668.028683248,14],[970668.21717021,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-19c5d0420ccb4f2482ed83ec","runtime":{"accepted":176,"cached":30,"decode_s":13.3681,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1905,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970654.632164092,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21599802596028894,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":5,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.07637248378942,"done":970668.23220674,"finish_reason":"length","first":970654.848752722,"full_response_s":13.59923996089492,"last":970668.21607401,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970654.848752722,3],[970654.985848575,11],[970655.166944682,30],[970655.350175365,19],[970655.502326942,21],[970655.686915438,15],[970655.833917864,19],[970655.985185642,17],[970656.136393731,6],[970656.289535932,11],[970656.450647941,5],[970656.630630237,27],[970656.814313928,12],[970656.996325065,13],[970657.148694876,5],[970657.29506106,16],[970657.489894555,5],[970657.676120384,16],[970657.858548212,7],[970658.008017814,22],[970658.164111666,10],[970658.348827477,7],[970658.539798009,23],[970658.689663001,5],[970658.841802802,9],[970659.013662347,14],[970659.165691409,20],[970659.319327697,8],[970659.477826055,12],[970659.624397881,5],[970659.77375187,14],[970659.928802936,11],[970660.077600043,7],[970660.224701366,9],[970660.390130868,8],[970660.55831336,3],[970660.742225787,10],[970660.891321669,11],[970661.077517965,9],[970661.265899113,10],[970661.459091473,20],[970661.607920269,14],[970661.795080155,14],[970662.025058231,13],[970662.17849141,5],[970662.359747128,14],[970662.596971538,11],[970662.830843247,32],[970663.020652443,33],[970663.174218287,11],[970663.366241955,6],[970663.518454117,8],[970663.672691329,9],[970663.821471886,13],[970663.972060474,8],[970664.123273158,20],[970664.277295109,17],[970664.432436272,20],[970664.588981733,13],[970664.743190304,2],[970664.89049729,16],[970665.07956636,6],[970665.228576998,15],[970665.390796328,8],[970665.578194628,15],[970665.760372492,16],[970665.995391201,27],[970666.285129389,4],[970666.439739358,8],[970666.587819634,25],[970666.737553876,18],[970666.892287809,13],[970667.076894358,55],[970667.231581607,11],[970667.423870103,10],[970667.578096273,11],[970667.724371302,15],[970667.876858514,17],[970668.028018826,14],[970668.21607401,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-640ebc62cebc487ab103563f","runtime":{"accepted":176,"cached":30,"decode_s":13.3681,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1905,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970654.632966779,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2157859429717064,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":6,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.073962276179643,"done":970668.230856101,"finish_reason":"length","first":970654.847827345,"full_response_s":13.598371158004738,"last":970668.216837743,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970654.847827345,3],[970654.98576741,11],[970655.167362284,30],[970655.350291895,19],[970655.502141617,21],[970655.687403067,15],[970655.834029113,19],[970655.984967608,17],[970656.137217316,6],[970656.28906629,11],[970656.452014252,5],[970656.632359276,27],[970656.814481555,12],[970656.995927387,13],[970657.147982093,5],[970657.296247934,16],[970657.489656886,5],[970657.672855761,16],[970657.858724736,7],[970658.008379279,22],[970658.159516165,10],[970658.350523646,7],[970658.536814791,23],[970658.690086571,5],[970658.83990281,9],[970659.012985778,14],[970659.164741436,20],[970659.319521615,8],[970659.47859411,12],[970659.624054244,5],[970659.775362377,14],[970659.926016263,11],[970660.076943237,7],[970660.224304456,9],[970660.388870704,8],[970660.560244444,3],[970660.741700873,10],[970660.89323411,11],[970661.07830884,9],[970661.264651143,10],[970661.462209413,20],[970661.608267811,14],[970661.795782873,14],[970662.026195687,13],[970662.177500649,5],[970662.360035428,14],[970662.597164016,11],[970662.832039624,32],[970663.022744879,33],[970663.175586691,11],[970663.366397899,6],[970663.520179969,8],[970663.67165152,9],[970663.824095347,13],[970663.972567784,8],[970664.122110723,20],[970664.276836558,17],[970664.432622717,20],[970664.591301483,13],[970664.744523454,2],[970664.891786673,16],[970665.078237179,6],[970665.229234203,15],[970665.390156774,8],[970665.576577851,15],[970665.76088281,16],[970665.995283616,27],[970666.285658318,4],[970666.438921536,8],[970666.587583245,25],[970666.73930629,18],[970666.889440972,13],[970667.07824895,55],[970667.235247514,11],[970667.4252824,10],[970667.577336412,11],[970667.726023715,15],[970667.876537024,17],[970668.028298901,14],[970668.216837743,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-756dabef4ec44e05a0a7187b","runtime":{"accepted":176,"cached":30,"decode_s":13.368,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1905,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970654.632484943,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21534240199252963,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":7,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.07414625737715,"done":970668.225421059,"finish_reason":"length","first":970654.849037231,"full_response_s":13.595946973888204,"last":970668.217918677,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970654.849037231,3],[970654.986695268,11],[970655.167993807,30],[970655.350058739,19],[970655.502555394,21],[970655.686340644,15],[970655.835694879,19],[970655.985911164,17],[970656.139171495,6],[970656.288496489,11],[970656.451650643,5],[970656.631954541,27],[970656.813397865,12],[970656.994965029,13],[970657.147729989,5],[970657.296140781,16],[970657.488376862,5],[970657.673339693,16],[970657.858432082,7],[970658.007360496,22],[970658.158947356,10],[970658.349787659,7],[970658.537272607,23],[970658.690633632,5],[970658.841437833,9],[970659.013803665,14],[970659.165363037,20],[970659.318072285,8],[970659.476904807,12],[970659.623608846,5],[970659.77517614,14],[970659.926380959,11],[970660.080033206,7],[970660.226946147,9],[970660.387838048,8],[970660.558092461,3],[970660.74195344,10],[970660.889616332,11],[970661.078944539,9],[970661.264408418,10],[970661.464723499,20],[970661.607493819,14],[970661.794133144,14],[970662.026131373,13],[970662.179451047,5],[970662.35994527,14],[970662.597390355,11],[970662.831940536,32],[970663.022036098,33],[970663.176256603,11],[970663.364331131,6],[970663.517945991,8],[970663.671750608,9],[970663.821805329,13],[970663.972255272,8],[970664.124263087,20],[970664.276478471,17],[970664.432339777,20],[970664.590587357,13],[970664.743427524,2],[970664.891740426,16],[970665.082349189,6],[970665.229544059,15],[970665.392026646,8],[970665.577407211,15],[970665.761268022,16],[970665.99414925,27],[970666.284298205,4],[970666.440377776,8],[970666.586373747,25],[970666.738391445,18],[970666.889200215,13],[970667.076307884,55],[970667.230315604,11],[970667.424664385,10],[970667.574916424,11],[970667.725539401,15],[970667.875673404,17],[970668.027722076,14],[970668.217918677,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-5243e532ea1e486abfffcf52","runtime":{"accepted":176,"cached":30,"decode_s":13.368,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1905,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970654.629474085,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2195631458889693,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":8,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.07535850732644,"done":970668.231649646,"finish_reason":"length","first":970654.848604731,"full_response_s":13.598555470933206,"last":970668.216636577,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970654.848604731,3],[970654.986761406,11],[970655.168303472,30],[970655.351083523,19],[970655.502252706,21],[970655.686843635,15],[970655.834561917,19],[970655.989877674,17],[970656.139237681,6],[970656.289745805,11],[970656.450504671,5],[970656.629697147,27],[970656.813720699,12],[970656.997086977,13],[970657.147163613,5],[970657.296043454,16],[970657.48891621,5],[970657.675907263,16],[970657.857414659,7],[970658.006834029,22],[970658.158587364,10],[970658.349144535,7],[970658.536273507,23],[970658.690409373,5],[970658.840119276,9],[970659.014675513,14],[970659.16686972,20],[970659.318915264,8],[970659.478893261,12],[970659.624339408,5],[970659.775773657,14],[970659.926516308,11],[970660.078388358,7],[970660.227109836,9],[970660.390968503,8],[970660.558486891,3],[970660.745645327,10],[970660.890197526,11],[970661.076667849,9],[970661.266102793,10],[970661.464862161,20],[970661.607811596,14],[970661.795497804,14],[970662.026904309,13],[970662.181097703,5],[970662.363816863,14],[970662.596584822,11],[970662.831615078,32],[970663.021183646,33],[970663.173865865,11],[970663.365078143,6],[970663.516339646,8],[970663.673551591,9],[970663.823054258,13],[970663.973931851,8],[970664.123470325,20],[970664.273471606,17],[970664.433884912,20],[970664.588078345,13],[970664.743285391,2],[970664.889946389,16],[970665.078800482,6],[970665.227940068,15],[970665.389638278,8],[970665.57617142,15],[970665.762959275,16],[970665.994531581,27],[970666.284790729,4],[970666.439462323,8],[970666.589865885,25],[970666.73688651,18],[970666.888748866,13],[970667.076596584,55],[970667.233239861,11],[970667.424536077,10],[970667.575324695,11],[970667.725620053,15],[970667.875979643,17],[970668.028885278,14],[970668.216636577,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-1f8e515f74be430eb241fefa","runtime":{"accepted":176,"cached":30,"decode_s":13.3681,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1905,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970654.633094175,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21551055600866675,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":9,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.075799452994204,"done":970668.229755164,"finish_reason":"length","first":970654.848658179,"full_response_s":13.59465046506375,"last":970668.216381017,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970654.848658179,3],[970654.986460767,11],[970655.168345158,30],[970655.350573699,19],[970655.502734798,21],[970655.688772418,15],[970655.835024661,19],[970655.985605244,17],[970656.139097419,6],[970656.289906582,11],[970656.450033877,5],[970656.630050819,27],[970656.815722661,12],[970656.997228743,13],[970657.14787622,5],[970657.296323353,16],[970657.489213457,5],[970657.675215138,16],[970657.860267905,7],[970658.006920523,22],[970658.1607417,10],[970658.349441573,7],[970658.537054989,23],[970658.690345299,5],[970658.841158126,9],[970659.014305887,14],[970659.165627511,20],[970659.320068868,8],[970659.478322932,12],[970659.624192233,5],[970659.775294926,14],[970659.927229555,11],[970660.077978854,7],[970660.227752336,9],[970660.389669821,8],[970660.558953827,3],[970660.742625977,10],[970660.890538843,11],[970661.077027057,9],[970661.265068984,10],[970661.460084315,20],[970661.607367015,14],[970661.794409267,14],[970662.024845702,13],[970662.176500622,5],[970662.36048689,14],[970662.597951978,11],[970662.831494563,32],[970663.020235243,33],[970663.174518622,11],[970663.365213508,6],[970663.517191378,8],[970663.673052729,9],[970663.824187745,13],[970663.973124654,8],[970664.121970445,20],[970664.274180852,17],[970664.432940318,20],[970664.588814091,13],[970664.742420249,2],[970664.890641216,16],[970665.079026213,6],[970665.228209053,15],[970665.389968472,8],[970665.579390141,15],[970665.761710378,16],[970665.994357746,27],[970666.287650865,4],[970666.439870514,8],[970666.588163287,25],[970666.738818135,18],[970666.889719943,13],[970667.080273693,55],[970667.231791719,11],[970667.425186929,10],[970667.576428673,11],[970667.725830406,15],[970667.876250532,17],[970668.028825317,14],[970668.216381017,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-96a78a08117949379d7c7937","runtime":{"accepted":176,"cached":30,"decode_s":13.3681,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1905,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970654.635104699,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2135534801054746,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":10,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.07624297483646,"done":970668.232945893,"finish_reason":"length","first":970654.848464517,"full_response_s":13.603391458978876,"last":970668.215876556,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970654.848464517,3],[970654.986386835,11],[970655.168143479,30],[970655.349607372,19],[970655.504352348,21],[970655.693074997,15],[970655.835457961,19],[970655.985233826,17],[970656.136783296,6],[970656.288826028,11],[970656.452773971,5],[970656.629207646,27],[970656.815136457,12],[970656.999046867,13],[970657.150141551,5],[970657.294444147,16],[970657.489589132,5],[970657.672960082,16],[970657.859257459,7],[970658.006417212,22],[970658.159017911,10],[970658.35013661,7],[970658.535858962,23],[970658.69048825,5],[970658.841015783,9],[970659.013398978,14],[970659.166465417,20],[970659.320194488,8],[970659.478789661,12],[970659.623819839,5],[970659.775026244,14],[970659.927164345,11],[970660.077820893,7],[970660.226649205,9],[970660.389126152,8],[970660.558683033,3],[970660.741368725,10],[970660.89174471,11],[970661.077693352,9],[970661.26532448,10],[970661.460456501,20],[970661.609257021,14],[970661.793734507,14],[970662.025838048,13],[970662.179120564,5],[970662.359258076,14],[970662.595336036,11],[970662.832092496,32],[970663.019994582,33],[970663.173998013,11],[970663.36720364,6],[970663.518639202,8],[970663.671577685,9],[970663.822505821,13],[970663.97302195,8],[970664.124505637,20],[970664.273197084,17],[970664.431521107,20],[970664.58786724,13],[970664.741535456,2],[970664.89036351,16],[970665.078870349,6],[970665.229599171,15],[970665.389727891,8],[970665.577098459,15],[970665.761057717,16],[970665.994094345,27],[970666.287035362,4],[970666.439059685,8],[970666.586823353,25],[970666.737331202,18],[970666.888968483,13],[970667.077707427,55],[970667.230570779,11],[970667.42474923,10],[970667.575022361,11],[970667.725401428,15],[970667.876318639,17],[970668.027972179,14],[970668.215876556,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-6872a0f9f3b141aa8530e17a","runtime":{"accepted":176,"cached":30,"decode_s":13.368,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1905,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970654.629554434,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21891008305829018,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":11,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.076413748197098,"done":970668.231313803,"finish_reason":"length","first":970654.848388377,"full_response_s":13.598415883025154,"last":970668.21568075,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970654.848388377,3],[970654.987039594,11],[970655.168398911,30],[970655.350740846,19],[970655.503743709,21],[970655.688027405,15],[970655.834649563,19],[970655.985561125,17],[970656.137736022,6],[970656.290762508,11],[970656.450134469,5],[970656.630876756,27],[970656.813459987,12],[970656.998908446,13],[970657.148418049,5],[970657.294526944,16],[970657.489068922,5],[970657.674973965,16],[970657.857229543,7],[970658.006115693,22],[970658.163253789,10],[970658.348983006,7],[970658.538208529,23],[970658.689844421,5],[970658.840060498,9],[970659.014043703,14],[970659.165531912,20],[970659.31863194,8],[970659.477368383,12],[970659.624679141,5],[970659.774913635,14],[970659.928206492,11],[970660.077676167,7],[970660.225843031,9],[970660.387907946,8],[970660.558559318,3],[970660.74258149,10],[970660.890390756,11],[970661.078257456,9],[970661.264704688,10],[970661.462792831,20],[970661.608375076,14],[970661.794316965,14],[970662.025453108,13],[970662.181443452,5],[970662.360599068,14],[970662.595930352,11],[970662.831835688,32],[970663.019829084,33],[970663.174437377,11],[970663.366977269,6],[970663.51641889,8],[970663.672978494,9],[970663.821276879,13],[970663.971907986,8],[970664.123737662,20],[970664.276671637,17],[970664.432250451,20],[970664.588382888,13],[970664.742667871,2],[970664.891180756,16],[970665.076858038,6],[970665.228990918,15],[970665.390654034,8],[970665.57609184,15],[970665.760475452,16],[970665.995628053,27],[970666.283972459,4],[970666.442407352,8],[970666.58979653,25],[970666.737482393,18],[970666.890943251,13],[970667.077654939,55],[970667.231436832,11],[970667.424853822,10],[970667.575793343,11],[970667.726640274,15],[970667.878302511,17],[970668.028067345,14],[970668.21568075,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-e3c42cd4024b4c3b8370f6d6","runtime":{"accepted":176,"cached":30,"decode_s":13.3681,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1905,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970654.63289792,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21549045701976866,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":12,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.075061336224664,"done":970668.231808439,"finish_reason":"length","first":970654.847225842,"full_response_s":13.601978154038079,"last":970668.215465949,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970654.847225842,3],[970654.987617333,11],[970655.167509411,30],[970655.351165408,19],[970655.502459139,21],[970655.685925923,15],[970655.834398211,19],[970655.986328509,17],[970656.13629858,6],[970656.288717163,11],[970656.449660859,5],[970656.628388942,27],[970656.813192345,12],[970656.996445004,13],[970657.148343477,5],[970657.296869567,16],[970657.49031707,5],[970657.671801084,16],[970657.857054379,7],[970658.006017342,22],[970658.15816837,10],[970658.351281285,7],[970658.539913947,23],[970658.689989628,5],[970658.840197768,9],[970659.014353799,14],[970659.164906006,20],[970659.318378333,8],[970659.476502808,12],[970659.623944451,5],[970659.773107689,14],[970659.925675074,11],[970660.0752945,7],[970660.224045888,9],[970660.388993507,8],[970660.559972258,3],[970660.742858781,10],[970660.889904248,11],[970661.075942072,9],[970661.264253402,10],[970661.45929256,20],[970661.607066329,14],[970661.793657839,14],[970662.024298785,13],[970662.179047929,5],[970662.359377966,14],[970662.596649088,11],[970662.832584844,32],[970663.021434388,33],[970663.173435094,11],[970663.364708774,6],[970663.516699574,8],[970663.672155022,9],[970663.823411033,13],[970663.971383473,8],[970664.122257017,20],[970664.274953371,17],[970664.431276125,20],[970664.593181149,13],[970664.7452861,2],[970664.890556355,16],[970665.078943192,6],[970665.229337515,15],[970665.389541927,8],[970665.577262885,15],[970665.759603973,16],[970665.994283575,27],[970666.28385076,4],[970666.439338224,8],[970666.58647157,25],[970666.737052327,18],[970666.888466182,13],[970667.076169094,55],[970667.229851485,11],[970667.42779725,10],[970667.57448487,11],[970667.72593919,15],[970667.875495025,17],[970668.027910553,14],[970668.215465949,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-bd005c3696214e08a0118006","runtime":{"accepted":176,"cached":30,"decode_s":13.368,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1905,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970654.629830285,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21739555697422475,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":13,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.076456616832264,"done":970668.233427999,"finish_reason":"length","first":970654.849191207,"full_response_s":13.601754863979295,"last":970668.216453541,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970654.849191207,3],[970654.987692977,11],[970655.168541733,30],[970655.349727247,19],[970655.502817355,21],[970655.688654047,15],[970655.835220196,19],[970655.986953744,17],[970656.138477098,6],[970656.290915332,11],[970656.450304127,5],[970656.629299965,27],[970656.814253215,12],[970656.998310112,13],[970657.148829714,5],[970657.294160615,16],[970657.489824832,5],[970657.671888202,16],[970657.859393417,7],[970658.007490132,22],[970658.160014339,10],[970658.350372215,7],[970658.537314325,23],[970658.690705083,5],[970658.841281393,9],[970659.014758598,14],[970659.166509984,20],[970659.320762768,8],[970659.477662781,12],[970659.626323766,5],[970659.775411184,14],[970659.926608851,11],[970660.079149596,7],[970660.225478863,9],[970660.388374819,8],[970660.56295765,3],[970660.745054035,10],[970660.891260603,11],[970661.077237762,9],[970661.264583661,10],[970661.458553837,20],[970661.609988478,14],[970661.793815207,14],[970662.02452506,13],[970662.178876414,5],[970662.361191432,14],[970662.595492861,11],[970662.830709914,32],[970663.020131403,33],[970663.173679468,11],[970663.366104894,6],[970663.517091635,8],[970663.671692375,9],[970663.822327538,13],[970663.971961802,8],[970664.122783643,20],[970664.276927148,17],[970664.435436192,20],[970664.590242775,13],[970664.741355444,2],[970664.890203245,16],[970665.07928254,6],[970665.22875669,15],[970665.390411965,8],[970665.575607317,15],[970665.76007859,16],[970665.994568514,27],[970666.285185541,4],[970666.4387144,8],[970666.587992604,25],[970666.737252086,18],[970666.889127596,13],[970667.076833164,55],[970667.231355812,11],[970667.424472212,10],[970667.575927924,11],[970667.725344027,15],[970667.876746016,17],[970668.028200149,14],[970668.216453541,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-683c28647fda40eba9b4f303","runtime":{"accepted":176,"cached":30,"decode_s":13.368,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1905,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970654.631673135,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21751807199325413,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":14,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.074699273218464,"done":970668.233263142,"finish_reason":"length","first":970654.8482818,"full_response_s":13.603632056037895,"last":970668.216775654,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970654.8482818,3],[970654.986234347,11],[970655.166768287,30],[970655.35153169,19],[970655.502384327,21],[970655.68788079,15],[970655.834314694,19],[970655.988328727,17],[970656.138977672,6],[970656.290165262,11],[970656.451403596,5],[970656.629525696,27],[970656.815629926,12],[970656.998438052,13],[970657.148917263,5],[970657.294273849,16],[970657.488800288,5],[970657.672644176,16],[970657.858342772,7],[970658.006283079,22],[970658.159312021,10],[970658.352461805,7],[970658.537695665,23],[970658.69086586,5],[970658.840352704,9],[970659.016595444,14],[970659.16718689,20],[970659.318266299,8],[970659.478088704,12],[970659.623713583,5],[970659.774067615,14],[970659.928530142,11],[970660.077471703,7],[970660.228245885,9],[970660.38822574,8],[970660.558873591,3],[970660.742045406,10],[970660.893603735,11],[970661.077809066,9],[970661.265618606,10],[970661.459207699,20],[970661.607603836,14],[970661.793971759,14],[970662.026036382,13],[970662.178963788,5],[970662.361475268,14],[970662.595415633,11],[970662.832264891,32],[970663.02149451,33],[970663.177747169,11],[970663.364647164,6],[970663.519470547,8],[970663.672766205,9],[970663.823255217,13],[970663.971738008,8],[970664.122453736,20],[970664.273102957,17],[970664.433629224,20],[970664.589083316,13],[970664.742238813,2],[970664.891654941,16],[970665.078342539,6],[970665.227605936,15],[970665.389877995,8],[970665.575976078,15],[970665.76032514,16],[970665.993941314,27],[970666.285546877,4],[970666.44070205,8],[970666.5902779,25],[970666.737379162,18],[970666.890322515,13],[970667.076679445,55],[970667.232730823,11],[970667.424271749,10],[970667.576766101,11],[970667.725791696,15],[970667.875739094,17],[970668.029302862,14],[970668.216775654,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-56f5bfa3550c490eac496793","runtime":{"accepted":176,"cached":30,"decode_s":13.368,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1905,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970654.629631086,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21865071402862668,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":15,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.075552170566482,"done":970668.233729949,"finish_reason":"length","first":970654.848807803,"full_response_s":13.604332659975626,"last":970668.216703931,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970654.848807803,3],[970654.985914825,11],[970655.167174014,30],[970655.350372516,19],[970655.50201843,21],[970655.692132401,15],[970655.834080049,19],[970655.986055203,17],[970656.136643835,6],[970656.28924203,11],[970656.451193707,5],[970656.628624547,27],[970656.814063825,12],[970656.999109837,13],[970657.147303251,5],[970657.294632481,16],[970657.490171063,5],[970657.672733694,16],[970657.85758355,7],[970658.006779157,22],[970658.159250267,10],[970658.349511472,7],[970658.535985894,23],[970658.690820605,5],[970658.840740797,9],[970659.015651473,14],[970659.164645277,20],[970659.318559785,8],[970659.478488702,12],[970659.624126303,5],[970659.774407236,14],[970659.927574185,11],[970660.077199405,7],[970660.225211253,9],[970660.387648418,8],[970660.561665785,3],[970660.74306803,10],[970660.890981552,11],[970661.077914043,9],[970661.265259142,10],[970661.462524118,20],[970661.610864727,14],[970661.794697488,14],[970662.024196993,13],[970662.176744004,5],[970662.360223137,14],[970662.595194926,11],[970662.831408822,32],[970663.020067713,33],[970663.174337218,11],[970663.364901347,6],[970663.516495574,8],[970663.672409718,9],[970663.821705682,13],[970663.972733122,8],[970664.123666515,20],[970664.277706356,17],[970664.43355054,20],[970664.58825202,13],[970664.741719165,2],[970664.890909354,16],[970665.076695293,6],[970665.230403775,15],[970665.39186947,8],[970665.57568853,15],[970665.761130337,16],[970665.994025807,27],[970666.284101615,4],[970666.44227546,8],[970666.58692164,25],[970666.740241858,18],[970666.890372555,13],[970667.077338058,55],[970667.230883387,11],[970667.425765546,10],[970667.57617401,11],[970667.725167808,15],[970667.87666754,17],[970668.028578159,14],[970668.216703931,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-b7216f98fdcb40128dc6bc30","runtime":{"accepted":176,"cached":30,"decode_s":13.3681,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1905,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970654.629397289,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21941051399335265,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.0042126281006,"done":970681.924291554,"finish_reason":"length","first":970668.48780156,"full_response_s":13.67562427406665,"last":970681.905879172,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970668.48780156,3],[970668.628589882,11],[970668.80788926,30],[970668.98269494,19],[970669.132920074,21],[970669.373080684,15],[970669.514707574,19],[970669.663836844,17],[970669.814886871,6],[970669.965340429,11],[970670.113896738,5],[970670.303090518,27],[970670.49792836,12],[970670.678729274,13],[970670.827109535,5],[970670.976761456,16],[970671.161509033,5],[970671.351425045,16],[970671.537495095,7],[970671.68707267,22],[970671.837020917,10],[970672.021465291,7],[970672.20867663,23],[970672.364556433,5],[970672.51743946,9],[970672.69244355,14],[970672.839985164,20],[970672.993678591,8],[970673.143270819,12],[970673.291130624,5],[970673.452854807,14],[970673.60342952,11],[970673.751396285,7],[970673.901163699,9],[970674.051115859,8],[970674.229157623,3],[970674.425340841,10],[970674.577173367,11],[970674.756554854,9],[970674.942153166,10],[970675.126214111,20],[970675.275475869,14],[970675.474880032,14],[970675.702478574,13],[970675.85241055,5],[970676.028548998,14],[970676.26159033,11],[970676.504768058,32],[970676.690047727,33],[970676.843110537,11],[970677.028712011,6],[970677.181747998,8],[970677.330885782,9],[970677.495315712,13],[970677.648046773,8],[970677.798266464,20],[970677.949239654,17],[970678.100508565,20],[970678.254448454,13],[970678.414971989,2],[970678.569505712,16],[970678.752101818,6],[970678.901893169,15],[970679.05988804,8],[970679.24238768,15],[970679.439460998,16],[970679.673741282,27],[970679.955645432,4],[970680.115399995,8],[970680.263206271,25],[970680.423392482,18],[970680.571420535,13],[970680.763664098,55],[970680.916441666,11],[970681.106934066,10],[970681.254374069,11],[970681.418104527,15],[970681.56837025,17],[970681.719239119,14],[970681.905879172,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-cc2b259133194d0f8831d74e","runtime":{"accepted":176,"cached":30,"decode_s":13.4201,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.2031,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970668.24866728,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23913428001105785,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.000392863240258,"done":970681.923547763,"finish_reason":"length","first":970668.485058851,"full_response_s":13.676671206019819,"last":970681.905833981,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970668.485058851,3],[970668.628258487,11],[970668.807351978,30],[970668.984304115,19],[970669.132725997,21],[970669.373390123,15],[970669.514385461,19],[970669.662357978,17],[970669.814496107,6],[970669.965082518,11],[970670.113692066,5],[970670.300716363,27],[970670.497838682,12],[970670.678663056,13],[970670.827255749,5],[970670.975892412,16],[970671.161932457,5],[970671.351119623,16],[970671.538186369,7],[970671.686690675,22],[970671.838280196,10],[970672.02097496,7],[970672.207618805,23],[970672.363937747,5],[970672.516398902,9],[970672.691644932,14],[970672.840148389,20],[970672.993863339,8],[970673.143338157,12],[970673.291523868,5],[970673.455206236,14],[970673.602182419,11],[970673.753158841,7],[970673.900636547,9],[970674.051170684,8],[970674.227944463,3],[970674.42360493,10],[970674.57359164,11],[970674.75518623,9],[970674.941492762,10],[970675.125264959,20],[970675.27519125,14],[970675.47231726,14],[970675.702709857,13],[970675.849368266,5],[970676.027421196,14],[970676.260597668,11],[970676.504057263,32],[970676.689325842,33],[970676.841917397,11],[970677.029430759,6],[970677.180596048,8],[970677.331136668,9],[970677.496985115,13],[970677.643753534,8],[970677.796523081,20],[970677.950878348,17],[970678.101561843,20],[970678.251983347,13],[970678.414873047,2],[970678.565894144,16],[970678.750529533,6],[970678.901194328,15],[970679.057562651,8],[970679.241436434,15],[970679.440266688,16],[970679.673511968,27],[970679.954361495,4],[970680.112472436,8],[970680.261621745,25],[970680.422264905,18],[970680.573485133,13],[970680.762812691,55],[970680.914724065,11],[970681.105864721,10],[970681.255560887,11],[970681.418404444,15],[970681.568845617,17],[970681.718962854,14],[970681.905833981,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-769b50337c01450c9abf4f02","runtime":{"accepted":176,"cached":30,"decode_s":13.42,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.2031,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970668.246876557,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23818229394964874,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.001744528519627,"done":970681.922066182,"finish_reason":"length","first":970668.484864005,"full_response_s":13.674578026984818,"last":970681.904684465,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970668.484864005,3],[970668.627421062,11],[970668.807659657,30],[970668.98150447,19],[970669.132506747,21],[970669.37389012,15],[970669.514056098,19],[970669.663536894,17],[970669.81274832,6],[970669.965945466,11],[970670.115428172,5],[970670.300574533,27],[970670.494477577,12],[970670.679628387,13],[970670.828429544,5],[970670.978484807,16],[970671.162963398,5],[970671.352080649,16],[970671.538249563,7],[970671.689956229,22],[970671.839607406,10],[970672.021533957,7],[970672.208367447,23],[970672.364912968,5],[970672.51792483,9],[970672.690107419,14],[970672.839041517,20],[970672.994880454,8],[970673.142487292,12],[970673.291068118,5],[970673.455046884,14],[970673.603147605,11],[970673.753978102,7],[970673.900429139,9],[970674.051662806,8],[970674.228412294,3],[970674.425064191,10],[970674.572095541,11],[970674.758224883,9],[970674.941954368,10],[970675.12772578,20],[970675.276249666,14],[970675.474764334,14],[970675.702561226,13],[970675.852533656,5],[970676.026844533,14],[970676.260353008,11],[970676.504728932,32],[970676.693209325,33],[970676.845299219,11],[970677.03085499,6],[970677.184769046,8],[970677.330946303,9],[970677.497926633,13],[970677.644168428,8],[970677.796727016,20],[970677.950962329,17],[970678.102222823,20],[970678.254352983,13],[970678.416693577,2],[970678.566746432,16],[970678.752287718,6],[970678.904280279,15],[970679.058911925,8],[970679.243182296,15],[970679.440169313,16],[970679.673959475,27],[970679.955549385,4],[970680.111223497,8],[970680.263617964,25],[970680.422015572,18],[970680.57402627,13],[970680.763974673,55],[970680.914651574,11],[970681.108971555,10],[970681.256267441,11],[970681.417342221,15],[970681.569045567,17],[970681.719516473,14],[970681.904684465,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-536fa5c74d1b455386a8987e","runtime":{"accepted":176,"cached":30,"decode_s":13.42,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.2031,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970668.247488155,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2373758499743417,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.001171879014958,"done":970681.924427863,"finish_reason":"length","first":970668.485720985,"full_response_s":13.677482798928395,"last":970681.905945886,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970668.485720985,3],[970668.62778595,11],[970668.808291866,30],[970668.982303905,19],[970669.133179506,21],[970669.372391426,15],[970669.515149865,19],[970669.66260496,17],[970669.814274697,6],[970669.963609765,11],[970670.115277461,5],[970670.300991173,27],[970670.497545277,12],[970670.678976784,13],[970670.827806217,5],[970670.981451291,16],[970671.162188352,5],[970671.352787829,16],[970671.538990892,7],[970671.686901508,22],[970671.83629151,10],[970672.021685949,7],[970672.207378161,23],[970672.364231248,5],[970672.516695795,9],[970672.691991817,14],[970672.840286746,20],[970672.994756979,8],[970673.142852435,12],[970673.290555401,5],[970673.453773362,14],[970673.602792832,11],[970673.750732745,7],[970673.901313497,9],[970674.051270459,8],[970674.227760579,3],[970674.425767594,10],[970674.571861442,11],[970674.756132102,9],[970674.941396044,10],[970675.125489345,20],[970675.275953541,14],[970675.472880209,14],[970675.70058984,13],[970675.850607317,5],[970676.026605536,14],[970676.263378777,11],[970676.503969857,32],[970676.691452307,33],[970676.842128965,11],[970677.028245156,6],[970677.180438905,8],[970677.331509828,9],[970677.496510116,13],[970677.645868461,8],[970677.797948672,20],[970677.948960396,17],[970678.104391549,20],[970678.252304659,13],[970678.416434097,2],[970678.568149156,16],[970678.751972854,6],[970678.901411592,15],[970679.060889854,8],[970679.241916042,15],[970679.443312825,16],[970679.675618396,27],[970679.956328622,4],[970680.113551334,8],[970680.261695148,25],[970680.421643788,18],[970680.572937579,13],[970680.762953976,55],[970680.917100341,11],[970681.106865495,10],[970681.254435278,11],[970681.417446845,15],[970681.57043059,17],[970681.72012554,14],[970681.905945886,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-9ec8326da11443bc903a4665","runtime":{"accepted":176,"cached":30,"decode_s":13.4201,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.2031,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970668.246945064,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23877592093776911,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.0013736867189,"done":970681.92261796,"finish_reason":"length","first":970668.485283078,"full_response_s":13.675339212990366,"last":970681.905365447,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970668.485283078,3],[970668.627979708,11],[970668.808346978,30],[970668.982213363,19],[970669.133288419,21],[970669.373036117,15],[970669.514235294,19],[970669.662476364,17],[970669.815983166,6],[970669.963544187,11],[970670.114085391,5],[970670.300434672,27],[970670.494823085,12],[970670.677628178,13],[970670.826672188,5],[970670.976689877,16],[970671.163389543,5],[970671.351344809,16],[970671.541394026,7],[970671.688902981,22],[970671.837130885,10],[970672.02163018,7],[970672.20791501,23],[970672.366408315,5],[970672.518381684,9],[970672.691063324,14],[970672.839843062,20],[970672.99334366,8],[970673.143123181,12],[970673.291448576,5],[970673.453706264,14],[970673.604902368,11],[970673.751095872,7],[970673.900761062,9],[970674.051918141,8],[970674.228255998,3],[970674.424816858,10],[970674.576550185,11],[970674.756750387,9],[970674.941754418,10],[970675.125098918,20],[970675.276624315,14],[970675.473786074,14],[970675.701461748,13],[970675.849668311,5],[970676.026159533,14],[970676.260498325,11],[970676.503729421,32],[970676.690792688,33],[970676.843769996,11],[970677.028925003,6],[970677.184395469,8],[970677.330776853,9],[970677.495538449,13],[970677.644307361,8],[970677.796293591,20],[970677.951503946,17],[970678.102809503,20],[970678.25216339,13],[970678.414722896,2],[970678.566944302,16],[970678.751276573,6],[970678.902550467,15],[970679.058589589,8],[970679.243739836,15],[970679.44140169,16],[970679.674615125,27],[970679.957548597,4],[970680.110937342,8],[970680.260972992,25],[970680.421577634,18],[970680.571670157,13],[970680.763086028,55],[970680.918448798,11],[970681.113801397,10],[970681.255810188,11],[970681.41714424,15],[970681.568966435,17],[970681.719885424,14],[970681.905365447,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-6dfe5d7c02ac4634bf285270","runtime":{"accepted":176,"cached":30,"decode_s":13.42,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.2031,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970668.247278747,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23800433101132512,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.00308188905754,"done":970681.92370161,"finish_reason":"length","first":970668.48601807,"full_response_s":13.675360123976134,"last":970681.904894097,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970668.48601807,3],[970668.628177082,11],[970668.807809744,30],[970668.98193508,19],[970669.134937855,21],[970669.372237227,15],[970669.516300938,19],[970669.664232377,17],[970669.813549531,6],[970669.965572721,11],[970670.114166443,5],[970670.30180933,27],[970670.497046465,12],[970670.678597638,13],[970670.827873395,5],[970670.978421229,16],[970671.162783739,5],[970671.352166134,16],[970671.537408186,7],[970671.689586893,22],[970671.83649218,10],[970672.021885051,7],[970672.208153575,23],[970672.365238633,5],[970672.518455375,9],[970672.691147961,14],[970672.839416758,20],[970672.99507021,8],[970673.142770887,12],[970673.291202043,5],[970673.453849374,14],[970673.603355957,11],[970673.750978382,7],[970673.899939993,9],[970674.056681311,8],[970674.229730798,3],[970674.425891789,10],[970674.572794911,11],[970674.7559607,9],[970674.944334569,10],[970675.12734329,20],[970675.275338264,14],[970675.473647125,14],[970675.701144292,13],[970675.851174811,5],[970676.028432612,14],[970676.261897401,11],[970676.506449896,32],[970676.691634671,33],[970676.842189102,11],[970677.028020802,6],[970677.180515204,8],[970677.331803504,9],[970677.49743912,13],[970677.645809428,8],[970677.799455827,20],[970677.949394285,17],[970678.102658952,20],[970678.253987264,13],[970678.416928108,2],[970678.567965368,16],[970678.750571747,6],[970678.901513608,15],[970679.05865283,8],[970679.244157482,15],[970679.441218366,16],[970679.672820056,27],[970679.957097185,4],[970680.111691551,8],[970680.261875335,25],[970680.42244058,18],[970680.571526519,13],[970680.762894671,55],[970680.914927247,11],[970681.107872766,10],[970681.257807719,11],[970681.418195085,15],[970681.569260735,17],[970681.721284017,14],[970681.904894097,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-bd0931e035124c6ebb32162a","runtime":{"accepted":176,"cached":30,"decode_s":13.4201,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.2031,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970668.248341486,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2376765840454027,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.00297860021903,"done":970681.925242,"finish_reason":"length","first":970668.486263052,"full_response_s":13.676313256029971,"last":970681.905212016,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970668.486263052,3],[970668.628484297,11],[970668.808061462,30],[970668.984231143,19],[970669.13573993,21],[970669.372853209,15],[970669.51623536,19],[970669.663034833,17],[970669.813859338,6],[970669.964975317,11],[970670.115356305,5],[970670.299816017,27],[970670.495109417,12],[970670.679560265,13],[970670.828582303,5],[970670.975796781,16],[970671.161089369,5],[970671.352225743,16],[970671.540371134,7],[970671.687550263,22],[970671.836574193,10],[970672.022195594,7],[970672.209255742,23],[970672.36416455,5],[970672.518204937,9],[970672.692130478,14],[970672.83957539,20],[970672.993473216,8],[970673.144426099,12],[970673.29172569,5],[970673.455625676,14],[970673.602500019,11],[970673.751164218,7],[970673.900838449,9],[970674.051320562,8],[970674.230289587,3],[970674.424452787,10],[970674.571925387,11],[970674.756614719,9],[970674.942733382,10],[970675.126718363,20],[970675.275793309,14],[970675.472964446,14],[970675.701559923,13],[970675.851799097,5],[970676.028652854,14],[970676.263962401,11],[970676.504415493,32],[970676.691737183,33],[970676.842235701,11],[970677.028478871,6],[970677.180879771,8],[970677.331054527,9],[970677.496703617,13],[970677.645228588,8],[970677.797364072,20],[970677.94949606,17],[970678.102726018,20],[970678.253484164,13],[970678.415323706,2],[970678.566245189,16],[970678.750467092,6],[970678.901971356,15],[970679.058308859,8],[970679.242591183,15],[970679.439991542,16],[970679.672940778,27],[970679.957192432,4],[970680.112341008,8],[970680.262337052,25],[970680.422087279,18],[970680.572711577,13],[970680.763762001,55],[970680.914507873,11],[970681.108105697,10],[970681.255288638,11],[970681.4162639,15],[970681.568573624,17],[970681.718232648,14],[970681.905212016,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-c0e3cbb11f7f4acbbd9696d8","runtime":{"accepted":176,"cached":30,"decode_s":13.4201,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.2031,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970668.248928744,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.237334307981655,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.002039478926743,"done":970681.925062534,"finish_reason":"length","first":970668.484801724,"full_response_s":13.677378493011929,"last":970681.904413881,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970668.484801724,3],[970668.627529255,11],[970668.806873344,30],[970668.981872799,19],[970669.132391881,21],[970669.372327464,15],[970669.514617064,19],[970669.66191191,17],[970669.813698449,6],[970669.962883094,11],[970670.114885929,5],[970670.301272928,27],[970670.497150017,12],[970670.68067826,13],[970670.826844278,5],[970670.977044539,16],[970671.160986137,5],[970671.35154892,16],[970671.53723736,7],[970671.686600422,22],[970671.836209657,10],[970672.021133817,7],[970672.208268216,23],[970672.363538102,5],[970672.516559631,9],[970672.692373187,14],[970672.839691087,20],[970672.993626023,8],[970673.143705653,12],[970673.291604312,5],[970673.455361204,14],[970673.6013734,11],[970673.750868365,7],[970673.900508031,9],[970674.051037607,8],[970674.228303253,3],[970674.423456748,10],[970674.571603755,11],[970674.755095849,9],[970674.940982589,10],[970675.126537216,20],[970675.276828154,14],[970675.474280565,14],[970675.701944013,13],[970675.849431924,5],[970676.027524107,14],[970676.260745371,11],[970676.50691243,32],[970676.68921533,33],[970676.841745051,11],[970677.027914642,6],[970677.180309525,8],[970677.33222528,9],[970677.495164345,13],[970677.643597974,8],[970677.79610409,20],[970677.949994951,17],[970678.101620188,20],[970678.251479127,13],[970678.416215345,2],[970678.568055301,16],[970678.750245874,6],[970678.900878776,15],[970679.060720885,8],[970679.241566533,15],[970679.44114682,16],[970679.674533401,27],[970679.9552206,4],[970680.111434584,8],[970680.260839772,25],[970680.420794845,18],[970680.571603347,13],[970680.761136551,55],[970680.913976177,11],[970681.106685532,10],[970681.253699472,11],[970681.418874595,15],[970681.569378625,17],[970681.719390246,14],[970681.904413881,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-b6a2a68183cc4e2b8d4ef64c","runtime":{"accepted":176,"cached":30,"decode_s":13.42,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.2031,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970668.247684041,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23711768293287605,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.0009824656209,"done":970681.921454075,"finish_reason":"length","first":970668.485414058,"full_response_s":13.673586070071906,"last":970681.90577274,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970668.485414058,3],[970668.627947031,11],[970668.808732285,30],[970668.982377564,19],[970669.133697937,21],[970669.372503171,15],[970669.514887121,19],[970669.663896485,17],[970669.814142197,6],[970669.96384292,11],[970670.114288814,5],[970670.300137731,27],[970670.495185269,12],[970670.679701422,13],[970670.827189675,5],[970670.977561466,16],[970671.161774721,5],[970671.353686158,16],[970671.537548416,7],[970671.687954356,22],[970671.836376611,10],[970672.023409907,7],[970672.208759315,23],[970672.365530982,5],[970672.517977606,9],[970672.690313514,14],[970672.83896749,20],[970672.995721093,8],[970673.14263221,12],[970673.291796309,5],[970673.45314962,14],[970673.603692904,11],[970673.75295649,7],[970673.900572041,9],[970674.051550933,8],[970674.229072282,3],[970674.425236858,10],[970674.572180466,11],[970674.756074461,9],[970674.942078739,10],[970675.125961945,20],[970675.276369268,14],[970675.477394973,14],[970675.702164174,13],[970675.849703949,5],[970676.025931339,14],[970676.263278281,11],[970676.506790572,32],[970676.689430322,33],[970676.841969484,11],[970677.030772497,6],[970677.180791518,8],[970677.331623781,9],[970677.496124778,13],[970677.646489866,8],[970677.797660693,20],[970677.949109634,17],[970678.100916962,20],[970678.251865633,13],[970678.41590357,2],[970678.56648985,16],[970678.753259144,6],[970678.901113436,15],[970679.057837156,8],[970679.244025319,15],[970679.440538472,16],[970679.675104799,27],[970679.955349595,4],[970680.111105047,8],[970680.262017388,25],[970680.420939939,18],[970680.571803937,13],[970680.761920749,55],[970680.914313779,11],[970681.10611223,10],[970681.254293065,11],[970681.417896016,15],[970681.570020449,17],[970681.718769113,14],[970681.90577274,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-5b78a54483f0416483372d22","runtime":{"accepted":176,"cached":30,"decode_s":13.4201,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.2031,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970668.247868005,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2375460530165583,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.006105682440598,"done":970681.922118894,"finish_reason":"length","first":970668.488075762,"full_response_s":13.674517138046212,"last":970681.904816901,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970668.488075762,3],[970668.628422784,11],[970668.808251539,30],[970668.982531123,19],[970669.13380917,21],[970669.37395957,15],[970669.514544349,19],[970669.664379663,17],[970669.814793065,6],[970669.965260289,11],[970670.114355368,5],[970670.300521341,27],[970670.494716253,12],[970670.679873577,13],[970670.827583223,5],[970670.979105157,16],[970671.164088274,5],[970671.351756696,16],[970671.537091786,7],[970671.691589118,22],[970671.836856844,10],[970672.023713057,7],[970672.209415271,23],[970672.364610682,5],[970672.518259217,9],[970672.69146793,14],[970672.839500963,20],[970672.993548331,8],[970673.142371482,12],[970673.290683788,5],[970673.45362558,14],[970673.602434937,11],[970673.750526169,7],[970673.901877871,9],[970674.055740673,8],[970674.228024843,3],[970674.428077528,10],[970674.571707594,11],[970674.757226796,9],[970674.941299117,10],[970675.127474654,20],[970675.275685901,14],[970675.474539276,14],[970675.702422709,13],[970675.850971004,5],[970676.028838098,14],[970676.261097312,11],[970676.505091131,32],[970676.689379962,33],[970676.842700219,11],[970677.027813475,6],[970677.180729108,8],[970677.332430959,9],[970677.494980381,13],[970677.648444481,8],[970677.796969036,20],[970677.948876591,17],[970678.101494457,20],[970678.251369462,13],[970678.417471726,2],[970678.566128227,16],[970678.751692124,6],[970678.900788027,15],[970679.058058981,8],[970679.242174528,15],[970679.439822461,16],[970679.675255525,27],[970679.954078957,4],[970680.111017306,8],[970680.26135084,25],[970680.421104075,18],[970680.571733782,13],[970680.763430943,55],[970680.916223521,11],[970681.106291569,10],[970681.254643758,11],[970681.417801826,15],[970681.568489612,17],[970681.719043874,14],[970681.904816901,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-6056d0999de24f21b1587cc0","runtime":{"accepted":176,"cached":30,"decode_s":13.42,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.2031,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970668.247601756,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2404740060446784,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.00123064743204,"done":970681.924951957,"finish_reason":"length","first":970668.484912925,"full_response_s":13.677753302967176,"last":970681.905096319,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970668.484912925,3],[970668.627695472,11],[970668.807585261,30],[970668.981717799,19],[970669.133414278,21],[970669.372790447,15],[970669.517222791,19],[970669.66521107,17],[970669.816072508,6],[970669.963246189,11],[970670.113990992,5],[970670.300203453,27],[970670.495246094,12],[970670.677978583,13],[970670.828156478,5],[970670.976828618,16],[970671.164237081,5],[970671.353252876,16],[970671.543205614,7],[970671.686833145,22],[970671.837859828,10],[970672.021257115,7],[970672.207737447,23],[970672.365734741,5],[970672.517850787,9],[970672.690844987,14],[970672.838910489,20],[970672.992512558,8],[970673.142910972,12],[970673.293304474,5],[970673.453955838,14],[970673.603762563,11],[970673.750802771,7],[970673.900690619,9],[970674.053186205,8],[970674.228463998,3],[970674.42386897,10],[970674.574779388,11],[970674.755610343,9],[970674.942852616,10],[970675.126422127,20],[970675.276324222,14],[970675.472602023,14],[970675.703044548,13],[970675.850220859,5],[970676.027883137,14],[970676.262198454,11],[970676.50466489,32],[970676.689907546,33],[970676.843909345,11],[970677.029928386,6],[970677.181025249,8],[970677.331368703,9],[970677.496424615,13],[970677.646549731,8],[970677.798647113,20],[970677.948743899,17],[970678.103397015,20],[970678.251631758,13],[970678.415555325,2],[970678.566309119,16],[970678.751808446,6],[970678.9014636,15],[970679.061156615,8],[970679.243892467,15],[970679.442461705,16],[970679.674040815,27],[970679.955922433,4],[970680.113107507,8],[970680.261462873,25],[970680.421931239,18],[970680.571923587,13],[970680.763199709,55],[970680.915136367,11],[970681.105675349,10],[970681.25814801,11],[970681.416691132,15],[970681.571955779,17],[970681.719820598,14],[970681.905096319,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-83974d4dcfe64275b1ac3cdd","runtime":{"accepted":176,"cached":30,"decode_s":13.42,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.2031,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970668.247198654,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23771427106112242,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.005259603954066,"done":970681.925900547,"finish_reason":"length","first":970668.488369119,"full_response_s":13.678816533996724,"last":970681.905707546,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970668.488369119,3],[970668.628023347,11],[970668.808812377,30],[970668.98211466,19],[970669.135344413,21],[970669.372575198,15],[970669.514999346,19],[970669.664875451,17],[970669.812619869,6],[970669.964358023,11],[970670.114601277,5],[970670.300059063,27],[970670.494659861,12],[970670.679129223,13],[970670.829475943,5],[970670.977663802,16],[970671.162283471,5],[970671.350565874,16],[970671.539661906,7],[970671.686781713,22],[970671.836789185,10],[970672.022246978,7],[970672.207680623,23],[970672.364517372,5],[970672.516998641,9],[970672.690906228,14],[970672.839625157,20],[970672.994160248,8],[970673.145022077,12],[970673.291867104,5],[970673.454575596,14],[970673.601538177,11],[970673.750428394,7],[970673.901027326,9],[970674.050959804,8],[970674.22814915,3],[970674.423747784,10],[970674.572901535,11],[970674.755368738,9],[970674.941173338,10],[970675.127906863,20],[970675.276442127,14],[970675.472184616,14],[970675.70183142,13],[970675.849306833,5],[970676.025665746,14],[970676.263090637,11],[970676.503881956,32],[970676.69035939,33],[970676.841845562,11],[970677.028307582,6],[970677.181806855,8],[970677.331443658,9],[970677.49546519,13],[970677.644722064,8],[970677.796443325,20],[970677.950106536,17],[970678.099762164,20],[970678.253182199,13],[970678.414596541,2],[970678.566827597,16],[970678.751147066,6],[970678.902486538,15],[970679.060398005,8],[970679.241753425,15],[970679.441302123,16],[970679.675459828,27],[970679.956471396,4],[970680.111795919,8],[970680.262246175,25],[970680.422343477,18],[970680.5721694,13],[970680.763511147,55],[970680.914820047,11],[970681.107034849,10],[970681.254914134,11],[970681.417653388,15],[970681.570818936,17],[970681.721376431,14],[970681.905707546,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-0170a1dbfeca4c2390cd2b9b","runtime":{"accepted":176,"cached":30,"decode_s":13.42,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.2031,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970668.247084013,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2412851060507819,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.002016075541682,"done":970681.92448688,"finish_reason":"length","first":970668.485327853,"full_response_s":13.676717257942073,"last":970681.904956538,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970668.485327853,3],[970668.627604338,11],[970668.807240488,30],[970668.981663855,19],[970669.132777749,21],[970669.372615429,15],[970669.514772544,19],[970669.66407384,17],[970669.813081363,6],[970669.964758148,11],[970670.114780137,5],[970670.300348003,27],[970670.499059973,12],[970670.679792428,13],[970670.827039524,5],[970670.975686236,16],[970671.163770337,5],[970671.351683613,16],[970671.538812816,7],[970671.686510488,22],[970671.838059203,10],[970672.023291121,7],[970672.208040246,23],[970672.363820017,5],[970672.518049137,9],[970672.69098408,14],[970672.838679414,20],[970672.993056384,8],[970673.142687322,12],[970673.292849045,5],[970673.454124696,14],[970673.602121097,11],[970673.751635794,7],[970673.901231229,9],[970674.052450894,8],[970674.227874436,3],[970674.423940501,10],[970674.571500203,11],[970674.756195263,9],[970674.94448952,10],[970675.12739573,20],[970675.276583909,14],[970675.473494206,14],[970675.704329494,13],[970675.850399846,5],[970676.026461275,14],[970676.26066331,11],[970676.505706552,32],[970676.691898119,33],[970676.845605121,11],[970677.029214822,6],[970677.183307769,8],[970677.33067415,9],[970677.497623692,13],[970677.645306552,8],[970677.79690045,20],[970677.950462142,17],[970678.103227982,20],[970678.252889323,13],[970678.415829782,2],[970678.567362909,16],[970678.750767201,6],[970678.901344334,15],[970679.057756872,8],[970679.242454875,15],[970679.441063111,16],[970679.676325558,27],[970679.954730447,4],[970680.115310478,8],[970680.265141569,25],[970680.421371651,18],[970680.571871483,13],[970680.762623846,55],[970680.915361744,11],[970681.111117492,10],[970681.255135111,11],[970681.418995365,15],[970681.569938581,17],[970681.71944403,14],[970681.904956538,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-2c25a89d33ab4b1bb12e3185","runtime":{"accepted":176,"cached":30,"decode_s":13.4201,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.2031,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970668.247769622,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23755823099054396,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.002611124350857,"done":970681.919852187,"finish_reason":"length","first":970668.485559264,"full_response_s":13.672725544078276,"last":970681.904767726,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970668.485559264,3],[970668.627850488,11],[970668.807979818,30],[970668.983419499,19],[970669.132981908,21],[970669.372658427,15],[970669.514480339,19],[970669.66329881,17],[970669.813772077,6],[970669.964137429,11],[970670.115052402,5],[970670.299942645,27],[970670.497234334,12],[970670.678410457,13],[970670.828084019,5],[970670.976595415,16],[970671.16184662,5],[970671.35296624,16],[970671.539366293,7],[970671.688042626,22],[970671.839139335,10],[970672.023138794,7],[970672.209133452,23],[970672.363344665,5],[970672.517600733,9],[970672.69140752,14],[970672.839347435,20],[970672.99606633,8],[970673.14492579,12],[970673.292392336,5],[970673.454458635,14],[970673.601975907,11],[970673.751285405,7],[970673.900879352,9],[970674.05287139,8],[970674.229492074,3],[970674.423677021,10],[970674.574914048,11],[970674.755506535,9],[970674.941883862,10],[970675.126874115,20],[970675.277178111,14],[970675.473194417,14],[970675.70311547,13],[970675.849532323,5],[970676.028364474,14],[970676.262046015,11],[970676.50458155,32],[970676.689984006,33],[970676.843215432,11],[970677.030158149,6],[970677.182253354,8],[970677.333729123,9],[970677.497764929,13],[970677.644537012,8],[970677.801861262,20],[970677.94860463,17],[970678.100823844,20],[970678.251308093,13],[970678.415235613,2],[970678.567282017,16],[970678.754227578,6],[970678.901032991,15],[970679.057911247,8],[970679.243476052,15],[970679.442139401,16],[970679.673088272,27],[970679.953783825,4],[970680.110764084,8],[970680.264172399,25],[970680.423015402,18],[970680.571357294,13],[970680.761832512,55],[970680.914408866,11],[970681.110608792,10],[970681.25327032,11],[970681.419766696,15],[970681.569606755,17],[970681.719955514,14],[970681.904767726,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-80c2ffaa5a3e4fcb8bd6e25b","runtime":{"accepted":176,"cached":30,"decode_s":13.42,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.2031,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970668.247126643,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23843262100126594,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.003220329488933,"done":970681.925583139,"finish_reason":"length","first":970668.485777441,"full_response_s":13.677589002996683,"last":970681.90455571,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970668.485777441,3],[970668.628896617,11],[970668.807039722,30],[970668.983497543,19],[970669.134742897,21],[970669.373126387,15],[970669.516061525,19],[970669.662815952,17],[970669.814395308,6],[970669.964897146,11],[970670.113546044,5],[970670.302948544,27],[970670.494603788,12],[970670.677760006,13],[970670.827370966,5],[970670.977320229,16],[970671.163975649,5],[970671.354280585,16],[970671.537616586,7],[970671.688619129,22],[970671.837371994,10],[970672.022321181,7],[970672.207796432,23],[970672.363610353,5],[970672.518958204,9],[970672.689468441,14],[970672.839459116,20],[970672.994349093,8],[970673.143798755,12],[970673.290373501,5],[970673.454195699,14],[970673.603253958,11],[970673.751941104,7],[970673.90014316,9],[970674.051501886,8],[970674.229214992,3],[970674.425966632,10],[970674.573198124,11],[970674.755711974,9],[970674.944132202,10],[970675.125527847,20],[970675.276056517,14],[970675.473050395,14],[970675.701689062,13],[970675.851091791,5],[970676.027233599,14],[970676.26081671,11],[970676.505191786,32],[970676.690311687,33],[970676.843044559,11],[970677.028415214,6],[970677.181574116,8],[970677.33176393,9],[970677.495402973,13],[970677.644610639,8],[970677.797889271,20],[970677.949819741,17],[970678.100717716,20],[970678.253078776,13],[970678.418942491,2],[970678.569370027,16],[970678.753358359,6],[970678.901667903,15],[970679.059111475,8],[970679.243029393,15],[970679.440942389,16],[970679.673010052,27],[970679.954273242,4],[970680.113277789,8],[970680.261552006,25],[970680.421524186,18],[970680.572349443,13],[970680.765119949,55],[970680.915850474,11],[970681.10917885,10],[970681.254089019,11],[970681.417984189,15],[970681.571057996,17],[970681.720027845,14],[970681.90455571,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-088e528a6be840a2af9f2333","runtime":{"accepted":176,"cached":30,"decode_s":13.4201,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.2031,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970668.247994136,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23778330499771982,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":19.002839278028414,"done":970681.925112813,"finish_reason":"length","first":970668.486221702,"full_response_s":13.678308170987293,"last":970681.905269049,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970668.486221702,3],[970668.627901936,11],[970668.807726803,30],[970668.981801492,19],[970669.134545523,21],[970669.372535016,15],[970669.514840922,19],[970669.662867528,17],[970669.815072819,6],[970669.963402469,11],[970670.116021414,5],[970670.300281113,27],[970670.495460303,12],[970670.679218965,13],[970670.827538656,5],[970670.975969415,16],[970671.163580901,5],[970671.351227639,16],[970671.538558266,7],[970671.692668419,22],[970671.836085206,10],[970672.021814912,7],[970672.209038173,23],[970672.364049876,5],[970672.516641995,9],[970672.689803148,14],[970672.8388496,20],[970672.993798513,8],[970673.143028174,12],[970673.290492495,5],[970673.455823834,14],[970673.604072706,11],[970673.751228244,7],[970673.900298223,9],[970674.050831112,8],[970674.227610412,3],[970674.423297219,10],[970674.573074121,11],[970674.757346702,9],[970674.941570998,10],[970675.1257466,20],[970675.276527516,14],[970675.473126903,14],[970675.700862841,13],[970675.850898609,5],[970676.028290959,14],[970676.261198511,11],[970676.504524053,32],[970676.69023518,33],[970676.842320881,11],[970677.028795095,6],[970677.183067717,8],[970677.333013959,9],[970677.496208966,13],[970677.647099494,8],[970677.798017082,20],[970677.949045833,17],[970678.099900969,20],[970678.251165992,13],[970678.41550863,2],[970678.566030677,16],[970678.750381783,6],[970678.900411602,15],[970679.057113719,8],[970679.242059391,15],[970679.440409349,16],[970679.67343474,27],[970679.954653427,4],[970680.111338426,8],[970680.263813001,25],[970680.422618078,18],[970680.572616955,13],[970680.76152709,55],[970680.914582236,11],[970681.106767753,10],[970681.254228047,11],[970681.416442567,15],[970681.570720746,17],[970681.718646918,14],[970681.905269049,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-f8f2835de27549a295f20fce","runtime":{"accepted":176,"cached":30,"decode_s":13.42,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.2031,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970668.246804642,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2394170599291101,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.965588181663517,"done":970695.6224051,"finish_reason":"length","first":970682.164227368,"full_response_s":13.680819489993155,"last":970695.609631621,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970682.164227368,3],[970682.301986125,11],[970682.489986947,30],[970682.664851439,19],[970682.811774124,21],[970682.99814718,15],[970683.152772958,19],[970683.299216892,17],[970683.46106173,6],[970683.60910099,11],[970683.757408113,5],[970683.942424546,27],[970684.133539649,12],[970684.321287546,13],[970684.480691896,5],[970684.629373019,16],[970684.820523579,5],[970685.004528693,16],[970685.192804921,7],[970685.340692172,22],[970685.496889922,10],[970685.682818842,7],[970685.866287044,23],[970686.018968438,5],[970686.167679259,9],[970686.347615382,14],[970686.500524042,20],[970686.652054673,8],[970686.803537265,12],[970686.954051562,5],[970687.107413671,14],[970687.258733493,11],[970687.413160527,7],[970687.563364009,9],[970687.713004799,8],[970687.886648977,3],[970688.073272118,10],[970688.222762972,11],[970688.414873244,9],[970688.601345547,10],[970688.789301909,20],[970688.940379619,14],[970689.124228236,14],[970689.363752423,13],[970689.516089033,5],[970689.689417666,14],[970689.923084719,11],[970690.162236226,32],[970690.356599093,33],[970690.515415943,11],[970690.698673943,6],[970690.848619412,8],[970690.99890535,9],[970691.151610299,13],[970691.301413701,8],[970691.459362156,20],[970691.611995239,17],[970691.761253937,20],[970691.910341623,13],[970692.115166943,2],[970692.252167147,16],[970692.449618056,6],[970692.597389984,15],[970692.749717972,8],[970692.935620066,15],[970693.124479185,16],[970693.37460588,27],[970693.656534063,4],[970693.806956275,8],[970693.958878762,25],[970694.116989465,18],[970694.264425696,13],[970694.460335441,55],[970694.612643232,11],[970694.799607815,10],[970694.951512901,11],[970695.104086897,15],[970695.254310839,17],[970695.415195007,14],[970695.609631621,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-1f2cdf18979d45fcaae66310","runtime":{"accepted":176,"cached":30,"decode_s":13.4401,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1926,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970681.94158561,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.22264175792224705,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.974799465005777,"done":970695.618486513,"finish_reason":"length","first":970682.164398129,"full_response_s":13.675799809978344,"last":970695.603275334,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970682.164398129,3],[970682.30309373,11],[970682.491175077,30],[970682.665275711,19],[970682.812194299,21],[970683.001325206,15],[970683.149798531,19],[970683.299608214,17],[970683.460354473,6],[970683.609378391,11],[970683.757991928,5],[970683.941476581,27],[970684.135047409,12],[970684.320072117,13],[970684.482457807,5],[970684.62924628,16],[970684.820871887,5],[970685.003622574,16],[970685.194876989,7],[970685.341346269,22],[970685.498833139,10],[970685.680715809,7],[970685.86886661,23],[970686.01501534,5],[970686.167826913,9],[970686.348192092,14],[970686.500094842,20],[970686.653450496,8],[970686.803670869,12],[970686.952517687,5],[970687.108415451,14],[970687.257499134,11],[970687.413378896,7],[970687.563963585,9],[970687.712757098,8],[970687.885903843,3],[970688.072171267,10],[970688.220784392,11],[970688.417883673,9],[970688.60185351,10],[970688.788931678,20],[970688.93938184,14],[970689.123789755,14],[970689.365286233,13],[970689.515680941,5],[970689.689785704,14],[970689.922385448,11],[970690.164398305,32],[970690.358434899,33],[970690.515189334,11],[970690.698070318,6],[970690.848453756,8],[970690.99839089,9],[970691.150513401,13],[970691.30067116,8],[970691.459984936,20],[970691.609073177,17],[970691.762679523,20],[970691.911344954,13],[970692.11502505,2],[970692.252389179,16],[970692.449302826,6],[970692.599905137,15],[970692.750779776,8],[970692.936064916,15],[970693.127184765,16],[970693.375120292,27],[970693.655534429,4],[970693.80752607,8],[970693.960650477,25],[970694.111350385,18],[970694.264568565,13],[970694.460247156,55],[970694.613621007,11],[970694.801145255,10],[970694.951723763,11],[970695.104736304,15],[970695.253541783,17],[970695.416026873,14],[970695.603275334,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-53fea00f7bbe4a37b1cf0abb","runtime":{"accepted":176,"cached":30,"decode_s":13.4403,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1926,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970681.942686703,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.221711425925605,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.97241234549459,"done":970695.620310571,"finish_reason":"length","first":970682.16444476,"full_response_s":13.678639860008843,"last":970695.605012852,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970682.16444476,3],[970682.302605449,11],[970682.492986563,30],[970682.664939692,19],[970682.812250115,21],[970682.99862858,15],[970683.150110833,19],[970683.298873321,17],[970683.460775735,6],[970683.608587793,11],[970683.757942865,5],[970683.941671986,27],[970684.133127491,12],[970684.318970561,13],[970684.480252327,5],[970684.630155919,16],[970684.820799812,5],[970685.004371021,16],[970685.193806654,7],[970685.341913058,22],[970685.49768308,10],[970685.67936124,7],[970685.865536565,23],[970686.014917165,5],[970686.16969583,9],[970686.347873933,14],[970686.499939411,20],[970686.652687087,8],[970686.802197066,12],[970686.9521171,5],[970687.108327966,14],[970687.256181243,11],[970687.413052735,7],[970687.563510462,9],[970687.71419323,8],[970687.885983342,3],[970688.070554532,10],[970688.220299633,11],[970688.414539387,9],[970688.600712077,10],[970688.787582327,20],[970688.938226741,14],[970689.125307739,14],[970689.363041262,13],[970689.517769137,5],[970689.691786912,14],[970689.924251451,11],[970690.162942906,32],[970690.357645551,33],[970690.515061699,11],[970690.698600924,6],[970690.851941885,8],[970690.999556437,9],[970691.152278813,13],[970691.300910987,8],[970691.459801405,20],[970691.609848587,17],[970691.760898685,20],[970691.912161314,13],[970692.116114153,2],[970692.253508992,16],[970692.450639518,6],[970692.600521164,15],[970692.751175674,8],[970692.938324894,15],[970693.126066089,16],[970693.376256458,27],[970693.654896639,4],[970693.805576233,8],[970693.958704769,25],[970694.112733387,18],[970694.264755776,13],[970694.462100803,55],[970694.612176396,11],[970694.799811925,10],[970694.951619748,11],[970695.103714875,15],[970695.254726883,17],[970695.415932747,14],[970695.605012852,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-de1374d51091410f927e39d4","runtime":{"accepted":176,"cached":30,"decode_s":13.4403,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1926,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970681.941670711,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.22277404891792685,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.974168447718924,"done":970695.622265336,"finish_reason":"length","first":970682.163499931,"full_response_s":13.679422306013294,"last":970695.602824068,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970682.163499931,3],[970682.303163692,11],[970682.490688476,30],[970682.667660899,19],[970682.812046965,21],[970683.000286219,15],[970683.150964593,19],[970683.298835219,17],[970683.45957026,6],[970683.608913762,11],[970683.757218869,5],[970683.941595511,27],[970684.134188753,12],[970684.32046704,13],[970684.480599627,5],[970684.629976116,16],[970684.821740016,5],[970685.003868355,16],[970685.190876154,7],[970685.342848813,22],[970685.497169388,10],[970685.681701572,7],[970685.865796459,23],[970686.015264576,5],[970686.170744577,9],[970686.348038437,14],[970686.500990607,20],[970686.653156324,8],[970686.805916626,12],[970686.953257156,5],[970687.108062599,14],[970687.255616328,11],[970687.41355361,7],[970687.567825581,9],[970687.713697349,8],[970687.889244736,3],[970688.071493887,10],[970688.223338978,11],[970688.415064216,9],[970688.602973931,10],[970688.790218204,20],[970688.938336117,14],[970689.123474828,14],[970689.363414181,13],[970689.51597532,5],[970689.690630805,14],[970689.923238374,11],[970690.162722154,32],[970690.35882438,33],[970690.516061046,11],[970690.699345434,6],[970690.851014996,8],[970690.998856639,9],[970691.151420175,13],[970691.301496561,8],[970691.461036706,20],[970691.609639677,17],[970691.760636086,20],[970691.91390573,13],[970692.115674761,2],[970692.253638034,16],[970692.449124688,6],[970692.600261285,15],[970692.750671424,8],[970692.937682672,15],[970693.126172521,16],[970693.374906068,27],[970693.657356855,4],[970693.806327831,8],[970693.960302762,25],[970694.112239235,18],[970694.26408923,13],[970694.459353874,55],[970694.612331874,11],[970694.803383118,10],[970694.951059106,11],[970695.102424047,15],[970695.254386082,17],[970695.415684999,14],[970695.602824068,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-122478d27a7941828aa45f72","runtime":{"accepted":176,"cached":30,"decode_s":13.4403,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1926,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970681.94284303,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.22065690101590008,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.96956272675869,"done":970695.622215072,"finish_reason":"length","first":970682.163147959,"full_response_s":13.680454508052208,"last":970695.605735101,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970682.163147959,3],[970682.302685845,11],[970682.496849396,30],[970682.663217595,19],[970682.811890174,21],[970682.998059375,15],[970683.149911956,19],[970683.299038961,17],[970683.461828308,6],[970683.608386259,11],[970683.756678132,5],[970683.941300235,27],[970684.133700441,12],[970684.31973005,13],[970684.481459498,5],[970684.63024278,16],[970684.820638044,5],[970685.00331032,16],[970685.192956351,7],[970685.340817423,22],[970685.498014281,10],[970685.68244493,7],[970685.865930207,23],[970686.015119659,5],[970686.169204893,9],[970686.347949464,14],[970686.499121866,20],[970686.651362778,8],[970686.801904335,12],[970686.951999802,5],[970687.10847682,14],[970687.255755532,11],[970687.412361705,7],[970687.564730643,9],[970687.716248383,8],[970687.889603141,3],[970688.072289893,10],[970688.220892152,11],[970688.414763068,9],[970688.600348119,10],[970688.788364074,20],[970688.944424023,14],[970689.125702341,14],[970689.366156794,13],[970689.515539992,5],[970689.691848041,14],[970689.922795108,11],[970690.165317624,32],[970690.358218483,33],[970690.517265655,11],[970690.699124073,6],[970690.849479107,8],[970690.999412464,9],[970691.152954064,13],[970691.301653016,8],[970691.460637672,20],[970691.610693943,17],[970691.761905025,20],[970691.910817309,13],[970692.114987108,2],[970692.254251548,16],[970692.449532972,6],[970692.59861722,15],[970692.751269656,8],[970692.936948789,15],[970693.127622333,16],[970693.374986672,27],[970693.656446754,4],[970693.809423996,8],[970693.957680827,25],[970694.111129024,18],[970694.263839466,13],[970694.460024164,55],[970694.611277897,11],[970694.799397128,10],[970694.951663819,11],[970695.103020902,15],[970695.256382037,17],[970695.414523597,14],[970695.605735101,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-3736363d8f0341edb3342148","runtime":{"accepted":176,"cached":30,"decode_s":13.4401,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1926,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970681.941760564,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.22138739505317062,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.96706488526721,"done":970695.621191579,"finish_reason":"length","first":970682.164163022,"full_response_s":13.67840980598703,"last":970695.608520467,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970682.164163022,3],[970682.301725542,11],[970682.490286,30],[970682.664112753,19],[970682.815278839,21],[970683.000921178,15],[970683.150200783,19],[970683.299771887,17],[970683.460984983,6],[970683.608662124,11],[970683.757888969,5],[970683.940723877,27],[970684.131992122,12],[970684.321590743,13],[970684.480364664,5],[970684.631830632,16],[970684.822707136,5],[970685.003049177,16],[970685.191753533,7],[970685.341161122,22],[970685.499101483,10],[970685.680268847,7],[970685.866226251,23],[970686.015746376,5],[970686.168544075,9],[970686.347768653,14],[970686.502221798,20],[970686.653973901,8],[970686.803466566,12],[970686.953201068,5],[970687.109182701,14],[970687.256704873,11],[970687.41323369,7],[970687.563447125,9],[970687.713354066,8],[970687.88787831,3],[970688.071402417,10],[970688.220623088,11],[970688.41496665,9],[970688.601121082,10],[970688.78876671,20],[970688.939030636,14],[970689.124030766,14],[970689.364171285,13],[970689.515831427,5],[970689.690563419,14],[970689.924415635,11],[970690.16257106,32],[970690.357715737,33],[970690.517081276,11],[970690.697585062,6],[970690.849619079,8],[970690.998973904,9],[970691.151947372,13],[970691.30124566,8],[970691.462194045,20],[970691.609789091,17],[970691.762328511,20],[970691.910161005,13],[970692.114399166,2],[970692.254441544,16],[970692.449909763,6],[970692.599058709,15],[970692.752103666,8],[970692.937444654,15],[970693.126723401,16],[970693.375510189,27],[970693.655036084,4],[970693.806847475,8],[970693.959293767,25],[970694.112605624,18],[970694.263600951,13],[970694.46280617,55],[970694.618677346,11],[970694.799974684,10],[970694.950428454,11],[970695.105180449,15],[970695.253247788,17],[970695.415522303,14],[970695.608520467,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-817b62e671e64319a03aab21","runtime":{"accepted":176,"cached":30,"decode_s":13.4402,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1926,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970681.942781773,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.22138124890625477,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.96857979176435,"done":970695.621257317,"finish_reason":"length","first":970682.162817445,"full_response_s":13.679005447076634,"last":970695.60610117,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970682.162817445,3],[970682.303425732,11],[970682.496672602,30],[970682.667730141,19],[970682.812442352,21],[970682.998929073,15],[970683.151793676,19],[970683.297920619,17],[970683.459025619,6],[970683.60803083,11],[970683.756385769,5],[970683.941038724,27],[970684.133782261,12],[970684.319544758,13],[970684.483370775,5],[970684.630054256,16],[970684.821866979,5],[970685.00252798,16],[970685.195193308,7],[970685.342423037,22],[970685.497313553,10],[970685.681626425,7],[970685.866642681,23],[970686.01548749,5],[970686.168828213,9],[970686.348490344,14],[970686.499653513,20],[970686.652242829,8],[970686.802481572,12],[970686.951188018,5],[970687.11019069,14],[970687.256058297,11],[970687.414386373,7],[970687.563834094,9],[970687.713416155,8],[970687.885379477,3],[970688.070837518,10],[970688.221428727,11],[970688.413767305,9],[970688.600485516,10],[970688.787440338,20],[970688.938650788,14],[970689.124099033,14],[970689.3634876,13],[970689.515912607,5],[970689.690874905,14],[970689.922991553,11],[970690.16284462,32],[970690.357963246,33],[970690.51649687,11],[970690.698255929,6],[970690.848979817,8],[970690.999617934,9],[970691.150592005,13],[970691.300544789,8],[970691.459734179,20],[970691.609190667,17],[970691.760711393,20],[970691.912904031,13],[970692.114868803,2],[970692.25322631,16],[970692.449688755,6],[970692.599119838,15],[970692.750611079,8],[970692.93664348,15],[970693.127280699,16],[970693.37480631,27],[970693.654471857,4],[970693.806634932,8],[970693.960990223,25],[970694.114166572,18],[970694.265232486,13],[970694.460869167,55],[970694.617412905,11],[970694.799740042,10],[970694.950492736,11],[970695.102663554,15],[970695.253397858,17],[970695.416619951,14],[970695.60610117,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-76ddbe27c4d14d4097230c52","runtime":{"accepted":176,"cached":30,"decode_s":13.4403,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1926,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970681.94225187,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.220565575058572,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.97218498955919,"done":970695.618934626,"finish_reason":"length","first":970682.163103392,"full_response_s":13.677108980016783,"last":970695.603832551,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970682.163103392,3],[970682.302381784,11],[970682.489872946,30],[970682.665019848,19],[970682.811485297,21],[970683.000347284,15],[970683.151467275,19],[970683.298926064,17],[970683.460649413,6],[970683.609653616,11],[970683.757611119,5],[970683.942487116,27],[970684.133033381,12],[970684.318877923,13],[970684.481973591,5],[970684.629512591,16],[970684.820243122,5],[970685.003407598,16],[970685.197276017,7],[970685.340448392,22],[970685.497388925,10],[970685.684310199,7],[970685.865415587,23],[970686.015660219,5],[970686.168904736,9],[970686.346869208,14],[970686.50003024,20],[970686.652124443,8],[970686.80282732,12],[970686.951780218,5],[970687.107287124,14],[970687.255814373,11],[970687.412957793,7],[970687.564165071,9],[970687.713604263,8],[970687.888108456,3],[970688.071868982,10],[970688.219673988,11],[970688.417019881,9],[970688.602485411,10],[970688.790059253,20],[970688.944643656,14],[970689.125103693,14],[970689.364040434,13],[970689.517523132,5],[970689.689314659,14],[970689.924014552,11],[970690.162174489,32],[970690.356770478,33],[970690.514776825,11],[970690.698540467,6],[970690.850194892,8],[970690.999102963,9],[970691.150784849,13],[970691.302194472,8],[970691.459178161,20],[970691.609372133,17],[970691.762237714,20],[970691.911129979,13],[970692.114764132,2],[970692.252563605,16],[970692.449040644,6],[970692.597766904,15],[970692.750493318,8],[970692.938268838,15],[970693.127343476,16],[970693.377910396,27],[970693.654266067,4],[970693.805780519,8],[970693.958147087,25],[970694.112851052,18],[970694.264357574,13],[970694.459611192,55],[970694.61138068,11],[970694.798682624,10],[970694.95142852,11],[970695.103393068,15],[970695.25460453,17],[970695.416197297,14],[970695.603832551,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-70fcc315042a466b9dfebab1","runtime":{"accepted":176,"cached":30,"decode_s":13.4402,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1926,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970681.941825646,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2212777460226789,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.963833385190195,"done":970695.621942297,"finish_reason":"length","first":970682.162890864,"full_response_s":13.68002907000482,"last":970695.609539272,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970682.162890864,3],[970682.303512257,11],[970682.49183876,30],[970682.665807902,19],[970682.811387507,21],[970682.999985406,15],[970683.149302073,19],[970683.299274901,17],[970683.459275192,6],[970683.609801862,11],[970683.758500804,5],[970683.942351415,27],[970684.135303079,12],[970684.322928926,13],[970684.483284266,5],[970684.629812092,16],[970684.822635429,5],[970685.003513182,16],[970685.195057479,7],[970685.342987905,22],[970685.498229897,10],[970685.682548658,7],[970685.866765275,23],[970686.017411359,5],[970686.169831706,9],[970686.347169972,14],[970686.501187068,20],[970686.651853235,8],[970686.804715392,12],[970686.951677915,5],[970687.107845767,14],[970687.25678106,11],[970687.413287938,7],[970687.564093349,9],[970687.714750241,8],[970687.886702329,3],[970688.071601119,10],[970688.220373563,11],[970688.415125137,9],[970688.602602741,10],[970688.787783908,20],[970688.941607672,14],[970689.123610929,14],[970689.362621264,13],[970689.515757416,5],[970689.690925136,14],[970689.923478009,11],[970690.162497289,32],[970690.359402258,33],[970690.51527365,11],[970690.699634804,6],[970690.848300037,8],[970691.000454713,9],[970691.152492476,13],[970691.302708243,8],[970691.459274144,20],[970691.610095024,17],[970691.762558705,20],[970691.910672968,13],[970692.114816139,2],[970692.254186099,16],[970692.449469379,6],[970692.599263507,15],[970692.753653462,8],[970692.937612566,15],[970693.126850204,16],[970693.377170832,27],[970693.656884066,4],[970693.808670846,8],[970693.958523798,25],[970694.114229862,18],[970694.265532737,13],[970694.461892709,55],[970694.613328724,11],[970694.80038324,10],[970694.95119607,11],[970695.103467479,15],[970695.256830246,17],[970695.417224167,14],[970695.609539272,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-a999ea7a6eef49aab6a8334a","runtime":{"accepted":176,"cached":30,"decode_s":13.4402,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1926,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970681.941913227,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.22097763698548079,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.974216525368025,"done":970695.62164739,"finish_reason":"length","first":970682.163666132,"full_response_s":13.679247402003966,"last":970695.602956216,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970682.163666132,3],[970682.302883011,11],[970682.491053058,30],[970682.666053587,19],[970682.812133778,21],[970682.999006764,15],[970683.150297869,19],[970683.299706789,17],[970683.460849282,6],[970683.609597016,11],[970683.757130392,5],[970683.941533806,27],[970684.133985843,12],[970684.319807422,13],[970684.481046509,5],[970684.629897417,16],[970684.82195512,5],[970685.00271652,16],[970685.19051074,7],[970685.340554136,22],[970685.496637597,10],[970685.680521172,7],[970685.866708226,23],[970686.015176035,5],[970686.16988381,9],[970686.347541739,14],[970686.500337262,20],[970686.652498739,8],[970686.802617304,12],[970686.951271342,5],[970687.107482401,14],[970687.256650785,11],[970687.412867028,7],[970687.563639938,9],[970687.712676334,8],[970687.8868034,3],[970688.070654499,10],[970688.22020205,11],[970688.414010653,9],[970688.600652612,10],[970688.788837184,20],[970688.938902425,14],[970689.124856152,14],[970689.362553654,13],[970689.517346898,5],[970689.689942063,14],[970689.923963296,11],[970690.162299852,32],[970690.356714662,33],[970690.514852916,11],[970690.698145065,6],[970690.848694976,8],[970690.998532719,9],[970691.1518941,13],[970691.301337034,8],[970691.458896136,20],[970691.608825429,17],[970691.761861866,20],[970691.911482031,13],[970692.11431901,2],[970692.253713598,16],[970692.450314143,6],[970692.598733942,15],[970692.751343331,8],[970692.936730389,15],[970693.126941225,16],[970693.376445782,27],[970693.657893878,4],[970693.807956885,8],[970693.958222746,25],[970694.11125173,18],[970694.264285867,13],[970694.459733881,55],[970694.611323343,11],[970694.803464026,10],[970694.9503266,11],[970695.104453463,15],[970695.253928079,17],[970695.414752975,14],[970695.602956216,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-ad54a02cef6046028f7cac78","runtime":{"accepted":176,"cached":30,"decode_s":13.4402,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1926,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970681.942399988,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.22126614407170564,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.974468382373594,"done":970695.621441216,"finish_reason":"length","first":970682.165771231,"full_response_s":13.678861200925894,"last":970695.604882929,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970682.165771231,3],[970682.302280153,11],[970682.491942151,30],[970682.663517096,19],[970682.814166833,21],[970682.998330568,15],[970683.149449359,19],[970683.298765177,17],[970683.462299291,6],[970683.608512246,11],[970683.756286218,5],[970683.941355139,27],[970684.13263265,12],[970684.319885001,13],[970684.480945198,5],[970684.631213341,16],[970684.821236069,5],[970685.004109623,16],[970685.196295807,7],[970685.343230533,22],[970685.498543384,10],[970685.680868184,7],[970685.865345688,23],[970686.01616791,5],[970686.169947915,9],[970686.347468144,14],[970686.500219036,20],[970686.65218514,8],[970686.802888625,12],[970686.951859526,5],[970687.108620969,14],[970687.255908035,11],[970687.413882474,7],[970687.565140784,9],[970687.713132593,8],[970687.886333026,3],[970688.072838838,10],[970688.221118153,11],[970688.415238226,9],[970688.601713345,10],[970688.789639175,20],[970688.939245739,14],[970689.125604423,14],[970689.365941402,13],[970689.516798497,5],[970689.689492157,14],[970689.923300959,11],[970690.163606924,32],[970690.358329412,33],[970690.514997673,11],[970690.697903253,6],[970690.850329056,8],[970690.99925753,9],[970691.151093039,13],[970691.301573853,8],[970691.459885913,20],[970691.610354294,17],[970691.761529946,20],[970691.913128704,13],[970692.114927788,2],[970692.252936028,16],[970692.450542592,6],[970692.598788029,15],[970692.751576373,8],[970692.937741353,15],[970693.129560905,16],[970693.376845472,27],[970693.654600564,4],[970693.807747591,8],[970693.959558525,25],[970694.111748171,18],[970694.263697445,13],[970694.460724858,55],[970694.61684167,11],[970694.799306363,10],[970694.952715108,11],[970695.103313264,15],[970695.254672555,17],[970695.415399245,14],[970695.604882929,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-95d32b06b60147e88f9af6de","runtime":{"accepted":176,"cached":30,"decode_s":13.4402,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1926,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970681.942580015,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.22319121600594372,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.96884679622731,"done":970695.618553274,"finish_reason":"length","first":970682.162520985,"full_response_s":13.676572997006588,"last":970695.605615483,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970682.162520985,3],[970682.302777875,11],[970682.490547015,30],[970682.665596911,19],[970682.811971514,21],[970682.999120685,15],[970683.149610599,19],[970683.300586088,17],[970683.461150527,6],[970683.609197068,11],[970683.756967279,5],[970683.941406795,27],[970684.132435404,12],[970684.319297938,13],[970684.482673311,5],[970684.629736273,16],[970684.822560858,5],[970685.003467159,16],[970685.191252706,7],[970685.341431498,22],[970685.497920844,10],[970685.679932109,7],[970685.866534713,23],[970686.015327626,5],[970686.168412712,9],[970686.349308561,14],[970686.501599593,20],[970686.651963795,8],[970686.803209168,12],[970686.952988317,5],[970687.109241621,14],[970687.257211316,11],[970687.414033585,7],[970687.566973167,9],[970687.714022581,8],[970687.886532399,3],[970688.073678354,10],[970688.221843557,11],[970688.414477074,9],[970688.600786344,10],[970688.788095459,20],[970688.938443765,14],[970689.123948338,14],[970689.363236587,13],[970689.515176658,5],[970689.690285922,14],[970689.922704775,11],[970690.163301615,32],[970690.356892544,33],[970690.51380521,11],[970690.699055743,6],[970690.848922913,8],[970690.999336117,9],[970691.150438462,13],[970691.300743219,8],[970691.459456586,20],[970691.609310748,17],[970691.760539416,20],[970691.910914411,13],[970692.115273294,2],[970692.253574985,16],[970692.449379125,6],[970692.599982109,15],[970692.750395048,8],[970692.935928944,15],[970693.125593652,16],[970693.374296123,27],[970693.654969226,4],[970693.805850497,8],[970693.96038151,25],[970694.11187795,18],[970694.263526028,13],[970694.459527723,55],[970694.61145117,11],[970694.799194346,10],[970694.953876061,11],[970695.102564371,15],[970695.255363552,17],[970695.417828943,14],[970695.605615483,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-e1e331fbbe6f4d0391a0c341","runtime":{"accepted":176,"cached":30,"decode_s":13.4402,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1926,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970681.941980277,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.22054070804733783,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.964698393829963,"done":970695.62261265,"finish_reason":"length","first":970682.162954762,"full_response_s":13.680149820982479,"last":970695.608989848,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970682.162954762,3],[970682.30475489,11],[970682.490626259,30],[970682.665353802,19],[970682.813293567,21],[970682.997700026,15],[970683.152330748,19],[970683.300641856,17],[970683.46172162,6],[970683.609504186,11],[970683.758594498,5],[970683.943453419,27],[970684.133895526,12],[970684.32263429,13],[970684.48009912,5],[970684.629579481,16],[970684.821646514,5],[970685.002785938,16],[970685.193944706,7],[970685.341609973,22],[970685.500347972,10],[970685.681462704,7],[970685.866131773,23],[970686.018070545,5],[970686.168725526,9],[970686.347322763,14],[970686.499852486,20],[970686.651766262,8],[970686.802552095,12],[970686.951331095,5],[970687.108691668,14],[970687.255501623,11],[970687.416066174,7],[970687.565070901,9],[970687.71347546,8],[970687.885644428,3],[970688.074070268,10],[970688.220847649,11],[970688.416902184,9],[970688.602839832,10],[970688.787950109,20],[970688.93991267,14],[970689.128162304,14],[970689.362891064,13],[970689.517433055,5],[970689.691389381,14],[970689.922532094,11],[970690.163539938,32],[970690.357289915,33],[970690.514925599,11],[970690.699215606,6],[970690.849560207,8],[970690.999199953,9],[970691.151372952,13],[970691.302799105,8],[970691.459665737,20],[970691.610427888,17],[970691.763865489,20],[970691.913217117,13],[970692.115321797,2],[970692.253153403,16],[970692.448828741,6],[970692.597687356,15],[970692.753427829,8],[970692.935534134,15],[970693.12455558,16],[970693.374487479,27],[970693.654826629,4],[970693.807143982,8],[970693.958336091,25],[970694.11239849,18],[970694.266293793,13],[970694.46057074,55],[970694.611562258,11],[970694.800444865,10],[970694.953791617,11],[970695.10319003,15],[970695.256579234,17],[970695.414639902,14],[970695.608989848,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-eec94bcb8a7e437397e2177b","runtime":{"accepted":176,"cached":30,"decode_s":13.4401,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1926,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970681.942462829,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2204919329378754,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.97168742895162,"done":970695.618172147,"finish_reason":"length","first":970682.162253185,"full_response_s":13.676122259930708,"last":970695.603334847,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970682.162253185,3],[970682.302099261,11],[970682.493103877,30],[970682.663350015,19],[970682.811329754,21],[970682.998759224,15],[970683.151587437,19],[970683.298361068,17],[970683.460168477,6],[970683.608833766,11],[970683.756873329,5],[970683.9408478,27],[970684.132204634,12],[970684.319071584,13],[970684.480872835,5],[970684.630312374,16],[970684.819983947,5],[970685.002849051,16],[970685.190977961,7],[970685.340282655,22],[970685.50049489,10],[970685.679725518,7],[970685.865175535,23],[970686.014722864,5],[970686.167591742,9],[970686.347057156,14],[970686.49939557,20],[970686.652317752,8],[970686.802422604,12],[970686.951063072,5],[970687.108564961,14],[970687.255420923,11],[970687.412778855,7],[970687.563060924,9],[970687.713528124,8],[970687.887671144,3],[970688.07105339,10],[970688.220480539,11],[970688.414678943,9],[970688.600926605,10],[970688.787703897,20],[970688.937952717,14],[970689.123356827,14],[970689.363682669,13],[970689.515458412,5],[970689.689093554,14],[970689.923801993,11],[970690.163992101,32],[970690.359880376,33],[970690.515127532,11],[970690.699523172,6],[970690.850115952,8],[970690.998598889,9],[970691.150725353,13],[970691.301006889,8],[970691.461929718,20],[970691.608967754,17],[970691.760126123,20],[970691.912970169,13],[970692.114502013,2],[970692.253114198,16],[970692.448685376,6],[970692.597486927,15],[970692.749838422,8],[970692.934703756,15],[970693.123669146,16],[970693.375208977,27],[970693.658211412,4],[970693.805660485,8],[970693.958429625,25],[970694.111688274,18],[970694.263436431,13],[970694.459235873,55],[970694.611177994,11],[970694.798568111,10],[970694.950245292,11],[970695.102949211,15],[970695.256304073,17],[970695.414378264,14],[970695.603334847,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-8a6298c767cb41f8b82822d0","runtime":{"accepted":176,"cached":30,"decode_s":13.4401,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1926,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970681.942049887,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.22020329791121185,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.973602945250427,"done":970695.62284438,"finish_reason":"length","first":970682.163416207,"full_response_s":13.68033501598984,"last":970695.603140899,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970682.163416207,3],[970682.302468101,11],[970682.490120359,30],[970682.66658269,19],[970682.812597223,21],[970683.00006289,15],[970683.149526778,19],[970683.298026794,17],[970683.461360815,6],[970683.608244686,11],[970683.757039722,5],[970683.941223311,27],[970684.133606155,12],[970684.318709786,13],[970684.482750587,5],[970684.631754909,16],[970684.820964029,5],[970685.003250263,16],[970685.190759321,7],[970685.340758118,22],[970685.499351136,10],[970685.680131995,7],[970685.867402537,23],[970686.016325966,5],[970686.16896761,9],[970686.348905622,14],[970686.499781356,20],[970686.653052597,8],[970686.802340879,12],[970686.951618754,5],[970687.108174999,14],[970687.255973965,11],[970687.415131075,7],[970687.564825585,9],[970687.712572831,8],[970687.885778,3],[970688.0709347,10],[970688.221361245,11],[970688.413580877,9],[970688.605447529,10],[970688.78802564,20],[970688.939119641,14],[970689.124369504,14],[970689.362403616,13],[970689.517073258,5],[970689.690498994,14],[970689.925359774,11],[970690.162051159,32],[970690.357501034,33],[970690.514646374,11],[970690.698478666,6],[970690.851095392,8],[970690.998671507,9],[970691.150674929,13],[970691.300852851,8],[970691.460932995,20],[970691.611730688,17],[970691.761799601,20],[970691.911053664,13],[970692.116660474,2],[970692.252756577,16],[970692.448950086,6],[970692.598539625,15],[970692.751403964,8],[970692.936422408,15],[970693.126357876,16],[970693.375052906,27],[970693.65603687,4],[970693.805906793,8],[970693.957558505,25],[970694.111800162,18],[970694.264886051,13],[970694.460956556,55],[970694.611911765,11],[970694.801089983,10],[970694.952125694,11],[970695.104236983,15],[970695.254195606,17],[970695.417352234,14],[970695.603140899,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-bca91a08fe9a4848b8421955","runtime":{"accepted":176,"cached":30,"decode_s":13.4403,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1926,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970681.942509364,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.22090684296563268,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.97094250118668,"done":970695.621017218,"finish_reason":"length","first":970682.162367394,"full_response_s":13.679521924932487,"last":970695.603976844,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970682.162367394,3],[970682.301896127,11],[970682.49257815,30],[970682.663942567,19],[970682.81155518,21],[970682.998225368,15],[970683.151254924,19],[970683.29869763,17],[970683.458838647,6],[970683.608461214,11],[970683.756473638,5],[970683.941120672,27],[970684.132530538,12],[970684.319158893,13],[970684.479657598,5],[970684.629654468,16],[970684.822178385,5],[970685.005219867,16],[970685.192436994,7],[970685.34205079,22],[970685.497605373,10],[970685.68062546,7],[970685.868506685,23],[970686.01770041,5],[970686.168351534,9],[970686.347704355,14],[970686.499257534,20],[970686.651647316,8],[970686.803795207,12],[970686.951377406,5],[970687.107656651,14],[970687.256542913,11],[970687.41247513,7],[970687.564038204,9],[970687.714609356,8],[970687.88584721,3],[970688.073977742,10],[970688.220962162,11],[970688.413860887,9],[970688.600577289,10],[970688.790839336,20],[970688.938971299,14],[970689.124728805,14],[970689.363939747,13],[970689.519202084,5],[970689.692083435,14],[970689.923133734,11],[970690.164059791,32],[970690.357085837,33],[970690.517149238,11],[970690.698431091,6],[970690.849047939,8],[970691.000848435,9],[970691.153309508,13],[970691.301784172,8],[970691.459067361,20],[970691.610638287,17],[970691.761666718,20],[970691.911279313,13],[970692.1144397,2],[970692.252827964,16],[970692.451353159,6],[970692.597849284,15],[970692.752907064,8],[970692.936802608,15],[970693.130081589,16],[970693.375439234,27],[970693.656645983,4],[970693.807399828,8],[970693.958755784,25],[970694.112462755,18],[970694.263294218,13],[970694.459424588,55],[970694.616112891,11],[970694.799898337,10],[970694.950937537,11],[970695.102253766,15],[970695.253472428,17],[970695.415111923,14],[970695.603976844,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-e02c9812e1504f8d866c6c37","runtime":{"accepted":176,"cached":30,"decode_s":13.4401,"drafted":371,"drafts":true,"min_rows":4,"prefill_s":0.1926,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":970681.941495293,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.22087210090830922,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":371,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":1,"burst":null,"stream":0,"phase":"warmup","request":{"cache_state":"cold","cached_tokens":0,"case_id":null,"complete":true,"decode_tps":59.565695785339386,"done":970708.830641778,"finish_reason":"length","first":970708.578775169,"full_response_s":0.4044715859927237,"last":970708.830597964,"output_sha256":"26fc9e1892da6e23aa1a0cb06681c20c4a62f7257e19635806de87234b9035bb","pieces":[[970708.578775169,2],[970708.665818074,7],[970708.746774241,4],[970708.830597964,73]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":16,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"e9df2e35a58091c749bae4e1446600aeb669237cc39db72a41d5cae938d5620a","response_id":"cmpl-6a69db0152233eed4ecea64b72d4fd40","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.126846813,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":0.252629262,"time_to_first_token":0.127826489,"token_sha":"41b4449e1b18","tokens_per_second":59.37554454796293},"seed":1234,"sent":970708.426170192,"speculative":{"acceptance_rate":0.26666666666666666,"accepted":12,"drafted":45,"rounds":3,"tokens_per_round":5.333333333333333},"token_sha":"41b4449e1b18","tokens":16,"ttft_s":0.15260497701819986,"usage":{"completion_tokens":16,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":0},"total_tokens":30},"work":{"accepted":12,"drafted":45,"rounds":3},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":1,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":69.17764390462743,"done":970712.528263758,"finish_reason":"length","first":970708.842049751,"full_response_s":3.696219493052922,"last":970712.528211719,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970708.842049751,2],[970708.930468014,7],[970709.010236231,4],[970709.092896331,73],[970709.17347263,51],[970709.253807472,21],[970709.333732975,14],[970709.420696999,20],[970709.504409024,16],[970709.585122272,15],[970709.664898522,23],[970709.746178954,23],[970709.82665698,25],[970709.907115994,36],[970709.988726019,14],[970710.070032833,6],[970710.150755581,18],[970710.2311651,18],[970710.313835196,19],[970710.399709234,8],[970710.48439544,11],[970710.565754037,18],[970710.645698434,15],[970710.726909827,39],[970710.807542018,30],[970710.888103506,14],[970710.969686162,15],[970711.050989979,8],[970711.131684189,6],[970711.212204583,15],[970711.292752852,23],[970711.377780636,22],[970711.463085388,26],[970711.544762057,35],[970711.625356541,31],[970711.70612273,12],[970711.787071616,13],[970711.867705307,38],[970711.94902288,47],[970712.029988804,25],[970712.111638568,11],[970712.191666439,34],[970712.274285781,12],[970712.358356943,36],[970712.444471547,60],[970712.528211719,48]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-0886418a30df9462ccdfe64f64fec65c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.008203102,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":3.686091494,"time_to_first_token":0.008786385,"token_sha":"2b28aa2108de","tokens_per_second":69.17896650559918},"seed":1234,"sent":970708.832044265,"speculative":{"acceptance_rate":0.31555555555555553,"accepted":213,"drafted":675,"rounds":45,"tokens_per_round":5.688888888888889},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.010005485964938998,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":213,"drafted":675,"rounds":45},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":1,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":69.38225251305545,"done":970716.207698394,"finish_reason":"length","first":970712.532359025,"full_response_s":3.6782805050024763,"last":970716.207650483,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970712.532359025,2],[970712.620947674,7],[970712.701983031,4],[970712.782349462,73],[970712.862926373,51],[970712.943589049,21],[970713.024658742,14],[970713.104876203,20],[970713.185960586,16],[970713.266611037,15],[970713.347345931,23],[970713.433996955,23],[970713.517262814,25],[970713.598458269,36],[970713.679237666,14],[970713.759771011,6],[970713.840526252,18],[970713.921052824,18],[970714.002123584,19],[970714.083664347,8],[970714.16414408,11],[970714.244347262,18],[970714.326887493,15],[970714.413920757,39],[970714.497700699,30],[970714.57901719,14],[970714.659546178,15],[970714.740480567,8],[970714.821035652,6],[970714.901564379,15],[970714.983064011,23],[970715.06458931,22],[970715.145270266,26],[970715.226119262,35],[970715.306789513,31],[970715.392069388,12],[970715.478172899,13],[970715.558548756,38],[970715.64008849,47],[970715.720718511,25],[970715.801559426,11],[970715.882019965,34],[970715.963673885,12],[970716.044359541,36],[970716.125608477,60],[970716.207650483,48]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-3481d62944bf5069a066e8a20540808b","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.002166898,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":3.674569629,"time_to_first_token":0.002466269,"token_sha":"2b28aa2108de","tokens_per_second":69.39588189798322},"seed":1234,"sent":970712.529417889,"speculative":{"acceptance_rate":0.31555555555555553,"accepted":213,"drafted":675,"rounds":45,"tokens_per_round":5.688888888888889},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.0029411360155791044,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":213,"drafted":675,"rounds":45},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":1,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":69.21225989250125,"done":970719.89635154,"finish_reason":"length","first":970716.211954799,"full_response_s":3.687343891011551,"last":970719.896273161,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970716.211954799,2],[970716.300307947,7],[970716.386131588,4],[970716.471093524,73],[970716.55140836,51],[970716.632805941,21],[970716.712451195,14],[970716.793808785,20],[970716.87390047,16],[970716.955474598,15],[970717.035249498,23],[970717.117546735,23],[970717.197967037,25],[970717.278480056,36],[970717.361464797,14],[970717.446480351,6],[970717.530247554,18],[970717.610342419,18],[970717.691583908,19],[970717.772124867,8],[970717.852666311,11],[970717.933102371,18],[970718.014684063,15],[970718.096025913,39],[970718.176506427,30],[970718.256631483,14],[970718.339633917,15],[970718.427047337,8],[970718.511059192,6],[970718.59111147,15],[970718.672069395,23],[970718.753057852,22],[970718.833359903,26],[970718.914752491,35],[970718.99627761,31],[970719.07749307,12],[970719.158619637,13],[970719.239346292,38],[970719.319842644,47],[970719.406425988,25],[970719.491154242,11],[970719.572034215,34],[970719.652222668,12],[970719.733683538,36],[970719.814284574,60],[970719.896273161,48]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-cc9e89cfb7495caebe0e7dba54333d28","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.002186883,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":3.683600214,"time_to_first_token":0.002480268,"token_sha":"2b28aa2108de","tokens_per_second":69.22575338953436},"seed":1234,"sent":970716.209007649,"speculative":{"acceptance_rate":0.31555555555555553,"accepted":213,"drafted":675,"rounds":45,"tokens_per_round":5.688888888888889},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.002947150031104684,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":213,"drafted":675,"rounds":45},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.48201866972554,"done":970730.159828817,"finish_reason":"length","first":970720.152735774,"full_response_s":10.259688236983493,"last":970730.159792252,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970720.152735774,2],[970720.302191373,7],[970720.457751198,4],[970720.669938605,63],[970720.904027966,10],[970721.087588364,31],[970721.270312101,29],[970721.461815682,22],[970721.641505878,14],[970721.826432461,24],[970722.006900622,4],[970722.155044266,13],[970722.337616799,21],[970722.531277063,2],[970722.708121137,18],[970722.890631354,29],[970723.126551949,27],[970723.364470405,24],[970723.518208466,4],[970723.668748948,16],[970723.901740171,10],[970724.086276946,31],[970724.234526977,8],[970724.426602203,11],[970724.610040907,16],[970724.793802904,12],[970724.974831856,39],[970725.14949111,18],[970725.329757265,11],[970725.524888464,16],[970725.704219402,16],[970725.8509522,11],[970726.033988979,6],[970726.218461172,9],[970726.411791337,29],[970726.598321061,22],[970726.779214905,8],[970726.929302268,18],[970727.113469284,18],[970727.295977,34],[970727.485054803,10],[970727.668870379,14],[970727.854368927,13],[970728.035081295,2],[970728.21924532,36],[970728.411461042,42],[970728.596646135,26],[970728.747215902,17],[970728.927983752,34],[970729.171143844,12],[970729.349248176,36],[970729.643505667,50],[970729.826767983,2],[970730.159792252,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-c4ca783b0256838b2e6d36346a6ddd45","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.158522173,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.004703661,"time_to_first_token":0.247822979,"token_sha":"2b28aa2108de","tokens_per_second":25.488011303526402},"seed":1234,"sent":970719.90014058,"speculative":{"acceptance_rate":0.5607734806629834,"accepted":203,"drafted":362,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.25259519403334707,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":362,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":1,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.485602971195238,"done":970730.159279798,"finish_reason":"length","first":970720.153595798,"full_response_s":10.258658559061587,"last":970730.159244881,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970720.153595798,2],[970720.303535256,7],[970720.458213758,4],[970720.669371022,63],[970720.903437852,10],[970721.088098067,31],[970721.271033497,29],[970721.46195655,22],[970721.642340458,14],[970721.826233089,24],[970722.00702952,4],[970722.156248049,13],[970722.338695221,21],[970722.530945897,2],[970722.707885377,18],[970722.893058138,29],[970723.127459131,27],[970723.364904657,24],[970723.519082299,4],[970723.665785514,16],[970723.903519825,10],[970724.087059951,31],[970724.233518822,8],[970724.42607133,11],[970724.609243053,16],[970724.79341765,12],[970724.976937411,39],[970725.148885618,18],[970725.329364811,11],[970725.524471446,16],[970725.704982435,16],[970725.852821641,11],[970726.035036099,6],[970726.219727074,9],[970726.410548382,29],[970726.598158015,22],[970726.779388961,8],[970726.9289816,18],[970727.114354317,18],[970727.294532913,34],[970727.485324984,10],[970727.669314776,14],[970727.852021405,13],[970728.034690601,2],[970728.219524222,36],[970728.410657684,42],[970728.596904187,26],[970728.744819973,17],[970728.929552207,34],[970729.168813812,12],[970729.34921438,36],[970729.642640205,50],[970729.827033059,2],[970730.159244881,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-fcc11fa4da8282d5c765d018b36cbaac","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.158180605,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.005176672,"time_to_first_token":0.249658562,"token_sha":"2b28aa2108de","tokens_per_second":25.48680631633728},"seed":1234,"sent":970719.900621239,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.25297455897089094,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":2,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.49227044762741,"done":970730.15753964,"finish_reason":"length","first":970720.154458158,"full_response_s":10.253811664995737,"last":970730.157490274,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970720.154458158,2],[970720.303316378,7],[970720.459321096,4],[970720.669545078,63],[970720.903515751,10],[970721.0871877,31],[970721.271664353,29],[970721.46162716,22],[970721.641621318,14],[970721.824533637,24],[970722.007570539,4],[970722.15603834,13],[970722.337701515,21],[970722.528921104,2],[970722.708750313,18],[970722.890250725,29],[970723.12551987,27],[970723.364742123,24],[970723.520956543,4],[970723.66708483,16],[970723.902175799,10],[970724.087751422,31],[970724.235596437,8],[970724.426417554,11],[970724.609141711,16],[970724.792868726,12],[970724.973931268,39],[970725.148978975,18],[970725.330184348,11],[970725.521562165,16],[970725.703996299,16],[970725.852910037,11],[970726.033396097,6],[970726.218208577,9],[970726.410646507,29],[970726.596478295,22],[970726.77994979,8],[970726.928142796,18],[970727.113378071,18],[970727.296216009,34],[970727.486812933,10],[970727.669263505,14],[970727.85237939,13],[970728.035145207,2],[970728.221489884,36],[970728.410070883,42],[970728.597154605,26],[970728.744024856,17],[970728.927895404,34],[970729.168378713,12],[970729.348954184,36],[970729.643870181,50],[970729.827289542,2],[970730.157490274,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-292487a7867268761151e0cefcd49434","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.158913828,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.004736593,"time_to_first_token":0.245603517,"token_sha":"2b28aa2108de","tokens_per_second":25.48792740614635},"seed":1234,"sent":970719.903727975,"speculative":{"acceptance_rate":0.5623268698060941,"accepted":203,"drafted":361,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2507301829755306,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":361,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":3,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.485161965266883,"done":970730.161176073,"finish_reason":"length","first":970720.154360369,"full_response_s":10.255463453009725,"last":970730.160182594,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970720.154360369,2],[970720.302352659,7],[970720.458998684,4],[970720.669474444,63],[970720.904891863,10],[970721.089344688,31],[970721.271282972,29],[970721.459581932,22],[970721.643105652,14],[970721.82689038,24],[970722.008199746,4],[970722.156535193,13],[970722.337783062,21],[970722.530496443,2],[970722.708615046,18],[970722.890505288,29],[970723.12618617,27],[970723.365315082,24],[970723.518442402,4],[970723.668346909,16],[970723.902347151,10],[970724.086571211,31],[970724.234061777,8],[970724.426747183,11],[970724.609418549,16],[970724.791770447,12],[970724.975997633,39],[970725.148664116,18],[970725.329858591,11],[970725.521647393,16],[970725.704902408,16],[970725.85134379,11],[970726.035292262,6],[970726.219111309,9],[970726.410022357,29],[970726.596767919,22],[970726.778509768,8],[970726.927627045,18],[970727.112943916,18],[970727.294786836,34],[970727.485561161,10],[970727.668992684,14],[970727.852877714,13],[970728.035917713,2],[970728.220785979,36],[970728.410732142,42],[970728.595988717,26],[970728.746281262,17],[970728.928530755,34],[970729.1679925,12],[970729.350135562,36],[970729.646203845,50],[970729.82734499,2],[970730.160182594,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-89bae0eb12a7d7c67ba2c6f7bd9d4e85","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.159034037,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.00742312,"time_to_first_token":0.244988279,"token_sha":"2b28aa2108de","tokens_per_second":25.481085084768555},"seed":1234,"sent":970719.90571262,"speculative":{"acceptance_rate":0.5638888888888889,"accepted":203,"drafted":360,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.24864774895831943,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":360,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":4,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.48477284827869,"done":970730.159399479,"finish_reason":"length","first":970720.153378024,"full_response_s":10.255558912060224,"last":970730.159353024,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970720.153378024,2],[970720.302824933,7],[970720.457861837,4],[970720.669254014,63],[970720.903335886,10],[970721.087650692,31],[970721.271778401,29],[970721.463526192,22],[970721.64318944,14],[970721.825149531,24],[970722.007629955,4],[970722.156857238,13],[970722.338459172,21],[970722.531427596,2],[970722.70793556,18],[970722.892228327,29],[970723.125710969,27],[970723.364125973,24],[970723.520688842,4],[970723.667284537,16],[970723.90243249,10],[970724.087496731,31],[970724.236100939,8],[970724.425789707,11],[970724.608956181,16],[970724.793307923,12],[970724.977294228,39],[970725.150364718,18],[970725.32958953,11],[970725.521348919,16],[970725.704087448,16],[970725.852215126,11],[970726.034542047,6],[970726.219694638,9],[970726.410165193,29],[970726.597184008,22],[970726.779013293,8],[970726.929812914,18],[970727.112554758,18],[970727.294717707,34],[970727.486583445,10],[970727.668471636,14],[970727.852545781,13],[970728.034897221,2],[970728.219715112,36],[970728.410979088,42],[970728.596250097,26],[970728.744712855,17],[970728.928906886,34],[970729.170756527,12],[970729.350767536,36],[970729.643646119,50],[970729.826841321,2],[970730.159353024,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-00bf5ebf1ba228ed323b9ea8549d6c88","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.15869423,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.004635204,"time_to_first_token":0.247298473,"token_sha":"2b28aa2108de","tokens_per_second":25.4881857059663},"seed":1234,"sent":970719.903840567,"speculative":{"acceptance_rate":0.5623268698060941,"accepted":203,"drafted":361,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.24953745701350272,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":361,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":5,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.487907967860085,"done":970730.158314466,"finish_reason":"length","first":970720.153554961,"full_response_s":10.25846405501943,"last":970730.158299184,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970720.153554961,2],[970720.303843059,7],[970720.458465217,4],[970720.670106612,63],[970720.904584876,10],[970721.087530372,31],[970721.270482412,29],[970721.462374816,22],[970721.642986771,14],[970721.828078385,24],[970722.007396083,4],[970722.156075993,13],[970722.338508379,21],[970722.53158413,2],[970722.709122348,18],[970722.890167993,29],[970723.128608538,27],[970723.365171302,24],[970723.518024377,4],[970723.668797739,16],[970723.903329654,10],[970724.086428103,31],[970724.235505961,8],[970724.42648862,11],[970724.608757114,16],[970724.792355023,12],[970724.975589721,39],[970725.148782468,18],[970725.329433605,11],[970725.522783069,16],[970725.706169191,16],[970725.853246724,11],[970726.034579588,6],[970726.219034227,9],[970726.410236915,29],[970726.598254044,22],[970726.778626344,8],[970726.930159585,18],[970727.112773844,18],[970727.294417025,34],[970727.484602517,10],[970727.668383032,14],[970727.852292706,13],[970728.03558434,2],[970728.220577679,36],[970728.409803774,42],[970728.595922148,26],[970728.744389738,17],[970728.929044617,34],[970729.167669112,12],[970729.349015408,36],[970729.64498379,50],[970729.827499843,2],[970730.158299184,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-98e100b694cf517a1797157b9d531127","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.158991919,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.004546695,"time_to_first_token":0.245278624,"token_sha":"2b28aa2108de","tokens_per_second":25.488411196825346},"seed":1234,"sent":970719.899850411,"speculative":{"acceptance_rate":0.5638888888888889,"accepted":203,"drafted":360,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.25370454997755587,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":360,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":6,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.486873179455845,"done":970730.158464919,"finish_reason":"length","first":970720.153264568,"full_response_s":10.258685590000823,"last":970730.158414992,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970720.153264568,2],[970720.302689602,7],[970720.458894749,4],[970720.67015766,63],[970720.903594258,10],[970721.087437863,31],[970721.270835277,29],[970721.461434813,22],[970721.64258598,14],[970721.824720751,24],[970722.009116786,4],[970722.155491576,13],[970722.338087617,21],[970722.529747699,2],[970722.708451311,18],[970722.891069846,29],[970723.126023028,27],[970723.363777013,24],[970723.517723215,4],[970723.666281551,16],[970723.902039844,10],[970724.086867924,31],[970724.23331649,8],[970724.425184679,11],[970724.608519545,16],[970724.791497977,12],[970724.973823365,39],[970725.149383591,18],[970725.330724903,11],[970725.525239056,16],[970725.706092525,16],[970725.85333248,11],[970726.03354455,6],[970726.218911282,9],[970726.411565098,29],[970726.597328156,22],[970726.779283538,8],[970726.929215264,18],[970727.111446894,18],[970727.294839579,34],[970727.485484494,10],[970727.668131701,14],[970727.853519018,13],[970728.034059714,2],[970728.222374213,36],[970728.411247701,42],[970728.595321537,26],[970728.746009945,17],[970728.927816673,34],[970729.167758484,12],[970729.350549507,36],[970729.644025083,50],[970729.826912931,2],[970730.158414992,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-7836629068435386d982546963db90e7","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.158818614,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.004793818,"time_to_first_token":0.245756642,"token_sha":"2b28aa2108de","tokens_per_second":25.48778162136834},"seed":1234,"sent":970719.899779329,"speculative":{"acceptance_rate":0.5623268698060941,"accepted":203,"drafted":361,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.25348523899447173,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":361,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":7,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.485707722272355,"done":970730.159097565,"finish_reason":"length","first":970720.153441729,"full_response_s":10.258845977950841,"last":970730.159049687,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970720.153441729,2],[970720.302264023,7],[970720.459623138,4],[970720.670200561,63],[970720.905509388,10],[970721.088425312,31],[970721.270530835,29],[970721.461231825,22],[970721.64173935,14],[970721.825781667,24],[970722.007686811,4],[970722.155900017,13],[970722.337936412,21],[970722.529585436,2],[970722.708031541,18],[970722.891677723,29],[970723.128510028,27],[970723.36427185,24],[970723.519857014,4],[970723.667770781,16],[970723.902624773,10],[970724.089879556,31],[970724.237069761,8],[970724.425468254,11],[970724.609653878,16],[970724.791378968,12],[970724.974719329,39],[970725.149328608,18],[970725.329800039,11],[970725.52267291,16],[970725.705210387,16],[970725.853289786,11],[970726.034984332,6],[970726.218830839,9],[970726.411354445,29],[970726.597764328,22],[970726.779139967,8],[970726.928429108,18],[970727.111774507,18],[970727.295218896,34],[970727.486374841,10],[970727.670513213,14],[970727.852749297,13],[970728.034414579,2],[970728.221201428,36],[970728.410782101,42],[970728.595505659,26],[970728.744565378,17],[970728.92830962,34],[970729.166064156,12],[970729.349427289,36],[970729.644465831,50],[970729.827223277,2],[970730.159049687,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-bd92fa04157cfd2a6755e6defc16ac63","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.158300286,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.004926813,"time_to_first_token":0.249492699,"token_sha":"2b28aa2108de","tokens_per_second":25.487442813540948},"seed":1234,"sent":970719.900251587,"speculative":{"acceptance_rate":0.5576923076923077,"accepted":203,"drafted":364,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2531901419861242,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":364,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":8,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":24.873138043950064,"done":970730.159643192,"finish_reason":"length","first":970719.905849295,"full_response_s":10.258671168936417,"last":970730.157872966,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970719.905849295,2],[970719.995030323,7],[970720.302082638,4],[970720.457256745,72],[970720.669160465,1],[970720.904942654,27],[970721.087314102,30],[970721.269841027,15],[970721.461551694,14],[970721.641241905,20],[970721.827716719,14],[970722.008805062,4],[970722.155350565,13],[970722.338609705,21],[970722.530032474,2],[970722.709069941,18],[970722.889995522,29],[970723.125617868,27],[970723.364371063,24],[970723.518620219,4],[970723.667362948,16],[970723.902961796,10],[970724.089463355,31],[970724.233440395,8],[970724.42556574,11],[970724.609482638,16],[970724.793533602,12],[970724.97656856,39],[970725.1485473,18],[970725.329501998,11],[970725.521954539,16],[970725.703759163,16],[970725.852673973,11],[970726.033709068,6],[970726.219304536,9],[970726.409759681,29],[970726.597080954,22],[970726.778703699,8],[970726.92969485,18],[970727.114260609,18],[970727.295691409,34],[970727.487060071,10],[970727.669672921,14],[970727.85156307,13],[970728.03453618,2],[970728.220136418,36],[970728.409861142,42],[970728.596076585,26],[970728.745559979,17],[970728.928603085,34],[970729.166731319,12],[970729.349545417,36],[970729.644240248,50],[970729.826982108,2],[970730.157872966,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-5ebc898a8593cdcc504a6c2455943305","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.002222694,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.252126008,"time_to_first_token":0.002680566,"token_sha":"2b28aa2108de","tokens_per_second":24.87288975974514},"seed":1234,"sent":970719.900972023,"speculative":{"acceptance_rate":0.5474254742547425,"accepted":202,"drafted":369,"rounds":54,"tokens_per_round":4.7407407407407405},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.004877271945588291,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":202,"drafted":369,"rounds":54},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":9,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.489023850182736,"done":970730.158628989,"finish_reason":"length","first":970720.15429588,"full_response_s":10.25816297205165,"last":970730.158602106,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970720.15429588,2],[970720.302122259,7],[970720.459761318,4],[970720.670454517,63],[970720.905222212,10],[970721.088527742,31],[970721.27010596,29],[970721.463058575,22],[970721.641684446,14],[970721.824199079,24],[970722.009669326,4],[970722.155991934,13],[970722.338414238,21],[970722.529468636,2],[970722.709171171,18],[970722.892078962,29],[970723.124939374,27],[970723.364039481,24],[970723.519626102,4],[970723.666166239,16],[970723.903752737,10],[970724.087683061,31],[970724.234203541,8],[970724.426699449,11],[970724.609887974,16],[970724.791182429,12],[970724.975044814,39],[970725.151071664,18],[970725.329646754,11],[970725.524042171,16],[970725.70659613,16],[970725.850624411,11],[970726.035197513,6],[970726.219415351,9],[970726.41108796,29],[970726.598506479,22],[970726.779848384,8],[970726.926592247,18],[970727.113140023,18],[970727.296539797,34],[970727.485886453,10],[970727.670108821,14],[970727.852970191,13],[970728.034243404,2],[970728.218794186,36],[970728.410205926,42],[970728.595686755,26],[970728.744978459,17],[970728.927154326,34],[970729.169615058,12],[970729.349687388,36],[970729.642963561,50],[970729.827559115,2],[970730.158602106,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-838264dfef6f2d0c2c77365bad588743","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.158761566,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.004802123,"time_to_first_token":0.246188958,"token_sha":"2b28aa2108de","tokens_per_second":25.48776046392577},"seed":1234,"sent":970719.900466017,"speculative":{"acceptance_rate":0.5623268698060941,"accepted":203,"drafted":361,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.25382986303884536,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":361,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":10,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.488039031512923,"done":970730.15804883,"finish_reason":"length","first":970720.153325841,"full_response_s":10.256690385052934,"last":970730.158018618,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970720.153325841,2],[970720.303409335,7],[970720.457604313,4],[970720.6696176,63],[970720.903089244,10],[970721.089492996,31],[970721.272160134,29],[970721.462132318,22],[970721.642220121,14],[970721.826154246,24],[970722.010078471,4],[970722.155584501,13],[970722.339237568,21],[970722.529158785,2],[970722.708680191,18],[970722.891150242,29],[970723.127821293,27],[970723.363899318,24],[970723.521548625,4],[970723.668686236,16],[970723.902265251,10],[970724.087575302,31],[970724.233725043,8],[970724.426653074,11],[970724.609202935,16],[970724.792547578,12],[970724.974996551,39],[970725.149653228,18],[970725.33098153,11],[970725.522606421,16],[970725.703887788,16],[970725.852275358,11],[970726.034057084,6],[970726.219372113,9],[970726.412063774,29],[970726.596176206,22],[970726.778781037,8],[970726.926803124,18],[970727.113988763,18],[970727.295131011,34],[970727.485832782,10],[970727.670331892,14],[970727.853639643,13],[970728.036558089,2],[970728.220961043,36],[970728.409750151,42],[970728.595639773,26],[970728.74415153,17],[970728.927615861,34],[970729.167550631,12],[970729.349484769,36],[970729.645883513,50],[970729.826573716,2],[970730.158018618,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-2da2c5c8bd6ec83d27e90e78e8b32e95","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.158953641,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.004633171,"time_to_first_token":0.245577769,"token_sha":"2b28aa2108de","tokens_per_second":25.48819088531477},"seed":1234,"sent":970719.901358445,"speculative":{"acceptance_rate":0.5638888888888889,"accepted":203,"drafted":360,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2519673960050568,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":360,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":11,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.48820333053989,"done":970730.158874703,"finish_reason":"length","first":970720.154202059,"full_response_s":10.257154223043472,"last":970730.158830345,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970720.154202059,2],[970720.302398538,7],[970720.458818818,4],[970720.670518654,63],[970720.905924422,10],[970721.087793016,31],[970721.271940807,29],[970721.462646774,22],[970721.641399623,14],[970721.824084583,24],[970722.007905321,4],[970722.154879011,13],[970722.337996036,21],[970722.528824771,2],[970722.70939581,18],[970722.890326319,29],[970723.124767462,27],[970723.364559697,24],[970723.522345647,4],[970723.666674037,16],[970723.903937579,10],[970724.090245143,31],[970724.233600369,8],[970724.425689357,11],[970724.60839772,16],[970724.794073965,12],[970724.976493894,39],[970725.149772093,18],[970725.331177573,11],[970725.521208116,16],[970725.705140249,16],[970725.851573933,11],[970726.035724402,6],[970726.218964329,9],[970726.411876821,29],[970726.597797533,22],[970726.779680281,8],[970726.929890684,18],[970727.113659214,18],[970727.295326958,34],[970727.483913046,10],[970727.668801121,14],[970727.854437656,13],[970728.037010887,2],[970728.219900594,36],[970728.41026971,42],[970728.597437284,26],[970728.745424664,17],[970728.927421243,34],[970729.169015088,12],[970729.349624628,36],[970729.642405325,50],[970729.827391716,2],[970730.158830345,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-72d513d07e8cfaa1a80ce0021eb3d52a","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.158570676,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.004692396,"time_to_first_token":0.247928417,"token_sha":"2b28aa2108de","tokens_per_second":25.488040002304537},"seed":1234,"sent":970719.90172048,"speculative":{"acceptance_rate":0.5607734806629834,"accepted":203,"drafted":362,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2524815790820867,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":362,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":12,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.491219118595268,"done":970730.157183224,"finish_reason":"length","first":970720.153663136,"full_response_s":10.256366277928464,"last":970730.157107805,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970720.153663136,2],[970720.302006483,7],[970720.457665506,4],[970720.669878245,63],[970720.90572217,10],[970721.089019923,31],[970721.271870525,29],[970721.461887148,22],[970721.642312406,14],[970721.825548946,24],[970722.00732132,4],[970722.157800681,13],[970722.338994206,21],[970722.527834281,2],[970722.708306571,18],[970722.892559189,29],[970723.126870601,27],[970723.364805203,24],[970723.520180563,4],[970723.667840582,16],[970723.90286415,10],[970724.088791022,31],[970724.235252294,8],[970724.426362346,11],[970724.609838607,16],[970724.792019393,12],[970724.974455676,39],[970725.149271912,18],[970725.330301708,11],[970725.52364658,16],[970725.706794573,16],[970725.852989408,11],[970726.034210369,6],[970726.220831994,9],[970726.410770844,29],[970726.597852485,22],[970726.779338058,8],[970726.926470982,18],[970727.111113328,18],[970727.294177264,34],[970727.485405507,10],[970727.670162237,14],[970727.85191099,13],[970728.034829804,2],[970728.219041948,36],[970728.410130907,42],[970728.596184376,26],[970728.747087853,17],[970728.930074662,34],[970729.166626377,12],[970729.349916444,36],[970729.645266389,50],[970729.827442763,2],[970730.157107805,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-9a5c736c2024117bfd78457206d4fb3c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.158384698,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.004840337,"time_to_first_token":0.248681658,"token_sha":"2b28aa2108de","tokens_per_second":25.48766311211949},"seed":1234,"sent":970719.900816946,"speculative":{"acceptance_rate":0.5576923076923077,"accepted":203,"drafted":364,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.25284618989098817,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":364,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":13,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.48824245720978,"done":970730.157629669,"finish_reason":"length","first":970720.152972751,"full_response_s":10.257703774957918,"last":970730.157585679,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970720.152972751,2],[970720.303614643,7],[970720.458300298,4],[970720.6700202,63],[970720.903229663,10],[970721.08832589,31],[970721.270169249,29],[970721.459936141,22],[970721.64227288,14],[970721.825595113,24],[970722.00816547,4],[970722.155424143,13],[970722.338561666,21],[970722.530720218,2],[970722.708823187,18],[970722.890705876,29],[970723.128200977,27],[970723.36502557,24],[970723.520309669,4],[970723.666853934,16],[970723.901921332,10],[970724.088431436,31],[970724.236572428,8],[970724.425339437,11],[970724.608873242,16],[970724.794372406,12],[970724.975157101,39],[970725.149454097,18],[970725.330114835,11],[970725.522113009,16],[970725.70595673,16],[970725.853642554,11],[970726.033624289,6],[970726.220392814,9],[970726.410089886,29],[970726.598028781,22],[970726.779075462,8],[970726.928770611,18],[970727.112189204,18],[970727.295065675,34],[970727.486962345,10],[970727.668733144,14],[970727.853911504,13],[970728.036356253,2],[970728.220649064,36],[970728.409987112,42],[970728.597498156,26],[970728.746898451,17],[970728.928108313,34],[970729.1670838,12],[970729.34932105,36],[970729.644717401,50],[970729.827105101,2],[970730.157585679,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-fc0aec2cc33a941be1d2afe333e64372","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.158250759,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.0049773,"time_to_first_token":0.249713673,"token_sha":"2b28aa2108de","tokens_per_second":25.48731419910368},"seed":1234,"sent":970719.899925894,"speculative":{"acceptance_rate":0.5576923076923077,"accepted":203,"drafted":364,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.25304685696028173,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":364,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":14,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.487968661720284,"done":970730.157377298,"finish_reason":"length","first":970720.152610109,"full_response_s":10.25787811994087,"last":970730.157330508,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970720.152610109,2],[970720.30325032,7],[970720.459484127,4],[970720.670591096,63],[970720.903950292,10],[970721.086979687,31],[970721.26963359,29],[970721.461096862,22],[970721.642158832,14],[970721.824619793,24],[970722.008484522,4],[970722.157185843,13],[970722.337526019,21],[970722.531914399,2],[970722.70820891,18],[970722.8916297,29],[970723.125044828,27],[970723.365602066,24],[970723.519340751,4],[970723.66765158,16],[970723.90428137,10],[970724.087411567,31],[970724.233637703,8],[970724.426550212,11],[970724.608653867,16],[970724.79430038,12],[970724.975098053,39],[970725.149034279,18],[970725.330051274,11],[970725.521787028,16],[970725.706299817,16],[970725.852155373,11],[970726.035803501,6],[970726.218582741,9],[970726.41114496,29],[970726.59580393,22],[970726.778938211,8],[970726.930031392,18],[970727.113905984,18],[970727.294089412,34],[970727.48426023,10],[970727.669902537,14],[970727.854738562,13],[970728.0358518,2],[970728.220382676,36],[970728.411729255,42],[970728.594994869,26],[970728.746601514,17],[970728.926964748,34],[970729.170208996,12],[970729.349098172,36],[970729.643298279,50],[970729.826686036,2],[970730.157330508,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-b5ba53fdf28341ae21cf276127ce072d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.158616187,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.004684283,"time_to_first_token":0.247417066,"token_sha":"2b28aa2108de","tokens_per_second":25.488060671069555},"seed":1234,"sent":970719.899499178,"speculative":{"acceptance_rate":0.5623268698060941,"accepted":203,"drafted":361,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2531109309056774,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":361,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":15,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.483913842799716,"done":970730.159475185,"finish_reason":"length","first":970720.153126821,"full_response_s":10.2600725479424,"last":970730.1594391,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970720.153126821,2],[970720.302772974,7],[970720.457951498,4],[970720.669325912,63],[970720.906241906,10],[970721.089577984,31],[970721.270742257,29],[970721.46070372,22],[970721.643471751,14],[970721.8248669,24],[970722.007137903,4],[970722.157413811,13],[970722.339125489,21],[970722.528613301,2],[970722.708364723,18],[970722.890957495,29],[970723.126238082,27],[970723.365407975,24],[970723.520409811,4],[970723.668110892,16],[970723.902762872,10],[970724.088086685,31],[970724.234564135,8],[970724.425882008,11],[970724.609943054,16],[970724.792952882,12],[970724.97416322,39],[970725.149683905,18],[970725.330243828,11],[970725.525624085,16],[970725.706010497,16],[970725.853371813,11],[970726.034484695,6],[970726.219656168,9],[970726.410829268,29],[970726.597957763,22],[970726.779607999,8],[970726.92726978,18],[970727.113420589,18],[970727.29562828,34],[970727.485934604,10],[970727.669469517,14],[970727.853590996,13],[970728.036882262,2],[970728.220836722,36],[970728.410416515,42],[970728.595202289,26],[970728.745646823,17],[970728.9292393,34],[970729.168905921,12],[970729.349871526,36],[970729.643794331,50],[970729.827161333,2],[970730.1594391,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-f207ac4bd278484d3276e005c9c4c4df","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.158441426,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.004951824,"time_to_first_token":0.248098105,"token_sha":"2b28aa2108de","tokens_per_second":25.48737909844832},"seed":1234,"sent":970719.899402637,"speculative":{"acceptance_rate":0.5576923076923077,"accepted":203,"drafted":364,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2537241840036586,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":364,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.327318449394724,"done":970740.364267388,"finish_reason":"length","first":970730.295622664,"full_response_s":10.198502814979292,"last":970740.363802622,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970730.295622664,2],[970730.487655272,7],[970730.6348084,4],[970730.84605233,63],[970731.08403268,10],[970731.270033697,31],[970731.457617618,29],[970731.639664415,22],[970731.823572582,14],[970732.006692408,24],[970732.190135877,4],[970732.33724891,13],[970732.526394356,21],[970732.708429842,2],[970732.890445609,18],[970733.07643093,29],[970733.311766962,27],[970733.557445088,24],[970733.707171175,4],[970733.853275718,16],[970734.091833488,10],[970734.274816404,31],[970734.430142765,8],[970734.616276428,11],[970734.798855752,16],[970734.984221812,12],[970735.163923021,39],[970735.34011457,18],[970735.532581685,11],[970735.711469776,16],[970735.896024437,16],[970736.041951178,11],[970736.225881906,6],[970736.418601199,9],[970736.602923436,29],[970736.787371466,22],[970736.972408816,8],[970737.120719586,18],[970737.306158344,18],[970737.497021162,34],[970737.680753354,10],[970737.862726239,14],[970738.052185109,13],[970738.233661559,2],[970738.42513342,36],[970738.614572703,42],[970738.795780141,26],[970738.945272985,17],[970739.130073885,34],[970739.372009653,12],[970739.562160473,36],[970739.848336997,50],[970740.034576396,2],[970740.363802622,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-0105acbae9e256249211b31f4bce1104","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.035880906,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.069434449,"time_to_first_token":0.125727991,"token_sha":"2b28aa2108de","tokens_per_second":25.324163069091153},"seed":1234,"sent":970730.165764573,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12985809100791812,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.324582182765806,"done":970740.363766377,"finish_reason":"length","first":970730.294448391,"full_response_s":10.197940643993206,"last":970740.363716194,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970730.294448391,2],[970730.489437916,7],[970730.633822953,4],[970730.847325016,63],[970731.086510491,10],[970731.268963583,31],[970731.458152651,29],[970731.640444873,22],[970731.823349928,14],[970732.007122834,24],[970732.188695201,4],[970732.337821212,13],[970732.527739947,21],[970732.709993575,2],[970732.890677032,18],[970733.077556699,29],[970733.313389502,27],[970733.556587739,24],[970733.705794123,4],[970733.853334222,16],[970734.094659312,10],[970734.275865954,31],[970734.430714811,8],[970734.614567892,11],[970734.799880036,16],[970734.983011568,12],[970735.166501242,39],[970735.339321999,18],[970735.530452596,11],[970735.712227334,16],[970735.894684208,16],[970736.043767392,11],[970736.227021116,6],[970736.419575411,9],[970736.606197975,29],[970736.78761926,22],[970736.973137618,8],[970737.120142884,18],[970737.306560991,18],[970737.494818641,34],[970737.677843025,10],[970737.862040963,14],[970738.051310255,13],[970738.234968119,2],[970738.425475562,36],[970738.610220181,42],[970738.796122651,26],[970738.943661104,17],[970739.128843928,34],[970739.373161888,12],[970739.563070867,36],[970739.847612147,50],[970740.035074239,2],[970740.363716194,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-d6d58cb8889efcec67019c5a88007d6e","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.035708387,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.069290078,"time_to_first_token":0.12607175,"token_sha":"2b28aa2108de","tokens_per_second":25.324526160701197},"seed":1234,"sent":970730.165825733,"speculative":{"acceptance_rate":0.553133514986376,"accepted":203,"drafted":367,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12862265796866268,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":367,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.319607795829008,"done":970740.366772573,"finish_reason":"length","first":970730.295108914,"full_response_s":10.20080573298037,"last":970740.366354964,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970730.295108914,2],[970730.489049735,7],[970730.634176138,4],[970730.846628568,63],[970731.086212626,10],[970731.270400403,31],[970731.457346141,29],[970731.641527293,22],[970731.823171072,14],[970732.005631815,24],[970732.190623272,4],[970732.337502736,13],[970732.528293431,21],[970732.711098045,2],[970732.890362926,18],[970733.078678932,29],[970733.313839404,27],[970733.559860744,24],[970733.707417256,4],[970733.855209821,16],[970734.0937754,10],[970734.276897902,31],[970734.430915078,8],[970734.616980604,11],[970734.798669599,16],[970734.986060477,12],[970735.168224723,39],[970735.338922537,18],[970735.530753485,11],[970735.710994655,16],[970735.894763611,16],[970736.043836889,11],[970736.226775291,6],[970736.418999301,9],[970736.603845561,29],[970736.789804691,22],[970736.971450366,8],[970737.121462951,18],[970737.306480276,18],[970737.498267955,34],[970737.679239486,10],[970737.864839756,14],[970738.051843879,13],[970738.234502857,2],[970738.425644609,36],[970738.613452264,42],[970738.796899924,26],[970738.945022231,17],[970739.130984215,34],[970739.371776822,12],[970739.561018047,36],[970739.84906327,50],[970740.03442124,2],[970740.366354964,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-a4c06f97b68b412d07ad52312e3b799c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.036176002,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.071679534,"time_to_first_token":0.125063692,"token_sha":"2b28aa2108de","tokens_per_second":25.3185180425142},"seed":1234,"sent":970730.16596684,"speculative":{"acceptance_rate":0.5561643835616439,"accepted":203,"drafted":365,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.129142074030824,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":365,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.32559039096295,"done":970740.364218998,"finish_reason":"length","first":970730.295318846,"full_response_s":10.197540652006865,"last":970740.364185793,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970730.295318846,2],[970730.488092356,7],[970730.632707729,4],[970730.847211464,63],[970731.084914449,10],[970731.270296133,31],[970731.459257682,29],[970731.640339675,22],[970731.823284319,14],[970732.007239618,24],[970732.189841949,4],[970732.33739541,13],[970732.527556034,21],[970732.709611347,2],[970732.890415365,18],[970733.076967963,29],[970733.312684655,27],[970733.558951789,24],[970733.706996879,4],[970733.854119641,16],[970734.092348246,10],[970734.276238341,31],[970734.429333919,8],[970734.616203186,11],[970734.801969967,16],[970734.983757717,12],[970735.167652854,39],[970735.339423021,18],[970735.531424376,11],[970735.71228459,16],[970735.895387999,16],[970736.04456934,11],[970736.227507678,6],[970736.417804307,9],[970736.604092314,29],[970736.791064702,22],[970736.971840755,8],[970737.121938391,18],[970737.3049995,18],[970737.497957961,34],[970737.679767397,10],[970737.865186811,14],[970738.053698641,13],[970738.232613706,2],[970738.425716123,36],[970738.61055653,42],[970738.79715583,26],[970738.944654422,17],[970739.130199598,34],[970739.373649569,12],[970739.56276329,36],[970739.849656278,50],[970740.034164325,2],[970740.364185793,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-b3dbaf20ea29f3fe74f3ae202a3c48aa","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.036002266,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.069425968,"time_to_first_token":0.125485637,"token_sha":"2b28aa2108de","tokens_per_second":25.324184398432834},"seed":1234,"sent":970730.166678346,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12864050001371652,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.32258086970417,"done":970740.364638846,"finish_reason":"length","first":970730.294553398,"full_response_s":10.198496349039488,"last":970740.364617003,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970730.294553398,2],[970730.485967921,7],[970730.634997194,4],[970730.846241124,63],[970731.08498553,10],[970731.268184261,31],[970731.457286469,29],[970731.641097074,22],[970731.821460439,14],[970732.006645938,24],[970732.190715284,4],[970732.337713245,13],[970732.527468134,21],[970732.710602106,2],[970732.890316615,18],[970733.07777156,29],[970733.311993313,27],[970733.559014453,24],[970733.708168974,4],[970733.855287719,16],[970734.092494442,10],[970734.27520036,31],[970734.430514112,8],[970734.615173158,11],[970734.798993659,16],[970734.984859514,12],[970735.164661937,39],[970735.338091128,18],[970735.53036452,11],[970735.711950337,16],[970735.89694493,16],[970736.043497035,11],[970736.228162535,6],[970736.418306775,9],[970736.603908161,29],[970736.791354101,22],[970736.970786757,8],[970737.122791962,18],[970737.304906527,18],[970737.495270766,34],[970737.679837022,10],[970737.862557529,14],[970738.053111666,13],[970738.233738658,2],[970738.425407153,36],[970738.614169545,42],[970738.795214289,26],[970738.945127813,17],[970739.130726773,34],[970739.372992745,12],[970739.56310564,36],[970739.848458341,50],[970740.03452823,2],[970740.364617003,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-b28ba90816bb02babff8430f33cc02ea","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.035819825,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.069564419,"time_to_first_token":0.125895101,"token_sha":"2b28aa2108de","tokens_per_second":25.323836204756493},"seed":1234,"sent":970730.166142497,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12841090105939656,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.323851623330842,"done":970740.364812053,"finish_reason":"length","first":970730.295237587,"full_response_s":10.198432020028122,"last":970740.364795875,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970730.295237587,2],[970730.484978922,7],[970730.633294193,4],[970730.847736416,63],[970731.084283099,10],[970731.269277642,31],[970731.458424496,29],[970731.640986643,22],[970731.821761136,14],[970732.006981759,24],[970732.187914487,4],[970732.337680889,13],[970732.526714608,21],[970732.710545202,2],[970732.890901575,18],[970733.076592952,29],[970733.313140989,27],[970733.558105818,24],[970733.706256314,4],[970733.853695007,16],[970734.092607641,10],[970734.276332529,31],[970734.430059618,8],[970734.616501339,11],[970734.802804032,16],[970734.983804347,12],[970735.166899808,39],[970735.339477556,18],[970735.530675251,11],[970735.712656592,16],[970735.89412074,16],[970736.042857893,11],[970736.227394719,6],[970736.418757572,9],[970736.604556985,29],[970736.789206466,22],[970736.971383701,8],[970737.123435953,18],[970737.306272552,18],[970737.495753295,34],[970737.679607759,10],[970737.863625593,14],[970738.051217539,13],[970738.235280849,2],[970738.424725061,36],[970738.612101522,42],[970738.795528555,26],[970738.945481509,17],[970739.131578071,34],[970739.371656421,12],[970739.563467464,36],[970739.847706032,50],[970740.034714159,2],[970740.364795875,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-2688ad7b2b84d8206db1733ef5f79986","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.036040304,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.070201528,"time_to_first_token":0.125352115,"token_sha":"2b28aa2108de","tokens_per_second":25.32223404774745},"seed":1234,"sent":970730.166380033,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12885755393654108,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.326196552425284,"done":970740.362749409,"finish_reason":"length","first":970730.294084902,"full_response_s":10.195547136012465,"last":970740.362710859,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970730.294084902,2],[970730.485344412,7],[970730.632292488,4],[970730.848291035,63],[970731.08446618,10],[970731.267458386,31],[970731.457882358,29],[970731.641355221,22],[970731.821835546,14],[970732.007302267,24],[970732.190524298,4],[970732.338429999,13],[970732.528514229,21],[970732.709376179,2],[970732.889807698,18],[970733.076308625,29],[970733.312928432,27],[970733.55852197,24],[970733.706644799,4],[970733.855097293,16],[970734.094030843,10],[970734.276040922,31],[970734.431024277,8],[970734.615515701,11],[970734.801060772,16],[970734.986859001,12],[970735.165590895,39],[970735.338211608,18],[970735.530075265,11],[970735.712399358,16],[970735.895479483,16],[970736.043406671,11],[970736.227632047,6],[970736.417701381,9],[970736.604753651,29],[970736.787874974,22],[970736.970949243,8],[970737.121205732,18],[970737.306845733,18],[970737.495835402,34],[970737.680365398,10],[970737.863567153,14],[970738.052539669,13],[970738.232766031,2],[970738.425210742,36],[970738.611359182,42],[970738.795132294,26],[970738.944328666,17],[970739.130316158,34],[970739.372127605,12],[970739.561222058,36],[970739.84801857,50],[970740.03424776,2],[970740.362710859,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-66865b871274f87acae80c558aa035d6","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.035488084,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.06813258,"time_to_first_token":0.126097225,"token_sha":"2b28aa2108de","tokens_per_second":25.327437632927953},"seed":1234,"sent":970730.167202273,"speculative":{"acceptance_rate":0.5501355013550135,"accepted":203,"drafted":369,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12688262900337577,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":369,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.329058296507334,"done":970740.363317581,"finish_reason":"length","first":970730.295764667,"full_response_s":10.196432119002566,"last":970740.363253044,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970730.295764667,2],[970730.487885448,7],[970730.631443988,4],[970730.845716172,63],[970731.085071734,10],[970731.268714093,31],[970731.456735865,29],[970731.641453763,22],[970731.821672404,14],[970732.00647433,24],[970732.189478924,4],[970732.33669125,13],[970732.527855515,21],[970732.710403855,2],[970732.890516594,18],[970733.077053495,29],[970733.311851693,27],[970733.558799752,24],[970733.705412359,4],[970733.854343271,16],[970734.093937182,10],[970734.276831077,31],[970734.42951188,8],[970734.614491466,11],[970734.797680601,16],[970734.981760294,12],[970735.164041165,39],[970735.339857255,18],[970735.528774145,11],[970735.711788571,16],[970735.894566288,16],[970736.0439205,11],[970736.226217104,6],[970736.419498424,9],[970736.604854721,29],[970736.787766944,22],[970736.972087828,8],[970737.122598848,18],[970737.305840733,18],[970737.495036287,34],[970737.678396268,10],[970737.863128502,14],[970738.052839277,13],[970738.232070369,2],[970738.424269192,36],[970738.609899834,42],[970738.794963151,26],[970738.943478119,17],[970739.12944092,34],[970739.372463154,12],[970739.561704043,36],[970739.849516563,50],[970740.034344989,2],[970740.363253044,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-83b5f330c30f0af115a32c782e8960be","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.035664333,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.069111206,"time_to_first_token":0.126184005,"token_sha":"2b28aa2108de","tokens_per_second":25.32497603642019},"seed":1234,"sent":970730.166885462,"speculative":{"acceptance_rate":0.5501355013550135,"accepted":203,"drafted":369,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12887920497450978,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":369,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.020393129076083,"done":970740.362171475,"finish_reason":"length","first":970730.17042433,"full_response_s":10.196100795990787,"last":970740.362110715,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970730.17042433,2],[970730.259262108,7],[970730.489845476,4],[970730.632863686,72],[970730.845842685,1],[970731.086363094,27],[970731.266879619,30],[970731.456443426,15],[970731.639833014,14],[970731.820629429,20],[970732.007186667,14],[970732.189053074,4],[970732.337553111,13],[970732.527346918,21],[970732.708834841,2],[970732.890244734,18],[970733.075930926,29],[970733.312582721,27],[970733.557801792,24],[970733.705321947,4],[970733.85318417,16],[970734.091409031,10],[970734.275965712,31],[970734.429104,8],[970734.617669849,11],[970734.798359013,16],[970734.982712391,12],[970735.167341548,39],[970735.337835861,18],[970735.529749781,11],[970735.712044157,16],[970735.895809752,16],[970736.042557212,11],[970736.226865383,6],[970736.418400644,9],[970736.603510267,29],[970736.788883575,22],[970736.971508838,8],[970737.120933167,18],[970737.304172236,18],[970737.494536299,34],[970737.678120727,10],[970737.862778807,14],[970738.047059154,13],[970738.231279622,2],[970738.423898022,36],[970738.609523927,42],[970738.79431532,26],[970738.942956193,17],[970739.129509297,34],[970739.37237407,12],[970739.560319873,36],[970739.849279539,50],[970740.035128262,2],[970740.362110715,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-0fc1d73771730845742dacaab1e73c8e","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.00229649,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.19159082,"time_to_first_token":0.002783788,"token_sha":"2b28aa2108de","tokens_per_second":25.020627741410834},"seed":1234,"sent":970730.166070679,"speculative":{"acceptance_rate":0.5401069518716578,"accepted":202,"drafted":374,"rounds":54,"tokens_per_round":4.7407407407407405},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.004353651078417897,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":202,"drafted":374,"rounds":54},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.324264245876428,"done":970740.363932111,"finish_reason":"length","first":970730.294502175,"full_response_s":10.196943450951949,"last":970740.363896394,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970730.294502175,2],[970730.48665744,7],[970730.632004689,4],[970730.846708467,63],[970731.085563241,10],[970731.268527059,31],[970731.459801932,29],[970731.641057373,22],[970731.823447333,14],[970732.006410833,24],[970732.189654596,4],[970732.338515338,13],[970732.52960777,21],[970732.708988206,2],[970732.889885485,18],[970733.076863581,29],[970733.314044375,27],[970733.558220489,24],[970733.707235887,4],[970733.855456638,16],[970734.092953768,10],[970734.274721943,31],[970734.430012283,8],[970734.615996262,11],[970734.799298949,16],[970734.985462988,12],[970735.166381306,39],[970735.339973191,18],[970735.532075808,11],[970735.712454725,16],[970735.896672189,16],[970736.043267452,11],[970736.226382054,6],[970736.418677625,9],[970736.606460426,29],[970736.790635859,22],[970736.970650386,8],[970737.121788387,18],[970737.305776213,18],[970737.495429732,34],[970737.681509888,10],[970737.863240677,14],[970738.053828722,13],[970738.235346442,2],[970738.425046464,36],[970738.611262705,42],[970738.796853021,26],[970738.946149167,17],[970739.131302002,34],[970739.373861438,12],[970739.56184459,36],[970739.848541616,50],[970740.035357253,2],[970740.363896394,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-3371f670402b3ba0cfd14e49dbcf268f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.035756232,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.06957959,"time_to_first_token":0.125831653,"token_sha":"2b28aa2108de","tokens_per_second":25.323798051433844},"seed":1234,"sent":970730.16698866,"speculative":{"acceptance_rate":0.553133514986376,"accepted":203,"drafted":367,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1275135149480775,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":367,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.32078707288572,"done":970740.365705149,"finish_reason":"length","first":970730.294835644,"full_response_s":10.199421289027669,"last":970740.365612641,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970730.294835644,2],[970730.486782817,7],[970730.633364459,4],[970730.848585267,63],[970731.085200616,10],[970731.267612375,31],[970731.457089338,29],[970731.640943373,22],[970731.821057024,14],[970732.006922087,24],[970732.18934969,4],[970732.336492999,13],[970732.527810661,21],[970732.709164662,2],[970732.890629538,18],[970733.078559844,29],[970733.312735029,27],[970733.557314206,24],[970733.707603249,4],[970733.854724731,16],[970734.093866404,10],[970734.275715918,31],[970734.42987004,8],[970734.617122319,11],[970734.798528636,16],[970734.982432417,12],[970735.165306328,39],[970735.338444168,18],[970735.532810212,11],[970735.71064784,16],[970735.894615398,16],[970736.041892258,11],[970736.22769756,6],[970736.41942331,9],[970736.604963936,29],[970736.786857397,22],[970736.971574687,8],[970737.120490899,18],[970737.305209176,18],[970737.496712849,34],[970737.681780933,10],[970737.86437867,14],[970738.052627617,13],[970738.233085466,2],[970738.424806768,36],[970738.6124994,42],[970738.796039088,26],[970738.945820082,17],[970739.130798415,34],[970739.373566902,12],[970739.562040105,36],[970739.848700261,50],[970740.035167404,2],[970740.365612641,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-db8155f84f11c01c11b7076ed58945e0","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.036114986,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.071031575,"time_to_first_token":0.125101153,"token_sha":"2b28aa2108de","tokens_per_second":25.32014700787988},"seed":1234,"sent":970730.16628386,"speculative":{"acceptance_rate":0.5561643835616439,"accepted":203,"drafted":365,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12855178397148848,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":365,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.325027714813707,"done":970740.363481859,"finish_reason":"length","first":970730.294371181,"full_response_s":10.19668344897218,"last":970740.36346184,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970730.294371181,2],[970730.487516021,7],[970730.631505788,4],[970730.848150504,63],[970731.086442321,10],[970731.26710829,31],[970731.45661897,29],[970731.641261241,22],[970731.823091365,14],[970732.005461568,24],[970732.190921616,4],[970732.338042906,13],[970732.527141514,21],[970732.708566437,2],[970732.890204312,18],[970733.078483785,29],[970733.312992104,27],[970733.559451232,24],[970733.705620516,4],[970733.853547051,16],[970734.093078201,10],[970734.274296109,31],[970734.43032895,8],[970734.617319386,11],[970734.797858913,16],[970734.986475973,12],[970735.164123368,39],[970735.3389768,18],[970735.531930349,11],[970735.712356904,16],[970735.894477028,16],[970736.042461503,11],[970736.227920438,6],[970736.419349076,9],[970736.60368077,29],[970736.790365311,22],[970736.971322845,8],[970737.120629814,18],[970737.304378504,18],[970737.495095543,34],[970737.679664775,10],[970737.861771855,14],[970738.0472463,13],[970738.235535108,2],[970738.42413847,36],[970738.609776569,42],[970738.794506449,26],[970738.943091891,17],[970739.129973248,34],[970739.373987471,12],[970739.561124157,36],[970739.847513254,50],[970740.034892583,2],[970740.36346184,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-d0aed3e713502f3d3d9770c0fbaaecbc","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.035553789,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.068216463,"time_to_first_token":0.125950885,"token_sha":"2b28aa2108de","tokens_per_second":25.32722661825035},"seed":1234,"sent":970730.16679841,"speculative":{"acceptance_rate":0.5501355013550135,"accepted":203,"drafted":369,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12757277104537934,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":369,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.322996833298006,"done":970740.364724826,"finish_reason":"length","first":970730.294788646,"full_response_s":10.198495293967426,"last":970740.364686837,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970730.294788646,2],[970730.486292894,7],[970730.6313265,4],[970730.846853479,63],[970731.086285276,10],[970731.26755059,31],[970731.457131471,29],[970731.640103195,22],[970731.821720746,14],[970732.006075268,24],[970732.188437598,4],[970732.336603318,13],[970732.527238215,21],[970732.709665818,2],[970732.890038513,18],[970733.077609954,29],[970733.312466385,27],[970733.559320351,24],[970733.708464662,4],[970733.854223159,16],[970734.093565788,10],[970734.274407676,31],[970734.429774379,8],[970734.615013665,11],[970734.799930922,16],[970734.983699613,12],[970735.164749293,39],[970735.338786902,18],[970735.529585359,11],[970735.711896649,16],[970735.895327623,16],[970736.044627748,11],[970736.226941618,6],[970736.41906571,9],[970736.604161379,29],[970736.789954439,22],[970736.972692358,8],[970737.121330293,18],[970737.305570697,18],[970737.496650456,34],[970737.678317473,10],[970737.862333531,14],[970738.051390426,13],[970738.231939567,2],[970738.424525034,36],[970738.613157904,42],[970738.797480466,26],[970738.945955108,17],[970739.130518377,34],[970739.372218257,12],[970739.561585083,36],[970739.849456811,50],[970740.034662616,2],[970740.364686837,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-79d12e363acd57dfac77c23fa1c41cb2","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.035932081,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.069548928,"time_to_first_token":0.125895694,"token_sha":"2b28aa2108de","tokens_per_second":25.323875162961023},"seed":1234,"sent":970730.166229532,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1285591140622273,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.323210402804204,"done":970740.365790137,"finish_reason":"length","first":970730.295853976,"full_response_s":10.198710824013688,"last":970740.36566724,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970730.295853976,2],[970730.486942423,7],[970730.631718505,4],[970730.846795487,63],[970731.085647669,10],[970731.267363381,31],[970731.458244935,29],[970731.640693515,22],[970731.82251487,14],[970732.005918302,24],[970732.189207703,4],[970732.336779374,13],[970732.528967347,21],[970732.709734452,2],[970732.890716702,18],[970733.078126313,29],[970733.312055161,27],[970733.558844014,24],[970733.707718657,4],[970733.853906044,16],[970734.094556898,10],[970734.277241885,31],[970734.429951011,8],[970734.61475523,11],[970734.800017606,16],[970734.987689001,12],[970735.164875086,39],[970735.337770701,18],[970735.530917123,11],[970735.712428225,16],[970735.895852942,16],[970736.043973579,11],[970736.226980839,6],[970736.418849792,9],[970736.606117308,29],[970736.788318058,22],[970736.971197932,8],[970737.122973363,18],[970737.305693946,18],[970737.496402951,34],[970737.679147649,10],[970737.863895213,14],[970738.053434237,13],[970738.232910818,2],[970738.424049962,36],[970738.610467302,42],[970738.798043022,26],[970738.945200399,17],[970739.130413835,34],[970739.371926778,12],[970739.562372709,36],[970739.849573083,50],[970740.033992958,2],[970740.36566724,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-41da9799c8828aefa6a5b2ef85e00b83","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.036076949,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.071093215,"time_to_first_token":0.125344162,"token_sha":"2b28aa2108de","tokens_per_second":25.319992036236954},"seed":1234,"sent":970730.167079313,"speculative":{"acceptance_rate":0.5561643835616439,"accepted":203,"drafted":365,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1287746630841866,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":365,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.32753867757436,"done":970740.36228397,"finish_reason":"length","first":970730.294171026,"full_response_s":10.195752923958935,"last":970740.362263439,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970730.294171026,2],[970730.488486506,7],[970730.631395101,4],[970730.846567456,63],[970731.08391356,10],[970731.269626506,31],[970731.458827591,29],[970731.639972057,22],[970731.823515455,14],[970732.007046824,24],[970732.188184108,4],[970732.337755299,13],[970732.528725074,21],[970732.710444692,2],[970732.890973505,18],[970733.076172335,29],[970733.312647113,27],[970733.557679952,24],[970733.705734211,4],[970733.85343238,16],[970734.092812869,10],[970734.277327992,31],[970734.429217952,8],[970734.614842954,11],[970734.800734247,16],[970734.983599887,12],[970735.168329458,39],[970735.337959158,18],[970735.529062392,11],[970735.711238976,16],[970735.893880899,16],[970736.04442356,11],[970736.227329078,6],[970736.418948446,9],[970736.604029041,29],[970736.78794684,22],[970736.972166879,8],[970737.122173175,18],[970737.306118019,18],[970737.496317948,34],[970737.679977201,10],[970737.863509545,14],[970738.05112111,13],[970738.231458222,2],[970738.425779155,36],[970738.614356482,42],[970738.797781931,26],[970738.944047524,17],[970739.129171332,34],[970739.372173451,12],[970739.560452371,36],[970739.848917571,50],[970740.034621666,2],[970740.362263439,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-bcc3b983c60d3fedda618054c08361d7","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.035360371,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.068253028,"time_to_first_token":0.12625579,"token_sha":"2b28aa2108de","tokens_per_second":25.32713463704579},"seed":1234,"sent":970730.166531046,"speculative":{"acceptance_rate":0.5471698113207547,"accepted":203,"drafted":371,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12763997993897647,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":371,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.32595363903686,"done":970740.36307486,"finish_reason":"length","first":970730.294315045,"full_response_s":10.197378568002023,"last":970740.363037575,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970730.294315045,2],[970730.485541527,7],[970730.634413802,4],[970730.846140598,63],[970731.084213105,10],[970731.268056739,31],[970731.457737938,29],[970731.640543943,22],[970731.820473792,14],[970732.007089038,24],[970732.189565608,4],[970732.338347924,13],[970732.528349198,21],[970732.710089556,2],[970732.889963351,18],[970733.076741692,29],[970733.313924007,27],[970733.55670814,24],[970733.706015017,4],[970733.853495508,16],[970734.094999886,10],[970734.275588092,31],[970734.429575408,8],[970734.615393012,11],[970734.801319511,16],[970734.981996198,12],[970735.164554514,39],[970735.33786729,18],[970735.52854893,11],[970735.712516429,16],[970735.894867721,16],[970736.042363586,11],[970736.228035589,6],[970736.418070599,9],[970736.603404957,29],[970736.786765096,22],[970736.972985742,8],[970737.121870446,18],[970737.305292515,18],[970737.49474996,34],[970737.681178099,10],[970737.863846902,14],[970738.051466564,13],[970738.235460426,2],[970738.424598884,36],[970738.610753533,42],[970738.79823436,26],[970738.946402241,17],[970739.129269377,34],[970739.372068365,12],[970739.560831622,36],[970739.847968115,50],[970740.033747245,2],[970740.363037575,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-78c48682951d748f82fc1c898040b2d6","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.035408409,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.068269335,"time_to_first_token":0.126169715,"token_sha":"2b28aa2108de","tokens_per_second":25.327093616134377},"seed":1234,"sent":970730.165696292,"speculative":{"acceptance_rate":0.5501355013550135,"accepted":203,"drafted":369,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12861875304952264,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":369,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.285175199304508,"done":970750.590187687,"finish_reason":"length","first":970740.503854782,"full_response_s":10.216337780002505,"last":970750.588815554,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970740.503854782,2],[970740.688817978,7],[970740.836942079,4],[970741.052813467,63],[970741.288795598,10],[970741.477671929,31],[970741.662485956,29],[970741.844157713,22],[970742.026577598,14],[970742.213517352,24],[970742.402438826,4],[970742.553046249,13],[970742.735858618,21],[970742.91717665,2],[970743.100439339,18],[970743.284619046,29],[970743.525960832,27],[970743.75958378,24],[970743.911252146,4],[970744.057420119,16],[970744.294547285,10],[970744.49002242,31],[970744.636921354,8],[970744.818898737,11],[970745.00211733,16],[970745.186368269,12],[970745.373115363,39],[970745.551288517,18],[970745.73593162,11],[970745.91741642,16],[970746.103518536,16],[970746.253285491,11],[970746.446517209,6],[970746.631034474,9],[970746.81570883,29],[970747.001227479,22],[970747.185873451,8],[970747.333476596,18],[970747.524213584,18],[970747.707407748,34],[970747.891935349,10],[970748.078479224,14],[970748.262940264,13],[970748.457523923,2],[970748.641697708,36],[970748.826286153,42],[970749.014559747,26],[970749.163200172,17],[970749.346882792,34],[970749.594165217,12],[970749.77864503,36],[970750.069061344,50],[970750.253891303,2],[970750.588815554,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-ab514cd42dd9637b1cbe06013772a1df","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.033819084,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.084925073,"time_to_first_token":0.128468541,"token_sha":"2b28aa2108de","tokens_per_second":25.285264704911107},"seed":1234,"sent":970740.373849907,"speculative":{"acceptance_rate":0.5471698113207547,"accepted":203,"drafted":371,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.13000487501267344,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":371,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":24.972849310067822,"done":970750.589486714,"finish_reason":"length","first":970740.378378899,"full_response_s":10.215496517019346,"last":970750.589468424,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970740.378378899,2],[970740.469911233,7],[970740.686602177,4],[970740.836701519,72],[970741.053282554,1],[970741.287916184,27],[970741.477302583,30],[970741.660330259,15],[970741.84392845,14],[970742.026103903,20],[970742.212242701,14],[970742.402189961,4],[970742.552694426,13],[970742.736288372,21],[970742.918718056,2],[970743.102513183,18],[970743.281704049,29],[970743.52681349,27],[970743.759612824,24],[970743.909551824,4],[970744.057600847,16],[970744.294259854,10],[970744.489618574,31],[970744.634876634,8],[970744.820438158,11],[970745.004352779,16],[970745.188764123,12],[970745.37148561,39],[970745.551729536,18],[970745.734185708,11],[970745.918826848,16],[970746.103712113,16],[970746.254746149,11],[970746.44532377,6],[970746.63301168,9],[970746.816771563,29],[970746.999738049,22],[970747.185295183,8],[970747.33376409,18],[970747.525103125,18],[970747.708043896,34],[970747.893574414,10],[970748.07675466,14],[970748.261252969,13],[970748.457828443,2],[970748.643629644,36],[970748.82808399,42],[970749.012792825,26],[970749.162161875,17],[970749.347648269,34],[970749.594979805,12],[970749.77829252,36],[970750.069335092,50],[970750.25291911,2],[970750.589468424,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-6c499e9ec1e84acd64b7b72cca067d55","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.002812618,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.209782169,"time_to_first_token":0.003221793,"token_sha":"2b28aa2108de","tokens_per_second":24.97604706731721},"seed":1234,"sent":970740.373990197,"speculative":{"acceptance_rate":0.5401069518716578,"accepted":202,"drafted":374,"rounds":54,"tokens_per_round":4.7407407407407405},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.00438870198559016,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":202,"drafted":374,"rounds":54},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.27960902643262,"done":970750.590727566,"finish_reason":"length","first":970740.503509135,"full_response_s":10.216221555019729,"last":970750.590690457,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970740.503509135,2],[970740.689920814,7],[970740.837123447,4],[970741.05178861,63],[970741.288346481,10],[970741.479985679,31],[970741.660657087,29],[970741.84419767,22],[970742.026302857,14],[970742.212088425,24],[970742.401822776,4],[970742.553395656,13],[970742.73561545,21],[970742.91669665,2],[970743.100976338,18],[970743.283395058,29],[970743.527037264,27],[970743.760206615,24],[970743.90814266,4],[970744.057745139,16],[970744.296367623,10],[970744.489299075,31],[970744.636235967,8],[970744.819209482,11],[970745.002965747,16],[970745.188075424,12],[970745.372675177,39],[970745.552060044,18],[970745.736963245,11],[970745.919064767,16],[970746.104308865,16],[970746.254886248,11],[970746.44578988,6],[970746.634819952,9],[970746.817429858,29],[970746.99951962,22],[970747.187885878,8],[970747.332846928,18],[970747.526318006,18],[970747.708838306,34],[970747.891052881,10],[970748.076945118,14],[970748.262875487,13],[970748.455488053,2],[970748.644282418,36],[970748.826775833,42],[970749.012730273,26],[970749.163026149,17],[970749.347198882,34],[970749.595329291,12],[970749.777626272,36],[970750.06847181,50],[970750.252777892,2],[970750.590690457,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-cbb63c3badbacedbe96d7cc5aa643d43","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.033890805,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.084845847,"time_to_first_token":0.128082569,"token_sha":"2b28aa2108de","tokens_per_second":25.285463344574215},"seed":1234,"sent":970740.374506011,"speculative":{"acceptance_rate":0.5501355013550135,"accepted":203,"drafted":369,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1290031239623204,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":369,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.285670098381768,"done":970750.588861368,"finish_reason":"length","first":970740.504080988,"full_response_s":10.214253248064779,"last":970750.588844374,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970740.504080988,2],[970740.689195597,7],[970740.835477563,4],[970741.051658928,63],[970741.287736176,10],[970741.478624296,31],[970741.66092445,29],[970741.844317414,22],[970742.026414472,14],[970742.213794141,24],[970742.403868858,4],[970742.552764771,13],[970742.736170884,21],[970742.918445219,2],[970743.100267684,18],[970743.282526062,29],[970743.525344526,27],[970743.760631296,24],[970743.910880353,4],[970744.057312377,16],[970744.296053309,10],[970744.487319388,31],[970744.635184307,8],[970744.821385756,11],[970745.004203768,16],[970745.186762561,12],[970745.372156131,39],[970745.55044042,18],[970745.736841725,11],[970745.917527651,16],[970746.103950897,16],[970746.254441965,11],[970746.447299361,6],[970746.631524411,9],[970746.816277385,29],[970747.001050271,22],[970747.184949089,8],[970747.333817825,18],[970747.523788295,18],[970747.710774146,34],[970747.892465708,10],[970748.076547049,14],[970748.262996655,13],[970748.455800495,2],[970748.641919689,36],[970748.826870086,42],[970749.011656195,26],[970749.161785105,17],[970749.347965623,34],[970749.596317069,12],[970749.777564408,36],[970750.069193729,50],[970750.254089265,2],[970750.588844374,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-3bb69792ae58d98fbcc6790a12267a6f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.034065309,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.085028207,"time_to_first_token":0.128394051,"token_sha":"2b28aa2108de","tokens_per_second":25.285006126507902},"seed":1234,"sent":970740.37460812,"speculative":{"acceptance_rate":0.553133514986376,"accepted":203,"drafted":367,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12947286805137992,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":367,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.28873546331231,"done":970750.589451334,"finish_reason":"length","first":970740.505885694,"full_response_s":10.215542139019817,"last":970750.589426659,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970740.505885694,2],[970740.690358761,7],[970740.834763739,4],[970741.05272992,63],[970741.286815764,10],[970741.476854107,31],[970741.660096739,29],[970741.845623253,22],[970742.026494451,14],[970742.211296591,24],[970742.40310722,4],[970742.551965928,13],[970742.735714375,21],[970742.917485315,2],[970743.101287244,18],[970743.283270178,29],[970743.526578659,27],[970743.760135341,24],[970743.910463465,4],[970744.057918122,16],[970744.295287079,10],[970744.489021198,31],[970744.635117658,8],[970744.820171786,11],[970745.003735753,16],[970745.189042912,12],[970745.373245124,39],[970745.551909528,18],[970745.7344877,11],[970745.918751606,16],[970746.104151868,16],[970746.253054244,11],[970746.446568912,6],[970746.632913715,9],[970746.818246894,29],[970747.00019403,22],[970747.186150528,8],[970747.33328361,18],[970747.524572191,18],[970747.709802273,34],[970747.894175246,10],[970748.077232692,14],[970748.261437793,13],[970748.455899932,2],[970748.642487012,36],[970748.827426399,42],[970749.013102786,26],[970749.163408183,17],[970749.347576324,34],[970749.593695139,12],[970749.77949215,36],[970750.069857305,50],[970750.252574537,2],[970750.589426659,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-c750f056afd9418b858a4ddd5f391833","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034101553,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.085116634,"time_to_first_token":0.128419878,"token_sha":"2b28aa2108de","tokens_per_second":25.28478442582581},"seed":1234,"sent":970740.373909195,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.13197649898938835,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.279925810366816,"done":970750.591949103,"finish_reason":"length","first":970740.504746037,"full_response_s":10.217825560015626,"last":970750.591800956,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970740.504746037,2],[970740.689075965,7],[970740.834461634,4],[970741.052018032,63],[970741.288578593,10],[970741.477071448,31],[970741.660779631,29],[970741.845202461,22],[970742.027211459,14],[970742.211197169,24],[970742.402750772,4],[970742.551739274,13],[970742.735278573,21],[970742.916628433,2],[970743.099987454,18],[970743.281319325,29],[970743.52499912,27],[970743.759120406,24],[970743.909469045,4],[970744.057868371,16],[970744.2949603,10],[970744.486025151,31],[970744.635929062,8],[970744.821056768,11],[970745.002466705,16],[970745.18759296,12],[970745.372725887,39],[970745.550325605,18],[970745.736395474,11],[970745.918140293,16],[970746.103659402,16],[970746.254788971,11],[970746.446330912,6],[970746.63353959,9],[970746.817990604,29],[970747.00034485,22],[970747.186625407,8],[970747.333076334,18],[970747.524758392,18],[970747.707698747,34],[970747.894694194,10],[970748.078745548,14],[970748.262194789,13],[970748.456109959,2],[970748.641635012,36],[970748.827488887,42],[970749.012136563,26],[970749.162345211,17],[970749.348679093,34],[970749.596062924,12],[970749.777208857,36],[970750.068796429,50],[970750.254840195,2],[970750.591800956,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-afa41568cf6c28566e0aafb715130660","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034325904,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.088017671,"time_to_first_token":0.1281372,"token_sha":"2b28aa2108de","tokens_per_second":25.277513215807293},"seed":1234,"sent":970740.374123543,"speculative":{"acceptance_rate":0.5561643835616439,"accepted":203,"drafted":365,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1306224939180538,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":365,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.284830093463523,"done":970750.590626129,"finish_reason":"length","first":970740.505489353,"full_response_s":10.21621433889959,"last":970750.590587772,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970740.505489353,2],[970740.687426927,7],[970740.837734745,4],[970741.053376934,63],[970741.287066886,10],[970741.478447217,31],[970741.661269425,29],[970741.845021333,22],[970742.026357889,14],[970742.212630641,24],[970742.403162987,4],[970742.552195655,13],[970742.735168238,21],[970742.919087753,2],[970743.100574605,18],[970743.282675922,29],[970743.525718864,27],[970743.760159505,24],[970743.90874426,4],[970744.057489024,16],[970744.295053992,10],[970744.486205447,31],[970744.634783757,8],[970744.820008661,11],[970745.004293748,16],[970745.187338078,12],[970745.372226301,39],[970745.551182855,18],[970745.734771081,11],[970745.917905221,16],[970746.103845011,16],[970746.253874049,11],[970746.447030301,6],[970746.633988578,9],[970746.817322004,29],[970747.000074878,22],[970747.18465745,8],[970747.333334273,18],[970747.524829745,18],[970747.707850239,34],[970747.892939418,10],[970748.076275397,14],[970748.261833606,13],[970748.454447068,2],[970748.64314606,36],[970748.826384774,42],[970749.01173883,26],[970749.162392273,17],[970749.347145019,34],[970749.595378113,12],[970749.777821338,36],[970750.067833198,50],[970750.254045467,2],[970750.590587772,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-05ddfc66b75ea2b96e23e04c312f76bb","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034252982,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.08540904,"time_to_first_token":0.128074344,"token_sha":"2b28aa2108de","tokens_per_second":25.28405134473356},"seed":1234,"sent":970740.37441179,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.13107756292447448,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.27898211556744,"done":970750.591896648,"finish_reason":"length","first":970740.504311067,"full_response_s":10.217117257067002,"last":970750.591742548,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970740.504311067,2],[970740.688276785,7],[970740.837796033,4],[970741.051517901,63],[970741.287796808,10],[970741.478300717,31],[970741.660225973,29],[970741.846148459,22],[970742.026853235,14],[970742.211587894,24],[970742.402111103,4],[970742.553165289,13],[970742.736679064,21],[970742.916511953,2],[970743.100143843,18],[970743.282029932,29],[970743.525119312,27],[970743.75972079,24],[970743.908260196,4],[970744.058161338,16],[970744.29489005,10],[970744.487750981,31],[970744.634692033,8],[970744.819801225,11],[970745.003511163,16],[970745.188919936,12],[970745.373419323,39],[970745.550942967,18],[970745.735031084,11],[970745.917164323,16],[970746.104445203,16],[970746.252864123,11],[970746.445695388,6],[970746.632464727,9],[970746.815985475,29],[970747.000655163,22],[970747.186903668,8],[970747.333877481,18],[970747.526599244,18],[970747.707547399,34],[970747.890819778,10],[970748.078019228,14],[970748.262334472,13],[970748.458116753,2],[970748.644580313,36],[970748.826944191,42],[970749.011181285,26],[970749.163156582,17],[970749.348275536,34],[970749.595625746,12],[970749.778337166,36],[970750.068899386,50],[970750.254925023,2],[970750.591742548,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-552a831ac0c9ca6a184af5d5b390fd19","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034289035,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.088040603,"time_to_first_token":0.127986876,"token_sha":"2b28aa2108de","tokens_per_second":25.27745575529976},"seed":1234,"sent":970740.374779391,"speculative":{"acceptance_rate":0.5561643835616439,"accepted":203,"drafted":365,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12953167606610805,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":365,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.283036020500628,"done":970750.589792883,"finish_reason":"length","first":970740.503942265,"full_response_s":10.215600738069043,"last":970750.589756318,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970740.503942265,2],[970740.6884422,7],[970740.835744686,4],[970741.052073272,63],[970741.288154392,10],[970741.480124001,31],[970741.661021471,29],[970741.84552492,22],[970742.026261124,14],[970742.213105681,24],[970742.401741325,4],[970742.552991826,13],[970742.736215738,21],[970742.919909847,2],[970743.101821539,18],[970743.28147693,29],[970743.524167761,27],[970743.761095069,24],[970743.908455614,4],[970744.05767713,16],[970744.295550234,10],[970744.48744478,31],[970744.635971036,8],[970744.819282388,11],[970745.003421232,16],[970745.187288071,12],[970745.371857452,39],[970745.550719241,18],[970745.736514961,11],[970745.919323826,16],[970746.103429724,16],[970746.254960753,11],[970746.446179884,6],[970746.632634718,9],[970746.816436254,29],[970746.999884565,22],[970747.187492066,8],[970747.333400105,18],[970747.524408025,18],[970747.709502218,34],[970747.891166416,10],[970748.077308062,14],[970748.262739293,13],[970748.455287003,2],[970748.641785992,36],[970748.826677884,42],[970749.013052108,26],[970749.161481625,17],[970749.347817651,34],[970749.594820872,12],[970749.778712735,36],[970750.068594242,50],[970750.254595971,2],[970750.589756318,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-d3b188bbc16e89a444bfaed879e29482","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.0340282,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.084997498,"time_to_first_token":0.128105724,"token_sha":"2b28aa2108de","tokens_per_second":25.285083119809418},"seed":1234,"sent":970740.374192145,"speculative":{"acceptance_rate":0.553133514986376,"accepted":203,"drafted":367,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12975011998787522,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":367,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.277947267451214,"done":970750.592705427,"finish_reason":"length","first":970740.50398768,"full_response_s":10.218241821974516,"last":970750.591832128,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970740.50398768,2],[970740.68674922,7],[970740.836351104,4],[970741.053169131,63],[970741.288855542,10],[970741.478064845,31],[970741.6605769,29],[970741.845429259,22],[970742.02665356,14],[970742.212460842,24],[970742.402941838,4],[970742.551578165,13],[970742.734898186,21],[970742.91636579,2],[970743.101607351,18],[970743.282471991,29],[970743.525430313,27],[970743.759302254,24],[970743.908565628,4],[970744.058418572,16],[970744.295174056,10],[970744.488706789,31],[970744.635069267,8],[970744.819119822,11],[970745.002355298,16],[970745.186521825,12],[970745.371766816,39],[970745.551546471,18],[970745.736469179,11],[970745.91831454,16],[970746.103778762,16],[970746.254340351,11],[970746.446838755,6],[970746.633167573,9],[970746.815588046,29],[970747.000986823,22],[970747.187259187,8],[970747.333030536,18],[970747.525452388,18],[970747.707942635,34],[970747.893223728,10],[970748.076622835,14],[970748.261751451,13],[970748.457219994,2],[970748.643388412,36],[970748.826190044,42],[970749.012612754,26],[970749.161896416,17],[970749.347101333,34],[970749.594362715,12],[970749.779200608,36],[970750.06814039,50],[970750.253106527,2],[970750.591832128,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-ff32677924765b69a213517c5b4b5b8d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034379255,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.088040011,"time_to_first_token":0.12757058,"token_sha":"2b28aa2108de","tokens_per_second":25.277457238665583},"seed":1234,"sent":970740.374463605,"speculative":{"acceptance_rate":0.5561643835616439,"accepted":203,"drafted":365,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1295240749605,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":365,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.29074876785432,"done":970750.588208898,"finish_reason":"length","first":970740.505426609,"full_response_s":10.213984060916118,"last":970750.58816486,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970740.505426609,2],[970740.687893086,7],[970740.834290716,4],[970741.053515017,63],[970741.287264208,10],[970741.479053554,31],[970741.660888189,29],[970741.84567606,22],[970742.027027834,14],[970742.212374703,24],[970742.401947353,4],[970742.553857909,13],[970742.736640579,21],[970742.917307131,2],[970743.102463689,18],[970743.285361257,29],[970743.526275594,27],[970743.760878321,24],[970743.908674779,4],[970744.057216044,16],[970744.295824975,10],[970744.48786034,31],[970744.637013494,8],[970744.819955533,11],[970745.004084392,16],[970745.188807585,12],[970745.373316142,39],[970745.551132496,18],[970745.736287491,11],[970745.919803313,16],[970746.104207731,16],[970746.25452716,11],[970746.447563956,6],[970746.632834281,9],[970746.81584496,29],[970747.000923086,22],[970747.186440279,8],[970747.332372881,18],[970747.526061108,18],[970747.707316696,34],[970747.892791863,10],[970748.077015319,14],[970748.263265027,13],[970748.454627363,2],[970748.6425463,36],[970748.826104033,42],[970749.012340318,26],[970749.162104395,17],[970749.348811271,34],[970749.596436125,12],[970749.777432086,36],[970750.069271499,50],[970750.254767626,2],[970750.58816486,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-2daa84993c9c8b7e963ccd1bfd006d57","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.03385376,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.084878795,"time_to_first_token":0.128181702,"token_sha":"2b28aa2108de","tokens_per_second":25.285380735207934},"seed":1234,"sent":970740.374224837,"speculative":{"acceptance_rate":0.5501355013550135,"accepted":203,"drafted":369,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.13120177190285176,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":369,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.286437510426026,"done":970750.590052517,"finish_reason":"length","first":970740.505558386,"full_response_s":10.215394246042706,"last":970750.590015712,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970740.505558386,2],[970740.688593068,7],[970740.837648333,4],[970741.053706339,63],[970741.286710614,10],[970741.479542755,31],[970741.662773354,29],[970741.845134052,22],[970742.027405677,14],[970742.21197713,24],[970742.403637691,4],[970742.552399666,13],[970742.736397715,21],[970742.918535727,2],[970743.101903566,18],[970743.285033901,29],[970743.524495212,27],[970743.759389082,24],[970743.909276875,4],[970744.058027512,16],[970744.295342207,10],[970744.486545221,31],[970744.63562923,8],[970744.82114502,11],[970745.003326051,16],[970745.186630672,12],[970745.372517828,39],[970745.551395923,18],[970745.736724237,11],[970745.918388469,16],[970746.104248713,16],[970746.253715772,11],[970746.445500482,6],[970746.631771819,9],[970746.817754093,29],[970747.001690916,22],[970747.187781736,8],[970747.332939388,18],[970747.525683602,18],[970747.708274839,34],[970747.894393275,10],[970748.077812288,14],[970748.263085019,13],[970748.456966361,2],[970748.642150136,36],[970748.827988953,42],[970749.014089509,26],[970749.162011631,17],[970749.348034272,34],[970749.596179371,12],[970749.778471615,36],[970750.068317166,50],[970750.254366245,2],[970750.590015712,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-1f7c718177dca44546abf0ad92423d5d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034215089,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.085071827,"time_to_first_token":0.128249328,"token_sha":"2b28aa2108de","tokens_per_second":25.284896763680727},"seed":1234,"sent":970740.374658271,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.13090011500753462,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.28556907689815,"done":970750.589683988,"finish_reason":"length","first":970740.504840546,"full_response_s":10.21538190904539,"last":970750.589644223,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970740.504840546,2],[970740.68836915,7],[970740.836022132,4],[970741.052891621,63],[970741.286922947,10],[970741.47854563,31],[970741.661851279,29],[970741.845957762,22],[970742.027119655,14],[970742.211483304,24],[970742.40348151,4],[970742.552837533,13],[970742.736831677,21],[970742.917609668,2],[970743.101196384,18],[970743.282110455,29],[970743.524783427,27],[970743.760403361,24],[970743.91066434,4],[970744.058561279,16],[970744.295124034,10],[970744.487976595,31],[970744.635242026,8],[970744.820776731,11],[970745.004591227,16],[970745.187769559,12],[970745.372313608,39],[970745.550631806,18],[970745.735843864,11],[970745.918053849,16],[970746.104090932,16],[970746.253420757,11],[970746.44695181,6],[970746.631297357,9],[970746.817922291,29],[970747.00084418,22],[970747.185933699,8],[970747.332601712,18],[970747.523988866,18],[970747.707163732,34],[970747.891743852,10],[970748.077176076,14],[970748.262780947,13],[970748.458492995,2],[970748.642821345,36],[970748.828353001,42],[970749.01286045,26],[970749.161589719,17],[970749.347739833,34],[970749.594607435,12],[970749.778374595,36],[970750.067697196,50],[970750.253964928,2],[970750.589644223,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-25ec98c38883abbc377a4edeacfcc151","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034138662,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.085044369,"time_to_first_token":0.12835755,"token_sha":"2b28aa2108de","tokens_per_second":25.284965605489443},"seed":1234,"sent":970740.374302079,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.13053846708498895,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.2905422571904,"done":970750.589857179,"finish_reason":"length","first":970740.505644446,"full_response_s":10.215592065011151,"last":970750.588465028,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970740.505644446,2],[970740.689469506,7],[970740.836800716,4],[970741.05191197,63],[970741.286252537,10],[970741.479757168,31],[970741.661538613,29],[970741.844977135,22],[970742.027164653,14],[970742.212696666,24],[970742.402680139,4],[970742.552608926,13],[970742.734757255,21],[970742.916867649,2],[970743.100224334,18],[970743.284203406,29],[970743.525650071,27],[970743.760031615,24],[970743.910958027,4],[970744.057802938,16],[970744.295499348,10],[970744.487166183,31],[970744.63652935,8],[970744.818984812,11],[970745.003658591,16],[970745.188849223,12],[970745.371409648,39],[970745.549529339,18],[970745.735588982,11],[970745.918679788,16],[970746.104376154,16],[970746.253549798,11],[970746.445917833,6],[970746.63195842,9],[970746.815390004,29],[970747.001917122,22],[970747.187042774,8],[970747.332717391,18],[970747.524708897,18],[970747.70917091,34],[970747.891689829,10],[970748.07762524,14],[970748.263558586,13],[970748.456376075,2],[970748.640916485,36],[970748.825914552,42],[970749.013453809,26],[970749.16136977,17],[970749.346966419,34],[970749.594055171,12],[970749.778058089,36],[970750.067561546,50],[970750.253542056,2],[970750.588465028,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-36fe162c36eff0591fb6406a5fc4b77c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034176107,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.084875738,"time_to_first_token":0.128420791,"token_sha":"2b28aa2108de","tokens_per_second":25.285388399894234},"seed":1234,"sent":970740.374265114,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.13137933204416186,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.287996448060674,"done":970750.58907034,"finish_reason":"length","first":970740.504669035,"full_response_s":10.21433557907585,"last":970750.588504681,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970740.504669035,2],[970740.687134296,7],[970740.837346517,4],[970741.052558313,63],[970741.289066498,10],[970741.47986147,31],[970741.662158984,29],[970741.844072438,22],[970742.026925277,14],[970742.213637544,24],[970742.403414509,4],[970742.552304086,13],[970742.734985606,21],[970742.919534037,2],[970743.102700072,18],[970743.281845924,29],[970743.526183054,27],[970743.759454258,24],[970743.909227621,4],[970744.057373937,16],[970744.294388704,10],[970744.486840716,31],[970744.635576183,8],[970744.819386466,11],[970745.002641976,16],[970745.18833573,12],[970745.37296944,39],[970745.550119514,18],[970745.735312369,11],[970745.91703933,16],[970746.103896826,16],[970746.254087774,11],[970746.445593086,6],[970746.634296379,9],[970746.816331697,29],[970746.999942604,22],[970747.185802674,8],[970747.33205884,18],[970747.52388738,18],[970747.710303908,34],[970747.891597961,10],[970748.076103854,14],[970748.262251389,13],[970748.454820829,2],[970748.641212236,36],[970748.827243559,42],[970749.01157196,26],[970749.162572441,17],[970749.347890173,34],[970749.595557945,12],[970749.778564988,36],[970750.068232931,50],[970750.2542389,2],[970750.588504681,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-e035649c555d0437269c98e706f9642d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.033990851,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.085092951,"time_to_first_token":0.128125983,"token_sha":"2b28aa2108de","tokens_per_second":25.284843802526893},"seed":1234,"sent":970740.374734761,"speculative":{"acceptance_rate":0.5501355013550135,"accepted":203,"drafted":369,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12993427400942892,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":369,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.289516253898118,"done":970750.588778397,"finish_reason":"length","first":970740.505168446,"full_response_s":10.215019398950972,"last":970750.588398091,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[970740.505168446,2],[970740.687086578,7],[970740.836586607,4],[970741.053913294,63],[970741.288104449,10],[970741.478934642,31],[970741.660736137,29],[970741.845763208,22],[970742.026160438,14],[970742.212173716,24],[970742.401632559,4],[970742.552492415,13],[970742.73673976,21],[970742.916763187,2],[970743.101761019,18],[970743.283143729,29],[970743.525240656,27],[970743.760438102,24],[970743.909922129,4],[970744.05795139,16],[970744.29610578,10],[970744.488941316,31],[970744.636084283,8],[970744.82152443,11],[970745.002229377,16],[970745.187191098,12],[970745.371612203,39],[970745.550872158,18],[970745.737144213,11],[970745.919612024,16],[970746.10360858,16],[970746.253339594,11],[970746.447428498,6],[970746.634581088,9],[970746.816097153,29],[970747.000129365,22],[970747.185435985,8],[970747.332162021,18],[970747.523498417,18],[970747.71051432,34],[970747.890717156,10],[970748.078304513,14],[970748.263625395,13],[970748.45471003,2],[970748.644104986,36],[970748.827205186,42],[970749.011317927,26],[970749.162756897,17],[970749.348205751,34],[970749.59472041,12],[970749.778604961,36],[970750.067439962,50],[970750.25325181,2],[970750.588398091,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-19d97218de263d8f281743601f2ab315","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.033927482,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.085075125,"time_to_first_token":0.127973242,"token_sha":"2b28aa2108de","tokens_per_second":25.28488849506711},"seed":1234,"sent":970740.373758998,"speculative":{"acceptance_rate":0.5501355013550135,"accepted":203,"drafted":369,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.13140944798942655,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":369,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":1,"burst":null,"stream":0,"phase":"warmup","request":{"cache_state":"cold","cached_tokens":0,"case_id":null,"complete":true,"decode_tps":59.32341457840952,"done":970751.016957065,"finish_reason":"length","first":970750.764053032,"full_response_s":0.41085459291934967,"last":970751.01690429,"output_sha256":"6bffe2c2436146ed3af0e8c4e21d88b3dddfbe4a47910e8940f3039340788c85","pieces":[[970750.764053032,3],[970750.851541721,26],[970750.932289863,15],[970751.01690429,30]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":16,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"c81230cadd07c8b22d2a507aa18b8b00964a157b29ba5c65c8fdf55148cf2238","response_id":"chatcmpl-33dc543907b67d0bacc281e391ed49d4","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.155754479,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":0.253805287,"time_to_first_token":0.157099537,"token_sha":"a9100b9c265b","tokens_per_second":59.100423703939626},"seed":1234,"sent":970750.606102472,"speculative":{"acceptance_rate":0.28888888888888886,"accepted":13,"drafted":45,"rounds":3,"tokens_per_round":5.333333333333333},"token_sha":"a9100b9c265b","tokens":16,"ttft_s":0.157950559980236,"usage":{"completion_tokens":16,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":0},"total_tokens":47},"work":{"accepted":13,"drafted":45,"rounds":3},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":1,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":49.410522066662715,"done":970756.195085333,"finish_reason":"length","first":970751.034190772,"full_response_s":5.169722569989972,"last":970756.195034846,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970751.034190772,3],[970751.124330614,26],[970751.205093526,15],[970751.285421741,34],[970751.367079859,21],[970751.453969481,25],[970751.537462992,14],[970751.618151879,14],[970751.69913754,18],[970751.779549734,26],[970751.860339198,13],[970751.941110316,13],[970752.022652911,13],[970752.103918365,23],[970752.184890966,32],[970752.265843675,7],[970752.348752786,23],[970752.436617811,9],[970752.521316485,13],[970752.601630006,15],[970752.682581276,19],[970752.763254028,12],[970752.844911862,5],[970752.925882347,23],[970753.007156455,9],[970753.08880266,17],[970753.169574111,3],[970753.250639839,21],[970753.331267607,10],[970753.417325766,24],[970753.503054826,19],[970753.584585176,14],[970753.664898935,13],[970753.746188821,5],[970753.826639905,22],[970753.907411256,13],[970753.98847535,51],[970754.07080084,15],[970754.151525881,6],[970754.231601188,8],[970754.31442228,9],[970754.400787674,16],[970754.486773147,16],[970754.567881198,9],[970754.648622577,32],[970754.730173806,18],[970754.810991051,13],[970754.891996573,11],[970754.972498701,15],[970755.055157239,8],[970755.13564791,18],[970755.210467969,25],[970755.291796397,19],[970755.372958451,8],[970755.460480793,40],[970755.544140933,16],[970755.625311901,64],[970755.706085137,6],[970755.787036188,6],[970755.868167568,11],[970755.949257882,15],[970756.031312946,17],[970756.112900652,21],[970756.195034846,14]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-be9bdd20e965b9b4d16d07a2b71bce23","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.007668321,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":5.160604667,"time_to_first_token":0.008116124,"token_sha":"8a91591c94a3","tokens_per_second":49.41281428329956},"seed":1234,"sent":970751.025362763,"speculative":{"acceptance_rate":0.2052910052910053,"accepted":194,"drafted":945,"rounds":63,"tokens_per_round":4.063492063492063},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.008828009013086557,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":194,"drafted":945,"rounds":63},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":1,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":49.410444515850806,"done":970761.367141431,"finish_reason":"length","first":970756.206171114,"full_response_s":5.164069456979632,"last":970761.367023288,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970756.206171114,3],[970756.295943583,26],[970756.379355351,15],[970756.465596657,34],[970756.548623415,21],[970756.62963535,25],[970756.710362993,14],[970756.791210875,14],[970756.871813206,18],[970756.952360454,26],[970757.033622419,13],[970757.115776708,13],[970757.196446851,13],[970757.277119251,23],[970757.358297941,32],[970757.445715395,7],[970757.529580754,23],[970757.610508948,9],[970757.691182164,13],[970757.771684878,15],[970757.852333024,19],[970757.933308788,12],[970758.014615796,5],[970758.096329848,23],[970758.177317149,9],[970758.257939748,17],[970758.34090185,3],[970758.427832275,21],[970758.512696368,10],[970758.593467098,24],[970758.674405225,19],[970758.755247996,14],[970758.835819798,13],[970758.916563865,5],[970758.998218834,22],[970759.079551457,13],[970759.160253838,51],[970759.241517092,15],[970759.321568637,6],[970759.408104447,8],[970759.493471369,9],[970759.574581691,16],[970759.655604754,16],[970759.736920303,9],[970759.817811124,32],[970759.898638334,18],[970759.980486588,13],[970760.062337131,11],[970760.143331323,15],[970760.224229743,8],[970760.307045723,18],[970760.384940746,25],[970760.471366857,19],[970760.553505917,8],[970760.634464248,40],[970760.716054197,16],[970760.796673701,64],[970760.877626944,6],[970760.958744908,6],[970761.040642382,11],[970761.12255717,15],[970761.203944913,17],[970761.284623301,21],[970761.367023288,14]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-800d4c991606bc98d2c6acdd97e0517e","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.002241236,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":5.160797303,"time_to_first_token":0.002663387,"token_sha":"8a91591c94a3","tokens_per_second":49.41096986153033},"seed":1234,"sent":970756.203071974,"speculative":{"acceptance_rate":0.2052910052910053,"accepted":194,"drafted":945,"rounds":63,"tokens_per_round":4.063492063492063},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.0030991400126367807,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":194,"drafted":945,"rounds":63},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":1,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":49.3076713250235,"done":970766.556216528,"finish_reason":"length","first":970761.384530637,"full_response_s":5.175776579999365,"last":970766.556139702,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970761.384530637,3],[970761.476140757,26],[970761.558633075,15],[970761.639618239,34],[970761.720416498,21],[970761.800728855,25],[970761.882546253,14],[970761.963018259,14],[970762.045436741,18],[970762.126643594,26],[970762.207408518,13],[970762.288547346,13],[970762.371469764,13],[970762.458630137,23],[970762.54244419,32],[970762.623061031,7],[970762.704669872,23],[970762.785549755,9],[970762.866218829,13],[970762.946846613,15],[970763.028973213,19],[970763.111310352,12],[970763.192630561,5],[970763.27327857,23],[970763.35388067,9],[970763.441306865,17],[970763.525281991,3],[970763.605886667,21],[970763.686490767,10],[970763.767742695,24],[970763.848746694,19],[970763.929174688,14],[970764.010847355,13],[970764.092438987,5],[970764.173122439,22],[970764.253911168,13],[970764.337057047,51],[970764.42341814,15],[970764.509094345,6],[970764.590155301,8],[970764.670893271,9],[970764.751831748,16],[970764.833726325,16],[970764.915026413,9],[970764.996329733,32],[970765.078068388,18],[970765.159394383,13],[970765.239823687,11],[970765.320691335,15],[970765.406749025,8],[970765.493000195,18],[970765.567987569,25],[970765.648736834,19],[970765.730094625,8],[970765.811205505,40],[970765.892903992,16],[970765.973291848,64],[970766.055883474,6],[970766.136984381,6],[970766.218352234,11],[970766.301208533,15],[970766.385513258,17],[970766.47162375,21],[970766.556139702,14]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-31b73ac3c1456743ce246b926cbf8320","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.00289415,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":5.171638381,"time_to_first_token":0.003482033,"token_sha":"8a91591c94a3","tokens_per_second":49.30739181935853},"seed":1234,"sent":970761.380439948,"speculative":{"acceptance_rate":0.2052910052910053,"accepted":194,"drafted":945,"rounds":63,"tokens_per_round":4.063492063492063},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.004090688889846206,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":194,"drafted":945,"rounds":63},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.548679291962664,"done":970780.524454089,"finish_reason":"length","first":970766.776814695,"full_response_s":13.943265884998254,"last":970780.524424214,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970766.776814695,3],[970766.927654676,11],[970767.110343085,30],[970767.292322843,19],[970767.483710492,21],[970767.666155029,15],[970767.811854905,19],[970767.958133797,17],[970768.110227574,6],[970768.254846942,8],[970768.445726241,3],[970768.616935575,5],[970768.798767096,27],[970768.981790777,12],[970769.165996158,13],[970769.348019997,5],[970769.526966724,16],[970769.712041479,5],[970769.891770223,14],[970770.076201733,9],[970770.223465466,22],[970770.371849309,10],[970770.561972534,7],[970770.748678205,23],[970770.894207026,5],[970771.046334653,9],[970771.216796957,14],[970771.364852132,20],[970771.519708025,8],[970771.669615595,12],[970771.817095463,5],[970771.96659821,14],[970772.150151476,14],[970772.298633054,8],[970772.490203014,13],[970772.663495109,3],[970772.847964082,10],[970772.99409296,11],[970773.17787714,9],[970773.360131047,10],[970773.553784074,20],[970773.724887148,14],[970773.908580366,14],[970774.139405797,13],[970774.327320887,5],[970774.521694056,22],[970774.752727145,3],[970774.987768298,32],[970775.175046177,33],[970775.360853919,11],[970775.551919843,6],[970775.725684421,8],[970775.872364807,9],[970776.022601509,13],[970776.17420851,8],[970776.324441628,20],[970776.481141781,17],[970776.667399905,20],[970776.81617279,13],[970776.990530834,6],[970777.177574678,13],[970777.326172739,9],[970777.481704102,11],[970777.632097077,8],[970777.816506173,14],[970778.003854107,12],[970778.217304078,13],[970778.459219004,23],[970778.613349996,8],[970778.7948259,25],[970778.980574875,18],[970779.130941569,13],[970779.31589625,55],[970779.474599298,11],[970779.660954858,10],[970779.836340897,11],[970779.983821949,15],[970780.135599873,17],[970780.330478902,14],[970780.524424214,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-61c56c9bea18a5bba02d3a198ac1a5dd","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.106143968,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.747481299,"time_to_first_token":0.191065108,"token_sha":"8a91591c94a3","tokens_per_second":18.548852291841186},"seed":1234,"sent":970766.581188204,"speculative":{"acceptance_rate":0.44110275689223055,"accepted":176,"drafted":399,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.19562649098224938,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":399,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":1,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.551394461880935,"done":970780.329849271,"finish_reason":"length","first":970766.58409688,"full_response_s":13.753189918934368,"last":970780.329694308,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970766.58409688,3],[970766.670389412,26],[970766.925530917,15],[970767.111080027,19],[970767.292067563,21],[970767.482019716,15],[970767.664965373,19],[970767.811710727,17],[970767.957965167,6],[970768.106521149,11],[970768.254699723,5],[970768.447090879,18],[970768.615804663,21],[970768.801982466,9],[970768.980885222,9],[970769.168891694,16],[970769.347836533,5],[970769.524197587,10],[970769.709460799,13],[970769.892193621,27],[970770.074888846,11],[970770.22173651,8],[970770.372741646,16],[970770.562555664,9],[970770.748816639,10],[970770.893718692,9],[970771.043784938,20],[970771.215692721,8],[970771.36331096,12],[970771.519097836,5],[970771.66992805,14],[970771.817254155,11],[970771.96651796,7],[970772.153120091,17],[970772.297875486,3],[970772.4892411,10],[970772.664434716,11],[970772.846903564,9],[970772.992535211,10],[970773.177335136,20],[970773.359694784,14],[970773.553414443,14],[970773.724663904,13],[970773.908652487,5],[970774.138740529,14],[970774.328526223,11],[970774.520723054,59],[970774.752901343,6],[970774.988719121,11],[970775.174090697,4],[970775.358887463,10],[970775.554389834,9],[970775.725445127,9],[970775.872270507,12],[970776.022288733,20],[970776.173273849,21],[970776.323280778,16],[970776.480600721,13],[970776.666768514,6],[970776.815557432,12],[970776.992680576,6],[970777.17732239,15],[970777.325748478,8],[970777.481622204,14],[970777.632971155,12],[970777.818535819,26],[970778.003779138,10],[970778.216870087,5],[970778.457319886,3],[970778.610515737,25],[970778.798141099,18],[970778.981290692,13],[970779.131783579,64],[970779.316286923,2],[970779.474814717,10],[970779.659437965,11],[970779.835010587,15],[970779.982126138,17],[970780.136354943,14],[970780.329694308,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-42d2cd00d825b216a1fabdd525a405ec","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":1,"prefill_raised":[],"prefill_seconds":0.002642674,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.747883528,"time_to_first_token":0.003120687,"token_sha":"8a91591c94a3","tokens_per_second":18.548309598393626},"seed":1234,"sent":970766.576659352,"speculative":{"acceptance_rate":0.44221105527638194,"accepted":176,"drafted":398,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.00743752799462527,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":398,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":2,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.547710040017282,"done":970780.524116879,"finish_reason":"length","first":970766.775773058,"full_response_s":13.946789665031247,"last":970780.524100989,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970766.775773058,3],[970766.926150628,11],[970767.110632258,30],[970767.293172792,19],[970767.481557144,21],[970767.665778021,15],[970767.811174946,19],[970767.958057531,17],[970768.108516044,6],[970768.258222588,8],[970768.445418809,3],[970768.618789619,5],[970768.79954854,29],[970768.984266708,10],[970769.169226937,13],[970769.348937809,5],[970769.524053681,16],[970769.709729025,5],[970769.89259844,16],[970770.075146175,7],[970770.222285236,27],[970770.372158228,11],[970770.562379834,8],[970770.748103156,16],[970770.896064526,5],[970771.043405834,9],[970771.215602982,14],[970771.364134809,20],[970771.519945191,8],[970771.668877245,12],[970771.817147245,5],[970771.965511064,14],[970772.151527858,14],[970772.29782524,8],[970772.488051398,13],[970772.665178778,3],[970772.846069522,10],[970772.993901208,11],[970773.177457999,9],[970773.359865526,10],[970773.554347473,20],[970773.724145999,14],[970773.910484927,14],[970774.138896244,13],[970774.328227738,5],[970774.520623505,22],[970774.751070376,3],[970774.986615417,32],[970775.175522541,33],[970775.3618138,11],[970775.552732569,6],[970775.725783265,8],[970775.871862232,9],[970776.022515482,13],[970776.17439679,8],[970776.323412538,20],[970776.482271683,17],[970776.667853738,20],[970776.817430275,13],[970776.989728477,6],[970777.176193336,13],[970777.326500764,9],[970777.48222948,11],[970777.63351143,8],[970777.818995028,15],[970778.004247244,16],[970778.21788383,27],[970778.457243141,4],[970778.612101936,8],[970778.796198727,25],[970778.980096335,18],[970779.12937915,13],[970779.31666009,64],[970779.472926769,2],[970779.660223967,10],[970779.834576261,11],[970779.983639446,15],[970780.136785477,17],[970780.329810466,14],[970780.524100989,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-522b4691cc59a285e902cd12e7bf7651","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.105720506,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.747662363,"time_to_first_token":0.195599944,"token_sha":"8a91591c94a3","tokens_per_second":18.548607993625048},"seed":1234,"sent":970766.577327214,"speculative":{"acceptance_rate":0.41025641025641024,"accepted":176,"drafted":429,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.19844584399834275,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":429,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":3,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.548257875234686,"done":970780.525849991,"finish_reason":"length","first":970766.77561307,"full_response_s":13.945954976021312,"last":970780.523534935,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970766.77561307,3],[970766.926420406,11],[970767.111235999,30],[970767.295896836,19],[970767.482806824,21],[970767.666359231,15],[970767.812636669,19],[970767.957883877,17],[970768.109120585,6],[970768.25753218,8],[970768.446376675,3],[970768.616118831,5],[970768.798692639,27],[970768.98365391,12],[970769.168662513,13],[970769.349830915,5],[970769.526255337,16],[970769.712218014,5],[970769.891854762,14],[970770.075505517,9],[970770.222332282,22],[970770.372933623,10],[970770.563606214,7],[970770.748741221,23],[970770.894922669,5],[970771.045580237,9],[970771.217786123,14],[970771.364796461,20],[970771.520984971,8],[970771.670864665,12],[970771.817623401,5],[970771.966428253,14],[970772.152869436,14],[970772.29753141,8],[970772.488461274,13],[970772.664675546,3],[970772.846023404,10],[970772.994026856,11],[970773.181806245,9],[970773.360427629,10],[970773.555279495,20],[970773.726099541,14],[970773.909901973,14],[970774.139846956,13],[970774.32845119,5],[970774.523677314,22],[970774.753371674,3],[970774.987996086,32],[970775.17746965,33],[970775.359517735,11],[970775.554216868,6],[970775.727440786,8],[970775.873697695,9],[970776.02344267,13],[970776.174314396,8],[970776.323942365,20],[970776.483111517,17],[970776.666888145,20],[970776.81682548,13],[970776.992276781,6],[970777.17768802,13],[970777.326245164,9],[970777.480961737,11],[970777.633071887,8],[970777.817288543,15],[970778.002213182,16],[970778.217552701,27],[970778.458266341,4],[970778.60975673,8],[970778.796106956,25],[970778.980933592,18],[970779.129718056,13],[970779.316997844,64],[970779.473955186,2],[970779.661664515,10],[970779.834674321,11],[970779.98254555,15],[970780.136073868,17],[970780.331157514,14],[970780.523534935,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-8a102b3d1ae1511a70c6d453fb53043f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.105941846,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.747606195,"time_to_first_token":0.193753884,"token_sha":"8a91591c94a3","tokens_per_second":18.548683776870437},"seed":1234,"sent":970766.579895015,"speculative":{"acceptance_rate":0.4230769230769231,"accepted":176,"drafted":416,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1957180550089106,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":416,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":4,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.549641968688114,"done":970780.52299738,"finish_reason":"length","first":970766.776080362,"full_response_s":13.945766641991213,"last":970780.522976417,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970766.776080362,3],[970766.927366735,11],[970767.110120721,30],[970767.295740304,19],[970767.481452299,21],[970767.666888547,15],[970767.812077605,19],[970767.958647638,17],[970768.106629899,6],[970768.255650564,8],[970768.445188092,3],[970768.618338922,5],[970768.799610852,27],[970768.981115011,12],[970769.167458456,13],[970769.347092343,5],[970769.527067105,16],[970769.708844288,5],[970769.891975033,14],[970770.076096216,9],[970770.222168629,22],[970770.371976957,10],[970770.56213177,7],[970770.748886616,23],[970770.895245334,5],[970771.045920825,9],[970771.218574127,14],[970771.364971683,20],[970771.520009263,8],[970771.671173376,12],[970771.81768981,5],[970771.964843268,14],[970772.15339603,14],[970772.299255885,8],[970772.489089977,13],[970772.66152526,3],[970772.84627542,10],[970772.992887384,11],[970773.182420258,9],[970773.361489763,10],[970773.555040809,20],[970773.727377559,14],[970773.910614287,14],[970774.138987216,13],[970774.328883436,5],[970774.521926534,22],[970774.752374396,3],[970774.987853588,32],[970775.17531293,33],[970775.362435046,11],[970775.553910749,6],[970775.724146627,8],[970775.872916684,9],[970776.023515912,13],[970776.173835856,8],[970776.324118115,20],[970776.482573273,17],[970776.667135088,20],[970776.815187354,13],[970776.991533408,6],[970777.176667332,13],[970777.326123901,9],[970777.483696656,11],[970777.631685441,8],[970777.816738154,15],[970778.00365053,16],[970778.218314012,27],[970778.457454271,4],[970778.610126184,8],[970778.797284895,25],[970778.981785666,18],[970779.129996891,13],[970779.318240111,64],[970779.473295583,2],[970779.660453691,10],[970779.835573553,11],[970779.982219349,15],[970780.136969436,17],[970780.33101412,14],[970780.522976417,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-3dc6c6c92157e322d2e74372431901e4","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.105902481,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.747619813,"time_to_first_token":0.193479752,"token_sha":"8a91591c94a3","tokens_per_second":18.548665403073436},"seed":1234,"sent":970766.577230738,"speculative":{"acceptance_rate":0.4230769230769231,"accepted":176,"drafted":416,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.19884962402284145,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":416,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":5,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.54721266485277,"done":970780.524976154,"finish_reason":"length","first":970766.776242878,"full_response_s":13.94043019192759,"last":970780.524939494,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970766.776242878,3],[970766.926062217,11],[970767.112023556,30],[970767.293276597,19],[970767.481830379,21],[970767.666444346,15],[970767.812285504,19],[970767.958198061,17],[970768.107533582,6],[970768.25792303,8],[970768.446898214,3],[970768.617860493,5],[970768.798865189,27],[970768.984643524,12],[970769.166252094,9],[970769.348130683,9],[970769.524838357,16],[970769.709812315,5],[970769.891399584,14],[970770.077571379,9],[970770.224605595,22],[970770.37288344,10],[970770.564049454,7],[970770.749101475,23],[970770.893984486,5],[970771.045129988,9],[970771.217138745,14],[970771.363986198,20],[970771.52079205,8],[970771.668232939,12],[970771.817420512,5],[970771.966169676,14],[970772.151161059,14],[970772.297624462,8],[970772.488332809,13],[970772.66228406,3],[970772.847218275,10],[970772.994271239,11],[970773.180130385,9],[970773.360554269,10],[970773.553140281,20],[970773.72553307,14],[970773.910659781,14],[970774.140432966,13],[970774.328412897,5],[970774.521796709,22],[970774.752964903,3],[970774.986931152,32],[970775.175977078,33],[970775.35897029,11],[970775.552313828,6],[970775.725721865,8],[970775.873070064,9],[970776.025099647,13],[970776.172131658,8],[970776.323706607,20],[970776.482061961,17],[970776.668060884,20],[970776.817495292,13],[970776.992049249,6],[970777.176066264,13],[970777.324876753,9],[970777.481791905,11],[970777.633833215,8],[970777.816340488,14],[970778.001830046,12],[970778.218625203,13],[970778.457530969,23],[970778.61132451,8],[970778.79876284,25],[970778.979835407,18],[970779.130088919,13],[970779.318385537,55],[970779.47450439,11],[970779.661317143,10],[970779.83639268,11],[970779.983946861,15],[970780.136852462,17],[970780.330330339,14],[970780.524939494,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-80b6a85c8457c58441e0505dc475ffb6","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.106275361,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.747245333,"time_to_first_token":0.189821605,"token_sha":"8a91591c94a3","tokens_per_second":18.549170675515434},"seed":1234,"sent":970766.584545962,"speculative":{"acceptance_rate":0.4512820512820513,"accepted":176,"drafted":390,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.19169691600836813,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":390,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":6,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.549811606124976,"done":970780.523866928,"finish_reason":"length","first":970766.777059895,"full_response_s":13.944399743922986,"last":970780.523830235,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970766.777059895,3],[970766.927143507,11],[970767.110830651,30],[970767.293471774,19],[970767.481979983,21],[970767.665434793,15],[970767.811797938,19],[970767.958812699,17],[970768.108750666,6],[970768.256518403,8],[970768.445857025,3],[970768.617039252,5],[970768.799666907,27],[970768.983462238,12],[970769.168608202,9],[970769.347335653,9],[970769.525497337,16],[970769.708411513,5],[970769.892439716,14],[970770.075205703,9],[970770.22151741,22],[970770.372831033,10],[970770.56398919,7],[970770.748969538,23],[970770.896966064,5],[970771.044594288,9],[970771.21903881,14],[970771.363725477,20],[970771.519445624,8],[970771.668522688,12],[970771.816344103,5],[970771.965041597,14],[970772.150680103,14],[970772.297207818,8],[970772.489829783,13],[970772.661918525,3],[970772.84817454,10],[970772.993149369,11],[970773.179448171,9],[970773.361220145,10],[970773.554602001,20],[970773.728388359,14],[970773.90833888,14],[970774.140710697,13],[970774.327477547,5],[970774.520923895,22],[970774.751562134,3],[970774.987622919,32],[970775.175242154,33],[970775.360236593,11],[970775.551728539,6],[970775.725233356,8],[970775.872812943,9],[970776.022821456,13],[970776.173410314,8],[970776.325025701,20],[970776.481744641,17],[970776.666573945,20],[970776.816914067,13],[970776.990666755,6],[970777.178385483,13],[970777.325121951,9],[970777.482438819,11],[970777.631205477,8],[970777.81810074,14],[970778.001969311,12],[970778.218951164,13],[970778.457388791,23],[970778.609964948,8],[970778.795644162,25],[970778.980048057,18],[970779.130802304,13],[970779.316793034,55],[970779.473851269,11],[970779.660718012,10],[970779.834068534,11],[970779.983397288,15],[970780.135334208,17],[970780.329774046,14],[970780.523830235,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-c088d9457532cbd79950213856b56b3f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.106241613,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.747292971,"time_to_first_token":0.190574773,"token_sha":"8a91591c94a3","tokens_per_second":18.54910639774129},"seed":1234,"sent":970766.579467184,"speculative":{"acceptance_rate":0.4489795918367347,"accepted":176,"drafted":392,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.19759271095972508,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":392,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":7,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.549155328668032,"done":970780.523792279,"finish_reason":"length","first":970766.776515537,"full_response_s":13.944647039985284,"last":970780.523772244,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970766.776515537,3],[970766.925744416,11],[970767.10905204,30],[970767.292512548,19],[970767.481650404,21],[970767.664880354,15],[970767.812130588,19],[970767.959185515,17],[970768.107715462,6],[970768.255894356,8],[970768.445506405,3],[970768.619374334,5],[970768.801262278,27],[970768.983011588,12],[970769.168281873,13],[970769.348822835,5],[970769.524319555,16],[970769.708077935,5],[970769.892093736,14],[970770.075085431,9],[970770.221858782,22],[970770.372474796,10],[970770.563743863,7],[970770.749626662,23],[970770.894291453,5],[970771.045215183,9],[970771.218442878,14],[970771.363846068,20],[970771.519328345,8],[970771.670484345,12],[970771.817883386,5],[970771.966332896,14],[970772.149722141,14],[970772.299016302,8],[970772.490035889,13],[970772.663029066,3],[970772.847066224,10],[970772.993774536,11],[970773.182117372,9],[970773.360687117,10],[970773.552077346,20],[970773.7245412,14],[970773.907628006,14],[970774.140216123,13],[970774.328282705,5],[970774.522425877,22],[970774.751697335,3],[970774.985886813,32],[970775.174200038,33],[970775.359026265,11],[970775.552074886,6],[970775.725945654,8],[970775.874080479,9],[970776.02235599,13],[970776.173720833,8],[970776.324975407,20],[970776.482765505,17],[970776.66746969,20],[970776.817705014,13],[970776.990918483,6],[970777.177789777,13],[970777.324734463,9],[970777.482578036,11],[970777.633417755,8],[970777.816099146,14],[970778.003695351,12],[970778.21867633,13],[970778.459336411,23],[970778.611203151,8],[970778.797487881,25],[970778.980683689,18],[970779.131191745,13],[970779.317163384,55],[970779.47509168,11],[970779.660384051,10],[970779.836461248,11],[970779.982642282,15],[970780.134792285,17],[970780.330973027,14],[970780.523772244,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-6c66edc756a9481979b3e701a04c748e","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.106182981,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.747361476,"time_to_first_token":0.190424626,"token_sha":"8a91591c94a3","tokens_per_second":18.549013964983487},"seed":1234,"sent":970766.579145239,"speculative":{"acceptance_rate":0.44110275689223055,"accepted":176,"drafted":399,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.19737029809039086,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":399,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":8,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.548138163047383,"done":970780.523611808,"finish_reason":"length","first":970766.775564696,"full_response_s":13.946549732005224,"last":970780.523575292,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970766.775564696,3],[970766.927427095,11],[970767.109351486,30],[970767.292705868,19],[970767.482076587,21],[970767.665259427,15],[970767.811516238,19],[970767.958478641,17],[970768.108225959,6],[970768.258296342,8],[970768.446080878,3],[970768.618407539,5],[970768.800906793,29],[970768.983927353,10],[970769.167114732,13],[970769.348600214,5],[970769.524745401,16],[970769.710970431,5],[970769.892874683,16],[970770.076476024,7],[970770.222423926,22],[970770.372665636,16],[970770.563336227,8],[970770.747651963,16],[970770.894779531,5],[970771.044428251,9],[970771.215853222,14],[970771.364614118,20],[970771.519169333,8],[970771.669503228,12],[970771.816917216,5],[970771.966813357,14],[970772.151981851,14],[970772.29801736,8],[970772.489309541,13],[970772.664975696,3],[970772.846342677,10],[970772.993724994,11],[970773.180491023,9],[970773.361381845,10],[970773.552411053,20],[970773.728692717,14],[970773.910233919,14],[970774.14004791,13],[970774.330216724,5],[970774.523074566,22],[970774.753158175,3],[970774.987405548,32],[970775.175752122,33],[970775.362347707,11],[970775.551238733,6],[970775.724490638,8],[970775.87396736,9],[970776.022741414,13],[970776.173887622,8],[970776.323640375,20],[970776.483029315,17],[970776.666183464,20],[970776.815670839,13],[970776.989529461,6],[970777.177957174,13],[970777.325598699,9],[970777.483897833,11],[970777.63374586,8],[970777.816610602,15],[970778.004117116,16],[970778.217765623,27],[970778.458895843,4],[970778.613433942,8],[970778.798654859,25],[970778.980258787,18],[970779.130232489,13],[970779.316600882,64],[970779.473712916,2],[970779.661049638,10],[970779.834406,11],[970779.983874788,15],[970780.135413882,17],[970780.330417054,14],[970780.523575292,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-d16836979d623eb165c5190947921dd4","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.105759711,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.747827472,"time_to_first_token":0.195313428,"token_sha":"8a91591c94a3","tokens_per_second":18.54838522809184},"seed":1234,"sent":970766.577062076,"speculative":{"acceptance_rate":0.411214953271028,"accepted":176,"drafted":428,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.19850262010004371,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":428,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":9,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.547603934875706,"done":970780.523969901,"finish_reason":"length","first":970766.775520002,"full_response_s":13.947240364039317,"last":970780.523926583,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970766.775520002,3],[970766.926722157,11],[970767.109982991,30],[970767.295447531,19],[970767.481886115,21],[970767.666799688,15],[970767.81129517,19],[970767.958996883,17],[970768.109829331,6],[970768.255181753,8],[970768.446150247,3],[970768.619735676,5],[970768.799294923,27],[970768.982130724,12],[970769.169300066,13],[970769.349305136,5],[970769.526836579,16],[970769.711028502,5],[970769.893360377,14],[970770.076433619,9],[970770.223643872,22],[970770.373010384,10],[970770.563253305,7],[970770.747210819,23],[970770.89624314,5],[970771.045390517,9],[970771.217887512,14],[970771.364089059,20],[970771.519834825,8],[970771.669350793,12],[970771.817035823,5],[970771.965580369,14],[970772.150884288,14],[970772.297761328,8],[970772.488610989,13],[970772.661762234,3],[970772.845548416,10],[970772.993482467,11],[970773.179043896,9],[970773.361306476,10],[970773.553051966,20],[970773.72768443,14],[970773.910321754,14],[970774.139483134,13],[970774.330332771,5],[970774.523796962,22],[970774.753275934,3],[970774.987558175,32],[970775.176018107,33],[970775.361089084,11],[970775.552624011,6],[970775.727127354,8],[970775.873375974,9],[970776.024007317,13],[970776.172314176,8],[970776.325233823,20],[970776.481842141,17],[970776.666488543,20],[970776.816476636,13],[970776.991249996,6],[970777.178287151,13],[970777.326842551,9],[970777.483228422,11],[970777.632646538,8],[970777.817157022,15],[970778.003051063,16],[970778.217056671,27],[970778.459431014,4],[970778.612368545,8],[970778.795031877,25],[970778.979940092,18],[970779.132524647,13],[970779.318310264,55],[970779.4741017,11],[970779.660671175,10],[970779.835148524,11],[970779.984055514,15],[970780.13509437,17],[970780.330768266,14],[970780.523926583,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-59c2dd8b643481211959702955418103","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.106102971,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.747539658,"time_to_first_token":0.192216695,"token_sha":"8a91591c94a3","tokens_per_second":18.548773551026624},"seed":1234,"sent":970766.576729537,"speculative":{"acceptance_rate":0.4282238442822384,"accepted":176,"drafted":411,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.19879046501591802,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":411,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":10,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.550160163996843,"done":970780.524594779,"finish_reason":"length","first":970766.776767601,"full_response_s":13.945324740023352,"last":970780.523279639,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970766.776767601,3],[970766.92817271,11],[970767.111300375,30],[970767.293822875,19],[970767.483406965,21],[970767.666400261,15],[970767.81162478,19],[970767.958772054,17],[970768.107793824,6],[970768.255853886,8],[970768.445652935,3],[970768.616051142,5],[970768.798401641,27],[970768.983162776,12],[970769.168021375,13],[970769.348075892,5],[970769.526541134,16],[970769.711873234,5],[970769.891251405,14],[970770.076787744,9],[970770.224219562,22],[970770.372235982,10],[970770.562932752,7],[970770.74925191,23],[970770.895804381,5],[970771.04661016,9],[970771.217458321,14],[970771.36322615,20],[970771.518716315,8],[970771.672877512,12],[970771.817739432,5],[970771.966884502,14],[970772.150434951,14],[970772.297461066,8],[970772.489640431,13],[970772.663119861,3],[970772.845729127,10],[970772.994553034,11],[970773.181297028,9],[970773.361096417,10],[970773.552795837,20],[970773.725391724,14],[970773.909338766,14],[970774.140905474,13],[970774.328964262,5],[970774.521397699,22],[970774.751996108,3],[970774.988413563,32],[970775.177176973,33],[970775.359900807,11],[970775.552136014,6],[970775.725527425,8],[970775.872465524,9],[970776.024702829,13],[970776.173762694,8],[970776.324050507,20],[970776.481591134,17],[970776.666981501,20],[970776.815920854,13],[970776.989843916,6],[970777.175727358,13],[970777.326897038,9],[970777.48113123,11],[970777.631950755,8],[970777.817481223,15],[970778.003436967,16],[970778.217367318,27],[970778.458467054,4],[970778.611520951,8],[970778.795547718,25],[970778.980414519,18],[970779.129494429,13],[970779.316415979,55],[970779.47585896,11],[970779.660913685,10],[970779.835977524,11],[970779.983335296,15],[970780.13565748,17],[970780.329884315,14],[970780.523279639,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-392092b731a5dc213314b50a35694546","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.105984075,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.747520089,"time_to_first_token":0.192336935,"token_sha":"8a91591c94a3","tokens_per_second":18.54879995440318},"seed":1234,"sent":970766.579270039,"speculative":{"acceptance_rate":0.4251207729468599,"accepted":176,"drafted":414,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.19749756203964353,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":414,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":11,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.548815179301954,"done":970780.523219887,"finish_reason":"length","first":970766.775675094,"full_response_s":13.94385854108259,"last":970780.523183899,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970766.775675094,3],[970766.926283621,11],[970767.112803991,30],[970767.294788966,19],[970767.481952283,21],[970767.665918823,15],[970767.812700069,19],[970767.957607154,17],[970768.107188386,6],[970768.256388098,8],[970768.445603249,3],[970768.616294773,5],[970768.798556765,27],[970768.982443564,12],[970769.164943592,13],[970769.34875649,5],[970769.525682448,16],[970769.708360355,5],[970769.89215432,14],[970770.078129882,9],[970770.224820166,22],[970770.371719708,10],[970770.562994616,7],[970770.74843443,23],[970770.895556861,5],[970771.04405542,9],[970771.216725716,14],[970771.363784076,20],[970771.519245198,8],[970771.672535917,12],[970771.81781997,5],[970771.965368854,14],[970772.1517624,14],[970772.298172292,8],[970772.489561749,13],[970772.661657644,3],[970772.846206371,10],[970772.993838976,11],[970773.177988818,9],[970773.361865938,10],[970773.554694925,20],[970773.725938305,14],[970773.909400342,14],[970774.139228606,13],[970774.329838437,5],[970774.52107649,22],[970774.752551426,3],[970774.986517084,32],[970775.176954753,33],[970775.361162214,11],[970775.551820966,6],[970775.724838506,8],[970775.874913479,9],[970776.023332337,13],[970776.172496167,8],[970776.323567134,20],[970776.482937207,17],[970776.667173445,20],[970776.81578991,13],[970776.991116348,6],[970777.176801061,13],[970777.325982651,9],[970777.483128953,11],[970777.632815455,8],[970777.815893712,15],[970778.003176534,16],[970778.216665342,27],[970778.460621659,4],[970778.611584031,8],[970778.796893438,25],[970778.979367204,18],[970779.130873961,13],[970779.315401052,55],[970779.47432248,11],[970779.659774087,10],[970779.836116053,11],[970779.983211377,15],[970780.135155434,17],[970780.330709218,14],[970780.523183899,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-eaf5c181996ada2f4becd6efaec7209a","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.106025601,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.747495269,"time_to_first_token":0.192375659,"token_sha":"8a91591c94a3","tokens_per_second":18.54883344277367},"seed":1234,"sent":970766.579361346,"speculative":{"acceptance_rate":0.4261501210653753,"accepted":176,"drafted":413,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.19631374801974744,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":413,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":12,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.547798639159893,"done":970780.524282916,"finish_reason":"length","first":970766.775992846,"full_response_s":13.946593608008698,"last":970780.524255104,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970766.775992846,3],[970766.92594681,11],[970767.111689945,30],[970767.295132642,19],[970767.482147572,21],[970767.665964653,15],[970767.812449397,19],[970767.958937771,17],[970768.109481367,6],[970768.257172006,8],[970768.446008661,3],[970768.617746206,5],[970768.799944414,27],[970768.982532807,12],[970769.168352618,13],[970769.349543983,5],[970769.524901277,16],[970769.709259205,5],[970769.89365323,14],[970770.074785361,9],[970770.224522112,22],[970770.372588395,10],[970770.563812336,7],[970770.749169372,23],[970770.895430861,5],[970771.045829085,9],[970771.218095986,14],[970771.363154925,20],[970771.518816264,8],[970771.670533791,12],[970771.816764477,5],[970771.965825536,14],[970772.151868765,14],[970772.298800147,8],[970772.490158352,13],[970772.663937005,3],[970772.847147626,10],[970772.994339439,11],[970773.179925207,9],[970773.361713839,10],[970773.553695151,20],[970773.726924382,14],[970773.909151046,14],[970774.141143504,13],[970774.327744669,5],[970774.52037189,22],[970774.751624382,3],[970774.986980775,32],[970775.175807793,33],[970775.359966831,11],[970775.552383341,6],[970775.724971723,8],[970775.871983991,9],[970776.024526807,13],[970776.173160955,8],[970776.324314252,20],[970776.481492785,17],[970776.667219195,20],[970776.816364846,13],[970776.98904884,6],[970777.178156831,13],[970777.325908594,9],[970777.481250509,11],[970777.631883786,8],[970777.819230738,15],[970778.003121456,16],[970778.218181052,27],[970778.460062277,4],[970778.610427982,8],[970778.795312793,25],[970778.981057495,18],[970779.131471732,13],[970779.316508599,55],[970779.475552233,11],[970779.659989794,10],[970779.834803345,11],[970779.982288014,15],[970780.137068697,17],[970780.329960197,14],[970780.524255104,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-da9d54cfbe1eba6e1fb2aeeccdb5c5a9","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.106064326,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.747496533,"time_to_first_token":0.191799426,"token_sha":"8a91591c94a3","tokens_per_second":18.548831737319485},"seed":1234,"sent":970766.577689308,"speculative":{"acceptance_rate":0.4282238442822384,"accepted":176,"drafted":411,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.19830353802535683,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":411,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":13,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.551330149730642,"done":970780.522931339,"finish_reason":"length","first":970766.777126191,"full_response_s":13.945525794988498,"last":970780.522771271,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970766.777126191,3],[970766.927897939,11],[970767.112417494,30],[970767.294303848,19],[970767.483233967,21],[970767.665862704,15],[970767.812747275,19],[970767.957778471,17],[970768.107964021,6],[970768.25665202,8],[970768.446648966,3],[970768.620153505,5],[970768.802232786,27],[970768.983260132,12],[970769.165596731,13],[970769.348880362,5],[970769.525299888,16],[970769.707860963,5],[970769.893113097,14],[970770.075362699,9],[970770.222660852,22],[970770.372795173,16],[970770.563674574,8],[970770.746872792,16],[970770.894523898,5],[970771.04353369,9],[970771.216562383,14],[970771.364545373,20],[970771.518585547,8],[970771.669074486,12],[970771.816590567,5],[970771.966556989,14],[970772.152509886,14],[970772.297394865,8],[970772.489145136,13],[970772.66428068,3],[970772.847727236,10],[970772.993372005,11],[970773.178522022,9],[970773.359812799,10],[970773.55296141,20],[970773.725104904,14],[970773.908497268,14],[970774.141372589,13],[970774.326972267,5],[970774.520068731,22],[970774.751886863,3],[970774.988308414,32],[970775.174276512,33],[970775.360030103,11],[970775.553205413,6],[970775.726836198,8],[970775.873315951,9],[970776.022900394,13],[970776.172981092,8],[970776.322972739,20],[970776.48073173,17],[970776.666266691,20],[970776.81604575,13],[970776.990054614,6],[970777.176895633,13],[970777.32664035,9],[970777.481535905,11],[970777.631758827,8],[970777.819517462,15],[970778.002098496,16],[970778.217236053,27],[970778.45864874,4],[970778.609871929,8],[970778.79604458,25],[970778.979262263,18],[970779.130347527,13],[970779.317858975,64],[970779.4730777,2],[970779.660072604,10],[970779.834963061,11],[970779.983568318,15],[970780.136241937,17],[970780.329748379,14],[970780.522771271,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-98c0fed994eae6df2c9d2c21f076a900","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.105823366,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.747558462,"time_to_first_token":0.194679634,"token_sha":"8a91591c94a3","tokens_per_second":18.548748179893355},"seed":1234,"sent":970766.577405544,"speculative":{"acceptance_rate":0.4200477326968974,"accepted":176,"drafted":419,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.19972064695321023,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":419,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":14,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.55008378562133,"done":970780.52481495,"finish_reason":"length","first":970766.776153555,"full_response_s":13.947972917929292,"last":970780.522722193,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970766.776153555,3],[970766.927036437,11],[970767.110233423,30],[970767.294664807,19],[970767.482269668,21],[970767.66450437,15],[970767.812932146,19],[970767.957360402,17],[970768.110552751,6],[970768.255074395,8],[970768.444991715,3],[970768.616826393,5],[970768.799415227,27],[970768.981190941,12],[970769.165220859,13],[970769.348497881,5],[970769.523887068,16],[970769.710271734,5],[970769.892938051,14],[970770.076013277,9],[970770.223207353,22],[970770.372066936,10],[970770.564099268,7],[970770.748244422,23],[970770.896510342,5],[970771.044729378,9],[970771.216213267,14],[970771.364448785,20],[970771.51952925,8],[970771.671552864,12],[970771.816108634,5],[970771.966386599,14],[970772.150817656,14],[970772.297050086,8],[970772.487922693,13],[970772.665253635,3],[970772.845044769,10],[970772.994824829,11],[970773.181550852,9],[970773.360190943,10],[970773.554035114,20],[970773.723933652,14],[970773.908760629,14],[970774.13995777,13],[970774.327882142,5],[970774.520820698,22],[970774.752192965,3],[970774.986679537,32],[970775.176550158,33],[970775.360687594,11],[970775.553603127,6],[970775.726411952,8],[970775.874999506,9],[970776.023879573,13],[970776.173491556,8],[970776.32439303,20],[970776.480945517,17],[970776.666828121,20],[970776.817370604,13],[970776.989967531,6],[970777.17701736,13],[970777.326711703,9],[970777.483018635,11],[970777.631446675,8],[970777.817531853,15],[970778.00264482,16],[970778.217930892,27],[970778.457601601,4],[970778.610695664,8],[970778.79804299,25],[970778.981858267,18],[970779.132119381,13],[970779.317436059,64],[970779.475034681,2],[970779.659516294,10],[970779.834892748,11],[970779.983491108,15],[970780.134927005,17],[970780.330090213,14],[970780.522722193,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-4592a8188fdb00766181712067980dee","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.105863228,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.747518392,"time_to_first_token":0.193698149,"token_sha":"8a91591c94a3","tokens_per_second":18.54880224407559},"seed":1234,"sent":970766.576842032,"speculative":{"acceptance_rate":0.4200477326968974,"accepted":176,"drafted":419,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1993115229997784,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":419,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":15,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.551188411554012,"done":970780.522664234,"finish_reason":"length","first":970766.776873935,"full_response_s":13.946106494986452,"last":970780.522624037,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970766.776873935,3],[970766.925815257,11],[970767.109637027,30],[970767.293949275,19],[970767.481797207,21],[970767.665663143,15],[970767.81190984,19],[970767.958699373,17],[970768.107590358,6],[970768.255798375,8],[970768.445932843,3],[970768.61756756,5],[970768.800438205,29],[970768.981038633,10],[970769.168112107,13],[970769.347713446,5],[970769.525943074,16],[970769.707663946,5],[970769.892694916,16],[970770.076256668,7],[970770.222920181,27],[970770.372286852,11],[970770.563414781,8],[970770.747399739,16],[970770.895622438,5],[970771.044347377,9],[970771.218904488,14],[970771.364387673,20],[970771.51965205,8],[970771.669166786,12],[970771.81737777,5],[970771.966745189,14],[970772.150742078,14],[970772.298239628,8],[970772.48821401,13],[970772.662660443,3],[970772.846591188,10],[970772.99298298,11],[970773.178447708,9],[970773.361551707,10],[970773.555505652,20],[970773.726497784,14],[970773.909821451,14],[970774.138847134,13],[970774.327097707,5],[970774.5234024,22],[970774.752475977,3],[970774.986394605,32],[970775.176122552,33],[970775.361582186,11],[970775.551463705,6],[970775.72535774,8],[970775.872760249,9],[970776.022197074,13],[970776.172601781,8],[970776.323514887,20],[970776.481253939,17],[970776.666413109,23],[970776.816988588,12],[970776.9904145,16],[970777.175851902,6],[970777.326081672,15],[970777.483975411,5],[970777.632349221,7],[970777.817823666,22],[970778.002898756,26],[970778.218741778,10],[970778.459732732,5],[970778.612898772,3],[970778.795427751,25],[970778.979433516,18],[970779.130446372,13],[970779.315670926,64],[970779.474030379,2],[970779.65919467,10],[970779.835721252,11],[970779.982932942,15],[970780.135505382,17],[970780.330827457,14],[970780.522624037,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-f536bc34cc99104412462d2673ab404d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":1,"prefill_raised":[],"prefill_seconds":0.105682004,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.747570032,"time_to_first_token":0.195970215,"token_sha":"8a91591c94a3","tokens_per_second":18.548732569206088},"seed":1234,"sent":970766.576557739,"speculative":{"acceptance_rate":0.4074074074074074,"accepted":176,"drafted":432,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.20031619595829397,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":432,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.53125644267429,"done":970794.434512801,"finish_reason":"length","first":970780.673931646,"full_response_s":13.887366777053103,"last":970794.434466491,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970780.673931646,3],[970780.825665385,11],[970781.008626694,30],[970781.193082908,19],[970781.376240384,21],[970781.564328363,15],[970781.712905006,19],[970781.861943582,17],[970782.010780544,6],[970782.160501103,8],[970782.343172878,3],[970782.522183621,5],[970782.710517619,27],[970782.891659617,12],[970783.077702712,13],[970783.257803998,5],[970783.432843184,16],[970783.619173371,5],[970783.802667318,14],[970783.986117108,9],[970784.135369957,22],[970784.280572033,10],[970784.474238558,7],[970784.659557697,23],[970784.807684663,5],[970784.956236673,9],[970785.132831988,14],[970785.279213681,20],[970785.431781786,8],[970785.586229868,12],[970785.73304691,5],[970785.882110903,14],[970786.065080804,14],[970786.214499719,8],[970786.40215031,13],[970786.579021091,3],[970786.764633383,10],[970786.910978839,11],[970787.093326479,9],[970787.278537543,10],[970787.469318878,20],[970787.643760168,14],[970787.828815737,14],[970788.058721438,13],[970788.245875948,5],[970788.435104904,22],[970788.670088173,3],[970788.903864473,32],[970789.091687918,33],[970789.276474447,11],[970789.467498398,6],[970789.642930883,8],[970789.788946719,9],[970789.939196038,13],[970790.090259388,8],[970790.237983688,20],[970790.390608701,17],[970790.578362,20],[970790.729298694,13],[970790.901671529,6],[970791.089761195,13],[970791.238895507,9],[970791.390710322,11],[970791.545236045,8],[970791.730088004,15],[970791.91582107,16],[970792.132799452,27],[970792.365800028,4],[970792.524416472,8],[970792.710609609,25],[970792.895035711,18],[970793.044611242,13],[970793.230899053,64],[970793.381234388,2],[970793.573892959,10],[970793.749386143,11],[970793.895574731,15],[970794.047598606,17],[970794.242799732,14],[970794.434466491,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-13d043a07a101ca583ce9e0940a4480d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034386097,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.760261084,"time_to_first_token":0.124377579,"token_sha":"8a91591c94a3","tokens_per_second":18.531625122760644},"seed":1234,"sent":970780.547146024,"speculative":{"acceptance_rate":0.4230769230769231,"accepted":176,"drafted":416,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12678562209475785,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":416,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.532462079325768,"done":970794.43353401,"finish_reason":"length","first":970780.673848452,"full_response_s":13.886292773997411,"last":970794.4334881,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970780.673848452,3],[970780.825769174,11],[970781.010547797,30],[970781.194308532,19],[970781.375175324,21],[970781.567120502,15],[970781.713634776,19],[970781.862992065,17],[970782.010354315,6],[970782.16011832,8],[970782.345406515,3],[970782.52634153,5],[970782.708428143,27],[970782.891269777,12],[970783.076180219,13],[970783.258397512,5],[970783.433716733,16],[970783.618289598,5],[970783.801615188,14],[970783.986220545,9],[970784.13401587,22],[970784.281304796,10],[970784.474030148,7],[970784.658904496,23],[970784.80664151,5],[970784.957448919,9],[970785.134117699,14],[970785.279771958,20],[970785.432721342,8],[970785.585576555,12],[970785.732477128,5],[970785.881242971,14],[970786.065799229,14],[970786.213225722,8],[970786.40188066,13],[970786.578514436,3],[970786.762220605,10],[970786.912554057,11],[970787.094287813,9],[970787.279588729,10],[970787.470635152,20],[970787.645406419,14],[970787.828654613,14],[970788.05848136,13],[970788.245117566,5],[970788.434198553,22],[970788.66942534,3],[970788.903731064,32],[970789.09087249,33],[970789.276838428,11],[970789.467178711,6],[970789.642245615,8],[970789.790694486,9],[970789.93840807,13],[970790.089521617,8],[970790.238487142,20],[970790.390719386,17],[970790.579803552,20],[970790.729037574,13],[970790.902147283,6],[970791.089570388,13],[970791.238967356,9],[970791.390395724,11],[970791.547499922,8],[970791.730676507,15],[970791.915484981,16],[970792.130494994,27],[970792.365118537,4],[970792.52784249,8],[970792.711588976,25],[970792.896019255,18],[970793.04467413,13],[970793.231362245,64],[970793.380775084,2],[970793.575174635,10],[970793.749236781,11],[970793.897848895,15],[970794.046463748,17],[970794.24270468,14],[970794.4334881,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-5c83606e950c388ff9b7f87337bf2762","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034311592,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.759477181,"time_to_first_token":0.124437889,"token_sha":"8a91591c94a3","tokens_per_second":18.532680903902435},"seed":1234,"sent":970780.547241236,"speculative":{"acceptance_rate":0.4200477326968974,"accepted":176,"drafted":419,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12660721607971936,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":419,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.53124550206469,"done":970794.435966257,"finish_reason":"length","first":970780.675343215,"full_response_s":13.887239763978869,"last":970794.435886184,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970780.675343215,3],[970780.826301625,11],[970781.011142463,30],[970781.193987036,19],[970781.374214116,21],[970781.564837562,15],[970781.713684767,19],[970781.861690831,17],[970782.010540402,6],[970782.159331374,8],[970782.343851042,3],[970782.522860841,5],[970782.709308045,27],[970782.893882965,12],[970783.076510756,13],[970783.259321275,5],[970783.432929931,16],[970783.619847087,5],[970783.801552092,14],[970783.985982563,9],[970784.134542031,22],[970784.281675642,10],[970784.47359067,7],[970784.658520481,23],[970784.80699333,5],[970784.95780045,9],[970785.131679174,14],[970785.279677242,20],[970785.431960464,8],[970785.585913669,12],[970785.732691027,5],[970785.88233261,14],[970786.064695013,14],[970786.21379344,8],[970786.400332566,13],[970786.578023624,3],[970786.763575044,10],[970786.909799654,11],[970787.0942412,9],[970787.280940687,10],[970787.46979468,20],[970787.645120415,14],[970787.827580177,14],[970788.059235597,13],[970788.24560025,5],[970788.434549924,22],[970788.669027291,3],[970788.904625574,32],[970789.091746342,33],[970789.276270678,11],[970789.466208032,6],[970789.641314781,8],[970789.78991239,9],[970789.939348953,13],[970790.089655298,8],[970790.238253209,20],[970790.390095966,17],[970790.579209608,20],[970790.728963645,13],[970790.901867521,6],[970791.088692424,13],[970791.23959652,9],[970791.391079519,11],[970791.547687369,8],[970791.729870489,14],[970791.914828325,12],[970792.131436069,13],[970792.364413587,23],[970792.526659562,8],[970792.710191766,25],[970792.895820191,18],[970793.044467657,13],[970793.231883749,55],[970793.380502651,11],[970793.575462302,10],[970793.750884054,11],[970793.897508982,15],[970794.045956199,17],[970794.243878759,14],[970794.435886184,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-5980db7cf08e5bb41226962a5f6a152f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034593851,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.762045669,"time_to_first_token":0.123866443,"token_sha":"8a91591c94a3","tokens_per_second":18.52922204541189},"seed":1234,"sent":970780.548726493,"speculative":{"acceptance_rate":0.44110275689223055,"accepted":176,"drafted":399,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12661672197282314,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":399,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.53129530424419,"done":970794.436121796,"finish_reason":"length","first":970780.675428281,"full_response_s":13.88840766903013,"last":970794.435934269,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970780.675428281,3],[970780.825988898,11],[970781.008460513,30],[970781.194055845,19],[970781.374715282,21],[970781.565922305,15],[970781.713386298,19],[970781.861789499,17],[970782.010253486,6],[970782.15968553,8],[970782.344780725,3],[970782.521328571,5],[970782.707410209,27],[970782.89145764,12],[970783.076815594,13],[970783.258338193,5],[970783.433193404,16],[970783.617783279,5],[970783.802500897,14],[970783.9863412,9],[970784.134664846,22],[970784.281971598,10],[970784.474617981,7],[970784.660053743,23],[970784.807609134,5],[970784.957137696,9],[970785.132248764,14],[970785.278989701,20],[970785.432350241,8],[970785.586434885,12],[970785.733296333,5],[970785.879683899,14],[970786.064083065,14],[970786.213376796,8],[970786.401096468,13],[970786.579277443,3],[970786.762514113,10],[970786.909954137,11],[970787.09479474,9],[970787.281463072,10],[970787.469853456,20],[970787.643101239,14],[970787.828115843,14],[970788.05899888,13],[970788.241731582,5],[970788.434936163,22],[970788.670527763,3],[970788.904938316,32],[970789.090479562,33],[970789.277187399,11],[970789.466466447,6],[970789.642300454,8],[970789.790015411,9],[970789.938722924,13],[970790.088934889,8],[970790.238591955,20],[970790.390270451,17],[970790.579857047,20],[970790.728249333,13],[970790.901941258,6],[970791.088886096,13],[970791.238602127,9],[970791.389880717,11],[970791.54646858,8],[970791.73182292,14],[970791.915421549,12],[970792.134062022,13],[970792.366580827,23],[970792.525884075,8],[970792.710311716,25],[970792.896062668,18],[970793.044970566,13],[970793.231220916,55],[970793.380673408,11],[970793.57431229,10],[970793.748522294,11],[970793.895726733,15],[970794.047140855,17],[970794.242031702,14],[970794.435934269,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-a69bf13733da05ee355e13ab14728462","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.03463048,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.762057142,"time_to_first_token":0.123671474,"token_sha":"8a91591c94a3","tokens_per_second":18.529206598174436},"seed":1234,"sent":970780.547714127,"speculative":{"acceptance_rate":0.44110275689223055,"accepted":176,"drafted":399,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1277141539612785,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":399,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.533195008120572,"done":970794.434193674,"finish_reason":"length","first":970780.675037656,"full_response_s":13.886858507059515,"last":970794.434133154,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970780.675037656,3],[970780.826080509,11],[970781.008327904,30],[970781.194857497,19],[970781.374306687,21],[970781.564474941,15],[970781.71276734,19],[970781.862770981,17],[970782.010424228,6],[970782.159745569,8],[970782.345116095,3],[970782.52177005,5],[970782.706990605,27],[970782.892261948,12],[970783.078325782,13],[970783.25901298,5],[970783.432270777,16],[970783.619633956,5],[970783.802576123,14],[970783.987251456,9],[970784.134369593,22],[970784.280798429,10],[970784.473488737,7],[970784.661074557,23],[970784.806747891,5],[970784.960267779,9],[970785.132173315,14],[970785.278924893,20],[970785.433032197,8],[970785.585406646,12],[970785.732542048,5],[970785.882269162,14],[970786.065171615,14],[970786.211765989,8],[970786.401443919,13],[970786.580487672,3],[970786.763397646,10],[970786.909760609,11],[970787.095899084,9],[970787.280426208,10],[970787.469607713,20],[970787.644121877,14],[970787.829435685,14],[970788.058942297,13],[970788.245542403,5],[970788.435045601,22],[970788.669623764,3],[970788.904251176,32],[970789.090982216,33],[970789.275622343,11],[970789.466908438,6],[970789.641632692,8],[970789.790495949,9],[970789.938833578,13],[970790.089071466,8],[970790.237580375,20],[970790.389477106,17],[970790.579318981,20],[970790.728868017,13],[970790.902666418,6],[970791.090170029,13],[970791.23919604,9],[970791.391374339,11],[970791.546828608,8],[970791.730725746,15],[970791.915940253,16],[970792.132265514,27],[970792.365187681,4],[970792.526433854,8],[970792.709294808,25],[970792.894644719,18],[970793.045690798,13],[970793.232618382,55],[970793.380092489,11],[970793.574551903,10],[970793.749923809,11],[970793.897076578,15],[970794.046054915,17],[970794.242747629,14],[970794.434133154,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-8aa529320353fe8df0e295af204b2b52","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034483037,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.760274782,"time_to_first_token":0.12408071,"token_sha":"8a91591c94a3","tokens_per_second":18.53160667500397},"seed":1234,"sent":970780.547335167,"speculative":{"acceptance_rate":0.4261501210653753,"accepted":176,"drafted":413,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12770248902961612,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":413,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.53235727168892,"done":970794.433899078,"finish_reason":"length","first":970780.674152698,"full_response_s":13.885992638999596,"last":970794.433870162,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970780.674152698,3],[970780.825016185,11],[970781.008982674,30],[970781.193220845,19],[970781.375615826,21],[970781.566279326,15],[970781.714924889,19],[970781.86267881,17],[970782.010968679,6],[970782.160424006,8],[970782.344157768,3],[970782.525163895,5],[970782.708569105,27],[970782.892782972,12],[970783.075566111,13],[970783.258587247,5],[970783.432546524,16],[970783.619305996,5],[970783.800848292,14],[970783.98692356,9],[970784.134185667,22],[970784.281749283,16],[970784.475267869,8],[970784.66147283,16],[970784.807162567,5],[970784.959646422,9],[970785.131361342,14],[970785.279622595,20],[970785.432882338,8],[970785.585146374,12],[970785.731750958,5],[970785.882503815,14],[970786.064943187,14],[970786.212794724,8],[970786.4017184,13],[970786.576773614,3],[970786.762797652,10],[970786.912137446,11],[970787.095243851,9],[970787.27980746,10],[970787.471418528,20],[970787.644996368,14],[970787.82924819,14],[970788.058584957,13],[970788.242104332,5],[970788.435867318,22],[970788.670056169,3],[970788.905092767,32],[970789.091251465,33],[970789.276034089,11],[970789.467061112,6],[970789.642751261,8],[970789.79045284,9],[970789.93954152,13],[970790.089403411,8],[970790.239320828,20],[970790.390658659,17],[970790.579075959,20],[970790.728594287,13],[970790.902316248,6],[970791.090265385,13],[970791.239482939,9],[970791.391677673,11],[970791.546686046,8],[970791.731925732,15],[970791.915764295,16],[970792.133105201,27],[970792.364567094,4],[970792.527362863,8],[970792.711692349,25],[970792.894124256,18],[970793.04505648,13],[970793.230986199,64],[970793.381076369,2],[970793.57498202,10],[970793.748254549,11],[970793.896611577,15],[970794.047924582,17],[970794.243429616,14],[970794.433870162,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-98e1c4f5805fc8cd2cb26aa8922d048c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034275523,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.759449338,"time_to_first_token":0.12491739,"token_sha":"8a91591c94a3","tokens_per_second":18.532718405798168},"seed":1234,"sent":970780.547906439,"speculative":{"acceptance_rate":0.4200477326968974,"accepted":176,"drafted":419,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12624625896569341,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":419,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.529954738298752,"done":970794.436103922,"finish_reason":"length","first":970780.67456723,"full_response_s":13.88812193798367,"last":970794.436068734,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970780.67456723,3],[970780.825389175,11],[970781.009640916,30],[970781.192253477,19],[970781.375324862,21],[970781.564639537,15],[970781.715533845,19],[970781.863545734,17],[970782.01139054,6],[970782.160599067,8],[970782.343578912,3],[970782.526248398,5],[970782.709012104,27],[970782.892864247,12],[970783.075365174,13],[970783.260436693,5],[970783.432763254,16],[970783.619776118,5],[970783.802023654,14],[970783.987609517,9],[970784.135468193,22],[970784.281204399,10],[970784.474297125,7],[970784.66043627,23],[970784.806490531,5],[970784.959263687,9],[970785.132538784,14],[970785.279801369,20],[970785.432436715,8],[970785.587397292,12],[970785.731929956,5],[970785.883092192,14],[970786.066313148,14],[970786.212020341,8],[970786.401801499,13],[970786.578764803,3],[970786.760849764,10],[970786.911347044,11],[970787.094057785,9],[970787.282013155,10],[970787.469982271,20],[970787.64423453,14],[970787.828423993,14],[970788.059557333,13],[970788.243863796,5],[970788.435369513,22],[970788.668920398,3],[970788.903672945,32],[970789.090603337,33],[970789.275931549,11],[970789.466509701,6],[970789.642042054,8],[970789.789573788,9],[970789.938502881,13],[970790.089990491,8],[970790.238549517,20],[970790.390356654,17],[970790.579634716,20],[970790.728685003,13],[970790.902188888,6],[970791.088566617,13],[970791.23909894,9],[970791.391864335,11],[970791.547097489,8],[970791.731260131,15],[970791.916687336,16],[970792.131721448,27],[970792.365620358,4],[970792.526566526,8],[970792.710968228,25],[970792.894313255,18],[970793.046666356,13],[970793.232213613,55],[970793.381480114,11],[970793.575520805,10],[970793.748330319,11],[970793.897650983,15],[970794.047503795,17],[970794.242165382,14],[970794.436068734,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-1de886124ba49a0fa162a685b79e5fdf","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034555943,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.762048549,"time_to_first_token":0.123718088,"token_sha":"8a91591c94a3","tokens_per_second":18.529218167779916},"seed":1234,"sent":970780.547981984,"speculative":{"acceptance_rate":0.4282238442822384,"accepted":176,"drafted":411,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12658524606376886,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":411,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.532124298123886,"done":970794.435120987,"finish_reason":"length","first":970780.675121955,"full_response_s":13.886961461044848,"last":970794.435012397,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970780.675121955,3],[970780.825170892,11],[970781.008137433,30],[970781.192707773,19],[970781.374975955,21],[970781.564916292,15],[970781.713341092,19],[970781.862585326,17],[970782.011813392,6],[970782.160039478,8],[970782.345806021,3],[970782.523053185,5],[970782.710292967,27],[970782.890117618,12],[970783.07802576,13],[970783.259593404,5],[970783.432679132,16],[970783.618543325,5],[970783.803942564,14],[970783.988015567,9],[970784.135287387,22],[970784.282380401,10],[970784.473906341,7],[970784.660602371,23],[970784.807380162,5],[970784.957723913,9],[970785.134503203,14],[970785.27984051,20],[970785.432034009,8],[970785.587072404,12],[970785.731839193,5],[970785.880925284,14],[970786.065564576,14],[970786.214622102,8],[970786.401012457,13],[970786.580036976,3],[970786.763073478,10],[970786.911650394,11],[970787.094402723,9],[970787.279406914,10],[970787.469931721,20],[970787.643615462,14],[970787.82898571,14],[970788.058399238,13],[970788.242675218,5],[970788.435136284,22],[970788.669680667,3],[970788.903783871,32],[970789.091053121,33],[970789.276324797,11],[970789.467110734,6],[970789.64066979,8],[970789.78913319,9],[970789.93981549,13],[970790.090918428,8],[970790.239883969,20],[970790.389925689,17],[970790.58009122,20],[970790.72918876,13],[970790.901831148,6],[970791.09057475,13],[970791.23935137,9],[970791.390667965,11],[970791.547313963,8],[970791.732728822,15],[970791.916467837,16],[970792.13331129,27],[970792.364501182,4],[970792.526342147,8],[970792.71222507,25],[970792.894231037,18],[970793.046405429,13],[970793.231127433,55],[970793.380829475,11],[970793.576291699,10],[970793.748582797,11],[970793.897006729,15],[970794.046649163,17],[970794.243042417,14],[970794.435012397,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-aee37f6838dddea960aa1ed2b218e718","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.03451981,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.761224673,"time_to_first_token":0.124176497,"token_sha":"8a91591c94a3","tokens_per_second":18.53032750059803},"seed":1234,"sent":970780.548159526,"speculative":{"acceptance_rate":0.4282238442822384,"accepted":176,"drafted":411,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12696242902893573,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":411,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.53525216170871,"done":970794.433181167,"finish_reason":"length","first":970780.675579772,"full_response_s":13.885781880002469,"last":970794.433148203,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970780.675579772,3],[970780.827326376,11],[970781.010052887,30],[970781.192450237,19],[970781.375750659,21],[970781.5656239,15],[970781.715044264,19],[970781.861264554,17],[970782.010585768,6],[970782.159588942,8],[970782.343048814,3],[970782.524564941,5],[970782.708271132,29],[970782.89110198,10],[970783.075919787,13],[970783.258213409,5],[970783.433367121,16],[970783.620536212,5],[970783.803900335,16],[970783.986303403,7],[970784.133763742,22],[970784.28083653,16],[970784.474161284,8],[970784.65841626,16],[970784.80638359,5],[970784.956659797,9],[970785.13150536,14],[970785.280038743,20],[970785.431627111,8],[970785.585313659,12],[970785.733416988,5],[970785.883264277,14],[970786.065399211,14],[970786.214555566,8],[970786.40241135,13],[970786.579724762,3],[970786.760603894,10],[970786.909271381,11],[970787.094873581,9],[970787.27790625,10],[970787.471158864,20],[970787.643014764,14],[970787.827439312,14],[970788.057548542,13],[970788.245664081,5],[970788.435174513,22],[970788.668778492,3],[970788.903570309,32],[970789.091466531,33],[970789.275689263,11],[970789.466118261,6],[970789.641854799,8],[970789.789398983,9],[970789.937735891,13],[970790.088817419,8],[970790.238818478,20],[970790.390799188,17],[970790.578937158,20],[970790.729385424,13],[970790.902234109,6],[970791.089106571,13],[970791.238295001,9],[970791.39047775,11],[970791.545722873,8],[970791.731037352,15],[970791.914620556,16],[970792.130870432,27],[970792.365412861,4],[970792.527646754,8],[970792.710433267,25],[970792.894911104,18],[970793.044553475,13],[970793.231295165,64],[970793.38152436,2],[970793.576076137,10],[970793.749472378,11],[970793.896525278,15],[970794.047731215,17],[970794.241962558,14],[970794.433148203,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-1180adfdd7c048df067f35804c643ace","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.03423763,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.75943668,"time_to_first_token":0.125001432,"token_sha":"8a91591c94a3","tokens_per_second":18.53273545498085},"seed":1234,"sent":970780.547399287,"speculative":{"acceptance_rate":0.411214953271028,"accepted":176,"drafted":428,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1281804849859327,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":428,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.52806696111551,"done":970794.437358315,"finish_reason":"length","first":970780.674284378,"full_response_s":13.889879866037518,"last":970794.437188006,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970780.674284378,3],[970780.826659925,11],[970781.009155063,30],[970781.191974658,19],[970781.375870258,21],[970781.564761617,15],[970781.713107575,19],[970781.860787407,17],[970782.011010924,6],[970782.160311352,8],[970782.343697855,3],[970782.524130599,5],[970782.707778575,27],[970782.89266819,12],[970783.077442024,9],[970783.260287538,9],[970783.43382689,16],[970783.61940236,5],[970783.802794518,14],[970783.986458302,9],[970784.135191711,22],[970784.28098554,10],[970784.475072245,7],[970784.6587106,23],[970784.806684795,5],[970784.957193831,9],[970785.131131746,14],[970785.279737714,20],[970785.432288377,8],[970785.584543964,12],[970785.733488709,5],[970785.882031021,14],[970786.066122965,14],[970786.212860236,8],[970786.402207357,13],[970786.579577576,3],[970786.761436844,10],[970786.910649983,11],[970787.096272586,9],[970787.281106852,10],[970787.470301159,20],[970787.644737648,14],[970787.827891159,14],[970788.05832931,13],[970788.244821322,5],[970788.434638879,22],[970788.669888949,3],[970788.903994345,32],[970789.090924913,33],[970789.27747329,11],[970789.466325566,6],[970789.64156478,8],[970789.789870929,9],[970789.940548428,13],[970790.091062894,8],[970790.237903102,20],[970790.390163046,17],[970790.580590065,20],[970790.728930249,13],[970790.902370158,6],[970791.089285025,13],[970791.239276705,9],[970791.391635683,11],[970791.545572486,8],[970791.730903479,14],[970791.915233639,12],[970792.133970939,13],[970792.364973911,23],[970792.526024988,8],[970792.710277744,25],[970792.896103297,18],[970793.045865155,13],[970793.231681532,55],[970793.380401135,11],[970793.573338876,10],[970793.748707869,11],[970793.896112092,15],[970794.047319596,17],[970794.243273437,14],[970794.437188006,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-1de4b22831a37bd1612c988388035018","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034703241,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.763187231,"time_to_first_token":0.123647631,"token_sha":"8a91591c94a3","tokens_per_second":18.52768517350703},"seed":1234,"sent":970780.547478449,"speculative":{"acceptance_rate":0.4512820512820513,"accepted":176,"drafted":390,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12680592900142074,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":390,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.53277330463529,"done":970794.433826557,"finish_reason":"length","first":970780.673965683,"full_response_s":13.886194249032997,"last":970794.433374262,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970780.673965683,3],[970780.826892114,11],[970781.011908878,30],[970781.193161734,19],[970781.375668857,21],[970781.566770635,15],[970781.712835717,19],[970781.861080323,17],[970782.010062711,6],[970782.160876334,8],[970782.343826287,3],[970782.52252752,5],[970782.710443978,27],[970782.892108841,12],[970783.079339027,13],[970783.259934551,5],[970783.433658486,16],[970783.618707649,5],[970783.800749016,14],[970783.987914946,9],[970784.134936111,22],[970784.282179432,10],[970784.473161273,7],[970784.660691182,23],[970784.807060778,5],[970784.956875184,9],[970785.132309988,14],[970785.278829537,20],[970785.432784998,8],[970785.587758665,12],[970785.732998296,5],[970785.881482873,14],[970786.064561716,14],[970786.211663849,8],[970786.400938432,13],[970786.5775989,3],[970786.761842174,10],[970786.910138688,11],[970787.093153338,9],[970787.278903348,10],[970787.470906865,20],[970787.643375465,14],[970787.827667948,14],[970788.057332579,13],[970788.243212404,5],[970788.435687456,22],[970788.670298487,3],[970788.903414465,32],[970789.091913338,33],[970789.275444897,11],[970789.467254976,6],[970789.642861691,8],[970789.789967149,9],[970789.939117068,13],[970790.089016771,8],[970790.240344249,20],[970790.389824461,17],[970790.580300173,20],[970790.729346236,13],[970790.901472304,6],[970791.088967162,13],[970791.239542594,9],[970791.391015896,11],[970791.547731934,8],[970791.729643485,15],[970791.915572352,16],[970792.131961317,27],[970792.365310592,4],[970792.525047829,8],[970792.71106592,25],[970792.894857529,18],[970793.045578608,13],[970793.231524969,64],[970793.381108389,2],[970793.575789014,10],[970793.748041147,11],[970793.895858221,15],[970794.0480702,17],[970794.244048619,14],[970794.433374262,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-9f986ea71adc0938140d4ac4df84d00c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034348652,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.759760624,"time_to_first_token":0.124441011,"token_sha":"8a91591c94a3","tokens_per_second":18.532299141543554},"seed":1234,"sent":970780.547632308,"speculative":{"acceptance_rate":0.4230769230769231,"accepted":176,"drafted":416,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12633337499573827,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":416,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.529900335565998,"done":970794.436505155,"finish_reason":"length","first":970780.674918426,"full_response_s":13.88872570800595,"last":970794.436460333,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970780.674918426,3],[970780.826823514,11],[970781.009312811,30],[970781.192608657,19],[970781.374650794,21],[970781.56589595,15],[970781.713257257,19],[970781.862076271,17],[970782.010499293,6],[970782.160370991,8],[970782.345916995,3],[970782.523414558,5],[970782.709667449,27],[970782.891983417,12],[970783.078826692,9],[970783.258806299,9],[970783.433255492,16],[970783.618240872,5],[970783.801132072,14],[970783.987329354,9],[970784.134623289,22],[970784.281342,10],[970784.473754658,7],[970784.659882826,23],[970784.807216157,5],[970784.957867131,9],[970785.132564595,14],[970785.279559276,20],[970785.433278819,8],[970785.585223472,12],[970785.733559134,5],[970785.881065414,14],[970786.064310773,14],[970786.214190625,8],[970786.401161452,13],[970786.576940786,3],[970786.764042798,10],[970786.912223872,11],[970787.094164102,9],[970787.27860896,10],[970787.469704061,20],[970787.642117262,14],[970787.827514281,14],[970788.058768548,13],[970788.245438662,5],[970788.434602154,22],[970788.668540943,3],[970788.904369287,32],[970789.090677698,33],[970789.277812772,11],[970789.46593587,6],[970789.641808746,8],[970789.789781638,9],[970789.941114865,13],[970790.090342198,8],[970790.237378286,20],[970790.389660169,17],[970790.579740361,20],[970790.729240863,13],[970790.90261414,6],[970791.090850336,13],[970791.237703681,9],[970791.390145789,11],[970791.544822955,8],[970791.730224916,14],[970791.914222971,12],[970792.130266006,13],[970792.366186443,23],[970792.527945062,8],[970792.711954893,25],[970792.894508975,18],[970793.045155516,13],[970793.232747278,55],[970793.380710805,11],[970793.575243892,10],[970793.748764339,11],[970793.896427171,15],[970794.046560752,17],[970794.24233017,14],[970794.436460333,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-36c31f5416a14cea799e9ef056463673","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034667141,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.762537824,"time_to_first_token":0.124033119,"token_sha":"8a91591c94a3","tokens_per_second":18.528559431481785},"seed":1234,"sent":970780.547779447,"speculative":{"acceptance_rate":0.4489795918367347,"accepted":176,"drafted":392,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.127138978918083,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":392,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.532098841930136,"done":970794.434610028,"finish_reason":"length","first":970780.674653416,"full_response_s":13.886319445096888,"last":970794.434562759,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970780.674653416,3],[970780.827211386,11],[970781.01149089,30],[970781.193720347,19],[970781.375256022,21],[970781.567366437,15],[970781.712549681,19],[970781.861489414,17],[970782.012015289,6],[970782.160262673,8],[970782.344443435,3],[970782.52595385,5],[970782.707293362,27],[970782.890920021,12],[970783.075125368,13],[970783.26004506,5],[970783.432374534,16],[970783.620174007,5],[970783.803701862,14],[970783.985511465,9],[970784.135554444,22],[970784.280608101,10],[970784.474367534,7],[970784.658166965,23],[970784.806247669,5],[970784.958835314,9],[970785.133198241,14],[970785.279503589,20],[970785.43335118,8],[970785.584794042,12],[970785.73205394,5],[970785.879575086,14],[970786.066495779,14],[970786.212644786,8],[970786.400441267,13],[970786.577887367,3],[970786.762910546,10],[970786.909047561,11],[970787.093694796,9],[970787.280077797,10],[970787.469447502,20],[970787.642537793,14],[970787.828593134,14],[970788.057774697,13],[970788.24378137,5],[970788.435819216,22],[970788.669163772,3],[970788.904326161,32],[970789.091298991,33],[970789.276551385,11],[970789.466268983,6],[970789.640998758,8],[970789.790333033,9],[970789.940101365,13],[970790.08960742,8],[970790.240091882,20],[970790.390424934,17],[970790.580198785,20],[970790.728782086,13],[970790.90256543,6],[970791.091141012,13],[970791.239785151,9],[970791.389989466,11],[970791.547993854,8],[970791.733145577,15],[970791.914316151,16],[970792.133902066,27],[970792.366680264,4],[970792.525596552,8],[970792.711172701,25],[970792.896348399,18],[970793.044894957,13],[970793.232117169,55],[970793.38024518,11],[970793.573574712,10],[970793.748145544,11],[970793.8983832,15],[970794.046256107,17],[970794.243736821,14],[970794.434562759,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-dc5db7b03bc12351af93501d05a09b0f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034447561,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.760335605,"time_to_first_token":0.124431985,"token_sha":"8a91591c94a3","tokens_per_second":18.53152476218257},"seed":1234,"sent":970780.548290583,"speculative":{"acceptance_rate":0.4251207729468599,"accepted":176,"drafted":414,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12636283307801932,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":414,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.532914241748006,"done":970794.433083427,"finish_reason":"length","first":970780.673756857,"full_response_s":13.885236388072371,"last":970794.4330608,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970780.673756857,3],[970780.826368513,11],[970781.009706652,30],[970781.191855139,19],[970781.376317578,21],[970781.565169971,15],[970781.714361299,19],[970781.861120344,17],[970782.011126427,6],[970782.160671012,8],[970782.342949058,3],[970782.525518275,5],[970782.707151265,29],[970782.890481407,10],[970783.079063809,13],[970783.257945776,5],[970783.43243771,16],[970783.620465051,5],[970783.80321345,16],[970783.98664935,7],[970784.133666946,27],[970784.280759064,11],[970784.475517228,8],[970784.66098333,16],[970784.806527384,5],[970784.959978624,9],[970785.134196125,14],[970785.279458063,20],[970785.431892008,8],[970785.58579271,12],[970785.733614901,5],[970785.879931258,14],[970786.064895517,14],[970786.21356866,8],[970786.400182211,13],[970786.578706348,3],[970786.761762933,10],[970786.911835505,11],[970787.094935061,9],[970787.280248202,10],[970787.469127318,20],[970787.644489378,14],[970787.829675363,14],[970788.057975874,13],[970788.243644473,5],[970788.434287348,22],[970788.669280122,3],[970788.903620315,32],[970789.090335384,33],[970789.276391173,11],[970789.467611708,6],[970789.643154623,8],[970789.789344144,9],[970789.93796864,13],[970790.090153551,8],[970790.238945342,20],[970790.391328805,17],[970790.57958671,20],[970790.729116383,13],[970790.902084395,6],[970791.089910141,13],[970791.238151688,9],[970791.389707656,11],[970791.546967665,8],[970791.73048602,15],[970791.915292062,16],[970792.134198566,27],[970792.363935881,4],[970792.527067931,8],[970792.709862253,25],[970792.895433951,18],[970793.045441951,13],[970793.231452544,64],[970793.381168988,2],[970793.574402653,10],[970793.751221983,11],[970793.895937639,15],[970794.045801652,17],[970794.242599995,14],[970794.4330608,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-4efd0cc61dcaf42eb6952c5ecfd71e8e","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034206587,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.759483102,"time_to_first_token":0.125078162,"token_sha":"8a91591c94a3","tokens_per_second":18.532672928893284},"seed":1234,"sent":970780.547847039,"speculative":{"acceptance_rate":0.41025641025641024,"accepted":176,"drafted":429,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12590981810353696,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":429,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.53300470090278,"done":970794.43301065,"finish_reason":"length","first":970780.673714547,"full_response_s":13.885456959018484,"last":970794.432951331,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970780.673714547,3],[970780.827112526,11],[970781.010810549,30],[970781.193337371,19],[970781.374513593,21],[970781.566139516,15],[970781.713758936,19],[970781.860980199,17],[970782.011248458,6],[970782.160202666,8],[970782.344199725,3],[970782.523790461,5],[970782.708502937,29],[970782.890608095,10],[970783.077200794,13],[970783.258898566,5],[970783.433288024,16],[970783.617973174,5],[970783.802074989,16],[970783.985411773,7],[970784.133089659,27],[970784.280522635,11],[970784.472984691,8],[970784.660771304,16],[970784.807325243,5],[970784.958149325,9],[970785.133506407,14],[970785.278652475,20],[970785.432096737,8],[970785.585620129,12],[970785.733683085,5],[970785.880024853,14],[970786.065134459,14],[970786.214044783,8],[970786.400772012,13],[970786.580312082,3],[970786.761096338,10],[970786.912799191,11],[970787.093514534,9],[970787.279484652,10],[970787.470046807,20],[970787.643191794,14],[970787.827978834,14],[970788.059330057,13],[970788.2418792,5],[970788.434436902,22],[970788.670599116,3],[970788.903930721,32],[970789.090741162,33],[970789.276171258,11],[970789.465775146,6],[970789.642806004,8],[970789.790734811,9],[970789.941471053,13],[970790.090088951,8],[970790.238070339,20],[970790.389594929,17],[970790.57968805,23],[970790.729620557,12],[970790.901999521,16],[970791.089241755,6],[970791.24004856,15],[970791.391586285,5],[970791.546016701,7],[970791.732351512,22],[970791.915872965,26],[970792.133202653,10],[970792.366053195,5],[970792.525291186,3],[970792.709506738,25],[970792.895640969,18],[970793.044096699,13],[970793.232492847,64],[970793.380602023,2],[970793.576382686,10],[970793.750974977,11],[970793.898067882,15],[970794.046726836,17],[970794.241836894,14],[970794.432951331,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-30b2e1ce2a25593a04b0b5624d28b97f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":1,"prefill_raised":[],"prefill_seconds":0.03416815,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.759388338,"time_to_first_token":0.125025227,"token_sha":"8a91591c94a3","tokens_per_second":18.53280056757709},"seed":1234,"sent":970780.547553691,"speculative":{"acceptance_rate":0.4074074074074074,"accepted":176,"drafted":432,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12616085598710924,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":432,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.62506807623692,"done":970794.242531331,"finish_reason":"length","first":970780.551212771,"full_response_s":13.695490968064405,"last":970794.242437896,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970780.551212771,3],[970780.640217025,26],[970780.827027731,15],[970781.007937264,19],[970781.193499968,21],[970781.37509381,15],[970781.565515246,19],[970781.712450117,17],[970781.86060332,6],[970782.009779507,11],[970782.159071821,5],[970782.343379367,18],[970782.522685907,21],[970782.706815623,9],[970782.893511831,9],[970783.076886467,16],[970783.257903147,5],[970783.432501702,10],[970783.618149948,13],[970783.801487396,27],[970783.985113512,11],[970784.133462313,8],[970784.280475541,16],[970784.475124588,9],[970784.660480356,10],[970784.807266371,9],[970784.956389924,20],[970785.131893904,8],[970785.27875236,12],[970785.431541036,5],[970785.584283979,14],[970785.731499871,11],[970785.883481376,7],[970786.064443782,17],[970786.214939437,3],[970786.400848277,10],[970786.578277927,11],[970786.763798608,9],[970786.90876127,10],[970787.095437155,20],[970787.278652486,14],[970787.470370991,14],[970787.642210457,13],[970787.827068482,5],[970788.058203022,14],[970788.243932829,11],[970788.434886157,59],[970788.668334406,6],[970788.903497932,11],[970789.091962208,4],[970789.275361751,10],[970789.46682934,9],[970789.640455636,9],[970789.788846179,12],[970789.938911235,20],[970790.088587391,21],[970790.237682419,16],[970790.391092168,13],[970790.578779795,6],[970790.728374485,12],[970790.901595279,6],[970791.088417895,15],[970791.237590899,8],[970791.390970722,14],[970791.54630552,12],[970791.731499008,26],[970791.916352671,10],[970792.130615969,5],[970792.364033653,3],[970792.524135366,25],[970792.709111442,18],[970792.895313201,13],[970793.044234252,64],[970793.231994594,2],[970793.381287291,10],[970793.57421399,11],[970793.749832182,15],[970793.895353312,17],[970794.047273063,14],[970794.242437896,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-fc1277f041505fe89f1b572e1f779710","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":1,"prefill_raised":[],"prefill_seconds":0.002311089,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.690180726,"time_to_first_token":0.002739717,"token_sha":"8a91591c94a3","tokens_per_second":18.6264889488063},"seed":1234,"sent":970780.547040363,"speculative":{"acceptance_rate":0.44221105527638194,"accepted":176,"drafted":398,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.0041724080219864845,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":398,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.35788620899792,"done":970808.492804202,"finish_reason":"length","first":970794.602205861,"full_response_s":14.02816194598563,"last":970808.492693965,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970794.602205861,3],[970794.772391465,11],[970794.954172958,30],[970795.142125048,19],[970795.325135722,21],[970795.516718445,15],[970795.662602806,19],[970795.811452054,17],[970795.956919692,6],[970796.107716583,8],[970796.291488237,3],[970796.471557251,5],[970796.657027494,27],[970796.840674678,12],[970797.024083608,9],[970797.212495366,9],[970797.37819185,16],[970797.570829719,5],[970797.755130325,14],[970797.939754012,9],[970798.08787557,22],[970798.237215579,10],[970798.426398861,7],[970798.615179871,23],[970798.763569109,5],[970798.913944292,9],[970799.085999469,14],[970799.236619151,20],[970799.38276031,8],[970799.538601037,12],[970799.687232272,5],[970799.835384532,14],[970800.023582908,14],[970800.169375176,8],[970800.356243233,13],[970800.537522681,3],[970800.722865658,10],[970800.868184961,11],[970801.05363527,9],[970801.240517111,10],[970801.427145274,20],[970801.57987876,6],[970801.763458668,8],[970801.948020057,14],[970802.183531892,13],[970802.333350803,5],[970802.528513355,22],[970802.756348078,3],[970802.993451808,43],[970803.183394093,22],[970803.36658125,11],[970803.560886489,6],[970803.73383407,8],[970803.881361267,9],[970804.032228318,13],[970804.180535223,8],[970804.333892411,20],[970804.489726935,17],[970804.675222984,20],[970804.824379012,13],[970805.009841465,6],[970805.193897334,13],[970805.343494376,9],[970805.50043351,11],[970805.652422486,5],[970805.836023191,7],[970806.022203609,14],[970806.208208198,16],[970806.3989341,28],[970806.593595015,8],[970806.774899669,25],[970806.925054192,18],[970807.097052678,13],[970807.283193307,64],[970807.439129901,2],[970807.628634833,10],[970807.803047638,11],[970807.951983211,15],[970808.10514141,17],[970808.298831213,14],[970808.492693965,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-3893319d70840bb28b2acad6449cb074","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.033038433,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.892310662,"time_to_first_token":0.132713319,"token_sha":"8a91591c94a3","tokens_per_second":18.355477803811873},"seed":1234,"sent":970794.464642256,"speculative":{"acceptance_rate":0.44080604534005036,"accepted":175,"drafted":397,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1375636049779132,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":397,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.358715317010432,"done":970808.490054948,"finish_reason":"length","first":970794.600174718,"full_response_s":14.025995210977271,"last":970808.490035506,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970794.600174718,3],[970794.772333602,11],[970794.954460577,30],[970795.142465057,19],[970795.325672204,21],[970795.515271133,15],[970795.662283487,19],[970795.808619518,17],[970795.956272797,6],[970796.10837095,8],[970796.289889531,3],[970796.472048174,5],[970796.656495414,29],[970796.840935702,10],[970797.022920603,13],[970797.211141763,5],[970797.378281445,16],[970797.570560215,5],[970797.75386678,16],[970797.938033485,7],[970798.087563997,27],[970798.23582898,11],[970798.426546367,8],[970798.615742883,16],[970798.762594479,5],[970798.912992946,9],[970799.084565856,14],[970799.23776681,20],[970799.38357356,8],[970799.537189187,12],[970799.685901952,5],[970799.837288377,14],[970800.021172586,14],[970800.16900846,8],[970800.356021494,13],[970800.538094446,3],[970800.721746851,10],[970800.869770256,11],[970801.055322561,9],[970801.241059016,10],[970801.428245662,20],[970801.578829434,6],[970801.762887432,8],[970801.948332398,14],[970802.18266582,13],[970802.332572038,5],[970802.526420224,22],[970802.757466244,3],[970802.994672706,43],[970803.182430042,22],[970803.367020295,11],[970803.559713773,6],[970803.73361182,8],[970803.881882609,9],[970804.032282708,13],[970804.181985588,8],[970804.333152563,20],[970804.490304972,17],[970804.675182948,23],[970804.823126351,12],[970805.010069684,16],[970805.193738419,6],[970805.343091768,15],[970805.500830997,5],[970805.653467426,7],[970805.83589532,22],[970806.02160653,26],[970806.208283295,10],[970806.398971801,5],[970806.590346468,13],[970806.777452644,30],[970806.925276843,11],[970807.09835176,5],[970807.284238103,64],[970807.437599832,2],[970807.629139853,10],[970807.802684891,11],[970807.95029429,15],[970808.101775363,17],[970808.299268737,14],[970808.490035506,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-f5ad289a1c007b8bae099f254471ad24","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.032609309,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.889212279,"time_to_first_token":0.134032472,"token_sha":"8a91591c94a3","tokens_per_second":18.359572514097938},"seed":1234,"sent":970794.464059737,"speculative":{"acceptance_rate":0.39149888143176736,"accepted":175,"drafted":447,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.13611498090904206,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":447,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.357861360006787,"done":970808.492964445,"finish_reason":"length","first":970794.602274381,"full_response_s":14.027552879997529,"last":970808.492781287,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970794.602274381,3],[970794.772208338,11],[970794.955205291,30],[970795.143978233,19],[970795.324578759,21],[970795.517337,15],[970795.661681414,19],[970795.811135072,17],[970795.956731269,6],[970796.107375806,8],[970796.292566592,3],[970796.470709724,5],[970796.656098086,27],[970796.839857252,12],[970797.023021079,9],[970797.210056559,9],[970797.378898495,16],[970797.572353744,5],[970797.756156465,14],[970797.939143859,9],[970798.087266937,22],[970798.236659992,10],[970798.427304971,7],[970798.617237015,23],[970798.762774949,5],[970798.911154868,9],[970799.086358728,14],[970799.236373346,20],[970799.382605795,8],[970799.539605094,12],[970799.686655579,5],[970799.837424441,14],[970800.023340847,14],[970800.170392483,8],[970800.357618902,13],[970800.53770051,3],[970800.722611211,10],[970800.870178737,11],[970801.054761902,9],[970801.238648343,10],[970801.428940033,20],[970801.580619921,6],[970801.764088424,8],[970801.949850436,14],[970802.181325067,13],[970802.332875162,5],[970802.529421448,22],[970802.757649098,3],[970802.993597473,43],[970803.182691593,22],[970803.368281614,11],[970803.559893395,6],[970803.733149412,8],[970803.88150322,9],[970804.033533658,13],[970804.180076864,8],[970804.333654591,20],[970804.489516942,17],[970804.675658604,20],[970804.823085418,13],[970805.00845666,6],[970805.194794593,13],[970805.345844688,9],[970805.500955524,11],[970805.65202135,5],[970805.837243496,7],[970806.022556835,14],[970806.208032561,16],[970806.399931355,28],[970806.591157957,8],[970806.779320994,25],[970806.924835735,18],[970807.098760337,13],[970807.285443974,64],[970807.438021706,2],[970807.627662142,10],[970807.802095141,11],[970807.9509183,15],[970808.103379041,17],[970808.297560455,14],[970808.492781287,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-de493247abe14999f0b9822a229f97dc","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.03307455,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.892409569,"time_to_first_token":0.132419476,"token_sha":"8a91591c94a3","tokens_per_second":18.35534712200076},"seed":1234,"sent":970794.465411565,"speculative":{"acceptance_rate":0.44080604534005036,"accepted":175,"drafted":397,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1368628159398213,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":397,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.359961458065058,"done":970808.491085438,"finish_reason":"length","first":970794.602127468,"full_response_s":14.026854160008952,"last":970808.491045513,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970794.602127468,3],[970794.77197271,11],[970794.955811717,30],[970795.143903408,19],[970795.32419244,21],[970795.515912507,15],[970795.663591262,19],[970795.809426016,17],[970795.956542718,6],[970796.105994631,8],[970796.291235278,3],[970796.473396945,5],[970796.658637673,27],[970796.840512019,12],[970797.023904146,13],[970797.208380725,5],[970797.379037552,16],[970797.572030249,5],[970797.755489504,14],[970797.939260385,9],[970798.086650703,22],[970798.236281547,16],[970798.427513476,8],[970798.616177431,16],[970798.763134417,5],[970798.91230219,9],[970799.08532334,14],[970799.236420743,20],[970799.382446192,8],[970799.537760216,12],[970799.688553167,5],[970799.835823768,14],[970800.022437362,14],[970800.169133835,8],[970800.357815582,13],[970800.539037839,3],[970800.722438519,10],[970800.870513673,11],[970801.054540979,9],[970801.241446423,10],[970801.42937671,20],[970801.57846059,6],[970801.762825952,8],[970801.949208903,14],[970802.181596012,13],[970802.33357451,5],[970802.528840658,22],[970802.756625647,3],[970802.993531305,43],[970803.182781812,22],[970803.366971745,11],[970803.561924518,6],[970803.733551892,8],[970803.882086682,9],[970804.033130218,13],[970804.180194958,8],[970804.334203024,20],[970804.489840325,17],[970804.675709987,20],[970804.824623873,13],[970805.009231616,6],[970805.194410179,13],[970805.344387587,9],[970805.500772014,11],[970805.653658489,8],[970805.837953021,14],[970806.023344624,8],[970806.20883024,19],[970806.399573296,21],[970806.593891386,8],[970806.775160724,25],[970806.926086251,18],[970807.097714981,13],[970807.283433783,64],[970807.439692592,2],[970807.628287752,10],[970807.803893978,11],[970807.951721371,15],[970808.103068988,17],[970808.297627727,14],[970808.491045513,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-116a03793e15541893cc176eaef79eb8","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.032822583,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.890660643,"time_to_first_token":0.133869844,"token_sha":"8a91591c94a3","tokens_per_second":18.357658181542547},"seed":1234,"sent":970794.464231278,"speculative":{"acceptance_rate":0.4268292682926829,"accepted":175,"drafted":410,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1378961899317801,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":410,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.36068356503254,"done":970808.489444268,"finish_reason":"length","first":970794.60102919,"full_response_s":14.024225990055129,"last":970808.489400998,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970794.60102919,3],[970794.771332744,11],[970794.956769353,30],[970795.143146116,19],[970795.325935644,21],[970795.51761193,15],[970795.663085552,19],[970795.809165329,17],[970795.956177474,6],[970796.109359022,8],[970796.290072242,3],[970796.471712085,5],[970796.660172451,29],[970796.842512917,10],[970797.023449963,13],[970797.212801691,5],[970797.379630824,16],[970797.572966298,5],[970797.756588037,16],[970797.939463753,7],[970798.087391448,27],[970798.236229284,11],[970798.427108115,8],[970798.618140628,16],[970798.764157452,5],[970798.91357676,9],[970799.085561112,14],[970799.237465301,20],[970799.381786785,8],[970799.536799204,12],[970799.687808837,5],[970799.835711083,14],[970800.020256716,14],[970800.172139317,8],[970800.358101776,13],[970800.537376375,3],[970800.723518857,10],[970800.868989666,11],[970801.055610339,9],[970801.239108574,10],[970801.428335897,20],[970801.580385941,6],[970801.763963785,8],[970801.947043108,14],[970802.181762752,13],[970802.333484787,5],[970802.528189012,22],[970802.757409677,3],[970802.994103134,43],[970803.182737278,22],[970803.367636785,11],[970803.560700739,6],[970803.733034503,8],[970803.882822225,9],[970804.034636285,13],[970804.180594366,8],[970804.33344503,20],[970804.489776189,17],[970804.675025969,23],[970804.8237763,12],[970805.00913058,16],[970805.193648968,6],[970805.344721323,15],[970805.500065034,5],[970805.651383866,7],[970805.836573849,22],[970806.023714716,26],[970806.208950398,10],[970806.400165719,5],[970806.594815384,13],[970806.775959106,30],[970806.925765221,11],[970807.09747076,5],[970807.28392837,64],[970807.438080417,2],[970807.628373282,10],[970807.802789479,11],[970807.952742052,15],[970808.10327098,17],[970808.297311097,14],[970808.489400998,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-8385965301b6005398f3d358e9e30c80","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.03257076,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.889148944,"time_to_first_token":0.134140437,"token_sha":"8a91591c94a3","tokens_per_second":18.359656234384175},"seed":1234,"sent":970794.465218278,"speculative":{"acceptance_rate":0.39149888143176736,"accepted":175,"drafted":447,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.135810912004672,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":447,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.442977347596333,"done":970808.297110273,"finish_reason":"length","first":970794.470667964,"full_response_s":13.83294766000472,"last":970808.29706894,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970794.470667964,3],[970794.568138327,26],[970794.771181462,15],[970794.955556022,19],[970795.144189651,21],[970795.324653696,15],[970795.515995893,19],[970795.661930596,17],[970795.810254165,6],[970795.955398147,11],[970796.106644293,5],[970796.290019899,18],[970796.472962717,21],[970796.657586154,9],[970796.841495018,9],[970797.024334934,16],[970797.21080201,5],[970797.380081263,10],[970797.571709282,13],[970797.756851557,27],[970797.938175182,11],[970798.087806842,8],[970798.23652484,16],[970798.426644827,9],[970798.616865034,13],[970798.762648598,15],[970798.910976895,17],[970799.085801989,6],[970799.234415078,8],[970799.381959686,5],[970799.539030625,14],[970799.687023367,11],[970799.837325725,7],[970800.02034263,17],[970800.169268076,3],[970800.356859531,10],[970800.537909432,11],[970800.721398778,9],[970800.8688368,10],[970801.055871683,20],[970801.241801618,14],[970801.428072025,14],[970801.579650989,13],[970801.76232298,5],[970801.950444523,22],[970802.181908369,3],[970802.331816619,59],[970802.527718732,6],[970802.755731636,11],[970802.996716982,3],[970803.182119188,4],[970803.36727895,7],[970803.560393806,9],[970803.73453857,9],[970803.881213137,12],[970804.031567151,20],[970804.180482785,21],[970804.33285984,16],[970804.489092236,13],[970804.674865326,6],[970804.822955834,12],[970805.010889173,6],[970805.194469098,15],[970805.343206166,8],[970805.500355853,14],[970805.651042081,12],[970805.835229433,26],[970806.021516343,10],[970806.208754327,5],[970806.400389697,3],[970806.590777015,25],[970806.776029883,18],[970806.922685159,13],[970807.098951079,64],[970807.284548844,2],[970807.437856342,10],[970807.627366619,11],[970807.803107901,15],[970807.95310936,17],[970808.101319373,14],[970808.29706894,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-70b1e1d94042e70a9dbcaa70c76cba93","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":1,"prefill_raised":[],"prefill_seconds":0.004478272,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.826277682,"time_to_first_token":0.005043606,"token_sha":"8a91591c94a3","tokens_per_second":18.443141810465484},"seed":1234,"sent":970794.464162613,"speculative":{"acceptance_rate":0.4268292682926829,"accepted":175,"drafted":410,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.006505350931547582,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":410,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.359220426786877,"done":970808.490992195,"finish_reason":"length","first":970794.601420038,"full_response_s":14.025999624980614,"last":970808.49089868,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970794.601420038,3],[970794.772446719,11],[970794.955971784,30],[970795.143400243,19],[970795.325066674,21],[970795.517441573,15],[970795.661976906,19],[970795.810008887,17],[970795.955477469,6],[970796.106909925,8],[970796.291870315,3],[970796.472720191,5],[970796.659770723,27],[970796.84158466,12],[970797.024130061,13],[970797.209392047,5],[970797.37895631,16],[970797.570892655,5],[970797.758136096,14],[970797.940627382,9],[970798.087986224,22],[970798.236729809,16],[970798.425663541,8],[970798.618254914,16],[970798.765850392,5],[970798.912386841,9],[970799.084998084,14],[970799.23622736,20],[970799.382222309,8],[970799.538191116,12],[970799.687092207,5],[970799.835016263,14],[970800.02076945,14],[970800.169833712,8],[970800.357198164,13],[970800.537834143,3],[970800.722118176,10],[970800.868899079,11],[970801.054692085,9],[970801.238998769,10],[970801.42676638,20],[970801.580330334,6],[970801.764386332,8],[970801.949126941,14],[970802.182450306,13],[970802.332936289,5],[970802.527523237,22],[970802.756052059,3],[970802.995418267,43],[970803.183929501,22],[970803.366476134,11],[970803.562589989,6],[970803.734380119,8],[970803.883006023,9],[970804.031719937,13],[970804.181455525,8],[970804.332550683,20],[970804.488938409,17],[970804.675843042,20],[970804.823574564,13],[970805.00901399,6],[970805.194848039,13],[970805.344169753,9],[970805.499820653,11],[970805.651635304,8],[970805.83718981,14],[970806.024504906,8],[970806.208092856,19],[970806.398595388,21],[970806.592733616,8],[970806.7758405,25],[970806.923310561,18],[970807.098472143,13],[970807.284867106,64],[970807.439860772,2],[970807.628165994,10],[970807.80315053,11],[970807.950848868,15],[970808.102226745,17],[970808.298415228,14],[970808.49089868,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-c9d62e7d24ac7bb2efb8c4f142a30e0d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.032855355,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.890704279,"time_to_first_token":0.133478789,"token_sha":"8a91591c94a3","tokens_per_second":18.35760051313666},"seed":1234,"sent":970794.46499257,"speculative":{"acceptance_rate":0.4268292682926829,"accepted":175,"drafted":410,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.13642746803816408,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":410,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.35679670466809,"done":970808.491964118,"finish_reason":"length","first":970794.60054854,"full_response_s":14.027148096938618,"last":970808.491861066,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970794.60054854,3],[970794.772267514,11],[970794.956223543,30],[970795.144403309,19],[970795.325320769,21],[970795.516838828,15],[970795.662824193,19],[970795.8092294,17],[970795.957214895,6],[970796.109473308,8],[970796.2907553,3],[970796.471189062,5],[970796.658776922,27],[970796.840102929,12],[970797.023688856,9],[970797.213326075,9],[970797.379750118,16],[970797.571138157,5],[970797.755728573,14],[970797.940341251,9],[970798.085995263,22],[970798.237079595,10],[970798.427883217,7],[970798.616966486,23],[970798.764835822,5],[970798.911538402,9],[970799.084796796,14],[970799.23717269,20],[970799.381123105,8],[970799.538761537,12],[970799.688038561,5],[970799.836567874,14],[970800.021853628,14],[970800.169566704,8],[970800.357416382,13],[970800.540386545,3],[970800.720772462,10],[970800.867937844,11],[970801.053978384,9],[970801.239665185,10],[970801.427027628,20],[970801.581840627,6],[970801.764269182,8],[970801.950130566,14],[970802.182747302,13],[970802.331999633,5],[970802.527134534,22],[970802.756772897,3],[970802.993243479,43],[970803.182244499,22],[970803.367876637,11],[970803.561334223,6],[970803.73264164,8],[970803.88202469,9],[970804.032893805,13],[970804.181270047,8],[970804.333997336,20],[970804.489171909,17],[970804.675344871,20],[970804.823719733,13],[970805.009527987,6],[970805.193840879,13],[970805.345013917,9],[970805.49994302,11],[970805.652086814,5],[970805.836657794,7],[970806.024259389,18],[970806.208893463,18],[970806.400667906,27],[970806.594086449,9],[970806.777719412,19],[970806.926625243,18],[970807.096913254,13],[970807.284312592,64],[970807.439058917,2],[970807.627538831,10],[970807.802544154,11],[970807.952294063,15],[970808.101479344,17],[970808.298901621,14],[970808.491861066,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-9d99f9f97b8927cfc08c09ad4bd25246","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.032966808,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.891544891,"time_to_first_token":0.133245272,"token_sha":"8a91591c94a3","tokens_per_second":18.35648964898126},"seed":1234,"sent":970794.464816021,"speculative":{"acceptance_rate":0.43209876543209874,"accepted":175,"drafted":405,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.13573251897469163,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":405,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.357218911208268,"done":970808.491729658,"finish_reason":"length","first":970794.600646583,"full_response_s":14.026830522925593,"last":970808.491639616,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970794.600646583,3],[970794.772085316,11],[970794.954829358,30],[970795.141894156,19],[970795.325403835,21],[970795.515811103,15],[970795.662189396,19],[970795.808517458,17],[970795.957300842,6],[970796.108236854,8],[970796.293079662,3],[970796.47231579,5],[970796.656878228,27],[970796.84125278,12],[970797.023569338,13],[970797.208812169,5],[970797.379455811,16],[970797.571968641,5],[970797.754835729,14],[970797.940544476,9],[970798.086785263,22],[970798.237395697,10],[970798.426289328,7],[970798.615979487,23],[970798.765142819,5],[970798.912733186,9],[970799.085374898,14],[970799.236514067,20],[970799.381657025,8],[970799.536954407,12],[970799.686834224,5],[970799.836505386,14],[970800.020492488,14],[970800.172635393,8],[970800.357496824,13],[970800.536440423,3],[970800.721497013,10],[970800.868944636,11],[970801.055080164,9],[970801.237933665,10],[970801.429273385,20],[970801.578208143,6],[970801.763310187,8],[970801.947646604,14],[970802.18102732,13],[970802.331950539,5],[970802.526171443,22],[970802.755934845,3],[970802.99720368,43],[970803.183079783,22],[970803.368194467,11],[970803.559366308,6],[970803.733438535,8],[970803.883568602,9],[970804.033450624,13],[970804.18134372,8],[970804.333093964,20],[970804.489683026,17],[970804.675752184,20],[970804.82362337,13],[970805.009411461,6],[970805.194575878,13],[970805.346094798,9],[970805.500532258,11],[970805.650900833,5],[970805.835373162,7],[970806.022858375,18],[970806.209030488,18],[970806.399436064,27],[970806.594918196,9],[970806.776891105,19],[970806.923523579,18],[970807.097851557,13],[970807.28551371,64],[970807.439259613,2],[970807.629993747,10],[970807.803354154,11],[970807.949994031,15],[970808.101565354,17],[970808.299328728,14],[970808.491639616,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-90c0b08a01269c4f7185ace166498629","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.03292834,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.891432317,"time_to_first_token":0.13357088,"token_sha":"8a91591c94a3","tokens_per_second":18.35663840710919},"seed":1234,"sent":970794.464899135,"speculative":{"acceptance_rate":0.4257907542579075,"accepted":175,"drafted":411,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1357474479591474,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":411,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.357919748965298,"done":970808.492404266,"finish_reason":"length","first":970794.601851946,"full_response_s":14.028002743027173,"last":970808.492314672,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970794.601851946,3],[970794.772162813,11],[970794.954301102,30],[970795.142302014,19],[970795.325632935,21],[970795.517514382,15],[970795.661862572,19],[970795.808326795,17],[970795.957828282,6],[970796.10754493,8],[970796.293541334,3],[970796.473219964,5],[970796.658465316,27],[970796.842259094,12],[970797.023150711,9],[970797.211335674,9],[970797.379906921,16],[970797.570168792,5],[970797.754108649,14],[970797.939089788,9],[970798.087049919,22],[970798.235946434,10],[970798.426033617,7],[970798.61759141,23],[970798.764417323,5],[970798.911723753,9],[970799.084929356,14],[970799.235799821,20],[970799.380876579,8],[970799.537132876,12],[970799.686238488,5],[970799.837597566,14],[970800.020594517,14],[970800.170604972,8],[970800.357886726,13],[970800.536718888,3],[970800.723106167,10],[970800.868437792,11],[970801.053461074,9],[970801.240067425,10],[970801.427668153,20],[970801.579170691,6],[970801.764500121,8],[970801.949502859,14],[970802.183260531,13],[970802.333099861,5],[970802.529751392,22],[970802.758059899,3],[970802.994343978,43],[970803.18261784,22],[970803.367087839,11],[970803.563316988,6],[970803.733505055,8],[970803.882729094,9],[970804.033792072,13],[970804.180293978,8],[970804.333933888,20],[970804.489360332,17],[970804.674810887,20],[970804.823829762,13],[970805.008725268,6],[970805.194608394,13],[970805.345966671,9],[970805.501548763,11],[970805.651821054,5],[970805.837038144,7],[970806.024349608,18],[970806.20916844,18],[970806.400106,27],[970806.591812243,9],[970806.776262759,19],[970806.923135997,18],[970807.097581637,13],[970807.285202969,64],[970807.437724326,2],[970807.628058509,10],[970807.801810707,11],[970807.951117956,15],[970808.102362281,17],[970808.298721664,14],[970808.492314672,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-a12c3c06ec8739722d11f7ea7cee06eb","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.033001997,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.891997232,"time_to_first_token":0.133179888,"token_sha":"8a91591c94a3","tokens_per_second":18.355891938461625},"seed":1234,"sent":970794.464401523,"speculative":{"acceptance_rate":0.43209876543209874,"accepted":175,"drafted":405,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1374504229752347,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":405,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.441974855345855,"done":970808.297873372,"finish_reason":"length","first":970794.470692575,"full_response_s":13.833553683012724,"last":970808.297845144,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970794.470692575,3],[970794.568023897,26],[970794.771407121,15],[970794.955418757,19],[970795.145028361,21],[970795.324288692,15],[970795.516174715,19],[970795.661367328,17],[970795.808814502,6],[970795.955976089,11],[970796.109806532,5],[970796.29403845,18],[970796.473313943,21],[970796.65725469,9],[970796.842591758,9],[970797.023108306,16],[970797.210586848,5],[970797.378098943,10],[970797.570397683,13],[970797.754468165,27],[970797.939200234,11],[970798.086519679,8],[970798.23689314,16],[970798.425865613,9],[970798.616232286,13],[970798.764749139,15],[970798.911792369,17],[970799.084878502,6],[970799.236992892,8],[970799.380753972,5],[970799.539385036,14],[970799.687939029,11],[970799.837173611,7],[970800.020393404,17],[970800.168883997,3],[970800.356411349,10],[970800.538414884,11],[970800.720997641,9],[970800.868368935,10],[970801.055706191,20],[970801.238298173,14],[970801.42709506,14],[970801.580495154,13],[970801.762461445,5],[970801.947534079,22],[970802.182370281,3],[970802.333139226,59],[970802.526576563,6],[970802.757911529,11],[970802.99402634,3],[970803.184150295,4],[970803.366719603,7],[970803.56160872,9],[970803.733336395,9],[970803.883688825,12],[970804.032469627,20],[970804.180936983,21],[970804.332903797,16],[970804.489926751,13],[970804.674691385,6],[970804.825040547,12],[970805.009585242,6],[970805.19406481,15],[970805.343617575,8],[970805.50072164,14],[970805.65225837,12],[970805.835437201,26],[970806.023046557,10],[970806.20856024,5],[970806.399054995,3],[970806.592237989,25],[970806.778101393,18],[970806.922934261,13],[970807.097329879,64],[970807.285250799,2],[970807.438625905,10],[970807.627988741,11],[970807.802183215,15],[970807.952925178,17],[970808.102298513,14],[970808.297845144,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-ff4d15ef0d51403f083b872dd8c767ba","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":1,"prefill_raised":[],"prefill_seconds":0.004522774,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.826368924,"time_to_first_token":0.004980317,"token_sha":"8a91591c94a3","tokens_per_second":18.443020101783013},"seed":1234,"sent":970794.464319689,"speculative":{"acceptance_rate":0.4268292682926829,"accepted":175,"drafted":410,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.006372886011376977,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":410,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.358038833109855,"done":970808.491327083,"finish_reason":"length","first":970794.600920249,"full_response_s":14.026050413958728,"last":970808.491292871,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970794.600920249,3],[970794.772501046,11],[970794.955303879,30],[970795.144824544,19],[970795.324381279,21],[970795.515153135,15],[970795.662658925,19],[970795.808209677,17],[970795.957574331,6],[970796.106753955,8],[970796.29281955,3],[970796.470852685,5],[970796.657954695,27],[970796.839740901,12],[970797.023513875,13],[970797.211448648,5],[970797.379559455,16],[970797.571202885,5],[970797.755178074,14],[970797.93884091,9],[970798.088129937,22],[970798.236036909,10],[970798.425504081,7],[970798.618039688,23],[970798.763693156,5],[970798.91268342,9],[970799.086171234,14],[970799.235612422,20],[970799.383364415,8],[970799.539178627,12],[970799.686473781,5],[970799.835134982,14],[970800.021651972,14],[970800.17241151,8],[970800.35587234,13],[970800.537143579,3],[970800.722808083,10],[970800.869289686,11],[970801.055424125,9],[970801.238485828,10],[970801.428847558,20],[970801.581353337,6],[970801.763572506,8],[970801.947863126,14],[970802.182980082,13],[970802.332108494,5],[970802.528248475,22],[970802.755841522,3],[970802.993051648,43],[970803.183303474,22],[970803.368628599,11],[970803.562292562,6],[970803.733990105,8],[970803.882636571,9],[970804.031900071,13],[970804.180408168,8],[970804.3327922,20],[970804.490651942,17],[970804.674571867,20],[970804.823171764,13],[970805.010666411,6],[970805.194525568,13],[970805.343697441,9],[970805.500876923,11],[970805.653976911,5],[970805.837593794,7],[970806.022794815,18],[970806.209079293,18],[970806.39933322,27],[970806.5944764,9],[970806.779086983,19],[970806.92439013,18],[970807.097788477,13],[970807.28367706,64],[970807.437793615,2],[970807.628908674,10],[970807.80414716,11],[970807.953348572,15],[970808.102902009,17],[970808.297601851,14],[970808.491292871,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-a29efed07211671b183035db3145a6c0","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.032891999,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.891105319,"time_to_first_token":0.133269867,"token_sha":"8a91591c94a3","tokens_per_second":18.357070524201962},"seed":1234,"sent":970794.465276669,"speculative":{"acceptance_rate":0.4257907542579075,"accepted":175,"drafted":411,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1356435799971223,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":411,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.358812759836713,"done":970808.490429264,"finish_reason":"length","first":970794.600592081,"full_response_s":14.025331416982226,"last":970808.490379146,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970794.600592081,3],[970794.771649102,11],[970794.955081516,30],[970795.145272022,19],[970795.323992496,21],[970795.516115668,15],[970795.663512564,19],[970795.80991718,17],[970795.956417871,6],[970796.110272509,8],[970796.293806022,3],[970796.470946633,5],[970796.660428706,29],[970796.841893658,10],[970797.023629521,13],[970797.212707376,5],[970797.378335851,16],[970797.573234202,5],[970797.755825801,16],[970797.938449119,7],[970798.087509046,22],[970798.237728297,16],[970798.427442203,8],[970798.618194059,16],[970798.764541242,5],[970798.912148476,9],[970799.084483766,14],[970799.235514666,20],[970799.382865603,8],[970799.537688575,12],[970799.68811601,5],[970799.836723957,14],[970800.022806991,14],[970800.16968875,8],[970800.357938301,13],[970800.538744396,3],[970800.721859633,10],[970800.868599315,11],[970801.054810451,9],[970801.238039214,10],[970801.426857991,20],[970801.581978756,6],[970801.762679695,8],[970801.947372667,14],[970802.182807709,13],[970802.333517959,5],[970802.526799278,22],[970802.756269381,3],[970802.996953394,43],[970803.182531606,22],[970803.367594027,11],[970803.563166602,6],[970803.733936146,8],[970803.882332151,9],[970804.034566277,13],[970804.180819353,8],[970804.332331633,20],[970804.489886042,17],[970804.675250412,20],[970804.823646061,13],[970805.010595906,6],[970805.194366526,13],[970805.345921226,9],[970805.501817227,11],[970805.652346717,8],[970805.836442009,15],[970806.021886323,16],[970806.207901281,31],[970806.399676284,5],[970806.591873402,9],[970806.776153818,19],[970806.923768024,18],[970807.099421887,13],[970807.28557759,64],[970807.440178106,2],[970807.629695327,10],[970807.803752441,11],[970807.951418584,15],[970808.105245214,17],[970808.298956572,14],[970808.490379146,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-bee46b7c919231b47cf2b6d7e0f143ac","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.032782962,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.88982952,"time_to_first_token":0.13377076,"token_sha":"8a91591c94a3","tokens_per_second":18.358756645128356},"seed":1234,"sent":970794.465097847,"speculative":{"acceptance_rate":0.4146919431279621,"accepted":175,"drafted":422,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1354942339239642,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":422,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.359712080931047,"done":970808.490231593,"finish_reason":"length","first":970794.601088989,"full_response_s":14.025747803971171,"last":970808.490195685,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970794.601088989,3],[970794.772989361,11],[970794.954537098,30],[970795.143632527,19],[970795.325371847,21],[970795.515478359,15],[970795.660939484,19],[970795.808700296,17],[970795.957022936,6],[970796.106342337,8],[970796.292069844,3],[970796.47194973,5],[970796.65661602,29],[970796.839522779,10],[970797.02472599,13],[970797.208141544,5],[970797.379107961,16],[970797.570736908,5],[970797.755265653,16],[970797.938686012,7],[970798.08722602,27],[970798.237492077,11],[970798.427827786,8],[970798.61653117,16],[970798.763940306,5],[970798.912597298,9],[970799.085067629,14],[970799.236578762,20],[970799.384022206,8],[970799.537308978,12],[970799.688196516,5],[970799.835321068,14],[970800.021527541,14],[970800.170966216,8],[970800.356671748,13],[970800.536129281,3],[970800.721298414,10],[970800.868715937,11],[970801.054231646,9],[970801.241198409,10],[970801.429473489,20],[970801.579400734,6],[970801.764445331,8],[970801.946833851,14],[970802.181453243,13],[970802.332751963,5],[970802.527324125,22],[970802.757723203,3],[970802.995042158,43],[970803.183470438,22],[970803.368151422,11],[970803.56007084,6],[970803.734110103,8],[970803.882953217,9],[970804.034282259,13],[970804.181800542,8],[970804.332615331,20],[970804.48959564,17],[970804.674491217,20],[970804.824708363,13],[970805.008615751,6],[970805.194127009,13],[970805.344087695,9],[970805.501479123,11],[970805.654085932,8],[970805.835528652,15],[970806.021688684,16],[970806.208479558,31],[970806.398828264,5],[970806.591903197,13],[970806.775578837,30],[970806.924701751,11],[970807.098109588,5],[970807.283074829,64],[970807.438177372,2],[970807.629902664,10],[970807.801943011,11],[970807.95267334,15],[970808.104140203,17],[970808.298356373,14],[970808.490195685,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-06fd307aef0cd0e07419455111fd72fa","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.03268247,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.889517115,"time_to_first_token":0.134077486,"token_sha":"8a91591c94a3","tokens_per_second":18.359169572901312},"seed":1234,"sent":970794.464483789,"speculative":{"acceptance_rate":0.40792540792540793,"accepted":175,"drafted":429,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.13660519989207387,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":429,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.361460088003962,"done":970808.489950632,"finish_reason":"length","first":970794.601928083,"full_response_s":14.0253491490148,"last":970808.489712539,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970794.601928083,3],[970794.772830238,11],[970794.955760543,30],[970795.145133381,19],[970795.325018924,21],[970795.514991228,15],[970795.661191579,19],[970795.810572667,17],[970795.956099544,6],[970796.105775036,8],[970796.292213893,3],[970796.472510262,5],[970796.658567841,29],[970796.840344462,10],[970797.023240994,13],[970797.210514503,5],[970797.380309066,16],[970797.569975744,5],[970797.757739216,16],[970797.940455777,7],[970798.08585147,22],[970798.236141642,16],[970798.426974451,8],[970798.615455904,16],[970798.76507057,5],[970798.910829597,9],[970799.08465025,14],[970799.233990419,20],[970799.383945845,8],[970799.537482198,12],[970799.687399636,5],[970799.83695472,14],[970800.020078278,14],[970800.171841793,8],[970800.356490463,13],[970800.539493414,3],[970800.721902326,10],[970800.868504888,11],[970801.055531434,9],[970801.239417267,10],[970801.42867629,20],[970801.581685889,6],[970801.764317956,8],[970801.947733222,14],[970802.182294511,13],[970802.332379999,5],[970802.527956248,22],[970802.755485415,3],[970802.995528616,43],[970803.183869686,22],[970803.366916346,11],[970803.562856421,6],[970803.732928922,8],[970803.882772491,9],[970804.032026262,13],[970804.180878976,8],[970804.332459136,20],[970804.489260544,17],[970804.675128381,20],[970804.824120997,13],[970805.008890919,6],[970805.194217804,13],[970805.345299423,9],[970805.501652519,11],[970805.652821029,8],[970805.836748541,15],[970806.021984783,16],[970806.208138781,31],[970806.398478062,5],[970806.590054834,9],[970806.774703741,19],[970806.924783984,18],[970807.09804358,13],[970807.283783249,64],[970807.438559562,2],[970807.628814247,10],[970807.802595104,11],[970807.950208328,15],[970808.102809662,17],[970808.298297678,14],[970808.489712539,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-7500f2afc8928255991beb673b643df6","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.032718826,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.889461365,"time_to_first_token":0.133785114,"token_sha":"8a91591c94a3","tokens_per_second":18.359243263570573},"seed":1234,"sent":970794.464601483,"speculative":{"acceptance_rate":0.4146919431279621,"accepted":175,"drafted":422,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.13732660003006458,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":422,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.35949679042848,"done":970808.489540631,"finish_reason":"length","first":970794.600247015,"full_response_s":14.025613117963076,"last":970808.48951658,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[970794.600247015,3],[970794.771483498,11],[970794.954717088,30],[970795.142766134,19],[970795.324510751,21],[970795.515363625,15],[970795.661503776,19],[970795.810052188,17],[970795.958156098,6],[970796.107320647,8],[970796.291017284,3],[970796.471098811,5],[970796.659236866,29],[970796.840024712,10],[970797.024970579,13],[970797.210889172,5],[970797.379998437,16],[970797.571449346,5],[970797.757144456,16],[970797.938297981,7],[970798.086938273,27],[970798.23768266,11],[970798.427590237,8],[970798.61785949,16],[970798.76551744,5],[970798.911907407,9],[970799.08471573,14],[970799.235205701,20],[970799.381719961,8],[970799.537868741,12],[970799.687148166,5],[970799.836320548,14],[970800.023106771,14],[970800.171282046,8],[970800.357141117,13],[970800.540055882,3],[970800.722391137,10],[970800.870126554,11],[970801.053782376,9],[970801.242149835,10],[970801.429019579,20],[970801.580903155,6],[970801.763353968,8],[970801.948188093,14],[970802.182930332,13],[970802.33250715,5],[970802.527008695,22],[970802.757055571,3],[970802.997429275,43],[970803.182982668,22],[970803.367709977,11],[970803.561499267,6],[970803.734481796,8],[970803.883493361,9],[970804.032714792,13],[970804.180347633,8],[970804.333400065,20],[970804.490392055,17],[970804.675891096,20],[970804.824769346,13],[970805.010365095,6],[970805.193962685,13],[970805.343773034,9],[970805.501174318,11],[970805.651207221,8],[970805.837754213,15],[970806.023802967,16],[970806.208676637,31],[970806.400038856,5],[970806.59153477,13],[970806.776445196,30],[970806.924083933,11],[970807.09949532,5],[970807.284044672,64],[970807.438139368,2],[970807.629604021,10],[970807.802875649,11],[970807.95136933,15],[970808.105419427,17],[970808.297396979,14],[970808.48951658,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-46a3895db9476ac138d4e75c808f6d23","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.032645425,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.889166546,"time_to_first_token":0.13415932,"token_sha":"8a91591c94a3","tokens_per_second":18.359632966849155},"seed":1234,"sent":970794.463927513,"speculative":{"acceptance_rate":0.40792540792540793,"accepted":175,"drafted":429,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.13631950202398002,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":429,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} diff --git a/validation/pr608-exact-cache/requests-reverse.jsonl b/validation/pr608-exact-cache/requests-reverse.jsonl new file mode 100644 index 000000000..a800cf870 --- /dev/null +++ b/validation/pr608-exact-cache/requests-reverse.jsonl @@ -0,0 +1,312 @@ +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":1,"burst":null,"stream":0,"phase":"warmup","request":{"cache_state":"cold","cached_tokens":0,"case_id":null,"complete":true,"decode_tps":58.3166930938117,"done":971570.18189167,"finish_reason":"length","first":971569.924634318,"full_response_s":0.3998692419845611,"last":971570.181850549,"output_sha256":"26fc9e1892da6e23aa1a0cb06681c20c4a62f7257e19635806de87234b9035bb","pieces":[[971569.924634318,2],[971570.011307711,7],[971570.091803253,4],[971570.181850549,73]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":16,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"e9df2e35a58091c749bae4e1446600aeb669237cc39db72a41d5cae938d5620a","response_id":"cmpl-eef79832cc78d468314310541fc2df15","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.126497247,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":0.258589093,"time_to_first_token":0.127854267,"token_sha":"41b4449e1b18","tokens_per_second":58.007086942371544},"seed":1234,"sent":971569.782022428,"speculative":{"acceptance_rate":0.26666666666666666,"accepted":12,"drafted":45,"rounds":3,"tokens_per_round":5.333333333333333},"token_sha":"41b4449e1b18","tokens":16,"ttft_s":0.14261188998352736,"usage":{"completion_tokens":16,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":0},"total_tokens":30},"work":{"accepted":12,"drafted":45,"rounds":3},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":1,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":69.41195157942639,"done":971573.868113277,"finish_reason":"length","first":971570.194192747,"full_response_s":3.685287144035101,"last":971573.86791167,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971570.194192747,2],[971570.282880366,7],[971570.363416213,4],[971570.443969453,73],[971570.524600456,51],[971570.606113055,21],[971570.687303452,14],[971570.767092939,20],[971570.847660914,16],[971570.928396732,15],[971571.009190519,23],[971571.09035992,23],[971571.177037885,25],[971571.260410429,36],[971571.340689528,14],[971571.421814031,6],[971571.5032552,18],[971571.583234897,18],[971571.664169106,19],[971571.744363754,8],[971571.824830043,11],[971571.905773912,18],[971571.98707072,15],[971572.068217348,39],[971572.154086786,30],[971572.238451647,14],[971572.319554897,15],[971572.399902715,8],[971572.481510397,6],[971572.561992667,15],[971572.644888856,23],[971572.725373926,22],[971572.805616428,26],[971572.88727958,35],[971572.968399419,31],[971573.049751026,12],[971573.133281023,13],[971573.218514021,38],[971573.300363355,47],[971573.381334661,25],[971573.462608041,11],[971573.543031057,34],[971573.624056764,12],[971573.704819231,36],[971573.786089523,60],[971573.86791167,48]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-b474fe9c0e8083094add6a6dd1c99df0","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.010026873,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":3.673981493,"time_to_first_token":0.010636573,"token_sha":"2b28aa2108de","tokens_per_second":69.40699088600445},"seed":1234,"sent":971570.182826133,"speculative":{"acceptance_rate":0.31555555555555553,"accepted":213,"drafted":675,"rounds":45,"tokens_per_round":5.688888888888889},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.011366614024154842,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":213,"drafted":675,"rounds":45},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":1,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":69.21533578373189,"done":971577.557662998,"finish_reason":"length","first":971573.873481292,"full_response_s":3.688612314988859,"last":971577.557635925,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971573.873481292,2],[971573.960446022,7],[971574.041638243,4],[971574.124302656,73],[971574.210984689,51],[971574.292391125,21],[971574.372857195,14],[971574.453928708,20],[971574.53440385,16],[971574.617392673,15],[971574.697788437,23],[971574.778270731,23],[971574.858935716,25],[971574.939943703,36],[971575.021259173,14],[971575.102547153,6],[971575.189706685,18],[971575.272363318,18],[971575.352962956,19],[971575.433008864,8],[971575.514293116,11],[971575.595129338,18],[971575.675346067,15],[971575.755801348,39],[971575.836679714,30],[971575.918010028,14],[971575.999100766,15],[971576.08043932,8],[971576.166427162,6],[971576.250388441,15],[971576.331041421,23],[971576.411585805,22],[971576.493317044,26],[971576.573685423,35],[971576.656953896,31],[971576.737347251,12],[971576.818322129,13],[971576.899004466,38],[971576.98076519,47],[971577.062266385,25],[971577.147778335,11],[971577.232637352,34],[971577.313516047,12],[971577.394144622,36],[971577.475155162,60],[971577.557635925,48]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-fa1ad15ad3c854af3a17a436d1e4b694","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.003389711,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":3.683710378,"time_to_first_token":0.003788348,"token_sha":"2b28aa2108de","tokens_per_second":69.22368314374579},"seed":1234,"sent":971573.869050683,"speculative":{"acceptance_rate":0.31555555555555553,"accepted":213,"drafted":675,"rounds":45,"tokens_per_round":5.688888888888889},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.004430609056726098,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":213,"drafted":675,"rounds":45},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":1,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":69.20667719649116,"done":971581.247959004,"finish_reason":"length","first":971577.563300541,"full_response_s":3.688717187033035,"last":971581.247916106,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971577.563300541,2],[971577.649709401,7],[971577.730400554,4],[971577.810289217,73],[971577.890935085,51],[971577.972322529,21],[971578.053831016,14],[971578.136979157,20],[971578.222945646,16],[971578.305078554,15],[971578.385385435,23],[971578.466629418,23],[971578.547438043,25],[971578.629774766,36],[971578.710664274,14],[971578.791359311,6],[971578.871659053,18],[971578.952855078,18],[971579.034141379,19],[971579.116027651,8],[971579.202421446,11],[971579.285263989,18],[971579.365424301,15],[971579.446979043,39],[971579.527388211,30],[971579.608054123,14],[971579.688885865,15],[971579.769732248,8],[971579.850397118,6],[971579.930963216,15],[971580.012793754,23],[971580.093764073,22],[971580.180943776,26],[971580.26434171,35],[971580.345234202,31],[971580.426164871,12],[971580.507741945,13],[971580.588302746,38],[971580.671303899,47],[971580.752147765,25],[971580.832715366,11],[971580.913417128,34],[971580.994505382,12],[971581.076396543,36],[971581.162160533,60],[971581.247916106,48]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-21721b3952352b9060f0409bea581f24","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.003288059,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":3.684477704,"time_to_first_token":0.003582549,"token_sha":"2b28aa2108de","tokens_per_second":69.20926668199483},"seed":1234,"sent":971577.559241817,"speculative":{"acceptance_rate":0.31555555555555553,"accepted":213,"drafted":675,"rounds":45,"tokens_per_round":5.688888888888889},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.004058724036440253,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":213,"drafted":675,"rounds":45},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.526978764398816,"done":971591.494056994,"finish_reason":"length","first":971581.50460116,"full_response_s":10.242103956989013,"last":971591.494032434,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971581.50460116,2],[971581.65190218,7],[971581.798454839,4],[971582.011862324,63],[971582.249975885,10],[971582.431055557,31],[971582.615285251,29],[971582.79697715,22],[971582.979270773,14],[971583.166531772,24],[971583.353385941,4],[971583.499174786,13],[971583.680066779,21],[971583.862391888,2],[971584.042789105,18],[971584.231692435,29],[971584.468153137,27],[971584.705307669,24],[971584.85315566,4],[971585.001973788,16],[971585.246960337,10],[971585.424435387,31],[971585.574444002,8],[971585.758722679,11],[971585.939171899,16],[971586.12541191,12],[971586.312138864,39],[971586.48817106,18],[971586.669752377,11],[971586.850848381,16],[971587.034321383,16],[971587.18720414,11],[971587.371827738,6],[971587.557780724,9],[971587.739254829,29],[971587.923339269,22],[971588.10530247,8],[971588.26131404,18],[971588.446929485,18],[971588.631516242,34],[971588.815300156,10],[971589.000372632,14],[971589.187196475,13],[971589.372250918,2],[971589.554294945,36],[971589.738651878,42],[971589.925819758,26],[971590.073901317,17],[971590.265919445,34],[971590.50364492,12],[971590.689604295,36],[971590.975145465,50],[971591.164277205,2],[971591.494032434,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-3f07d8ac6747919331d9ebe0732c6480","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.159261887,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.990181315,"time_to_first_token":0.248880769,"token_sha":"2b28aa2108de","tokens_per_second":25.52506225458832},"seed":1234,"sent":971581.251953037,"speculative":{"acceptance_rate":0.559228650137741,"accepted":203,"drafted":363,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2526481229579076,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":363,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":1,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.52545403127018,"done":971591.494628229,"finish_reason":"length","first":971581.50455815,"full_response_s":10.242145590949804,"last":971591.494586131,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971581.50455815,2],[971581.652101274,7],[971581.799168206,4],[971582.012765665,63],[971582.248862345,10],[971582.431125783,31],[971582.614294563,29],[971582.799822538,22],[971582.97911176,14],[971583.166379559,24],[971583.351656621,4],[971583.498701667,13],[971583.681351077,21],[971583.860979203,2],[971584.042601291,18],[971584.230892218,29],[971584.466701042,27],[971584.706449242,24],[971584.852980118,4],[971585.002541871,16],[971585.243314284,10],[971585.423946283,31],[971585.57327078,8],[971585.755953614,11],[971585.939727036,16],[971586.124024473,12],[971586.316454427,39],[971586.48644342,18],[971586.66934806,11],[971586.851341677,16],[971587.033852472,16],[971587.186512806,11],[971587.370891868,6],[971587.557501691,9],[971587.73898522,29],[971587.923586573,22],[971588.105101375,8],[971588.261108097,18],[971588.446960046,18],[971588.631423711,34],[971588.814156904,10],[971588.998710963,14],[971589.187093432,13],[971589.372783415,2],[971589.554069386,36],[971589.738894973,42],[971589.923928114,26],[971590.075103291,17],[971590.267790353,34],[971590.503726219,12],[971590.689958483,36],[971590.976064614,50],[971591.164658225,2],[971591.494586131,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-c03695914fb6656a2a868ccfb01d4f69","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.159199693,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.990182867,"time_to_first_token":0.248736812,"token_sha":"2b28aa2108de","tokens_per_second":25.525058289205788},"seed":1234,"sent":971581.252482638,"speculative":{"acceptance_rate":0.559228650137741,"accepted":203,"drafted":363,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.25207551196217537,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":363,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":2,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.522889997276415,"done":971591.495435086,"finish_reason":"length","first":971581.504351424,"full_response_s":10.243829980958253,"last":971591.495383005,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971581.504351424,2],[971581.653425733,7],[971581.798721648,4],[971582.012978072,63],[971582.25130508,10],[971582.434480004,31],[971582.61495924,29],[971582.797600546,22],[971582.978209395,14],[971583.165797668,24],[971583.352466567,4],[971583.498292966,13],[971583.681283507,21],[971583.861708826,2],[971584.042146108,18],[971584.232645314,29],[971584.468339687,27],[971584.705822502,24],[971584.854504935,4],[971585.003281942,16],[971585.2444324,10],[971585.42459384,31],[971585.574525765,8],[971585.758315738,11],[971585.941718604,16],[971586.123730272,12],[971586.314654881,39],[971586.487024303,18],[971586.669089284,11],[971586.85291432,16],[971587.033769349,16],[971587.186560903,11],[971587.371445358,6],[971587.557092125,9],[971587.741926707,29],[971587.922710417,22],[971588.104888872,8],[971588.263525246,18],[971588.448872155,18],[971588.63188659,34],[971588.814300668,10],[971588.998463163,14],[971589.187546166,13],[971589.371382827,2],[971589.555372259,36],[971589.741301706,42],[971589.924074631,26],[971590.074279329,17],[971590.266542793,34],[971590.504852415,12],[971590.690152729,36],[971590.975341247,50],[971591.164527021,2],[971591.495383005,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-1a2d8a093f63bfa92a0042c87bfeaea3","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.159492359,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.99242681,"time_to_first_token":0.246642761,"token_sha":"2b28aa2108de","tokens_per_second":25.519326270651966},"seed":1234,"sent":971581.251605105,"speculative":{"acceptance_rate":0.5638888888888889,"accepted":203,"drafted":360,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.252746319049038,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":360,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":3,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.523816778663633,"done":971591.494276217,"finish_reason":"length","first":971581.503562246,"full_response_s":10.241191399982199,"last":971591.494231048,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971581.503562246,2],[971581.652316993,7],[971581.799433143,4],[971582.011600651,63],[971582.250682804,10],[971582.432068694,31],[971582.615117949,29],[971582.79789422,22],[971582.979368312,14],[971583.166968714,24],[971583.352914646,4],[971583.498924586,13],[971583.680874437,21],[971583.86225574,2],[971584.042677037,18],[971584.232580384,29],[971584.46707747,27],[971584.706023932,24],[971584.853215806,4],[971585.005628418,16],[971585.2436826,10],[971585.423208996,31],[971585.572512996,8],[971585.755863323,11],[971585.940511414,16],[971586.123581451,12],[971586.313837639,39],[971586.487481982,18],[971586.669208904,11],[971586.850130918,16],[971587.035318135,16],[971587.188059287,11],[971587.371999104,6],[971587.555702993,9],[971587.739212492,29],[971587.924745778,22],[971588.104601951,8],[971588.261223605,18],[971588.448462334,18],[971588.632293531,34],[971588.814415328,10],[971588.997463339,14],[971589.187341344,13],[971589.37017738,2],[971589.554805025,36],[971589.738989312,42],[971589.92348826,26],[971590.074236943,17],[971590.266185038,34],[971590.502964515,12],[971590.689160617,36],[971590.977259964,50],[971591.163474459,2],[971591.494231048,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-961c47c57baa7d3fb5b062f42320692d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.159340274,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.990225812,"time_to_first_token":0.248253789,"token_sha":"2b28aa2108de","tokens_per_second":25.52494856459607},"seed":1234,"sent":971581.253084817,"speculative":{"acceptance_rate":0.5623268698060941,"accepted":203,"drafted":361,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2504774290136993,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":361,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":4,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.521608275433202,"done":971591.49536598,"finish_reason":"length","first":971581.503791262,"full_response_s":10.24332049197983,"last":971591.495324603,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971581.503791262,2],[971581.652904708,7],[971581.79884274,4],[971582.013134045,63],[971582.249462493,10],[971582.431354063,31],[971582.615759554,29],[971582.797975662,22],[971582.978449323,14],[971583.166612302,24],[971583.35371368,4],[971583.498105056,13],[971583.680337908,21],[971583.861656489,2],[971584.042028616,18],[971584.232949948,29],[971584.467940186,27],[971584.706702402,24],[971584.854576665,4],[971585.004271958,16],[971585.243064068,10],[971585.425086256,31],[971585.573841615,8],[971585.758792281,11],[971585.940145178,16],[971586.12467067,12],[971586.311772309,39],[971586.485767031,18],[971586.67051205,11],[971586.852048436,16],[971587.032977884,16],[971587.186195276,11],[971587.372547698,6],[971587.556766963,9],[971587.74164665,29],[971587.922042219,22],[971588.104785973,8],[971588.263965964,18],[971588.445991087,18],[971588.632011121,34],[971588.815922784,10],[971588.999588367,14],[971589.187885489,13],[971589.370682548,2],[971589.554996215,36],[971589.739971744,42],[971589.924917538,26],[971590.07420299,17],[971590.268105387,34],[971590.504412081,12],[971590.690965779,36],[971590.977628632,50],[971591.164477803,2],[971591.495324603,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-c11efac775c370c5ed56246ff85ac25d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.159453109,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.99241705,"time_to_first_token":0.246549062,"token_sha":"2b28aa2108de","tokens_per_second":25.519351196415485},"seed":1234,"sent":971581.252045488,"speculative":{"acceptance_rate":0.5638888888888889,"accepted":203,"drafted":360,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.25174577406141907,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":360,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":5,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.52028565138516,"done":971591.495971759,"finish_reason":"length","first":971581.503721611,"full_response_s":10.244857948971912,"last":971591.495772777,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971581.503721611,2],[971581.650961893,7],[971581.799918615,4],[971582.012348963,63],[971582.249273271,10],[971582.434115672,31],[971582.614460376,29],[971582.800188566,22],[971582.978896873,14],[971583.167538028,24],[971583.352837667,4],[971583.498184866,13],[971583.680106877,21],[971583.860836382,2],[971584.042193518,18],[971584.230500509,29],[971584.467033117,27],[971584.705696082,24],[971584.854739503,4],[971585.003370841,16],[971585.244155127,10],[971585.42602171,31],[971585.573331822,8],[971585.758646229,11],[971585.939850208,16],[971586.12423832,12],[971586.31475538,39],[971586.484449244,18],[971586.669883758,11],[971586.850342013,16],[971587.034835943,16],[971587.187697964,11],[971587.371953438,6],[971587.556927256,9],[971587.741507317,29],[971587.922474377,22],[971588.105406009,8],[971588.262703444,18],[971588.446502991,18],[971588.632358525,34],[971588.813715322,10],[971588.998548702,14],[971589.187448515,13],[971589.37124951,2],[971589.555069562,36],[971589.738526882,42],[971589.924590775,26],[971590.07526032,17],[971590.266760304,34],[971590.505220507,12],[971590.689521029,36],[971590.97705055,50],[971591.164961722,2],[971591.495772777,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-339ae463d9ea377db2e048596454905a","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.15953084,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.992777829,"time_to_first_token":0.246121208,"token_sha":"2b28aa2108de","tokens_per_second":25.51842984640022},"seed":1234,"sent":971581.25111381,"speculative":{"acceptance_rate":0.5638888888888889,"accepted":203,"drafted":360,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2526078009977937,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":360,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":6,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.52092187295948,"done":971591.497133092,"finish_reason":"length","first":971581.504465587,"full_response_s":10.245001025032252,"last":971591.496267657,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971581.504465587,2],[971581.651165708,7],[971581.800361285,4],[971582.012113724,63],[971582.250737334,10],[971582.430587974,31],[971582.615643758,29],[971582.799577346,22],[971582.978098335,14],[971583.166869559,24],[971583.352533626,4],[971583.499016829,13],[971583.68046972,21],[971583.861346239,2],[971584.042104987,18],[971584.232373113,29],[971584.468997388,27],[971584.705119167,24],[971584.852723022,4],[971585.003988781,16],[971585.242926079,10],[971585.423635553,31],[971585.572674249,8],[971585.758429422,11],[971585.939603721,16],[971586.125191503,12],[971586.31667893,39],[971586.485544448,18],[971586.668332268,11],[971586.850716265,16],[971587.033157554,16],[971587.18776555,11],[971587.371243176,6],[971587.556018843,9],[971587.739755165,29],[971587.923874422,22],[971588.104660721,8],[971588.261563936,18],[971588.445804457,18],[971588.632807659,34],[971588.814739818,10],[971588.999741284,14],[971589.188810015,13],[971589.37260957,2],[971589.554459958,36],[971589.738828555,42],[971589.924120376,26],[971590.074644156,17],[971590.265309634,34],[971590.505422833,12],[971590.690522277,36],[971590.976511701,50],[971591.163682002,2],[971591.496267657,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-f2df7d424527c2d08fd2a02678caee8a","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.159666283,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.993151698,"time_to_first_token":0.245584854,"token_sha":"2b28aa2108de","tokens_per_second":25.517475137601977},"seed":1234,"sent":971581.252132067,"speculative":{"acceptance_rate":0.5654596100278552,"accepted":203,"drafted":359,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2523335199803114,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":359,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":7,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.52086523157025,"done":971591.495863996,"finish_reason":"length","first":971581.50399178,"full_response_s":10.243638421990909,"last":971591.495816026,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971581.50399178,2],[971581.653641148,7],[971581.799518794,4],[971582.012265633,63],[971582.252151492,10],[971582.433549174,31],[971582.613957608,29],[971582.798282664,22],[971582.979432362,14],[971583.16591492,24],[971583.352712847,4],[971583.500578911,13],[971583.680958792,21],[971583.861924321,2],[971584.042471655,18],[971584.231876457,29],[971584.467823718,27],[971584.70596145,24],[971584.853947541,4],[971585.005973629,16],[971585.244713209,10],[971585.424495325,31],[971585.57313668,8],[971585.757895596,11],[971585.94195858,16],[971586.125033258,12],[971586.314977084,39],[971586.485373114,18],[971586.669470528,11],[971586.851480994,16],[971587.034549982,16],[971587.187969124,11],[971587.371089443,6],[971587.558365158,9],[971587.739114777,29],[971587.921801572,22],[971588.105024509,8],[971588.264080336,18],[971588.44544899,18],[971588.632404558,34],[971588.814536324,10],[971588.999131136,14],[971589.189046854,13],[971589.371450653,2],[971589.553839906,36],[971589.738729192,42],[971589.925578695,26],[971590.07456025,17],[971590.266920181,34],[971590.503934514,12],[971590.689292141,36],[971590.975970307,50],[971591.164586366,2],[971591.495816026,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-83e0acb98be4ace8fd707f86f948198b","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.159569129,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.992696179,"time_to_first_token":0.246321582,"token_sha":"2b28aa2108de","tokens_per_second":25.51863835667209},"seed":1234,"sent":971581.252225574,"speculative":{"acceptance_rate":0.5654596100278552,"accepted":203,"drafted":359,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2517662059981376,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":359,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":8,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.522303703987482,"done":971591.494541378,"finish_reason":"length","first":971581.503248092,"full_response_s":10.241217560949735,"last":971591.494509185,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971581.503248092,2],[971581.652761727,7],[971581.799363637,4],[971582.012588651,63],[971582.251766455,10],[971582.432836431,31],[971582.614395574,29],[971582.798246343,22],[971582.978338631,14],[971583.16648033,24],[971583.352771841,4],[971583.497954699,13],[971583.682180911,21],[971583.861609959,2],[971584.042411141,18],[971584.232875689,29],[971584.467393113,27],[971584.705512876,24],[971584.853690157,4],[971585.00188593,16],[971585.245298892,10],[971585.426260006,31],[971585.574285469,8],[971585.758018336,11],[971585.939386994,16],[971586.123486824,12],[971586.314523437,39],[971586.484230373,18],[971586.670763322,11],[971586.851727081,16],[971587.032772789,16],[971587.185882402,11],[971587.371346875,6],[971587.556618238,9],[971587.741438931,29],[971587.923014875,22],[971588.105167377,8],[971588.261484253,18],[971588.446792489,18],[971588.631589892,34],[971588.813981058,10],[971588.998984732,14],[971589.188289806,13],[971589.370531183,2],[971589.554235823,36],[971589.739402254,42],[971589.923377904,26],[971590.074497448,17],[971590.267026136,34],[971590.505505988,12],[971590.690051462,36],[971590.974667626,50],[971591.165260132,2],[971591.494509185,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-7a45bcd5f51a57861e3928d4a85bca4a","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.159300624,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.990227124,"time_to_first_token":0.24810356,"token_sha":"2b28aa2108de","tokens_per_second":25.524945212446802},"seed":1234,"sent":971581.253323817,"speculative":{"acceptance_rate":0.5623268698060941,"accepted":203,"drafted":361,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.24992427497636527,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":361,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":9,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.522347929316826,"done":971591.494938127,"finish_reason":"length","first":971581.503666554,"full_response_s":10.24203345994465,"last":971591.494910334,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971581.503666554,2],[971581.651481606,7],[971581.798926855,4],[971582.011665373,63],[971582.2495584,10],[971582.43181923,31],[971582.615917751,29],[971582.798801049,22],[971582.978286069,14],[971583.166182288,24],[971583.351930662,4],[971583.499630545,13],[971583.681054283,21],[971583.861977539,2],[971584.042629196,18],[971584.232463852,29],[971584.467273397,27],[971584.704828262,24],[971584.854012327,4],[971585.002646114,16],[971585.247246986,10],[971585.425202724,31],[971585.574872384,8],[971585.756320282,11],[971585.942304975,16],[971586.123417142,12],[971586.312511836,39],[971586.48585481,18],[971586.669626597,11],[971586.850917008,16],[971587.033943195,16],[971587.185673451,11],[971587.370417421,6],[971587.556308948,9],[971587.740498725,29],[971587.924197312,22],[971588.10555931,8],[971588.263257574,18],[971588.445661636,18],[971588.632691831,34],[971588.81536299,10],[971589.001183122,14],[971589.187999845,13],[971589.371970845,2],[971589.555234319,36],[971589.739166902,42],[971589.924264621,26],[971590.073834978,17],[971590.267232431,34],[971590.503204106,12],[971590.689365568,36],[971590.975272829,50],[971591.164905769,2],[971591.494910334,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-a9be4e112eb5bb7c4d4c6705e5f33ae9","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.1594149,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.991839416,"time_to_first_token":0.24723086,"token_sha":"2b28aa2108de","tokens_per_second":25.520826484827886},"seed":1234,"sent":971581.252904667,"speculative":{"acceptance_rate":0.5638888888888889,"accepted":203,"drafted":360,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.25076188694220036,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":360,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":10,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.51934065425613,"done":971591.495923902,"finish_reason":"length","first":971581.503476883,"full_response_s":10.244711608975194,"last":971591.495898061,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971581.503476883,2],[971581.652476246,7],[971581.799297139,4],[971582.011965143,63],[971582.251494478,10],[971582.433287821,31],[971582.616173071,29],[971582.799648948,22],[971582.979676738,14],[971583.165977642,24],[971583.352650541,4],[971583.500648418,13],[971583.679764258,21],[971583.860758972,2],[971584.042371363,18],[971584.231066383,29],[971584.467122192,27],[971584.706191634,24],[971584.852814961,4],[971585.002048927,16],[971585.245450929,10],[971585.425624625,31],[971585.573009604,8],[971585.757331738,11],[971585.940024278,16],[971586.12418667,12],[971586.31343633,39],[971586.484917595,18],[971586.668094036,11],[971586.85285107,16],[971587.033530942,16],[971587.186030726,11],[971587.370516064,6],[971587.557647775,9],[971587.739882881,29],[971587.923494842,22],[971588.104833511,8],[971588.262224245,18],[971588.446454766,18],[971588.632637158,34],[971588.81360463,10],[971589.000639856,14],[971589.189559079,13],[971589.371895995,2],[971589.555134268,36],[971589.740774953,42],[971589.924225228,26],[971590.074140604,17],[971590.267378324,34],[971590.505360255,12],[971590.689916753,36],[971590.97666985,50],[971591.165065102,2],[971591.495898061,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-ae67fd195151001f48312860a60691a8","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.159607082,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.992756388,"time_to_first_token":0.246267373,"token_sha":"2b28aa2108de","tokens_per_second":25.51848460012713},"seed":1234,"sent":971581.251212293,"speculative":{"acceptance_rate":0.5654596100278552,"accepted":203,"drafted":359,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2522645900025964,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":359,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":11,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.525479947695594,"done":971591.493052114,"finish_reason":"length","first":971581.502979539,"full_response_s":10.241368478047661,"last":971591.492997377,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971581.502979539,2],[971581.652809041,7],[971581.80019344,4],[971582.011534057,63],[971582.250510671,10],[971582.433808798,31],[971582.616244178,29],[971582.797326409,22],[971582.978517821,14],[971583.167044876,24],[971583.352078395,4],[971583.499677618,13],[971583.679963304,21],[971583.861541941,2],[971584.042732543,18],[971584.23176447,29],[971584.466802998,27],[971584.707096239,24],[971584.85434357,4],[971585.002454828,16],[971585.246368222,10],[971585.4243306,31],[971585.574486948,8],[971585.756222311,11],[971585.940661306,16],[971586.124458167,12],[971586.315846391,39],[971586.485102017,18],[971586.670274058,11],[971586.851949393,16],[971587.03523242,16],[971587.18676707,11],[971587.370952046,6],[971587.558430632,9],[971587.739609784,29],[971587.92312115,22],[971588.105487052,8],[971588.26170858,18],[971588.447829914,18],[971588.633341228,34],[971588.815690169,10],[971588.99787204,14],[971589.18927731,13],[971589.371140947,2],[971589.554735823,36],[971589.739103732,42],[971589.925161465,26],[971590.074527081,17],[971590.267099483,34],[971590.503328942,12],[971590.689424994,36],[971590.977567046,50],[971591.163778245,2],[971591.492997377,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-a492ac9a1c635d474e0bf503010d3d3f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.159161564,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.990149153,"time_to_first_token":0.248897522,"token_sha":"2b28aa2108de","tokens_per_second":25.525144429242534},"seed":1234,"sent":971581.251683636,"speculative":{"acceptance_rate":0.559228650137741,"accepted":203,"drafted":363,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.25129590299911797,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":363,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":12,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.522422315776133,"done":971591.494123124,"finish_reason":"length","first":971581.5028852,"full_response_s":10.242379310075194,"last":971591.49409986,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971581.5028852,2],[971581.653529832,7],[971581.799983897,4],[971582.012057082,63],[971582.249661795,10],[971582.431856815,31],[971582.613894694,29],[971582.797203078,22],[971582.979139809,14],[971583.16605958,24],[971583.351853044,4],[971583.499117456,13],[971583.681607645,21],[971583.861428129,2],[971584.042321474,18],[971584.231175459,29],[971584.467324806,27],[971584.707510988,24],[971584.853628171,4],[971585.006289271,16],[971585.245179256,10],[971585.424676227,31],[971585.57289216,8],[971585.75701296,11],[971585.940996245,16],[971586.124405077,12],[971586.313128272,39],[971586.486144515,18],[971586.671043763,11],[971586.853321021,16],[971587.03265877,16],[971587.185788366,11],[971587.370321994,6],[971587.558026123,9],[971587.73979507,29],[971587.923915143,22],[971588.105229459,8],[971588.262984477,18],[971588.448213302,18],[971588.631954864,34],[971588.81409895,10],[971588.997741348,14],[971589.18854583,13],[971589.372715781,2],[971589.555317122,36],[971589.739664758,42],[971589.923612168,26],[971590.073651885,17],[971590.267173629,34],[971590.504810702,12],[971590.690756316,36],[971590.977920145,50],[971591.164334502,2],[971591.49409986,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-cafe1781b929757877edb1e9fff90985","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.159122618,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.990189571,"time_to_first_token":0.24914529,"token_sha":"2b28aa2108de","tokens_per_second":25.52504116040262},"seed":1234,"sent":971581.251743814,"speculative":{"acceptance_rate":0.559228650137741,"accepted":203,"drafted":363,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.251141385990195,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":363,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":13,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.52383288422899,"done":971591.494804346,"finish_reason":"length","first":971581.504092919,"full_response_s":10.243489186046645,"last":971591.494755417,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971581.504092919,2],[971581.653848163,7],[971581.800071868,4],[971582.012508089,63],[971582.248606801,10],[971582.431711466,31],[971582.61413611,29],[971582.797790264,22],[971582.979226932,14],[971583.16746169,24],[971583.351579307,4],[971583.498376568,13],[971583.680530586,21],[971583.861742363,2],[971584.042248511,18],[971584.232808647,29],[971584.468466459,27],[971584.707624272,24],[971584.85421211,4],[971585.005148258,16],[971585.245878174,10],[971585.423847144,31],[971585.575273789,8],[971585.757620996,11],[971585.941153354,16],[971586.124527017,12],[971586.315550318,39],[971586.486749558,18],[971586.670172759,11],[971586.851076245,16],[971587.032876345,16],[971587.187091752,11],[971587.37101584,6],[971587.557405944,9],[971587.741285086,29],[971587.922637983,22],[971588.10536764,8],[971588.263780854,18],[971588.448674405,18],[971588.631653126,34],[971588.815195161,10],[971588.999978187,14],[971589.187586504,13],[971589.370455581,2],[971589.555414437,36],[971589.739590436,42],[971589.924320207,26],[971590.075143292,17],[971590.265660061,34],[971590.503993875,12],[971590.690696394,36],[971590.975640841,50],[971591.163590559,2],[971591.494755417,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-cff701b7815027037b7497ee3bb9d7dc","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.159373459,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.990461579,"time_to_first_token":0.247535654,"token_sha":"2b28aa2108de","tokens_per_second":25.524346195976698},"seed":1234,"sent":971581.25131516,"speculative":{"acceptance_rate":0.5638888888888889,"accepted":203,"drafted":360,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.25277775910217315,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":360,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":14,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":24.91114833037863,"done":971591.493698279,"finish_reason":"length","first":971581.256464223,"full_response_s":10.242293196031824,"last":971591.492845004,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971581.256464223,2],[971581.344348953,7],[971581.65167286,4],[971581.80013307,72],[971582.012194142,1],[971582.248221397,27],[971582.430436641,30],[971582.613789554,15],[971582.796641811,14],[971582.979074687,20],[971583.1667877,14],[971583.35111982,4],[971583.499574495,13],[971583.68181882,21],[971583.861493363,2],[971584.042540729,18],[971584.230327543,29],[971584.468721635,27],[971584.705628911,24],[971584.853887923,4],[971585.002320375,16],[971585.244991122,10],[971585.423119681,31],[971585.573518836,8],[971585.756758504,11],[971585.940067687,16],[971586.123283569,12],[971586.311260452,39],[971586.484327912,18],[971586.668683367,11],[971586.850255786,16],[971587.034461003,16],[971587.187605945,11],[971587.372351755,6],[971587.556499722,9],[971587.740666714,29],[971587.92280674,22],[971588.104729043,8],[971588.262297335,18],[971588.447522208,18],[971588.632078036,34],[971588.814634247,10],[971589.000028429,14],[971589.186950243,13],[971589.371834937,2],[971589.554660509,36],[971589.739469776,42],[971589.92417881,26],[971590.075062042,17],[971590.266641292,34],[971590.502852799,12],[971590.690307694,36],[971590.978123256,50],[971591.163955962,2],[971591.492845004,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-4be5dacce3a3777a27566f669e6c68c0","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.00339211,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.236532226,"time_to_first_token":0.003805499,"token_sha":"2b28aa2108de","tokens_per_second":24.91077978070735},"seed":1234,"sent":971581.251405083,"speculative":{"acceptance_rate":0.5474254742547425,"accepted":202,"drafted":369,"rounds":54,"tokens_per_round":4.7407407407407405},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.005059140035882592,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":202,"drafted":369,"rounds":54},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":0,"stream":15,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.53019956836545,"done":971591.492928142,"finish_reason":"length","first":971581.504727084,"full_response_s":10.241932703997009,"last":971591.492898125,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971581.504727084,2],[971581.652545209,7],[971581.798356388,4],[971582.012686766,63],[971582.248702612,10],[971582.431253948,31],[971582.61606766,29],[971582.798392156,22],[971582.978992076,14],[971583.166305156,24],[971583.352323619,4],[971583.500044926,13],[971583.681551883,21],[971583.86202738,2],[971584.041974407,18],[971584.231292614,29],[971584.467429994,27],[971584.707385336,24],[971584.853540808,4],[971585.002939643,16],[971585.245731273,10],[971585.425946876,31],[971585.573598583,8],[971585.756483791,11],[971585.939304735,16],[971586.125125117,12],[971586.316146193,39],[971586.488437228,18],[971586.668961088,11],[971586.853809276,16],[971587.033697139,16],[971587.186385538,11],[971587.371893997,6],[971587.555838501,9],[971587.739169146,29],[971587.924960953,22],[971588.10494273,8],[971588.262490765,18],[971588.447192118,18],[971588.633224376,34],[971588.815607174,10],[971589.00088948,14],[971589.187491413,13],[971589.37030148,2],[971589.555451254,36],[971589.739226936,42],[971589.923202091,26],[971590.073776529,17],[971590.268826898,34],[971590.503386864,12],[971590.690919841,36],[971590.975211963,50],[971591.163865815,2],[971591.492898125,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-fc5c7654864b7ab4d4cee91dfd64038f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.159079833,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.990194659,"time_to_first_token":0.248922434,"token_sha":"2b28aa2108de","tokens_per_second":25.525028160514843},"seed":1234,"sent":971581.250995438,"speculative":{"acceptance_rate":0.5561643835616439,"accepted":203,"drafted":365,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.25373164599295706,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":365,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.30221470289472,"done":971601.727106805,"finish_reason":"length","first":971591.647010077,"full_response_s":10.223997921915725,"last":971601.725179241,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971591.647010077,2],[971591.830402336,7],[971591.977102845,4],[971592.198648151,63],[971592.4374962,10],[971592.620998551,31],[971592.803768655,29],[971592.986672164,22],[971593.174093463,14],[971593.360055052,24],[971593.543067924,4],[971593.690217767,13],[971593.873130089,21],[971594.056778396,2],[971594.244996032,18],[971594.428260183,29],[971594.668966796,27],[971594.905522409,24],[971595.055648462,4],[971595.210852659,16],[971595.454952889,10],[971595.635168903,31],[971595.783387871,8],[971595.966970032,11],[971596.154245829,16],[971596.342509721,12],[971596.52557444,39],[971596.699393827,18],[971596.885861883,11],[971597.06816801,16],[971597.258524279,16],[971597.40752241,11],[971597.589878555,6],[971597.774524356,9],[971597.962059473,29],[971598.147650815,22],[971598.33560372,8],[971598.483016578,18],[971598.670382168,18],[971598.856741421,34],[971599.038752306,10],[971599.231630333,14],[971599.417872103,13],[971599.600703526,2],[971599.784074998,36],[971599.967411293,42],[971600.154213553,26],[971600.308548935,17],[971600.495699317,34],[971600.732507789,12],[971600.916177705,36],[971601.210879297,50],[971601.396971589,2],[971601.725179241,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-a6915886adc17da810a3ea4f18c90edc","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.051191471,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.07884165,"time_to_first_token":0.140718724,"token_sha":"2b28aa2108de","tokens_per_second":25.300526474686702},"seed":1234,"sent":971591.503108883,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14390119398012757,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.30035103612154,"done":971601.726347277,"finish_reason":"length","first":971591.647397353,"full_response_s":10.223967009107582,"last":971601.726308892,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971591.647397353,2],[971591.82995357,7],[971591.97826533,4],[971592.198025251,63],[971592.439622907,10],[971592.621222782,31],[971592.80361169,29],[971592.98663165,22],[971593.174012613,14],[971593.361262723,24],[971593.544600468,4],[971593.691248808,13],[971593.874202075,21],[971594.056072629,2],[971594.244896285,18],[971594.430182436,29],[971594.668567983,27],[971594.906468743,24],[971595.056919222,4],[971595.210490344,16],[971595.453560269,10],[971595.637627157,31],[971595.783274331,8],[971595.96779697,11],[971596.154102128,16],[971596.343556986,12],[971596.526959332,39],[971596.701026359,18],[971596.885449806,11],[971597.068100216,16],[971597.258071769,16],[971597.407209024,11],[971597.591707925,6],[971597.774201898,9],[971597.961617603,29],[971598.148109934,22],[971598.336020661,8],[971598.484535586,18],[971598.67143257,18],[971598.857080536,34],[971599.039356821,10],[971599.232860244,14],[971599.416722659,13],[971599.599735336,2],[971599.785244651,36],[971599.967932382,42],[971600.155762145,26],[971600.311101575,17],[971600.494608307,34],[971600.731631058,12],[971600.918305036,36],[971601.210996964,50],[971601.398771406,2],[971601.726308892,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-d31aa08d5bc2c10df7b75853611e7a5f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.050765426,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.079347746,"time_to_first_token":0.141753637,"token_sha":"2b28aa2108de","tokens_per_second":25.29925610525711},"seed":1234,"sent":971591.502380268,"speculative":{"acceptance_rate":0.5486486486486486,"accepted":203,"drafted":370,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14501708501484245,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":370,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.303494529163622,"done":971601.726795676,"finish_reason":"length","first":971591.646984924,"full_response_s":10.22347561805509,"last":971601.724644344,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971591.646984924,2],[971591.829024101,7],[971591.977770242,4],[971592.198555956,63],[971592.437613851,10],[971592.622330882,31],[971592.803441701,29],[971592.987880922,22],[971593.173694298,14],[971593.360282835,24],[971593.544506833,4],[971593.689998288,13],[971593.873689835,21],[971594.056520468,2],[971594.246596147,18],[971594.429584081,29],[971594.668037071,27],[971594.907205183,24],[971595.055819059,4],[971595.210288609,16],[971595.456958296,10],[971595.635773962,31],[971595.784822508,8],[971595.968897293,11],[971596.155492092,16],[971596.341755633,12],[971596.524557128,39],[971596.700085145,18],[971596.884533505,11],[971597.067236989,16],[971597.258260079,16],[971597.407922503,11],[971597.589581378,6],[971597.775456625,9],[971597.959726856,29],[971598.147117199,22],[971598.336822511,8],[971598.483858077,18],[971598.671772932,18],[971598.855999382,34],[971599.038686896,10],[971599.230220481,14],[971599.417806661,13],[971599.604465725,2],[971599.784808429,36],[971599.966839179,42],[971600.154681471,26],[971600.308902706,17],[971600.493860011,34],[971600.732071616,12],[971600.917083814,36],[971601.212501764,50],[971601.397427267,2],[971601.724644344,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-24bb71e4a8013e05a7cb27b9acd46f34","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.051153246,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.078841746,"time_to_first_token":0.140800631,"token_sha":"2b28aa2108de","tokens_per_second":25.300526233701614},"seed":1234,"sent":971591.503320058,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14366486598737538,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.302197108431933,"done":971601.72489936,"finish_reason":"length","first":971591.646698035,"full_response_s":10.222575717954896,"last":971601.724874207,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971591.646698035,2],[971591.831102503,7],[971591.976550171,4],[971592.199913359,63],[971592.437842115,10],[971592.621298497,31],[971592.803111531,29],[971592.987622834,22],[971593.173880176,14],[971593.359895639,24],[971593.544860317,4],[971593.690151157,13],[971593.873040438,21],[971594.057036516,2],[971594.245412813,18],[971594.429841177,29],[971594.668397514,27],[971594.90567587,24],[971595.056313027,4],[971595.21055289,16],[971595.455954745,10],[971595.63793035,31],[971595.785468161,8],[971595.967268585,11],[971596.155170914,16],[971596.341649613,12],[971596.525116298,39],[971596.701279759,18],[971596.88442659,11],[971597.068932658,16],[971597.259223262,16],[971597.407154015,11],[971597.5904103,6],[971597.773847599,9],[971597.963266935,29],[971598.147579581,22],[971598.337134473,8],[971598.48390355,18],[971598.670594895,18],[971598.85621398,34],[971599.040474776,10],[971599.231501497,14],[971599.417599039,13],[971599.605023902,2],[971599.784293645,36],[971599.971241926,42],[971600.155711536,26],[971600.310426002,17],[971600.493679126,34],[971600.732451052,12],[971600.917416832,36],[971601.211718971,50],[971601.398122233,2],[971601.724874207,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-28c3c259b802a8b8b0e75998014fe5c5","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.05102177,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.07906236,"time_to_first_token":0.141143026,"token_sha":"2b28aa2108de","tokens_per_second":25.299972447040204},"seed":1234,"sent":971591.502323642,"speculative":{"acceptance_rate":0.553133514986376,"accepted":203,"drafted":367,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14437439292669296,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":367,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.296856249694667,"done":971601.726961089,"finish_reason":"length","first":971591.646623649,"full_response_s":10.224499362986535,"last":971601.7269276,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971591.646623649,2],[971591.829119096,7],[971591.978646702,4],[971592.19935779,63],[971592.436988552,10],[971592.621147532,31],[971592.803358658,29],[971592.987576736,22],[971593.174477779,14],[971593.360146111,24],[971593.544183447,4],[971593.692210887,13],[971593.873527605,21],[971594.057828637,2],[971594.245684598,18],[971594.428722885,29],[971594.66883948,27],[971594.905604652,24],[971595.057355188,4],[971595.210224255,16],[971595.453815557,10],[971595.636982704,31],[971595.783188584,8],[971595.966638021,11],[971596.15370802,16],[971596.342930774,12],[971596.52442946,39],[971596.699211789,18],[971596.885110963,11],[971597.06740973,16],[971597.260169595,16],[971597.406962809,11],[971597.590152916,6],[971597.77460135,9],[971597.963480462,29],[971598.147288564,22],[971598.33586416,8],[971598.483525682,18],[971598.671111199,18],[971598.856583784,34],[971599.039881125,10],[971599.230036731,14],[971599.417349591,13],[971599.60039406,2],[971599.784510852,36],[971599.970957709,42],[971600.155373957,26],[971600.310913521,17],[971600.494155637,34],[971600.732129761,12],[971600.916944833,36],[971601.211265757,50],[971601.397349473,2],[971601.7269276,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-70b7423af3d073ac7e0ffbf4a105c190","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050983592,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.07909913,"time_to_first_token":0.141417947,"token_sha":"2b28aa2108de","tokens_per_second":25.299880149110113},"seed":1234,"sent":971591.502461726,"speculative":{"acceptance_rate":0.553133514986376,"accepted":203,"drafted":367,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14416192308999598,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":367,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.296655721996,"done":971601.726413184,"finish_reason":"length","first":971591.645998077,"full_response_s":10.2235540850088,"last":971601.726381935,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971591.645998077,2],[971591.829843727,7],[971591.977989529,4],[971592.199498242,63],[971592.437800545,10],[971592.622252351,31],[971592.80415286,29],[971592.986519215,22],[971593.174293406,14],[971593.363906487,24],[971593.544251417,4],[971593.691193398,13],[971593.875732747,21],[971594.056949297,2],[971594.245288489,18],[971594.429487262,29],[971594.669508573,27],[971594.907072266,24],[971595.056268865,4],[971595.210668125,16],[971595.453669248,10],[971595.636246169,31],[971595.78376153,8],[971595.967849884,11],[971596.155323463,16],[971596.341188767,12],[971596.527259341,39],[971596.700171452,18],[971596.88417679,11],[971597.068824479,16],[971597.259266415,16],[971597.407878198,11],[971597.590617986,6],[971597.77509287,9],[971597.960726551,29],[971598.147818597,22],[971598.336884545,8],[971598.484780906,18],[971598.670965467,18],[971598.856705868,34],[971599.040738,10],[971599.232653021,14],[971599.41655099,13],[971599.603994078,2],[971599.785123511,36],[971599.970678548,42],[971600.156143821,26],[971600.311184714,17],[971600.494939229,34],[971600.734043806,12],[971600.918393919,36],[971601.21212124,50],[971601.397828064,2],[971601.726381935,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-5fd23f9a040aa1a887471320255800c1","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.051116189,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.078873618,"time_to_first_token":0.140759398,"token_sha":"2b28aa2108de","tokens_per_second":25.300446226906942},"seed":1234,"sent":971591.502859099,"speculative":{"acceptance_rate":0.553133514986376,"accepted":203,"drafted":367,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14313897804822773,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":367,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.302709013864508,"done":971601.724539253,"finish_reason":"length","first":971591.646538846,"full_response_s":10.222012197016738,"last":971601.724511124,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971591.646538846,2],[971591.829480627,7],[971591.977934663,4],[971592.198128166,63],[971592.437159693,10],[971592.62197719,31],[971592.803555433,29],[971592.986775271,22],[971593.174332095,14],[971593.360184464,24],[971593.54403517,4],[971593.69105189,13],[971593.872574119,21],[971594.056364447,2],[971594.246957358,18],[971594.430542943,29],[971594.669217284,27],[971594.905862932,24],[971595.056059755,4],[971595.211294305,16],[971595.453364151,10],[971595.636324347,31],[971595.78463703,8],[971595.966715624,11],[971596.153542654,16],[971596.342406613,12],[971596.525833936,39],[971596.699262447,18],[971596.883839707,11],[971597.069240972,16],[971597.257807489,16],[971597.405589709,11],[971597.589500591,6],[971597.775866318,9],[971597.962744343,29],[971598.148594877,22],[971598.335471572,8],[971598.482892798,18],[971598.671202466,18],[971598.856863505,34],[971599.038427816,10],[971599.232180302,14],[971599.41567629,13],[971599.604673875,2],[971599.78590224,36],[971599.970204309,42],[971600.154138414,26],[971600.310716587,17],[971600.493472015,34],[971600.7327121,12],[971600.917022308,36],[971601.211637976,50],[971601.397486277,2],[971601.724511124,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-3e33b73330bdfb655b1988b89fdca31b","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.050837732,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.079107418,"time_to_first_token":0.141718309,"token_sha":"2b28aa2108de","tokens_per_second":25.29985934514425},"seed":1234,"sent":971591.502527056,"speculative":{"acceptance_rate":0.5486486486486486,"accepted":203,"drafted":370,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14401178993284702,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":370,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":24.95855059611457,"done":971601.724469219,"finish_reason":"length","first":971591.507492047,"full_response_s":10.221908562001772,"last":971601.724431489,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971591.507492047,2],[971591.59558615,7],[971591.82975966,4],[971591.97856942,72],[971592.2003083,1],[971592.435812594,27],[971592.621602986,30],[971592.803205966,15],[971592.986174052,14],[971593.174180762,20],[971593.359504747,14],[971593.542553603,4],[971593.689610948,13],[971593.872459427,21],[971594.055873183,2],[971594.244787705,18],[971594.427619954,29],[971594.667619825,27],[971594.905323283,24],[971595.055265122,4],[971595.210157325,16],[971595.453070557,10],[971595.635295579,31],[971595.784290251,8],[971595.967907469,11],[971596.153283142,16],[971596.340883045,12],[971596.524671404,39],[971596.69954508,18],[971596.884882556,11],[971597.068881809,16],[971597.258158764,16],[971597.407117422,11],[971597.590204949,6],[971597.774039669,9],[971597.962458574,29],[971598.147018908,22],[971598.33730443,8],[971598.485538626,18],[971598.670505388,18],[971598.855797183,34],[971599.038917719,10],[971599.230533275,14],[971599.414504253,13],[971599.599039394,2],[971599.785529108,36],[971599.967552434,42],[971600.154500042,26],[971600.309828143,17],[971600.495316441,34],[971600.732242069,12],[971600.91608783,36],[971601.21157143,50],[971601.39682296,2],[971601.724431489,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-71ed11e7f681eec057331d0f517889e4","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.0033831,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.216340352,"time_to_first_token":0.003917404,"token_sha":"2b28aa2108de","tokens_per_second":24.960014174750942},"seed":1234,"sent":971591.502560657,"speculative":{"acceptance_rate":0.5386666666666666,"accepted":202,"drafted":375,"rounds":54,"tokens_per_round":4.7407407407407405},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.0049313900526613,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":202,"drafted":375,"rounds":54},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.296972574546984,"done":971601.726574037,"finish_reason":"length","first":971591.64629951,"full_response_s":10.223174361046404,"last":971601.726557108,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971591.64629951,2],[971591.829247948,7],[971591.978508442,4],[971592.200501138,63],[971592.436880388,10],[971592.621083034,31],[971592.803854818,29],[971592.987948204,22],[971593.174552118,14],[971593.361411623,24],[971593.542788459,4],[971593.690695511,13],[971593.8744805,21],[971594.058079573,2],[971594.247415709,18],[971594.427975182,29],[971594.670547134,27],[971594.905950839,24],[971595.056825267,4],[971595.210031817,16],[971595.452909576,10],[971595.636843276,31],[971595.784502402,8],[971595.968564226,11],[971596.154544798,16],[971596.341974232,12],[971596.525305456,39],[971596.699859138,18],[971596.885390844,11],[971597.068368368,16],[971597.258746606,16],[971597.407629054,11],[971597.591993102,6],[971597.775280636,9],[971597.961120227,29],[971598.148312948,22],[971598.337092151,8],[971598.485021713,18],[971598.670862168,18],[971598.856539431,34],[971599.039243009,10],[971599.230362741,14],[971599.416304198,13],[971599.600216231,2],[971599.783817742,36],[971599.969235911,42],[971600.155631229,26],[971600.309312447,17],[971600.494367419,34],[971600.733256309,12],[971600.917832461,36],[971601.211187738,50],[971601.398373489,2],[971601.726557108,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-270fa519d4148f8ada9329a48c101ed3","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.051058459,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.079083289,"time_to_first_token":0.141033822,"token_sha":"2b28aa2108de","tokens_per_second":25.299919912190738},"seed":1234,"sent":971591.503399676,"speculative":{"acceptance_rate":0.553133514986376,"accepted":203,"drafted":367,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14289983408525586,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":367,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.302068883447784,"done":971601.725490195,"finish_reason":"length","first":971591.647239524,"full_response_s":10.222547541023232,"last":971601.72546677,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971591.647239524,2],[971591.828870976,7],[971591.977303187,4],[971592.19872993,63],[971592.43920667,10],[971592.621543609,31],[971592.803728926,29],[971592.988052336,22],[971593.173523477,14],[971593.362786531,24],[971593.543717688,4],[971593.690610404,13],[971593.875297342,21],[971594.056172313,2],[971594.247310233,18],[971594.428831657,29],[971594.669891257,27],[971594.906381717,24],[971595.056986152,4],[971595.210368676,16],[971595.456697424,10],[971595.635446175,31],[971595.783641831,8],[971595.968207671,11],[971596.156371624,16],[971596.343343267,12],[971596.524794863,39],[971596.700542344,18],[971596.884642804,11],[971597.068755613,16],[971597.259166796,16],[971597.407367941,11],[971597.58977452,6],[971597.776737738,9],[971597.963786536,29],[971598.148821604,22],[971598.335695611,8],[971598.484448351,18],[971598.670024989,18],[971598.85683616,34],[971599.038980153,10],[971599.232084459,14],[971599.416354792,13],[971599.604281927,2],[971599.785777612,36],[971599.968838554,42],[971600.155480633,26],[971600.31035544,17],[971600.494549041,34],[971600.731536303,12],[971600.916328318,36],[971601.211133769,50],[971601.397900962,2],[971601.72546677,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-ef5492b1f818ca98673544a4f06a3a7e","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.050874037,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.079165676,"time_to_first_token":0.141747461,"token_sha":"2b28aa2108de","tokens_per_second":25.299713110896977},"seed":1234,"sent":971591.502942654,"speculative":{"acceptance_rate":0.5516304347826086,"accepted":203,"drafted":368,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14429687010124326,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":368,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.300366659853257,"done":971601.727317004,"finish_reason":"length","first":971591.646790662,"full_response_s":10.224659399944358,"last":971601.725695977,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971591.646790662,2],[971591.829388384,7],[971591.9778421,4],[971592.199454961,63],[971592.438316546,10],[971592.622189645,31],[971592.804096362,29],[971592.986358394,22],[971593.174394513,14],[971593.361311572,24],[971593.544556051,4],[971593.690762937,13],[971593.872936643,21],[971594.057291964,2],[971594.246744887,18],[971594.428134515,29],[971594.667906779,27],[971594.906521433,24],[971595.056495129,4],[971595.210904485,16],[971595.453893271,10],[971595.63702669,31],[971595.784857629,8],[971595.967625669,11],[971596.154846056,16],[971596.344093563,12],[971596.525342529,39],[971596.699656043,18],[971596.886406348,11],[971597.067331824,16],[971597.259707805,16],[971597.406186768,11],[971597.590238406,6],[971597.7754124,9],[971597.962415324,29],[971598.146905496,22],[971598.336154714,8],[971598.483807483,18],[971598.67106931,18],[971598.857441091,34],[971599.039053899,10],[971599.231689807,14],[971599.416977979,13],[971599.605081152,2],[971599.783940722,36],[971599.967514177,42],[971600.154872917,26],[971600.309020278,17],[971600.495082594,34],[971600.733499324,12],[971600.916429073,36],[971601.211527957,50],[971601.399754109,2],[971601.725695977,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-257147a2d5f3e670b8927ed610773e14","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.050667711,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.079329441,"time_to_first_token":0.141429068,"token_sha":"2b28aa2108de","tokens_per_second":25.299302051059925},"seed":1234,"sent":971591.502657604,"speculative":{"acceptance_rate":0.5456989247311828,"accepted":203,"drafted":372,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.144133057910949,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":372,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.301782711969867,"done":971601.725094454,"finish_reason":"length","first":971591.6467365,"full_response_s":10.222476947004907,"last":971601.725077734,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971591.6467365,2],[971591.82907335,7],[971591.977680719,4],[971592.200420943,63],[971592.43617915,10],[971592.622115931,31],[971592.803673644,29],[971592.986741142,22],[971593.173956883,14],[971593.359967721,24],[971593.54472652,4],[971593.692028785,13],[971593.874802238,21],[971594.057264091,2],[971594.246305625,18],[971594.429036639,29],[971594.671235076,27],[971594.906860212,24],[971595.056437351,4],[971595.210622172,16],[971595.455482602,10],[971595.635675911,31],[971595.784580276,8],[971595.968969151,11],[971596.155599631,16],[971596.342851203,12],[971596.525663739,39],[971596.699114362,18],[971596.886216326,11],[971597.068315487,16],[971597.258336946,16],[971597.405771619,11],[971597.591051552,6],[971597.776215881,9],[971597.959960639,29],[971598.147627215,22],[971598.336582423,8],[971598.484385293,18],[971598.669782118,18],[971598.856104201,34],[971599.040339876,10],[971599.231019834,14],[971599.414628737,13],[971599.60474783,2],[971599.783380976,36],[971599.967881052,42],[971600.155954712,26],[971600.310084279,17],[971600.49521111,34],[971600.731996781,12],[971600.917448241,36],[971601.211323679,50],[971601.39757932,2],[971601.725077734,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-7142cc7afaccc6818f5da05675dc50e0","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.050801651,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.079226317,"time_to_first_token":0.141825256,"token_sha":"2b28aa2108de","tokens_per_second":25.299560896842596},"seed":1234,"sent":971591.502617507,"speculative":{"acceptance_rate":0.5486486486486486,"accepted":203,"drafted":370,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14411899296101183,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":370,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.303926418065526,"done":971601.724950098,"finish_reason":"length","first":971591.647441899,"full_response_s":10.221447394927964,"last":971601.724929313,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971591.647441899,2],[971591.828757212,7],[971591.976399046,4],[971592.199201017,63],[971592.437889796,10],[971592.620859539,31],[971592.804052536,29],[971592.987219989,22],[971593.173462707,14],[971593.359692017,24],[971593.544963568,4],[971593.689826395,13],[971593.875604311,21],[971594.057325469,2],[971594.246672837,18],[971594.428969949,29],[971594.668135426,27],[971594.906259057,24],[971595.056649518,4],[971595.210743776,16],[971595.454676368,10],[971595.635545907,31],[971595.784903519,8],[971595.967481504,11],[971596.154161314,16],[971596.342134765,12],[971596.526120201,39],[971596.700480934,18],[971596.886055489,11],[971597.068993844,16],[971597.257534792,16],[971597.406584749,11],[971597.592350265,6],[971597.774894864,9],[971597.960297402,29],[971598.147860054,22],[971598.33642261,8],[971598.485267817,18],[971598.672515612,18],[971598.856777806,34],[971599.03938751,10],[971599.229716737,14],[971599.415356968,13],[971599.599600307,2],[971599.783545397,36],[971599.969026304,42],[971600.15496156,26],[971600.309144362,17],[971600.494805689,34],[971600.731442764,12],[971600.916874463,36],[971601.210798542,50],[971601.398712172,2],[971601.724929313,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-7cbccca8ec7c9539a15f99c99f59a33e","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.050910022,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.079082617,"time_to_first_token":0.141199092,"token_sha":"2b28aa2108de","tokens_per_second":25.299921599005582},"seed":1234,"sent":971591.503502703,"speculative":{"acceptance_rate":0.5516304347826086,"accepted":203,"drafted":368,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14393919601570815,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":368,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.301107683896756,"done":971601.725930432,"finish_reason":"length","first":971591.646218004,"full_response_s":10.223163479939103,"last":971601.724828126,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971591.646218004,2],[971591.831358111,7],[971591.977229233,4],[971592.198830877,63],[971592.436541849,10],[971592.620939781,31],[971592.803886995,29],[971592.986431484,22],[971593.17335464,14],[971593.359807572,24],[971593.543423919,4],[971593.690822939,13],[971593.874996612,21],[971594.056285884,2],[971594.245124388,18],[971594.428916971,29],[971594.670711891,27],[971594.906703167,24],[971595.056865556,4],[971595.210814098,16],[971595.454098174,10],[971595.636354652,31],[971595.784693688,8],[971595.967553474,11],[971596.153639057,16],[971596.343825746,12],[971596.527351504,39],[971596.699748766,18],[971596.884044098,11],[971597.06792029,16],[971597.259120058,16],[971597.40758486,11],[971597.589698965,6],[971597.775956065,9],[971597.960201367,29],[971598.147239459,22],[971598.336916434,8],[971598.483392094,18],[971598.672801781,18],[971598.857544438,34],[971599.03825277,10],[971599.232444887,14],[971599.416824086,13],[971599.600543313,2],[971599.784455202,36],[971599.96807029,42],[971600.155211648,26],[971600.30864305,17],[971600.493232616,34],[971600.731860473,12],[971600.917759611,36],[971601.212036645,50],[971601.39819398,2],[971601.724828126,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-4b8b0814ef0f05253e9fdf01fbd2b5a3","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.051223008,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.078919172,"time_to_first_token":0.140289271,"token_sha":"2b28aa2108de","tokens_per_second":25.30033187570442},"seed":1234,"sent":971591.502766952,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14345105201937258,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.30117420137696,"done":971601.724745179,"finish_reason":"length","first":971591.646125953,"full_response_s":10.221291004912928,"last":971601.724709578,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971591.646125953,2],[971591.831197594,7],[971591.9761984,4],[971592.199851437,63],[971592.439551209,10],[971592.622401412,31],[971592.803820529,29],[971592.987401323,22],[971593.174229963,14],[971593.361451513,24],[971593.543789147,4],[971593.691729943,13],[971593.874906017,21],[971594.057560549,2],[971594.247170357,18],[971594.427818681,29],[971594.671304326,27],[971594.905799298,24],[971595.057404309,4],[971595.211100171,16],[971595.456497354,10],[971595.637309595,31],[971595.783922368,8],[971595.966839212,11],[971596.153443531,16],[971596.342794994,12],[971596.526534919,39],[971596.701217533,18],[971596.88481369,11],[971597.067058391,16],[971597.260257038,16],[971597.406382678,11],[971597.590942301,6],[971597.77427526,9],[971597.960620708,29],[971598.147704481,22],[971598.337381952,8],[971598.483305867,18],[971598.672029692,18],[971598.856816879,34],[971599.041055274,10],[971599.230806419,14],[971599.415083568,13],[971599.599551602,2],[971599.784409633,36],[971599.966989424,42],[971600.154588317,26],[971600.310174618,17],[971600.493012593,34],[971600.732385225,12],[971600.917544052,36],[971601.212750075,50],[971601.399043286,2],[971601.724709578,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-0f0668871d7170e611192e5852882c8a","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050947383,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.079030392,"time_to_first_token":0.141366826,"token_sha":"2b28aa2108de","tokens_per_second":25.300052691814525},"seed":1234,"sent":971591.503454174,"speculative":{"acceptance_rate":0.553133514986376,"accepted":203,"drafted":367,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14267177891451865,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":367,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":1,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.30134126157646,"done":971601.725865358,"finish_reason":"length","first":971591.647313463,"full_response_s":10.223651304026134,"last":971601.725830541,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971591.647313463,2],[971591.828651081,7],[971591.976319284,4],[971592.198405503,63],[971592.439287361,10],[971592.620726655,31],[971592.80302804,29],[971592.987355737,22],[971593.17363036,14],[971593.363340021,24],[971593.544799419,4],[971593.691155125,13],[971593.873626921,21],[971594.056876815,2],[971594.246038817,18],[971594.428399755,29],[971594.669324871,27],[971594.906307634,24],[971595.055453016,4],[971595.210427302,16],[971595.455624526,10],[971595.636294186,31],[971595.784768154,8],[971595.968804906,11],[971596.156105519,16],[971596.342030297,12],[971596.526179275,39],[971596.701117738,18],[971596.885502848,11],[971597.06752167,16],[971597.258425092,16],[971597.405905511,11],[971597.590532816,6],[971597.775661976,9],[971597.960922445,29],[971598.148523435,22],[971598.336226044,8],[971598.484624741,18],[971598.669870344,18],[971598.856632698,34],[971599.03912579,10],[971599.229844421,14],[971599.415970203,13],[971599.599191607,2],[971599.784183913,36],[971599.969861963,42],[971600.154449784,26],[971600.309928994,17],[971600.495380347,34],[971600.732544926,12],[971600.916537477,36],[971601.210693739,50],[971601.397097609,2],[971601.725830541,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-5bec4e5f375834d093f1d6d0ebf12033","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.050727569,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.079289472,"time_to_first_token":0.141924315,"token_sha":"2b28aa2108de","tokens_per_second":25.299402374381973},"seed":1234,"sent":971591.502214054,"speculative":{"acceptance_rate":0.5486486486486486,"accepted":203,"drafted":370,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.14509940904099494,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":370,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.116831852002598,"done":971612.0421815,"finish_reason":"length","first":971601.88862141,"full_response_s":10.307906821952201,"last":971612.041175741,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971601.88862141,2],[971602.07143756,7],[971602.224332786,1],[971602.439475949,3],[971602.678949763,72],[971602.861799591,1],[971603.047883898,31],[971603.237491964,34],[971603.421230069,17],[971603.608218709,14],[971603.789984801,24],[971603.940250252,4],[971604.12292102,17],[971604.315900158,17],[971604.4972133,2],[971604.682345745,18],[971604.9143953,21],[971605.146442929,9],[971605.32395244,28],[971605.508658223,22],[971605.743751979,4],[971605.928210165,20],[971606.116108632,18],[971606.304029611,19],[971606.488749466,8],[971606.676524088,10],[971606.859358874,6],[971607.046559134,23],[971607.236518216,41],[971607.420544201,27],[971607.570237086,16],[971607.754757038,16],[971607.928123374,11],[971608.112599621,6],[971608.307552434,9],[971608.491973335,29],[971608.678156131,22],[971608.863832316,8],[971609.049376668,18],[971609.242360723,18],[971609.427475445,34],[971609.613780268,10],[971609.798787467,14],[971609.984659997,13],[971610.172745779,2],[971610.361994077,36],[971610.51130845,45],[971610.701483624,23],[971610.885511485,17],[971611.071901734,34],[971611.313234452,12],[971611.498353462,36],[971611.820915093,50],[971611.925531895,2],[971612.041175741,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-d9d54cb3268aae59faf920246da7fce6","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":1,"prefill_raised":[],"prefill_seconds":0.049221304,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.153360852,"time_to_first_token":0.150318718,"token_sha":"2b28aa2108de","tokens_per_second":25.114836724213372},"seed":1234,"sent":971601.734274678,"speculative":{"acceptance_rate":0.5444743935309974,"accepted":202,"drafted":371,"rounds":54,"tokens_per_round":4.7407407407407405},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15434673195704818,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":202,"drafted":371,"rounds":54},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.119512510614484,"done":971612.040505288,"finish_reason":"length","first":971601.888994942,"full_response_s":10.306296644033864,"last":971612.040465831,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971601.888994942,2],[971602.070662591,7],[971602.225290464,4],[971602.439224773,63],[971602.675998423,10],[971602.862089152,27],[971603.045790185,30],[971603.235845576,16],[971603.419980718,13],[971603.60667066,20],[971603.790351884,14],[971603.938353969,4],[971604.123657603,17],[971604.31517012,17],[971604.498435866,2],[971604.682453684,18],[971604.912505705,21],[971605.147692232,9],[971605.325469751,28],[971605.510123245,22],[971605.74370361,4],[971605.927700613,20],[971606.113640635,18],[971606.305189839,19],[971606.488228473,8],[971606.677651611,10],[971606.860157331,6],[971607.0459839,23],[971607.23701468,41],[971607.421228895,27],[971607.568863971,16],[971607.754090441,16],[971607.92702118,11],[971608.112318428,6],[971608.303772524,9],[971608.491480215,29],[971608.677187892,22],[971608.862378847,8],[971609.048794714,18],[971609.241560922,18],[971609.427873473,34],[971609.612124009,10],[971609.798005395,14],[971609.982258803,13],[971610.171209924,2],[971610.360824105,36],[971610.513328784,45],[971610.701155934,23],[971610.884893354,17],[971611.072383605,34],[971611.310472159,12],[971611.497995995,36],[971611.820642077,50],[971611.924480022,2],[971612.040465831,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-cec9dce533fbe04559256e342a2ea540","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":1,"prefill_raised":[],"prefill_seconds":0.049147973,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.152757922,"time_to_first_token":0.150442722,"token_sha":"2b28aa2108de","tokens_per_second":25.116328189746433},"seed":1234,"sent":971601.734208644,"speculative":{"acceptance_rate":0.5658263305322129,"accepted":202,"drafted":357,"rounds":54,"tokens_per_round":4.7407407407407405},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15478629793506116,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":202,"drafted":357,"rounds":54},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.670473520415037,"done":971611.820775889,"finish_reason":"length","first":971601.887162597,"full_response_s":10.085581501945853,"last":971611.820754192,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971601.887162597,2],[971602.071205936,7],[971602.223967815,4],[971602.438225622,63],[971602.67712753,10],[971602.860539488,31],[971603.048183108,29],[971603.238939689,22],[971603.420931564,14],[971603.606842474,24],[971603.792606531,4],[971603.939375617,13],[971604.122664612,21],[971604.316461424,2],[971604.498990812,18],[971604.683839151,29],[971604.91292375,27],[971605.147537779,24],[971605.324584523,2],[971605.508233938,18],[971605.742582263,10],[971605.928348634,31],[971606.113436164,8],[971606.30492863,11],[971606.489008226,16],[971606.67459838,12],[971606.860262966,41],[971607.045145522,27],[971607.23755588,16],[971607.420905653,16],[971607.569124955,11],[971607.754637611,6],[971607.928512442,9],[971608.114678326,29],[971608.304845037,22],[971608.491545113,8],[971608.678496829,18],[971608.862678617,18],[971609.049527393,34],[971609.242553577,10],[971609.426495639,14],[971609.613992915,13],[971609.797427601,2],[971609.981741043,36],[971610.171119169,45],[971610.361538751,23],[971610.510748384,14],[971610.699232483,22],[971610.884125186,27],[971611.070305477,36],[971611.310976382,50],[971611.498079725,2],[971611.820754192,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-a651773a02be2653fbfac21cce21d471","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.048942495,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.932847125,"time_to_first_token":0.150515556,"token_sha":"2b28aa2108de","tokens_per_second":25.672397530229784},"seed":1234,"sent":971601.735194387,"speculative":{"acceptance_rate":0.5619834710743802,"accepted":204,"drafted":363,"rounds":52,"tokens_per_round":4.923076923076923},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15196821000427008,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":204,"drafted":363,"rounds":52},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.665488833950008,"done":971611.822646427,"finish_reason":"length","first":971601.88708805,"full_response_s":10.087793170008808,"last":971611.822608922,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971601.88708805,2],[971602.070815188,7],[971602.225525544,4],[971602.438725078,63],[971602.678091176,10],[971602.861454668,31],[971603.045215367,34],[971603.236746116,21],[971603.420159492,20],[971603.606340218,14],[971603.793086434,4],[971603.940540213,17],[971604.122872763,17],[971604.314019876,2],[971604.497914634,18],[971604.682671499,29],[971604.913532281,27],[971605.145289453,24],[971605.324232256,2],[971605.510433638,18],[971605.74364812,10],[971605.928835369,31],[971606.114586056,8],[971606.305948614,11],[971606.488942016,16],[971606.676625659,12],[971606.859561409,41],[971607.045837624,27],[971607.236914805,16],[971607.421056281,16],[971607.570096553,11],[971607.753394052,6],[971607.927639503,9],[971608.114401341,29],[971608.307126596,22],[971608.493289408,8],[971608.676809209,18],[971608.862954833,18],[971609.048441087,34],[971609.241411749,10],[971609.427236206,14],[971609.614302556,13],[971609.801974926,2],[971609.982606174,36],[971610.171030862,45],[971610.362276742,23],[971610.511551673,17],[971610.701611644,34],[971610.884743414,12],[971611.071214481,36],[971611.313537309,50],[971611.496319415,2],[971611.822608922,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-10d8ee4e094bfc0bb0dc9aad6c237e6a","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.048765193,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.933038859,"time_to_first_token":0.151095398,"token_sha":"2b28aa2108de","tokens_per_second":25.671901984854603},"seed":1234,"sent":971601.734853257,"speculative":{"acceptance_rate":0.5368421052631579,"accepted":204,"drafted":380,"rounds":52,"tokens_per_round":4.923076923076923},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15223479305859655,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":204,"drafted":380,"rounds":52},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.116580689875338,"done":971612.040570586,"finish_reason":"length","first":971601.887893947,"full_response_s":10.30611190199852,"last":971612.040549802,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971601.887893947,2],[971602.073169998,7],[971602.225438101,4],[971602.43899747,63],[971602.677273887,10],[971602.861168707,27],[971603.047616706,30],[971603.23608672,16],[971603.421012303,13],[971603.606102547,20],[971603.789804491,14],[971603.938532295,4],[971604.123292936,17],[971604.31557626,17],[971604.497402458,2],[971604.683788206,18],[971604.913018025,21],[971605.147789435,9],[971605.32519459,28],[971605.509255553,22],[971605.742792189,4],[971605.928525743,20],[971606.114178715,18],[971606.306715774,19],[971606.490489056,8],[971606.674734864,10],[971606.858629332,6],[971607.046497916,23],[971607.236228703,41],[971607.421982086,27],[971607.571514661,16],[971607.754404195,16],[971607.926913593,11],[971608.112409295,6],[971608.305708472,9],[971608.490823987,29],[971608.676921548,22],[971608.862582262,8],[971609.049078467,18],[971609.241494552,18],[971609.426273104,34],[971609.614724297,10],[971609.801277928,14],[971609.984904133,13],[971610.173358486,2],[971610.362708308,36],[971610.512961621,45],[971610.699904679,23],[971610.883865562,17],[971611.072718432,34],[971611.311590321,12],[971611.497128784,36],[971611.821484823,50],[971611.924382051,2],[971612.040549802,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-b36f29e6324708b1ef612d6e753d6dcf","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":1,"prefill_raised":[],"prefill_seconds":0.049184583,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.152786466,"time_to_first_token":0.149940114,"token_sha":"2b28aa2108de","tokens_per_second":25.11625757657297},"seed":1234,"sent":971601.734458684,"speculative":{"acceptance_rate":0.5658263305322129,"accepted":202,"drafted":357,"rounds":54,"tokens_per_round":4.7407407407407405},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1534352629678324,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":202,"drafted":357,"rounds":54},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.671880277527716,"done":971611.821567578,"finish_reason":"length","first":971601.888482414,"full_response_s":10.086207024985924,"last":971611.821529672,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971601.888482414,2],[971602.072241217,7],[971602.224421637,4],[971602.439681668,63],[971602.6771935,10],[971602.861710036,31],[971603.046555105,29],[971603.239546908,22],[971603.421756742,14],[971603.60588486,24],[971603.791008369,4],[971603.939246797,13],[971604.12219503,21],[971604.314828605,2],[971604.499563181,18],[971604.683260349,29],[971604.914498167,27],[971605.146516036,24],[971605.32447196,2],[971605.508343749,18],[971605.743991379,10],[971605.928788999,31],[971606.114014406,8],[971606.306014424,11],[971606.490873756,16],[971606.675568538,12],[971606.85787966,39],[971607.044958124,18],[971607.236418037,11],[971607.421845346,16],[971607.571065431,13],[971607.754184652,8],[971607.927988474,12],[971608.111813229,9],[971608.306620261,29],[971608.491405301,22],[971608.677459757,18],[971608.863332189,23],[971609.047976336,37],[971609.2411155,10],[971609.427155675,14],[971609.614614246,13],[971609.800739672,2],[971609.985237871,36],[971610.170929867,42],[971610.360676693,26],[971610.511879011,14],[971610.699744467,22],[971610.8857205,27],[971611.070651072,36],[971611.310941533,50],[971611.496410762,2],[971611.821529672,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-1e1c43b22e98a2c5bf907198349826a8","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.049073843,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.932732769,"time_to_first_token":0.150150489,"token_sha":"2b28aa2108de","tokens_per_second":25.672693097699508},"seed":1234,"sent":971601.735360553,"speculative":{"acceptance_rate":0.5650969529085873,"accepted":204,"drafted":361,"rounds":52,"tokens_per_round":4.923076923076923},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15312186093069613,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":204,"drafted":361,"rounds":52},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.66842878340693,"done":971611.821798353,"finish_reason":"length","first":971601.887379899,"full_response_s":10.08685651794076,"last":971611.8217628,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971601.887379899,2],[971602.072437655,7],[971602.225707549,4],[971602.438960877,63],[971602.677562392,10],[971602.861839576,31],[971603.047137187,29],[971603.236322311,22],[971603.421785399,14],[971603.60786577,24],[971603.79059978,4],[971603.939200924,13],[971604.123807432,21],[971604.31442032,2],[971604.499108351,18],[971604.683325167,29],[971604.914151276,27],[971605.145960722,24],[971605.325734671,2],[971605.508990409,18],[971605.743353263,10],[971605.927180661,31],[971606.113907907,8],[971606.30760777,11],[971606.490059699,16],[971606.675920757,12],[971606.859304153,41],[971607.046128721,27],[971607.23678072,16],[971607.420580122,16],[971607.569464358,11],[971607.754697068,6],[971607.928616685,9],[971608.113134358,29],[971608.307743191,22],[971608.492224366,8],[971608.678984236,18],[971608.863295596,18],[971609.048723624,34],[971609.242714574,10],[971609.427734381,14],[971609.613422065,13],[971609.801516464,2],[971609.983027739,36],[971610.172650288,45],[971610.361148051,23],[971610.512174348,14],[971610.700839268,22],[971610.884364474,27],[971611.070510571,36],[971611.312027951,50],[971611.497579102,2],[971611.8217628,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-0b5f94a7045b4143b789b33ec92e5042","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.048831227,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.933209472,"time_to_first_token":0.150859902,"token_sha":"2b28aa2108de","tokens_per_second":25.671461043764445},"seed":1234,"sent":971601.734941835,"speculative":{"acceptance_rate":0.5604395604395604,"accepted":204,"drafted":364,"rounds":52,"tokens_per_round":4.923076923076923},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1524380639893934,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":204,"drafted":364,"rounds":52},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.67161032527261,"done":971611.820471112,"finish_reason":"length","first":971601.887291561,"full_response_s":10.085848103044555,"last":971611.820443271,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971601.887291561,2],[971602.070291012,7],[971602.22503748,4],[971602.439140707,63],[971602.677335745,10],[971602.860860138,31],[971603.047330745,29],[971603.237575566,22],[971603.422375257,14],[971603.608767958,24],[971603.790410158,4],[971603.939406978,13],[971604.12202208,21],[971604.315663207,2],[971604.498070767,18],[971604.68393245,29],[971604.914867459,27],[971605.148286987,24],[971605.324946855,2],[971605.510490216,18],[971605.742898657,10],[971605.928006095,31],[971606.115010101,8],[971606.307034472,11],[971606.489869453,16],[971606.678513782,12],[971606.859698677,41],[971607.045213332,27],[971607.23670275,16],[971607.421593962,16],[971607.569279664,11],[971607.754576553,6],[971607.927857542,9],[971608.114308442,29],[971608.305431984,22],[971608.490284882,8],[971608.678216676,18],[971608.862305485,18],[971609.048195111,34],[971609.242669132,10],[971609.427364514,14],[971609.613491715,13],[971609.798187145,2],[971609.983155055,36],[971610.171307383,45],[971610.361730469,23],[971610.512055481,14],[971610.700327237,22],[971610.884800839,27],[971611.070990266,36],[971611.31212093,50],[971611.497025101,2],[971611.820443271,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-342a54440beabfadf7984fb8e4b131b6","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.048868221,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.933149774,"time_to_first_token":0.151085222,"token_sha":"2b28aa2108de","tokens_per_second":25.671615328650535},"seed":1234,"sent":971601.734623009,"speculative":{"acceptance_rate":0.5604395604395604,"accepted":204,"drafted":364,"rounds":52,"tokens_per_round":4.923076923076923},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15266855200752616,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":204,"drafted":364,"rounds":52},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.673565694021825,"done":971611.820548778,"finish_reason":"length","first":971601.888119411,"full_response_s":10.08478398900479,"last":971611.820514585,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971601.888119411,2],[971602.072663726,7],[971602.224655724,4],[971602.439074017,63],[971602.676954629,10],[971602.861951708,31],[971603.046388443,29],[971603.237890616,22],[971603.422769414,14],[971603.607528703,24],[971603.790502577,4],[971603.937954197,13],[971604.12399875,21],[971604.315360622,2],[971604.498488748,18],[971604.682794239,29],[971604.913611051,27],[971605.146204986,24],[971605.326979798,2],[971605.509533786,18],[971605.742700218,10],[971605.927031121,31],[971606.113537767,8],[971606.304419335,11],[971606.488675351,16],[971606.67440143,12],[971606.859628675,39],[971607.04455936,18],[971607.235894037,11],[971607.421501783,16],[971607.569200541,13],[971607.753720542,8],[971607.927454425,12],[971608.111370031,9],[971608.308486623,29],[971608.491302194,22],[971608.677961788,18],[971608.861984739,23],[971609.048823979,37],[971609.241715231,10],[971609.42731416,14],[971609.612779741,13],[971609.796935458,2],[971609.981563229,36],[971610.172251572,42],[971610.360366987,26],[971610.511609915,14],[971610.69959691,22],[971610.8849431,27],[971611.070242499,36],[971611.312439948,50],[971611.497080382,2],[971611.820514585,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-ef3fc5b874cf1a54fe2a05c4e8192bb1","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.049110772,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.932784275,"time_to_first_token":0.150296269,"token_sha":"2b28aa2108de","tokens_per_second":25.672559973119924},"seed":1234,"sent":971601.735764789,"speculative":{"acceptance_rate":0.5650969529085873,"accepted":204,"drafted":361,"rounds":52,"tokens_per_round":4.923076923076923},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1523546219104901,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":204,"drafted":361,"rounds":52},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.305315925412366,"done":971611.819775682,"finish_reason":"length","first":971601.742788738,"full_response_s":10.085406248923391,"last":971611.8197228,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971601.742788738,2],[971601.839357273,7],[971602.07043316,4],[971602.223713727,72],[971602.438573169,1],[971602.676659563,27],[971602.862024542,30],[971603.047796455,15],[971603.238129344,14],[971603.421720581,20],[971603.607075681,14],[971603.789907326,4],[971603.938250094,17],[971604.122123043,17],[971604.313887567,2],[971604.497693603,18],[971604.682869281,29],[971604.913726495,27],[971605.145202394,24],[971605.324087708,2],[971605.50979325,18],[971605.745020227,10],[971605.929207236,31],[971606.115659882,8],[971606.306791505,11],[971606.489130934,16],[971606.676424229,12],[971606.857769577,41],[971607.04576847,27],[971607.235576379,16],[971607.419973848,16],[971607.569583497,11],[971607.754457157,6],[971607.928348213,9],[971608.11377921,29],[971608.308100707,22],[971608.492620779,8],[971608.678920138,18],[971608.862642279,18],[971609.048518913,34],[971609.240954807,10],[971609.426893987,14],[971609.613166297,13],[971609.799545635,2],[971609.982874358,36],[971610.170831752,45],[971610.360982174,23],[971610.511488615,17],[971610.700386998,34],[971610.884858569,12],[971611.069970155,36],[971611.31084529,50],[971611.497719698,2],[971611.8197228,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-522f523614d07e4b4f2c579dc16d7aa1","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.006774804,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.076817755,"time_to_first_token":0.007051854,"token_sha":"2b28aa2108de","tokens_per_second":25.305608000449542},"seed":1234,"sent":971601.734369433,"speculative":{"acceptance_rate":0.5205128205128206,"accepted":203,"drafted":390,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.008419304969720542,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":390,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.11801357878166,"done":971612.040913877,"finish_reason":"length","first":971601.888807608,"full_response_s":10.306348228943534,"last":971612.040884292,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971601.888807608,2],[971602.071075676,7],[971602.224552857,1],[971602.439947644,3],[971602.676368562,72],[971602.861756246,1],[971603.047062192,31],[971603.237648017,34],[971603.421593441,17],[971603.605577842,14],[971603.79110474,24],[971603.939892337,4],[971604.123358186,17],[971604.316167447,17],[971604.500287796,2],[971604.684545958,18],[971604.914566569,21],[971605.147136295,9],[971605.325071291,28],[971605.510046682,22],[971605.744222634,4],[971605.928157956,20],[971606.115173882,18],[971606.306105323,19],[971606.489596868,8],[971606.674862724,10],[971606.858289209,6],[971607.045606497,23],[971607.236152125,41],[971607.420666701,27],[971607.56936429,16],[971607.755023399,16],[971607.928037516,11],[971608.11185723,6],[971608.306041715,9],[971608.490910694,29],[971608.678096817,22],[971608.862899695,8],[971609.049124596,18],[971609.242602954,18],[971609.427075785,34],[971609.613012916,10],[971609.799928479,14],[971609.982725889,13],[971610.170703076,2],[971610.361248358,36],[971610.512509079,45],[971610.700872181,23],[971610.885057407,17],[971611.07131578,34],[971611.31302915,12],[971611.496623648,36],[971611.821929045,50],[971611.924814113,2],[971612.040884292,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-495b4c55fcea0578cd8fdade612a4b7f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":1,"prefill_raised":[],"prefill_seconds":0.049257801,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.153323203,"time_to_first_token":0.150151768,"token_sha":"2b28aa2108de","tokens_per_second":25.11492985120923},"seed":1234,"sent":971601.734565648,"speculative":{"acceptance_rate":0.5444743935309974,"accepted":202,"drafted":371,"rounds":54,"tokens_per_round":4.7407407407407405},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15424196003004909,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":202,"drafted":371,"rounds":54},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.67327089229649,"done":971611.820380037,"finish_reason":"length","first":971601.887835354,"full_response_s":10.08493399398867,"last":971611.82034458,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971601.887835354,2],[971602.073377444,7],[971602.223828146,4],[971602.440245813,63],[971602.678608601,10],[971602.860414076,31],[971603.047246006,29],[971603.237009389,22],[971603.42213621,14],[971603.606730054,24],[971603.792244727,4],[971603.938135642,13],[971604.123938812,21],[971604.313321758,2],[971604.498281189,18],[971604.683508069,29],[971604.915434004,27],[971605.145609879,24],[971605.324828307,2],[971605.510198127,18],[971605.745133478,10],[971605.92995126,31],[971606.11445042,8],[971606.30818958,11],[971606.489815883,16],[971606.675026601,12],[971606.859141155,41],[971607.046404425,27],[971607.237333842,16],[971607.421919764,16],[971607.569641515,11],[971607.753495287,6],[971607.928395895,9],[971608.113654518,29],[971608.304449985,22],[971608.490043755,8],[971608.678563919,18],[971608.863217609,18],[971609.048560659,34],[971609.241606603,10],[971609.426353394,14],[971609.613558949,13],[971609.799224921,2],[971609.98391455,36],[971610.17218533,45],[971610.362521038,23],[971610.512268895,14],[971610.700791283,22],[971610.885104225,27],[971611.070615055,36],[971611.312731493,50],[971611.497868791,2],[971611.82034458,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-fccf87e15a24931d5c923913833d9fe8","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.048905022,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.933071372,"time_to_first_token":0.150684393,"token_sha":"2b28aa2108de","tokens_per_second":25.67181795540208},"seed":1234,"sent":971601.735446043,"speculative":{"acceptance_rate":0.5619834710743802,"accepted":204,"drafted":363,"rounds":52,"tokens_per_round":4.923076923076923},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15238931099884212,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":204,"drafted":363,"rounds":52},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.671826021553223,"done":971611.821317506,"finish_reason":"length","first":971601.888235766,"full_response_s":10.086256291018799,"last":971611.821304017,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971601.888235766,2],[971602.071604589,7],[971602.224492119,4],[971602.438664228,63],[971602.676749358,10],[971602.860723669,31],[971603.045301257,29],[971603.237082831,22],[971603.421659619,14],[971603.608569456,24],[971603.792678853,4],[971603.938058264,13],[971604.122505055,21],[971604.314277628,2],[971604.497821799,18],[971604.68301279,29],[971604.912353924,27],[971605.14820452,24],[971605.326726958,2],[971605.508732673,18],[971605.743280412,10],[971605.927894043,31],[971606.114092601,8],[971606.305355204,11],[971606.489972656,16],[971606.675712975,12],[971606.858717478,39],[971607.04448491,18],[971607.237250047,11],[971607.420478951,16],[971607.568986951,13],[971607.754492486,8],[971607.927923736,12],[971608.11288563,9],[971608.305237546,29],[971608.493415475,22],[971608.677053568,18],[971608.86252842,23],[971609.048097204,37],[971609.241242736,10],[971609.426591289,14],[971609.613729787,13],[971609.797053845,2],[971609.9816432,36],[971610.171446619,42],[971610.360167669,26],[971610.511063498,14],[971610.699825909,22],[971610.884216021,27],[971611.07006939,36],[971611.311347402,50],[971611.497456474,2],[971611.821304017,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-5f5a593d5262e3654bb2978730fb35ec","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.049037314,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.932751202,"time_to_first_token":0.150602471,"token_sha":"2b28aa2108de","tokens_per_second":25.67264545483176},"seed":1234,"sent":971601.735061215,"speculative":{"acceptance_rate":0.5650969529085873,"accepted":204,"drafted":361,"rounds":52,"tokens_per_round":4.923076923076923},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1531745509710163,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":204,"drafted":361,"rounds":52},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.300619518069652,"done":971611.821707134,"finish_reason":"length","first":971601.742866468,"full_response_s":10.086954680969939,"last":971611.821671053,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971601.742866468,2],[971601.838844745,7],[971602.071793091,4],[971602.224934165,72],[971602.438447453,1],[971602.677778366,27],[971602.862063311,30],[971603.046650388,15],[971603.237830598,14],[971603.420786215,20],[971603.607043664,14],[971603.791657925,4],[971603.938807311,17],[971604.123727573,17],[971604.313709322,2],[971604.498955434,18],[971604.682170123,29],[971604.913117244,27],[971605.146889967,24],[971605.323606157,2],[971605.508816308,18],[971605.743457266,10],[971605.930400522,31],[971606.114386386,8],[971606.305467687,11],[971606.488371774,16],[971606.677558936,12],[971606.85824412,41],[971607.04553091,27],[971607.235673694,16],[971607.420378084,16],[971607.570636026,11],[971607.754247086,6],[971607.926820822,9],[971608.111516147,29],[971608.307945566,22],[971608.490575851,8],[971608.677547536,18],[971608.862460626,18],[971609.048907037,34],[971609.241647196,10],[971609.4264145,14],[971609.615217433,13],[971609.798571348,2],[971609.982786659,36],[971610.171695587,45],[971610.3620624,23],[971610.511443126,17],[971610.700697904,34],[971610.884674355,12],[971611.07071029,36],[971611.313136545,50],[971611.496891593,2],[971611.821671053,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-52dd86afb82ead1f23f75489d3865865","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.006817158,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.077044722,"time_to_first_token":0.007231251,"token_sha":"2b28aa2108de","tokens_per_second":25.305038037916926},"seed":1234,"sent":971601.734752453,"speculative":{"acceptance_rate":0.5205128205128206,"accepted":203,"drafted":390,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.00811401498503983,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":390,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.672058962996825,"done":971611.822105402,"finish_reason":"length","first":971601.888141667,"full_response_s":10.08698047301732,"last":971611.821119788,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971601.888141667,2],[971602.071699504,7],[971602.22387706,4],[971602.438877739,63],[971602.677386962,10],[971602.861907722,31],[971603.046694645,34],[971603.236552206,21],[971603.421943436,20],[971603.608657635,14],[971603.790918638,4],[971603.938601849,17],[971604.124236245,17],[971604.313558837,2],[971604.498626512,18],[971604.682927699,29],[971604.915681596,27],[971605.145137128,24],[971605.325563242,2],[971605.508443848,18],[971605.743395312,10],[971605.92953067,31],[971606.114484869,8],[971606.306526584,11],[971606.488597221,16],[971606.677238718,12],[971606.85857957,41],[971607.044756182,27],[971607.236568986,16],[971607.419892661,16],[971607.57082696,11],[971607.754844689,6],[971607.928566108,9],[971608.11236555,29],[971608.305927567,22],[971608.492044057,8],[971608.677654067,18],[971608.863419552,18],[971609.048610228,34],[971609.242010744,10],[971609.427427699,14],[971609.612356688,13],[971609.798690616,2],[971609.983592908,36],[971610.173125599,45],[971610.36141982,23],[971610.512700605,17],[971610.701250369,34],[971610.884981693,12],[971611.070157584,36],[971611.311722837,50],[971611.496496316,2],[971611.821119788,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-b4fbfd724edc0397e3ac419c02c621d6","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.048803738,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.933412791,"time_to_first_token":0.151170808,"token_sha":"2b28aa2108de","tokens_per_second":25.670935595371454},"seed":1234,"sent":971601.735124929,"speculative":{"acceptance_rate":0.5368421052631579,"accepted":204,"drafted":380,"rounds":52,"tokens_per_round":4.923076923076923},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15301673801150173,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":204,"drafted":380,"rounds":52},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"code","streams":16,"burst":2,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.67067422687607,"done":971611.821073578,"finish_reason":"length","first":971601.88753152,"full_response_s":10.086937127984129,"last":971611.821045449,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971601.88753152,2],[971602.072916054,7],[971602.224088059,4],[971602.439742726,63],[971602.677047064,10],[971602.861531759,31],[971603.04825727,29],[971603.238542909,22],[971603.42060797,14],[971603.606632723,24],[971603.790310907,4],[971603.937840929,13],[971604.124348809,21],[971604.315028259,2],[971604.498571518,18],[971604.683576071,29],[971604.915829217,27],[971605.146347886,24],[971605.323221761,2],[971605.50946356,18],[971605.744709513,10],[971605.928413772,31],[971606.115901457,8],[971606.304783522,11],[971606.489733512,16],[971606.676884755,12],[971606.858038993,39],[971607.045354665,18],[971607.235825187,11],[971607.420814738,16],[971607.569539832,13],[971607.753660972,8],[971607.927257107,12],[971608.112171896,9],[971608.306378941,29],[971608.490723664,22],[971608.678031423,18],[971608.862119335,23],[971609.048858428,37],[971609.242775871,10],[971609.427809999,14],[971609.613900976,13],[971609.797598726,2],[971609.982180384,36],[971610.171160594,42],[971610.361477165,26],[971610.512112187,14],[971610.700635646,22],[971610.885791686,27],[971611.070566813,36],[971611.310593794,50],[971611.497614751,2],[971611.821045449,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-a6b93d65248dc34cddd4badbda8336de","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.048979616,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.933162623,"time_to_first_token":0.15044181,"token_sha":"2b28aa2108de","tokens_per_second":25.671582121242395},"seed":1234,"sent":971601.73413645,"speculative":{"acceptance_rate":0.5650969529085873,"accepted":204,"drafted":361,"rounds":52,"tokens_per_round":4.923076923076923},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.15339506999589503,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":204,"drafted":361,"rounds":52},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":1,"burst":null,"stream":0,"phase":"warmup","request":{"cache_state":"cold","cached_tokens":0,"case_id":null,"complete":true,"decode_tps":59.475401747558195,"done":971612.47219751,"finish_reason":"length","first":971612.219956227,"full_response_s":0.4219378560082987,"last":971612.472161333,"output_sha256":"6bffe2c2436146ed3af0e8c4e21d88b3dddfbe4a47910e8940f3039340788c85","pieces":[[971612.219956227,3],[971612.307735515,26],[971612.387849176,15],[971612.472161333,30]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":16,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"c81230cadd07c8b22d2a507aa18b8b00964a157b29ba5c65c8fdf55148cf2238","response_id":"chatcmpl-d82fcbf4241fc53a8778cd6769fcbc38","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.168590859,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":0.252503196,"time_to_first_token":0.169078362,"token_sha":"a9100b9c265b","tokens_per_second":59.405188677295},"seed":1234,"sent":971612.050259654,"speculative":{"acceptance_rate":0.28888888888888886,"accepted":13,"drafted":45,"rounds":3,"tokens_per_round":5.333333333333333},"token_sha":"a9100b9c265b","tokens":16,"ttft_s":0.169696573051624,"usage":{"completion_tokens":16,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":0},"total_tokens":47},"work":{"accepted":13,"drafted":45,"rounds":3},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":1,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":49.42162295257638,"done":971617.65050636,"finish_reason":"length","first":971612.490577935,"full_response_s":5.170678838039748,"last":971617.650262801,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971612.490577935,3],[971612.579881111,26],[971612.662627988,15],[971612.743545513,34],[971612.824392651,21],[971612.904856174,25],[971612.986339633,14],[971613.067603757,14],[971613.148711188,18],[971613.235989386,26],[971613.319492267,13],[971613.400088658,13],[971613.480696666,13],[971613.563076568,23],[971613.643861461,32],[971613.724448653,7],[971613.805189672,23],[971613.885977314,9],[971613.967385919,13],[971614.05007914,15],[971614.131286602,19],[971614.218370294,12],[971614.302402371,5],[971614.383202589,23],[971614.464674668,9],[971614.544975847,17],[971614.627872786,3],[971614.708865234,21],[971614.789316801,10],[971614.870269021,24],[971614.951183655,19],[971615.032449132,14],[971615.113895094,13],[971615.199322651,5],[971615.283299587,22],[971615.364398003,13],[971615.445138663,51],[971615.526112835,15],[971615.607590382,6],[971615.688997383,8],[971615.769697499,9],[971615.850456686,16],[971615.931524025,16],[971616.013319194,9],[971616.094402694,32],[971616.179384169,18],[971616.265120724,13],[971616.346169566,11],[971616.426921936,15],[971616.508244098,8],[971616.589051221,18],[971616.666031075,25],[971616.746606031,19],[971616.827544629,8],[971616.90852081,40],[971616.990266886,16],[971617.071020196,64],[971617.153134699,6],[971617.240937682,6],[971617.324636218,11],[971617.405496043,15],[971617.487377915,17],[971617.567704492,21],[971617.650262801,14]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-3f2271cf08e7f2e0928e8bbc4ad4d9aa","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.009495478,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":5.159566655,"time_to_first_token":0.010229516,"token_sha":"8a91591c94a3","tokens_per_second":49.42275525268895},"seed":1234,"sent":971612.479827522,"speculative":{"acceptance_rate":0.2052910052910053,"accepted":194,"drafted":945,"rounds":63,"tokens_per_round":4.063492063492063},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.010750413057394326,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":194,"drafted":945,"rounds":63},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":1,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":49.42871207555355,"done":971622.827457146,"finish_reason":"length","first":971617.668393197,"full_response_s":5.163522948976606,"last":971622.827338055,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971617.668393197,3],[971617.75685836,26],[971617.837945887,15],[971617.91860223,34],[971618.000283692,21],[971618.08198842,25],[971618.162946644,14],[971618.249752872,14],[971618.332930333,18],[971618.41328073,26],[971618.49487419,13],[971618.575301582,13],[971618.65838104,13],[971618.739189836,23],[971618.819955446,32],[971618.90082664,7],[971618.982099735,23],[971619.063540946,9],[971619.143513473,13],[971619.230493318,15],[971619.313870237,19],[971619.394992207,12],[971619.476392201,5],[971619.557039389,23],[971619.637300724,9],[971619.718853379,17],[971619.799412212,3],[971619.879965666,21],[971619.961521965,10],[971620.043080441,24],[971620.123985073,19],[971620.20965865,14],[971620.2946872,13],[971620.375894657,5],[971620.457222101,22],[971620.538474887,13],[971620.620341565,51],[971620.701747572,15],[971620.783383842,6],[971620.864024687,8],[971620.94482928,9],[971621.026541084,16],[971621.107471345,16],[971621.193522883,9],[971621.278938768,32],[971621.360991927,18],[971621.442029615,13],[971621.523434355,11],[971621.603566495,15],[971621.684387313,8],[971621.765845286,18],[971621.841254865,25],[971621.921875321,19],[971622.003429229,8],[971622.085038371,40],[971622.1667223,16],[971622.254161091,64],[971622.337275367,6],[971622.418320412,6],[971622.500114344,11],[971622.581263616,15],[971622.664454134,17],[971622.745535292,21],[971622.827338055,14]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-47123c06039c3c43f18d541607ab2cdb","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.003309029,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":5.158938058,"time_to_first_token":0.003953305,"token_sha":"8a91591c94a3","tokens_per_second":49.42877722762532},"seed":1234,"sent":971617.663934197,"speculative":{"acceptance_rate":0.2052910052910053,"accepted":194,"drafted":945,"rounds":63,"tokens_per_round":4.063492063492063},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.004458999959751964,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":194,"drafted":945,"rounds":63},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":1,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":49.442654449246845,"done":971627.998042428,"finish_reason":"length","first":971622.840505671,"full_response_s":5.162194018019363,"last":971627.997995754,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971622.840505671,3],[971622.928914456,26],[971623.010783827,15],[971623.091954376,34],[971623.173783249,21],[971623.260279144,25],[971623.34318477,14],[971623.424508572,14],[971623.505808789,18],[971623.586565069,26],[971623.667112575,13],[971623.747265253,13],[971623.828547901,13],[971623.909341779,23],[971623.990836526,32],[971624.072574129,7],[971624.152389594,23],[971624.240148147,9],[971624.32380544,13],[971624.40393173,15],[971624.485778168,19],[971624.566098992,12],[971624.648493958,5],[971624.729400336,23],[971624.810809625,9],[971624.892160492,17],[971624.973511695,3],[971625.054821858,21],[971625.135995696,10],[971625.221091749,24],[971625.30541917,19],[971625.386927755,14],[971625.468235533,13],[971625.548585106,5],[971625.629553866,22],[971625.710151382,13],[971625.790445706,51],[971625.872082451,15],[971625.952533784,6],[971626.034252835,8],[971626.115808905,9],[971626.20077223,16],[971626.286668911,16],[971626.368228774,9],[971626.44880627,32],[971626.530785553,18],[971626.612512492,13],[971626.695031136,11],[971626.775272622,15],[971626.856421173,8],[971626.937858148,18],[971627.013137641,25],[971627.094575592,19],[971627.17663513,8],[971627.265300531,40],[971627.347891765,16],[971627.428814788,64],[971627.510636703,6],[971627.591439771,6],[971627.672447677,11],[971627.753513728,15],[971627.83376185,17],[971627.915676004,21],[971627.997995754,14]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-8df60ebd1ddbf76cdbfc6ff5a11157be","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.003348326,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":5.157472195,"time_to_first_token":0.004094781,"token_sha":"8a91591c94a3","tokens_per_second":49.44282593461465},"seed":1234,"sent":971622.83584841,"speculative":{"acceptance_rate":0.2052910052910053,"accepted":194,"drafted":945,"rounds":63,"tokens_per_round":4.063492063492063},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.004657260957174003,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":194,"drafted":945,"rounds":63},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.624909586848947,"done":971641.942075418,"finish_reason":"length","first":971628.249945987,"full_response_s":13.933191894902848,"last":971641.941287618,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971628.249945987,3],[971628.400221597,11],[971628.58184065,30],[971628.764331793,19],[971628.946919397,21],[971629.130382434,15],[971629.286014599,19],[971629.432540138,17],[971629.580618635,6],[971629.729218877,8],[971629.912665636,3],[971630.085559211,5],[971630.275053797,27],[971630.456821782,12],[971630.641207271,9],[971630.82524222,9],[971630.995524572,16],[971631.180690252,5],[971631.369553947,14],[971631.552151214,9],[971631.697816826,22],[971631.846698693,10],[971632.029716348,7],[971632.219334506,23],[971632.367110783,5],[971632.515629291,9],[971632.690768469,14],[971632.838134413,20],[971632.9897892,8],[971633.138612878,12],[971633.294525217,5],[971633.443967602,14],[971633.629450331,14],[971633.776852575,8],[971633.959504877,13],[971634.131931832,3],[971634.323862474,10],[971634.473190801,11],[971634.660149246,9],[971634.843086818,10],[971635.02583161,20],[971635.174142188,6],[971635.366823244,8],[971635.550572386,14],[971635.733730246,13],[971635.903949155,5],[971636.09409872,14],[971636.322477394,11],[971636.552907137,51],[971636.724926001,14],[971636.910736888,11],[971637.060146078,4],[971637.238105271,10],[971637.386372075,9],[971637.53653812,13],[971637.686795463,8],[971637.83539954,20],[971638.022100554,32],[971638.200296323,14],[971638.3512424,6],[971638.536295813,16],[971638.724569802,6],[971638.870783512,15],[971639.020482026,5],[971639.198478149,7],[971639.387109596,22],[971639.563040602,16],[971639.750547408,20],[971639.896312633,5],[971640.085162447,3],[971640.264974553,25],[971640.41433065,18],[971640.5979453,13],[971640.792221467,64],[971640.974902371,2],[971641.1594052,10],[971641.316744119,11],[971641.4918019,15],[971641.618242048,17],[971641.821517673,14],[971641.941287618,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-1b63e392bfa6a41e95e6ad5835173d21","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.146978023,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.692179033,"time_to_first_token":0.233173057,"token_sha":"8a91591c94a3","tokens_per_second":18.623770503249744},"seed":1234,"sent":971628.008883523,"speculative":{"acceptance_rate":0.44416243654822335,"accepted":175,"drafted":394,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.241062463959679,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":394,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":1,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.78773533219957,"done":971641.821977959,"finish_reason":"length","first":971628.249254142,"full_response_s":13.813725095009431,"last":971641.821938422,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971628.249254142,3],[971628.401872079,11],[971628.581521521,30],[971628.765443459,19],[971628.947495047,21],[971629.130998084,15],[971629.285918612,19],[971629.431890054,17],[971629.579565692,6],[971629.728155661,8],[971629.912778088,3],[971630.085948166,5],[971630.273606409,27],[971630.458116461,12],[971630.640871661,13],[971630.825870479,5],[971630.995228931,16],[971631.17973776,5],[971631.368907512,14],[971631.551934279,9],[971631.698152228,22],[971631.846635907,16],[971632.031760538,8],[971632.218551026,16],[971632.367927032,5],[971632.516944354,9],[971632.69358681,14],[971632.838373412,20],[971632.987348439,8],[971633.136508687,12],[971633.293238635,5],[971633.444784714,14],[971633.627018595,14],[971633.775825024,8],[971633.959571855,13],[971634.134832718,3],[971634.325836933,10],[971634.471841289,11],[971634.659920616,9],[971634.843548912,10],[971635.025670581,20],[971635.175573879,14],[971635.366247179,14],[971635.551276791,13],[971635.734209348,5],[971635.904692201,14],[971636.090026854,11],[971636.320442261,51],[971636.551119612,13],[971636.724158186,12],[971636.908562567,6],[971637.059727633,8],[971637.236842193,9],[971637.387897945,13],[971637.536113051,8],[971637.685973711,20],[971637.834627469,17],[971638.02183045,23],[971638.199040061,12],[971638.350957816,16],[971638.535924298,6],[971638.723170768,15],[971638.8713214,8],[971639.020437673,9],[971639.195874296,9],[971639.387927333,21],[971639.562648654,23],[971639.748362527,5],[971639.896597634,3],[971640.085977495,25],[971640.263054304,18],[971640.412267405,13],[971640.597696973,64],[971640.792667433,2],[971640.974689325,10],[971641.158811758,11],[971641.317188309,15],[971641.490880881,17],[971641.617849077,14],[971641.821938422,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-37258ab6d64c18f56b5e763713fdd0c6","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":1,"prefill_raised":[],"prefill_seconds":0.146578794,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.572549908,"time_to_first_token":0.2384352,"token_sha":"8a91591c94a3","tokens_per_second":18.787921335967727},"seed":1234,"sent":971628.008252864,"speculative":{"acceptance_rate":0.44139650872817954,"accepted":177,"drafted":401,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.24100127804558724,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":401,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":2,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.621654465129165,"done":971641.942614458,"finish_reason":"length","first":971628.248850946,"full_response_s":13.933943325071596,"last":971641.942585865,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971628.248850946,3],[971628.40125422,11],[971628.582284424,30],[971628.766234539,19],[971628.947890339,21],[971629.131071863,15],[971629.283880711,19],[971629.433993574,17],[971629.58005769,6],[971629.728877506,8],[971629.912421965,3],[971630.085082316,5],[971630.274069143,27],[971630.457352662,12],[971630.642268615,13],[971630.825646376,5],[971630.996775522,16],[971631.180800192,5],[971631.370801777,14],[971631.552365908,9],[971631.698856505,22],[971631.847349993,10],[971632.031459313,7],[971632.219757687,23],[971632.369289297,5],[971632.516548822,9],[971632.692920758,14],[971632.840159354,20],[971632.987630576,8],[971633.136435965,12],[971633.294015954,5],[971633.443075335,14],[971633.628216534,14],[971633.774029882,8],[971633.958166133,13],[971634.132923909,3],[971634.324109937,10],[971634.47375101,11],[971634.659282709,9],[971634.842370941,10],[971635.027417945,20],[971635.174896194,6],[971635.368642083,8],[971635.551063265,14],[971635.735213986,13],[971635.904088631,5],[971636.090844559,14],[971636.322027477,11],[971636.551030633,51],[971636.724404017,14],[971636.911828472,11],[971637.059832357,4],[971637.237432771,10],[971637.387382985,9],[971637.538114167,13],[971637.686400476,8],[971637.834922278,20],[971638.023089352,32],[971638.199645311,14],[971638.351978198,6],[971638.53624738,16],[971638.724479975,6],[971638.870098452,15],[971639.020985961,5],[971639.195922489,7],[971639.386764754,22],[971639.561839142,17],[971639.748237131,19],[971639.895630101,5],[971640.083489117,3],[971640.264100047,25],[971640.414525856,18],[971640.598754892,13],[971640.791466053,64],[971640.974287617,2],[971641.160617972,10],[971641.31690182,11],[971641.491185802,15],[971641.618191775,17],[971641.823686441,14],[971641.942585865,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-3e8668d6ae34d71dbb59b31f43f3aa92","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.14677056,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.691863872,"time_to_first_token":0.236226686,"token_sha":"8a91591c94a3","tokens_per_second":18.62419918748079},"seed":1234,"sent":971628.008671133,"speculative":{"acceptance_rate":0.42892156862745096,"accepted":175,"drafted":408,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.24017981300130486,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":408,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":3,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.62569422310696,"done":971641.940904119,"finish_reason":"length","first":971628.250091239,"full_response_s":13.932421312085353,"last":971641.940856101,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971628.250091239,3],[971628.400852272,11],[971628.581720759,30],[971628.764536872,19],[971628.94701972,21],[971629.130227853,15],[971629.285599307,19],[971629.433103355,17],[971629.580720334,6],[971629.728069418,8],[971629.913837528,3],[971630.085336452,5],[971630.275601301,27],[971630.458310067,12],[971630.641259608,9],[971630.825360944,9],[971630.99330273,16],[971631.180197613,5],[971631.36850526,14],[971631.554526245,9],[971631.698894234,22],[971631.846380028,10],[971632.033108418,7],[971632.218952111,23],[971632.369238447,5],[971632.515862498,9],[971632.690690547,14],[971632.839822256,20],[971632.987879223,8],[971633.137465148,12],[971633.293699176,5],[971633.443176538,14],[971633.629693475,14],[971633.77547951,8],[971633.960045485,13],[971634.134529445,3],[971634.325242179,10],[971634.474990423,11],[971634.658919194,9],[971634.843805512,10],[971635.026935755,20],[971635.17514161,6],[971635.367342876,8],[971635.55005125,14],[971635.735711793,13],[971635.90538963,5],[971636.094899256,14],[971636.323048627,11],[971636.55125552,51],[971636.724284286,14],[971636.911068898,11],[971637.060539322,4],[971637.237017607,10],[971637.387851767,9],[971637.537603592,13],[971637.688567532,8],[971637.836160971,20],[971638.022553832,32],[971638.199573405,14],[971638.351926805,6],[971638.536769139,16],[971638.724533801,6],[971638.871364825,15],[971639.019923129,5],[971639.197573594,7],[971639.386493354,22],[971639.563164174,16],[971639.7479873,20],[971639.897129842,5],[971640.083763574,3],[971640.262980685,25],[971640.414773895,18],[971640.598585895,13],[971640.78939788,64],[971640.9730435,2],[971641.160523569,10],[971641.318341175,11],[971641.492521026,15],[971641.617794211,17],[971641.822789727,14],[971641.940856101,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-d1997b2540a4ca16e416a217b2913238","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.14701564,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.691857471,"time_to_first_token":0.23266205,"token_sha":"8a91591c94a3","tokens_per_second":18.624207894370944},"seed":1234,"sent":971628.008482807,"speculative":{"acceptance_rate":0.4475703324808184,"accepted":175,"drafted":391,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.24160843202844262,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":391,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":4,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.788992713762926,"done":971641.821847011,"finish_reason":"length","first":971628.249879393,"full_response_s":13.812426368007436,"last":971641.821655373,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971628.249879393,3],[971628.400749469,11],[971628.581416877,30],[971628.765184603,19],[971628.94892485,21],[971629.13072086,15],[971629.284946439,19],[971629.43321379,17],[971629.580661885,6],[971629.728573353,8],[971629.912365499,3],[971630.085208864,5],[971630.275369246,27],[971630.458392166,12],[971630.641728038,13],[971630.826574772,5],[971630.996475657,16],[971631.1798989,5],[971631.370347987,14],[971631.553308929,9],[971631.699928361,22],[971631.847076384,10],[971632.03255525,7],[971632.218746888,23],[971632.370123114,5],[971632.517785467,9],[971632.692321044,14],[971632.841053621,20],[971632.990267759,8],[971633.139862404,12],[971633.295093698,5],[971633.444061381,14],[971633.628611906,14],[971633.775172893,8],[971633.960153185,13],[971634.133465653,3],[971634.323230007,10],[971634.474599035,11],[971634.658659058,9],[971634.842844043,10],[971635.027685681,20],[971635.175620056,14],[971635.367868236,14],[971635.549808619,13],[971635.734627969,5],[971635.904640728,14],[971636.09330604,11],[971636.32274377,51],[971636.551183822,13],[971636.726091684,12],[971636.910111381,6],[971637.059485818,8],[971637.236629627,9],[971637.388383671,13],[971637.538034597,8],[971637.68675471,20],[971637.836730252,17],[971638.024902878,23],[971638.200172511,12],[971638.3529797,16],[971638.535847944,6],[971638.724087227,15],[971638.870436446,5],[971639.019553998,7],[971639.197123997,14],[971639.386084958,21],[971639.561227524,23],[971639.748159561,5],[971639.895496513,3],[971640.082889644,25],[971640.264704145,18],[971640.414709253,13],[971640.598800366,64],[971640.790034602,2],[971640.972672721,10],[971641.159165273,11],[971641.318260532,15],[971641.491874559,17],[971641.616735188,14],[971641.821655373,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-08e1760406bd099e3a019d8c788fbccd","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":1,"prefill_raised":[],"prefill_seconds":0.146732767,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.572722393,"time_to_first_token":0.237465348,"token_sha":"8a91591c94a3","tokens_per_second":18.787682575126844},"seed":1234,"sent":971628.009420643,"speculative":{"acceptance_rate":0.4481012658227848,"accepted":177,"drafted":395,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2404587500495836,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":395,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":5,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.78577266111615,"done":971641.822634858,"finish_reason":"length","first":971628.248509608,"full_response_s":13.814857368008234,"last":971641.822611914,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971628.248509608,3],[971628.402145671,11],[971628.582675699,30],[971628.766476002,19],[971628.950148151,21],[971629.131315102,15],[971629.285446694,19],[971629.432181551,17],[971629.580962614,6],[971629.729397506,8],[971629.91312389,3],[971630.086732478,5],[971630.27455495,29],[971630.458977815,10],[971630.640764057,13],[971630.826329645,5],[971630.995767684,16],[971631.181577159,5],[971631.369737201,16],[971631.553642075,7],[971631.69873287,27],[971631.846827529,11],[971632.030959954,8],[971632.219581857,16],[971632.370298719,5],[971632.518250569,9],[971632.692561723,14],[971632.841452353,20],[971632.98859494,8],[971633.13907646,12],[971633.293761578,5],[971633.445080899,14],[971633.630061662,14],[971633.776171531,8],[971633.959168035,13],[971634.132853059,3],[971634.324763189,10],[971634.472592319,11],[971634.657960397,9],[971634.842583283,10],[971635.028137711,20],[971635.175085736,14],[971635.367286618,14],[971635.551793159,13],[971635.735891655,5],[971635.905654422,14],[971636.092198407,11],[971636.322313117,51],[971636.551990614,13],[971636.727452268,12],[971636.909471218,6],[971637.059606686,8],[971637.237493013,9],[971637.387464972,13],[971637.538306973,8],[971637.686943292,20],[971637.836237453,21],[971638.024477329,25],[971638.198944379,6],[971638.351808145,16],[971638.537669982,6],[971638.724285761,15],[971638.871679107,8],[971639.020736833,9],[971639.195763796,9],[971639.387451863,21],[971639.562588941,23],[971639.749616804,5],[971639.897039903,3],[971640.083966796,25],[971640.262814681,18],[971640.414999758,13],[971640.599019364,64],[971640.790186127,2],[971640.975512805,10],[971641.15859724,11],[971641.316992015,15],[971641.491837149,17],[971641.617674351,14],[971641.822611914,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-f6489e63811fcc17d3ae827f6998d5f6","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.146425558,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.572654695,"time_to_first_token":0.238030373,"token_sha":"8a91591c94a3","tokens_per_second":18.787776284763133},"seed":1234,"sent":971628.00777749,"speculative":{"acceptance_rate":0.4254807692307692,"accepted":177,"drafted":416,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2407321180216968,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":416,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":6,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.787370001928455,"done":971641.822350946,"finish_reason":"length","first":971628.248651276,"full_response_s":13.8143748260336,"last":971641.821599484,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971628.248651276,3],[971628.401349231,11],[971628.582026496,30],[971628.764661323,19],[971628.948386786,21],[971629.131181818,15],[971629.284255762,19],[971629.433642811,17],[971629.57963211,6],[971629.728476998,8],[971629.911358317,3],[971630.086216094,5],[971630.275721001,27],[971630.459084618,12],[971630.640681415,13],[971630.824360466,5],[971630.995329446,16],[971631.181185435,5],[971631.36811824,14],[971631.552765696,9],[971631.699507325,22],[971631.846560337,10],[971632.030732587,7],[971632.218622821,23],[971632.366856056,5],[971632.516304783,9],[971632.692374966,14],[971632.841780714,20],[971632.988494313,8],[971633.138429897,12],[971633.2948915,5],[971633.444853965,14],[971633.627113285,14],[971633.774854115,8],[971633.958671108,13],[971634.134897552,3],[971634.325576333,10],[971634.472746324,11],[971634.659168657,9],[971634.842074868,10],[971635.026746453,20],[971635.174305633,14],[971635.369103937,14],[971635.551606225,13],[971635.734299031,5],[971635.905799946,14],[971636.093230742,11],[971636.32262143,51],[971636.551393108,13],[971636.723739757,12],[971636.910650917,6],[971637.060612364,8],[971637.236749119,9],[971637.388917271,13],[971637.537206684,8],[971637.686503007,20],[971637.836318304,17],[971638.022266143,23],[971638.198781846,12],[971638.35074621,16],[971638.535748917,6],[971638.723433176,15],[971638.870914764,5],[971639.020617742,7],[971639.196623262,14],[971639.386236034,21],[971639.561644593,23],[971639.749267818,5],[971639.897232997,3],[971640.083300088,25],[971640.263116385,18],[971640.413888973,13],[971640.599334926,64],[971640.78888236,2],[971640.975871408,10],[971641.159888702,11],[971641.318055566,15],[971641.491055718,17],[971641.617119039,14],[971641.821599484,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-73d554a20acda061f2e888b3c41742e9","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":1,"prefill_raised":[],"prefill_seconds":0.146655821,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.572785691,"time_to_first_token":0.237805886,"token_sha":"8a91591c94a3","tokens_per_second":18.78759495695039},"seed":1234,"sent":971628.00797612,"speculative":{"acceptance_rate":0.4425,"accepted":177,"drafted":400,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2406751560047269,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":400,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":7,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.622514903546378,"done":971641.942905122,"finish_reason":"length","first":971628.249774382,"full_response_s":13.935050381929614,"last":971641.942876593,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971628.249774382,3],[971628.400622361,11],[971628.580727977,30],[971628.764420852,19],[971628.949787996,21],[971629.130644538,15],[971629.285674685,19],[971629.432847491,17],[971629.581022792,6],[971629.728953317,8],[971629.912120724,3],[971630.086474022,5],[971630.274667769,27],[971630.458214944,12],[971630.641843354,13],[971630.824219517,5],[971630.994531806,16],[971631.1817403,5],[971631.369651454,14],[971631.552027898,9],[971631.699712771,22],[971631.845970415,10],[971632.030563014,7],[971632.218099781,23],[971632.36946807,5],[971632.516007638,9],[971632.69364918,14],[971632.839469861,20],[971632.98877645,8],[971633.137286279,12],[971633.293086582,5],[971633.443331903,14],[971633.629113601,14],[971633.776591943,8],[971633.958323082,13],[971634.133559496,3],[971634.324573455,10],[971634.473450505,11],[971634.659583918,9],[971634.843447021,10],[971635.025964238,20],[971635.174227726,6],[971635.367575875,8],[971635.552043822,14],[971635.734912745,13],[971635.90517724,5],[971636.093760502,14],[971636.323312811,11],[971636.552183644,51],[971636.726026178,14],[971636.91187793,11],[971637.05927882,4],[971637.238629527,10],[971637.388818788,9],[971637.536697469,13],[971637.687245957,8],[971637.835476279,20],[971638.022619962,32],[971638.199374855,14],[971638.351693902,6],[971638.537286691,16],[971638.724032474,6],[971638.870733686,15],[971639.019671794,5],[971639.19811041,7],[971639.386702512,22],[971639.562737329,16],[971639.752520283,20],[971639.89688361,5],[971640.085881989,3],[971640.262914299,25],[971640.413959279,18],[971640.599743818,13],[971640.789238803,64],[971640.973655374,2],[971641.159258795,10],[971641.317852632,11],[971641.49137768,15],[971641.617426584,17],[971641.823208971,14],[971641.942876593,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-f2530ca3322769d79e8fba76fd5bbbff","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.146940582,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.69216628,"time_to_first_token":0.233011917,"token_sha":"8a91591c94a3","tokens_per_second":18.623787849587814},"seed":1234,"sent":971628.00785474,"speculative":{"acceptance_rate":0.43640897755610975,"accepted":175,"drafted":401,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.24191964196506888,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":401,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":8,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.787668577813868,"done":971641.821380773,"finish_reason":"length","first":971628.248611275,"full_response_s":13.813374603982083,"last":971641.82134378,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971628.248611275,3],[971628.399492647,11],[971628.582593201,30],[971628.765778125,19],[971628.948288559,21],[971629.131135817,15],[971629.285255216,19],[971629.43405812,17],[971629.579883637,6],[971629.728389892,8],[971629.914098751,3],[971630.084559756,5],[971630.273808191,29],[971630.458500729,10],[971630.641134693,13],[971630.826389967,5],[971630.99685378,16],[971631.181682554,5],[971631.369919254,16],[971631.552107324,7],[971631.700019436,27],[971631.846889611,11],[971632.030325199,8],[971632.218849371,16],[971632.369737038,5],[971632.51595098,9],[971632.692232625,14],[971632.842385165,20],[971632.989554921,8],[971633.138665648,12],[971633.292906609,5],[971633.444133175,14],[971633.628869706,14],[971633.776895472,8],[971633.958721526,13],[971634.132758352,3],[971634.324694659,10],[971634.472042799,11],[971634.658384554,9],[971634.842460863,10],[971635.026241622,20],[971635.174364002,14],[971635.369324343,14],[971635.551659443,13],[971635.73380396,5],[971635.905697863,14],[971636.093061633,11],[971636.323520833,51],[971636.551640636,13],[971636.725941887,12],[971636.910309643,6],[971637.060828338,8],[971637.2365258,9],[971637.387598608,13],[971637.538176089,8],[971637.68742473,20],[971637.835687917,17],[971638.023578406,23],[971638.198482253,12],[971638.352503174,16],[971638.537216721,6],[971638.72465158,15],[971638.871780678,8],[971639.020845173,9],[971639.197783536,9],[971639.3865535,21],[971639.562791267,23],[971639.750458397,5],[971639.895989824,3],[971640.084412473,25],[971640.264476778,18],[971640.412705242,13],[971640.597802928,64],[971640.789159248,2],[971640.974778927,10],[971641.160957102,11],[971641.317449884,15],[971641.491098888,17],[971641.617759794,14],[971641.82134378,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-e8e04b52796cff36e415bb4bbd260b4a","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.146486504,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.572642998,"time_to_first_token":0.238192697,"token_sha":"8a91591c94a3","tokens_per_second":18.78779247620199},"seed":1234,"sent":971628.008006169,"speculative":{"acceptance_rate":0.4317073170731707,"accepted":177,"drafted":410,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.24060510599520057,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":410,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":9,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.787832054465685,"done":971641.82248327,"finish_reason":"length","first":971628.249826911,"full_response_s":13.813878842978738,"last":971641.822441317,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971628.249826911,3],[971628.400506886,11],[971628.581043314,30],[971628.764223502,19],[971628.949080903,21],[971629.130587176,15],[971629.285344483,19],[971629.431619038,17],[971629.579826788,6],[971629.729602504,8],[971629.912853402,3],[971630.08407459,5],[971630.275148328,29],[971630.456899657,10],[971630.64166482,13],[971630.82389874,5],[971630.995464459,16],[971631.18075219,5],[971631.370423717,16],[971631.551363302,7],[971631.698944092,22],[971631.84631889,16],[971632.032817674,8],[971632.219118948,16],[971632.369789136,5],[971632.515041497,9],[971632.691775892,14],[971632.840592087,20],[971632.990558039,8],[971633.136857802,12],[971633.293352558,5],[971633.442737229,14],[971633.627434495,14],[971633.773818612,8],[971633.957829819,13],[971634.132054203,3],[971634.326263426,10],[971634.472646369,11],[971634.657190774,9],[971634.843136548,10],[971635.025320218,20],[971635.174852721,14],[971635.36667204,14],[971635.549654135,13],[971635.734714083,5],[971635.903872321,14],[971636.090667929,11],[971636.321849247,51],[971636.552818047,13],[971636.723914275,12],[971636.910545778,6],[971637.061042073,8],[971637.238408272,9],[971637.386790872,13],[971637.535934182,8],[971637.68820973,20],[971637.835024665,17],[971638.024114102,23],[971638.200039195,12],[971638.351156174,16],[971638.536213715,6],[971638.725476773,15],[971638.87144382,8],[971639.019786133,9],[971639.196456249,9],[971639.384852521,21],[971639.560906299,23],[971639.74873161,5],[971639.895688519,3],[971640.084125408,25],[971640.264258035,18],[971640.413692359,13],[971640.5992907,64],[971640.788221925,2],[971640.972832422,10],[971641.161064993,11],[971641.318767107,15],[971641.49145821,17],[971641.618095628,14],[971641.822441317,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-f5644c1d11c61fa30c35ab485af88a4c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.146540281,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.572910271,"time_to_first_token":0.238405263,"token_sha":"8a91591c94a3","tokens_per_second":18.787422513566252},"seed":1234,"sent":971628.008604427,"speculative":{"acceptance_rate":0.43276283618581907,"accepted":177,"drafted":409,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.24122248403728008,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":409,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":10,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.623685845018855,"done":971641.941784241,"finish_reason":"length","first":971628.24952703,"full_response_s":13.931238971999846,"last":971641.941768304,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971628.24952703,3],[971628.401676569,11],[971628.583205811,30],[971628.766133768,19],[971628.948436483,21],[971629.130313904,15],[971629.284785234,19],[971629.432763217,17],[971629.579736625,6],[971629.728319233,8],[971629.911419103,3],[971630.083877384,5],[971630.275300844,27],[971630.458890389,12],[971630.6409772,13],[971630.825909744,5],[971630.994264582,16],[971631.179316163,5],[971631.369600541,14],[971631.552850707,9],[971631.70021317,22],[971631.845555363,10],[971632.029375762,7],[971632.218288843,23],[971632.368935078,5],[971632.514808322,9],[971632.693180062,14],[971632.839047593,20],[971632.989312482,8],[971633.138023101,12],[971633.294811738,5],[971633.444442528,14],[971633.628117011,14],[971633.775706333,8],[971633.960558493,13],[971634.132148558,3],[971634.324955131,10],[971634.474069291,11],[971634.658876472,9],[971634.841175881,10],[971635.026044048,20],[971635.175928929,6],[971635.367691094,8],[971635.550841914,14],[971635.733648948,13],[971635.904566342,5],[971636.091408912,14],[971636.322824124,11],[971636.551326578,51],[971636.725128135,14],[971636.909598678,11],[971637.061640475,4],[971637.23706028,10],[971637.387752308,9],[971637.536425957,13],[971637.686827272,8],[971637.834796386,20],[971638.024815019,32],[971638.199303813,14],[971638.352898898,6],[971638.538189358,16],[971638.723798163,6],[971638.87192881,15],[971639.01961312,5],[971639.196365094,7],[971639.385135666,22],[971639.563441622,16],[971639.75289295,20],[971639.897493148,5],[971640.085500185,3],[971640.263310471,25],[971640.415227893,18],[971640.598529366,13],[971640.789889526,64],[971640.974204222,2],[971641.159311005,10],[971641.318626143,11],[971641.491139817,15],[971641.61831685,17],[971641.82342429,14],[971641.941768304,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-a595c3e3371455eece371761c19083dd","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.146894356,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.692151016,"time_to_first_token":0.233577102,"token_sha":"8a91591c94a3","tokens_per_second":18.623808611372972},"seed":1234,"sent":971628.010545269,"speculative":{"acceptance_rate":0.43316831683168316,"accepted":175,"drafted":404,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23898176103830338,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":404,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":11,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.78686952572535,"done":971641.82207905,"finish_reason":"length","first":971628.248730446,"full_response_s":13.814168964046985,"last":971641.822040233,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971628.248730446,3],[971628.400035976,11],[971628.583052911,30],[971628.765506373,19],[971628.948063976,21],[971629.130690539,15],[971629.284552683,19],[971629.434749596,17],[971629.579950279,6],[971629.729301727,8],[971629.911691719,3],[971630.086547112,5],[971630.274208427,27],[971630.457987898,12],[971630.642112482,13],[971630.826486337,5],[971630.994915258,16],[971631.180127323,5],[971631.369841428,14],[971631.554192091,9],[971631.699671378,22],[971631.84674383,10],[971632.03304232,7],[971632.218785482,23],[971632.368030651,5],[971632.5158056,9],[971632.693366339,14],[971632.840874271,20],[971632.991065319,8],[971633.138257796,12],[971633.29316004,5],[971633.444918783,14],[971633.627374285,14],[971633.775875698,8],[971633.960111519,13],[971634.133198429,3],[971634.324481533,10],[971634.472426458,11],[971634.657542976,9],[971634.84174553,10],[971635.026994765,20],[971635.174977253,14],[971635.366519043,14],[971635.550365756,13],[971635.734374201,5],[971635.90510175,14],[971636.09095989,11],[971636.322144024,51],[971636.552531398,13],[971636.727801415,12],[971636.911488238,6],[971637.060402102,8],[971637.237390338,9],[971637.389039835,13],[971637.537530726,8],[971637.687788197,20],[971637.835534728,17],[971638.024397535,23],[971638.199963913,12],[971638.353098568,16],[971638.536920552,6],[971638.724941893,15],[971638.871721732,5],[971639.020306069,7],[971639.198168924,14],[971639.388278015,21],[971639.562161584,23],[971639.749980607,5],[971639.896491663,3],[971640.086278608,25],[971640.264032541,18],[971640.414037649,13],[971640.600029122,64],[971640.791157388,2],[971640.975453091,10],[971641.161019008,11],[971641.317234342,15],[971641.492683607,17],[971641.617524971,14],[971641.822040233,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-2445bd3acac350f8dbf9daaba10b5b30","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":1,"prefill_raised":[],"prefill_seconds":0.14669387,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.572755178,"time_to_first_token":0.238018516,"token_sha":"8a91591c94a3","tokens_per_second":18.787637193465923},"seed":1234,"sent":971628.007910086,"speculative":{"acceptance_rate":0.44472361809045224,"accepted":177,"drafted":398,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.24082036002073437,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":398,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":12,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.78521895119026,"done":971641.823966018,"finish_reason":"length","first":971628.248550665,"full_response_s":13.815901912050322,"last":971641.823053079,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971628.248550665,3],[971628.401151673,11],[971628.582246438,30],[971628.764480038,19],[971628.948671754,21],[971629.131417457,15],[971629.284044188,19],[971629.435104471,17],[971629.580411621,6],[971629.728661596,8],[971629.913765045,3],[971630.085436343,5],[971630.273489286,27],[971630.457136784,12],[971630.641400157,13],[971630.825469971,5],[971630.996087469,16],[971631.180238415,5],[971631.369280755,14],[971631.55289474,9],[971631.699457163,22],[971631.846797288,10],[971632.032281257,7],[971632.218984944,23],[971632.370221485,5],[971632.517252507,9],[971632.693008745,14],[971632.839260239,20],[971632.989130589,8],[971633.139585388,12],[971633.294647189,5],[971633.443845774,14],[971633.627683718,14],[971633.775387651,8],[971633.959784758,13],[971634.133897394,3],[971634.323684405,10],[971634.474169342,11],[971634.657877466,9],[971634.84374023,10],[971635.026358826,20],[971635.175859295,14],[971635.367642325,14],[971635.551149683,13],[971635.736212192,5],[971635.905742601,14],[971636.092661317,11],[971636.32114385,51],[971636.550689375,13],[971636.726754055,12],[971636.911747654,6],[971637.060876132,8],[971637.237559831,9],[971637.387284022,13],[971637.537938562,8],[971637.688347398,20],[971637.836649882,17],[971638.023144745,23],[971638.198532078,12],[971638.352084841,16],[971638.538440069,6],[971638.723935831,15],[971638.871830919,8],[971639.020550044,9],[971639.196939703,9],[971639.387548953,21],[971639.563251824,23],[971639.750221686,5],[971639.897821942,3],[971640.084673489,25],[971640.263968795,18],[971640.414854154,13],[971640.599248507,64],[971640.791902882,2],[971640.975020934,10],[971641.160034434,11],[971641.317525455,15],[971641.492076981,17],[971641.618281457,14],[971641.823053079,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-435fe7e5da8c1b2d3ab37467e458e2b2","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":1,"prefill_raised":[],"prefill_seconds":0.146616572,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.572877373,"time_to_first_token":0.237895952,"token_sha":"8a91591c94a3","tokens_per_second":18.787468050603746},"seed":1234,"sent":971628.008064106,"speculative":{"acceptance_rate":0.44029850746268656,"accepted":177,"drafted":402,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.24048655899241567,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":402,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":13,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.623658509841157,"done":971641.941515529,"finish_reason":"length","first":971628.24919966,"full_response_s":13.933299753931351,"last":971641.941461031,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971628.24919966,3],[971628.401100744,11],[971628.582053889,30],[971628.765234701,19],[971628.947270368,21],[971629.131376608,15],[971629.284317636,19],[971629.433790592,17],[971629.579996585,6],[971629.728190238,8],[971629.911190696,3],[971630.08588522,5],[971630.273656219,27],[971630.45780146,12],[971630.640588228,13],[971630.825595351,5],[971630.99512328,16],[971631.181988627,5],[971631.368676513,14],[971631.551651583,9],[971631.698384171,22],[971631.845307723,10],[971632.033302648,7],[971632.219061074,23],[971632.367797124,5],[971632.517952656,9],[971632.691050126,14],[971632.840526549,20],[971632.987972906,8],[971633.136621171,12],[971633.293844941,5],[971633.44469132,14],[971633.627873868,14],[971633.774220064,8],[971633.958573601,13],[971634.134769805,3],[971634.322989296,10],[971634.471304345,11],[971634.657814105,9],[971634.841463826,10],[971635.026893146,20],[971635.175394129,6],[971635.367518433,8],[971635.551920906,14],[971635.73653969,13],[971635.903796639,5],[971636.089864001,14],[971636.323639541,11],[971636.550320916,51],[971636.727591248,14],[971636.908448324,11],[971637.059958664,4],[971637.237764525,10],[971637.388434633,9],[971637.535880436,13],[971637.686345722,8],[971637.834700208,20],[971638.023913232,32],[971638.199901911,14],[971638.352369122,6],[971638.536688321,16],[971638.723527387,6],[971638.870663732,15],[971639.019838183,5],[971639.1972392,7],[971639.386639902,22],[971639.562701472,17],[971639.749478848,19],[971639.898190753,5],[971640.086211102,3],[971640.263220549,25],[971640.413363037,18],[971640.600199239,13],[971640.789645791,64],[971640.974133564,2],[971641.159476002,10],[971641.31845633,11],[971641.491020549,15],[971641.617311877,17],[971641.821256881,14],[971641.941461031,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-f6e7dfd534e1b34ecf5f36e4be35bd8c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.146850131,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.692196457,"time_to_first_token":0.234852085,"token_sha":"8a91591c94a3","tokens_per_second":18.62374680357685},"seed":1234,"sent":971628.008215775,"speculative":{"acceptance_rate":0.43103448275862066,"accepted":175,"drafted":406,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2409838850144297,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":406,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":14,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.92049508949033,"done":971641.491751819,"finish_reason":"length","first":971628.014262229,"full_response_s":13.483808228047565,"last":971641.491710826,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971628.014262229,3],[971628.103115313,26],[971628.401026214,15],[971628.58330431,19],[971628.764799599,21],[971628.949440625,15],[971629.130147243,19],[971629.285103852,17],[971629.433280256,6],[971629.580193551,11],[971629.728210894,5],[971629.911288923,18],[971630.085668414,21],[971630.274772236,9],[971630.458435287,9],[971630.642207893,16],[971630.825173498,5],[971630.993969902,10],[971631.179592507,13],[971631.369102174,27],[971631.551064525,11],[971631.698639379,8],[971631.846128052,16],[971632.032082067,9],[971632.219992174,10],[971632.368625229,9],[971632.517496867,20],[971632.691445466,8],[971632.838944165,12],[971632.988219217,5],[971633.136956685,14],[971633.293631526,11],[971633.444217689,7],[971633.627172503,17],[971633.777273164,3],[971633.958936252,10],[971634.132470216,11],[971634.323370779,9],[971634.471183541,10],[971634.65814389,20],[971634.840410642,14],[971635.027178578,14],[971635.175206028,13],[971635.368271656,5],[971635.552267461,14],[971635.736610108,11],[971635.904493363,51],[971636.094565518,14],[971636.32295848,11],[971636.551588794,4],[971636.727111266,10],[971636.91141222,9],[971637.059389591,13],[971637.236693725,8],[971637.386496671,20],[971637.535773681,21],[971637.685886396,25],[971637.835835585,6],[971638.023331423,16],[971638.198406731,6],[971638.350539771,15],[971638.536352135,8],[971638.724871331,18],[971638.870557361,21],[971639.019430811,23],[971639.195634321,5],[971639.385947674,3],[971639.561556238,16],[971639.750626082,24],[971639.897431883,11],[971640.084768755,13],[971640.263598208,56],[971640.413780826,2],[971640.598402242,10],[971640.790591403,11],[971640.97312683,15],[971641.158724188,17],[971641.317348441,14],[971641.491710826,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-31d113742dc2fe3398e5eb4128351a84","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":1,"prefill_raised":[],"prefill_seconds":0.003375062,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.476551977,"time_to_first_token":0.004211359,"token_sha":"8a91591c94a3","tokens_per_second":18.921753905242255},"seed":1234,"sent":971628.007943591,"speculative":{"acceptance_rate":0.4585492227979275,"accepted":177,"drafted":386,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.006318637984804809,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":386,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":0,"stream":15,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.62315039673009,"done":971641.941601756,"finish_reason":"length","first":971628.248928596,"full_response_s":13.933901389013045,"last":971641.941563546,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971628.248928596,3],[971628.399785904,11],[971628.581776648,30],[971628.76535848,19],[971628.947966981,21],[971629.131252252,15],[971629.284118318,19],[971629.434276702,17],[971629.580146045,6],[971629.729651802,8],[971629.913302887,3],[971630.084629455,5],[971630.27371502,27],[971630.457913095,12],[971630.642534767,13],[971630.826139991,5],[971630.995041614,16],[971631.180326865,5],[971631.369021723,14],[971631.55294031,9],[971631.699194339,22],[971631.846262856,10],[971632.030050214,7],[971632.218181191,23],[971632.368261618,5],[971632.515689788,9],[971632.69053579,14],[971632.840226588,20],[971632.991352463,8],[971633.139265202,12],[971633.292779517,5],[971633.44390144,14],[971633.627272442,14],[971633.774971191,8],[971633.959417787,13],[971634.132581835,3],[971634.325348823,10],[971634.472559102,11],[971634.657683429,9],[971634.84334681,10],[971635.027890711,20],[971635.174523751,6],[971635.366393088,8],[971635.551848936,14],[971635.734425243,13],[971635.90499461,5],[971636.092409533,14],[971636.322906863,11],[971636.550561611,51],[971636.725877101,14],[971636.90898866,11],[971637.060789233,4],[971637.238188554,10],[971637.387702435,9],[971637.536614858,13],[971637.686135284,8],[971637.83574195,20],[971638.022812207,32],[971638.200386838,14],[971638.353496403,6],[971638.53805601,16],[971638.724385636,6],[971638.871139363,15],[971639.019876648,5],[971639.196530619,7],[971639.38576066,22],[971639.56190588,17],[971639.751521357,19],[971639.897752452,5],[971640.083685347,3],[971640.263695123,25],[971640.413195768,18],[971640.599586373,13],[971640.788482476,64],[971640.973840691,2],[971641.160200999,10],[971641.317966892,11],[971641.491237068,15],[971641.618361572,17],[971641.824155047,14],[971641.941563546,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-c20a672b9a041b165234be962ffd2413","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.146810962,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.692261931,"time_to_first_token":0.235999943,"token_sha":"8a91591c94a3","tokens_per_second":18.623657748079342},"seed":1234,"sent":971628.007700367,"speculative":{"acceptance_rate":0.42997542997543,"accepted":175,"drafted":407,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.24122822901699692,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":407,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.45333719592963,"done":971655.930887228,"finish_reason":"length","first":971642.112093906,"full_response_s":13.97488890204113,"last":971655.930732632,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971642.112093906,3],[971642.266280278,11],[971642.450050421,30],[971642.635219486,19],[971642.81918469,21],[971643.003274692,15],[971643.15005959,19],[971643.307094647,17],[971643.453279976,6],[971643.603607123,8],[971643.788874807,3],[971643.959191643,5],[971644.145036328,27],[971644.337210352,12],[971644.520868972,9],[971644.706987074,9],[971644.877563241,16],[971645.062947121,5],[971645.255176146,14],[971645.44117262,9],[971645.588056421,22],[971645.736359272,10],[971645.922189448,7],[971646.104601648,23],[971646.258100022,5],[971646.408346972,9],[971646.585519386,14],[971646.734454233,20],[971646.879109367,8],[971647.029921175,12],[971647.17951434,5],[971647.336902629,14],[971647.521729517,14],[971647.668866753,8],[971647.852868623,13],[971648.023844136,3],[971648.211647599,10],[971648.365682152,11],[971648.549859573,9],[971648.738915873,10],[971648.920936474,20],[971649.070161039,6],[971649.258754069,8],[971649.446553845,14],[971649.680102161,13],[971649.828131714,5],[971650.012984483,22],[971650.249987818,3],[971650.487505793,43],[971650.675377259,22],[971650.862752196,11],[971651.04572383,6],[971651.196546413,8],[971651.349490883,9],[971651.501133346,13],[971651.649847259,8],[971651.79845693,20],[971651.94821362,17],[971652.098797038,20],[971652.255309045,13],[971652.442061934,6],[971652.628784855,13],[971652.781630723,9],[971652.964922481,11],[971653.115103065,8],[971653.307804264,14],[971653.493937479,12],[971653.660618992,15],[971653.900918486,21],[971654.047849113,8],[971654.239519346,25],[971654.392178572,18],[971654.542044741,13],[971654.728691804,64],[971654.879185044,2],[971655.067703593,10],[971655.245396724,11],[971655.398307455,15],[971655.546630964,17],[971655.742970557,14],[971655.930732632,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-7975e7256520ad17129462db4eb1c361","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.04863456,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.820842967,"time_to_first_token":0.150518663,"token_sha":"8a91591c94a3","tokens_per_second":18.45039413361855},"seed":1234,"sent":971641.955998326,"speculative":{"acceptance_rate":0.4396984924623116,"accepted":175,"drafted":398,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1560955800814554,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":398,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.4541178259651,"done":971655.92784122,"finish_reason":"length","first":971642.109767277,"full_response_s":13.971238508005626,"last":971655.927821459,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971642.109767277,3],[971642.26811694,11],[971642.449362609,30],[971642.634143598,19],[971642.82146767,21],[971643.002011038,15],[971643.150496707,19],[971643.305449831,17],[971643.455018092,6],[971643.604817575,8],[971643.787983645,3],[971643.96017212,5],[971644.14389191,29],[971644.336333734,10],[971644.521276104,13],[971644.707180871,5],[971644.878803054,16],[971645.065295206,5],[971645.255465387,16],[971645.438272583,7],[971645.587301535,27],[971645.737726704,11],[971645.920923875,8],[971646.104067697,16],[971646.258451696,5],[971646.409464332,9],[971646.582673606,14],[971646.732868266,20],[971646.879947872,8],[971647.030157438,12],[971647.179721066,5],[971647.335489116,14],[971647.52314087,14],[971647.668102538,8],[971647.852509828,13],[971648.024378872,3],[971648.212440743,10],[971648.367065872,11],[971648.550445318,9],[971648.734885338,10],[971648.920179668,20],[971649.068714596,6],[971649.260460983,8],[971649.446771819,14],[971649.679362507,13],[971649.827295257,5],[971650.013979648,22],[971650.25017888,3],[971650.487602228,43],[971650.675250791,22],[971650.86044056,11],[971651.044876109,6],[971651.195927451,8],[971651.351476493,9],[971651.501182547,13],[971651.651109392,8],[971651.799361068,20],[971651.949343557,17],[971652.100373612,20],[971652.254794838,13],[971652.442560093,6],[971652.629033358,13],[971652.780513186,9],[971652.964742428,11],[971653.116095366,8],[971653.30691011,15],[971653.494571882,16],[971653.662747374,27],[971653.901124636,4],[971654.047820009,8],[971654.241473355,25],[971654.393352078,18],[971654.542387199,13],[971654.729866638,64],[971654.878405741,2],[971655.066636922,10],[971655.245678156,11],[971655.397118988,15],[971655.547270919,17],[971655.742998542,14],[971655.927821459,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-7b5826667ff007a4aeb03b9358a41e04","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.048243396,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.817738701,"time_to_first_token":0.151188059,"token_sha":"8a91591c94a3","tokens_per_second":18.45453916287659},"seed":1234,"sent":971641.956602712,"speculative":{"acceptance_rate":0.4060324825986079,"accepted":175,"drafted":431,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1531645649811253,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":431,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.45724819525609,"done":971655.927987992,"finish_reason":"length","first":971642.112256647,"full_response_s":13.97125210892409,"last":971655.927967272,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971642.112256647,3],[971642.267335509,11],[971642.450600933,30],[971642.634976359,19],[971642.819247764,21],[971643.001770375,15],[971643.150815804,19],[971643.306329569,17],[971643.454439002,6],[971643.603851402,8],[971643.788110369,3],[971643.960544259,5],[971644.147384269,27],[971644.335519102,12],[971644.520681207,13],[971644.705795758,5],[971644.878234013,16],[971645.063226969,5],[971645.254453053,14],[971645.438997132,9],[971645.587091049,22],[971645.736281942,16],[971645.922688023,8],[971646.103896316,16],[971646.257451955,5],[971646.407759098,9],[971646.583960428,14],[971646.732090243,20],[971646.880366316,8],[971647.031387091,12],[971647.179975601,5],[971647.334850281,14],[971647.519564333,14],[971647.667358597,8],[971647.851744926,13],[971648.023738277,3],[971648.211287525,10],[971648.365361854,11],[971648.548979691,9],[971648.735212948,10],[971648.921859221,20],[971649.069299893,6],[971649.259854373,8],[971649.445259823,14],[971649.680451995,13],[971649.828658193,5],[971650.014114228,22],[971650.24975202,3],[971650.486628023,43],[971650.674871004,22],[971650.861514719,11],[971651.047380855,6],[971651.196127489,8],[971651.350961838,9],[971651.500293881,13],[971651.648929808,8],[971651.798383856,20],[971651.947825497,17],[971652.099358526,20],[971652.254872552,13],[971652.443982998,6],[971652.628541488,13],[971652.778797664,9],[971652.963342115,11],[971653.115225868,8],[971653.310318433,15],[971653.495494469,16],[971653.662277312,27],[971653.898997278,4],[971654.048360968,8],[971654.240399052,25],[971654.393039013,18],[971654.541333536,13],[971654.729936608,64],[971654.877966384,2],[971655.066815823,10],[971655.24609164,11],[971655.396900326,15],[971655.546386093,17],[971655.742902443,14],[971655.927967272,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-ad6694b742efa54ffd2481b7b05ac07b","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.048429449,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.817654043,"time_to_first_token":0.150430005,"token_sha":"8a91591c94a3","tokens_per_second":18.454652230143406},"seed":1234,"sent":971641.956735883,"speculative":{"acceptance_rate":0.42168674698795183,"accepted":175,"drafted":415,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.15552076394669712,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":415,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.454578676961507,"done":971655.928529736,"finish_reason":"length","first":971642.110799196,"full_response_s":13.972455183975399,"last":971655.928508311,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971642.110799196,3],[971642.266707378,11],[971642.451522961,30],[971642.633940696,19],[971642.820120782,21],[971643.001698261,15],[971643.149733164,19],[971643.30664705,17],[971643.45428183,6],[971643.604162596,8],[971643.787635586,3],[971643.959842942,5],[971644.143690944,27],[971644.335219557,12],[971644.520946239,9],[971644.705878945,9],[971644.877745631,16],[971645.064152324,5],[971645.254298696,14],[971645.441751549,9],[971645.589255384,22],[971645.737236178,10],[971645.920116603,7],[971646.103231224,23],[971646.25803554,5],[971646.407289052,9],[971646.581802636,14],[971646.731948383,20],[971646.878701451,8],[971647.031520758,12],[971647.179878766,5],[971647.335642176,14],[971647.51985895,14],[971647.667265218,8],[971647.851864433,13],[971648.022879148,3],[971648.212756432,10],[971648.365945199,11],[971648.547911307,9],[971648.73630586,10],[971648.919289465,20],[971649.069447546,6],[971649.258876009,8],[971649.446363071,14],[971649.680870151,13],[971649.827217783,5],[971650.013664599,22],[971650.251258672,3],[971650.488796999,43],[971650.67548723,22],[971650.860258619,11],[971651.04639481,6],[971651.196213876,8],[971651.351674514,9],[971651.5013518,13],[971651.650525567,8],[971651.798716121,20],[971651.951472067,17],[971652.100645284,20],[971652.255106271,13],[971652.443881603,6],[971652.628860697,13],[971652.778656556,9],[971652.963765359,11],[971653.11541813,8],[971653.310912786,14],[971653.494247264,12],[971653.662991717,16],[971653.899832839,20],[971654.048492828,8],[971654.239811819,25],[971654.394949805,18],[971654.542894046,13],[971654.728195773,64],[971654.878587426,2],[971655.06656444,10],[971655.246328815,11],[971655.397478007,15],[971655.548554908,17],[971655.743206164,14],[971655.928508311,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-73495ead3ecf2e44113ce6fbcb34f053","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.048565725,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.817926003,"time_to_first_token":0.150367363,"token_sha":"8a91591c94a3","tokens_per_second":18.454289011580837},"seed":1234,"sent":971641.956074552,"speculative":{"acceptance_rate":0.43209876543209874,"accepted":175,"drafted":405,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.15472464391496032,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":405,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.45638827872037,"done":971655.927226594,"finish_reason":"length","first":971642.110836013,"full_response_s":13.969936757930554,"last":971655.927190337,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971642.110836013,3],[971642.267872981,11],[971642.451234312,30],[971642.634663149,19],[971642.81936428,21],[971643.002719987,15],[971643.150550949,19],[971643.30461283,17],[971643.455746881,6],[971643.603505392,8],[971643.788059631,3],[971643.959753788,5],[971644.147634357,29],[971644.337121565,10],[971644.521030321,13],[971644.705647786,5],[971644.879500738,16],[971645.064314393,5],[971645.254851273,16],[971645.438673602,7],[971645.588676791,22],[971645.737025627,16],[971645.921404385,8],[971646.104538078,16],[971646.25852381,5],[971646.408651397,9],[971646.583669907,14],[971646.731827404,20],[971646.878626089,8],[971647.030091996,12],[971647.179808316,5],[971647.334221462,14],[971647.521453141,14],[971647.668345874,8],[971647.852906592,13],[971648.023490126,3],[971648.212194431,10],[971648.365217978,11],[971648.548096865,9],[971648.735935625,10],[971648.92054883,20],[971649.068594529,6],[971649.258325417,8],[971649.44583504,14],[971649.679299225,13],[971649.826790203,5],[971650.014165894,22],[971650.251839313,3],[971650.488142132,43],[971650.675754022,22],[971650.86206816,11],[971651.048243648,6],[971651.196294966,8],[971651.350221976,9],[971651.501401306,13],[971651.649443872,8],[971651.798170218,20],[971651.949305844,17],[971652.09983054,20],[971652.255782259,13],[971652.442925992,6],[971652.628701076,13],[971652.782054351,9],[971652.965300204,11],[971653.115965506,8],[971653.306843692,15],[971653.495841855,16],[971653.663174731,27],[971653.901546969,4],[971654.047909627,8],[971654.24088433,25],[971654.393399024,18],[971654.541506437,13],[971654.728317473,64],[971654.878888075,2],[971655.067247772,10],[971655.247277051,11],[971655.396369415,15],[971655.547388955,17],[971655.742859642,14],[971655.927190337,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-61be0c823471ee51fd83a9862c86e31c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.04831959,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.817422436,"time_to_first_token":0.151168875,"token_sha":"8a91591c94a3","tokens_per_second":18.45496156617615},"seed":1234,"sent":971641.957289836,"speculative":{"acceptance_rate":0.4098360655737705,"accepted":175,"drafted":427,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.15354617696721107,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":427,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.452274956015632,"done":971655.930250138,"finish_reason":"length","first":971642.110762826,"full_response_s":13.972590130986646,"last":971655.930197048,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971642.110762826,3],[971642.266861191,11],[971642.451136805,30],[971642.635636906,19],[971642.818376955,21],[971643.002440859,15],[971643.151033619,19],[971643.305877923,17],[971643.453531712,6],[971643.604983772,8],[971643.788278501,3],[971643.960632549,5],[971644.144432438,27],[971644.336875606,12],[971644.521694085,9],[971644.705719852,9],[971644.877930884,16],[971645.065526205,5],[971645.25395987,14],[971645.439126704,9],[971645.5882915,22],[971645.736191155,10],[971645.921305102,7],[971646.103403885,23],[971646.258347933,5],[971646.409895833,9],[971646.583173349,14],[971646.734119887,20],[971646.880630164,8],[971647.031191421,12],[971647.178923858,5],[971647.337870529,14],[971647.52109921,14],[971647.66821867,8],[971647.853431023,13],[971648.025066892,3],[971648.212312595,10],[971648.364510117,11],[971648.549053389,9],[971648.735728211,10],[971648.920659906,20],[971649.07179035,6],[971649.260167023,8],[971649.445081017,14],[971649.679853753,13],[971649.827848026,5],[971650.013587541,22],[971650.250676239,3],[971650.487724071,43],[971650.675869529,22],[971650.860061077,11],[971651.048027753,6],[971651.197473624,8],[971651.350459151,9],[971651.501461275,13],[971651.651844486,8],[971651.799895628,20],[971651.948798805,17],[971652.098922594,20],[971652.254449644,13],[971652.443463335,6],[971652.628617858,13],[971652.781084691,9],[971652.964794749,11],[971653.116025156,8],[971653.309056636,14],[971653.495561991,12],[971653.663235868,16],[971653.899702563,20],[971654.049517306,8],[971654.23908199,25],[971654.392820927,18],[971654.542141336,13],[971654.729021557,64],[971654.878544561,2],[971655.066223614,10],[971655.246919632,11],[971655.39695092,15],[971655.547900521,17],[971655.742751799,14],[971655.930197048,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-c22f7674d9782f282f47a4ceb2fda2eb","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.048603471,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.820357849,"time_to_first_token":0.150132011,"token_sha":"8a91591c94a3","tokens_per_second":18.451041773744738},"seed":1234,"sent":971641.957660007,"speculative":{"acceptance_rate":0.43209876543209874,"accepted":175,"drafted":405,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.15310281899292022,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":405,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.453076244870328,"done":971655.928564041,"finish_reason":"length","first":971642.109716492,"full_response_s":13.971696202061139,"last":971655.928550632,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971642.109716492,3],[971642.266483756,11],[971642.45157077,30],[971642.633813508,19],[971642.81889233,21],[971643.003148336,15],[971643.149858176,19],[971643.304793299,17],[971643.454529165,6],[971643.603431806,8],[971643.788743155,3],[971643.960739657,5],[971644.143810244,29],[971644.336111935,10],[971644.520600677,13],[971644.705496854,5],[971644.878663562,16],[971645.06446259,5],[971645.253493441,16],[971645.43918821,7],[971645.58898128,27],[971645.737512202,11],[971645.921606519,8],[971646.105542476,16],[971646.257645672,5],[971646.406614569,9],[971646.581852894,14],[971646.732768295,20],[971646.879022709,8],[971647.030319795,12],[971647.179015077,5],[971647.334501774,14],[971647.519786804,14],[971647.670477616,8],[971647.852663417,13],[971648.022969982,3],[971648.21138068,10],[971648.365825884,11],[971648.549645182,9],[971648.736845092,10],[971648.918986177,20],[971649.068990652,6],[971649.260386373,8],[971649.446829053,14],[971649.680191219,13],[971649.828300967,5],[971650.014057987,22],[971650.249871879,3],[971650.488088482,43],[971650.675037313,22],[971650.860645158,11],[971651.046901801,6],[971651.197262274,8],[971651.349627799,9],[971651.500746118,13],[971651.648811021,8],[971651.799106533,20],[971651.948360744,17],[971652.098617497,20],[971652.256766672,13],[971652.443220352,6],[971652.628415548,13],[971652.781956876,9],[971652.963700957,11],[971653.115277966,8],[971653.309761169,15],[971653.492765765,16],[971653.662552872,27],[971653.899281415,4],[971654.047765623,8],[971654.240059266,25],[971654.394708438,18],[971654.541972883,13],[971654.728980692,64],[971654.878849978,2],[971655.066335137,10],[971655.245310034,11],[971655.395925786,15],[971655.546210408,17],[971655.743162787,14],[971655.928550632,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-992d8f32696b9605b4c93bf0f982c02c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.048169409,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.817813648,"time_to_first_token":0.151520997,"token_sha":"8a91591c94a3","tokens_per_second":18.45443906655297},"seed":1234,"sent":971641.956867839,"speculative":{"acceptance_rate":0.39863325740318906,"accepted":175,"drafted":439,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.15284865302965045,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":439,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.455513396864557,"done":971655.928862209,"finish_reason":"length","first":971642.111290954,"full_response_s":13.971315933973528,"last":971655.928300241,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971642.111290954,3],[971642.267262195,11],[971642.449242733,30],[971642.63435242,19],[971642.817931117,21],[971643.001399724,15],[971643.150246363,19],[971643.30638205,17],[971643.455167792,6],[971643.604241526,8],[971643.789035964,3],[971643.958883682,5],[971644.144650349,27],[971644.334995678,12],[971644.519811181,13],[971644.706508771,5],[971644.878432659,16],[971645.064768775,5],[971645.254172213,14],[971645.440679886,9],[971645.586891283,22],[971645.73698057,10],[971645.922878092,7],[971646.105322677,23],[971646.260147426,5],[971646.410490331,9],[971646.584647376,14],[971646.733311047,20],[971646.878808271,8],[971647.030701374,12],[971647.180041251,5],[971647.335736515,14],[971647.520092541,14],[971647.667625564,8],[971647.851187181,13],[971648.023672563,3],[971648.21317494,10],[971648.364998212,11],[971648.550332067,9],[971648.73391603,10],[971648.92135991,20],[971649.067933133,6],[971649.25959683,8],[971649.446117064,14],[971649.6806248,13],[971649.829059181,5],[971650.013433712,22],[971650.250078461,3],[971650.488318633,43],[971650.674127238,22],[971650.859571591,11],[971651.045240392,6],[971651.197636557,8],[971651.35132172,9],[971651.500357691,13],[971651.649493281,8],[971651.799439615,20],[971651.948442699,17],[971652.10049496,20],[971652.255151408,13],[971652.441936571,6],[971652.629216675,13],[971652.778706014,9],[971652.964176523,11],[971653.114442454,8],[971653.307741302,14],[971653.494811905,12],[971653.662806912,16],[971653.900741617,20],[971654.048939961,8],[971654.24191964,25],[971654.394567538,18],[971654.54188704,13],[971654.729308462,64],[971654.879558447,2],[971655.069256518,10],[971655.245839921,11],[971655.396093983,15],[971655.546910877,17],[971655.742928588,14],[971655.928300241,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-dd7c4fa3d7ef35b353ffaa6c8a230fa5","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.048527996,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.817705485,"time_to_first_token":0.150874081,"token_sha":"8a91591c94a3","tokens_per_second":18.45458352523281},"seed":1234,"sent":971641.957546275,"speculative":{"acceptance_rate":0.42475728155339804,"accepted":175,"drafted":412,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1537446790607646,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":412,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.456648853336365,"done":971655.928147437,"finish_reason":"length","first":971642.110970033,"full_response_s":13.971797485020943,"last":971655.927129295,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971642.110970033,3],[971642.2667621,11],[971642.450398815,30],[971642.634054459,19],[971642.819468139,21],[971643.001139716,15],[971643.149468501,19],[971643.305085804,17],[971643.455201745,6],[971643.603644996,8],[971643.787816072,3],[971643.9590886,5],[971644.147519953,29],[971644.335834935,10],[971644.521744678,13],[971644.706634631,5],[971644.879258347,16],[971645.065065759,5],[971645.253753944,16],[971645.440512841,7],[971645.588515059,27],[971645.737442712,11],[971645.920497654,8],[971646.104240358,16],[971646.258699575,5],[971646.408153574,9],[971646.58157351,14],[971646.731523059,20],[971646.878363489,8],[971647.030916053,12],[971647.180294315,5],[971647.337211646,14],[971647.520281874,14],[971647.668589193,8],[971647.851679964,13],[971648.024239428,3],[971648.211532828,10],[971648.365597141,11],[971648.548907913,9],[971648.734682405,10],[971648.919665892,20],[971649.068037008,6],[971649.259963881,8],[971649.445758637,14],[971649.679487743,13],[971649.827611299,5],[971650.01438198,22],[971650.251531704,3],[971650.488859913,43],[971650.675166084,22],[971650.860736585,11],[971651.047870869,6],[971651.196725091,8],[971651.349883726,9],[971651.501053183,13],[971651.650071314,8],[971651.799313195,20],[971651.949783346,17],[971652.099961472,20],[971652.256542569,13],[971652.4421316,6],[971652.628918395,13],[971652.782126225,9],[971652.964843215,11],[971653.114625995,8],[971653.311281581,15],[971653.493859125,16],[971653.661698432,27],[971653.901463126,4],[971654.04840145,8],[971654.24218096,25],[971654.394826425,18],[971654.541764909,13],[971654.729581638,64],[971654.878939757,2],[971655.067957552,10],[971655.246419586,11],[971655.398821422,15],[971655.548686944,17],[971655.743312967,14],[971655.927129295,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-2d69549a4c7573f09cba48b9b24534e0","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.048207075,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.817569976,"time_to_first_token":0.15134656,"token_sha":"8a91591c94a3","tokens_per_second":18.454764509455305},"seed":1234,"sent":971641.956349952,"speculative":{"acceptance_rate":0.39863325740318906,"accepted":175,"drafted":439,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1546200809534639,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":439,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.50896695064234,"done":971655.74339897,"finish_reason":"length","first":971641.9655524,"full_response_s":13.787231839029118,"last":971655.74265842,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971641.9655524,3],[971642.061537321,26],[971642.265843033,15],[971642.449593239,19],[971642.6354277,21],[971642.818617442,15],[971643.003340069,19],[971643.148810289,17],[971643.306194781,6],[971643.454069712,11],[971643.605316918,5],[971643.787737926,18],[971643.95937008,21],[971644.145468869,9],[971644.334528129,9],[971644.520411023,16],[971644.706121416,5],[971644.876581868,10],[971645.063832347,13],[971645.253864076,27],[971645.441516278,11],[971645.589206279,8],[971645.736911624,16],[971645.92084264,9],[971646.104901625,13],[971646.258885085,15],[971646.408441214,17],[971646.583778439,6],[971646.731413743,8],[971646.879464514,5],[971647.029618991,14],[971647.180173735,11],[971647.335407865,7],[971647.518988892,17],[971647.669953617,3],[971647.8514161,10],[971648.023586481,11],[971648.212893364,9],[971648.366872187,10],[971648.549185009,20],[971648.738080936,14],[971648.919931372,14],[971649.070070604,13],[971649.258673571,5],[971649.445674587,22],[971649.679924843,3],[971649.828375961,59],[971650.014478927,6],[971650.251100043,11],[971650.488231366,3],[971650.674747768,4],[971650.859982163,7],[971651.046975723,9],[971651.196432858,9],[971651.350105861,12],[971651.499725465,20],[971651.652223953,21],[971651.798789996,16],[971651.950136204,13],[971652.099614534,6],[971652.254934842,12],[971652.441475949,6],[971652.628980989,15],[971652.781770151,8],[971652.963983589,18],[971653.115333024,21],[971653.307372443,23],[971653.492672466,8],[971653.661322853,16],[971653.900637518,24],[971654.048566238,11],[971654.239374414,13],[971654.392053801,56],[971654.543704421,2],[971654.728800287,4],[971654.879373929,6],[971655.06822428,11],[971655.246280254,15],[971655.397745055,17],[971655.548426489,14],[971655.74265842,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-8229778d2b4b3239b2e65be687eae2fd","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":1,"prefill_raised":[],"prefill_seconds":0.006656469,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.777365964,"time_to_first_token":0.007318393,"token_sha":"8a91591c94a3","tokens_per_second":18.508617733339612},"seed":1234,"sent":971641.956167131,"speculative":{"acceptance_rate":0.45454545454545453,"accepted":175,"drafted":385,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.009385269018821418,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":385,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.450458192291077,"done":971655.931717108,"finish_reason":"length","first":971642.110660087,"full_response_s":13.973465068032965,"last":971655.931455069,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971642.110660087,3],[971642.266589583,11],[971642.449720715,30],[971642.633881622,19],[971642.818705988,21],[971643.002954874,15],[971643.149358081,19],[971643.305658877,17],[971643.455662015,6],[971643.605112032,8],[971643.788547549,3],[971643.958644379,5],[971644.146988002,27],[971644.336413912,12],[971644.521488351,9],[971644.706558037,9],[971644.877888163,16],[971645.063535762,5],[971645.254701652,14],[971645.440872131,9],[971645.58782435,22],[971645.738136988,10],[971645.919835075,7],[971646.104959755,23],[971646.257756396,5],[971646.408950781,9],[971646.581451426,14],[971646.73355083,20],[971646.880919069,8],[971647.031256431,12],[971647.179223195,5],[971647.336290211,14],[971647.520595147,14],[971647.670741688,8],[971647.85182224,13],[971648.025470792,3],[971648.213277631,10],[971648.364051288,11],[971648.549589005,9],[971648.735517197,10],[971648.921421288,20],[971649.070731855,6],[971649.259291589,8],[971649.445568184,14],[971649.678740617,13],[971649.828076896,5],[971650.013814251,22],[971650.250317332,3],[971650.487658517,43],[971650.674313435,22],[971650.85933144,11],[971651.046529182,6],[971651.196775588,8],[971651.350873643,9],[971651.500688501,13],[971651.649360989,8],[971651.798575077,20],[971651.947990094,17],[971652.099439153,20],[971652.255416968,13],[971652.443074636,6],[971652.629011677,13],[971652.780953487,9],[971652.965053237,11],[971653.114997238,8],[971653.308083056,14],[971653.496101286,12],[971653.662323874,15],[971653.899122402,21],[971654.049705744,8],[971654.240978061,25],[971654.393969632,18],[971654.542649943,13],[971654.728859745,64],[971654.878209191,2],[971655.067623783,10],[971655.24519571,11],[971655.396663599,15],[971655.54675116,17],[971655.742810121,14],[971655.931455069,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-adee7e44b6c3b2d12e959463a1ab14d2","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.048671745,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.821551964,"time_to_first_token":0.149230817,"token_sha":"8a91591c94a3","tokens_per_second":18.44944769329668},"seed":1234,"sent":971641.95825204,"speculative":{"acceptance_rate":0.4396984924623116,"accepted":175,"drafted":398,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.15240804699715227,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":398,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.455043373831536,"done":971655.927476041,"finish_reason":"length","first":971642.110008132,"full_response_s":13.970986613072455,"last":971655.927369318,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971642.110008132,3],[971642.267401591,11],[971642.451614323,30],[971642.634421526,19],[971642.818099122,21],[971643.001275528,15],[971643.150924,19],[971643.306930835,17],[971643.455563388,6],[971643.605784692,8],[971643.789090365,3],[971643.960276123,5],[971644.145278239,29],[971644.336027325,10],[971644.520782634,13],[971644.705570344,5],[971644.87691119,16],[971645.064691284,5],[971645.255234532,16],[971645.440179391,7],[971645.58903301,27],[971645.738361923,11],[971645.920652123,8],[971646.103296618,16],[971646.258992368,5],[971646.40781406,9],[971646.584991338,14],[971646.731630198,20],[971646.879860045,8],[971647.029299573,12],[971647.17912612,5],[971647.337909011,14],[971647.521859473,14],[971647.667505113,8],[971647.853336412,13],[971648.02608009,3],[971648.212268146,10],[971648.367351465,11],[971648.549684736,9],[971648.737815216,10],[971648.921583517,20],[971649.069643871,6],[971649.259905735,8],[971649.445498582,14],[971649.679806168,13],[971649.828919289,5],[971650.014202087,22],[971650.251467366,3],[971650.48687339,43],[971650.675598545,22],[971650.860555315,11],[971651.046019855,6],[971651.19703326,8],[971651.351558975,9],[971651.49965071,13],[971651.651030046,8],[971651.798096871,20],[971651.950691116,17],[971652.100256585,20],[971652.25594756,13],[971652.443628364,6],[971652.629600591,13],[971652.781496223,9],[971652.96426067,11],[971653.11657186,8],[971653.307477806,15],[971653.495906193,16],[971653.663416098,27],[971653.901336242,4],[971654.047688773,8],[971654.240182534,25],[971654.39328374,18],[971654.543518608,13],[971654.72999813,64],[971654.879723251,2],[971655.067209531,10],[971655.245465414,11],[971655.398046583,15],[971655.547528687,17],[971655.743036751,14],[971655.927369318,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-2ff06cd0dc01dcb629cd93f49e816745","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.048279589,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.817544248,"time_to_first_token":0.151081928,"token_sha":"8a91591c94a3","tokens_per_second":18.454798871869695},"seed":1234,"sent":971641.956489428,"speculative":{"acceptance_rate":0.4060324825986079,"accepted":175,"drafted":431,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1535187039989978,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":431,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.45547950058589,"done":971655.9282452,"finish_reason":"length","first":971642.111167654,"full_response_s":13.971983586903661,"last":971655.928202318,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971642.111167654,3],[971642.266654049,11],[971642.450957616,30],[971642.635685276,19],[971642.819527069,21],[971643.00255219,15],[971643.149959539,19],[971643.305770048,17],[971643.453759782,6],[971643.603778712,8],[971643.787916203,3],[971643.958782223,5],[971644.14571774,29],[971644.335437516,10],[971644.52030534,13],[971644.706869454,5],[971644.87855575,16],[971645.063136903,5],[971645.255807269,16],[971645.439257156,7],[971645.589154693,22],[971645.736482203,16],[971645.919956918,8],[971646.104848648,16],[971646.259306745,5],[971646.407112039,9],[971646.582288059,14],[971646.732711094,20],[971646.879549908,8],[971647.030870483,12],[971647.180101829,5],[971647.334992765,14],[971647.519490171,14],[971647.669093528,8],[971647.852404641,13],[971648.024849254,3],[971648.212979831,10],[971648.363900691,11],[971648.548277414,9],[971648.737338931,10],[971648.920716451,20],[971649.071341457,6],[971649.259504091,8],[971649.444572843,14],[971649.679153029,13],[971649.828230997,5],[971650.012884944,22],[971650.250545179,3],[971650.487201032,43],[971650.675692564,22],[971650.861396876,11],[971651.04495096,6],[971651.196621584,8],[971651.349246443,9],[971651.499590645,13],[971651.651539117,8],[971651.797922114,20],[971651.951544597,17],[971652.09928718,20],[971652.256256849,13],[971652.441659027,6],[971652.629358328,13],[971652.781408172,9],[971652.965653958,11],[971653.115731851,8],[971653.309334868,15],[971653.49531824,16],[971653.662031737,27],[971653.898840378,4],[971654.048219364,8],[971654.239602709,25],[971654.392758141,18],[971654.542433392,13],[971654.729782107,64],[971654.879013663,2],[971655.068987358,10],[971655.247115382,11],[971655.398573095,15],[971655.54861011,17],[971655.743258918,14],[971655.928202318,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-6f4ec01bdd55649c6e6fcbdf206ed08b","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.048356231,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.817513623,"time_to_first_token":0.151134442,"token_sha":"8a91591c94a3","tokens_per_second":18.454839774902677},"seed":1234,"sent":971641.956261613,"speculative":{"acceptance_rate":0.4098360655737705,"accepted":175,"drafted":427,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.15490604098886251,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":427,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.453508130737887,"done":971655.928472182,"finish_reason":"length","first":971642.109945602,"full_response_s":13.971549045061693,"last":971655.928456326,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971642.109945602,3],[971642.267626717,11],[971642.450875693,30],[971642.634708991,19],[971642.820985512,21],[971643.002086112,15],[971643.149262414,19],[971643.305528377,17],[971643.453980237,6],[971643.604287927,8],[971643.788484908,3],[971643.960812107,5],[971644.146055494,27],[971644.334744631,12],[971644.520094406,13],[971644.706926032,5],[971644.878284286,16],[971645.063297659,5],[971645.253229689,14],[971645.440353012,9],[971645.587919761,22],[971645.73657819,16],[971645.922454192,8],[971646.103965038,16],[971646.25960365,5],[971646.406339761,9],[971646.584322327,14],[971646.732203495,20],[971646.880969966,8],[971647.029973017,12],[971647.179072071,5],[971647.334720277,14],[971647.519212883,14],[971647.667431303,8],[971647.852070535,13],[971648.023129155,3],[971648.211783075,10],[971648.364720764,11],[971648.548583327,9],[971648.734460206,10],[971648.921635998,20],[971649.072054054,6],[971649.259091951,8],[971649.445877489,14],[971649.678603445,13],[971649.827920604,5],[971650.013172425,22],[971650.250751345,3],[971650.486987794,43],[971650.674010643,22],[971650.859858863,11],[971651.045865194,6],[971651.195990093,8],[971651.351384442,9],[971651.501306407,13],[971651.64999832,8],[971651.797988692,20],[971651.95055164,17],[971652.100588674,20],[971652.254656626,13],[971652.442512012,6],[971652.629805637,13],[971652.78125116,9],[971652.964972642,11],[971653.116322412,8],[971653.306772186,15],[971653.495786525,16],[971653.66114592,27],[971653.900533819,4],[971654.048286982,8],[971654.239213177,25],[971654.392643674,18],[971654.543145253,13],[971654.727834195,64],[971654.878301962,2],[971655.066930451,10],[971655.246770524,11],[971655.395830743,15],[971655.547985612,17],[971655.743516285,14],[971655.928456326,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-2c636d07b0c0fe4210768bad4d2e4642","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.048391656,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.817501399,"time_to_first_token":0.151009174,"token_sha":"8a91591c94a3","tokens_per_second":18.45485610144066},"seed":1234,"sent":971641.956923137,"speculative":{"acceptance_rate":0.42168674698795183,"accepted":175,"drafted":415,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.153022465063259,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":415,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.453430483060746,"done":971655.929403953,"finish_reason":"length","first":971642.110440817,"full_response_s":13.972354587982409,"last":971655.929009686,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971642.110440817,3],[971642.268032905,11],[971642.450723289,30],[971642.634920037,19],[971642.820494297,21],[971643.002398522,15],[971643.149154059,19],[971643.304711569,17],[971643.45524445,6],[971643.606268274,8],[971643.787500174,3],[971643.961047058,5],[971644.144867731,27],[971644.334379036,12],[971644.521795848,13],[971644.705350353,5],[971644.879800683,16],[971645.065835686,5],[971645.253645157,14],[971645.43907491,9],[971645.587465732,22],[971645.735828088,10],[971645.919714927,7],[971646.105395768,23],[971646.259844489,5],[971646.40911325,9],[971646.583875705,14],[971646.732648948,20],[971646.880421758,8],[971647.030828802,12],[971647.180454751,5],[971647.337660923,14],[971647.52346368,14],[971647.667901556,8],[971647.852997922,13],[971648.026225278,3],[971648.212827458,10],[971648.366453934,11],[971648.550212767,9],[971648.738636921,10],[971648.919376396,20],[971649.07108809,6],[971649.258170724,8],[971649.444690846,14],[971649.67941118,13],[971649.82684934,5],[971650.014646996,22],[971650.251766031,3],[971650.486729514,43],[971650.674568211,22],[971650.862927737,11],[971651.046287255,6],[971651.197348037,8],[971651.350376588,9],[971651.500225559,13],[971651.650741205,8],[971651.799827738,20],[971651.949462969,17],[971652.100813081,20],[971652.256116877,13],[971652.442609022,6],[971652.629256661,13],[971652.77817107,9],[971652.96557066,11],[971653.114782736,8],[971653.309376134,14],[971653.493604318,12],[971653.66184042,16],[971653.899986667,20],[971654.049749697,8],[971654.239876189,25],[971654.393607942,18],[971654.542697432,13],[971654.728617162,64],[971654.87906384,2],[971655.067332862,10],[971655.246997123,11],[971655.397208335,15],[971655.548740466,17],[971655.743570063,14],[971655.929009686,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-8f7dc36481684401d61f5a7a08f83e5e","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":2,"prefill_raised":[],"prefill_seconds":0.048488187,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.817611242,"time_to_first_token":0.150769663,"token_sha":"8a91591c94a3","tokens_per_second":18.4547093946964},"seed":1234,"sent":971641.957049365,"speculative":{"acceptance_rate":0.42475728155339804,"accepted":175,"drafted":412,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.15339145192410797,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":412,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":1,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.508278526375403,"done":971655.743459739,"finish_reason":"length","first":971641.965222279,"full_response_s":13.787573112989776,"last":971655.742840745,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971641.965222279,3],[971642.061365668,26],[971642.266371448,15],[971642.451461183,19],[971642.633702737,21],[971642.819953785,15],[971643.001841753,19],[971643.148578394,17],[971643.304456569,6],[971643.454323927,11],[971643.60432412,5],[971643.787343114,18],[971643.958388675,21],[971644.143542524,9],[971644.335602656,9],[971644.51957431,16],[971644.706188682,5],[971644.876671343,10],[971645.062632424,13],[971645.253570739,27],[971645.437969006,11],[971645.587689418,8],[971645.735693044,16],[971645.919528202,9],[971646.10314623,13],[971646.257570134,15],[971646.406879312,17],[971646.580855345,6],[971646.734817828,8],[971646.878479477,5],[971647.029107216,14],[971647.179590502,11],[971647.335916568,7],[971647.522875086,17],[971647.669597094,3],[971647.850988071,10],[971648.024885959,11],[971648.211978345,9],[971648.36358953,10],[971648.548454795,20],[971648.734305225,14],[971648.920425451,14],[971649.07142666,13],[971649.259663344,5],[971649.444449127,22],[971649.678385246,3],[971649.829170784,59],[971650.013762746,6],[971650.251187518,11],[971650.486474115,3],[971650.676108192,4],[971650.861741302,7],[971651.044679624,9],[971651.196840262,9],[971651.349975937,12],[971651.499480017,20],[971651.649031203,21],[971651.799264681,16],[971651.947571025,13],[971652.099733961,6],[971652.254548991,12],[971652.441370106,6],[971652.629662784,15],[971652.778062395,8],[971652.963238064,18],[971653.115661145,21],[971653.306608997,23],[971653.492061825,8],[971653.660456171,16],[971653.898659924,24],[971654.047594242,11],[971654.239449632,13],[971654.391868579,56],[971654.542226394,2],[971654.7276083,4],[971654.878787528,6],[971655.067439905,11],[971655.246845918,15],[971655.397022954,17],[971655.546826874,14],[971655.742840745,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-2ea71e5f59a66f3e969763041ebb5896","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":1,"prefill_raised":[],"prefill_seconds":0.00661458,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.777430158,"time_to_first_token":0.007164692,"token_sha":"8a91591c94a3","tokens_per_second":18.508531495035868},"seed":1234,"sent":971641.955886626,"speculative":{"acceptance_rate":0.45454545454545453,"accepted":175,"drafted":385,"rounds":80,"tokens_per_round":3.2},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.0093356529250741,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":175,"drafted":385,"rounds":80},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.848444453832943,"done":971669.632637807,"finish_reason":"length","first":971656.103644401,"full_response_s":13.67462254408747,"last":971669.632612302,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971656.103644401,3],[971656.260278241,11],[971656.443619961,30],[971656.631072472,19],[971656.813197164,21],[971657.000223046,15],[971657.143888489,19],[971657.300774378,17],[971657.485128104,12],[971657.666711749,5],[971657.815075535,5],[971657.999506967,27],[971658.183308588,12],[971658.374315251,13],[971658.560108994,5],[971658.707383223,16],[971658.890404931,5],[971659.076613239,14],[971659.264920039,9],[971659.414245745,22],[971659.55977515,10],[971659.742866903,7],[971659.92663,23],[971660.076352079,5],[971660.226752706,9],[971660.418021424,14],[971660.564772234,20],[971660.718737508,8],[971660.863961487,12],[971661.014383341,5],[971661.163285711,14],[971661.356429851,14],[971661.502295941,8],[971661.687121474,13],[971661.859330993,3],[971662.042211246,10],[971662.193530768,11],[971662.381189718,9],[971662.567724909,10],[971662.753208869,20],[971662.901863141,14],[971663.089107193,14],[971663.327624189,13],[971663.512610751,5],[971663.695394658,22],[971663.928677723,3],[971664.164590618,32],[971664.359472385,33],[971664.547454226,11],[971664.730839614,6],[971664.877975769,8],[971665.027750811,9],[971665.176524241,13],[971665.335340167,8],[971665.482840616,20],[971665.637026985,17],[971665.818753502,20],[971665.967919673,13],[971666.143988358,6],[971666.338148888,13],[971666.484466658,9],[971666.636511023,11],[971666.790976242,8],[971666.971546473,15],[971667.156796197,16],[971667.376391926,27],[971667.61585195,4],[971667.762957992,8],[971667.948579993,25],[971668.102055331,18],[971668.252812096,13],[971668.440355045,55],[971668.590338428,11],[971668.781669406,10],[971668.964178829,11],[971669.114481175,15],[971669.268898742,17],[971669.424181773,14],[971669.632612302,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-7d38c24136c2bc70da61cbff99706e28","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050423223,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.529867735,"time_to_first_token":0.142233678,"token_sha":"8a91591c94a3","tokens_per_second":18.84719089606089},"seed":1234,"sent":971655.958015263,"speculative":{"acceptance_rate":0.4254807692307692,"accepted":177,"drafted":416,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14562913798727095,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":416,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.846317240263158,"done":971669.633952468,"finish_reason":"length","first":971656.103439723,"full_response_s":13.675226272083819,"last":971669.63393466,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971656.103439723,3],[971656.261050824,11],[971656.443915553,30],[971656.631410385,19],[971656.815447133,21],[971656.997569945,15],[971657.14461011,19],[971657.298842978,17],[971657.485697976,12],[971657.66924595,5],[971657.81890435,5],[971658.001637204,27],[971658.182963635,12],[971658.375441171,13],[971658.557749278,5],[971658.709604151,16],[971658.890974371,5],[971659.075871153,14],[971659.266073768,9],[971659.412537584,22],[971659.560622694,10],[971659.742927065,7],[971659.926061199,23],[971660.075484582,5],[971660.227512072,9],[971660.414843557,14],[971660.564183145,20],[971660.716816541,8],[971660.86349613,12],[971661.012260608,5],[971661.162299506,14],[971661.354986417,14],[971661.503018842,8],[971661.687449243,13],[971661.861237608,3],[971662.041483369,10],[971662.191222301,11],[971662.381996637,9],[971662.56915743,10],[971662.753951402,20],[971662.901431225,14],[971663.090317003,14],[971663.327098733,13],[971663.514074153,5],[971663.69583755,22],[971663.927669214,3],[971664.165429186,32],[971664.360097123,33],[971664.544835622,11],[971664.730475588,6],[971664.878048171,8],[971665.027552581,9],[971665.176339532,13],[971665.333774586,8],[971665.48320189,20],[971665.632186606,17],[971665.819694233,20],[971665.968529739,13],[971666.142117233,6],[971666.335891528,13],[971666.484760522,9],[971666.635598741,11],[971666.786313741,8],[971666.971435974,15],[971667.155903563,16],[971667.375198244,27],[971667.614779199,4],[971667.762737698,8],[971667.947084671,25],[971668.0992881,18],[971668.253241612,13],[971668.440557771,55],[971668.592140367,11],[971668.780593103,10],[971668.963541531,11],[971669.113358567,15],[971669.268551676,17],[971669.42195739,14],[971669.63393466,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-0cd9ec3a73f7a83d7e2ba0240df340c8","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050520122,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.529593679,"time_to_first_token":0.14117712,"token_sha":"8a91591c94a3","tokens_per_second":18.847572665526464},"seed":1234,"sent":971655.958726196,"speculative":{"acceptance_rate":0.4254807692307692,"accepted":177,"drafted":416,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14471352705731988,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":416,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.846950379934103,"done":971669.633587226,"finish_reason":"length","first":971656.102741686,"full_response_s":13.674705217010342,"last":971669.632782083,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971656.102741686,3],[971656.260009673,11],[971656.443510918,30],[971656.629448712,19],[971656.815914234,21],[971656.998474116,15],[971657.144023421,19],[971657.299772717,17],[971657.486727046,12],[971657.667250372,5],[971657.815927175,5],[971657.99789972,27],[971658.182659082,12],[971658.375119738,13],[971658.558763355,5],[971658.708874114,16],[971658.891114599,5],[971659.076145833,14],[971659.26468656,9],[971659.411559332,22],[971659.560548468,10],[971659.74433901,7],[971659.927967462,23],[971660.075294065,5],[971660.227867794,9],[971660.417438111,14],[971660.565818152,20],[971660.717214744,8],[971660.865687425,12],[971661.012525943,5],[971661.164767785,14],[971661.356881368,14],[971661.503529001,8],[971661.687953178,13],[971661.860573445,3],[971662.042503431,10],[971662.191802142,11],[971662.381761479,9],[971662.568012613,10],[971662.753625137,20],[971662.901987305,14],[971663.086817095,14],[971663.32614653,13],[971663.510930815,5],[971663.696547315,22],[971663.930412316,3],[971664.165669241,32],[971664.35937091,33],[971664.54552585,11],[971664.733121824,6],[971664.876447421,8],[971665.0262336,9],[971665.176429454,13],[971665.334667267,8],[971665.48305731,20],[971665.63670224,17],[971665.818952628,20],[971665.967181108,13],[971666.144092985,6],[971666.335523437,13],[971666.484803596,9],[971666.636240344,11],[971666.787209014,8],[971666.971135965,15],[971667.156360504,16],[971667.37703204,27],[971667.614446774,4],[971667.764769484,8],[971667.949648808,25],[971668.102317099,18],[971668.252741454,13],[971668.441176381,55],[971668.592763169,11],[971668.778318782,10],[971668.963369638,11],[971669.116286922,15],[971669.269034281,17],[971669.421345916,14],[971669.632782083,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-a6f3d22b72bbe54f840539c9031fade3","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050349845,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.530021084,"time_to_first_token":0.14233741,"token_sha":"8a91591c94a3","tokens_per_second":18.846977282360015},"seed":1234,"sent":971655.958882009,"speculative":{"acceptance_rate":0.4254807692307692,"accepted":177,"drafted":416,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14385967701673508,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":416,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.847552025837246,"done":971669.636352265,"finish_reason":"length","first":971656.103886136,"full_response_s":13.67811195505783,"last":971669.633494631,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971656.103886136,3],[971656.260698974,11],[971656.444770202,30],[971656.630869922,19],[971656.81630111,21],[971656.998821598,15],[971657.143564751,19],[971657.300709576,17],[971657.484641273,12],[971657.666357562,5],[971657.81240533,5],[971658.001017122,18],[971658.184701445,21],[971658.374242753,9],[971658.557537832,9],[971658.706233366,16],[971658.89008473,5],[971659.075341618,14],[971659.264755682,9],[971659.411462993,22],[971659.56215357,10],[971659.74281687,7],[971659.92926454,23],[971660.076432993,5],[971660.228723531,9],[971660.41855168,14],[971660.564931871,20],[971660.719187569,8],[971660.864919291,12],[971661.013552517,5],[971661.162776592,14],[971661.355176807,14],[971661.502529372,8],[971661.687352025,13],[971661.862562222,3],[971662.042079147,10],[971662.192054229,11],[971662.381917179,9],[971662.568251196,10],[971662.755502807,20],[971662.900483806,14],[971663.089285086,14],[971663.32556885,13],[971663.513391829,5],[971663.695247998,22],[971663.927417623,3],[971664.164121869,32],[971664.358063241,33],[971664.545150176,11],[971664.731444592,6],[971664.877121136,8],[971665.02582554,9],[971665.176908364,13],[971665.333252411,8],[971665.483360007,20],[971665.636532395,17],[971665.82097547,20],[971665.968166544,13],[971666.143182463,6],[971666.33834099,13],[971666.484707289,9],[971666.636902058,11],[971666.790533573,8],[971666.971278065,15],[971667.157011243,16],[971667.377297824,27],[971667.615997202,4],[971667.765818682,8],[971667.94733167,25],[971668.100928771,18],[971668.253415249,13],[971668.43931388,55],[971668.591486845,11],[971668.778881646,10],[971668.965223979,11],[971669.115412721,15],[971669.268809107,17],[971669.421500945,14],[971669.633494631,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-36940ef0d99f3f8c790840284f76405f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050710239,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.530114079,"time_to_first_token":0.140776245,"token_sha":"8a91591c94a3","tokens_per_second":18.846847743566613},"seed":1234,"sent":971655.95824031,"speculative":{"acceptance_rate":0.42961165048543687,"accepted":177,"drafted":412,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14564582600723952,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":412,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.845975012334296,"done":971669.633354819,"finish_reason":"length","first":971656.102577522,"full_response_s":13.675241233082488,"last":971669.633318162,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971656.102577522,3],[971656.260820033,11],[971656.443705515,30],[971656.630177006,19],[971656.815176069,21],[971656.999522754,15],[971657.143441388,19],[971657.299063721,17],[971657.486348027,12],[971657.667365751,5],[971657.816032699,5],[971657.998596172,27],[971658.182910289,12],[971658.376586628,13],[971658.559322155,5],[971658.706918217,16],[971658.891444497,5],[971659.07597466,14],[971659.266311903,9],[971659.413328423,22],[971659.561501295,10],[971659.742766068,7],[971659.930489311,23],[971660.077109733,5],[971660.227676941,9],[971660.415403781,14],[971660.564449073,20],[971660.717357868,8],[971660.865628367,12],[971661.015455292,5],[971661.165282536,14],[971661.354081111,14],[971661.506025649,8],[971661.687308807,13],[971661.861601011,3],[971662.043538421,10],[971662.193284793,11],[971662.381032498,9],[971662.567161516,10],[971662.754514794,20],[971662.904217385,14],[971663.087574749,14],[971663.327797282,13],[971663.512934856,5],[971663.695127898,22],[971663.931319686,3],[971664.165540614,32],[971664.358337232,33],[971664.546302081,11],[971664.731930894,6],[971664.877461114,8],[971665.027389905,9],[971665.177233669,13],[971665.333577748,8],[971665.482706164,20],[971665.634975998,17],[971665.821091537,20],[971665.9677377,13],[971666.143355316,6],[971666.335800437,13],[971666.484515411,9],[971666.635515219,11],[971666.786557268,8],[971666.97088359,15],[971667.156739747,16],[971667.376579371,27],[971667.614591866,4],[971667.763156094,8],[971667.949492195,25],[971668.101611735,18],[971668.252566361,13],[971668.441578872,55],[971668.589925664,11],[971668.779814393,10],[971668.96495298,11],[971669.115971633,15],[971669.269141341,17],[971669.424618249,14],[971669.633318162,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-9e39526b3100b697b417597e4d504bb3","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.050279906,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.530198625,"time_to_first_token":0.142431877,"token_sha":"8a91591c94a3","tokens_per_second":18.84672997548105},"seed":1234,"sent":971655.958113586,"speculative":{"acceptance_rate":0.423444976076555,"accepted":177,"drafted":418,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14446393609978259,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":418,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.844728445369558,"done":971669.634704618,"finish_reason":"length","first":971656.103031247,"full_response_s":13.676534774014726,"last":971669.634666937,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971656.103031247,3],[971656.258476477,11],[971656.444904126,30],[971656.63039402,19],[971656.814880652,21],[971656.998200156,15],[971657.144645695,19],[971657.300876749,17],[971657.488822467,12],[971657.666955564,5],[971657.81796445,5],[971658.001752824,18],[971658.184205782,21],[971658.37483525,13],[971658.559671061,5],[971658.709195691,16],[971658.891705096,5],[971659.0775012,14],[971659.264532268,9],[971659.411253483,22],[971659.562433738,10],[971659.741970973,7],[971659.92859244,23],[971660.07660111,5],[971660.228797469,9],[971660.417078789,14],[971660.565671956,20],[971660.717479792,8],[971660.865104224,12],[971661.01471439,5],[971661.163878176,14],[971661.355237145,14],[971661.503661293,8],[971661.686497616,13],[971661.859840336,3],[971662.041790674,10],[971662.193077043,11],[971662.381392988,9],[971662.568069718,10],[971662.753454588,20],[971662.901323158,14],[971663.086080434,14],[971663.326739155,13],[971663.512729394,5],[971663.697032769,22],[971663.929427408,3],[971664.166041876,32],[971664.358879504,33],[971664.545240914,11],[971664.731269835,6],[971664.877906119,8],[971665.026852977,9],[971665.175860606,13],[971665.332771837,8],[971665.483512059,20],[971665.636943446,17],[971665.81907548,20],[971665.968981432,13],[971666.142172114,6],[971666.337210477,13],[971666.485095236,9],[971666.636471774,11],[971666.788163169,8],[971666.972510436,15],[971667.15685767,16],[971667.375823237,27],[971667.616388317,4],[971667.765655989,8],[971667.9483837,25],[971668.099856724,18],[971668.253855229,13],[971668.441332737,55],[971668.591065505,11],[971668.780768644,10],[971668.966360268,11],[971669.114660924,15],[971669.269646971,17],[971669.420497588,14],[971669.634666937,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-eaefb188a56acd6bbd61be70b7573cd4","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050633021,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.529419835,"time_to_first_token":0.141540298,"token_sha":"8a91591c94a3","tokens_per_second":18.847814844234968},"seed":1234,"sent":971655.958169844,"speculative":{"acceptance_rate":0.42650602409638555,"accepted":177,"drafted":415,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14486140303779393,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":415,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.8454776275797,"done":971669.633772047,"finish_reason":"length","first":971656.102644468,"full_response_s":13.674965464975685,"last":971669.633742222,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971656.102644468,3],[971656.259705153,11],[971656.443166188,30],[971656.629338005,19],[971656.812581066,21],[971656.996231123,15],[971657.144569757,19],[971657.298915332,17],[971657.483412694,12],[971657.665996432,5],[971657.812284894,5],[971657.997303255,27],[971658.182402514,12],[971658.373875494,13],[971658.558939968,5],[971658.707794691,16],[971658.891378431,5],[971659.075760158,14],[971659.264276308,9],[971659.411904301,22],[971659.55966177,10],[971659.742314711,7],[971659.929659975,23],[971660.0756839,5],[971660.229058725,9],[971660.41446361,14],[971660.566202451,20],[971660.718513005,8],[971660.864546512,12],[971661.015578815,5],[971661.163078921,14],[971661.356796886,14],[971661.50738692,8],[971661.685925199,13],[971661.862172643,3],[971662.041634206,10],[971662.192815947,11],[971662.382284166,9],[971662.566245714,10],[971662.75338081,20],[971662.900953723,14],[971663.088095355,14],[971663.328135355,13],[971663.511152229,5],[971663.696403823,22],[971663.928283407,3],[971664.165790813,32],[971664.359130071,33],[971664.54650471,11],[971664.732397483,6],[971664.876713668,8],[971665.026895651,9],[971665.175700377,13],[971665.332431939,8],[971665.482892713,20],[971665.636274979,17],[971665.820164807,20],[971665.968052557,13],[971666.143433926,6],[971666.336478664,13],[971666.484951168,9],[971666.635757658,11],[971666.788620415,8],[971666.970498139,15],[971667.155960541,16],[971667.376767312,27],[971667.617692819,4],[971667.765141527,8],[971667.947761554,25],[971668.098447196,18],[971668.252453557,13],[971668.439674898,55],[971668.591144915,11],[971668.778094152,10],[971668.965310142,11],[971669.114929604,15],[971669.268295412,17],[971669.422428459,14],[971669.633742222,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-6ea63aa580b12d9a71620358d857e736","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.050165856,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.530070653,"time_to_first_token":0.142884769,"token_sha":"8a91591c94a3","tokens_per_second":18.846908234249263},"seed":1234,"sent":971655.958806582,"speculative":{"acceptance_rate":0.41843971631205673,"accepted":177,"drafted":423,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14383788593113422,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":423,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.848089955900125,"done":971669.632994073,"finish_reason":"length","first":971656.103747012,"full_response_s":13.673550560022704,"last":971669.632969368,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971656.103747012,3],[971656.260214927,11],[971656.444486594,30],[971656.631309198,19],[971656.813069544,21],[971656.996653327,15],[971657.144511483,19],[971657.299558631,17],[971657.486133861,12],[971657.668383045,5],[971657.813792298,5],[971657.99768325,27],[971658.182616168,12],[971658.373680592,13],[971658.560172532,5],[971658.706702771,16],[971658.890169132,5],[971659.075928771,14],[971659.265265649,9],[971659.411807403,22],[971659.55937957,10],[971659.743450424,7],[971659.927383701,23],[971660.07583152,5],[971660.227756495,9],[971660.416532453,14],[971660.565376667,20],[971660.715607738,8],[971660.864384684,12],[971661.012883218,5],[971661.165166021,14],[971661.354718234,14],[971661.502904919,8],[971661.688268531,13],[971661.860798299,3],[971662.042964628,10],[971662.191322672,11],[971662.38297105,9],[971662.56784512,10],[971662.752340908,20],[971662.904682054,14],[971663.086136771,14],[971663.327439831,13],[971663.512484347,5],[971663.699024938,22],[971663.92776176,3],[971664.164204383,32],[971664.358653513,33],[971664.547884462,11],[971664.730074921,6],[971664.876921994,8],[971665.026451686,9],[971665.175889599,13],[971665.332229421,8],[971665.483749826,20],[971665.63316537,17],[971665.821298663,20],[971665.968690799,13],[971666.142243956,6],[971666.336095534,13],[971666.485252024,9],[971666.636137637,11],[971666.789247073,8],[971666.972323247,15],[971667.157276802,16],[971667.377232446,27],[971667.615534581,4],[971667.763539129,8],[971667.949759499,25],[971668.099038477,18],[971668.252861505,13],[971668.441410515,55],[971668.590954909,11],[971668.779276905,10],[971668.963685663,11],[971669.115072744,15],[971669.26897796,17],[971669.42127689,14],[971669.632969368,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-9451e5510eb7688cb67464260c5f7d75","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050595932,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.529607392,"time_to_first_token":0.142030217,"token_sha":"8a91591c94a3","tokens_per_second":18.847553562476648},"seed":1234,"sent":971655.959443513,"speculative":{"acceptance_rate":0.4254807692307692,"accepted":177,"drafted":416,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14430349902249873,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":416,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.84637358233599,"done":971669.634410353,"finish_reason":"length","first":971656.103924041,"full_response_s":13.676092904992402,"last":971669.634378528,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971656.103924041,3],[971656.258866184,11],[971656.445243672,30],[971656.629948823,19],[971656.814215689,21],[971657.000051393,15],[971657.14364069,19],[971657.299370802,17],[971657.487914808,12],[971657.668256753,5],[971657.818109847,5],[971658.000506708,27],[971658.182555671,12],[971658.374443142,13],[971658.558511892,5],[971658.711089058,16],[971658.890798974,5],[971659.076222171,14],[971659.265560825,9],[971659.41234337,22],[971659.56111706,10],[971659.743354085,7],[971659.928257871,23],[971660.078432875,5],[971660.229223337,9],[971660.41571627,14],[971660.565166069,20],[971660.716281933,8],[971660.865432106,12],[971661.014116165,5],[971661.163502501,14],[971661.356073713,14],[971661.506846232,8],[971661.688021388,13],[971661.860622182,3],[971662.04331187,10],[971662.191733772,11],[971662.382558622,9],[971662.566882196,10],[971662.754607805,20],[971662.901758418,14],[971663.089903695,14],[971663.325356555,13],[971663.511913867,5],[971663.69862011,22],[971663.926966842,3],[971664.164315522,32],[971664.360361114,33],[971664.54865778,11],[971664.730953874,6],[971664.877593182,8],[971665.027719546,9],[971665.17738385,13],[971665.332321504,8],[971665.482784294,20],[971665.63356063,17],[971665.821238245,20],[971665.96921491,13],[971666.142938488,6],[971666.335295079,13],[971666.484605558,9],[971666.636208183,11],[971666.787948507,8],[971666.972374465,15],[971667.15578668,16],[971667.377487957,27],[971667.615093272,4],[971667.76590326,8],[971667.947876549,25],[971668.101225932,18],[971668.252360163,13],[971668.440454184,55],[971668.592607676,11],[971668.779378716,10],[971668.965477138,11],[971669.113763906,15],[971669.269354179,17],[971669.422019119,14],[971669.634378528,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-8fc1507dd9dceb3a16ad2943ad79f659","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.050205825,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.530257731,"time_to_first_token":0.142525351,"token_sha":"8a91591c94a3","tokens_per_second":18.84664764483783},"seed":1234,"sent":971655.958317448,"speculative":{"acceptance_rate":0.4194312796208531,"accepted":177,"drafted":422,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14560659299604595,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":422,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.847408348193404,"done":971669.633408021,"finish_reason":"length","first":971656.103682546,"full_response_s":13.674183522933163,"last":971669.63339418,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971656.103682546,3],[971656.259931079,11],[971656.443861472,30],[971656.630978549,19],[971656.813324303,21],[971656.996690016,15],[971657.143705412,19],[971657.300281148,17],[971657.483729775,12],[971657.668656093,5],[971657.813360429,5],[971657.997751316,18],[971658.183363182,21],[971658.376885469,9],[971658.557997733,9],[971658.708473815,16],[971658.889927445,5],[971659.076874782,14],[971659.265630619,9],[971659.412622386,22],[971659.560257964,10],[971659.742982203,7],[971659.925816984,23],[971660.076657544,5],[971660.228224861,9],[971660.415060459,14],[971660.565986253,20],[971660.718105506,8],[971660.863620518,12],[971661.015955002,5],[971661.162522361,14],[971661.35542731,14],[971661.505458944,8],[971661.686390525,13],[971661.860667752,3],[971662.04213134,10],[971662.19360837,11],[971662.381843641,9],[971662.56706841,10],[971662.752857243,20],[971662.900770038,14],[971663.088804672,14],[971663.327853491,13],[971663.514145371,5],[971663.695341072,22],[971663.928867232,3],[971664.165019655,32],[971664.358786205,33],[971664.546177085,11],[971664.730552166,6],[971664.877518075,8],[971665.026024634,9],[971665.177295831,13],[971665.333852156,8],[971665.483273428,20],[971665.636122383,17],[971665.818462422,20],[971665.968625326,13],[971666.143119501,6],[971666.335993083,13],[971666.485039826,9],[971666.635863117,11],[971666.790037047,8],[971666.971067515,15],[971667.157552234,16],[971667.377854559,27],[971667.614844241,4],[971667.765039476,8],[971667.948926003,25],[971668.101152073,18],[971668.253965969,13],[971668.439419899,55],[971668.592669022,11],[971668.779776584,10],[971668.96399772,11],[971669.115691673,15],[971669.268720145,17],[971669.422097378,14],[971669.63339418,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-3422a98744b8f5c585a34c6e24a1e889","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.05067267,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.529651681,"time_to_first_token":0.140887416,"token_sha":"8a91591c94a3","tokens_per_second":18.847491865448564},"seed":1234,"sent":971655.959224498,"speculative":{"acceptance_rate":0.42961165048543687,"accepted":177,"drafted":412,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1444580479292199,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":412,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.847719889868845,"done":971669.633544761,"finish_reason":"length","first":971656.104040652,"full_response_s":13.674580525956117,"last":971669.633528648,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971656.104040652,3],[971656.260514248,11],[971656.444294892,30],[971656.629542475,19],[971656.812949764,21],[971656.996601997,15],[971657.14495044,19],[971657.299692187,17],[971657.483835426,12],[971657.666445773,5],[971657.814174373,5],[971657.999832416,27],[971658.183958719,12],[971658.376489618,13],[971658.560371338,5],[971658.70812086,16],[971658.890339041,5],[971659.075525863,14],[971659.265188399,9],[971659.410979219,22],[971659.558712447,10],[971659.743654814,7],[971659.926413113,23],[971660.075912114,5],[971660.22730461,9],[971660.41510958,14],[971660.565892154,20],[971660.719267779,8],[971660.864974317,12],[971661.013755291,5],[971661.164239034,14],[971661.354489715,14],[971661.505746249,8],[971661.687641185,13],[971661.860510835,3],[971662.042266576,10],[971662.190941813,11],[971662.383038203,9],[971662.569092868,10],[971662.754139423,20],[971662.901806436,14],[971663.085989407,14],[971663.327023099,13],[971663.51243057,5],[971663.696627701,22],[971663.926769028,3],[971664.164508696,32],[971664.361163473,33],[971664.544605344,11],[971664.73201512,6],[971664.878325315,8],[971665.026715053,9],[971665.175802252,13],[971665.334430141,8],[971665.483921063,20],[971665.632330738,17],[971665.82068695,20],[971665.967820471,13],[971666.142308534,6],[971666.337788126,13],[971666.485196887,9],[971666.635971488,11],[971666.788256516,8],[971666.972046551,15],[971667.157856547,16],[971667.378142104,27],[971667.616792217,4],[971667.763810881,8],[971667.947244851,25],[971668.099337366,18],[971668.252637259,13],[971668.440959479,55],[971668.592031724,11],[971668.7790849,10],[971668.965822268,11],[971669.11410062,15],[971669.268689312,17],[971669.422697347,14],[971669.633528648,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-b4ef6d1df2659d35e6fbbf3526c6c468","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050387046,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.530387958,"time_to_first_token":0.142661931,"token_sha":"8a91591c94a3","tokens_per_second":18.846466250010835},"seed":1234,"sent":971655.958964235,"speculative":{"acceptance_rate":0.4254807692307692,"accepted":177,"drafted":416,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14507641701493412,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":416,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.847558778095113,"done":971669.632748242,"finish_reason":"length","first":971656.103108097,"full_response_s":13.67323666298762,"last":971669.632711745,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971656.103108097,3],[971656.259630238,11],[971656.443035112,30],[971656.629675823,19],[971656.815647811,21],[971656.997877922,15],[971657.14510814,19],[971657.300392191,17],[971657.486876378,12],[971657.668734799,5],[971657.817214269,5],[971657.998742049,27],[971658.182353025,12],[971658.375684522,13],[971658.56065149,5],[971658.710021763,16],[971658.892019458,5],[971659.078077889,14],[971659.266192668,9],[971659.413037582,22],[971659.561898251,10],[971659.743413799,7],[971659.926520652,23],[971660.077212632,5],[971660.228138362,9],[971660.416305487,14],[971660.565782311,20],[971660.714814243,8],[971660.86377881,12],[971661.012774287,5],[971661.165090579,14],[971661.355067268,14],[971661.504789437,8],[971661.686064275,13],[971661.861856602,3],[971662.042682908,10],[971662.19193933,11],[971662.382741363,9],[971662.568691048,10],[971662.754455001,20],[971662.902925956,14],[971663.087741665,14],[971663.327214385,13],[971663.511703445,5],[971663.695898464,22],[971663.931491819,3],[971664.165283806,32],[971664.359329069,33],[971664.545920454,11],[971664.729923236,6],[971664.876991404,8],[971665.027614743,9],[971665.177340232,13],[971665.334912922,8],[971665.484112156,20],[971665.634374365,17],[971665.81985299,20],[971665.968446857,13],[971666.142052015,6],[971666.335742819,13],[971666.484566245,9],[971666.63570348,11],[971666.78713922,8],[971666.970389608,15],[971667.157797985,16],[971667.37766057,27],[971667.615721018,4],[971667.763949477,8],[971667.949316334,25],[971668.100214479,18],[971668.252697036,13],[971668.439492733,55],[971668.592100142,11],[971668.781280898,10],[971668.964527351,11],[971669.114019674,15],[971669.268384663,17],[971669.42169327,14],[971669.632711745,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-eed57369f6a9eae1c5ba5d091b37417f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.05046012,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.529640849,"time_to_first_token":0.141813843,"token_sha":"8a91591c94a3","tokens_per_second":18.847506954986727},"seed":1234,"sent":971655.959511579,"speculative":{"acceptance_rate":0.4254807692307692,"accepted":177,"drafted":416,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14359651796985418,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":416,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.84839101940855,"done":971669.632452218,"finish_reason":"length","first":971656.103386681,"full_response_s":13.673854426015168,"last":971669.632392936,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971656.103386681,3],[971656.258566928,11],[971656.4441598,30],[971656.629032332,19],[971656.813913808,21],[971656.997195023,15],[971657.144698576,19],[971657.301036354,17],[971657.48915854,12],[971657.667512444,5],[971657.814263799,5],[971658.001068484,27],[971658.182765933,12],[971658.375382114,13],[971658.559541954,5],[971658.708914563,16],[971658.892264761,5],[971659.076339087,14],[971659.265799392,9],[971659.412663107,22],[971659.558632589,10],[971659.743954807,7],[971659.926815013,23],[971660.077314747,5],[971660.227418885,9],[971660.414137728,14],[971660.565726262,20],[971660.715693628,8],[971660.863301132,12],[971661.012968916,5],[971661.165615282,14],[971661.35612101,14],[971661.504504053,8],[971661.686711974,13],[971661.859455621,3],[971662.042328226,10],[971662.192189705,11],[971662.381959404,9],[971662.566774641,10],[971662.75507369,20],[971662.902557465,14],[971663.088422981,14],[971663.325802728,13],[971663.512260917,5],[971663.698000061,22],[971663.929507762,3],[971664.164795328,32],[971664.359916046,33],[971664.544044464,11],[971664.73168103,6],[971664.876625042,8],[971665.026369556,9],[971665.175760635,13],[971665.332659594,8],[971665.482971452,20],[971665.635389466,17],[971665.818639291,20],[971665.969408036,13],[971666.143259857,6],[971666.336904709,13],[971666.484927119,9],[971666.636794103,11],[971666.78853886,8],[971666.971503352,15],[971667.156042831,16],[971667.375986234,27],[971667.615365712,4],[971667.766078833,8],[971667.947943751,25],[971668.100409988,18],[971668.253128713,13],[971668.440817939,55],[971668.592280611,11],[971668.782072873,10],[971668.964445829,11],[971669.114375076,15],[971669.269417508,17],[971669.420694858,14],[971669.632392936,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-1c2469c52c8ebbf9902eed810cc11b03","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.050558939,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.529572959,"time_to_first_token":0.142215439,"token_sha":"8a91591c94a3","tokens_per_second":18.84760152983037},"seed":1234,"sent":971655.958597792,"speculative":{"acceptance_rate":0.4254807692307692,"accepted":177,"drafted":416,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14478888898156583,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":416,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.845803211407997,"done":971669.633705741,"finish_reason":"length","first":971656.102819001,"full_response_s":13.675162589992397,"last":971669.633682989,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971656.102819001,3],[971656.259175073,11],[971656.444223994,30],[971656.629142288,19],[971656.814986303,21],[971656.999660502,15],[971657.144078846,19],[971657.298717871,17],[971657.485789755,12],[971657.670365966,5],[971657.816570698,5],[971658.001903196,27],[971658.182826703,12],[971658.374139518,13],[971658.559008674,5],[971658.706111378,16],[971658.889545882,5],[971659.075197838,14],[971659.26508622,9],[971659.414424342,22],[971659.5599949,10],[971659.741848122,7],[971659.930070211,23],[971660.076533108,5],[971660.227822241,9],[971660.414609246,14],[971660.563697595,20],[971660.715285152,8],[971660.863111159,12],[971661.012113532,5],[971661.165710261,14],[971661.356156691,14],[971661.504052728,8],[971661.686244889,13],[971661.860048678,3],[971662.041993304,10],[971662.191140219,11],[971662.382052943,9],[971662.566445816,10],[971662.752915452,20],[971662.901206675,14],[971663.089369296,14],[971663.326452555,13],[971663.513180159,5],[971663.697501934,22],[971663.927553098,3],[971664.166136295,32],[971664.359860492,33],[971664.546766958,11],[971664.73074358,6],[971664.877823508,8],[971665.027234124,9],[971665.175527428,13],[971665.335121232,8],[971665.483486554,20],[971665.634483248,17],[971665.817672559,20],[971665.966978318,13],[971666.142600302,6],[971666.335157731,13],[971666.484857277,9],[971666.636174758,11],[971666.787681828,8],[971666.971774255,15],[971667.156439403,16],[971667.3754947,27],[971667.614178926,4],[971667.764388721,8],[971667.947822628,25],[971668.100839425,18],[971668.253537476,13],[971668.440224962,55],[971668.591922169,11],[971668.777868161,10],[971668.96461033,11],[971669.112724405,15],[971669.269080731,17],[971669.421599987,14],[971669.633682989,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-521f7e0c6a812c9a55c94445d63a694e","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.050242529,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.529974651,"time_to_first_token":0.142293697,"token_sha":"8a91591c94a3","tokens_per_second":18.84704196257699},"seed":1234,"sent":971655.958543151,"speculative":{"acceptance_rate":0.42042755344418054,"accepted":177,"drafted":421,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14427584991790354,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":421,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.654281017443235,"done":971669.633227392,"finish_reason":"length","first":971655.9634207,"full_response_s":13.674173682928085,"last":971669.633205119,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971655.9634207,3],[971656.052761516,26],[971656.258968075,15],[971656.44378795,19],[971656.629377126,21],[971656.816754195,15],[971656.996905286,19],[971657.143939082,17],[971657.298982054,6],[971657.487278854,11],[971657.670782346,5],[971657.813928654,18],[971658.002160916,21],[971658.182480069,5],[971658.374891395,8],[971658.558196203,5],[971658.708740942,16],[971658.892483871,5],[971659.074972935,14],[971659.2644122,9],[971659.413630351,22],[971659.558418646,10],[971659.741744727,7],[971659.925451438,23],[971660.075082298,5],[971660.226843205,9],[971660.414322006,14],[971660.565290201,20],[971660.714454664,8],[971660.863903246,12],[971661.012649771,5],[971661.162395861,14],[971661.353624778,14],[971661.502040462,8],[971661.685671976,13],[971661.859109547,3],[971662.043377024,10],[971662.190846706,11],[971662.380832668,9],[971662.56603118,10],[971662.751916719,20],[971662.901406728,14],[971663.086989788,14],[971663.325178998,13],[971663.510757802,5],[971663.694952661,22],[971663.926604431,3],[971664.164743903,32],[971664.360695812,33],[971664.543869483,11],[971664.729692382,6],[971664.876354762,8],[971665.026939812,9],[971665.175604807,13],[971665.335927959,8],[971665.483564509,20],[971665.635715395,17],[971665.819938176,20],[971665.968310197,13],[971666.143674765,6],[971666.334949693,13],[971666.485144917,9],[971666.635664423,11],[971666.787490926,8],[971666.970087503,15],[971667.156932361,16],[971667.376825378,27],[971667.614955268,4],[971667.762555213,8],[971667.948444069,25],[971668.100344386,18],[971668.252521735,13],[971668.439143763,55],[971668.589763499,11],[971668.779460255,10],[971668.963208466,11],[971669.112613442,15],[971669.268445785,17],[971669.420620407,14],[971669.633205119,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-1c8c3a29fd88564bb602126865e0b5e7","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.003416483,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.668272648,"time_to_first_token":0.003770062,"token_sha":"8a91591c94a3","tokens_per_second":18.656344262880406},"seed":1234,"sent":971655.959053709,"speculative":{"acceptance_rate":0.4055299539170507,"accepted":176,"drafted":434,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.004366990993730724,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":434,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"reset_off","prompt":"chat","streams":16,"burst":2,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.845624416445855,"done":971669.633916323,"finish_reason":"length","first":971656.102905419,"full_response_s":13.676020726910792,"last":971669.633897779,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971656.102905419,3],[971656.259056014,11],[971656.445013041,30],[971656.630573529,19],[971656.814569011,21],[971657.000458733,15],[971657.144454025,19],[971657.299277215,17],[971657.488261138,12],[971657.670062982,5],[971657.815444377,5],[971658.000906047,27],[971658.183488258,12],[971658.375884896,13],[971658.558353039,5],[971658.710577843,16],[971658.89230585,5],[971659.075644491,14],[971659.265148062,9],[971659.412779159,22],[971659.562368489,10],[971659.74262712,7],[971659.926682753,23],[971660.078070545,5],[971660.226637567,9],[971660.416041463,14],[971660.566261141,20],[971660.715953412,8],[971660.864130324,12],[971661.013120312,5],[971661.162623228,14],[971661.355738775,14],[971661.505088934,8],[971661.688460648,13],[971661.859947059,3],[971662.043274125,10],[971662.192304652,11],[971662.381660612,9],[971662.568303485,10],[971662.75257349,20],[971662.901931383,14],[971663.089462515,14],[971663.325482495,13],[971663.512132337,5],[971663.695748684,22],[971663.926867703,3],[971664.165713387,32],[971664.359043877,33],[971664.54828961,11],[971664.732701124,6],[971664.877234899,8],[971665.027679145,9],[971665.176465695,13],[971665.333663159,8],[971665.483130208,20],[971665.632799824,17],[971665.817935063,20],[971665.968907078,13],[971666.142835621,6],[971666.338253515,13],[971666.484892126,9],[971666.636546624,11],[971666.786661735,8],[971666.97242925,15],[971667.156896616,16],[971667.376140142,27],[971667.615214588,4],[971667.765387006,8],[971667.949958049,25],[971668.10173001,18],[971668.253456034,13],[971668.440155568,55],[971668.590137862,11],[971668.778664392,10],[971668.963617229,11],[971669.114546505,15],[971669.268752849,17],[971669.423707743,14],[971669.633897779,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-e87d2d4adb0877abc88065940fe03493","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.050318436,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.530079725,"time_to_first_token":0.14260081,"token_sha":"8a91591c94a3","tokens_per_second":18.8468955972837},"seed":1234,"sent":971655.957895596,"speculative":{"acceptance_rate":0.423444976076555,"accepted":177,"drafted":418,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.14500982291065156,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":418,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":1,"burst":null,"stream":0,"phase":"warmup","request":{"cache_state":"cold","cached_tokens":0,"case_id":null,"complete":true,"decode_tps":45.989144038725776,"done":971457.27931083,"finish_reason":"length","first":971456.952863416,"full_response_s":0.5288928570225835,"last":971457.279027347,"output_sha256":"26fc9e1892da6e23aa1a0cb06681c20c4a62f7257e19635806de87234b9035bb","pieces":[[971456.952863416,2],[971457.112615923,7],[971457.196586785,4],[971457.279027347,73]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":16,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"e9df2e35a58091c749bae4e1446600aeb669237cc39db72a41d5cae938d5620a","response_id":"cmpl-68fe7202ab3c4894ae17bd7c","runtime":{"accepted":12,"cached":0,"decode_s":0.3314,"drafted":45,"drafts":true,"min_rows":16,"prefill_s":0.1688,"rounds":3,"token_sha":"41b4449e1b18"},"seed":1234,"sent":971456.750417973,"speculative":{},"token_sha":"41b4449e1b18","tokens":16,"ttft_s":0.20244544302113354,"usage":{"completion_tokens":16,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":0},"total_tokens":30},"work":{"accepted":12,"drafted":45,"rounds":3},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":1,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":67.90764578181158,"done":971461.147067201,"finish_reason":"length","first":971457.391141115,"full_response_s":3.8663069700123742,"last":971461.146241105,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971457.391141115,2],[971457.476186979,7],[971457.558636774,4],[971457.638902515,73],[971457.718901013,51],[971457.800061862,21],[971457.879596738,14],[971457.960643721,20],[971458.043028371,16],[971458.129265157,15],[971458.211065513,23],[971458.291554874,23],[971458.371636651,25],[971458.452667057,36],[971458.533231877,14],[971458.616074001,6],[971458.696676055,18],[971458.776440267,18],[971458.85724527,19],[971458.938499824,8],[971459.018486344,11],[971459.10570225,18],[971459.188822813,15],[971459.268892905,39],[971459.349472072,30],[971459.430853111,14],[971459.51188284,15],[971459.591580533,8],[971459.671621376,6],[971459.75210478,12],[971459.832737772,26],[971459.91462217,22],[971459.995366507,18],[971460.081694309,38],[971460.165614721,22],[971460.246191212,10],[971460.326269155,14],[971460.407608364,15],[971460.4877261,38],[971460.570258059,47],[971460.651112112,25],[971460.731748397,11],[971460.811834693,34],[971460.892991137,12],[971460.973472259,36],[971461.062006286,60],[971461.146241105,48]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-4ab0a38fb83343ddb466dd24","runtime":{"accepted":209,"cached":13,"decode_s":3.7553,"drafted":690,"drafts":true,"min_rows":16,"prefill_s":0.1075,"rounds":46,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971457.280760231,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.11038088402710855,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":209,"drafted":690,"rounds":46},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":1,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":68.10681758822123,"done":971465.006141905,"finish_reason":"length","first":971461.26106324,"full_response_s":3.857510322937742,"last":971465.005181803,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971461.26106324,2],[971461.344048571,7],[971461.425022512,4],[971461.505491346,73],[971461.586208429,51],[971461.666515464,21],[971461.746635292,14],[971461.826513686,20],[971461.907963129,16],[971461.988311697,15],[971462.075430719,23],[971462.159308096,23],[971462.239710554,25],[971462.319977551,36],[971462.400765816,14],[971462.481568322,6],[971462.562873567,18],[971462.646433283,18],[971462.726251111,19],[971462.806839336,8],[971462.887269983,11],[971462.968242154,18],[971463.052687036,15],[971463.13703625,39],[971463.218896839,30],[971463.299572903,14],[971463.380088449,15],[971463.461151184,8],[971463.541306108,6],[971463.62158134,12],[971463.701684038,26],[971463.782056842,22],[971463.863296828,18],[971463.945113156,38],[971464.026039144,22],[971464.113257904,10],[971464.195912392,14],[971464.276144881,15],[971464.356680007,38],[971464.438566257,47],[971464.519181546,25],[971464.601810016,11],[971464.682447066,34],[971464.762734774,12],[971464.842942125,36],[971464.924864579,60],[971465.005181803,48]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-fc088541b2b640a5a34615f4","runtime":{"accepted":209,"cached":13,"decode_s":3.7439,"drafted":690,"drafts":true,"min_rows":16,"prefill_s":0.1095,"rounds":46,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971461.148631582,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.11243165796622634,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":209,"drafted":690,"rounds":46},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":1,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":68.11649047897781,"done":971468.871720558,"finish_reason":"length","first":971465.127665309,"full_response_s":3.8645585019839928,"last":971468.871252188,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971465.127665309,2],[971465.208970156,7],[971465.289152591,4],[971465.369552123,73],[971465.450318836,51],[971465.531134304,21],[971465.611113067,14],[971465.692147343,20],[971465.772172269,16],[971465.852514243,15],[971465.933021374,23],[971466.013481303,23],[971466.101793503,25],[971466.185214842,36],[971466.266241705,14],[971466.346436072,6],[971466.427842213,18],[971466.507872798,18],[971466.590495626,19],[971466.671014101,8],[971466.751490639,11],[971466.831958759,18],[971466.912803322,15],[971466.99365051,39],[971467.080374179,30],[971467.164744285,14],[971467.245310518,15],[971467.326016467,8],[971467.407474158,6],[971467.488837797,12],[971467.568975133,26],[971467.649408448,22],[971467.730151759,18],[971467.810297368,38],[971467.890611185,22],[971467.971679208,10],[971468.057147352,14],[971468.141950734,15],[971468.223328865,38],[971468.303672604,47],[971468.384467416,25],[971468.465748247,11],[971468.546143412,34],[971468.629158678,12],[971468.709046511,36],[971468.789497567,60],[971468.871252188,48]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-025840875a2b48aabee1e7fd","runtime":{"accepted":209,"cached":13,"decode_s":3.7428,"drafted":690,"drafts":true,"min_rows":16,"prefill_s":0.1181,"rounds":46,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971465.007162056,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12050325295422226,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":209,"drafted":690,"rounds":46},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.430127687908183,"done":971479.229278461,"finish_reason":"length","first":971469.185042243,"full_response_s":10.35392077092547,"last":971479.212518437,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971469.185042243,2],[971469.381080282,7],[971469.518684674,4],[971469.753264013,53],[971469.929986361,47],[971470.128340077,30],[971470.281100785,15],[971470.456512087,14],[971470.61041183,20],[971470.790839053,14],[971470.975083771,4],[971471.153791957,13],[971471.325635272,21],[971471.509932312,2],[971471.687607786,18],[971471.872759974,29],[971472.131856559,27],[971472.309485621,15],[971472.460818832,11],[971472.648360929,18],[971472.83449449,10],[971473.018760242,31],[971473.181304047,8],[971473.361037355,11],[971473.510014308,16],[971473.660445764,12],[971473.843195056,39],[971474.028277373,18],[971474.218202033,11],[971474.364822519,16],[971474.547041431,16],[971474.70046088,11],[971474.883250113,6],[971475.078615113,9],[971475.261879078,29],[971475.449453222,22],[971475.63144741,8],[971475.781790141,18],[971475.967237731,18],[971476.163882208,34],[971476.34862545,10],[971476.53150427,14],[971476.718451051,13],[971476.90146691,2],[971477.099349231,36],[971477.286519482,42],[971477.469883781,26],[971477.62614011,17],[971477.805894432,34],[971477.993821357,12],[971478.189210307,36],[971478.490467578,50],[971478.67921863,2],[971478.964402324,54],[971479.212518437,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-04aa872cdfda4143a043a8d2","runtime":{"accepted":201,"cached":13,"decode_s":10.0262,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.2747,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971468.87535769,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.30968455295078456,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":1,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.427597400719485,"done":971479.228935504,"finish_reason":"length","first":971469.186102011,"full_response_s":10.353276762994938,"last":971479.214576034,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971469.186102011,2],[971469.381192206,7],[971469.522109125,4],[971469.755224937,53],[971469.932451735,47],[971470.129339027,30],[971470.278059965,15],[971470.457140127,14],[971470.611503472,20],[971470.791412386,14],[971470.977023317,4],[971471.152191672,13],[971471.327274439,21],[971471.510323335,2],[971471.687683245,18],[971471.871259981,29],[971472.132884438,27],[971472.309290046,15],[971472.464504093,11],[971472.647721848,18],[971472.833753869,10],[971473.018947897,31],[971473.184444391,8],[971473.360799922,11],[971473.510184458,16],[971473.661783974,12],[971473.843943997,39],[971474.028749375,18],[971474.218389976,11],[971474.363981831,16],[971474.5482161,16],[971474.699805143,11],[971474.883568749,6],[971475.078532502,9],[971475.261542809,29],[971475.448331803,22],[971475.63176483,8],[971475.785231696,18],[971475.966378147,18],[971476.163085186,34],[971476.349373015,10],[971476.532128613,14],[971476.720105338,13],[971476.90295111,2],[971477.097710433,36],[971477.284228563,42],[971477.470896443,26],[971477.626616176,17],[971477.808412063,34],[971477.995249155,12],[971478.187757277,36],[971478.489915493,50],[971478.67985171,2],[971478.963868128,54],[971479.214576034,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-95f1c4e027404c73a2d23d34","runtime":{"accepted":201,"cached":13,"decode_s":10.0263,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.2747,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971468.875658741,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.3104432700201869,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":2,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.430891149051114,"done":971479.231767483,"finish_reason":"length","first":971469.185415441,"full_response_s":10.354670047061518,"last":971479.2125906,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971469.185415441,2],[971469.381993645,7],[971469.518870857,4],[971469.75358785,53],[971469.932711089,47],[971470.128177543,30],[971470.277594011,15],[971470.45764461,14],[971470.611967554,20],[971470.791668428,14],[971470.976188581,4],[971471.15414093,13],[971471.326288433,21],[971471.508320506,2],[971471.689169734,18],[971471.872321413,29],[971472.132435333,27],[971472.312075976,15],[971472.459799354,11],[971472.650167638,18],[971472.837688851,10],[971473.020607928,31],[971473.181738992,8],[971473.360143801,11],[971473.510408659,16],[971473.660849203,12],[971473.846096798,39],[971474.028672732,18],[971474.218460235,11],[971474.365610005,16],[971474.549232954,16],[971474.701343121,11],[971474.883852648,6],[971475.077931103,9],[971475.26268594,29],[971475.449374259,22],[971475.633025982,8],[971475.782454678,18],[971475.966989178,18],[971476.163160133,34],[971476.350425135,10],[971476.531897805,14],[971476.718961023,13],[971476.901534353,2],[971477.097538474,36],[971477.284393145,42],[971477.470639489,26],[971477.626757029,17],[971477.806824867,34],[971477.994852708,12],[971478.194050602,36],[971478.491083121,50],[971478.679559603,2],[971478.964723232,54],[971479.2125906,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-fdf9cb01e04841cc8dfcd823","runtime":{"accepted":201,"cached":13,"decode_s":10.0264,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.2747,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971468.877097436,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.30831800505984575,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":3,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.430105492201005,"done":971479.22766656,"finish_reason":"length","first":971469.186051033,"full_response_s":10.352117230999283,"last":971479.213535979,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971469.186051033,2],[971469.381416487,7],[971469.518931483,4],[971469.75656622,53],[971469.930548063,47],[971470.128459906,30],[971470.277142569,15],[971470.45748078,14],[971470.613764295,20],[971470.791746495,14],[971470.976409166,4],[971471.153565804,13],[971471.326510746,21],[971471.509130857,2],[971471.688569039,18],[971471.87187578,29],[971472.133831386,27],[971472.310912812,15],[971472.462638422,11],[971472.650330988,18],[971472.835265879,10],[971473.018608364,31],[971473.184731234,8],[971473.361258371,11],[971473.512300347,16],[971473.66060441,12],[971473.84454818,39],[971474.028577112,18],[971474.22058822,11],[971474.365014815,16],[971474.548638084,16],[971474.700562836,11],[971474.883129068,6],[971475.077572225,9],[971475.262980527,29],[971475.452619326,22],[971475.634480277,8],[971475.78350163,18],[971475.967310022,18],[971476.16250902,34],[971476.350199158,10],[971476.532600055,14],[971476.718554399,13],[971476.904724698,2],[971477.09784455,36],[971477.28384098,42],[971477.470027642,26],[971477.627081649,17],[971477.807036299,34],[971477.994979177,12],[971478.188067352,36],[971478.490013673,50],[971478.679285176,2],[971478.964669614,54],[971479.213535979,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-cfbf525642034cb98d08fe33","runtime":{"accepted":201,"cached":13,"decode_s":10.0263,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.2747,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971468.875549329,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.310501703992486,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":4,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.433484522494638,"done":971479.230024185,"finish_reason":"length","first":971469.187077777,"full_response_s":10.353901089983992,"last":971479.213230496,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971469.187077777,2],[971469.382431997,7],[971469.521228515,4],[971469.75443721,53],[971469.931272922,47],[971470.128994214,30],[971470.278540895,15],[971470.45707078,14],[971470.611763178,20],[971470.791077446,14],[971470.976125587,4],[971471.152371679,13],[971471.326102138,21],[971471.507673089,2],[971471.688243682,18],[971471.87271338,29],[971472.133209763,27],[971472.311090274,15],[971472.462910224,11],[971472.649179408,18],[971472.836842499,10],[971473.019808154,31],[971473.179718755,8],[971473.360477126,11],[971473.511733461,16],[971473.661366231,12],[971473.843889242,39],[971474.030701049,18],[971474.221044893,11],[971474.364743668,16],[971474.547807812,16],[971474.700382269,11],[971474.88418282,6],[971475.077433292,9],[971475.261947992,29],[971475.448744059,22],[971475.632085515,8],[971475.782304417,18],[971475.966796163,18],[971476.162846313,34],[971476.349326837,10],[971476.53182825,14],[971476.718245347,13],[971476.90436166,2],[971477.098300215,36],[971477.285064739,42],[971477.470546334,26],[971477.627756267,17],[971477.807322134,34],[971477.994109176,12],[971478.1910206,36],[971478.49098827,50],[971478.679923153,2],[971478.965133184,54],[971479.213230496,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-de9a5c470e88444095c1bcd1","runtime":{"accepted":201,"cached":13,"decode_s":10.0263,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.2747,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971468.876123095,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.310954681946896,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":5,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.433517073936912,"done":971479.231034287,"finish_reason":"length","first":971469.186519403,"full_response_s":10.351779103977606,"last":971479.21265929,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971469.186519403,2],[971469.382157843,7],[971469.519116946,4],[971469.753519879,53],[971469.932379733,47],[971470.128918131,30],[971470.278792585,15],[971470.457372344,14],[971470.612989705,20],[971470.791231132,14],[971470.976947234,4],[971471.152250074,13],[971471.325388191,21],[971471.508248631,2],[971471.688508124,18],[971471.871953015,29],[971472.131968819,27],[971472.308644949,15],[971472.459207891,11],[971472.649080412,18],[971472.835962274,10],[971473.019029276,31],[971473.180155667,8],[971473.360718095,11],[971473.510898805,16],[971473.662088994,12],[971473.843764854,39],[971474.031255246,18],[971474.218740038,11],[971474.364650881,16],[971474.547948954,16],[971474.70266634,11],[971474.882471139,6],[971475.078201881,9],[971475.264443175,29],[971475.450902749,22],[971475.632250561,8],[971475.783835979,18],[971475.968507988,18],[971476.16218384,34],[971476.348918742,10],[971476.531750823,14],[971476.721811866,13],[971476.902066725,2],[971477.098192723,36],[971477.284633474,42],[971477.472909191,26],[971477.627401181,17],[971477.807755222,34],[971477.995121758,12],[971478.187671113,36],[971478.492820579,50],[971478.681453898,2],[971478.963519827,54],[971479.21265929,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-84cffccd0e8f461194144021","runtime":{"accepted":201,"cached":13,"decode_s":10.0264,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.2747,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971468.879255183,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.30726421996951103,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":6,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.43046266563185,"done":971479.231372252,"finish_reason":"length","first":971469.18580776,"full_response_s":10.355146880960092,"last":971479.213151869,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971469.18580776,2],[971469.382035166,7],[971469.520208748,4],[971469.757678535,53],[971469.931185735,47],[971470.127807433,30],[971470.278617762,15],[971470.456717983,14],[971470.612498486,20],[971470.791938951,14],[971470.977769282,4],[971471.151971455,13],[971471.327192308,21],[971471.510416538,2],[971471.68745642,18],[971471.872230738,29],[971472.132962169,27],[971472.310183776,15],[971472.459628259,11],[971472.648063221,18],[971472.835796603,10],[971473.02145164,31],[971473.181494966,8],[971473.361186017,11],[971473.51180124,16],[971473.66129706,12],[971473.844615046,39],[971474.031537801,18],[971474.218671811,11],[971474.364431321,16],[971474.547588236,16],[971474.700205926,11],[971474.882560999,6],[971475.078931397,9],[971475.262329223,29],[971475.450852347,22],[971475.633550146,8],[971475.78239626,18],[971475.966849797,18],[971476.163797229,34],[971476.348734879,10],[971476.531334807,14],[971476.720906344,13],[971476.904635638,2],[971477.098018572,36],[971477.284316438,42],[971477.469948103,26],[971477.62625013,17],[971477.806073319,34],[971477.993581156,12],[971478.1884958,36],[971478.493589968,50],[971478.678546397,2],[971478.965904045,54],[971479.213151869,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-f8e5f1fbc28644fda6bbf8fe","runtime":{"accepted":201,"cached":13,"decode_s":10.0263,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.2747,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971468.876225371,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.30958238895982504,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":7,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.43178902995068,"done":971479.229401106,"finish_reason":"length","first":971469.186962668,"full_response_s":10.353971958043985,"last":971479.213783813,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971469.186962668,2],[971469.380916067,7],[971469.519054128,4],[971469.753827043,53],[971469.930591888,47],[971470.129491337,30],[971470.277794034,15],[971470.456903606,14],[971470.611445646,20],[971470.794140411,14],[971470.977662605,4],[971471.152855841,13],[971471.325911443,21],[971471.508084881,2],[971471.690357827,18],[971471.871819026,29],[971472.132666062,27],[971472.309097494,15],[971472.460146679,11],[971472.651647502,18],[971472.834897001,10],[971473.01835317,31],[971473.179952156,8],[971473.361338774,11],[971473.511049403,16],[971473.661627969,12],[971473.844264297,39],[971474.028852514,18],[971474.219099603,11],[971474.36646231,16],[971474.547194669,16],[971474.701684638,11],[971474.882871523,6],[971475.078444354,9],[971475.261686446,29],[971475.452083034,22],[971475.635828409,8],[971475.781872032,18],[971475.967104046,18],[971476.164026678,34],[971476.349733636,10],[971476.531697861,14],[971476.718708693,13],[971476.901794683,2],[971477.099117366,36],[971477.288265884,42],[971477.469773296,26],[971477.626561278,17],[971477.806744592,34],[971477.994054342,12],[971478.18869416,36],[971478.490760869,50],[971478.679022783,2],[971478.9660849,54],[971479.213783813,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-d847d919b9b34fffb89d3a33","runtime":{"accepted":201,"cached":13,"decode_s":10.0262,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.2747,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971468.875429148,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.3115335199981928,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":8,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.425128255131067,"done":971479.230521308,"finish_reason":"length","first":971469.185885731,"full_response_s":10.353910594014451,"last":971479.215333663,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971469.185885731,2],[971469.381720354,7],[971469.519885712,4],[971469.753441044,53],[971469.932096346,47],[971470.129587165,30],[971470.279589495,15],[971470.45665454,14],[971470.611620677,20],[971470.790973106,14],[971470.975401335,4],[971471.152311532,13],[971471.327443485,21],[971471.50801483,2],[971471.689889745,18],[971471.874540826,29],[971472.132630205,27],[971472.309384545,15],[971472.46090914,11],[971472.647606596,18],[971472.835445294,10],[971473.019188834,31],[971473.179832055,8],[971473.360345585,11],[971473.51338042,16],[971473.661547949,12],[971473.843096012,39],[971474.029153086,18],[971474.218564559,11],[971474.365424158,16],[971474.549983431,16],[971474.699376215,11],[971474.883923707,6],[971475.078309277,9],[971475.26705833,29],[971475.45004134,22],[971475.631908484,8],[971475.783373529,18],[971475.966734736,18],[971476.161834899,34],[971476.350322699,10],[971476.532403408,14],[971476.718331079,13],[971476.902118567,2],[971477.098501711,36],[971477.284518686,42],[971477.470139374,26],[971477.627855647,17],[971477.806455861,34],[971477.99449983,12],[971478.187537044,36],[971478.492404915,50],[971478.682728475,2],[971478.964610044,54],[971479.215333663,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-6cda73aa74a84911beebfad8","runtime":{"accepted":201,"cached":13,"decode_s":10.0265,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.2747,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971468.876610714,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.3092750170035288,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":9,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.431964109463145,"done":971479.232032949,"finish_reason":"length","first":971469.186217616,"full_response_s":10.356310124974698,"last":971479.212969734,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971469.186217616,2],[971469.38275417,7],[971469.519549523,4],[971469.754518445,53],[971469.932655231,47],[971470.127668691,30],[971470.278459692,15],[971470.457582608,14],[971470.61170708,20],[971470.792643746,14],[971470.976234951,4],[971471.152028993,13],[971471.326034184,21],[971471.509433109,2],[971471.688403672,18],[971471.87265781,29],[971472.135048761,27],[971472.312151035,15],[971472.459104575,11],[971472.654265074,18],[971472.835114369,10],[971473.018664382,31],[971473.18107359,8],[971473.360241469,11],[971473.511859706,16],[971473.662202454,12],[971473.843455066,39],[971474.029423896,18],[971474.220248863,11],[971474.364346677,16],[971474.547498889,16],[971474.699627216,11],[971474.883626303,6],[971475.078828625,9],[971475.261804003,29],[971475.448550884,22],[971475.632195855,8],[971475.781990149,18],[971475.967833514,18],[971476.163637079,34],[971476.34904577,10],[971476.531092366,14],[971476.717746112,13],[971476.901930032,2],[971477.0974846,36],[971477.284047228,42],[971477.472287664,26],[971477.626073995,17],[971477.806522504,34],[971477.996102051,12],[971478.190560102,36],[971478.492033253,50],[971478.678825511,2],[971478.964097817,54],[971479.212969734,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-58b25fb47d014f0dacdc4a28","runtime":{"accepted":201,"cached":13,"decode_s":10.0263,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.2747,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971468.875722824,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.31049479194916785,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":10,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.434065768179476,"done":971479.228217093,"finish_reason":"length","first":971469.186315747,"full_response_s":10.352222883026116,"last":971479.212239338,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971469.186315747,2],[971469.381581949,7],[971469.520090248,4],[971469.755288939,53],[971469.93043241,47],[971470.128065107,30],[971470.277372594,15],[971470.456780449,14],[971470.610582109,20],[971470.791157113,14],[971470.975587678,4],[971471.153825206,13],[971471.328055749,21],[971471.507938379,2],[971471.687762032,18],[971471.873428736,29],[971472.132172539,27],[971472.308980194,15],[971472.462391996,11],[971472.647472975,18],[971472.835601492,10],[971473.0180734,31],[971473.180755786,8],[971473.361109678,11],[971473.512141717,16],[971473.662661784,12],[971473.847049763,39],[971474.028494885,18],[971474.218320374,11],[971474.364100444,16],[971474.548159842,16],[971474.699257538,11],[971474.885647436,6],[971475.078361263,9],[971475.262015243,29],[971475.448472257,22],[971475.633380892,8],[971475.783323623,18],[971475.966675198,18],[971476.161934039,34],[971476.351387411,10],[971476.533547851,14],[971476.719194647,13],[971476.901151746,2],[971477.098981505,36],[971477.286242575,42],[971477.47138827,26],[971477.629449387,17],[971477.808092899,34],[971477.993412493,12],[971478.189639204,36],[971478.491232247,50],[971478.68071091,2],[971478.963633623,54],[971479.212239338,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-a2711c122b334880bed7a32a","runtime":{"accepted":201,"cached":13,"decode_s":10.0262,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.2747,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971468.87599421,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.31032153696287423,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":11,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.433112285473218,"done":971479.229212187,"finish_reason":"length","first":971469.186414871,"full_response_s":10.3500659520505,"last":971479.212714332,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971469.186414871,2],[971469.381775828,7],[971469.519019055,4],[971469.753767217,53],[971469.930860187,47],[971470.128266138,30],[971470.28098782,15],[971470.456982585,14],[971470.610727939,20],[971470.792421977,14],[971470.97684451,4],[971471.152560102,13],[971471.325704843,21],[971471.507816855,2],[971471.688027274,18],[971471.873843312,29],[971472.132733377,27],[971472.312510585,15],[971472.459708486,11],[971472.648455604,18],[971472.834720882,10],[971473.020412321,31],[971473.183070498,8],[971473.362950724,11],[971473.510986201,16],[971473.661075355,12],[971473.844086818,39],[971474.029636816,18],[971474.21880676,11],[971474.365484337,16],[971474.548025949,16],[971474.699497099,11],[971474.885469493,6],[971475.07768471,9],[971475.263777742,29],[971475.448897281,22],[971475.631631609,8],[971475.782888263,18],[971475.968793038,18],[971476.16349549,34],[971476.348343616,10],[971476.53229734,14],[971476.717976729,13],[971476.90262665,2],[971477.097777219,36],[971477.287940479,42],[971477.470478875,26],[971477.625952935,17],[971477.807702868,34],[971477.993746714,12],[971478.188160748,36],[971478.492463734,50],[971478.679144515,2],[971478.963973364,54],[971479.212714332,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-7f8b540f694344718d730b54","runtime":{"accepted":201,"cached":13,"decode_s":10.0265,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.2747,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971468.879146235,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.3072686360683292,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":12,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.43295671420153,"done":971479.230882058,"finish_reason":"length","first":971469.185982519,"full_response_s":10.352647042018361,"last":971479.21234331,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971469.185982519,2],[971469.382099121,7],[971469.520632348,4],[971469.757034926,53],[971469.93032447,47],[971470.129429399,30],[971470.277498567,15],[971470.456842548,14],[971470.61080751,20],[971470.792577663,14],[971470.975531756,4],[971471.151914045,13],[971471.328151416,21],[971471.508512033,2],[971471.68896547,18],[971471.871409683,29],[971472.134757166,27],[971472.308747961,15],[971472.459472877,11],[971472.649610464,18],[971472.83723949,10],[971473.018564459,31],[971473.182049308,8],[971473.360542488,11],[971473.511224466,16],[971473.661160943,12],[971473.843312517,39],[971474.029868121,18],[971474.221177586,11],[971474.364258802,16],[971474.547882967,16],[971474.700280441,11],[971474.883437576,6],[971475.079045081,9],[971475.262405578,29],[971475.44951868,22],[971475.632958092,8],[971475.782707872,18],[971475.967772056,18],[971476.162660658,34],[971476.349657234,10],[971476.532470114,14],[971476.718828441,13],[971476.902562392,2],[971477.097076041,36],[971477.28536411,42],[971477.470593375,26],[971477.62969754,17],[971477.80668411,34],[971477.996333964,12],[971478.187887553,36],[971478.492760737,50],[971478.684922477,2],[971478.963705162,54],[971479.21234331,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-9fb5dedcc46e4d12b714c66f","runtime":{"accepted":201,"cached":13,"decode_s":10.0264,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.2747,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971468.878235016,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.3077475029276684,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":13,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.42169670251784,"done":971479.229761055,"finish_reason":"length","first":971469.186697842,"full_response_s":10.350922063924372,"last":971479.217499601,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971469.186697842,2],[971469.382219029,7],[971469.51878847,4],[971469.754965151,53],[971469.931606775,47],[971470.130663302,30],[971470.280226831,15],[971470.457752663,14],[971470.613466299,20],[971470.794076984,14],[971470.975956412,4],[971471.153301362,13],[971471.325502707,21],[971471.507336021,2],[971471.687952151,18],[971471.873911922,29],[971472.133368121,27],[971472.310393208,15],[971472.459370729,11],[971472.649689443,18],[971472.833864594,10],[971473.019535632,31],[971473.181949912,8],[971473.361860826,11],[971473.510833171,16],[971473.662153365,12],[971473.845062167,39],[971474.02993334,18],[971474.218081597,11],[971474.365234471,16],[971474.547663391,16],[971474.700899489,11],[971474.883029513,6],[971475.077852796,9],[971475.262853179,29],[971475.449906631,22],[971475.633877119,8],[971475.781619639,18],[971475.967445483,18],[971476.161741919,34],[971476.350015039,10],[971476.531589057,14],[971476.718161904,13],[971476.903126653,2],[971477.099990663,36],[971477.283915719,42],[971477.471665944,26],[971477.626418776,17],[971477.806205068,34],[971477.994218428,12],[971478.188964282,36],[971478.492272686,50],[971478.68086386,2],[971478.964513433,54],[971479.217499601,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-4f161a5e111047389f6f4cac","runtime":{"accepted":201,"cached":13,"decode_s":10.0264,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.2747,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971468.878838991,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.30785885092336684,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":14,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.431917193857128,"done":971479.230679202,"finish_reason":"length","first":971469.185659146,"full_response_s":10.354800452012569,"last":971479.212429761,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971469.185659146,2],[971469.381354708,7],[971469.520568602,4],[971469.755630616,53],[971469.930068636,47],[971470.128627272,30],[971470.277886726,15],[971470.458918547,14],[971470.611307849,20],[971470.791522599,14],[971470.978700341,4],[971471.152903395,13],[971471.325239145,21],[971471.509243453,2],[971471.688314053,18],[971471.871156969,29],[971472.132229597,27],[971472.309926166,15],[971472.462230278,11],[971472.648989929,18],[971472.836575673,10],[971473.018456422,31],[971473.181371218,8],[971473.360949528,11],[971473.510108567,16],[971473.660770112,12],[971473.844026032,39],[971474.029015769,18],[971474.218947822,11],[971474.364933036,16],[971474.547728545,16],[971474.700688825,11],[971474.885762672,6],[971475.078093477,9],[971475.263087427,29],[971475.448628231,22],[971475.631945701,8],[971475.783729927,18],[971475.966592667,18],[971476.164128186,34],[971476.351140922,10],[971476.532752125,14],[971476.71990597,13],[971476.901387979,2],[971477.097242639,36],[971477.283704319,42],[971477.469606986,26],[971477.630222088,17],[971477.806979209,34],[971477.993658167,12],[971478.188420646,36],[971478.491427022,50],[971478.685594007,2],[971478.964787091,54],[971479.212429761,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-e339241ccd0e4b6aa4a4a004","runtime":{"accepted":201,"cached":13,"decode_s":10.0262,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.2747,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971468.87587875,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.3097803960554302,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":0,"stream":15,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.431955138062186,"done":971479.22961873,"finish_reason":"length","first":971469.185366303,"full_response_s":10.354338995064609,"last":971479.212121958,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971469.185366303,2],[971469.381935258,7],[971469.519653079,4],[971469.755560917,53],[971469.931918947,47],[971470.129265552,30],[971470.277672286,15],[971470.458594519,14],[971470.611229558,20],[971470.791306014,14],[971470.977372194,4],[971471.153378629,13],[971471.327523825,21],[971471.510970527,2],[971471.68880028,18],[971471.872126766,29],[971472.133900317,27],[971472.309202058,15],[971472.461396822,11],[971472.653979863,18],[971472.834785077,10],[971473.018815124,31],[971473.182849306,8],[971473.361484284,11],[971473.511449642,16],[971473.6627707,12],[971473.843532317,39],[971474.030114899,18],[971474.219041729,11],[971474.366713903,16],[971474.54738658,16],[971474.701579578,11],[971474.882956742,6],[971475.077780265,9],[971475.262234339,29],[971475.449050663,22],[971475.632134524,8],[971475.782186188,18],[971475.966508776,18],[971476.16139165,34],[971476.349249298,10],[971476.532238793,14],[971476.718278085,13],[971476.902683516,2],[971477.097941529,36],[971477.284707381,42],[971477.470379527,26],[971477.62668429,17],[971477.807833737,34],[971477.994441508,12],[971478.188628237,36],[971478.491165077,50],[971478.679641334,2],[971478.963932147,54],[971479.212121958,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-163efbe5d1494a8e9393498d","runtime":{"accepted":201,"cached":13,"decode_s":10.0264,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.2747,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971468.875279735,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.31008656800258905,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.461364525760384,"done":971489.494064422,"finish_reason":"length","first":971479.457591314,"full_response_s":10.257069029961713,"last":971489.472765471,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971479.457591314,2],[971479.628604502,7],[971479.775959805,4],[971480.002668875,53],[971480.197621706,47],[971480.382741063,30],[971480.532789995,15],[971480.717346179,14],[971480.866892129,20],[971481.054498736,14],[971481.244123852,4],[971481.390691636,13],[971481.573390668,21],[971481.757149355,2],[971481.940735596,18],[971482.139399872,29],[971482.374035771,27],[971482.561630447,15],[971482.712941505,11],[971482.897677013,18],[971483.08972735,10],[971483.272220304,31],[971483.424156529,8],[971483.607517596,11],[971483.758600013,16],[971483.910454421,12],[971484.102706658,39],[971484.280032368,18],[971484.465139458,11],[971484.623664752,16],[971484.808264831,16],[971484.95516165,11],[971485.152879584,6],[971485.334865811,9],[971485.519454534,29],[971485.709445844,22],[971485.893571666,8],[971486.045909047,18],[971486.240499461,18],[971486.4219094,34],[971486.61537358,10],[971486.796545141,14],[971486.987766332,13],[971487.186370148,2],[971487.368230093,36],[971487.551401607,42],[971487.737947662,26],[971487.89092043,17],[971488.084206566,34],[971488.273784099,12],[971488.458356966,36],[971488.748987044,50],[971488.940280777,2],[971489.232857374,54],[971489.472765471,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-523965c1916349449d718f89","runtime":{"accepted":201,"cached":13,"decode_s":10.0159,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1927,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971479.236995392,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2205959219718352,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.449142111144166,"done":971489.494400403,"finish_reason":"length","first":971479.45703915,"full_response_s":10.256419342011213,"last":971489.477023277,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971479.45703915,2],[971479.630009995,7],[971479.777685614,4],[971480.003273377,53],[971480.201993727,47],[971480.384038488,30],[971480.532626965,15],[971480.718253861,14],[971480.866806717,20],[971481.053436664,14],[971481.243075797,4],[971481.39053403,13],[971481.574725902,21],[971481.757806179,2],[971481.940827951,18],[971482.139888482,29],[971482.374307621,27],[971482.560967463,15],[971482.712720057,11],[971482.896805589,18],[971483.090188839,10],[971483.273198021,31],[971483.424240788,8],[971483.609883765,11],[971483.760428161,16],[971483.909052432,12],[971484.102513275,39],[971484.280704873,18],[971484.466932213,11],[971484.623928986,16],[971484.805700831,16],[971484.955675317,11],[971485.154196514,6],[971485.338075547,9],[971485.519332866,29],[971485.70558914,22],[971485.892017704,8],[971486.047543268,18],[971486.23916842,18],[971486.423128613,34],[971486.61597453,10],[971486.798693926,14],[971486.982254398,13],[971487.182115878,2],[971487.364998165,36],[971487.553395953,42],[971487.737358488,26],[971487.891063555,17],[971488.084721561,34],[971488.273556587,12],[971488.459783115,36],[971488.750130334,50],[971488.937380222,2],[971489.234366071,54],[971489.477023277,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-d82b11bcc7a44fb7a89925aa","runtime":{"accepted":201,"cached":13,"decode_s":10.016,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1927,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971479.237981061,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2190580889582634,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.45887954848796,"done":971489.492178944,"finish_reason":"length","first":971479.458193497,"full_response_s":10.254361473023891,"last":971489.47434521,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971479.458193497,2],[971479.629718672,7],[971479.777160586,4],[971480.00350961,53],[971480.197547559,47],[971480.382857275,30],[971480.534427337,15],[971480.715703301,14],[971480.867165643,20],[971481.054160004,14],[971481.243163832,4],[971481.390198178,13],[971481.575176319,21],[971481.758080862,2],[971481.94068353,18],[971482.137453511,29],[971482.372543635,27],[971482.560873507,15],[971482.713298639,11],[971482.897768105,18],[971483.092368441,10],[971483.277179322,31],[971483.423306385,8],[971483.609369153,11],[971483.757339677,16],[971483.90722766,12],[971484.101862306,39],[971484.280937202,18],[971484.464654096,11],[971484.623363589,16],[971484.805472583,16],[971484.958519359,11],[971485.153957529,6],[971485.336869422,9],[971485.520138896,29],[971485.70677712,22],[971485.895059017,8],[971486.046228083,18],[971486.23863808,18],[971486.42249835,34],[971486.614650417,10],[971486.796906115,14],[971486.983091486,13],[971487.186932921,2],[971487.365161739,36],[971487.552531505,42],[971487.739149371,26],[971487.891511972,17],[971488.085183546,34],[971488.273164508,12],[971488.457301631,36],[971488.747165344,50],[971488.937826062,2],[971489.23584787,54],[971489.47434521,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-9829591a7d86485b8919a089","runtime":{"accepted":201,"cached":13,"decode_s":10.0161,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1927,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971479.237817471,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.22037602600175887,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.459755855532222,"done":971489.493177445,"finish_reason":"length","first":971479.456840966,"full_response_s":10.255571854067966,"last":971489.47264793,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971479.456840966,2],[971479.629850325,7],[971479.776636119,4],[971480.003327619,53],[971480.198093372,47],[971480.381758418,30],[971480.531736339,15],[971480.716975781,14],[971480.8663491,20],[971481.053620079,14],[971481.242968369,4],[971481.390606161,13],[971481.573866445,21],[971481.756718811,2],[971481.940900594,18],[971482.137584956,29],[971482.372944642,27],[971482.559913295,15],[971482.713226396,11],[971482.897182515,18],[971483.090111844,10],[971483.274209883,31],[971483.425923587,8],[971483.607704179,11],[971483.759750616,16],[971483.907324511,12],[971484.101425218,39],[971484.279817,18],[971484.463468787,11],[971484.622890563,16],[971484.804585637,16],[971484.955576897,11],[971485.155639751,6],[971485.335416967,9],[971485.517915725,29],[971485.704827287,22],[971485.892475385,8],[971486.046155408,18],[971486.238324308,18],[971486.422962591,34],[971486.612332778,10],[971486.796614232,14],[971486.982335921,13],[971487.186475272,2],[971487.364475185,36],[971487.550698973,42],[971487.737788776,26],[971487.890348953,17],[971488.086082491,34],[971488.272440337,12],[971488.45802633,36],[971488.74836118,50],[971488.937163974,2],[971489.232769771,54],[971489.47264793,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-15b39e2e80e4434ea9b087ea","runtime":{"accepted":201,"cached":13,"decode_s":10.0161,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1927,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971479.237605591,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2192353750579059,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.46587928449882,"done":971489.490368237,"finish_reason":"length","first":971479.459327332,"full_response_s":10.253279097029008,"last":971489.472725933,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971479.459327332,2],[971479.628315611,7],[971479.777756801,4],[971480.002554502,53],[971480.197869203,47],[971480.384658431,30],[971480.532905983,15],[971480.715376009,14],[971480.864976328,20],[971481.05290098,14],[971481.243227434,4],[971481.39116671,13],[971481.573989298,21],[971481.756413519,2],[971481.940608151,18],[971482.138311383,29],[971482.372685688,27],[971482.560394993,15],[971482.713093927,11],[971482.897097264,18],[971483.08918469,10],[971483.271910629,31],[971483.423150667,8],[971483.607199984,11],[971483.757211225,16],[971483.906857982,12],[971484.104186249,39],[971484.279201329,18],[971484.463348655,11],[971484.623021096,16],[971484.806026907,16],[971484.954970395,11],[971485.154354807,6],[971485.336234422,9],[971485.521935891,29],[971485.705761578,22],[971485.890917455,8],[971486.047211064,18],[971486.237618106,18],[971486.422126272,34],[971486.611752741,10],[971486.795298807,14],[971486.986415113,13],[971487.187261862,2],[971487.365535017,36],[971487.552293672,42],[971487.737103359,26],[971487.890708678,17],[971488.085424035,34],[971488.272193864,12],[971488.458279235,36],[971488.747042651,50],[971488.936998767,2],[971489.232607429,54],[971489.472725933,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-0a34f99e166f4aeabe18ffe8","runtime":{"accepted":201,"cached":13,"decode_s":10.0159,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1927,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971479.23708914,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2222381919855252,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.44768593722441,"done":971489.493911312,"finish_reason":"length","first":971479.456923337,"full_response_s":10.256760378018953,"last":971489.47748083,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971479.456923337,2],[971479.629167547,7],[971479.776285721,4],[971480.004620756,53],[971480.19704826,47],[971480.382145505,30],[971480.532481567,15],[971480.719338174,14],[971480.866956723,20],[971481.053145421,14],[971481.24498534,4],[971481.392285584,13],[971481.574274093,21],[971481.756322764,2],[971481.94052746,18],[971482.137667999,29],[971482.37491046,27],[971482.559660021,15],[971482.71337541,11],[971482.897896094,18],[971483.090654297,10],[971483.277727903,31],[971483.426647599,8],[971483.608311402,11],[971483.758504969,16],[971483.90877711,12],[971484.105250977,39],[971484.27938204,18],[971484.464929482,11],[971484.623250353,16],[971484.805052135,16],[971484.961250518,11],[971485.153171467,6],[971485.337149528,9],[971485.520701957,29],[971485.706222011,22],[971485.891288652,8],[971486.045513352,18],[971486.239094065,18],[971486.422703317,34],[971486.614406568,10],[971486.796339662,14],[971486.983638498,13],[971487.187609635,2],[971487.368150186,36],[971487.551483658,42],[971487.739900071,26],[971487.890181971,17],[971488.087869678,34],[971488.272638488,12],[971488.458487979,36],[971488.747122942,50],[971488.93729201,2],[971489.233929094,54],[971489.47748083,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-c6b3f0d547824fe7be010fe7","runtime":{"accepted":201,"cached":13,"decode_s":10.016,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1927,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971479.237150934,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21977240301202983,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.44615164034656,"done":971489.491392099,"finish_reason":"length","first":971479.456705217,"full_response_s":10.253484543995,"last":971489.477866908,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971479.456705217,2],[971479.630152656,7],[971479.777360386,4],[971480.003407606,53],[971480.198645617,47],[971480.383189336,30],[971480.534616096,15],[971480.717612173,14],[971480.866263657,20],[971481.052739486,14],[971481.243314302,4],[971481.391502099,13],[971481.574666012,21],[971481.758644899,2],[971481.942632371,18],[971482.139199784,29],[971482.37560055,27],[971482.56148017,15],[971482.713624251,11],[971482.897559585,18],[971483.09003309,10],[971483.27334081,31],[971483.424704582,8],[971483.607397656,11],[971483.757398,16],[971483.910972584,12],[971484.10277058,39],[971484.282610001,18],[971484.465978625,11],[971484.622723165,16],[971484.804490802,16],[971484.956151527,11],[971485.155091331,6],[971485.339030878,9],[971485.518632808,29],[971485.705106738,22],[971485.891632281,8],[971486.045597003,18],[971486.238107932,18],[971486.423371406,34],[971486.613347792,10],[971486.796791071,14],[971486.986339799,13],[971487.181942559,2],[971487.364839215,36],[971487.550539623,42],[971487.737493709,26],[971487.890075439,17],[971488.085957207,34],[971488.273038535,12],[971488.457921078,36],[971488.747228786,50],[971488.939962286,2],[971489.235729033,54],[971489.477866908,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-406e6700576f47459a87cce8","runtime":{"accepted":201,"cached":13,"decode_s":10.0161,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1927,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971479.237907555,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21879766206257045,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.455550530809283,"done":971489.491601195,"finish_reason":"length","first":971479.457242309,"full_response_s":10.254383185994811,"last":971489.474703911,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971479.457242309,2],[971479.629783842,7],[971479.777285919,4],[971480.003044281,53],[971480.197928902,47],[971480.38293659,30],[971480.53520655,15],[971480.718311111,14],[971480.867101672,20],[971481.053346229,14],[971481.244612158,4],[971481.39308499,13],[971481.574906213,21],[971481.756627255,2],[971481.942361161,18],[971482.13891755,29],[971482.376206732,27],[971482.560091574,15],[971482.713823907,11],[971482.898282428,18],[971483.089017099,10],[971483.272403143,31],[971483.423876519,8],[971483.608411182,11],[971483.758874279,16],[971483.90765894,12],[971484.101795872,39],[971484.279317557,18],[971484.465665621,11],[971484.624529361,16],[971484.807088115,16],[971484.957156541,11],[971485.15258943,6],[971485.335885913,9],[971485.518920274,29],[971485.705277784,22],[971485.891759582,8],[971486.045671918,18],[971486.238475178,18],[971486.425186786,34],[971486.613685981,10],[971486.7958623,14],[971486.982742769,13],[971487.182399072,2],[971487.36476454,36],[971487.554182174,42],[971487.738319372,26],[971487.891308653,17],[971488.086986733,34],[971488.274351928,12],[971488.458959533,36],[971488.748859631,50],[971488.938670942,2],[971489.233266622,54],[971489.474703911,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-ef6e67f7ac814626abcc8f1c","runtime":{"accepted":201,"cached":13,"decode_s":10.016,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1927,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971479.237218009,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2200243000406772,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.44016350417342,"done":971489.492932764,"finish_reason":"length","first":971479.45637466,"full_response_s":10.2552618739428,"last":971489.479895144,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971479.45637466,2],[971479.629312945,7],[971479.777083559,4],[971480.002930804,53],[971480.197676124,47],[971480.384395461,30],[971480.531921194,15],[971480.717049144,14],[971480.866003887,20],[971481.053700658,14],[971481.243383472,4],[971481.391446161,13],[971481.574769551,21],[971481.75734693,2],[971481.941153739,18],[971482.137109514,29],[971482.374436778,27],[971482.561855416,15],[971482.713573049,11],[971482.897234085,18],[971483.089501726,10],[971483.277949863,31],[971483.427608323,8],[971483.611703673,11],[971483.759159234,16],[971483.908484507,12],[971484.101730909,39],[971484.283291994,18],[971484.46681504,11],[971484.624960737,16],[971484.807847583,16],[971484.955350425,11],[971485.153054839,6],[971485.337496533,9],[971485.523949342,29],[971485.705703192,22],[971485.891202809,8],[971486.045773074,18],[971486.24141708,18],[971486.425426507,34],[971486.61190033,10],[971486.796395824,14],[971486.983502429,13],[971487.18705971,2],[971487.365089528,36],[971487.551803062,42],[971487.74036948,26],[971487.890502047,17],[971488.084322538,34],[971488.273102778,12],[971488.457542584,36],[971488.751681528,50],[971488.93835581,2],[971489.234247794,54],[971489.479895144,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-9d6a89dc13ca448fa0330735","runtime":{"accepted":201,"cached":13,"decode_s":10.016,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1927,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971479.23767089,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21870376996230334,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.454656421822698,"done":971489.493773195,"finish_reason":"length","first":971479.457751048,"full_response_s":10.255699457949959,"last":971489.475564519,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971479.457751048,2],[971479.629458182,7],[971479.778589888,4],[971480.00392289,53],[971480.198175135,47],[971480.382472237,30],[971480.533879572,15],[971480.71643216,14],[971480.86513387,20],[971481.053924011,14],[971481.24283462,4],[971481.390875355,13],[971481.574144184,21],[971481.757426053,2],[971481.942276134,18],[971482.136964788,29],[971482.373468438,27],[971482.560159608,15],[971482.713678141,11],[971482.897623091,18],[971483.090383503,10],[971483.274801905,31],[971483.424552144,8],[971483.609596586,11],[971483.761027448,16],[971483.908204272,12],[971484.102099403,39],[971484.280611782,18],[971484.464228208,11],[971484.625662427,16],[971484.809123647,16],[971484.955745944,11],[971485.154056812,6],[971485.336031982,9],[971485.518808686,29],[971485.705521761,22],[971485.895370549,8],[971486.046524766,18],[971486.240223035,18],[971486.422831498,34],[971486.613136136,10],[971486.797300786,14],[971486.983379816,13],[971487.182257131,2],[971487.365277407,36],[971487.551245377,42],[971487.738023537,26],[971487.892404277,17],[971488.087733721,34],[971488.274442491,12],[971488.457451845,36],[971488.749375538,50],[971488.939237203,2],[971489.234972685,54],[971489.475564519,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-6a5201e8f6e64493a8d573a4","runtime":{"accepted":201,"cached":13,"decode_s":10.0162,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1927,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971479.238073737,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21967731101904064,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.458623573264898,"done":971489.49374433,"finish_reason":"length","first":971479.456657439,"full_response_s":10.25643615797162,"last":971489.47290986,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971479.456657439,2],[971479.630070653,7],[971479.777595067,4],[971480.002727229,53],[971480.197335919,47],[971480.382571457,30],[971480.533584025,15],[971480.717269264,14],[971480.866742491,20],[971481.05352718,14],[971481.245158451,4],[971481.393440092,13],[971481.57511198,21],[971481.757606732,2],[971481.941661679,18],[971482.13727232,29],[971482.373804386,27],[971482.561226432,15],[971482.712872031,11],[971482.896498265,18],[971483.089333223,10],[971483.272120221,31],[971483.424977088,8],[971483.60852205,11],[971483.757445361,16],[971483.908519756,12],[971484.10238919,39],[971484.279450346,18],[971484.463107158,11],[971484.623115148,16],[971484.805935992,16],[971484.957339443,11],[971485.153333729,6],[971485.336587379,9],[971485.518293627,29],[971485.706320191,22],[971485.892112939,8],[971486.045388371,18],[971486.239688279,18],[971486.422026476,34],[971486.61322246,10],[971486.796470723,14],[971486.987903601,13],[971487.188070516,2],[971487.365873541,36],[971487.551675985,42],[971487.7378899,26],[971487.889948938,17],[971488.084626741,34],[971488.272060035,12],[971488.458166847,36],[971488.747407977,50],[971488.938034198,2],[971489.235981426,54],[971489.47290986,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-767f4e6067f5422f9335aaae","runtime":{"accepted":201,"cached":13,"decode_s":10.016,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1927,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971479.237308172,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21934926696121693,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.46173352244677,"done":971489.492368487,"finish_reason":"length","first":971479.457806634,"full_response_s":10.25499173591379,"last":971489.472835649,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971479.457806634,2],[971479.632783876,7],[971479.776992516,4],[971480.002980198,53],[971480.201405881,47],[971480.38325073,30],[971480.532000109,15],[971480.715928845,14],[971480.867039366,20],[971481.055027908,14],[971481.243716829,4],[971481.392540298,13],[971481.574200394,21],[971481.757747361,2],[971481.941209214,18],[971482.138012668,29],[971482.372434911,27],[971482.55979337,15],[971482.713422563,11],[971482.899262737,18],[971483.091358307,10],[971483.272048522,31],[971483.424458796,8],[971483.608216966,11],[971483.761090858,16],[971483.910754896,12],[971484.102460825,39],[971484.279971982,18],[971484.466278476,11],[971484.623861816,16],[971484.804818894,16],[971484.956471491,11],[971485.153551289,6],[971485.336113329,9],[971485.518698938,29],[971485.706030852,22],[971485.891130455,8],[971486.045267295,18],[971486.237861987,18],[971486.423988357,34],[971486.613959079,10],[971486.796045891,14],[971486.984052401,13],[971487.182329022,2],[971487.365737616,36],[971487.55117179,42],[971487.737681876,26],[971487.890023469,17],[971488.084804604,34],[971488.27257447,12],[971488.457867604,36],[971488.747294773,50],[971488.937442784,2],[971489.233181306,54],[971489.472835649,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-3b6e9c3aff2042929e29830a","runtime":{"accepted":201,"cached":13,"decode_s":10.0161,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1927,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971479.237376751,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.22042988298926502,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.455515646575215,"done":971489.491991897,"finish_reason":"length","first":971479.458228426,"full_response_s":10.254281245986931,"last":971489.475703756,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971479.458228426,2],[971479.629930616,7],[971479.777636748,4],[971480.002882243,53],[971480.199738922,47],[971480.381627725,30],[971480.532149107,15],[971480.71578212,14],[971480.865537326,20],[971481.052970247,14],[971481.243544838,4],[971481.390450555,13],[971481.573208341,21],[971481.757082616,2],[971481.941095145,18],[971482.137925785,29],[971482.37316145,27],[971482.56031835,15],[971482.713723727,11],[971482.897825179,18],[971483.090509811,10],[971483.273614581,31],[971483.423473752,8],[971483.60793678,11],[971483.759973216,16],[971483.908692099,12],[971484.102980956,39],[971484.280783388,18],[971484.463689371,11],[971484.624869501,16],[971484.804669353,16],[971484.955885085,11],[971485.155177206,6],[971485.335708034,9],[971485.519208717,29],[971485.704722915,22],[971485.893439901,8],[971486.046650851,18],[971486.240365616,18],[971486.422615634,34],[971486.612801852,10],[971486.795559937,14],[971486.982855445,13],[971487.186158573,2],[971487.366687028,36],[971487.550912197,42],[971487.737624946,26],[971487.89059093,17],[971488.0844968,34],[971488.272816847,12],[971488.457801618,36],[971488.749290015,50],[971488.937766092,2],[971489.233094455,54],[971489.475703756,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-58b70378f5ce46a3844cee5f","runtime":{"accepted":201,"cached":13,"decode_s":10.0161,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1927,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971479.237710651,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.22051777504384518,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.459879092884155,"done":971489.493650871,"finish_reason":"length","first":971479.456769107,"full_response_s":10.256208710023202,"last":971489.47252759,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971479.456769107,2],[971479.628839551,7],[971479.776913201,4],[971480.00376562,53],[971480.197406274,47],[971480.381980266,30],[971480.531611535,15],[971480.715852906,14],[971480.865880763,20],[971481.053065162,14],[971481.244282994,4],[971481.390309206,13],[971481.575250834,21],[971481.756503874,2],[971481.943167751,18],[971482.137348211,29],[971482.372624838,27],[971482.560020723,15],[971482.714928444,11],[971482.898567639,18],[971483.092149297,10],[971483.273714456,31],[971483.42365755,8],[971483.608977875,11],[971483.759669669,16],[971483.907879668,12],[971484.10510926,39],[971484.279719012,18],[971484.464584973,11],[971484.62541957,16],[971484.805327169,16],[971484.957242064,11],[971485.155546212,6],[971485.337904932,9],[971485.51804261,29],[971485.707025209,22],[971485.89105506,8],[971486.046076493,18],[971486.238233921,18],[971486.422420747,34],[971486.612659687,10],[971486.795784153,14],[971486.982148058,13],[971487.187681141,2],[971487.36460415,36],[971487.551739027,42],[971487.739020294,26],[971487.889846774,17],[971488.085678876,34],[971488.272736572,12],[971488.456925681,36],[971488.746936967,50],[971488.937239768,2],[971489.232711769,54],[971489.47252759,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-2119eb617dd341ebb49c01e1","runtime":{"accepted":201,"cached":13,"decode_s":10.0159,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1927,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971479.237442161,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21932694606948644,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.459321884740802,"done":971489.492884778,"finish_reason":"length","first":971479.45709816,"full_response_s":10.255141709931195,"last":971489.47307585,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971479.45709816,2],[971479.629373795,7],[971479.7781532,4],[971480.002811392,53],[971480.198351125,47],[971480.384837542,30],[971480.53149425,15],[971480.718181922,14],[971480.868564607,20],[971481.054965042,14],[971481.2454972,4],[971481.391091155,13],[971481.57409167,21],[971481.759278171,2],[971481.942570065,18],[971482.138229508,29],[971482.373888821,27],[971482.560612137,15],[971482.713781281,11],[971482.896639599,18],[971483.090450993,10],[971483.276633174,31],[971483.425203336,8],[971483.608718217,11],[971483.76199742,16],[971483.907396738,12],[971484.104821105,39],[971484.282451211,18],[971484.465881422,11],[971484.626462409,16],[971484.804727195,16],[971484.95522906,11],[971485.153633981,6],[971485.335233648,9],[971485.518464097,29],[971485.705221974,22],[971485.891092453,8],[971486.045836612,18],[971486.238395623,18],[971486.42453321,34],[971486.614207696,10],[971486.795941455,14],[971486.983224371,13],[971487.186263841,2],[971487.365799459,36],[971487.551091627,42],[971487.73773863,26],[971487.890305671,17],[971488.085897652,34],[971488.272863809,12],[971488.458086572,36],[971488.747739317,50],[971488.939386536,2],[971489.233568441,54],[971489.47307585,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-9edb355eed36486e94e6c920","runtime":{"accepted":201,"cached":13,"decode_s":10.0161,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1927,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971479.237743068,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21935509203467518,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":1,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.45873988833631,"done":971489.49332209,"finish_reason":"length","first":971479.457695734,"full_response_s":10.25641644501593,"last":971489.473902393,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971479.457695734,2],[971479.632877175,7],[971479.776494657,4],[971480.003379893,53],[971480.198017145,47],[971480.383564006,30],[971480.534307364,15],[971480.71556464,14],[971480.867435221,20],[971481.054889839,14],[971481.243935477,4],[971481.390823465,13],[971481.574801457,21],[971481.759208808,2],[971481.941788979,18],[971482.137855558,29],[971482.375514738,27],[971482.561067386,15],[971482.713150185,11],[971482.897980657,18],[971483.089596977,10],[971483.273066832,31],[971483.425749805,8],[971483.608468912,11],[971483.758679344,16],[971483.908134318,12],[971484.101261932,39],[971484.279901227,18],[971484.463904116,11],[971484.624111025,16],[971484.808998731,16],[971484.955102,11],[971485.15426794,6],[971485.33554278,9],[971485.523555216,29],[971485.705395373,22],[971485.892758227,8],[971486.045961993,18],[971486.239271831,18],[971486.424266304,34],[971486.612120643,10],[971486.796656474,14],[971486.982967625,13],[971487.186992604,2],[971487.365981609,36],[971487.553282557,42],[971487.738086515,26],[971487.890258853,17],[971488.084401725,34],[971488.272960756,12],[971488.456770379,36],[971488.749142649,50],[971488.937974292,2],[971489.233504742,54],[971489.473902393,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-5a4c5cdfbccb4572bedba6da","runtime":{"accepted":201,"cached":13,"decode_s":10.016,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1927,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971479.236905645,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.22079008899163455,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.301974581609887,"done":971499.808879099,"finish_reason":"length","first":971489.71736675,"full_response_s":10.305728530976921,"last":971499.795631558,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971489.71736675,2],[971489.886986647,7],[971490.03374561,4],[971490.271882795,53],[971490.457322906,47],[971490.644206045,30],[971490.792465129,15],[971490.974841148,14],[971491.133520401,20],[971491.319051256,14],[971491.50583699,4],[971491.653896969,13],[971491.837764641,21],[971492.029484579,2],[971492.223727185,18],[971492.409092424,29],[971492.649557604,27],[971492.835953087,15],[971492.98928438,11],[971493.186068478,18],[971493.369644392,10],[971493.554636262,31],[971493.706988991,8],[971493.89259624,11],[971494.04549538,16],[971494.207013191,12],[971494.435795497,39],[971494.597062242,18],[971494.783292387,11],[971494.934519987,16],[971495.129737349,16],[971495.276924191,11],[971495.463932114,6],[971495.650324943,9],[971495.834626381,29],[971496.024394732,22],[971496.218662912,8],[971496.366419254,18],[971496.556032607,18],[971496.739716702,34],[971496.927622977,10],[971497.123783231,14],[971497.313281513,13],[971497.497067777,2],[971497.687110463,36],[971497.872220068,42],[971498.063420002,26],[971498.225825952,17],[971498.404073331,34],[971498.595428422,12],[971498.781346419,36],[971499.076806989,50],[971499.270390151,2],[971499.556478281,54],[971499.795631558,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-dce58ac580c943749b58ff3a","runtime":{"accepted":201,"cached":13,"decode_s":10.0786,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1916,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971489.503150568,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21421618200838566,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.300806080535278,"done":971499.810546584,"finish_reason":"length","first":971489.716638243,"full_response_s":10.309543039998971,"last":971499.795368509,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971489.716638243,2],[971489.886233435,7],[971490.035040506,4],[971490.269750188,53],[971490.460785274,47],[971490.647663006,30],[971490.792859191,15],[971490.975868674,14],[971491.134332511,20],[971491.318188424,14],[971491.506319199,4],[971491.65489259,13],[971491.837931367,21],[971492.029204408,2],[971492.223576364,18],[971492.40943234,29],[971492.648814696,27],[971492.836786238,15],[971492.987212832,11],[971493.187333325,18],[971493.36958823,10],[971493.553390936,31],[971493.705840325,8],[971493.892401816,11],[971494.046927913,16],[971494.208517198,12],[971494.435944526,39],[971494.59740123,18],[971494.783234049,11],[971494.933865019,16],[971495.133868493,16],[971495.27739704,11],[971495.463864304,6],[971495.650859923,9],[971495.833925764,29],[971496.023199088,22],[971496.217736846,8],[971496.36838715,18],[971496.553980291,18],[971496.740903433,34],[971496.929641003,10],[971497.122988354,14],[971497.311657517,13],[971497.498641259,2],[971497.685725452,36],[971497.872550272,42],[971498.064551819,26],[971498.223651361,17],[971498.40442512,34],[971498.594991686,12],[971498.779851212,36],[971499.075658931,50],[971499.271342506,2],[971499.5559922,54],[971499.795368509,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-40539b01602e454292a9991c","runtime":{"accepted":201,"cached":13,"decode_s":10.0784,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1916,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971489.501003544,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21563469897955656,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.302505079510883,"done":971499.811341989,"finish_reason":"length","first":971489.716867035,"full_response_s":10.308901463984512,"last":971499.79492054,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971489.716867035,2],[971489.887667264,7],[971490.03299547,4],[971490.269839391,53],[971490.457038239,47],[971490.643063763,30],[971490.794012834,15],[971490.975069748,14],[971491.135067354,20],[971491.320990736,14],[971491.505724761,4],[971491.655862706,13],[971491.837875349,21],[971492.031594049,2],[971492.226554666,18],[971492.409655501,29],[971492.650232829,27],[971492.834914457,15],[971492.991044525,11],[971493.18857169,18],[971493.369456833,10],[971493.554213798,31],[971493.70759399,8],[971493.895042202,11],[971494.044816811,16],[971494.208232227,12],[971494.436774477,39],[971494.598794898,18],[971494.783116333,11],[971494.933935902,16],[971495.131755295,16],[971495.276347145,11],[971495.464063975,6],[971495.650171849,9],[971495.834194638,29],[971496.023069867,22],[971496.218497194,8],[971496.367599601,18],[971496.554954855,18],[971496.744417434,34],[971496.92950975,10],[971497.122447102,14],[971497.314284862,13],[971497.497520322,2],[971497.686138491,36],[971497.872768344,42],[971498.064290194,26],[971498.225703548,17],[971498.403946751,34],[971498.595543163,12],[971498.781414005,36],[971499.07703743,50],[971499.270442953,2],[971499.555917669,54],[971499.79492054,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-ef413178eaf4403b9bb508b6","runtime":{"accepted":201,"cached":13,"decode_s":10.0785,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1916,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971489.502440525,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21442651003599167,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.30290262497422,"done":971499.811144302,"finish_reason":"length","first":971489.716902796,"full_response_s":10.310071812011302,"last":971499.79479796,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971489.716902796,2],[971489.885371243,7],[971490.033373036,4],[971490.270248383,53],[971490.458051509,47],[971490.644578331,30],[971490.792791653,15],[971490.975766462,14],[971491.134016515,20],[971491.318862865,14],[971491.505176837,4],[971491.655474899,13],[971491.8374077,21],[971492.028690373,2],[971492.223502537,18],[971492.410874682,29],[971492.648610113,27],[971492.835792857,15],[971492.988989761,11],[971493.187120037,18],[971493.371722501,10],[971493.553919404,31],[971493.707718842,8],[971493.893949425,11],[971494.045277804,16],[971494.210052327,12],[971494.43734405,39],[971494.598596922,18],[971494.782972807,11],[971494.933644531,16],[971495.130678295,16],[971495.279410362,11],[971495.463708794,6],[971495.650548839,9],[971495.834521882,29],[971496.022999177,22],[971496.21872485,8],[971496.367238788,18],[971496.554532728,18],[971496.740146941,34],[971496.928641158,10],[971497.123556583,14],[971497.313571796,13],[971497.498608826,2],[971497.685574471,36],[971497.870958086,42],[971498.063882115,26],[971498.223943371,17],[971498.404601351,34],[971498.595937961,12],[971498.781180284,36],[971499.077617243,50],[971499.270239234,2],[971499.555761135,54],[971499.79479796,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-59630dcb648e44a5b407df0c","runtime":{"accepted":201,"cached":13,"decode_s":10.0785,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1916,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971489.50107249,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2158303059404716,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.300124191728624,"done":971499.809683688,"finish_reason":"length","first":971489.716736278,"full_response_s":10.308151404955424,"last":971499.795738186,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971489.716736278,2],[971489.88675083,7],[971490.033178341,4],[971490.270858421,53],[971490.458821057,47],[971490.64804614,30],[971490.792368885,15],[971490.974689542,14],[971491.135658144,20],[971491.319168604,14],[971491.505463088,4],[971491.654449069,13],[971491.838869818,21],[971492.030678639,2],[971492.22504957,18],[971492.410157279,29],[971492.649096931,27],[971492.835317464,15],[971492.991374361,11],[971493.186349832,18],[971493.369789485,10],[971493.555422995,31],[971493.709232642,8],[971493.891289135,11],[971494.045132391,16],[971494.207086217,12],[971494.436240809,39],[971494.598984473,18],[971494.783358518,11],[971494.933386713,16],[971495.12994206,16],[971495.277471459,11],[971495.463774268,6],[971495.652688774,9],[971495.834431254,29],[971496.023594302,22],[971496.218876504,8],[971496.367393626,18],[971496.55422862,18],[971496.740726371,34],[971496.926986009,10],[971497.125010972,14],[971497.310899698,13],[971497.496792903,2],[971497.686661151,36],[971497.872927838,42],[971498.06423336,26],[971498.224694263,17],[971498.405559434,34],[971498.595135036,12],[971498.780669274,36],[971499.075254164,50],[971499.271221878,2],[971499.557854412,54],[971499.795738186,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-c1409f25f56447e3978b9832","runtime":{"accepted":201,"cached":13,"decode_s":10.0785,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1916,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971489.501532283,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21520399500150234,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.297973169221134,"done":971499.812418012,"finish_reason":"length","first":971489.716470652,"full_response_s":10.311084951972589,"last":971499.796329552,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971489.716470652,2],[971489.887113339,7],[971490.034048693,4],[971490.27153635,53],[971490.45750248,47],[971490.647746993,30],[971490.792234304,15],[971490.974537633,14],[971491.136523792,20],[971491.319318274,14],[971491.505072289,4],[971491.653788469,13],[971491.837207996,21],[971492.028823658,2],[971492.223394165,18],[971492.408766828,29],[971492.649902241,27],[971492.837155835,15],[971492.987909098,11],[971493.187575446,18],[971493.370427381,10],[971493.55513524,31],[971493.707283818,8],[971493.892268003,11],[971494.045670427,16],[971494.207912536,12],[971494.436469953,39],[971494.597975075,18],[971494.785348223,11],[971494.932138091,16],[971495.130950721,16],[971495.277897346,11],[971495.465701363,6],[971495.650465236,9],[971495.83502598,29],[971496.024509024,22],[971496.218939738,8],[971496.366183469,18],[971496.555570222,18],[971496.743056456,34],[971496.927959885,10],[971497.126391599,14],[971497.313763867,13],[971497.498863203,2],[971497.687306134,36],[971497.873132854,42],[971498.064608445,26],[971498.222765616,17],[971498.404661705,34],[971498.596536735,12],[971498.783853214,36],[971499.075823305,50],[971499.269815714,2],[971499.556142013,54],[971499.796329552,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-cc85c5296eab44fa9d361722","runtime":{"accepted":201,"cached":13,"decode_s":10.0786,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1916,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971489.50133306,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21513759205117822,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.30323012421947,"done":971499.812911534,"finish_reason":"length","first":971489.717665881,"full_response_s":10.31125162995886,"last":971499.795430607,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971489.717665881,2],[971489.884660256,7],[971490.033858526,4],[971490.271813593,53],[971490.456912602,47],[971490.643859505,30],[971490.791929365,15],[971490.974602915,14],[971491.135742675,20],[971491.318674234,14],[971491.508617861,4],[971491.654263927,13],[971491.837487751,21],[971492.029550181,2],[971492.2238049,18],[971492.414203541,29],[971492.654332516,27],[971492.835735095,15],[971492.988520768,11],[971493.186270741,18],[971493.372051825,10],[971493.554027216,31],[971493.708023909,8],[971493.891620892,11],[971494.047599954,16],[971494.208449515,12],[971494.436522355,39],[971494.597891088,18],[971494.784200421,11],[971494.932569051,16],[971495.133710823,16],[971495.276671221,11],[971495.464379282,6],[971495.650093398,9],[971495.834740546,29],[971496.022869124,22],[971496.218379221,8],[971496.366978043,18],[971496.556191429,18],[971496.741239045,34],[971496.926822211,10],[971497.125673012,14],[971497.311593259,13],[971497.497601253,2],[971497.686195325,36],[971497.872458829,42],[971498.065339224,26],[971498.22477553,17],[971498.404855328,34],[971498.596901676,12],[971498.781109226,36],[971499.075521326,50],[971499.269985256,2],[971499.557528304,54],[971499.795430607,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-a8cc1e6e06214b738e68ddd0","runtime":{"accepted":201,"cached":13,"decode_s":10.0786,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1916,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971489.501659904,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2160059770103544,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.304381249376622,"done":971499.809148997,"finish_reason":"length","first":971489.718502488,"full_response_s":10.307897939928807,"last":971499.795808765,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971489.718502488,2],[971489.885508032,7],[971490.03411676,4],[971490.26990029,53],[971490.458549895,47],[971490.643661689,30],[971490.792741059,15],[971490.976028664,14],[971491.134225563,20],[971491.320260373,14],[971491.50618193,4],[971491.65419498,13],[971491.838046348,21],[971492.029621224,2],[971492.225657481,18],[971492.40948647,29],[971492.650086359,27],[971492.837362803,15],[971492.987315508,11],[971493.185315618,18],[971493.370036838,10],[971493.553324198,31],[971493.706580848,8],[971493.891210316,11],[971494.047739799,16],[971494.206835104,12],[971494.435676404,39],[971494.59815009,18],[971494.781751642,11],[971494.932501177,16],[971495.132683185,16],[971495.280455408,11],[971495.466773627,6],[971495.650822033,9],[971495.834780195,29],[971496.022794817,22],[971496.219921934,8],[971496.367052829,18],[971496.555190528,18],[971496.741024686,34],[971496.927917452,10],[971497.122591011,14],[971497.313375132,13],[971497.499017321,2],[971497.685450866,36],[971497.871155821,42],[971498.064137916,26],[971498.224421309,17],[971498.406182017,34],[971498.595265024,12],[971498.782831193,36],[971499.077438148,50],[971499.270999357,2],[971499.557285703,54],[971499.795808765,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-4d4aa9ecd2fe41aebfafda82","runtime":{"accepted":201,"cached":13,"decode_s":10.0785,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1916,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971489.501251057,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21725143096409738,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.301783008323437,"done":971499.812256279,"finish_reason":"length","first":971489.717621063,"full_response_s":10.310508868074976,"last":971499.795962179,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971489.717621063,2],[971489.885308952,7],[971490.033067521,4],[971490.269984869,53],[971490.461430386,47],[971490.645532319,30],[971490.793604115,15],[971490.975260619,14],[971491.133758698,20],[971491.319697168,14],[971491.506382114,4],[971491.654628116,13],[971491.838267204,21],[971492.030095081,2],[971492.224055341,18],[971492.411389821,29],[971492.648507165,27],[971492.835145617,15],[971492.988286215,11],[971493.186531839,18],[971493.369514195,10],[971493.554524434,31],[971493.707068498,8],[971493.895107164,11],[971494.045065508,16],[971494.207740657,12],[971494.437519016,39],[971494.599399448,18],[971494.78224094,11],[971494.934081187,16],[971495.130093666,16],[971495.276730983,11],[971495.464185883,6],[971495.649543634,9],[971495.834078121,29],[971496.024853773,22],[971496.218226976,8],[971496.370677442,18],[971496.555521756,18],[971496.742310829,34],[971496.927281828,10],[971497.12455662,14],[971497.31242633,13],[971497.496920188,2],[971497.686562907,36],[971497.872671749,42],[971498.063709708,26],[971498.223146718,17],[971498.405393604,34],[971498.596358921,12],[971498.780571622,36],[971499.07540609,50],[971499.271482111,2],[971499.556090843,54],[971499.795962179,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-894328a915ec47659f7fd696","runtime":{"accepted":201,"cached":13,"decode_s":10.0784,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1916,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971489.501747411,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21587365202140063,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.301691179088202,"done":971499.810847395,"finish_reason":"length","first":971489.716928205,"full_response_s":10.309666389017366,"last":971499.795305899,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971489.716928205,2],[971489.886158104,7],[971490.032895227,4],[971490.271927517,53],[971490.461309885,47],[971490.64411785,30],[971490.794541302,15],[971490.975501908,14],[971491.134949174,20],[971491.318916067,14],[971491.507508875,4],[971491.654079296,13],[971491.837816387,21],[971492.029429185,2],[971492.224865003,18],[971492.409051766,29],[971492.649436639,27],[971492.837920056,15],[971492.990646127,11],[971493.188088024,18],[971493.369162358,10],[971493.553203409,31],[971493.705933432,8],[971493.89168083,11],[971494.046066185,16],[971494.207180301,12],[971494.436115396,39],[971494.597471617,18],[971494.785049508,11],[971494.933323159,16],[971495.130277097,16],[971495.278066425,11],[971495.465038091,6],[971495.649390285,9],[971495.834359652,29],[971496.023834151,22],[971496.218589613,8],[971496.370188737,18],[971496.554695214,18],[971496.739948518,34],[971496.926422853,10],[971497.125514911,14],[971497.312073085,13],[971497.4985542,2],[971497.686045864,36],[971497.872374986,42],[971498.065465277,26],[971498.225279516,17],[971498.404319052,34],[971498.597036561,12],[971498.780456722,36],[971499.075865563,50],[971499.271759561,2],[971499.556238209,54],[971499.795305899,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-6c047ee1a58e4274beb8aa65","runtime":{"accepted":201,"cached":13,"decode_s":10.0785,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1916,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971489.501181006,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2157471990212798,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.304173167271266,"done":971499.812119121,"finish_reason":"length","first":971489.717308859,"full_response_s":10.310669416910969,"last":971499.794698004,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971489.717308859,2],[971489.886867282,7],[971490.033255256,4],[971490.27040658,53],[971490.456612255,47],[971490.644504184,30],[971490.792050969,15],[971490.978443889,14],[971491.134458547,20],[971491.320372153,14],[971491.505624598,4],[971491.655381536,13],[971491.838463099,21],[971492.030513721,2],[971492.22683234,18],[971492.409737632,29],[971492.651054411,27],[971492.836690074,15],[971492.987417671,11],[971493.185943881,18],[971493.369715354,10],[971493.554391613,31],[971493.706064861,8],[971493.893165108,11],[971494.046505801,16],[971494.206704507,12],[971494.436719995,39],[971494.598675997,18],[971494.782349168,11],[971494.932384804,16],[971495.130465168,16],[971495.27821579,11],[971495.46425619,6],[971495.65023886,9],[971495.835490237,29],[971496.024651429,22],[971496.220571494,8],[971496.366483032,18],[971496.555245666,18],[971496.742361311,34],[971496.92755571,10],[971497.123463331,14],[971497.31193548,13],[971497.499155678,2],[971497.687251124,36],[971497.873648761,42],[971498.063614441,26],[971498.22375474,17],[971498.40508636,34],[971498.597593782,12],[971498.780012338,36],[971499.076137669,50],[971499.270058027,2],[971499.555847138,54],[971499.794698004,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-0b7e250123b4449daf00d73d","runtime":{"accepted":201,"cached":13,"decode_s":10.0785,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1916,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971489.501449704,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21585915493778884,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.30607285001428,"done":971499.812043359,"finish_reason":"length","first":971489.717804238,"full_response_s":10.310007984982803,"last":971499.794436891,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971489.717804238,2],[971489.885539041,7],[971490.034166026,4],[971490.2696314,53],[971490.457256647,47],[971490.643932899,30],[971490.79266584,15],[971490.975131735,14],[971491.133708216,20],[971491.321147638,14],[971491.504755622,4],[971491.654523424,13],[971491.837345442,21],[971492.029346062,2],[971492.224266325,18],[971492.410413225,29],[971492.649176758,27],[971492.836188648,15],[971492.987775557,11],[971493.189801512,18],[971493.369282586,10],[971493.553829336,31],[971493.706644562,8],[971493.893062785,11],[971494.046446359,16],[971494.207340147,12],[971494.436187223,39],[971494.597561332,18],[971494.782484501,11],[971494.932674319,16],[971495.13189346,16],[971495.277817391,11],[971495.464725055,6],[971495.649642182,9],[971495.834294673,29],[971496.02370445,22],[971496.218310995,8],[971496.367320071,18],[971496.555115037,18],[971496.741320696,34],[971496.928738778,10],[971497.125091823,14],[971497.313018655,13],[971497.497961522,2],[971497.685961477,36],[971497.872607522,42],[971498.06353799,26],[971498.222867988,17],[971498.405281968,34],[971498.596699397,12],[971498.781050072,36],[971499.074997659,50],[971499.271086753,2],[971499.555635818,54],[971499.794436891,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-adf52cade6364eaa88535a74","runtime":{"accepted":201,"cached":13,"decode_s":10.0785,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1916,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971489.502035374,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2157688639126718,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.30525334124846,"done":971499.810331312,"finish_reason":"length","first":971489.719171345,"full_response_s":10.308533339062706,"last":971499.796130329,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971489.719171345,2],[971489.884896393,7],[971490.034477909,4],[971490.273236461,53],[971490.457565171,47],[971490.645457148,30],[971490.792609438,15],[971490.977052158,14],[971491.133636325,20],[971491.3210981,14],[971491.506223852,4],[971491.654568866,13],[971491.837986473,21],[971492.029825823,2],[971492.22462125,18],[971492.410576927,29],[971492.650724543,27],[971492.835037885,15],[971492.989069572,11],[971493.188482887,18],[971493.37068923,10],[971493.555834514,31],[971493.707130996,8],[971493.892013194,11],[971494.045199417,16],[971494.207540554,12],[971494.435987264,39],[971494.599806855,18],[971494.783033226,11],[971494.9332453,16],[971495.130360092,16],[971495.276819147,11],[971495.46359439,6],[971495.650892148,9],[971495.836150886,29],[971496.023768181,22],[971496.219212788,8],[971496.367950142,18],[971496.5547728,18],[971496.741800426,34],[971496.926281904,10],[971497.122933392,14],[971497.311246462,13],[971497.498499526,2],[971497.687837226,36],[971497.872823434,42],[971498.066384462,26],[971498.222940407,17],[971498.40469897,34],[971498.597883088,12],[971498.781244943,36],[971499.07667932,50],[971499.274054765,2],[971499.559137835,54],[971499.796130329,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-91dd19db9c064b40a4841cd2","runtime":{"accepted":201,"cached":13,"decode_s":10.0784,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1916,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971489.501797973,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21737337205559015,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.297105155022464,"done":971499.80943912,"finish_reason":"length","first":971489.716829434,"full_response_s":10.307609208975919,"last":971499.797034202,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971489.716829434,2],[971489.884798389,7],[971490.032827576,4],[971490.270320161,53],[971490.457809868,47],[971490.644770242,30],[971490.793252422,15],[971490.975935877,14],[971491.134068805,20],[971491.319246303,14],[971491.505924001,4],[971491.654697943,13],[971491.838212674,21],[971492.029689498,2],[971492.224702869,18],[971492.411327851,29],[971492.649252569,27],[971492.835202819,15],[971492.988875821,11],[971493.185707185,18],[971493.371643074,10],[971493.556306116,31],[971493.706380265,8],[971493.89194372,11],[971494.046364292,16],[971494.207835525,12],[971494.435606114,39],[971494.598868052,18],[971494.783453337,11],[971494.932330626,16],[971495.132061978,16],[971495.279019516,11],[971495.464645164,6],[971495.650010723,9],[971495.833862177,29],[971496.024105281,22],[971496.220500179,8],[971496.366336883,18],[971496.554360001,18],[971496.740335972,34],[971496.92662734,10],[971497.123362912,14],[971497.312707956,13],[971497.498399842,2],[971497.687646563,36],[971497.873407824,42],[971498.06408113,26],[971498.226482168,17],[971498.403557392,34],[971498.595723729,12],[971498.78241465,36],[971499.075164977,50],[971499.272108166,2],[971499.556996764,54],[971499.797034202,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-e76f5cb952d64faf904d9169","runtime":{"accepted":201,"cached":13,"decode_s":10.0785,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1916,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971489.501829911,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21499952301383018,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.30181229329285,"done":971499.812963584,"finish_reason":"length","first":971489.716533455,"full_response_s":10.31106226297561,"last":971499.794862906,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971489.716533455,2],[971489.885674278,7],[971490.03260632,4],[971490.272420799,53],[971490.461037523,47],[971490.642975872,30],[971490.794617545,15],[971490.974320057,14],[971491.135901817,20],[971491.318593303,14],[971491.506786977,4],[971491.654776922,13],[971491.83832167,21],[971492.029893858,2],[971492.226427701,18],[971492.409224125,29],[971492.649675272,27],[971492.835088319,15],[971492.98748169,11],[971493.186436779,18],[971493.370142314,10],[971493.555692253,31],[971493.705759762,8],[971493.891126409,11],[971494.044474239,16],[971494.20742951,12],[971494.435754823,39],[971494.597655224,18],[971494.784497552,11],[971494.935802706,16],[971495.134355663,16],[971495.277233418,11],[971495.465432329,6],[971495.650751903,9],[971495.834920536,29],[971496.023153902,22],[971496.218803669,8],[971496.367121392,18],[971496.554869956,18],[971496.741167107,34],[971496.926706495,10],[971497.122804491,14],[971497.311087464,13],[971497.498948566,2],[971497.686885351,36],[971497.872719847,42],[971498.064913945,26],[971498.224185956,17],[971498.40381017,34],[971498.59520547,12],[971498.779538304,36],[971499.076213175,50],[971499.273882439,2],[971499.556894185,54],[971499.794862906,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-e93abda25cda41c59bca0068","runtime":{"accepted":201,"cached":13,"decode_s":10.0785,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1916,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971489.501901321,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2146321339532733,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"code","streams":16,"burst":2,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":13,"case_id":null,"complete":true,"decode_tps":25.302770978076236,"done":971499.806774238,"finish_reason":"length","first":971489.716592225,"full_response_s":10.305844089016318,"last":971499.794539823,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971489.716592225,2],[971489.887376133,7],[971490.034780097,4],[971490.271715029,53],[971490.45874139,47],[971490.643591655,30],[971490.79255062,15],[971490.974462334,14],[971491.133419357,20],[971491.318350062,14],[971491.5074174,4],[971491.653982716,13],[971491.838677939,21],[971492.02893891,2],[971492.224127136,18],[971492.408870016,29],[971492.648372024,27],[971492.835860764,15],[971492.988802747,11],[971493.188791938,18],[971493.371290885,10],[971493.554309546,31],[971493.708735712,8],[971493.891495383,11],[971494.044582547,16],[971494.20693698,12],[971494.435536255,39],[971494.597265401,18],[971494.782117976,11],[971494.933181602,16],[971495.129874442,16],[971495.276604483,11],[971495.46480013,6],[971495.65096135,9],[971495.83762574,29],[971496.024919215,22],[971496.221722688,8],[971496.366908152,18],[971496.555053003,18],[971496.740080251,34],[971496.931335561,10],[971497.123915956,14],[971497.314488437,13],[971497.498812385,2],[971497.685661498,36],[971497.872317976,42],[971498.064823477,26],[971498.225163032,17],[971498.403671925,34],[971498.595329699,12],[971498.780301964,36],[971499.075590785,50],[971499.270129566,2],[971499.555486197,54],[971499.794539823,2]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-0544b683e81d4f02add322fa","runtime":{"accepted":201,"cached":13,"decode_s":10.0784,"drafted":343,"drafts":true,"min_rows":4,"prefill_s":0.1916,"rounds":54,"token_sha":"2b28aa2108de"},"seed":1234,"sent":971489.500930149,"speculative":{},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.21566207602154464,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":13},"total_tokens":270},"work":{"accepted":201,"drafted":343,"rounds":54},"work_source":"tensorfold","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":1,"burst":null,"stream":0,"phase":"warmup","request":{"cache_state":"cold","cached_tokens":0,"case_id":null,"complete":true,"decode_tps":59.076159677833616,"done":971500.19774228,"finish_reason":"length","first":971499.943069681,"full_response_s":0.37626993691083044,"last":971500.196979212,"output_sha256":"6bffe2c2436146ed3af0e8c4e21d88b3dddfbe4a47910e8940f3039340788c85","pieces":[[971499.943069681,3],[971500.025082869,26],[971500.112327864,15],[971500.196979212,30]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":16,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"c81230cadd07c8b22d2a507aa18b8b00964a157b29ba5c65c8fdf55148cf2238","response_id":"chatcmpl-f5a8836b7d8242eaab7a8e02","runtime":{"accepted":12,"cached":0,"decode_s":0.2538,"drafted":45,"drafts":true,"min_rows":16,"prefill_s":0.1157,"rounds":3,"token_sha":"a9100b9c265b"},"seed":1234,"sent":971499.821472343,"speculative":{},"token_sha":"a9100b9c265b","tokens":16,"ttft_s":0.12159733788575977,"usage":{"completion_tokens":16,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":0},"total_tokens":47},"work":{"accepted":12,"drafted":45,"rounds":3},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":1,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":50.243599125389714,"done":971505.396590742,"finish_reason":"length","first":971500.319671165,"full_response_s":5.190338440006599,"last":971505.394944522,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971500.319671165,3],[971500.401703026,26],[971500.482865654,15],[971500.56327128,34],[971500.646678678,21],[971500.727301687,25],[971500.807916296,14],[971500.88881075,14],[971500.971209388,18],[971501.052568611,26],[971501.139645707,13],[971501.22227528,13],[971501.302634163,13],[971501.383674479,23],[971501.465036518,32],[971501.545543487,7],[971501.626380403,23],[971501.707673,9],[971501.787622396,13],[971501.868548176,15],[971501.94921617,19],[971502.030089803,17],[971502.116743998,23],[971502.20096625,9],[971502.282609607,17],[971502.363366692,3],[971502.444779592,21],[971502.525164776,10],[971502.608683193,24],[971502.689698767,19],[971502.770196707,14],[971502.850595904,13],[971502.931943166,5],[971503.012146259,22],[971503.099181967,13],[971503.183427334,51],[971503.264638895,15],[971503.34534631,6],[971503.426723365,8],[971503.507205971,9],[971503.588891229,16],[971503.671666639,16],[971503.752278482,9],[971503.832725614,32],[971503.914616219,18],[971503.996659422,13],[971504.081372673,11],[971504.166912515,15],[971504.24810711,8],[971504.328603153,18],[971504.409664,25],[971504.484434858,19],[971504.565602029,8],[971504.648992705,40],[971504.731207946,16],[971504.813697964,64],[971504.894871579,6],[971504.97661227,6],[971505.059515483,11],[971505.146245555,15],[971505.230148196,17],[971505.312360393,21],[971505.394944522,14]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-65e4ec8cbcf84607962f62b3","runtime":{"accepted":193,"cached":30,"decode_s":5.0755,"drafted":930,"drafts":true,"min_rows":16,"prefill_s":0.1091,"rounds":62,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971500.206252302,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.11341886292211711,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":193,"drafted":930,"rounds":62},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":1,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":50.302361885157175,"done":971510.590148801,"finish_reason":"length","first":971505.519665107,"full_response_s":5.184694777941331,"last":971510.589009576,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971505.519665107,3],[971505.601090587,26],[971505.68282331,15],[971505.763074187,34],[971505.844125747,21],[971505.925511509,25],[971506.005737533,14],[971506.091504797,14],[971506.176494529,18],[971506.25753759,26],[971506.338161724,13],[971506.419200882,13],[971506.499676802,13],[971506.58232037,23],[971506.663344614,32],[971506.744239958,7],[971506.82447699,23],[971506.905538927,9],[971506.986667411,13],[971507.068991762,15],[971507.156472876,19],[971507.239219946,17],[971507.32028222,23],[971507.401674857,9],[971507.482372734,17],[971507.563368493,3],[971507.643448203,21],[971507.724748053,10],[971507.80520208,24],[971507.886191467,19],[971507.96729929,14],[971508.048566062,13],[971508.136114149,5],[971508.219683053,22],[971508.299695764,13],[971508.380451526,51],[971508.462671805,15],[971508.542715605,6],[971508.625786955,8],[971508.706402344,9],[971508.787135289,16],[971508.868320887,16],[971508.94965393,9],[971509.030435352,32],[971509.117927704,18],[971509.201887945,13],[971509.282521731,11],[971509.363234671,15],[971509.446209036,8],[971509.52840739,18],[971509.609562346,25],[971509.683369981,19],[971509.764258015,8],[971509.84509555,40],[971509.927136293,16],[971510.008144535,64],[971510.094195967,6],[971510.179422265,6],[971510.260637027,11],[971510.341657237,15],[971510.42317673,17],[971510.505359047,21],[971510.589009576,14]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-833ff1eee7a1409280343223","runtime":{"accepted":193,"cached":30,"decode_s":5.069,"drafted":930,"drafts":true,"min_rows":16,"prefill_s":0.1105,"rounds":62,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971505.405454023,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.11421108397189528,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":193,"drafted":930,"rounds":62},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":1,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":50.29466043996164,"done":971515.782482445,"finish_reason":"length","first":971510.711326792,"full_response_s":5.183799001039006,"last":971515.781447512,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971510.711326792,3],[971510.793433906,26],[971510.874558293,15],[971510.95615756,34],[971511.037438239,21],[971511.123944227,25],[971511.208357211,14],[971511.289536831,14],[971511.370129134,18],[971511.450986662,26],[971511.532143449,13],[971511.612268567,13],[971511.693304438,13],[971511.773787025,23],[971511.854867007,32],[971511.93615165,7],[971512.016871425,23],[971512.103085189,9],[971512.187865814,13],[971512.26957652,15],[971512.349888425,19],[971512.431665054,17],[971512.51198371,23],[971512.594398874,9],[971512.675363474,17],[971512.75567837,3],[971512.836610776,21],[971512.918715172,10],[971512.998981086,24],[971513.083164213,19],[971513.169462631,14],[971513.251385101,13],[971513.33171857,5],[971513.413753395,22],[971513.496386179,13],[971513.577172336,51],[971513.658091201,15],[971513.739248828,6],[971513.819660555,8],[971513.900796192,9],[971513.982063802,16],[971514.064790472,16],[971514.151766029,9],[971514.234526637,32],[971514.31561928,18],[971514.39710613,13],[971514.47816162,11],[971514.558964557,15],[971514.641556247,8],[971514.722308318,18],[971514.803329871,25],[971514.877548633,19],[971514.95924883,8],[971515.039733831,40],[971515.127661259,16],[971515.212166068,64],[971515.293279763,6],[971515.373877441,6],[971515.456560793,11],[971515.537714394,15],[971515.618999328,17],[971515.700511902,21],[971515.781447512,14]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-85adde08b621464ca0a3d91b","runtime":{"accepted":193,"cached":30,"decode_s":5.0699,"drafted":930,"drafts":true,"min_rows":16,"prefill_s":0.1093,"rounds":62,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971510.598683444,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.11264334805309772,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":193,"drafted":930,"rounds":62},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.98912075305298,"done":971529.456709356,"finish_reason":"length","first":971516.007089621,"full_response_s":13.663350491086021,"last":971529.435831442,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971516.007089621,3],[971516.153629197,11],[971516.332392721,30],[971516.514888283,19],[971516.666498455,21],[971516.849718057,15],[971517.000892109,19],[971517.166071749,17],[971517.312035568,6],[971517.460982646,11],[971517.611267307,5],[971517.7960459,27],[971517.982395755,12],[971518.176412267,13],[971518.355213437,5],[971518.506436571,16],[971518.69305338,5],[971518.881654575,16],[971519.069232959,7],[971519.223735978,22],[971519.373057068,10],[971519.560239199,7],[971519.743641787,23],[971519.898612945,5],[971520.045751055,9],[971520.23121665,14],[971520.378163153,20],[971520.525772591,8],[971520.67713637,12],[971520.826338407,5],[971520.978442541,14],[971521.136790015,11],[971521.287464785,7],[971521.43785913,9],[971521.586529653,8],[971521.764353817,3],[971521.951267766,10],[971522.112155721,11],[971522.297727476,9],[971522.47833856,10],[971522.667136781,20],[971522.817966493,14],[971523.008583456,14],[971523.244504161,13],[971523.394113038,5],[971523.568046069,14],[971523.799459511,11],[971524.036719452,32],[971524.233537727,33],[971524.383499904,11],[971524.571437707,6],[971524.723873172,8],[971524.877927873,9],[971525.027705396,13],[971525.189615586,8],[971525.340666577,20],[971525.490986263,17],[971525.641730444,20],[971525.795168719,13],[971525.943266528,2],[971526.103042218,16],[971526.291896305,6],[971526.442744273,15],[971526.594693705,8],[971526.783189331,15],[971526.969407701,16],[971527.211147392,21],[971527.495095427,10],[971527.637561717,8],[971527.787193395,25],[971527.939701519,18],[971528.097395679,13],[971528.290668444,55],[971528.440908039,11],[971528.635327741,10],[971528.783831596,11],[971528.935186407,15],[971529.091914813,17],[971529.251140987,14],[971529.435831442,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-53b177b52ce746d4a5b63853","runtime":{"accepted":176,"cached":30,"decode_s":13.4283,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1919,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971515.793358865,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2137307560769841,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":1,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.989612945514406,"done":971529.456255372,"finish_reason":"length","first":971516.007038019,"full_response_s":13.663906255038455,"last":971529.43543178,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971516.007038019,3],[971516.153071369,11],[971516.329414711,30],[971516.514349896,19],[971516.665877329,21],[971516.850049572,15],[971516.999046732,19],[971517.164019132,17],[971517.312208646,6],[971517.460323102,11],[971517.611398335,5],[971517.794748494,27],[971517.980993193,12],[971518.175444552,13],[971518.355630252,5],[971518.505371062,16],[971518.692536961,5],[971518.882685763,16],[971519.068498357,7],[971519.224098967,22],[971519.372749313,10],[971519.557759639,7],[971519.743839138,23],[971519.894876829,5],[971520.048932863,9],[971520.230955265,14],[971520.376907684,20],[971520.525662267,8],[971520.67606102,12],[971520.826153009,5],[971520.980776095,14],[971521.136281021,11],[971521.287966931,7],[971521.436577388,9],[971521.588260851,8],[971521.762380563,3],[971521.951601906,10],[971522.108506984,11],[971522.29839462,9],[971522.480453131,10],[971522.666864756,20],[971522.816790724,14],[971523.006319584,14],[971523.243153586,13],[971523.391609846,5],[971523.56432109,14],[971523.79489799,11],[971524.03876882,32],[971524.233468397,33],[971524.382591008,11],[971524.570643743,6],[971524.72194624,8],[971524.873072151,9],[971525.027288389,13],[971525.190271897,8],[971525.339129787,20],[971525.490695773,17],[971525.640452543,20],[971525.791789433,13],[971525.942366337,2],[971526.103196736,16],[971526.290562674,6],[971526.440875056,15],[971526.594219464,8],[971526.782974123,15],[971526.967508066,16],[971527.21264306,21],[971527.490562564,10],[971527.639574892,8],[971527.788829548,25],[971527.939307521,18],[971528.099289473,13],[971528.28786553,55],[971528.440235904,11],[971528.635863376,10],[971528.784947267,11],[971528.934618227,15],[971529.091675605,17],[971529.249630422,14],[971529.43543178,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-981e6c26a8ed4a388b5c0f57","runtime":{"accepted":176,"cached":30,"decode_s":13.4282,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1919,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971515.792349117,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21468890202231705,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":2,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.98523739358855,"done":971529.455995203,"finish_reason":"length","first":971516.007274652,"full_response_s":13.660237499978393,"last":971529.438763272,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971516.007274652,3],[971516.153396117,11],[971516.331130548,30],[971516.515423918,19],[971516.665998182,21],[971516.849219399,15],[971516.999811367,19],[971517.164151296,17],[971517.312676775,6],[971517.460511365,11],[971517.612958839,5],[971517.79583106,27],[971517.982564545,12],[971518.175868999,13],[971518.356832199,5],[971518.50627375,16],[971518.69626015,5],[971518.882436266,16],[971519.068098311,7],[971519.223810316,22],[971519.373397624,10],[971519.558953297,7],[971519.743965942,23],[971519.894685206,5],[971520.046413766,9],[971520.230763482,14],[971520.378095822,20],[971520.526222703,8],[971520.675964072,12],[971520.827397469,5],[971520.978845099,14],[971521.138388903,11],[971521.28862081,7],[971521.436791444,9],[971521.587362451,8],[971521.765674759,3],[971521.951751559,10],[971522.108840772,11],[971522.298781113,9],[971522.479708897,10],[971522.66987827,20],[971522.817494572,14],[971523.010990565,14],[971523.244044017,13],[971523.393074618,5],[971523.5657493,14],[971523.797799021,11],[971524.037595258,32],[971524.234659703,33],[971524.384530709,11],[971524.572840653,6],[971524.72287824,8],[971524.873730094,9],[971525.027634418,13],[971525.189946605,8],[971525.338264653,20],[971525.492165649,17],[971525.640655206,20],[971525.793478564,13],[971525.942507622,2],[971526.103786612,16],[971526.290671126,6],[971526.442435191,15],[971526.595106391,8],[971526.781878197,15],[971526.968515014,16],[971527.211070637,21],[971527.491211914,10],[971527.638050694,8],[971527.787441212,25],[971527.940338789,18],[971528.099975417,13],[971528.288323034,55],[971528.441145488,11],[971528.638277748,10],[971528.787268228,11],[971528.936128808,15],[971529.09290808,17],[971529.25054823,14],[971529.438763272,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-f265c056eae8403c9f60915a","runtime":{"accepted":176,"cached":30,"decode_s":13.4284,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1919,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971515.795757703,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21151694899890572,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":3,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.982931731872448,"done":971529.457153899,"finish_reason":"length","first":971516.007409809,"full_response_s":13.664388015051372,"last":971529.440529814,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971516.007409809,3],[971516.153012903,11],[971516.330259189,30],[971516.51520095,19],[971516.665812607,21],[971516.849959105,15],[971516.999467563,19],[971517.164907627,17],[971517.313813695,6],[971517.461941816,11],[971517.613058939,5],[971517.79633031,27],[971517.981696355,12],[971518.175965611,13],[971518.356890777,5],[971518.505756691,16],[971518.692617604,5],[971518.88225922,16],[971519.068722381,7],[971519.224856737,22],[971519.373763557,10],[971519.558829949,7],[971519.746295609,23],[971519.897274818,5],[971520.04652481,9],[971520.231423473,14],[971520.377647294,20],[971520.526503625,8],[971520.678485314,12],[971520.825896232,5],[971520.97978382,14],[971521.13666465,11],[971521.289327475,7],[971521.443877999,9],[971521.587251183,8],[971521.765618773,3],[971521.951851274,10],[971522.109099053,11],[971522.300207004,9],[971522.479969002,10],[971522.670564215,20],[971522.818147283,14],[971523.009968625,14],[971523.243461485,13],[971523.392047125,5],[971523.565579358,14],[971523.795477771,11],[971524.037692894,32],[971524.23419095,33],[971524.383280121,11],[971524.572121635,6],[971524.724155789,8],[971524.874134684,9],[971525.027851801,13],[971525.189836841,8],[971525.34029146,20],[971525.49037965,17],[971525.641878289,20],[971525.793107703,13],[971525.94376477,2],[971526.10399302,16],[971526.294899931,6],[971526.441628266,15],[971526.594374413,8],[971526.781952663,15],[971526.970357734,16],[971527.216444281,21],[971527.491546646,10],[971527.64276462,8],[971527.786918265,25],[971527.939565962,18],[971528.097733947,13],[971528.288911967,55],[971528.440021592,11],[971528.635151415,10],[971528.781577117,11],[971528.937642605,15],[971529.092765899,17],[971529.251213613,14],[971529.440529814,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-cecab29eef8040b8953e0053","runtime":{"accepted":176,"cached":30,"decode_s":13.4282,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1919,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971515.792765884,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21464392507914454,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":4,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.986280345646826,"done":971529.456798287,"finish_reason":"length","first":971516.006989106,"full_response_s":13.664123110007495,"last":971529.437739909,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971516.006989106,3],[971516.152362832,11],[971516.329582717,30],[971516.514533326,19],[971516.666104953,21],[971516.849912399,15],[971516.999323558,19],[971517.165222102,17],[971517.314050744,6],[971517.461202877,11],[971517.611814254,5],[971517.795419797,27],[971517.981081373,12],[971518.175278242,13],[971518.357327048,5],[971518.505282386,16],[971518.694218429,5],[971518.883142627,16],[971519.069916183,7],[971519.224386033,22],[971519.375764252,10],[971519.558213943,7],[971519.744120332,23],[971519.894518576,5],[971520.046092331,9],[971520.229989007,14],[971520.377709665,20],[971520.525948517,8],[971520.676177856,12],[971520.826992527,5],[971520.978503695,14],[971521.139804601,11],[971521.287188711,7],[971521.436684672,9],[971521.586186825,8],[971521.764714069,3],[971521.951453612,10],[971522.109180912,11],[971522.298169972,9],[971522.480102319,10],[971522.667262994,20],[971522.818077041,14],[971523.009347659,14],[971523.243732854,13],[971523.393884438,5],[971523.565138607,14],[971523.796204868,11],[971524.037489527,32],[971524.233200563,33],[971524.38360058,11],[971524.572459215,6],[971524.72597275,8],[971524.873408194,9],[971525.028213158,13],[971525.189311287,8],[971525.340399016,20],[971525.49009588,17],[971525.644159745,20],[971525.79257298,13],[971525.94572223,2],[971526.103592957,16],[971526.291370719,6],[971526.443711923,15],[971526.594444272,8],[971526.78328007,15],[971526.967399278,16],[971527.209575129,21],[971527.492174172,10],[971527.63774702,8],[971527.788046737,25],[971527.939403508,18],[971528.096262487,13],[971528.287609761,55],[971528.440680111,11],[971528.634978337,10],[971528.781688673,11],[971528.935912817,15],[971529.092694889,17],[971529.250118343,14],[971529.437739909,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-33206c99ee6b440f856debf2","runtime":{"accepted":176,"cached":30,"decode_s":13.4282,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1919,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971515.792675177,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21431392896920443,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":5,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.990428189021504,"done":971529.455560628,"finish_reason":"length","first":971516.008535865,"full_response_s":13.663314698962495,"last":971529.436353156,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971516.008535865,3],[971516.15354897,11],[971516.330044206,30],[971516.515541682,19],[971516.668169763,21],[971516.851520537,15],[971517.000039439,19],[971517.16532889,17],[971517.312872398,6],[971517.461584587,11],[971517.611538052,5],[971517.794628937,27],[971517.98146769,12],[971518.178209114,13],[971518.356783253,5],[971518.505510651,16],[971518.692421789,5],[971518.881506617,16],[971519.068803552,7],[971519.227446269,22],[971519.373685043,10],[971519.558168725,7],[971519.745272005,23],[971519.898381593,5],[971520.049817231,9],[971520.2310449,14],[971520.380569622,20],[971520.526089834,8],[971520.676373207,12],[971520.827192742,5],[971520.978073983,14],[971521.137285488,11],[971521.2902653,7],[971521.437146801,9],[971521.586756877,8],[971521.762517976,3],[971521.952383693,10],[971522.10997622,11],[971522.299051219,9],[971522.478749999,10],[971522.671085209,20],[971522.817626369,14],[971523.007362405,14],[971523.243325416,13],[971523.393193678,5],[971523.566846379,14],[971523.796425308,11],[971524.037777521,32],[971524.235852097,33],[971524.382716325,11],[971524.57180708,6],[971524.722750412,8],[971524.876559169,9],[971525.028139907,13],[971525.19236725,8],[971525.338480772,20],[971525.48998554,17],[971525.640502785,20],[971525.793598936,13],[971525.942655195,2],[971526.105267624,16],[971526.290890222,6],[971526.44116217,15],[971526.595387841,8],[971526.782709586,15],[971526.970084429,16],[971527.209858115,21],[971527.490745066,10],[971527.640415465,8],[971527.787356377,25],[971527.94055374,18],[971528.097127589,13],[971528.287227396,55],[971528.443234777,11],[971528.635613895,10],[971528.78509796,11],[971528.938903369,15],[971529.092848078,17],[971529.250041428,14],[971529.436353156,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-8ff0c19100b34b4d9fdc4389","runtime":{"accepted":176,"cached":30,"decode_s":13.4284,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1919,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971515.792245929,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21628993598278612,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":6,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.98348782156389,"done":971529.456440882,"finish_reason":"length","first":971516.007621064,"full_response_s":13.661390451947227,"last":971529.440347568,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971516.007621064,3],[971516.153136651,11],[971516.332974742,30],[971516.5158227,19],[971516.667096525,21],[971516.849790139,15],[971517.00052632,19],[971517.166640345,17],[971517.312935936,6],[971517.460228475,11],[971517.614709557,5],[971517.795155164,27],[971517.981584575,12],[971518.17707773,13],[971518.355749136,5],[971518.508383985,16],[971518.693939283,5],[971518.882169441,16],[971519.06908201,7],[971519.225432294,22],[971519.374886989,10],[971519.55768122,7],[971519.743544903,23],[971519.897144317,5],[971520.048546962,9],[971520.229620209,14],[971520.37780994,20],[971520.527279476,8],[971520.676989997,12],[971520.826510157,5],[971520.978599378,14],[971521.138051931,11],[971521.289828245,7],[971521.440956487,9],[971521.587180396,8],[971521.762613915,3],[971521.954042328,10],[971522.108291056,11],[971522.299387887,9],[971522.478789488,10],[971522.667628607,20],[971522.817093582,14],[971523.006961271,14],[971523.243840794,13],[971523.392536311,5],[971523.564181853,14],[971523.79575306,11],[971524.038570029,32],[971524.232961387,33],[971524.383024864,11],[971524.571653427,6],[971524.725156545,8],[971524.874884166,9],[971525.027348968,13],[971525.190331131,8],[971525.339285057,20],[971525.489868176,17],[971525.640099107,20],[971525.792325212,13],[971525.942789311,2],[971526.104543055,16],[971526.29072972,6],[971526.442385397,15],[971526.596674702,8],[971526.78408149,15],[971526.969581115,16],[971527.209710701,21],[971527.492912566,10],[971527.641590466,8],[971527.789144839,25],[971527.941035533,18],[971528.096370027,13],[971528.286943962,55],[971528.439232557,11],[971528.635425809,10],[971528.782678851,11],[971528.937099146,15],[971529.093424466,17],[971529.249406382,14],[971529.440347568,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-aa8104cf275c4ecfb2de6d11","runtime":{"accepted":176,"cached":30,"decode_s":13.4284,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1919,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971515.79505043,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21257063397206366,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":7,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.981257188004157,"done":971529.454410523,"finish_reason":"length","first":971516.00715884,"full_response_s":13.657478265929967,"last":971529.441463927,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971516.00715884,3],[971516.152489812,11],[971516.329895128,30],[971516.515245144,19],[971516.667681986,21],[971516.851738065,15],[971517.002428228,19],[971517.165551074,17],[971517.313676827,6],[971517.460577047,11],[971517.612877748,5],[971517.795360867,27],[971517.982730631,12],[971518.176470605,13],[971518.356152798,5],[971518.505680033,16],[971518.694743792,5],[971518.883066545,16],[971519.069303553,7],[971519.225279584,22],[971519.37327946,10],[971519.557517262,7],[971519.745788855,23],[971519.896539464,5],[971520.047512221,9],[971520.231136631,14],[971520.37802142,20],[971520.526029816,8],[971520.678761899,12],[971520.827704696,5],[971520.978790313,14],[971521.137106778,11],[971521.289982778,7],[971521.438487616,9],[971521.592067993,8],[971521.764596065,3],[971521.952574772,10],[971522.109466234,11],[971522.297976573,9],[971522.478698477,10],[971522.667733475,20],[971522.81737156,14],[971523.007471593,14],[971523.245044836,13],[971523.394212402,5],[971523.564993561,14],[971523.795834279,11],[971524.038246081,32],[971524.236397172,33],[971524.384633512,11],[971524.571867642,6],[971524.722393263,8],[971524.873818145,9],[971525.027421626,13],[971525.191475443,8],[971525.338063558,20],[971525.492052797,17],[971525.642254846,20],[971525.794386052,13],[971525.942584888,2],[971526.105189173,16],[971526.291548133,6],[971526.441242701,15],[971526.596259728,8],[971526.784777451,15],[971526.968949589,16],[971527.210086715,21],[971527.491066805,10],[971527.637671097,8],[971527.78852517,25],[971527.939473143,18],[971528.099903799,13],[971528.290557496,55],[971528.441831144,11],[971528.636518407,10],[971528.786373413,11],[971528.934517472,15],[971529.094123562,17],[971529.249559987,14],[971529.441463927,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-5589a0be082341a199d77db6","runtime":{"accepted":176,"cached":30,"decode_s":13.4284,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1919,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971515.796932257,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21022658294532448,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":8,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.98915269954282,"done":971529.454342873,"finish_reason":"length","first":971516.006817707,"full_response_s":13.659896016935818,"last":971529.435536936,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971516.006817707,3],[971516.153299521,11],[971516.330324328,30],[971516.515352187,19],[971516.66634565,21],[971516.849648662,15],[971516.999168096,19],[971517.164270197,17],[971517.314148891,6],[971517.462325045,11],[971517.613193439,5],[971517.796649025,27],[971517.982037279,12],[971518.175630591,13],[971518.356076156,5],[971518.507280778,16],[971518.693248443,5],[971518.882056525,16],[971519.068930612,7],[971519.226961004,22],[971519.373516045,10],[971519.558122259,7],[971519.743755391,23],[971519.896414387,5],[971520.047937724,9],[971520.230512865,14],[971520.377066794,20],[971520.526141692,8],[971520.677226533,12],[971520.825652095,5],[971520.977976652,14],[971521.137938215,11],[971521.288331072,7],[971521.436992923,9],[971521.586812895,8],[971521.763816614,3],[971521.951987615,10],[971522.10837882,11],[971522.298252679,9],[971522.479081354,10],[971522.669539266,20],[971522.819267179,14],[971523.010295389,14],[971523.247220977,13],[971523.395081408,5],[971523.565493627,14],[971523.795395304,11],[971524.038095196,32],[971524.233400394,33],[971524.384320205,11],[971524.572987106,6],[971524.725323863,8],[971524.877521171,9],[971525.026999947,13],[971525.190533954,8],[971525.341031742,20],[971525.491669279,17],[971525.641496772,20],[971525.791972959,13],[971525.946677336,2],[971526.105107699,16],[971526.294797383,6],[971526.444664613,15],[971526.595890883,8],[971526.782194256,15],[971526.968634458,16],[971527.213521923,21],[971527.490420479,10],[971527.640738036,8],[971527.787601745,25],[971527.939898198,18],[971528.098949701,13],[971528.286862855,55],[971528.439598538,11],[971528.635787277,10],[971528.782770102,11],[971528.935364237,15],[971529.092216776,17],[971529.251431813,14],[971529.435536936,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-f998a131e0d3450c9302a891","runtime":{"accepted":176,"cached":30,"decode_s":13.4284,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1919,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971515.794446856,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21237085096072406,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":9,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.98519971299964,"done":971529.454653988,"finish_reason":"length","first":971516.006942512,"full_response_s":13.66253955103457,"last":971529.43845779,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971516.006942512,3],[971516.15276891,11],[971516.330471597,30],[971516.516213226,19],[971516.667251858,21],[971516.849588516,15],[971516.999535933,19],[971517.164999615,17],[971517.313375248,6],[971517.461281984,11],[971517.614535455,5],[971517.795633389,27],[971517.982867772,12],[971518.17604939,13],[971518.356634576,5],[971518.505969147,16],[971518.692906847,5],[971518.881913464,16],[971519.070722132,7],[971519.224512949,22],[971519.374174228,10],[971519.55877057,7],[971519.745397257,23],[971519.896140122,5],[971520.046677391,9],[971520.230836077,14],[971520.377275089,20],[971520.526738337,8],[971520.677502559,12],[971520.826215107,5],[971520.977795286,14],[971521.136924963,11],[971521.288988343,7],[971521.437073134,9],[971521.587493304,8],[971521.764502094,3],[971521.952691768,10],[971522.109740196,11],[971522.299268923,9],[971522.478858323,10],[971522.667833558,20],[971522.817291125,14],[971523.009741753,14],[971523.246160508,13],[971523.392690956,5],[971523.56483458,14],[971523.796098145,11],[971524.038851959,32],[971524.232380246,33],[971524.384029891,11],[971524.574056263,6],[971524.725059053,8],[971524.87453273,9],[971525.026810821,13],[971525.189500334,8],[971525.338564759,20],[971525.490194875,17],[971525.643976203,20],[971525.79319337,13],[971525.942898499,2],[971526.103277458,16],[971526.294198274,6],[971526.441432131,15],[971526.594765563,8],[971526.781516312,15],[971526.96910505,16],[971527.211589183,21],[971527.492087817,10],[971527.640294261,8],[971527.790963319,25],[971527.939839988,18],[971528.09680873,13],[971528.287140753,55],[971528.440803092,11],[971528.635711451,10],[971528.782455371,11],[971528.935999972,15],[971529.092045122,17],[971529.250729228,14],[971529.43845779,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-1d165dfb1c7a4e64ba407c47","runtime":{"accepted":176,"cached":30,"decode_s":13.4283,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1919,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971515.792114437,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21482807502616197,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":10,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.986857646865975,"done":971529.456054741,"finish_reason":"length","first":971516.006735369,"full_response_s":13.66349435201846,"last":971529.437077806,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971516.006735369,3],[971516.153758354,11],[971516.330210644,30],[971516.515292825,19],[971516.666922039,21],[971516.851850997,15],[971517.000627444,19],[971517.164559311,17],[971517.313019555,6],[971517.463208053,11],[971517.611475058,5],[971517.794808016,27],[971517.983967219,12],[971518.177144709,13],[971518.35596268,5],[971518.505914201,16],[971518.693623752,5],[971518.881732385,16],[971519.070420601,7],[971519.224175209,22],[971519.375048531,10],[971519.558314314,7],[971519.744366628,23],[971519.895506723,5],[971520.048120467,9],[971520.230879342,14],[971520.378500781,20],[971520.526367716,8],[971520.676432425,12],[971520.826606193,5],[971520.978366298,14],[971521.137625004,11],[971521.289043993,7],[971521.436860198,9],[971521.588814278,8],[971521.765087202,3],[971521.952159589,10],[971522.109646736,11],[971522.298558674,9],[971522.478440708,10],[971522.668175106,20],[971522.818296313,14],[971523.007064667,14],[971523.245688923,13],[971523.393518569,5],[971523.564561114,14],[971523.7967562,11],[971524.036977557,32],[971524.23917431,33],[971524.386758083,11],[971524.571366713,6],[971524.722944707,8],[971524.874192734,9],[971525.028386268,13],[971525.190609301,8],[971525.338661291,20],[971525.490616698,17],[971525.640312874,20],[971525.791873372,13],[971525.943844517,2],[971526.103376646,16],[971526.293421687,6],[971526.442876054,15],[971526.595477332,8],[971526.782826742,15],[971526.967969874,16],[971527.210830341,21],[971527.490256569,10],[971527.637875776,8],[971527.787530511,25],[971527.940971163,18],[971528.096878157,13],[971528.290268686,55],[971528.439437828,11],[971528.636600138,10],[971528.782937228,11],[971528.936218939,15],[971529.092575796,17],[971529.251276575,14],[971529.437077806,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-789447a77c58455f99d04a3d","runtime":{"accepted":176,"cached":30,"decode_s":13.4283,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1919,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971515.792560389,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2141749799484387,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":11,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.988613472087884,"done":971529.456312126,"finish_reason":"length","first":971516.006671734,"full_response_s":13.662646290031262,"last":971529.435772304,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971516.006671734,3],[971516.153710896,11],[971516.329793621,30],[971516.515705528,19],[971516.666438213,21],[971516.849342411,15],[971516.999610944,19],[971517.166976453,17],[971517.313277628,6],[971517.463290328,11],[971517.611615591,5],[971517.795290865,27],[971517.982496655,12],[971518.176101184,13],[971518.356700402,5],[971518.505457753,16],[971518.692846908,5],[971518.882597056,16],[971519.068372992,7],[971519.225030295,22],[971519.374116722,10],[971519.559529781,7],[971519.744671615,23],[971519.895026018,5],[971520.047369128,9],[971520.23036734,14],[971520.376804208,20],[971520.52630989,8],[971520.676309428,12],[971520.827345307,5],[971520.979534451,14],[971521.136387184,11],[971521.288504854,7],[971521.438899951,9],[971521.587945544,8],[971521.765161029,3],[971521.953398977,10],[971522.109399816,11],[971522.297526237,9],[971522.478931573,10],[971522.669365388,20],[971522.818862365,14],[971523.006526968,14],[971523.243642387,13],[971523.394056636,5],[971523.566777592,14],[971523.796340393,11],[971524.037966584,32],[971524.233067919,33],[971524.386427751,11],[971524.570957978,6],[971524.722505267,8],[971524.877393422,9],[971525.027156721,13],[971525.191222746,8],[971525.338716013,20],[971525.490462517,17],[971525.641934659,20],[971525.792509122,13],[971525.943065497,2],[971526.104824249,16],[971526.291467746,6],[971526.440984228,15],[971526.594154646,8],[971526.781708911,15],[971526.967658071,16],[971527.212581858,21],[971527.490802124,10],[971527.638835154,8],[971527.789054228,25],[971527.941275126,18],[971528.096476863,13],[971528.286712562,55],[971528.440617101,11],[971528.636718462,10],[971528.783245495,11],[971528.936604265,15],[971529.093369952,17],[971529.249737465,14],[971529.435772304,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-2c5e6d28639946ecb53187fd","runtime":{"accepted":176,"cached":30,"decode_s":13.4283,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1919,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971515.793665836,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21300589805468917,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":12,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.982841919819837,"done":971529.457016534,"finish_reason":"length","first":971516.006909247,"full_response_s":13.662109134020284,"last":971529.440092807,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971516.006909247,3],[971516.153209022,11],[971516.332918228,30],[971516.514095743,19],[971516.666705663,21],[971516.852039051,15],[971517.000942303,19],[971517.164438107,17],[971517.315572126,6],[971517.463077712,11],[971517.613145134,5],[971517.79504004,27],[971517.982093921,12],[971518.178101671,13],[971518.355678254,5],[971518.506516878,16],[971518.694445349,5],[971518.88231655,16],[971519.070355079,7],[971519.226182864,22],[971519.374275976,10],[971519.558704072,7],[971519.745503293,23],[971519.898510238,5],[971520.046872678,9],[971520.230436094,14],[971520.377943417,20],[971520.526419318,8],[971520.678308139,12],[971520.826406858,5],[971520.979312379,14],[971521.136745213,11],[971521.290381112,7],[971521.437384841,9],[971521.5878489,8],[971521.76280613,3],[971521.952286634,10],[971522.110183251,11],[971522.297862377,9],[971522.479286418,10],[971522.667965419,20],[971522.817564095,14],[971523.006632235,14],[971523.243596369,13],[971523.393405061,5],[971523.564920007,14],[971523.795195633,11],[971524.037340001,32],[971524.236273775,33],[971524.383904175,11],[971524.570804661,6],[971524.724651407,8],[971524.877289243,9],[971525.027988782,13],[971525.192786529,8],[971525.341306504,20],[971525.490534615,17],[971525.640584244,20],[971525.792890991,13],[971525.944928891,2],[971526.103687537,16],[971526.293580732,6],[971526.442503817,15],[971526.59529019,8],[971526.783364569,15],[971526.970965788,16],[971527.210676815,21],[971527.490883151,10],[971527.639666687,8],[971527.788308746,25],[971527.940188944,18],[971528.096745976,13],[971528.288697399,55],[971528.439920725,11],[971528.636993607,10],[971528.784344366,11],[971528.936362688,15],[971529.092428335,17],[971529.250880145,14],[971529.440092807,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-ea1fa8b9c15048eebd7bd21b","runtime":{"accepted":176,"cached":30,"decode_s":13.4284,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1919,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971515.7949074,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21200184698682278,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":13,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.986193556948102,"done":971529.455854142,"finish_reason":"length","first":971516.007129991,"full_response_s":13.662615568959154,"last":971529.437942188,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971516.007129991,3],[971516.154392456,11],[971516.329509515,30],[971516.514595616,19],[971516.667312357,21],[971516.849434639,15],[971516.999235234,19],[971517.165106722,17],[971517.313073189,6],[971517.460414257,11],[971517.612126265,5],[971517.794890435,27],[971517.982793738,12],[971518.176225604,13],[971518.356395207,5],[971518.506577264,16],[971518.694385187,5],[971518.881809972,16],[971519.070221122,7],[971519.224584856,22],[971519.37433465,10],[971519.558656038,7],[971519.744562475,23],[971519.895629,5],[971520.049190473,9],[971520.229782247,14],[971520.376972134,20],[971520.527165088,8],[971520.676242706,12],[971520.826060014,5],[971520.979473265,14],[971521.140095699,11],[971521.289924424,7],[971521.441501259,9],[971521.586930516,8],[971521.762274191,3],[971521.951668868,10],[971522.108175852,11],[971522.299106101,9],[971522.478231484,10],[971522.667015897,20],[971522.816575436,14],[971523.006789825,14],[971523.244780043,13],[971523.393993754,5],[971523.564653229,14],[971523.796834139,11],[971524.039721573,32],[971524.232666896,33],[971524.387676947,11],[971524.57340544,6],[971524.726121539,8],[971524.873979478,9],[971525.028072049,13],[971525.190961777,8],[971525.339946712,20],[971525.491431079,17],[971525.642781697,20],[971525.792395886,13],[971525.942985238,2],[971526.102684126,16],[971526.290820139,6],[971526.442318643,15],[971526.594914656,8],[971526.782432184,15],[971526.968276077,16],[971527.213412399,21],[971527.491341359,10],[971527.637420432,8],[971527.790533608,25],[971527.939771537,18],[971528.098841905,13],[971528.288153236,55],[971528.440349796,11],[971528.636021733,10],[971528.782871498,11],[971528.935073187,15],[971529.092126949,17],[971529.249977394,14],[971529.437942188,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-7f82ff5f0cde4b229c305b5c","runtime":{"accepted":176,"cached":30,"decode_s":13.4283,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1919,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971515.793238573,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21389141795225441,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":14,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.986562387160433,"done":971529.457054664,"finish_reason":"length","first":971516.006869613,"full_response_s":13.664199657039717,"last":971529.437420905,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971516.006869613,3],[971516.154480075,11],[971516.331347308,30],[971516.513967882,19],[971516.668026526,21],[971516.852795862,15],[971517.000233478,19],[971517.165772586,17],[971517.313744477,6],[971517.460638505,11],[971517.611990869,5],[971517.795098858,27],[971517.981932443,12],[971518.176148561,13],[971518.355361634,5],[971518.507088739,16],[971518.692704759,5],[971518.881375797,16],[971519.068645722,7],[971519.227081248,22],[971519.3759641,10],[971519.560021975,7],[971519.744066106,23],[971519.896251966,5],[971520.04681426,9],[971520.231283116,14],[971520.377573484,20],[971520.525876402,8],[971520.677799209,12],[971520.827462847,5],[971520.978224053,14],[971521.138463178,11],[971521.28968512,7],[971521.437297046,9],[971521.589361322,8],[971521.765723337,3],[971521.95138073,10],[971522.107769502,11],[971522.300147162,9],[971522.480224851,10],[971522.66742444,20],[971522.820060439,14],[971523.008440555,14],[971523.244203815,13],[971523.394707907,5],[971523.56716023,14],[971523.800851544,11],[971524.036821455,32],[971524.233796152,33],[971524.390985896,11],[971524.571175634,6],[971524.723356321,8],[971524.877586661,9],[971525.026930729,13],[971525.18904635,8],[971525.338388033,20],[971525.492474667,17],[971525.64178603,20],[971525.794972249,13],[971525.943331586,2],[971526.103122013,16],[971526.292131321,6],[971526.445312908,15],[971526.596783522,8],[971526.782107613,15],[971526.968571976,16],[971527.211975165,21],[971527.491753485,10],[971527.637975572,8],[971527.788431982,25],[971527.940626607,18],[971528.097959506,13],[971528.287332552,55],[971528.440571884,11],[971528.635935234,10],[971528.782983182,11],[971528.937820451,15],[971529.091840395,17],[971529.250394032,14],[971529.437420905,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-3223588d820e406ead57e23e","runtime":{"accepted":176,"cached":30,"decode_s":13.4283,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1919,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971515.792855007,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21401460596825927,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":0,"stream":15,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.990373675039773,"done":971529.455124164,"finish_reason":"length","first":971516.008066328,"full_response_s":13.663106387015432,"last":971529.435922165,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971516.008066328,3],[971516.153472183,11],[971516.330402426,30],[971516.514046397,19],[971516.667035019,21],[971516.849510081,15],[971516.998900246,19],[971517.163898231,17],[971517.312799099,6],[971517.460911139,11],[971517.613497738,5],[971517.795476199,27],[971517.982135746,12],[971518.175769652,13],[971518.35581229,5],[971518.506369385,16],[971518.692778058,5],[971518.8815851,16],[971519.069554026,7],[971519.223602165,22],[971519.375251274,10],[971519.559311854,7],[971519.745054605,23],[971519.896809361,5],[971520.047577583,9],[971520.230075426,14],[971520.377885575,20],[971520.526252848,8],[971520.676545661,12],[971520.827579683,5],[971520.977518428,14],[971521.139938302,11],[971521.288888212,7],[971521.441410967,9],[971521.587107978,8],[971521.764133329,3],[971521.952918448,10],[971522.10787477,11],[971522.300039126,9],[971522.479789251,10],[971522.670261676,20],[971522.818357259,14],[971523.00671155,14],[971523.245126935,13],[971523.393936104,5],[971523.565980012,14],[971523.795279364,11],[971524.037073592,32],[971524.235732604,33],[971524.384468322,11],[971524.571100351,6],[971524.725627873,8],[971524.874764098,9],[971525.027494157,13],[971525.188926441,8],[971525.339648013,20],[971525.490314623,17],[971525.641427841,20],[971525.793550615,13],[971525.942715741,2],[971526.10287682,16],[971526.291110981,6],[971526.441797424,15],[971526.594042514,8],[971526.782578958,15],[971526.967905056,16],[971527.210931816,21],[971527.492247343,10],[971527.639447223,8],[971527.7897263,25],[971527.939645357,18],[971528.097199304,13],[971528.287930845,55],[971528.441893162,11],[971528.636290639,10],[971528.783437614,11],[971528.935251834,15],[971529.091964975,17],[971529.249891583,14],[971529.435922165,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-8ee7159a965e422c9af6e3bf","runtime":{"accepted":176,"cached":30,"decode_s":13.4283,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1919,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971515.792017777,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.21604855102486908,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.963826907769437,"done":971543.185678691,"finish_reason":"length","first":971529.721052131,"full_response_s":13.715777882025577,"last":971543.167705132,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971529.721052131,3],[971529.86150947,11],[971530.041662173,30],[971530.240943496,19],[971530.385715812,21],[971530.570777343,15],[971530.724926354,19],[971530.873843772,17],[971531.023716739,6],[971531.186173568,11],[971531.338857385,5],[971531.517335508,27],[971531.704205076,12],[971531.886580467,13],[971532.078829956,5],[971532.238439606,16],[971532.418019262,5],[971532.603136343,16],[971532.792292781,7],[971532.946240994,22],[971533.096661148,10],[971533.288889266,7],[971533.47469161,23],[971533.622493865,5],[971533.775683667,9],[971533.949440608,14],[971534.105145929,20],[971534.265753453,8],[971534.412325833,12],[971534.560871226,5],[971534.714027627,14],[971534.861231291,11],[971535.01201045,7],[971535.17346337,9],[971535.319914011,8],[971535.49255711,3],[971535.677229411,10],[971535.826906995,11],[971536.012333744,9],[971536.206809494,10],[971536.38962292,20],[971536.541534494,14],[971536.727558656,14],[971536.95584576,13],[971537.115284802,5],[971537.298370708,14],[971537.527817192,11],[971537.762343306,32],[971537.952055547,33],[971538.110122213,11],[971538.302240885,6],[971538.453334847,8],[971538.604838375,9],[971538.757631436,13],[971538.907164459,8],[971539.059844596,20],[971539.220952782,17],[971539.373507955,20],[971539.525091078,13],[971539.6749007,2],[971539.828102789,16],[971540.01474527,6],[971540.175797222,15],[971540.328458727,8],[971540.51215805,15],[971540.701657556,16],[971540.929469462,21],[971541.21829832,10],[971541.372887867,8],[971541.519064356,25],[971541.673999611,18],[971541.822903985,13],[971542.0079686,55],[971542.174885361,11],[971542.362566866,10],[971542.513867908,11],[971542.666968787,15],[971542.817343589,17],[971542.97340861,14],[971543.167705132,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-a43c9387bb554457aa5993f4","runtime":{"accepted":176,"cached":30,"decode_s":13.4474,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.2039,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971529.469900809,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2511513220379129,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.962710046295136,"done":971543.185455035,"finish_reason":"length","first":971529.720923839,"full_response_s":13.714878458995372,"last":971543.168368818,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971529.720923839,3],[971529.861423403,11],[971530.041758368,30],[971530.242757159,19],[971530.386629156,21],[971530.569661448,15],[971530.723966529,19],[971530.871879896,17],[971531.02321925,6],[971531.186091709,11],[971531.335967684,5],[971531.521618649,27],[971531.699805003,12],[971531.886972865,13],[971532.074576032,5],[971532.238999609,16],[971532.416142541,5],[971532.602417758,16],[971532.789356167,7],[971532.945079706,22],[971533.097866422,10],[971533.289224126,7],[971533.471270227,23],[971533.622674991,5],[971533.773890484,9],[971533.947621729,14],[971534.106567755,20],[971534.265995605,8],[971534.412231446,12],[971534.561652021,5],[971534.712094504,14],[971534.860777643,11],[971535.011945615,7],[971535.172167421,9],[971535.319645761,8],[971535.492902546,3],[971535.676103948,10],[971535.828493402,11],[971536.011478962,9],[971536.210214459,10],[971536.389744028,20],[971536.540618703,14],[971536.728749401,14],[971536.957422934,13],[971537.114045415,5],[971537.297583337,14],[971537.527579807,11],[971537.762623844,32],[971537.9531504,33],[971538.111228875,11],[971538.300817748,6],[971538.45421707,8],[971538.606447871,9],[971538.755389743,13],[971538.906179897,8],[971539.060529451,20],[971539.223126841,17],[971539.371624978,20],[971539.522565151,13],[971539.678307841,2],[971539.826869707,16],[971540.013403688,6],[971540.175106031,15],[971540.330934348,8],[971540.511931418,15],[971540.702143573,16],[971540.929535768,21],[971541.220266404,10],[971541.368916098,8],[971541.522899784,25],[971541.670669544,18],[971541.824984297,13],[971542.008224385,55],[971542.174398177,11],[971542.366301954,10],[971542.512972629,11],[971542.667778303,15],[971542.818239908,17],[971542.971094867,14],[971543.168368818,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-c00a60eb221840429867f385","runtime":{"accepted":176,"cached":30,"decode_s":13.4475,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.2039,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971529.470576576,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2503472630633041,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.96387041573722,"done":971543.184246898,"finish_reason":"length","first":971529.721517635,"full_response_s":13.714250085991807,"last":971543.168139786,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971529.721517635,3],[971529.86445634,11],[971530.043217459,30],[971530.242456765,19],[971530.38560584,21],[971530.569893792,15],[971530.72446229,19],[971530.872069598,17],[971531.023416521,6],[971531.186365447,11],[971531.335206297,5],[971531.519621524,27],[971531.700121654,12],[971531.888452132,13],[971532.076262187,5],[971532.239705378,16],[971532.419089523,5],[971532.601953374,16],[971532.790841818,7],[971532.945183981,22],[971533.096360802,10],[971533.29031682,7],[971533.47141948,23],[971533.623808022,5],[971533.772857008,9],[971533.94839542,14],[971534.106640909,20],[971534.264799196,8],[971534.411659538,12],[971534.561511681,5],[971534.714217778,14],[971534.861339135,11],[971535.013264557,7],[971535.173177856,9],[971535.320765464,8],[971535.49328984,3],[971535.676723986,10],[971535.828251425,11],[971536.012219132,9],[971536.208280137,10],[971536.389805055,20],[971536.541256853,14],[971536.726427593,14],[971536.955054356,13],[971537.114670732,5],[971537.29766966,14],[971537.526863607,11],[971537.761862362,32],[971537.954187812,33],[971538.112321681,11],[971538.302903852,6],[971538.4548545,8],[971538.605758375,9],[971538.756835536,13],[971538.907243886,8],[971539.058399266,20],[971539.225390071,17],[971539.373790685,20],[971539.52822597,13],[971539.676353662,2],[971539.826911772,16],[971540.013264131,6],[971540.175267156,15],[971540.328725728,8],[971540.512495197,15],[971540.702928432,16],[971540.930323459,21],[971541.219411558,10],[971541.372212291,8],[971541.519557893,25],[971541.671665578,18],[971541.82402244,13],[971542.010300024,55],[971542.176520233,11],[971542.367179376,10],[971542.512577688,11],[971542.666193865,15],[971542.819930702,17],[971542.971320203,14],[971543.168139786,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-091db6315ccb4e1bbbb49553","runtime":{"accepted":176,"cached":30,"decode_s":13.4474,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.2039,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971529.469996812,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.25152082298882306,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.962703411554525,"done":971543.18636217,"finish_reason":"length","first":971529.720840156,"full_response_s":13.715320441056974,"last":971543.16828984,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971529.720840156,3],[971529.862349339,11],[971530.041317521,30],[971530.2399353,19],[971530.385923803,21],[971530.570423986,15],[971530.725403555,19],[971530.873663126,17],[971531.023489755,6],[971531.186638672,11],[971531.336818338,5],[971531.517703969,27],[971531.700772812,12],[971531.887539204,13],[971532.076325437,5],[971532.238135627,16],[971532.41640479,5],[971532.602756746,16],[971532.790412587,7],[971532.945350963,22],[971533.097508634,10],[971533.289937223,7],[971533.47194881,23],[971533.621690445,5],[971533.774373989,9],[971533.948218134,14],[971534.106848709,20],[971534.265295965,8],[971534.412445022,12],[971534.560647875,5],[971534.711800654,14],[971534.860950849,11],[971535.011890573,7],[971535.171951238,9],[971535.324149149,8],[971535.493497943,3],[971535.675957463,10],[971535.827024999,11],[971536.011617127,9],[971536.208347355,10],[971536.389886225,20],[971536.541098639,14],[971536.728863341,14],[971536.956210956,13],[971537.114909493,5],[971537.298972985,14],[971537.527734229,11],[971537.763480498,32],[971537.950654346,33],[971538.109470062,11],[971538.301713715,6],[971538.453630153,8],[971538.606860349,9],[971538.758696913,13],[971538.906735212,8],[971539.060584349,20],[971539.222310109,17],[971539.374109944,20],[971539.522815143,13],[971539.675208006,2],[971539.826516463,16],[971540.015337034,6],[971540.175533405,15],[971540.329607998,8],[971540.511821862,15],[971540.703203145,16],[971540.931160112,21],[971541.225735711,10],[971541.36723332,8],[971541.519173064,25],[971541.672488503,18],[971541.82314433,13],[971542.010069344,55],[971542.178426507,11],[971542.363200904,10],[971542.514831061,11],[971542.668530953,15],[971542.816453991,17],[971542.970491422,14],[971543.16828984,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-a436bd694ba84efcbfaef223","runtime":{"accepted":176,"cached":30,"decode_s":13.4475,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.2039,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971529.471041729,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.24979842698667198,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.962517471619716,"done":971543.18419104,"finish_reason":"length","first":971529.720863308,"full_response_s":13.714120385004207,"last":971543.168444853,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971529.720863308,3],[971529.861457036,11],[971530.041613323,30],[971530.239649883,19],[971530.386424845,21],[971530.569953698,15],[971530.721577838,19],[971530.871460409,17],[971531.024917453,6],[971531.187463261,11],[971531.334224631,5],[971531.516735311,27],[971531.699870989,12],[971531.885939197,13],[971532.076900385,5],[971532.238057576,16],[971532.416751298,5],[971532.602275193,16],[971532.793434772,7],[971532.946769365,22],[971533.096589658,10],[971533.29111024,7],[971533.472554303,23],[971533.621779472,5],[971533.772618968,9],[971533.947467004,14],[971534.106375188,20],[971534.266373602,8],[971534.412065152,12],[971534.560594561,5],[971534.711955331,14],[971534.862502679,11],[971535.010675331,7],[971535.172647118,9],[971535.319762581,8],[971535.494107356,3],[971535.67604505,10],[971535.826308014,11],[971536.011810094,9],[971536.206585134,10],[971536.391221344,20],[971536.543682024,14],[971536.726670497,14],[971536.956868467,13],[971537.117423467,5],[971537.29812822,14],[971537.526542188,11],[971537.762989937,32],[971537.955382781,33],[971538.108702852,11],[971538.302629411,6],[971538.455681472,8],[971538.605385642,9],[971538.755938898,13],[971538.906949059,8],[971539.060068763,20],[971539.221401438,17],[971539.372399693,20],[971539.522721396,13],[971539.675091698,2],[971539.825952044,16],[971540.012742913,6],[971540.175463387,15],[971540.327321007,8],[971540.511493067,15],[971540.702047554,16],[971540.929081864,21],[971541.219316867,10],[971541.36651864,8],[971541.518825644,25],[971541.67228464,18],[971541.825622382,13],[971542.007853844,55],[971542.177130478,11],[971542.361036382,10],[971542.51411678,11],[971542.668870836,15],[971542.817755075,17],[971542.971025472,14],[971543.168444853,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-985fe2cca0234ca6a9c9d9b2","runtime":{"accepted":176,"cached":30,"decode_s":13.4473,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.2039,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971529.470070655,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.25079265295062214,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.96148428109997,"done":971543.186290695,"finish_reason":"length","first":971529.721197672,"full_response_s":13.715447820955887,"last":971543.169511961,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971529.721197672,3],[971529.862278072,11],[971530.040943028,30],[971530.242998351,19],[971530.386348698,21],[971530.570349744,15],[971530.724815583,19],[971530.876728417,17],[971531.023149487,6],[971531.18675986,11],[971531.339843659,5],[971531.519162884,27],[971531.702893494,12],[971531.887031299,13],[971532.076832303,5],[971532.237974278,16],[971532.417133135,5],[971532.602667831,16],[971532.790328408,7],[971532.947022381,22],[971533.096991384,10],[971533.289427861,7],[971533.471742259,23],[971533.623357367,5],[971533.772770141,9],[971533.949084756,14],[971534.105531047,20],[971534.265462035,8],[971534.411586656,12],[971534.561811883,5],[971534.712439604,14],[971534.863288194,11],[971535.013154025,7],[971535.173028555,9],[971535.320329865,8],[971535.493859428,3],[971535.676791252,10],[971535.827442149,11],[971536.011750603,9],[971536.208149604,10],[971536.390634075,20],[971536.542889821,14],[971536.730631338,14],[971536.955274684,13],[971537.116386344,5],[971537.298864805,14],[971537.528364586,11],[971537.761935212,32],[971537.951139307,33],[971538.113547483,11],[971538.301025179,6],[971538.456109551,8],[971538.606047489,9],[971538.756064086,13],[971538.905413871,8],[971539.058233852,20],[971539.222116982,17],[971539.371449276,20],[971539.522320502,13],[971539.674835273,2],[971539.826236021,16],[971540.014233188,6],[971540.176386331,15],[971540.327199515,8],[971540.514683369,15],[971540.702463856,16],[971540.9307096,21],[971541.218200861,10],[971541.366708342,8],[971541.520249421,25],[971541.674734468,18],[971541.824444838,13],[971542.010132946,55],[971542.175402963,11],[971542.363861678,10],[971542.512477204,11],[971542.667336768,15],[971542.815636683,17],[971542.969876777,14],[971543.169511961,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-00eda539323d449692f8d6fb","runtime":{"accepted":176,"cached":30,"decode_s":13.4475,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.2039,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971529.470842874,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.25035479792859405,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.955375305786863,"done":971543.186693653,"finish_reason":"length","first":971529.720386092,"full_response_s":13.716562067973427,"last":971543.17303453,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971529.720386092,3],[971529.861333047,11],[971530.040752797,30],[971530.239781039,19],[971530.384945417,21],[971530.569534435,15],[971530.727171649,19],[971530.871630735,17],[971531.022756914,6],[971531.185575019,11],[971531.337724033,5],[971531.518854169,27],[971531.699468127,12],[971531.885801816,13],[971532.074848858,5],[971532.237594088,16],[971532.41703278,5],[971532.603030387,16],[971532.787807441,7],[971532.945286193,22],[971533.096229789,10],[971533.288974965,7],[971533.472109488,23],[971533.623876473,5],[971533.773137754,9],[971533.94735196,14],[971534.105041702,20],[971534.265208922,8],[971534.411497821,12],[971534.560934717,5],[971534.711726251,14],[971534.860996931,11],[971535.011727784,7],[971535.171498774,9],[971535.319582495,8],[971535.492190138,3],[971535.675756704,10],[971535.827912021,11],[971536.011330397,9],[971536.208917135,10],[971536.389443938,20],[971536.541973693,14],[971536.729794365,14],[971536.956573513,13],[971537.114430148,5],[971537.297755887,14],[971537.526403863,11],[971537.762800154,32],[971537.951045624,33],[971538.108445579,11],[971538.306403253,6],[971538.453941332,8],[971538.605316072,9],[971538.755868943,13],[971538.906103206,8],[971539.059394644,20],[971539.225972779,17],[971539.371771831,20],[971539.523105201,13],[971539.675013647,2],[971539.827422574,16],[971540.013119422,6],[971540.175184545,15],[971540.327643851,8],[971540.511733203,15],[971540.706083724,16],[971540.928843712,21],[971541.218050232,10],[971541.366619027,8],[971541.518646566,25],[971541.670193192,18],[971541.822544373,13],[971542.009180066,55],[971542.174797774,11],[971542.361422811,10],[971542.512881442,11],[971542.668092522,15],[971542.816185437,17],[971542.970159843,14],[971543.17303453,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-ac36a31bc62c452baad3cb9e","runtime":{"accepted":176,"cached":30,"decode_s":13.4473,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.2039,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971529.470131585,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2502545069437474,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.961777702599882,"done":971543.185128208,"finish_reason":"length","first":971529.721990132,"full_response_s":13.714932685019448,"last":971543.170096317,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971529.721990132,3],[971529.863388495,11],[971530.040999782,30],[971530.239872642,19],[971530.385476028,21],[971530.570006788,15],[971530.721447481,19],[971530.876322403,17],[971531.02289023,6],[971531.185687183,11],[971531.335056724,5],[971531.517072891,27],[971531.701586505,12],[971531.888538407,13],[971532.074357177,5],[971532.237825824,16],[971532.416707648,5],[971532.603446706,16],[971532.789453434,7],[971532.944442308,22],[971533.096511991,10],[971533.289105738,7],[971533.470614476,23],[971533.622035193,5],[971533.772233563,9],[971533.948505024,14],[971534.104957491,20],[971534.263959711,8],[971534.411243764,12],[971534.560430523,5],[971534.712492598,14],[971534.861982677,11],[971535.011377276,7],[971535.172231775,9],[971535.323461621,8],[971535.493638876,3],[971535.676635598,10],[971535.826238059,11],[971536.011884512,9],[971536.210054742,10],[971536.389318302,20],[971536.540829254,14],[971536.726925786,14],[971536.955437761,13],[971537.114143898,5],[971537.301922191,14],[971537.527461099,11],[971537.763803469,32],[971537.953280101,33],[971538.111124791,11],[971538.302059903,6],[971538.454329986,8],[971538.604601183,9],[971538.757229838,13],[971538.908065946,8],[971539.059105066,20],[971539.22181854,17],[971539.376148622,20],[971539.527751265,13],[971539.675725112,2],[971539.826623395,16],[971540.013303252,6],[971540.176134658,15],[971540.328858948,8],[971540.513870333,15],[971540.703361599,16],[971540.930460152,21],[971541.218609691,10],[971541.371721619,8],[971541.519397552,25],[971541.670290635,18],[971541.82350207,13],[971542.008724818,55],[971542.175928629,11],[971542.363762811,10],[971542.514368517,11],[971542.670302229,15],[971542.815476789,17],[971542.972551429,14],[971543.170096317,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-fe466619412643009ff8c3ec","runtime":{"accepted":176,"cached":30,"decode_s":13.4473,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.2039,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971529.470195523,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.25179460900835693,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.96062286618617,"done":971543.185555694,"finish_reason":"length","first":971529.720679398,"full_response_s":13.714604065055028,"last":971543.169604668,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971529.720679398,3],[971529.861385129,11],[971530.041830099,30],[971530.24111043,19],[971530.386249111,21],[971530.570135592,15],[971530.724374527,19],[971530.873470287,17],[971531.024720054,6],[971531.187050847,11],[971531.334774074,5],[971531.51737687,27],[971531.700721627,12],[971531.887824942,13],[971532.074984254,5],[971532.239128766,16],[971532.416899639,5],[971532.60270772,16],[971532.790197156,7],[971532.945522281,22],[971533.0964173,10],[971533.291232004,7],[971533.472827753,23],[971533.623023723,5],[971533.774192319,9],[971533.948324409,14],[971534.106132924,20],[971534.263830154,8],[971534.411751877,12],[971534.56050435,5],[971534.711609751,14],[971534.860508706,11],[971535.011079025,7],[971535.172723888,9],[971535.319471563,8],[971535.492304654,3],[971535.676288258,10],[971535.827500807,11],[971536.01193421,9],[971536.20774295,10],[971536.391290658,20],[971536.54089076,14],[971536.728654278,14],[971536.955697418,13],[971537.115049897,5],[971537.299040027,14],[971537.527283605,11],[971537.762267912,32],[971537.954726247,33],[971538.109688118,11],[971538.301491852,6],[971538.453537798,8],[971538.606950608,9],[971538.755745195,13],[971538.910616354,8],[971539.057692313,20],[971539.224565291,17],[971539.372757673,20],[971539.524049794,13],[971539.675378524,2],[971539.826989439,16],[971540.013205089,6],[971540.176055455,15],[971540.329057323,8],[971540.512024381,15],[971540.702390445,16],[971540.929165339,21],[971541.219612173,10],[971541.36682273,8],[971541.519253899,25],[971541.673906103,18],[971541.825329396,13],[971542.008043947,55],[971542.177377463,11],[971542.361784951,10],[971542.512746285,11],[971542.6665305,15],[971542.816015575,17],[971542.970059375,14],[971543.169604668,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-4e3d400f63c54f6483ea4ea4","runtime":{"accepted":176,"cached":30,"decode_s":13.4476,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.2039,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971529.470951629,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2497277690563351,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.9577181834794,"done":971543.186979167,"finish_reason":"length","first":971529.720786922,"full_response_s":13.716711081098765,"last":971543.171772823,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971529.720786922,3],[971529.860812613,11],[971530.041133322,30],[971530.240185757,19],[971530.387551956,21],[971530.570489029,15],[971530.723642326,19],[971530.872140401,17],[971531.023784133,6],[971531.187933341,11],[971531.338363671,5],[971531.51849374,27],[971531.699699543,12],[971531.886154708,13],[971532.075118451,5],[971532.238291473,16],[971532.417173777,5],[971532.602355292,16],[971532.789538285,7],[971532.944697405,22],[971533.096095416,10],[971533.290790453,7],[971533.471870888,23],[971533.624114865,5],[971533.772139015,9],[971533.948584002,14],[971534.106502008,20],[971534.264204391,8],[971534.411409802,12],[971534.561599188,5],[971534.713148237,14],[971534.860656631,11],[971535.013216219,7],[971535.173400024,9],[971535.320379579,8],[971535.492372352,3],[971535.676673008,10],[971535.826763566,11],[971536.011677849,9],[971536.207444492,10],[971536.389512276,20],[971536.540961818,14],[971536.727316344,14],[971536.955223466,13],[971537.113947843,5],[971537.297837506,14],[971537.526172367,11],[971537.763332349,32],[971537.950570199,33],[971538.108787687,11],[971538.300891847,6],[971538.453225628,8],[971538.605910908,9],[971538.75775616,13],[971538.905136021,8],[971539.058155193,20],[971539.22112306,17],[971539.371507726,20],[971539.522206034,13],[971539.675275721,2],[971539.827685207,16],[971540.014939196,6],[971540.175887786,15],[971540.328397972,8],[971540.513218438,15],[971540.701962527,16],[971540.933393372,21],[971541.221849258,10],[971541.368176857,8],[971541.521459735,25],[971541.673640014,18],[971541.827289832,13],[971542.012481939,55],[971542.174037396,11],[971542.362882925,10],[971542.514886519,11],[971542.670201394,15],[971542.817581741,17],[971542.970563409,14],[971543.171772823,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-b24b884146e54013a3f4ab60","runtime":{"accepted":176,"cached":30,"decode_s":13.4474,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.2039,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971529.470268086,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.250518836081028,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.95979342392467,"done":971543.184705697,"finish_reason":"length","first":971529.721278219,"full_response_s":13.714367897016928,"last":971543.170791845,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971529.721278219,3],[971529.860951546,11],[971530.041084473,30],[971530.241316437,19],[971530.38618298,21],[971530.569826734,15],[971530.722940349,19],[971530.873150068,17],[971531.024196692,6],[971531.18731012,11],[971531.334839341,5],[971531.519930287,27],[971531.699630932,12],[971531.886217462,13],[971532.077340048,5],[971532.237358192,16],[971532.417587855,5],[971532.603517556,16],[971532.791347548,7],[971532.944821025,22],[971533.097096731,10],[971533.290029434,7],[971533.471137582,23],[971533.623080077,5],[971533.772987573,9],[971533.947909067,14],[971534.108785528,20],[971534.263651188,8],[971534.412391996,12],[971534.561214454,5],[971534.713084939,14],[971534.860728394,11],[971535.011198549,7],[971535.172573403,9],[971535.320582626,8],[971535.492782414,3],[971535.677445483,10],[971535.82805185,11],[971536.012636074,9],[971536.208764841,10],[971536.391603149,20],[971536.543274842,14],[971536.729256027,14],[971536.955476355,13],[971537.115494745,5],[971537.298026456,14],[971537.528297096,11],[971537.761737237,32],[971537.951715471,33],[971538.109371627,11],[971538.300544123,6],[971538.453796559,8],[971538.604491163,9],[971538.755468737,13],[971538.906269324,8],[971539.059919462,20],[971539.226387418,17],[971539.372635029,20],[971539.524374445,13],[971539.678184749,2],[971539.826106177,16],[971540.014435323,6],[971540.174964826,15],[971540.328278992,8],[971540.511643008,15],[971540.703661641,16],[971540.931396072,21],[971541.219890711,10],[971541.368432818,8],[971541.519687994,25],[971541.671062598,18],[971541.822734571,13],[971542.008613774,55],[971542.175736542,11],[971542.361903803,10],[971542.512802207,11],[971542.665990258,15],[971542.815573016,17],[971542.969976349,14],[971543.170791845,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-e140ef886e8848a5a9a3ba04","runtime":{"accepted":176,"cached":30,"decode_s":13.4476,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.2039,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971529.4703378,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2509404190350324,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.96364038316508,"done":971543.183868053,"finish_reason":"length","first":971529.720740952,"full_response_s":13.713187776971608,"last":971543.167526213,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971529.720740952,3],[971529.861230596,11],[971530.043129344,30],[971530.240266304,19],[971530.385850489,21],[971530.570086519,15],[971530.725032678,19],[971530.872770871,17],[971531.024387706,6],[971531.189281132,11],[971531.337010504,5],[971531.51727269,27],[971531.703831031,12],[971531.887340877,13],[971532.074490189,5],[971532.238372083,16],[971532.417363671,5],[971532.602598308,16],[971532.7891728,7],[971532.944877331,22],[971533.095826111,10],[971533.289604555,7],[971533.472013773,23],[971533.622103019,5],[971533.772917442,9],[971533.947571119,14],[971534.106987177,20],[971534.266174619,8],[971534.412574578,12],[971534.560781271,5],[971534.712881603,14],[971534.860394686,11],[971535.011665558,7],[971535.172087914,9],[971535.319835656,8],[971535.49244117,3],[971535.676128733,10],[971535.826849457,11],[971536.013224574,9],[971536.206997052,10],[971536.391427399,20],[971536.540365718,14],[971536.728178741,14],[971536.957765026,13],[971537.114798257,5],[971537.302413152,14],[971537.528096353,11],[971537.762076993,32],[971537.951831731,33],[971538.109262455,11],[971538.301082333,6],[971538.454530985,8],[971538.605171459,9],[971538.757056824,13],[971538.905658039,8],[971539.060020298,20],[971539.221737513,17],[971539.372846684,20],[971539.522422858,13],[971539.674696373,2],[971539.827826972,16],[971540.016013505,6],[971540.178464178,15],[971540.328529577,8],[971540.514040882,15],[971540.702794315,16],[971540.929897828,21],[971541.219485897,10],[971541.366375835,8],[971541.519753772,25],[971541.670389679,18],[971541.822966211,13],[971542.010482414,55],[971542.175523351,11],[971542.366401685,10],[971542.515913514,11],[971542.66687632,15],[971542.817138238,17],[971542.970767848,14],[971543.167526213,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-c751f70e521e4db799c25353","runtime":{"accepted":176,"cached":30,"decode_s":13.4475,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.2039,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971529.470680276,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.25006067589856684,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.96231211174138,"done":971543.183820755,"finish_reason":"length","first":971529.721233721,"full_response_s":13.713411320000887,"last":971543.168960902,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971529.721233721,3],[971529.861608161,11],[971530.042375222,30],[971530.242311847,19],[971530.385299718,21],[971530.571172429,15],[971530.724311821,19],[971530.872492013,17],[971531.023556557,6],[971531.18577757,11],[971531.33498573,5],[971531.518437114,27],[971531.703236802,12],[971531.886652566,13],[971532.075510881,5],[971532.237754462,16],[971532.416613837,5],[971532.60253005,16],[971532.791291482,7],[971532.944345136,22],[971533.096761104,10],[971533.289285456,7],[971533.471545228,23],[971533.622579819,5],[971533.772471843,9],[971533.948122226,14],[971534.104854815,20],[971534.264951889,8],[971534.412797162,12],[971534.561044768,5],[971534.71376317,14],[971534.862682829,11],[971535.012077156,7],[971535.173980076,9],[971535.321871822,8],[971535.494170558,3],[971535.676530939,10],[971535.827328369,11],[971536.014087708,9],[971536.206730259,10],[971536.389691291,20],[971536.542540721,14],[971536.726546045,14],[971536.955164904,13],[971537.114510583,5],[971537.298282961,14],[971537.527036061,11],[971537.761411738,32],[971537.952431176,33],[971538.110919328,11],[971538.300691616,6],[971538.453113416,8],[971538.605831354,9],[971538.755302636,13],[971538.905347804,8],[971539.057591558,20],[971539.221334476,17],[971539.371250933,20],[971539.522486844,13],[971539.674792056,2],[971539.827147509,16],[971540.013454185,6],[971540.175365128,15],[971540.328791074,8],[971540.512454652,15],[971540.702880654,16],[971540.930065482,21],[971541.221565024,10],[971541.368012403,8],[971541.519826174,25],[971541.673358549,18],[971541.823920388,13],[971542.008159951,55],[971542.176745985,11],[971542.361583392,10],[971542.516192371,11],[971542.667074839,15],[971542.816087466,17],[971542.970847418,14],[971543.168960902,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-a6b9ffcc7dac470081f40170","runtime":{"accepted":176,"cached":30,"decode_s":13.4474,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.2039,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971529.470409435,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2508242860203609,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.96278276575984,"done":971543.180034961,"finish_reason":"length","first":971529.720596147,"full_response_s":13.709296970977448,"last":971543.167989557,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971529.720596147,3],[971529.861284262,11],[971530.041264543,30],[971530.241198081,19],[971530.388088999,21],[971530.569748171,15],[971530.723535586,19],[971530.872588593,17],[971531.023988876,6],[971531.186852584,11],[971531.336117049,5],[971531.517162766,27],[971531.699935807,12],[971531.889656174,13],[971532.075405517,5],[971532.238814307,16],[971532.41630373,5],[971532.602086307,16],[971532.789404312,7],[971532.94450719,22],[971533.098269076,10],[971533.28951108,7],[971533.472198611,23],[971533.621394786,5],[971533.774047738,9],[971533.949591861,14],[971534.105686492,20],[971534.264633206,8],[971534.411971357,12],[971534.561112291,5],[971534.713578684,14],[971534.862577114,11],[971535.011449726,7],[971535.172296769,9],[971535.32112354,8],[971535.493719919,3],[971535.677045661,10],[971535.828113644,11],[971536.012936996,9],[971536.207985326,10],[971536.390973815,20],[971536.543325628,14],[971536.727191587,14],[971536.955383136,13],[971537.117229701,5],[971537.297943093,14],[971537.529699673,11],[971537.76197163,32],[971537.952684,33],[971538.111844016,11],[971538.302361018,6],[971538.453877634,8],[971538.605462573,9],[971538.759549038,13],[971538.905476657,8],[971539.058799072,20],[971539.224442599,17],[971539.374260269,20],[971539.523923902,13],[971539.676872384,2],[971539.826381722,16],[971540.013495243,6],[971540.175704131,15],[971540.328909094,8],[971540.511878536,15],[971540.702276074,16],[971540.931792005,21],[971541.221684532,10],[971541.367548579,8],[971541.523337959,25],[971541.671024132,18],[971541.823824481,13],[971542.009954332,55],[971542.175640011,11],[971542.362130979,10],[971542.512688555,11],[971542.667696284,15],[971542.816800114,17],[971542.971900446,14],[971543.167989557,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-eb72db163dcd44cbb2e2fb9e","runtime":{"accepted":176,"cached":30,"decode_s":13.4475,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.2039,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971529.47073799,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.24985815701074898,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.9644841546546,"done":971543.186518959,"finish_reason":"length","first":971529.722486613,"full_response_s":13.716036034049466,"last":971543.168673597,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971529.722486613,3],[971529.861165634,11],[971530.040878946,30],[971530.240701039,19],[971530.385773126,21],[971530.570205675,15],[971530.723316346,19],[971530.871997436,17],[971531.024430732,6],[971531.185873062,11],[971531.334341211,5],[971531.516856147,27],[971531.699986145,12],[971531.886038896,13],[971532.074740294,5],[971532.237872322,16],[971532.419280762,5],[971532.603207114,16],[971532.790780328,7],[971532.944950085,22],[971533.09844193,10],[971533.288730957,7],[971533.470514696,23],[971533.622945688,5],[971533.772530533,9],[971533.948025455,14],[971534.104743852,20],[971534.264529778,8],[971534.411890202,12],[971534.561914143,5],[971534.712195164,14],[971534.864742693,11],[971535.010908283,7],[971535.173308501,9],[971535.319982637,8],[971535.493432277,3],[971535.676473945,10],[971535.826587288,11],[971536.012128633,9],[971536.207190755,10],[971536.391051162,20],[971536.541393161,14],[971536.726747652,14],[971536.956493046,13],[971537.114263726,5],[971537.298627165,14],[971537.527981901,11],[971537.762548273,32],[971537.953392105,33],[971538.113328947,11],[971538.302305,6],[971538.455349957,8],[971538.604933211,9],[971538.75515671,13],[971538.90527625,8],[971539.05898239,20],[971539.221481681,17],[971539.371371001,20],[971539.524186791,13],[971539.675820187,2],[971539.826807625,16],[971540.014873018,6],[971540.179368225,15],[971540.329228929,8],[971540.512368457,15],[971540.702703528,16],[971540.92982253,21],[971541.219114508,10],[971541.367462736,8],[971541.520691596,25],[971541.67152927,18],[971541.823415811,13],[971542.009045869,55],[971542.174631945,11],[971542.365205516,10],[971542.51462707,11],[971542.668443686,15],[971542.817674192,17],[971542.970422988,14],[971543.168673597,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-ee48eda51dca4af998e97421","runtime":{"accepted":176,"cached":30,"decode_s":13.4473,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.2039,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971529.470482925,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.25200368801597506,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":1,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.959112258269865,"done":971543.18614157,"finish_reason":"length","first":971529.721945074,"full_response_s":13.716332043986768,"last":971543.171941916,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971529.721945074,3],[971529.861086191,11],[971530.041384211,30],[971530.240346083,19],[971530.386729816,21],[971530.571079993,15],[971530.726875703,19],[971530.871798229,17],[971531.023849864,6],[971531.186478075,11],[971531.334544578,5],[971531.517945913,27],[971531.699561122,12],[971531.886734824,13],[971532.076971908,5],[971532.238659469,16],[971532.416854934,5],[971532.602466464,16],[971532.790972911,7],[971532.944051702,22],[971533.096872003,10],[971533.290257554,7],[971533.471363926,23],[971533.621941237,5],[971533.77233755,9],[971533.948820586,14],[971534.105355489,20],[971534.264706777,8],[971534.411816168,12],[971534.563190779,5],[971534.711473875,14],[971534.861855985,11],[971535.011790058,7],[971535.171835954,9],[971535.322049589,8],[971535.492626841,3],[971535.678226662,10],[971535.826496676,11],[971536.0119869,9],[971536.20688204,10],[971536.390384275,20],[971536.540739251,14],[971536.726868008,14],[971536.955337758,13],[971537.116034395,5],[971537.299323221,14],[971537.526265154,11],[971537.762733544,32],[971537.951267855,33],[971538.10828983,11],[971538.301883049,6],[971538.453406546,8],[971538.605990447,9],[971538.755646935,13],[971538.905997587,8],[971539.059651725,20],[971539.221251737,17],[971539.372133267,20],[971539.523401996,13],[971539.677735389,2],[971539.826558528,16],[971540.012928711,6],[971540.177844605,15],[971540.329970955,8],[971540.512554287,15],[971540.70414489,16],[971540.928943012,21],[971541.221968718,10],[971541.368595095,8],[971541.518734521,25],[971541.672710894,18],[971541.823596521,13],[971542.012561222,55],[971542.174976164,11],[971542.362372187,10],[971542.513747488,11],[971542.667595865,15],[971542.8159217,17],[971542.970919997,14],[971543.171941916,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-a45797ab6d3a4566a8917224","runtime":{"accepted":176,"cached":30,"decode_s":13.4474,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.2039,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971529.469809526,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.25213554804213345,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.91718272631467,"done":971556.946532707,"finish_reason":"length","first":971543.452359225,"full_response_s":13.731617863988504,"last":971556.932167698,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971543.452359225,3],[971543.588689635,11],[971543.770652054,30],[971543.957300514,19],[971544.115904174,21],[971544.303991433,15],[971544.451910408,19],[971544.601790618,17],[971544.750619335,6],[971544.899422272,11],[971545.050478786,5],[971545.244177779,27],[971545.43159739,12],[971545.617727677,13],[971545.800585452,5],[971545.957262998,16],[971546.150954157,5],[971546.335956988,16],[971546.524688378,7],[971546.67695315,22],[971546.825289691,10],[971547.01232551,7],[971547.210939914,23],[971547.359924262,5],[971547.512808039,9],[971547.683874947,14],[971547.834590921,20],[971547.984698515,8],[971548.143122617,12],[971548.296903184,5],[971548.450141365,14],[971548.599320833,11],[971548.748590575,7],[971548.899639717,9],[971549.050977778,8],[971549.235021748,3],[971549.420982231,10],[971549.572162655,11],[971549.759283993,9],[971549.942384597,10],[971550.137750589,20],[971550.343092599,14],[971550.519408458,14],[971550.74942332,13],[971550.895073432,5],[971551.070266477,14],[971551.30793981,11],[971551.542379593,32],[971551.730208217,33],[971551.885804499,11],[971552.069432779,6],[971552.230092747,8],[971552.379105843,9],[971552.528197469,13],[971552.682497207,8],[971552.83272471,20],[971552.985121256,17],[971553.141879789,20],[971553.296474137,13],[971553.446976795,2],[971553.599320571,16],[971553.784839674,6],[971553.934143853,15],[971554.0885575,8],[971554.283885739,15],[971554.47267251,16],[971554.700882401,21],[971554.977210687,10],[971555.139171203,8],[971555.290918864,25],[971555.441827104,18],[971555.595947229,13],[971555.780582075,55],[971555.93257681,11],[971556.133707737,10],[971556.285289592,11],[971556.436183505,15],[971556.593529554,17],[971556.744872042,14],[971556.932167698,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-56b9a526235c4590b8cb106d","runtime":{"accepted":176,"cached":30,"decode_s":13.4786,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1951,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971543.214914843,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2374443820444867,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.920710704434473,"done":971556.948077143,"finish_reason":"length","first":971543.453470191,"full_response_s":13.735478059039451,"last":971556.930765203,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971543.453470191,3],[971543.588851608,11],[971543.768144352,30],[971543.958759716,19],[971544.114803417,21],[971544.301279517,15],[971544.451262466,19],[971544.604353697,17],[971544.752259968,6],[971544.899033635,11],[971545.05037027,5],[971545.242700001,27],[971545.430993385,12],[971545.616491891,13],[971545.800437415,5],[971545.956144864,16],[971546.150528911,5],[971546.335084287,16],[971546.524038292,7],[971546.676526527,22],[971546.824882493,10],[971547.011571692,7],[971547.211875898,23],[971547.360493466,5],[971547.513674309,9],[971547.683379618,14],[971547.83351586,20],[971547.983383735,8],[971548.143174922,12],[971548.295854077,5],[971548.447567246,14],[971548.597236522,11],[971548.74832103,7],[971548.898868379,9],[971549.050178823,8],[971549.233733048,3],[971549.420662941,10],[971549.571933415,11],[971549.756166464,9],[971549.941434229,10],[971550.137546262,20],[971550.340389244,14],[971550.516472071,14],[971550.747411812,13],[971550.89576104,5],[971551.072353859,14],[971551.305802633,11],[971551.541411209,32],[971551.728975567,33],[971551.881241913,11],[971552.069046062,6],[971552.229274832,8],[971552.379991025,9],[971552.528499319,13],[971552.683399509,8],[971552.832809465,20],[971552.983931552,17],[971553.141773961,20],[971553.295934471,13],[971553.446473466,2],[971553.598186757,16],[971553.783259173,6],[971553.936352984,15],[971554.090911803,8],[971554.282057278,15],[971554.470746942,16],[971554.705484044,21],[971554.976997768,10],[971555.138807095,8],[971555.293410467,25],[971555.441881218,18],[971555.593596158,13],[971555.77866153,55],[971555.933284546,11],[971556.13325153,10],[971556.286350124,11],[971556.434100347,15],[971556.592247783,17],[971556.742403815,14],[971556.930765203,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-a4124cea969945bebd3364c7","runtime":{"accepted":176,"cached":30,"decode_s":13.4785,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1951,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971543.212599084,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.24087110697291791,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.91781125423709,"done":971556.947933586,"finish_reason":"length","first":971543.452307447,"full_response_s":13.734051289968193,"last":971556.931668065,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971543.452307447,3],[971543.588744277,11],[971543.770356364,30],[971543.957679199,19],[971544.114550224,21],[971544.302036231,15],[971544.452334935,19],[971544.601420157,17],[971544.751948757,6],[971544.899878383,11],[971545.052200205,5],[971545.243113679,27],[971545.431986475,12],[971545.616605671,13],[971545.801286452,5],[971545.958691623,16],[971546.151272232,5],[971546.33559736,16],[971546.527525147,7],[971546.677621989,22],[971546.827257614,10],[971547.012551773,7],[971547.213224856,23],[971547.3603209,5],[971547.512734501,9],[971547.687029166,14],[971547.833885537,20],[971547.983852679,8],[971548.143733725,12],[971548.296276779,5],[971548.448374553,14],[971548.598744733,11],[971548.74902675,7],[971548.89923708,9],[971549.049846876,8],[971549.233946688,3],[971549.421821572,10],[971549.573498492,11],[971549.756435785,9],[971549.941667437,10],[971550.137352512,20],[971550.341835933,14],[971550.517701857,14],[971550.747162508,13],[971550.895449813,5],[971551.069371502,14],[971551.306262617,11],[971551.544277769,32],[971551.729438655,33],[971551.885406821,11],[971552.071956272,6],[971552.229667805,8],[971552.377371528,9],[971552.529752305,13],[971552.684911064,8],[971552.832880395,20],[971552.984685641,17],[971553.142848766,20],[971553.296026986,13],[971553.446649872,2],[971553.598856332,16],[971553.784300664,6],[971553.93504078,15],[971554.088308467,8],[971554.282238692,15],[971554.46992885,16],[971554.702119386,21],[971554.977312162,10],[971555.140292841,8],[971555.292658842,25],[971555.440552485,18],[971555.594309478,13],[971555.779069816,55],[971555.932658205,11],[971556.134134151,10],[971556.286504049,11],[971556.435847334,15],[971556.59334294,17],[971556.742761187,14],[971556.931668065,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-fcefc97825c14f4c858c5093","runtime":{"accepted":176,"cached":30,"decode_s":13.4786,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1951,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971543.213882296,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23842515097931027,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.917590872067958,"done":971556.946945201,"finish_reason":"length","first":971543.452433756,"full_response_s":13.732260653981939,"last":971556.931951403,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971543.452433756,3],[971543.588948044,11],[971543.770783483,30],[971543.958679873,19],[971544.113667778,21],[971544.301804415,15],[971544.45208123,19],[971544.600436731,17],[971544.7513268,6],[971544.899990739,11],[971545.050912689,5],[971545.243411257,27],[971545.43218909,12],[971545.618616235,13],[971545.800910167,5],[971545.959171992,16],[971546.151649461,5],[971546.335431834,16],[971546.525356001,7],[971546.679394529,22],[971546.825667512,10],[971547.011729137,7],[971547.212498607,23],[971547.361458379,5],[971547.512892282,9],[971547.684202942,14],[971547.833749932,20],[971547.983610318,8],[971548.144493239,12],[971548.297838272,5],[971548.447400632,14],[971548.598371616,11],[971548.748738772,7],[971548.899031729,9],[971549.049406941,8],[971549.234720394,3],[971549.420735135,10],[971549.573170561,11],[971549.756532588,9],[971549.942568443,10],[971550.137251804,20],[971550.34123308,14],[971550.516933111,14],[971550.745688106,13],[971550.895224301,5],[971551.069232906,14],[971551.305961023,11],[971551.544810908,32],[971551.73224179,33],[971551.882714042,11],[971552.070282599,6],[971552.230531546,8],[971552.37830676,9],[971552.530041547,13],[971552.682415412,8],[971552.833279881,20],[971552.984337549,17],[971553.142964689,20],[971553.29781903,13],[971553.447867545,2],[971553.599067283,16],[971553.784161347,6],[971553.934399286,15],[971554.089421785,8],[971554.282505725,15],[971554.472270769,16],[971554.70134056,21],[971554.978837941,10],[971555.138318102,8],[971555.292350112,25],[971555.442938806,18],[971555.596876716,13],[971555.780116843,55],[971555.934257379,11],[971556.135352384,10],[971556.283799974,11],[971556.43431861,15],[971556.593666695,17],[971556.742699873,14],[971556.931951403,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-5234451453784c4e8828287e","runtime":{"accepted":176,"cached":30,"decode_s":13.4786,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1951,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971543.214684547,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2377492089290172,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.91631426424491,"done":971556.946475025,"finish_reason":"length","first":971543.452402171,"full_response_s":13.732695005019195,"last":971556.932829512,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971543.452402171,3],[971543.589351929,11],[971543.769723142,30],[971543.956983112,19],[971544.1144407,21],[971544.300547828,15],[971544.45354368,19],[971544.600800136,17],[971544.750775341,6],[971544.899307628,11],[971545.053592876,5],[971545.244335896,27],[971545.432923243,12],[971545.619697824,13],[971545.802444956,5],[971545.957457885,16],[971546.15143651,5],[971546.336631299,16],[971546.524303853,7],[971546.676878731,22],[971546.826768045,10],[971547.012665505,7],[971547.213501489,23],[971547.358992567,5],[971547.512150113,9],[971547.683255374,14],[971547.833319933,20],[971547.985416988,8],[971548.143306623,12],[971548.297630553,5],[971548.449340586,14],[971548.599490854,11],[971548.749372425,7],[971548.898759063,9],[971549.050057859,8],[971549.23437171,3],[971549.42189751,10],[971549.5726568,11],[971549.756815046,9],[971549.944269237,10],[971550.138911685,20],[971550.341657655,14],[971550.51731922,14],[971550.746187675,13],[971550.894447987,5],[971551.071545896,14],[971551.30642691,11],[971551.542462108,32],[971551.729735353,33],[971551.881711,11],[971552.073408593,6],[971552.231039707,8],[971552.379898542,9],[971552.530111789,13],[971552.684210897,8],[971552.833630756,20],[971552.984547909,17],[971553.146598892,20],[971553.295826291,13],[971553.449622244,2],[971553.599618917,16],[971553.784386475,6],[971553.934505578,15],[971554.089156896,8],[971554.28266557,15],[971554.469470003,16],[971554.701137673,21],[971554.980073759,10],[971555.139063887,8],[971555.290723913,25],[971555.440685914,18],[971555.592933096,13],[971555.77853375,55],[971555.932412693,11],[971556.135793535,10],[971556.28460717,11],[971556.435959417,15],[971556.593194647,17],[971556.744619793,14],[971556.932829512,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-151319d09a27496b9de1c843","runtime":{"accepted":176,"cached":30,"decode_s":13.4785,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1951,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971543.21378002,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23862215096596628,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.918069189305317,"done":971556.944628692,"finish_reason":"length","first":971543.452888427,"full_response_s":13.731921683996916,"last":971556.932065263,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971543.452888427,3],[971543.587578861,11],[971543.77041731,30],[971543.956114122,19],[971544.113837671,21],[971544.300667752,15],[971544.452541038,19],[971544.60131721,17],[971544.750363791,6],[971544.899363118,11],[971545.050076628,5],[971545.246768316,27],[971545.433035247,12],[971545.618936278,13],[971545.801749172,5],[971545.95708584,16],[971546.152153414,5],[971546.336207925,16],[971546.526622908,7],[971546.677056017,22],[971546.82474412,10],[971547.012841671,7],[971547.211698404,23],[971547.363867021,5],[971547.512616369,9],[971547.683992311,14],[971547.834080679,20],[971547.984420154,8],[971548.144086313,12],[971548.296339053,5],[971548.447723443,14],[971548.59972667,11],[971548.749974974,7],[971548.89989267,9],[971549.049573586,8],[971549.233333083,3],[971549.421127836,10],[971549.573681474,11],[971549.757956972,9],[971549.944186914,10],[971550.137422706,20],[971550.34175745,14],[971550.516599867,14],[971550.749104877,13],[971550.89517582,5],[971551.071981543,14],[971551.305547969,11],[971551.542876842,32],[971551.728447805,33],[971551.884509095,11],[971552.070461773,6],[971552.230853557,8],[971552.37812549,9],[971552.528373699,13],[971552.683480104,8],[971552.833681398,20],[971552.984256283,17],[971553.142159734,20],[971553.298136609,13],[971553.44636559,2],[971553.598716967,16],[971553.784058111,6],[971553.933856852,15],[971554.088900615,8],[971554.283494174,15],[971554.472436966,16],[971554.702496135,21],[971554.978386662,10],[971555.138148497,8],[971555.291261995,25],[971555.441285294,18],[971555.595110689,13],[971555.779416452,55],[971555.933040506,11],[971556.133895647,10],[971556.285450222,11],[971556.434781666,15],[971556.59245027,17],[971556.74439065,14],[971556.932065263,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-78995d11d87f4409a9a67d11","runtime":{"accepted":176,"cached":30,"decode_s":13.4785,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1951,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971543.212707008,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.24018141895066947,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.91641426840158,"done":971556.947439858,"finish_reason":"length","first":971543.451995021,"full_response_s":13.734398102969863,"last":971556.932351096,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971543.451995021,3],[971543.587264818,11],[971543.769283975,30],[971543.957128444,19],[971544.113745732,21],[971544.301720268,15],[971544.452647281,19],[971544.601716919,17],[971544.751181515,6],[971544.899685929,11],[971545.050210121,5],[971545.243834471,27],[971545.431830166,12],[971545.61876744,13],[971545.801132063,5],[971545.959034275,16],[971546.150163442,5],[971546.336110754,16],[971546.525222077,7],[971546.679132856,22],[971546.82666249,10],[971547.016578806,7],[971547.210402456,23],[971547.360117789,5],[971547.511699458,9],[971547.683677228,14],[971547.834014117,20],[971547.985996783,8],[971548.142954243,12],[971548.295924319,5],[971548.447804438,14],[971548.598015716,11],[971548.749257525,7],[971548.901867921,9],[971549.051128823,8],[971549.235222107,3],[971549.422033131,10],[971549.572337669,11],[971549.757333031,9],[971549.942995546,10],[971550.136840894,20],[971550.342201849,14],[971550.516877605,14],[971550.745855183,13],[971550.894577656,5],[971551.069125238,14],[971551.305680581,11],[971551.541595839,32],[971551.728359834,33],[971551.881559923,11],[971552.071098259,6],[971552.229579514,8],[971552.377963852,9],[971552.5297024,13],[971552.682985847,8],[971552.832564417,20],[971552.984817502,17],[971553.144608473,20],[971553.296211664,13],[971553.446722546,2],[971553.599258089,16],[971553.783496685,6],[971553.934982698,15],[971554.088153422,8],[971554.282607984,15],[971554.470968117,16],[971554.701243661,21],[971554.980240005,10],[971555.138433578,8],[971555.29217769,25],[971555.442384259,18],[971555.593388007,13],[971555.781540763,55],[971555.933563451,11],[971556.133648647,10],[971556.285521776,11],[971556.435692145,15],[971556.592381292,17],[971556.742266994,14],[971556.932351096,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-d95b07dd043c462292516a0e","runtime":{"accepted":176,"cached":30,"decode_s":13.4785,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1951,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971543.213041755,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23895326594356447,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.917055049923494,"done":971556.94721793,"finish_reason":"length","first":971543.452230117,"full_response_s":13.733966871979646,"last":971556.932129569,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971543.452230117,3],[971543.588056381,11],[971543.770714744,30],[971543.960602403,19],[971544.114010861,21],[971544.300743834,15],[971544.452463051,19],[971544.601501536,17],[971544.753559964,6],[971544.900620185,11],[971545.053939144,5],[971545.243549086,27],[971545.435490147,12],[971545.61728443,13],[971545.802517822,5],[971545.959295388,16],[971546.151475183,5],[971546.336039951,16],[971546.526772129,7],[971546.678224905,22],[971546.825339661,10],[971547.014640148,7],[971547.210734579,23],[971547.359591867,5],[971547.511412824,9],[971547.683527607,14],[971547.833676521,20],[971547.984553678,8],[971548.144918518,12],[971548.295746537,5],[971548.447930314,14],[971548.598975877,11],[971548.749532303,7],[971548.899956896,9],[971549.051700123,8],[971549.234037779,3],[971549.422861287,10],[971549.571707887,11],[971549.756309205,9],[971549.943104909,10],[971550.138289775,20],[971550.341482081,14],[971550.517399702,14],[971550.747752432,13],[971550.89501391,5],[971551.070591832,14],[971551.30587182,11],[971551.542801383,32],[971551.728529456,33],[971551.884711646,11],[971552.07022695,6],[971552.229505,8],[971552.378640563,9],[971552.529094507,13],[971552.682081577,8],[971552.833093778,20],[971552.984902992,17],[971553.144526582,20],[971553.296891815,13],[971553.447663074,2],[971553.599840317,16],[971553.783622209,6],[971553.934588044,15],[971554.088464232,8],[971554.283045743,15],[971554.47005871,16],[971554.703572859,21],[971554.97777613,10],[971555.139412939,8],[971555.290802284,25],[971555.441218572,18],[971555.596021967,13],[971555.779575433,55],[971555.934030523,11],[971556.133402719,10],[971556.286596996,11],[971556.434163421,15],[971556.592785545,17],[971556.743858408,14],[971556.932129569,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-edcfbbeebb0344c090cadb2b","runtime":{"accepted":176,"cached":30,"decode_s":13.4785,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1951,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971543.213251058,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23897905903868377,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.917398181467775,"done":971556.947670378,"finish_reason":"length","first":971543.452744902,"full_response_s":13.73399039299693,"last":971556.93239985,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971543.452744902,3],[971543.588450139,11],[971543.770024593,30],[971543.956605947,19],[971544.114345769,21],[971544.301464291,15],[971544.452234707,19],[971544.600577568,17],[971544.751906995,6],[971544.900685211,11],[971545.052863411,5],[971545.243336982,27],[971545.432271589,12],[971545.616722827,13],[971545.801031275,5],[971545.956375608,16],[971546.151530961,5],[971546.33718719,16],[971546.525436356,7],[971546.679050805,22],[971546.826591895,10],[971547.012726691,7],[971547.215853937,23],[971547.360430744,5],[971547.512250724,9],[971547.68408793,14],[971547.833408816,20],[971547.984116736,8],[971548.14288072,12],[971548.296396511,5],[971548.448315015,14],[971548.597822942,11],[971548.749599985,7],[971548.900608822,9],[971549.050338604,8],[971549.234788156,3],[971549.421733649,10],[971549.572959978,11],[971549.759425694,9],[971549.942486904,10],[971550.138215469,20],[971550.340482751,14],[971550.518195409,14],[971550.748050922,13],[971550.895134634,5],[971551.070422546,14],[971551.30634838,11],[971551.545341613,32],[971551.731070262,33],[971551.880821482,11],[971552.069687299,6],[971552.230032889,8],[971552.378368874,9],[971552.529643662,13],[971552.683679023,8],[971552.83385894,20],[971552.985347055,17],[971553.142580869,20],[971553.296276738,13],[971553.447035549,2],[971553.599204519,16],[971553.784564609,6],[971553.934911159,15],[971554.088677984,8],[971554.283751111,15],[971554.470195131,16],[971554.702375635,21],[971554.978280339,10],[971555.141155318,8],[971555.291565157,25],[971555.443120988,18],[971555.593745667,13],[971555.779532456,55],[971555.936215012,11],[971556.133783947,10],[971556.285217302,11],[971556.434222991,15],[971556.592188789,17],[971556.743186737,14],[971556.93239985,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-dabfbe5094aa4190ba98aeac","runtime":{"accepted":176,"cached":30,"decode_s":13.4785,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1951,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971543.213679985,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23906491696834564,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.91755763764808,"done":971556.942519517,"finish_reason":"length","first":971543.451944155,"full_response_s":13.72986031905748,"last":971556.931485483,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971543.451944155,3],[971543.587117853,11],[971543.770184118,30],[971543.956325041,19],[971544.115450575,21],[971544.300368478,15],[971544.451500602,19],[971544.600713621,17],[971544.750705178,6],[971544.899738219,11],[971545.05345316,5],[971545.247095943,27],[971545.431248706,12],[971545.616790397,13],[971545.800678751,5],[971545.956227491,16],[971546.150053391,5],[971546.335313686,16],[971546.524185673,7],[971546.678308172,22],[971546.825588661,10],[971547.013050798,7],[971547.210488507,23],[971547.35915718,5],[971547.511596974,9],[971547.683596249,14],[971547.834331648,20],[971547.985601634,8],[971548.14268881,12],[971548.296551316,5],[971548.449095346,14],[971548.597036035,11],[971548.750604227,7],[971548.900182136,9],[971549.051245131,8],[971549.234542244,3],[971549.420890708,10],[971549.571328963,11],[971549.7572265,9],[971549.942625149,10],[971550.137177706,20],[971550.341124373,14],[971550.516992329,14],[971550.747059064,13],[971550.894929604,5],[971551.069582021,14],[971551.306953136,11],[971551.54275351,32],[971551.72953373,33],[971551.882796493,11],[971552.069320167,6],[971552.230192063,8],[971552.377895498,9],[971552.528723295,13],[971552.681592392,8],[971552.832951678,20],[971552.983823404,17],[971553.143861888,20],[971553.295569322,13],[971553.44683583,2],[971553.598575634,16],[971553.783871529,6],[971553.933461942,15],[971554.087886245,8],[971554.284351931,15],[971554.470613817,16],[971554.701863794,21],[971554.980172994,10],[971555.138636561,8],[971555.290568628,25],[971555.440435041,18],[971555.593175744,13],[971555.781374054,55],[971555.932075945,11],[971556.13433691,10],[971556.285126419,11],[971556.433999112,15],[971556.592078289,17],[971556.743659457,14],[971556.931485483,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-4924eebd7d164d0e93d15c62","runtime":{"accepted":176,"cached":30,"decode_s":13.4785,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1951,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971543.212659198,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2392849570605904,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.91840784532012,"done":971556.942668114,"finish_reason":"length","first":971543.452470621,"full_response_s":13.728693558950908,"last":971556.931406168,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971543.452470621,3],[971543.590264681,11],[971543.769429036,30],[971543.956821922,19],[971544.114062191,21],[971544.302563065,15],[971544.452771493,19],[971544.601104626,17],[971544.751245613,6],[971544.901901028,11],[971545.050423664,5],[971545.242875847,27],[971545.431532604,12],[971545.617157721,13],[971545.801192241,5],[971545.957377866,16],[971546.150669748,5],[971546.337395997,16],[971546.527996891,7],[971546.679215051,22],[971546.826088326,10],[971547.012781109,7],[971547.210187201,23],[971547.359358003,5],[971547.515084421,9],[971547.684277936,14],[971547.834939636,20],[971547.985037119,8],[971548.143881026,12],[971548.296964818,5],[971548.448418011,14],[971548.597940194,11],[971548.749716069,7],[971548.899533666,9],[971549.050751882,8],[971549.234165847,3],[971549.423229796,10],[971549.573039437,11],[971549.758619235,9],[971549.944597456,10],[971550.137813743,20],[971550.342791469,14],[971550.517477065,14],[971550.74629827,13],[971550.894761118,5],[971551.071240206,14],[971551.307521779,11],[971551.542602449,32],[971551.73070457,33],[971551.881943536,11],[971552.071804747,6],[971552.229959575,8],[971552.378711109,9],[971552.528672973,13],[971552.681925747,8],[971552.834064979,20],[971552.9841878,17],[971553.142317756,20],[971553.296128925,13],[971553.44885561,2],[971553.59947792,16],[971553.783786582,6],[971553.934850677,15],[971554.08838903,8],[971554.283162739,15],[971554.469706235,16],[971554.701493701,21],[971554.981044208,10],[971555.138901114,8],[971555.291029891,25],[971555.44133312,18],[971555.594939051,13],[971555.779370418,55],[971555.932224942,11],[971556.133972242,10],[971556.284341945,11],[971556.434396133,15],[971556.592316777,17],[971556.743746276,14],[971556.931406168,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-8cbd461b82fd44efb8dba0fa","runtime":{"accepted":176,"cached":30,"decode_s":13.4785,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1951,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971543.213974555,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23849606595467776,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.917435075654904,"done":971556.944486847,"finish_reason":"length","first":971543.451643697,"full_response_s":13.731528231059201,"last":971556.931272356,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971543.451643697,3],[971543.588793158,11],[971543.771067172,30],[971543.957385637,19],[971544.114184819,21],[971544.30096709,15],[971544.451986667,19],[971544.600868282,17],[971544.751846433,6],[971544.902195454,11],[971545.051442851,5],[971545.243767445,27],[971545.431470522,12],[971545.616965923,13],[971545.802594449,5],[971545.958113587,16],[971546.150251749,5],[971546.336688389,16],[971546.525701917,7],[971546.67724916,22],[971546.825221337,10],[971547.012485499,7],[971547.211805,23],[971547.362515359,5],[971547.511876264,9],[971547.684398997,14],[971547.834489941,20],[971547.984964348,8],[971548.143043894,12],[971548.297126328,5],[971548.448846329,14],[971548.599087753,11],[971548.748458314,7],[971548.898960478,9],[971549.050532419,8],[971549.234104757,3],[971549.420550921,10],[971549.572060811,11],[971549.756631327,9],[971549.943817045,10],[971550.13659263,20],[971550.341190535,14],[971550.518052733,14],[971550.746396066,13],[971550.894818384,5],[971551.069512531,14],[971551.306014689,11],[971551.543033279,32],[971551.730789212,33],[971551.882084853,11],[971552.069972573,6],[971552.230939816,8],[971552.378057647,9],[971552.529886358,13],[971552.683761441,8],[971552.833156453,20],[971552.986037671,17],[971553.142241545,20],[971553.296528891,13],[971553.446904937,2],[971553.600206649,16],[971553.784892348,6],[971553.933600683,15],[971554.088747154,8],[971554.282335095,15],[971554.470123545,16],[971554.706475053,21],[971554.977250016,10],[971555.138738948,8],[971555.290647591,25],[971555.441949412,18],[971555.59311067,13],[971555.778065398,55],[971555.931993799,11],[971556.133855758,10],[971556.285046288,11],[971556.436813158,15],[971556.592582658,17],[971556.742833797,14],[971556.931272356,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-6f80d3553fd94a4d90389f75","runtime":{"accepted":176,"cached":30,"decode_s":13.4785,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1951,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971543.212958616,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23868508101440966,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.91920999766538,"done":971556.946990275,"finish_reason":"length","first":971543.452830121,"full_response_s":13.734112814068794,"last":971556.931194177,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971543.452830121,3],[971543.588339431,11],[971543.770085651,30],[971543.956255631,19],[971544.113927227,21],[971544.301532085,15],[971544.454529442,19],[971544.600944861,17],[971544.750441409,6],[971544.899489298,11],[971545.050854991,5],[971545.243029996,27],[971545.435390367,12],[971545.618253535,13],[971545.80145169,5],[971545.958858125,16],[971546.15038017,5],[971546.335881034,16],[971546.524543525,7],[971546.677732408,22],[971546.82573321,10],[971547.012109054,7],[971547.210584078,23],[971547.363517313,5],[971547.512329047,9],[971547.68710016,14],[971547.833468354,20],[971547.983680817,8],[971548.14358148,12],[971548.295582003,5],[971548.448100832,14],[971548.597356478,11],[971548.749140322,7],[971548.900288155,9],[971549.051753564,8],[971549.232889836,3],[971549.421631357,10],[971549.572809381,11],[971549.760115814,9],[971549.943471514,10],[971550.138052807,20],[971550.340443614,14],[971550.517559068,14],[971550.747255583,13],[971550.894853425,5],[971551.071831842,14],[971551.307881168,11],[971551.541310117,32],[971551.730132646,33],[971551.883350544,11],[971552.070401131,6],[971552.229409524,8],[971552.377646433,9],[971552.529807939,13],[971552.682799345,8],[971552.834233097,20],[971552.985608904,17],[971553.142080164,20],[971553.29639911,13],[971553.446552157,2],[971553.599918863,16],[971553.78395958,6],[971553.934805476,15],[971554.088837541,8],[971554.283641155,15],[971554.470917875,16],[971554.701556264,21],[971554.978071724,10],[971555.138964028,8],[971555.290492449,25],[971555.440619896,18],[971555.592711856,13],[971555.779479286,55],[971555.93232285,11],[971556.136174556,10],[971556.2866986,11],[971556.43447388,15],[971556.592683046,17],[971556.743332038,14],[971556.931194177,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-b3ff3a643b0a46a491bbc8cd","runtime":{"accepted":176,"cached":30,"decode_s":13.4785,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1951,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971543.212877461,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23995266004931182,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.916455468224154,"done":971556.947124791,"finish_reason":"length","first":971543.451691298,"full_response_s":13.732739293947816,"last":971556.932018013,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971543.451691298,3],[971543.588896058,11],[971543.769655428,30],[971543.956479238,19],[971544.115136788,21],[971544.302803457,15],[971544.451398919,19],[971544.602991395,17],[971544.750573414,6],[971544.901767488,11],[971545.051523718,5],[971545.243894537,27],[971545.431384695,12],[971545.618074697,13],[971545.800834821,5],[971545.95631239,16],[971546.150875355,5],[971546.335732565,16],[971546.526184413,7],[971546.677997217,22],[971546.827115465,10],[971547.012030396,7],[971547.212142163,23],[971547.360980618,5],[971547.513165299,9],[971547.685439224,14],[971547.833607655,20],[971547.98478263,8],[971548.145412358,12],[971548.297533686,5],[971548.449472431,14],[971548.599403635,11],[971548.748860008,7],[971548.899377308,9],[971549.049993489,8],[971549.235970868,3],[971549.422156607,10],[971549.573093454,11],[971549.756385639,9],[971549.944126192,10],[971550.137918163,20],[971550.341806044,14],[971550.517643183,14],[971550.748546986,13],[971550.896520777,5],[971551.070010788,14],[971551.306639654,11],[971551.541904649,32],[971551.73419808,33],[971551.88135574,11],[971552.069626529,6],[971552.22987898,8],[971552.37753811,9],[971552.52954609,13],[971552.681815488,8],[971552.834297051,20],[971552.986425892,17],[971553.142492066,20],[971553.298245653,13],[971553.446777028,2],[971553.600431009,16],[971553.784237174,6],[971553.934448408,15],[971554.088013129,8],[971554.283280247,15],[971554.470344816,16],[971554.701640266,21],[971554.977101963,10],[971555.139657619,8],[971555.291382511,25],[971555.441556423,18],[971555.593516203,13],[971555.779691101,55],[971555.933925735,11],[971556.134465458,10],[971556.284494702,11],[971556.434988793,15],[971556.593269529,17],[971556.743041004,14],[971556.932018013,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-e232a4ee45e043d9a79dbad2","runtime":{"accepted":176,"cached":30,"decode_s":13.4786,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1951,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971543.214385497,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23730580101255327,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.918357651610577,"done":971556.948133113,"finish_reason":"length","first":971543.451894265,"full_response_s":13.734601901029237,"last":971556.930865574,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971543.451894265,3],[971543.587642431,11],[971543.769557249,30],[971543.956387075,19],[971544.11491182,21],[971544.304186016,15],[971544.453669716,19],[971544.601597571,17],[971544.751412531,6],[971544.89914039,11],[971545.051096391,5],[971545.24360872,27],[971545.435619431,12],[971545.618702718,13],[971545.800751058,5],[971545.958977105,16],[971546.150459485,5],[971546.335820088,16],[971546.524615352,7],[971546.678793741,22],[971546.826456883,10],[971547.013180691,7],[971547.211316007,23],[971547.360052283,5],[971547.511778756,9],[971547.684944071,14],[971547.834890259,20],[971547.984621313,8],[971548.143460068,12],[971548.29601541,5],[971548.4476344,14],[971548.598493716,11],[971548.748511356,7],[971548.901104951,9],[971549.051601703,8],[971549.234453425,3],[971549.42134754,10],[971549.572403143,11],[971549.757836568,9],[971549.942889478,10],[971550.137096263,20],[971550.342130471,14],[971550.517933689,14],[971550.747880772,13],[971550.896110635,5],[971551.06977518,14],[971551.305625891,11],[971551.54333601,32],[971551.729039041,33],[971551.884285327,11],[971552.070788233,6],[971552.228676892,8],[971552.37844142,9],[971552.528600106,13],[971552.682294096,8],[971552.833366284,20],[971552.984441841,17],[971553.143934834,20],[971553.296591917,13],[971553.448987759,2],[971553.600295708,16],[971553.784777528,6],[971553.935085837,15],[971554.088225312,8],[971554.283331192,15],[971554.470500357,16],[971554.702196365,21],[971554.97820472,10],[971555.139908572,8],[971555.290286346,25],[971555.441022549,18],[971555.594048605,13],[971555.781594429,55],[971555.932376035,11],[971556.134974915,10],[971556.284697125,11],[971556.435503162,15],[971556.593598148,17],[971556.742918696,14],[971556.930865574,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-f924c85f1d614feab3700c3e","runtime":{"accepted":176,"cached":30,"decode_s":13.4785,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1951,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971543.213531212,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.23836305306758732,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"python","prompt":"chat","streams":16,"burst":2,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":30,"case_id":null,"complete":true,"decode_tps":18.91991100786407,"done":971556.945119636,"finish_reason":"length","first":971543.453237831,"full_response_s":13.73259132297244,"last":971556.931102494,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971543.453237831,3],[971543.588210946,11],[971543.770292554,30],[971543.956437397,19],[971544.115540146,21],[971544.301388592,15],[971544.451840246,19],[971544.601652229,17],[971544.752015095,6],[971544.899246042,11],[971545.052067464,5],[971545.243248899,27],[971545.435239946,12],[971545.617204843,13],[971545.801506188,5],[971545.956949564,16],[971546.151182149,5],[971546.33653608,16],[971546.524825135,7],[971546.678901088,22],[971546.824994225,10],[971547.012196625,7],[971547.210858935,23],[971547.360553244,5],[971547.512015308,9],[971547.68450972,14],[971547.834224668,20],[971547.983935497,8],[971548.145575532,12],[971548.296085908,5],[971548.447978956,14],[971548.59811556,11],[971548.748651425,7],[971548.899589043,9],[971549.05027665,8],[971549.233548018,3],[971549.423302758,10],[971549.57272709,11],[971549.756950186,9],[971549.943985323,10],[971550.136976451,20],[971550.34271353,14],[971550.517062875,14],[971550.746562007,13],[971550.895707614,5],[971551.071306432,14],[971551.306726857,11],[971551.541657921,32],[971551.729600948,33],[971551.882307836,11],[971552.070539488,6],[971552.228870658,8],[971552.378782568,9],[971552.528081657,13],[971552.68198863,8],[971552.833966976,20],[971552.985909762,17],[971553.143132295,20],[971553.29674469,13],[971553.448933933,2],[971553.599152053,16],[971553.784700613,6],[971553.93392527,15],[971554.089510204,8],[971554.282755813,15],[971554.470698588,16],[971554.701428595,21],[971554.978772499,10],[971555.139750102,8],[971555.291141575,25],[971555.440949939,18],[971555.593963162,13],[971555.779140987,55],[971555.933357892,11],[971556.135287854,10],[971556.284205364,11],[971556.434608124,15],[971556.593077411,17],[971556.742482586,14],[971556.931102494,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-b9962544d4074739977c58a7","runtime":{"accepted":176,"cached":30,"decode_s":13.4786,"drafted":374,"drafts":true,"min_rows":4,"prefill_s":0.1951,"rounds":79,"token_sha":"8a91591c94a3"},"seed":1234,"sent":971543.212528313,"speculative":{},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.24070951796602458,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":30},"total_tokens":287},"work":{"accepted":176,"drafted":374,"rounds":79},"work_source":"tensorfold","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":1,"burst":null,"stream":0,"phase":"warmup","request":{"cache_state":"cold","cached_tokens":0,"case_id":null,"complete":true,"decode_tps":57.99492924395294,"done":971335.145098157,"finish_reason":"length","first":971334.886413461,"full_response_s":0.409933440038003,"last":971335.145056763,"output_sha256":"26fc9e1892da6e23aa1a0cb06681c20c4a62f7257e19635806de87234b9035bb","pieces":[[971334.886413461,2],[971334.978099088,7],[971335.061988153,4],[971335.145056763,73]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":16,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"e9df2e35a58091c749bae4e1446600aeb669237cc39db72a41d5cae938d5620a","response_id":"cmpl-58a11d377c4e2c689426d3837262a47c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.126212195,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":0.25901612,"time_to_first_token":0.126729516,"token_sha":"41b4449e1b18","tokens_per_second":57.911453541964875},"seed":1234,"sent":971334.735164717,"speculative":{"acceptance_rate":0.26666666666666666,"accepted":12,"drafted":45,"rounds":3,"tokens_per_round":5.333333333333333},"token_sha":"41b4449e1b18","tokens":16,"ttft_s":0.1512487439904362,"usage":{"completion_tokens":16,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":0},"total_tokens":30},"work":{"accepted":12,"drafted":45,"rounds":3},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":1,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":69.65976817548925,"done":971338.816201289,"finish_reason":"length","first":971335.155505707,"full_response_s":3.6699776059249416,"last":971338.816155271,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971335.155505707,2],[971335.243333247,7],[971335.324017792,4],[971335.40414263,73],[971335.484500984,51],[971335.564645552,21],[971335.644763478,14],[971335.724307889,20],[971335.80460632,16],[971335.885613515,15],[971335.971024501,23],[971336.055413072,23],[971336.13561146,25],[971336.215813176,36],[971336.296216885,14],[971336.377309156,6],[971336.45771581,18],[971336.539615478,18],[971336.619868349,19],[971336.700323389,8],[971336.780908931,11],[971336.862448674,18],[971336.94699627,15],[971337.031219978,39],[971337.112260783,30],[971337.193128045,14],[971337.273761727,15],[971337.354739585,8],[971337.435241326,6],[971337.515473949,15],[971337.595553701,23],[971337.675746771,22],[971337.756197756,26],[971337.837760969,35],[971337.918434151,31],[971338.005162098,12],[971338.088433819,13],[971338.168602369,38],[971338.249075238,47],[971338.329614573,25],[971338.411444674,11],[971338.491303274,34],[971338.574098636,12],[971338.654959379,36],[971338.734493291,60],[971338.816155271,48]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-53d77910a8a4196524230e0d12412293","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.007757008,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":3.661208663,"time_to_first_token":0.00842976,"token_sha":"2b28aa2108de","tokens_per_second":69.64913051173997},"seed":1234,"sent":971335.146223683,"speculative":{"acceptance_rate":0.31555555555555553,"accepted":213,"drafted":675,"rounds":45,"tokens_per_round":5.688888888888889},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.009282023995183408,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":213,"drafted":675,"rounds":45},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":1,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":69.49616723093884,"done":971342.49016485,"finish_reason":"length","first":971338.820777937,"full_response_s":3.6726459950441495,"last":971342.490045037,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971338.820777937,2],[971338.908343277,7],[971338.994783733,4],[971339.077457771,73],[971339.157951418,51],[971339.238139499,21],[971339.318049999,14],[971339.399371382,20],[971339.479343164,16],[971339.559623634,15],[971339.639644715,23],[971339.719778697,23],[971339.800052862,25],[971339.880988317,36],[971339.966678923,14],[971340.051266196,6],[971340.132040235,18],[971340.21193468,18],[971340.291879255,19],[971340.372754386,8],[971340.453285021,11],[971340.535833623,18],[971340.617476839,15],[971340.697554924,39],[971340.778114057,30],[971340.85877327,14],[971340.944348616,15],[971341.028880952,8],[971341.109796399,6],[971341.189997044,15],[971341.270058579,23],[971341.351129794,22],[971341.431589187,26],[971341.512075046,35],[971341.59254748,31],[971341.672937046,12],[971341.753416104,13],[971341.834565881,38],[971341.915938287,47],[971342.002457686,25],[971342.085891101,11],[971342.166617701,34],[971342.246830389,12],[971342.326838571,36],[971342.407904019,60],[971342.490045037,48]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-527ec10eca0bf7f4d9d871600819b989","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.002206392,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":3.669342512,"time_to_first_token":0.002832278,"token_sha":"2b28aa2108de","tokens_per_second":69.49473895284049},"seed":1234,"sent":971338.817518855,"speculative":{"acceptance_rate":0.31555555555555553,"accepted":213,"drafted":675,"rounds":45,"tokens_per_round":5.688888888888889},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.00325908197555691,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":213,"drafted":675,"rounds":45},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":1,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":69.44959816527007,"done":971346.166988149,"finish_reason":"length","first":971342.495191438,"full_response_s":3.675162165076472,"last":971346.166918946,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971342.495191438,2],[971342.582957664,7],[971342.663043626,4],[971342.743411553,73],[971342.823647472,51],[971342.904578124,21],[971342.991640598,14],[971343.074797961,20],[971343.15481921,16],[971343.235145913,15],[971343.315334306,23],[971343.396336256,23],[971343.476491783,25],[971343.556722978,36],[971343.636874857,14],[971343.717470964,6],[971343.797794387,18],[971343.878799533,18],[971343.964742092,19],[971344.049056511,8],[971344.129872255,11],[971344.209898122,18],[971344.290055563,15],[971344.370989968,39],[971344.451274135,30],[971344.533516298,14],[971344.614322713,15],[971344.694716437,8],[971344.775702845,6],[971344.856792566,15],[971344.940696672,23],[971345.026333338,22],[971345.107824595,26],[971345.187942189,35],[971345.268734709,31],[971345.350053894,12],[971345.430573634,13],[971345.510910309,38],[971345.591411696,47],[971345.672060018,25],[971345.752538396,11],[971345.833603024,34],[971345.914506087,12],[971346.0020461,36],[971346.085093231,60],[971346.166918946,48]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-5f78a3c47eb0eedb66f87fe35b2eff5e","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.00222452,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":3.671749685,"time_to_first_token":0.002687454,"token_sha":"2b28aa2108de","tokens_per_second":69.4491786958511},"seed":1234,"sent":971342.491825984,"speculative":{"acceptance_rate":0.31555555555555553,"accepted":213,"drafted":675,"rounds":45,"tokens_per_round":5.688888888888889},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.0033654540311545134,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":213,"drafted":675,"rounds":45},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.763658367235543,"done":971356.308485388,"finish_reason":"length","first":971346.410789039,"full_response_s":10.136830557021312,"last":971356.308451722,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971346.410789039,2],[971346.561363347,7],[971346.706528507,4],[971346.919108111,63],[971347.154628821,10],[971347.336326357,31],[971347.51601548,29],[971347.697139517,22],[971347.87914279,14],[971348.067342854,24],[971348.250348709,4],[971348.395812677,13],[971348.579934647,21],[971348.76138963,2],[971348.944087125,18],[971349.129408241,29],[971349.364486512,27],[971349.597142702,24],[971349.74624438,4],[971349.893346071,16],[971350.082628349,10],[971350.263949186,31],[971350.411165518,8],[971350.594224756,11],[971350.777946232,16],[971350.961862346,12],[971351.146932623,39],[971351.317794404,18],[971351.499574897,11],[971351.681484324,16],[971351.864489782,16],[971352.018977883,11],[971352.200737193,6],[971352.38423348,9],[971352.569560891,29],[971352.754426489,22],[971352.939299613,8],[971353.08942419,18],[971353.274822406,18],[971353.4591155,34],[971353.639615827,10],[971353.822463253,14],[971354.015340248,13],[971354.199815032,2],[971354.382627692,36],[971354.565659226,42],[971354.748614244,26],[971354.898547194,17],[971355.087036421,34],[971355.32428675,12],[971355.507545657,36],[971355.791357211,50],[971355.978532141,2],[971356.308451722,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-59faef210f1ac562cce4faa77b9a4ed9","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.147271962,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.897497829,"time_to_first_token":0.232696485,"token_sha":"2b28aa2108de","tokens_per_second":25.764087490157507},"seed":1234,"sent":971346.171654831,"speculative":{"acceptance_rate":0.5670391061452514,"accepted":203,"drafted":358,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.23913420794997364,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":358,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":1,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.762811481636827,"done":971356.306872226,"finish_reason":"length","first":971346.408837684,"full_response_s":10.135026698932052,"last":971356.306825727,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971346.408837684,2],[971346.559614338,7],[971346.704843949,4],[971346.918984809,63],[971347.152910565,10],[971347.334046011,31],[971347.516654709,29],[971347.697352231,22],[971347.879232202,14],[971348.069620191,24],[971348.250658339,4],[971348.395607451,13],[971348.580068222,21],[971348.761278457,2],[971348.943832937,18],[971349.129878455,29],[971349.362486467,27],[971349.596258789,24],[971349.745795543,4],[971349.89254797,16],[971350.081057252,10],[971350.26312422,31],[971350.410103277,8],[971350.593733821,11],[971350.775279757,16],[971350.963239546,12],[971351.146314419,39],[971351.318077905,18],[971351.500046247,11],[971351.680794932,16],[971351.863681505,16],[971352.019678267,11],[971352.201143404,6],[971352.38396702,9],[971352.570592939,29],[971352.753742777,22],[971352.940695374,8],[971353.089594886,18],[971353.274326944,18],[971353.457758398,34],[971353.641595822,10],[971353.822706688,14],[971354.014387436,13],[971354.198655523,2],[971354.378794988,36],[971354.564947497,42],[971354.749015895,26],[971354.897102088,17],[971355.086774905,34],[971355.323395445,12],[971355.508082401,36],[971355.788590268,50],[971355.979772565,2],[971356.306825727,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-ae1f456371b543342605fbe22ace2551","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.147356638,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.897849334,"time_to_first_token":0.231000165,"token_sha":"2b28aa2108de","tokens_per_second":25.76317252315128},"seed":1234,"sent":971346.171845527,"speculative":{"acceptance_rate":0.5686274509803921,"accepted":203,"drafted":357,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.23699215694796294,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":357,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":2,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.759745154655104,"done":971356.309143546,"finish_reason":"length","first":971346.409928983,"full_response_s":10.1346749040531,"last":971356.309095239,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971346.409928983,2],[971346.559200702,7],[971346.705427576,4],[971346.91727529,63],[971347.152243926,10],[971347.33699154,31],[971347.516793708,29],[971347.697578833,22],[971347.878315167,14],[971348.070035299,24],[971348.249633427,4],[971348.396516149,13],[971348.579443249,21],[971348.760566536,2],[971348.944165961,18],[971349.129623819,29],[971349.36315621,27],[971349.597454108,24],[971349.745358227,4],[971349.893144398,16],[971350.08196027,10],[971350.264205326,31],[971350.411382376,8],[971350.594159281,11],[971350.77445191,16],[971350.962041314,12],[971351.150401968,39],[971351.317518695,18],[971351.500739111,11],[971351.684235251,16],[971351.864183112,16],[971352.017211417,11],[971352.201335621,6],[971352.385324666,9],[971352.570150038,29],[971352.756739219,22],[971352.938217468,8],[971353.090333672,18],[971353.274633854,18],[971353.458978694,34],[971353.63846747,10],[971353.822597019,14],[971354.015773532,13],[971354.198965393,2],[971354.379263201,36],[971354.565564134,42],[971354.747514834,26],[971354.89818961,17],[971355.086514237,34],[971355.32459614,12],[971355.506329793,36],[971355.789247114,50],[971355.978766935,2],[971356.309095239,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-7fccef684f539cd4d904411db059b1fe","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.14764734,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.900238323,"time_to_first_token":0.228761917,"token_sha":"2b28aa2108de","tokens_per_second":25.756955709600447},"seed":1234,"sent":971346.174468642,"speculative":{"acceptance_rate":0.5702247191011236,"accepted":203,"drafted":356,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2354603409767151,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":356,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":3,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.76005672967825,"done":971356.308832763,"finish_reason":"length","first":971346.40973275,"full_response_s":10.13550006202422,"last":971356.308779273,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971346.40973275,2],[971346.559088873,7],[971346.706125305,4],[971346.919758605,63],[971347.154226243,10],[971347.335714089,31],[971347.517689125,29],[971347.696336999,22],[971347.878204554,14],[971348.067668501,24],[971348.250194477,4],[971348.3976114,13],[971348.579320011,21],[971348.760727232,2],[971348.944666,18],[971349.129997517,29],[971349.363704347,27],[971349.595947382,24],[971349.744223918,4],[971349.892992055,16],[971350.082853047,10],[971350.264418264,31],[971350.409877954,8],[971350.593641945,11],[971350.77491966,16],[971350.96219801,12],[971351.147337554,39],[971351.318578392,18],[971351.500588096,11],[971351.682385646,16],[971351.863075253,16],[971352.019805857,11],[971352.202513531,6],[971352.384445778,9],[971352.572634265,29],[971352.75553718,22],[971352.938733619,8],[971353.089173186,18],[971353.276737119,18],[971353.459599058,34],[971353.64055155,10],[971353.822818486,14],[971354.01430196,13],[971354.199995264,2],[971354.382969084,36],[971354.565049326,42],[971354.747983479,26],[971354.898117127,17],[971355.086127275,34],[971355.325202552,12],[971355.507078275,36],[971355.790369965,50],[971355.980068339,2],[971356.308779273,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-007f0f807cb84a7c93c02d4ab8c946e7","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.147572904,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.900134734,"time_to_first_token":0.229271285,"token_sha":"2b28aa2108de","tokens_per_second":25.757225214749283},"seed":1234,"sent":971346.173332701,"speculative":{"acceptance_rate":0.5686274509803921,"accepted":203,"drafted":357,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.23640004906337708,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":357,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":4,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.76315828267888,"done":971356.307739833,"finish_reason":"length","first":971346.409843859,"full_response_s":10.135801341035403,"last":971356.307698664,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971346.409843859,2],[971346.559394327,7],[971346.705283153,4],[971346.91740976,63],[971347.152158434,10],[971347.334700473,31],[971347.51529495,29],[971347.696607396,22],[971347.879649213,14],[971348.068751527,24],[971348.250063383,4],[971348.395125381,13],[971348.579217606,21],[971348.75991497,2],[971348.943604671,18],[971349.131334843,29],[971349.362247048,27],[971349.596137103,24],[971349.746481895,4],[971349.89311342,16],[971350.083231977,10],[971350.264025366,31],[971350.410655958,8],[971350.592997851,11],[971350.774748548,16],[971350.962860664,12],[971351.150829843,39],[971351.319359436,18],[971351.499689126,11],[971351.681365567,16],[971351.863327728,16],[971352.017628076,11],[971352.201894463,6],[971352.383831141,9],[971352.572171379,29],[971352.757369808,22],[971352.938448214,8],[971353.089953814,18],[971353.275455027,18],[971353.457361611,34],[971353.638614341,10],[971353.823658044,14],[971354.01365513,13],[971354.198439049,2],[971354.378944307,36],[971354.566187218,42],[971354.749586785,26],[971354.897933406,17],[971355.086599089,34],[971355.323564173,12],[971355.507171288,36],[971355.79112064,50],[971355.979669905,2],[971356.307698664,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-30d2fa3ae1ea112943a8d15e52001303","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.147475924,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.898462129,"time_to_first_token":0.229999911,"token_sha":"2b28aa2108de","tokens_per_second":25.761577574047006},"seed":1234,"sent":971346.171938492,"speculative":{"acceptance_rate":0.5686274509803921,"accepted":203,"drafted":357,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.23790536704473197,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":357,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":5,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.764331404729756,"done":971356.307949043,"finish_reason":"length","first":971346.410496945,"full_response_s":10.135559921967797,"last":971356.307901073,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971346.410496945,2],[971346.558062601,7],[971346.705952032,4],[971346.917517077,63],[971347.152780175,10],[971347.338060086,31],[971347.515606181,29],[971347.697744745,22],[971347.878378786,14],[971348.06899429,24],[971348.250752359,4],[971348.396224536,13],[971348.579587271,21],[971348.760960762,2],[971348.943190075,18],[971349.130165204,29],[971349.362945496,27],[971349.596704122,24],[971349.745178954,4],[971349.892825599,16],[971350.082252059,10],[971350.264839915,31],[971350.410556722,8],[971350.594309992,11],[971350.778338762,16],[971350.963347055,12],[971351.148367762,39],[971351.319206181,18],[971351.499952403,11],[971351.684508352,16],[971351.863927916,16],[971352.01822636,11],[971352.202670482,6],[971352.385616136,9],[971352.570275996,29],[971352.753315174,22],[971352.939049794,8],[971353.089748349,18],[971353.274755043,18],[971353.458573987,34],[971353.639968515,10],[971353.82300907,14],[971354.015090364,13],[971354.199616623,2],[971354.381179353,36],[971354.565442448,42],[971354.748287973,26],[971354.896608065,17],[971355.085949939,34],[971355.325987644,12],[971355.508172214,36],[971355.789148581,50],[971355.978941007,2],[971356.307901073,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-511194c800515779786cf21f374f4e91","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.147409041,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.89794673,"time_to_first_token":0.230003736,"token_sha":"2b28aa2108de","tokens_per_second":25.762919013002207},"seed":1234,"sent":971346.172389121,"speculative":{"acceptance_rate":0.5686274509803921,"accepted":203,"drafted":357,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.23810782399959862,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":357,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":6,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.76427092337104,"done":971356.307329815,"finish_reason":"length","first":971346.408941977,"full_response_s":10.13523213204462,"last":971356.306369339,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971346.408941977,2],[971346.559430025,7],[971346.706571629,4],[971346.918269256,63],[971347.15362335,10],[971347.33415136,31],[971347.514745229,29],[971347.697057369,22],[971347.878608461,14],[971348.070361378,24],[971348.25287137,4],[971348.39613994,13],[971348.579039694,21],[971348.760810932,2],[971348.943674738,18],[971349.13024964,29],[971349.363252407,27],[971349.59650288,24],[971349.746183737,4],[971349.893471069,16],[971350.081508585,10],[971350.263015799,31],[971350.41198826,8],[971350.593811872,11],[971350.774668256,16],[971350.961675138,12],[971351.146631089,39],[971351.318673421,18],[971351.500413192,11],[971351.681838453,16],[971351.863983742,16],[971352.017559801,11],[971352.200859023,6],[971352.385543092,9],[971352.572055614,29],[971352.753151502,22],[971352.94061689,8],[971353.089515874,18],[971353.276941432,18],[971353.459050553,34],[971353.640275361,10],[971353.823537799,14],[971354.014127472,13],[971354.199426022,2],[971354.381992815,36],[971354.566389484,42],[971354.747149201,26],[971354.897573454,17],[971355.087577838,34],[971355.325853142,12],[971355.505770007,36],[971355.788356449,50],[971355.979012931,2],[971356.306369339,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-86900522aa2e1f97f0f7da4fad0928f0","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.147310028,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.897900056,"time_to_first_token":0.232529245,"token_sha":"2b28aa2108de","tokens_per_second":25.763040499224054},"seed":1234,"sent":971346.172097683,"speculative":{"acceptance_rate":0.5670391061452514,"accepted":203,"drafted":358,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.23684429400600493,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":358,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":7,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.761913350804104,"done":971356.308941104,"finish_reason":"length","first":971346.410547572,"full_response_s":10.136925296974368,"last":971356.308880686,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971346.410547572,2],[971346.561089174,7],[971346.706025172,4],[971346.918558773,63],[971347.155514526,10],[971347.337699717,31],[971347.517016758,29],[971347.696671287,22],[971347.879988189,14],[971348.068524364,24],[971348.249103579,4],[971348.396709598,13],[971348.578946266,21],[971348.760090898,2],[971348.943795095,18],[971349.130325148,29],[971349.362358509,27],[971349.596835248,24],[971349.744111513,4],[971349.893579298,16],[971350.080693203,10],[971350.262498255,31],[971350.410199601,8],[971350.593224949,11],[971350.77483132,16],[971350.961420358,12],[971351.148451941,39],[971351.319776176,18],[971351.499337942,11],[971351.681886071,16],[971351.86370805,16],[971352.018033263,11],[971352.201030471,6],[971352.384358158,9],[971352.571710718,29],[971352.754755112,22],[971352.939455605,8],[971353.090227827,18],[971353.27420681,18],[971353.459829533,34],[971353.640914831,10],[971353.823604058,14],[971354.01376992,13],[971354.19780294,2],[971354.379867469,36],[971354.56457244,42],[971354.751224124,26],[971354.898800262,17],[971355.086400632,34],[971355.325054801,12],[971355.50609007,36],[971355.789541207,50],[971355.980496631,2],[971356.308880686,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-4f8c46361740652cb4d62c5ff0884288","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.147610058,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.900186737,"time_to_first_token":0.228912724,"token_sha":"2b28aa2108de","tokens_per_second":25.75708991902018},"seed":1234,"sent":971346.172015807,"speculative":{"acceptance_rate":0.5702247191011236,"accepted":203,"drafted":356,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.23853176494594663,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":356,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":8,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.76438942623844,"done":971356.307205729,"finish_reason":"length","first":971346.409792704,"full_response_s":10.132191221928224,"last":971356.307174543,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971346.409792704,2],[971346.5595776,7],[971346.706400117,4],[971346.917855749,63],[971347.153272358,10],[971347.334603989,31],[971347.51464924,29],[971347.697278819,22],[971347.878795589,14],[971348.069543596,24],[971348.250229919,4],[971348.397479842,13],[971348.580629448,21],[971348.760671757,2],[971348.94329096,18],[971349.13006056,29],[971349.363576534,27],[971349.596565571,24],[971349.744924559,4],[971349.893535184,16],[971350.08244578,10],[971350.265065206,31],[971350.410779724,8],[971350.592889238,11],[971350.77657108,16],[971350.962903914,12],[971351.1475543,39],[971351.318151525,18],[971351.500935312,11],[971351.684752907,16],[971351.86375858,16],[971352.018907431,11],[971352.202457817,6],[971352.385874611,9],[971352.569440613,29],[971352.752967814,22],[971352.939630797,8],[971353.090275589,18],[971353.277084815,18],[971353.458490815,34],[971353.638868497,10],[971353.822313838,14],[971354.014935877,13],[971354.199241006,2],[971354.380642305,36],[971354.566530322,42],[971354.747338426,26],[971354.899328254,17],[971355.087100344,34],[971355.32437973,12],[971355.505916798,36],[971355.789213224,50],[971355.98040501,2],[971356.307174543,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-67ecac57c80bad550801c30226013dd2","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.147520342,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.898468642,"time_to_first_token":0.229777053,"token_sha":"2b28aa2108de","tokens_per_second":25.761560623429617},"seed":1234,"sent":971346.175014507,"speculative":{"acceptance_rate":0.5686274509803921,"accepted":203,"drafted":357,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.234778197016567,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":357,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":9,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.766135275504844,"done":971356.305879908,"finish_reason":"length","first":971346.40914485,"full_response_s":10.13443063898012,"last":971356.305856067,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971346.40914485,2],[971346.559962498,7],[971346.706765478,4],[971346.919490657,63],[971347.15386213,10],[971347.333932406,31],[971347.516095163,29],[971347.696442204,22],[971347.879592122,14],[971348.070569147,24],[971348.250935824,4],[971348.397424768,13],[971348.579658027,21],[971348.761045198,2],[971348.94424334,18],[971349.129545624,29],[971349.363076654,27],[971349.597660326,24],[971349.744655522,4],[971349.893300229,16],[971350.082950988,10],[971350.264580879,31],[971350.411674581,8],[971350.593458864,11],[971350.775457941,16],[971350.96254401,12],[971351.148996447,39],[971351.319029085,18],[971351.499858558,11],[971351.681126324,16],[971351.863183194,16],[971352.018869254,11],[971352.202080183,6],[971352.386152832,9],[971352.570219513,29],[971352.757479398,22],[971352.940846021,8],[971353.090666503,18],[971353.275790403,18],[971353.457984008,34],[971353.642108534,10],[971353.822058979,14],[971354.015966021,13],[971354.197054233,2],[971354.380303089,36],[971354.566112847,42],[971354.748896977,26],[971354.896741463,17],[971355.087762583,34],[971355.32472253,12],[971355.506379043,36],[971355.789067025,50],[971355.979510185,2],[971356.305856067,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-b5a623d95bfdfc1981734939ffa84493","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.147146485,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.897528599,"time_to_first_token":0.233073942,"token_sha":"2b28aa2108de","tokens_per_second":25.76400739329655},"seed":1234,"sent":971346.171449269,"speculative":{"acceptance_rate":0.5638888888888889,"accepted":203,"drafted":360,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.23769558093044907,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":360,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":10,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.758652677369742,"done":971356.308413992,"finish_reason":"length","first":971346.408784466,"full_response_s":10.13685534207616,"last":971356.308370566,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971346.408784466,2],[971346.559510333,7],[971346.705230367,4],[971346.917695805,63],[971347.151999211,10],[971347.338586014,31],[971347.514791695,29],[971347.696858992,22],[971347.879480245,14],[971348.069338002,24],[971348.252972782,4],[971348.394867369,13],[971348.580457632,21],[971348.761491731,2],[971348.943361939,18],[971349.130616025,29],[971349.363633368,27],[971349.596207891,24],[971349.744308514,4],[971349.892655175,16],[971350.081318512,10],[971350.264625137,31],[971350.410867232,8],[971350.593762958,11],[971350.775563178,16],[971350.963405361,12],[971351.145961778,39],[971351.317922122,18],[971351.499921201,11],[971351.681277755,16],[971351.864232138,16],[971352.019558645,11],[971352.200557249,6],[971352.384816771,9],[971352.57144413,29],[971352.756186586,22],[971352.938636383,8],[971353.090854592,18],[971353.276607577,18],[971353.459267891,34],[971353.638233475,10],[971353.822769075,14],[971354.013921591,13],[971354.19797802,2],[971354.379931216,36],[971354.566842528,42],[971354.749285187,26],[971354.897665442,17],[971355.086852605,34],[971355.325277003,12],[971355.506963934,36],[971355.789480548,50],[971355.979112103,2],[971356.308370566,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-ee8c5578ac29f65d13daf5a2be54556b","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.147098403,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.897650844,"time_to_first_token":0.234009538,"token_sha":"2b28aa2108de","tokens_per_second":25.763689184346422},"seed":1234,"sent":971346.17155865,"speculative":{"acceptance_rate":0.5638888888888889,"accepted":203,"drafted":360,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.23722581600304693,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":360,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":11,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.765339882365918,"done":971356.305687915,"finish_reason":"length","first":971346.408627162,"full_response_s":10.133378733997233,"last":971356.305643897,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971346.408627162,2],[971346.560501611,7],[971346.705594432,4],[971346.918661578,63],[971347.152851203,10],[971347.337390887,31],[971347.515515328,29],[971347.696191521,22],[971347.879551737,14],[971348.070439317,24],[971348.249504653,4],[971348.39597726,13],[971348.578719855,21],[971348.759769907,2],[971348.944888378,18],[971349.131643385,29],[971349.362563703,27],[971349.595484321,24],[971349.745456839,4],[971349.892922419,16],[971350.081407092,10],[971350.263505598,31],[971350.411114923,8],[971350.594062908,11],[971350.775046594,16],[971350.961936526,12],[971351.147863482,39],[971351.318628667,18],[971351.499152814,11],[971351.683988184,16],[971351.86271818,16],[971352.019484482,11],[971352.202305185,6],[971352.385803776,9],[971352.569796246,29],[971352.755722933,22],[971352.93878847,8],[971353.091140909,18],[971353.273989008,18],[971353.458124318,34],[971353.64124003,10],[971353.821852905,14],[971354.015018969,13],[971354.197242178,2],[971354.383312027,36],[971354.566770301,42],[971354.74726535,26],[971354.896370566,17],[971355.085317718,34],[971355.323699395,12],[971355.508445554,36],[971355.788665343,50],[971355.980300574,2],[971356.305643897,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-7acb6389aa4ebcd39c7b4f1bfb050472","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.147017151,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.897519991,"time_to_first_token":0.234503961,"token_sha":"2b28aa2108de","tokens_per_second":25.764029800584012},"seed":1234,"sent":971346.172309181,"speculative":{"acceptance_rate":0.5607734806629834,"accepted":203,"drafted":362,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2363179810345173,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":362,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":12,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.75736546542951,"done":971356.310302351,"finish_reason":"length","first":971346.409468561,"full_response_s":10.132792336051352,"last":971356.309549388,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971346.409468561,2],[971346.558217249,7],[971346.70512393,4],[971346.917935304,63],[971347.153478432,10],[971347.334780893,31],[971347.515700825,29],[971347.696744474,22],[971347.879300013,14],[971348.068088376,24],[971348.25222894,4],[971348.395344895,13],[971348.58023815,21],[971348.760608762,2],[971348.943745925,18],[971349.132014762,29],[971349.364116223,27],[971349.596628134,24],[971349.744160731,4],[971349.892862353,16],[971350.081584636,10],[971350.26338396,31],[971350.411792283,8],[971350.593109632,11],[971350.777573687,16],[971350.963185431,12],[971351.14993585,39],[971351.317241162,18],[971351.500361941,11],[971351.682576919,16],[971351.864619964,16],[971352.017680239,11],[971352.202396966,6],[971352.384943081,9],[971352.570561241,29],[971352.753408058,22],[971352.940326397,8],[971353.089669465,18],[971353.277170754,18],[971353.457029868,34],[971353.639344359,10],[971353.823882038,14],[971354.015537057,13],[971354.199555404,2],[971354.379691461,36],[971354.565729885,42],[971354.747663305,26],[971354.89728,17],[971355.087946607,34],[971355.325587322,12],[971355.506622526,36],[971355.789594234,50],[971355.979452503,2],[971356.309549388,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-250138b343fef4db019421ba9dbd16cb","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.147702735,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.900774411,"time_to_first_token":0.228297832,"token_sha":"2b28aa2108de","tokens_per_second":25.755561071736857},"seed":1234,"sent":971346.177510015,"speculative":{"acceptance_rate":0.5702247191011236,"accepted":203,"drafted":356,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.23195854597724974,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":356,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":13,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.171987697238333,"done":971356.306307416,"finish_reason":"length","first":971346.175953415,"full_response_s":10.133824819000438,"last":971356.306261878,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971346.175953415,2],[971346.262060481,7],[971346.558556416,4],[971346.705523644,72],[971346.918441696,1],[971347.153363322,27],[971347.33454389,30],[971347.514400188,15],[971347.696014504,14],[971347.87811583,20],[971348.069443543,14],[971348.248936691,4],[971348.397049966,13],[971348.578510581,21],[971348.759656862,2],[971348.943441175,18],[971349.129191687,29],[971349.362093105,27],[971349.595583334,24],[971349.743743112,4],[971349.892393595,16],[971350.080531068,10],[971350.262323383,31],[971350.409610774,8],[971350.592600776,11],[971350.776962698,16],[971350.962457974,12],[971351.147235005,39],[971351.318343293,18],[971351.499760378,11],[971351.681163749,16],[971351.863865769,16],[971352.017387425,11],[971352.200380521,6],[971352.383430339,9],[971352.569227932,29],[971352.754112666,22],[971352.938527882,8],[971353.090599684,18],[971353.273025812,18],[971353.456807026,34],[971353.640836315,10],[971353.821982767,14],[971354.014455295,13],[971354.196732666,2],[971354.383372638,36],[971354.566902547,42],[971354.75103714,26],[971354.897720404,17],[971355.085460621,34],[971355.323271839,12],[971355.507806629,36],[971355.789981467,50],[971355.978855899,2],[971356.306261878,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-28a56a77735848e64dc97155f5a5908a","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.002270121,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.129790216,"time_to_first_token":0.002672653,"token_sha":"2b28aa2108de","tokens_per_second":25.17327551336923},"seed":1234,"sent":971346.172482597,"speculative":{"acceptance_rate":0.5534246575342465,"accepted":202,"drafted":365,"rounds":54,"tokens_per_round":4.7407407407407405},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.0034708180464804173,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":202,"drafted":365,"rounds":54},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":14,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.765613939489214,"done":971356.307817773,"finish_reason":"length","first":971346.410874851,"full_response_s":10.134070141008124,"last":971356.307786316,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971346.410874851,2],[971346.558718744,7],[971346.70495077,4],[971346.919889539,63],[971347.155070458,10],[971347.335327479,31],[971347.515941012,29],[971347.697179631,22],[971347.879514951,14],[971348.06985049,24],[971348.249762185,4],[971348.397225094,13],[971348.580934662,21],[971348.761145331,2],[971348.944015714,18],[971349.130970762,29],[971349.364770365,27],[971349.597607539,24],[971349.743816891,4],[971349.89305697,16],[971350.08217732,10],[971350.263537887,31],[971350.409777997,8],[971350.592779937,11],[971350.775716913,16],[971350.962125366,12],[971351.150757216,39],[971351.316998895,18],[971351.499799771,11],[971351.680970604,16],[971351.863409956,16],[971352.019059854,11],[971352.201442698,6],[971352.383694703,9],[971352.569632878,29],[971352.756503753,22],[971352.938102518,8],[971353.090397899,18],[971353.27321374,18],[971353.458651335,34],[971353.639029624,10],[971353.821720083,14],[971354.014656232,13],[971354.198333028,2],[971354.379135531,36],[971354.564223816,42],[971354.750538589,26],[971354.899109028,17],[971355.08665858,34],[971355.324105526,12],[971355.506149097,36],[971355.788487159,50],[971355.97917001,2],[971356.307786316,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-7c86bf33fbe9d290658999fdcf9d8a0b","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.147216711,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.897387649,"time_to_first_token":0.232662723,"token_sha":"2b28aa2108de","tokens_per_second":25.764374301916362},"seed":1234,"sent":971346.173747632,"speculative":{"acceptance_rate":0.5638888888888889,"accepted":203,"drafted":360,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.2371272190939635,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":360,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":0,"stream":15,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.762997520609048,"done":971356.306673449,"finish_reason":"length","first":971346.408709806,"full_response_s":10.135340376989916,"last":971356.306626374,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971346.408709806,2],[971346.55902743,7],[971346.705177708,4],[971346.918023629,63],[971347.152302681,10],[971347.334877874,31],[971347.516155006,29],[971347.697661253,22],[971347.87884404,14],[971348.067472796,24],[971348.251687283,4],[971348.395901433,13],[971348.580546244,21],[971348.760271483,2],[971348.943513514,18],[971349.131456752,29],[971349.362655307,27],[971349.596037499,24],[971349.743907647,4],[971349.892732859,16],[971350.080874027,10],[971350.26390088,31],[971350.410937283,8],[971350.593692827,11],[971350.775606044,16],[971350.962590012,12],[971351.148849976,39],[971351.320121552,18],[971351.499467196,11],[971351.685076554,16],[971351.863250653,16],[971352.017772499,11],[971352.201621458,6],[971352.385421807,9],[971352.570930778,29],[971352.755244703,22],[971352.940075681,8],[971353.091279507,18],[971353.273686242,18],[971353.458451485,34],[971353.64241618,10],[971353.823793346,14],[971354.013510036,13],[971354.199125816,2],[971354.381501672,36],[971354.564737232,42],[971354.749863582,26],[971354.897338547,17],[971355.087332995,34],[971355.323851594,12],[971355.505991585,36],[971355.789019679,50],[971355.978680163,2],[971356.306626374,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-26ab4a74b6d3d368699bbd532bb924f4","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.147059505,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":9.897528279,"time_to_first_token":0.234042627,"token_sha":"2b28aa2108de","tokens_per_second":25.764008226280513},"seed":1234,"sent":971346.171333072,"speculative":{"acceptance_rate":0.5638888888888889,"accepted":203,"drafted":360,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.23737673403229564,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":360,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.477350202499196,"done":971366.451591948,"finish_reason":"length","first":971356.442679569,"full_response_s":10.136773438076489,"last":971366.451569739,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971356.442679569,2],[971356.627266635,7],[971356.770947602,4],[971356.991046826,63],[971357.225026362,10],[971357.407572361,31],[971357.588517871,29],[971357.772477359,22],[971357.957462323,14],[971358.143481827,24],[971358.323753741,4],[971358.472528456,13],[971358.657633822,21],[971358.839818221,2],[971359.027255744,18],[971359.209709472,29],[971359.445131375,27],[971359.679623012,24],[971359.829746592,4],[971359.982304498,16],[971360.211474435,10],[971360.392921432,31],[971360.54302777,8],[971360.725212704,11],[971360.907314043,16],[971361.097196962,12],[971361.282169962,39],[971361.45112873,18],[971361.633020325,11],[971361.814904176,16],[971362.005157978,16],[971362.154251864,11],[971362.335085046,6],[971362.519986189,9],[971362.701886763,29],[971362.885037565,22],[971363.075809905,8],[971363.224447215,18],[971363.409659462,18],[971363.593521536,34],[971363.77427571,10],[971363.965073911,14],[971364.152502645,13],[971364.334375224,2],[971364.519022312,36],[971364.703090094,42],[971364.88634689,26],[971365.043402319,17],[971365.22659176,34],[971365.464681872,12],[971365.649964352,36],[971365.932506655,50],[971366.124141888,2],[971366.451569739,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-c78c85777bba0cd81fe7294220283e6b","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.033156399,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.010649277,"time_to_first_token":0.123225087,"token_sha":"2b28aa2108de","tokens_per_second":25.472873231696976},"seed":1234,"sent":971356.31481851,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12786105903796852,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.480448902318138,"done":971366.449993764,"finish_reason":"length","first":971356.442283726,"full_response_s":10.135122820036486,"last":971366.449956706,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971356.442283726,2],[971356.624782425,7],[971356.770636324,4],[971356.989834387,63],[971357.225893266,10],[971357.40876192,31],[971357.589038487,29],[971357.770905095,22],[971357.956712272,14],[971358.141989647,24],[971358.326688563,4],[971358.474206308,13],[971358.657560747,21],[971358.839650453,2],[971359.026774554,18],[971359.209340239,29],[971359.44593378,27],[971359.680571215,24],[971359.829670541,4],[971359.981458699,16],[971360.211196983,10],[971360.394171841,31],[971360.541450082,8],[971360.72433964,11],[971360.907072288,16],[971361.097684584,12],[971361.279107871,39],[971361.45185161,18],[971361.634301231,11],[971361.814416426,16],[971362.003473277,16],[971362.152471639,11],[971362.338240309,6],[971362.519807893,9],[971362.702403987,29],[971362.886208514,22],[971363.076034571,8],[971363.225379817,18],[971363.411290736,18],[971363.592301993,34],[971363.773495355,10],[971363.963649863,14],[971364.159797919,13],[971364.337588105,2],[971364.518336553,36],[971364.705870492,42],[971364.887742761,26],[971365.042884968,17],[971365.227306512,34],[971365.465498341,12],[971365.648428315,36],[971365.931894228,50],[971366.128905558,2],[971366.449956706,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-b20708d8325234a2a974bf47bb908a24","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.03304681,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.010441523,"time_to_first_token":0.123516859,"token_sha":"2b28aa2108de","tokens_per_second":25.473401888828953},"seed":1234,"sent":971356.314870944,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12741278193425387,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.16635172139443,"done":971366.451512808,"finish_reason":"length","first":971356.318905321,"full_response_s":10.136211875942536,"last":971366.451482455,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971356.318905321,2],[971356.406857159,7],[971356.626313087,4],[971356.771655603,72],[971356.989749919,1],[971357.224902117,27],[971357.408019854,30],[971357.588198929,15],[971357.770839764,14],[971357.95902001,20],[971358.141397796,14],[971358.323571556,4],[971358.471849817,13],[971358.657303487,21],[971358.839944739,2],[971359.02557938,18],[971359.210671884,29],[971359.444286713,27],[971359.681389733,24],[971359.830707932,4],[971359.981944449,16],[971360.211544966,10],[971360.39388866,31],[971360.541409072,8],[971360.72507577,11],[971360.907027742,16],[971361.097628022,12],[971361.28128581,39],[971361.45215796,18],[971361.633106665,11],[971361.816940428,16],[971362.004174989,16],[971362.152590172,11],[971362.336269308,6],[971362.517350165,9],[971362.703801058,29],[971362.887042824,22],[971363.079586284,8],[971363.225821629,18],[971363.408868738,18],[971363.591169174,34],[971363.774660559,10],[971363.963301383,14],[971364.150676627,13],[971364.337084819,2],[971364.519188016,36],[971364.707566121,42],[971364.886550595,26],[971365.042382705,17],[971365.228926185,34],[971365.464384147,12],[971365.650332001,36],[971365.931608455,50],[971366.128503156,2],[971366.451482455,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-80ced5e5014e1e63f13b5ec2dc05f98f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.002395614,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.131023448,"time_to_first_token":0.002689212,"token_sha":"2b28aa2108de","tokens_per_second":25.170211213985535},"seed":1234,"sent":971356.315300932,"speculative":{"acceptance_rate":0.543010752688172,"accepted":202,"drafted":372,"rounds":54,"tokens_per_round":4.7407407407407405},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.0036043889122083783,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":202,"drafted":372,"rounds":54},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.47633913253344,"done":971366.450891164,"finish_reason":"length","first":971356.441576846,"full_response_s":10.135034063016064,"last":971366.450864235,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971356.441576846,2],[971356.625723876,7],[971356.771133499,4],[971356.991490254,63],[971357.223416353,10],[971357.405809913,31],[971357.588905777,29],[971357.771492978,22],[971357.959308263,14],[971358.143966425,24],[971358.323893635,4],[971358.472297693,13],[971358.656504363,21],[971358.837962968,2],[971359.026907744,18],[971359.210184806,29],[971359.444547605,27],[971359.679231266,24],[971359.828196474,4],[971359.981662453,16],[971360.2107813,10],[971360.39508385,31],[971360.543524128,8],[971360.724834271,11],[971360.906697247,16],[971361.096870275,12],[971361.278356573,39],[971361.452288958,18],[971361.633318835,11],[971361.814696263,16],[971362.004887981,16],[971362.153436755,11],[971362.335900203,6],[971362.518836488,9],[971362.701800791,29],[971362.885217589,22],[971363.076944404,8],[971363.223680108,18],[971363.407848628,18],[971363.591545895,34],[971363.77485748,10],[971363.964629475,14],[971364.152941385,13],[971364.33739248,2],[971364.519404714,36],[971364.708760559,42],[971364.888240768,26],[971365.044773405,17],[971365.228879735,34],[971365.466998121,12],[971365.647424797,36],[971365.932394586,50],[971366.128787665,2],[971366.450864235,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-0e4bde7e5a3c80b52b7fd8b8ccfedd37","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.033119342,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.01038088,"time_to_first_token":0.123158491,"token_sha":"2b28aa2108de","tokens_per_second":25.473556206984206},"seed":1234,"sent":971356.315857101,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12571974494494498,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.475589303159705,"done":971366.45078628,"finish_reason":"length","first":971356.441167259,"full_response_s":10.135788338026032,"last":971366.450749254,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971356.441167259,2],[971356.626089541,7],[971356.772603806,4],[971356.989926647,63],[971357.224947591,10],[971357.406128007,31],[971357.589138556,29],[971357.771701051,22],[971357.95980211,14],[971358.142458276,24],[971358.326603583,4],[971358.473362494,13],[971358.65884735,21],[971358.838670969,2],[971359.027403511,18],[971359.210742335,29],[971359.444155011,27],[971359.681199916,24],[971359.82922068,4],[971359.982743302,16],[971360.210960844,10],[971360.394028218,31],[971360.542486033,8],[971360.724528401,11],[971360.906644925,16],[971361.097288374,12],[971361.280623876,39],[971361.451779463,18],[971361.633407015,11],[971361.815289938,16],[971362.004478427,16],[971362.153293804,11],[971362.33729321,6],[971362.519352352,9],[971362.704331866,29],[971362.886101357,22],[971363.07888942,8],[971363.224976519,18],[971363.411754485,18],[971363.591914024,34],[971363.775152406,10],[971363.963550274,14],[971364.159272343,13],[971364.334970291,2],[971364.518593573,36],[971364.705504364,42],[971364.887097228,26],[971365.042497622,17],[971365.22748236,34],[971365.46449756,12],[971365.649431576,36],[971365.932566578,50],[971366.125308212,2],[971366.450749254,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-a10ed2de7301a4b98b18374228d3c5a6","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.033429564,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.010647052,"time_to_first_token":0.122675941,"token_sha":"2b28aa2108de","tokens_per_second":25.472878893383246},"seed":1234,"sent":971356.314997942,"speculative":{"acceptance_rate":0.559228650137741,"accepted":203,"drafted":363,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12616931705269963,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":363,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.483225671878813,"done":971366.452636779,"finish_reason":"length","first":971356.44322993,"full_response_s":10.137214658083394,"last":971366.449812428,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971356.44322993,2],[971356.625864138,7],[971356.77320873,4],[971356.991270036,63],[971357.226695191,10],[971357.406535802,31],[971357.589582336,29],[971357.77192767,22],[971357.957726751,14],[971358.143223559,24],[971358.32558432,4],[971358.472410914,13],[971358.656698611,21],[971358.838149857,2],[971359.025415468,18],[971359.21045037,29],[971359.442958124,27],[971359.680077753,24],[971359.829583257,4],[971359.98208844,16],[971360.211775745,10],[971360.396482682,31],[971360.542560724,8],[971360.724925171,11],[971360.90658457,16],[971361.098007255,12],[971361.278519588,39],[971361.452431173,18],[971361.63316206,11],[971361.816779685,16],[971362.004549454,16],[971362.153503366,11],[971362.335425477,6],[971362.519164807,9],[971362.702531273,29],[971362.885682362,22],[971363.076746683,8],[971363.223966841,18],[971363.409378009,18],[971363.591356174,34],[971363.774430821,10],[971363.965508507,14],[971364.150890684,13],[971364.335921982,2],[971364.520102665,36],[971364.708022077,42],[971364.886081422,26],[971365.04330041,17],[971365.227824328,34],[971365.466942807,12],[971365.648207617,36],[971365.93213627,50],[971366.125688101,2],[971366.449812428,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-1c20a88ba0e9b061964a818ac3c463af","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.033357161,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.010404033,"time_to_first_token":0.122734136,"token_sha":"2b28aa2108de","tokens_per_second":25.47349728935761},"seed":1234,"sent":971356.315422121,"speculative":{"acceptance_rate":0.559228650137741,"accepted":203,"drafted":363,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12780780903995037,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":363,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.47181318456037,"done":971366.452738656,"finish_reason":"length","first":971356.441639201,"full_response_s":10.13779300393071,"last":971366.452705086,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971356.441639201,2],[971356.625555452,7],[971356.772321025,4],[971356.990797871,63],[971357.22628298,10],[971357.406295791,31],[971357.589239568,29],[971357.771559429,22],[971357.958510387,14],[971358.14499324,24],[971358.324725369,4],[971358.473433185,13],[971358.658055681,21],[971358.839685575,2],[971359.026151742,18],[971359.210096674,29],[971359.444500387,27],[971359.680259777,24],[971359.829151109,4],[971359.981146333,16],[971360.211132148,10],[971360.395049881,31],[971360.543442957,8],[971360.724888945,11],[971360.907751551,16],[971361.097901586,12],[971361.279636359,39],[971361.452846504,18],[971361.633740662,11],[971361.816583452,16],[971362.00400967,16],[971362.15396177,11],[971362.335552859,6],[971362.518892507,9],[971362.702658782,29],[971362.885286089,22],[971363.07720736,8],[971363.225123037,18],[971363.410303395,18],[971363.593133503,34],[971363.774485511,10],[971363.963172337,14],[971364.157245084,13],[971364.336353185,2],[971364.520438344,36],[971364.704423691,42],[971364.887919169,26],[971365.042647901,17],[971365.228412146,34],[971365.465922328,12],[971365.648638948,36],[971365.933142444,50],[971366.125577136,2],[971366.452705086,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-fba871b94d780afb26a04945775c230c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.033007816,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.011204518,"time_to_first_token":0.123855899,"token_sha":"2b28aa2108de","tokens_per_second":25.47146045628313},"seed":1234,"sent":971356.314945652,"speculative":{"acceptance_rate":0.5516304347826086,"accepted":203,"drafted":368,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1266935489838943,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":368,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.476095186510427,"done":971366.451779844,"finish_reason":"length","first":971356.442372338,"full_response_s":10.136095711030066,"last":971366.451755571,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971356.442372338,2],[971356.624613025,7],[971356.772902684,4],[971356.990930053,63],[971357.22532708,10],[971357.406378979,31],[971357.590739749,29],[971357.771331514,22],[971357.958212869,14],[971358.142863623,24],[971358.324878336,4],[971358.472820709,13],[971358.659753583,21],[971358.839155375,2],[971359.026411546,18],[971359.208596061,29],[971359.443636859,27],[971359.681430391,24],[971359.829853861,4],[971359.982020117,16],[971360.210700544,10],[971360.396597743,31],[971360.542412462,8],[971360.724726346,11],[971360.90777984,16],[971361.097816142,12],[971361.281579039,39],[971361.451672322,18],[971361.634727331,11],[971361.816048308,16],[971362.003961155,16],[971362.152896074,11],[971362.336933226,6],[971362.518221053,9],[971362.702826118,29],[971362.885612423,22],[971363.076821166,8],[971363.224911924,18],[971363.408521891,18],[971363.591443506,34],[971363.774733059,10],[971363.964902191,14],[971364.151807174,13],[971364.339787549,2],[971364.520505339,36],[971364.704510703,42],[971364.886788382,26],[971365.042583306,17],[971365.22672303,34],[971365.465298332,12],[971365.651584521,36],[971365.932852175,50],[971366.124817502,2],[971366.451755571,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-892750b4cee4febc91810a6b5121d056","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.033465854,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.011244807,"time_to_first_token":0.122245985,"token_sha":"2b28aa2108de","tokens_per_second":25.471357949582902},"seed":1234,"sent":971356.315684133,"speculative":{"acceptance_rate":0.5607734806629834,"accepted":203,"drafted":362,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12668820505496114,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":362,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.4707688464424,"done":971366.451319376,"finish_reason":"length","first":971356.43982091,"full_response_s":10.135223784018308,"last":971366.451297263,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971356.43982091,2],[971356.625654609,7],[971356.77242663,4],[971356.99046968,63],[971357.224149218,10],[971357.406766868,31],[971357.588835134,29],[971357.770678845,22],[971357.957234008,14],[971358.141644607,24],[971358.32549734,4],[971358.473221655,13],[971358.658386321,21],[971358.839736889,2],[971359.026954802,18],[971359.20875074,29],[971359.445733371,27],[971359.680310052,24],[971359.829276907,4],[971359.981888495,16],[971360.211266954,10],[971360.393546308,31],[971360.542382124,8],[971360.725123244,11],[971360.907556038,16],[971361.097741531,12],[971361.280557345,39],[971361.452115174,18],[971361.635019632,11],[971361.815694004,16],[971362.004090617,16],[971362.153731808,11],[971362.338492976,6],[971362.51724472,9],[971362.705456749,29],[971362.884662204,22],[971363.077697846,8],[971363.225160431,18],[971363.409611636,18],[971363.591707406,34],[971363.774142808,10],[971363.963037339,14],[971364.151309663,13],[971364.337452963,2],[971364.521128536,36],[971364.703491153,42],[971364.887819789,26],[971365.043795329,17],[971365.227387076,34],[971365.465577193,12],[971365.648711927,36],[971365.932191953,50],[971366.126043093,2],[971366.451297263,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-da0161fdb8972c01f115bbc8179711f6","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.033503264,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.01118314,"time_to_first_token":0.121807677,"token_sha":"2b28aa2108de","tokens_per_second":25.47151484834389},"seed":1234,"sent":971356.316095592,"speculative":{"acceptance_rate":0.5607734806629834,"accepted":203,"drafted":362,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1237253180006519,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":362,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.472208986848713,"done":971366.452203111,"finish_reason":"length","first":971356.441256639,"full_response_s":10.136245444999076,"last":971366.452166966,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971356.441256639,2],[971356.626796069,7],[971356.772105207,4],[971356.99165727,63],[971357.224977896,10],[971357.408345165,31],[971357.590861066,29],[971357.771378573,22],[971357.956812677,14],[971358.143685564,24],[971358.325441386,4],[971358.473841652,13],[971358.657188826,21],[971358.840217823,2],[971359.026063258,18],[971359.210245897,29],[971359.446079851,27],[971359.68110044,24],[971359.831076909,4],[971359.981726712,16],[971360.211072001,10],[971360.393152658,31],[971360.54264556,8],[971360.724959108,11],[971360.906777571,16],[971361.097955077,12],[971361.282842344,39],[971361.451029813,18],[971361.633804265,11],[971361.816736595,16],[971362.00422952,16],[971362.153227417,11],[971362.336719488,6],[971362.518945085,9],[971362.70278202,29],[971362.885830241,22],[971363.076428909,8],[971363.225068779,18],[971363.409488287,18],[971363.592761678,34],[971363.77568235,10],[971363.964987475,14],[971364.16007262,13],[971364.336730691,2],[971364.520926942,36],[971364.703997623,42],[971364.890159558,26],[971365.044290151,17],[971365.229429456,34],[971365.464556651,12],[971365.649531708,36],[971365.93262362,50],[971366.127075508,2],[971366.452166966,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-b4e3a8f52bb7b8af1e98cb9142b9a537","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.033319687,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.010948026,"time_to_first_token":0.12291488,"token_sha":"2b28aa2108de","tokens_per_second":25.472113064389614},"seed":1234,"sent":971356.315957666,"speculative":{"acceptance_rate":0.559228650137741,"accepted":203,"drafted":363,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12529897294007242,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":363,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.472976162948374,"done":971366.450944767,"finish_reason":"length","first":971356.44031602,"full_response_s":10.135571511927992,"last":971366.450924846,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971356.44031602,2],[971356.624334084,7],[971356.773490199,4],[971356.991574242,63],[971357.224275736,10],[971357.407746145,31],[971357.587847008,29],[971357.771773951,22],[971357.956393378,14],[971358.144917556,24],[971358.325891582,4],[971358.472227322,13],[971358.657072133,21],[971358.838240021,2],[971359.026995588,18],[971359.209648093,29],[971359.44308661,27],[971359.680029191,24],[971359.828324048,4],[971359.982953375,16],[971360.211815267,10],[971360.392751888,31],[971360.543253076,8],[971360.72478246,11],[971360.906175512,16],[971361.098098939,12],[971361.280467533,39],[971361.451308402,18],[971361.632842445,11],[971361.814833133,16],[971362.005079238,16],[971362.15447581,11],[971362.338128672,6],[971362.520051392,9],[971362.703997675,29],[971362.885151154,22],[971363.078482138,8],[971363.224265543,18],[971363.407491364,18],[971363.590815126,34],[971363.774044099,10],[971363.964064137,14],[971364.151868345,13],[971364.338664074,2],[971364.520729141,36],[971364.70524192,42],[971364.887876079,26],[971365.043930151,17],[971365.225814141,34],[971365.465048145,12],[971365.647801214,36],[971365.931697915,50],[971366.126501898,2],[971366.450924846,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-9dd60b9c4a4cec8cfeb08d32ae6bb461","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.033083004,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.010402801,"time_to_first_token":0.123283825,"token_sha":"2b28aa2108de","tokens_per_second":25.473500424431123},"seed":1234,"sent":971356.315373255,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1249427649891004,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.47736852501306,"done":971366.449763849,"finish_reason":"length","first":971356.44084166,"full_response_s":10.134603756014258,"last":971366.449724632,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971356.44084166,2],[971356.625805592,7],[971356.772533147,4],[971356.99086157,63],[971357.224447312,10],[971357.406045715,31],[971357.589947665,29],[971357.77128692,22],[971357.956629197,14],[971358.143317627,24],[971358.325824507,4],[971358.473485043,13],[971358.657254589,21],[971358.839483646,2],[971359.027293346,18],[971359.208498473,29],[971359.44374832,27],[971359.680506428,24],[971359.828891449,4],[971359.981359255,16],[971360.211628442,10],[971360.394873793,31],[971360.542910724,8],[971360.724632998,11],[971360.907616393,16],[971361.097365018,12],[971361.282259134,39],[971361.450881742,18],[971361.632624803,11],[971361.817210377,16],[971362.003392298,16],[971362.154023837,11],[971362.335963086,6],[971362.518770565,9],[971362.704921429,29],[971362.884524966,22],[971363.076171745,8],[971363.224058989,18],[971363.408749213,18],[971363.59094646,34],[971363.773036806,10],[971363.963711945,14],[971364.150834234,13],[971364.340540335,2],[971364.518504769,36],[971364.70732723,42],[971364.890284492,26],[971365.042754274,17],[971365.226134587,34],[971365.465772098,12],[971365.64926592,36],[971365.931966295,50],[971366.126337059,2],[971366.449724632,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-bf4c233e6544819437070066c3834a77","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.033193377,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.010291068,"time_to_first_token":0.123185501,"token_sha":"2b28aa2108de","tokens_per_second":25.473784754887006},"seed":1234,"sent":971356.315160093,"speculative":{"acceptance_rate":0.5576923076923077,"accepted":203,"drafted":364,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12568156700581312,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":364,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.46939534035661,"done":971366.45243701,"finish_reason":"length","first":971356.440399176,"full_response_s":10.137225906015374,"last":971366.452415425,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971356.440399176,2],[971356.626855144,7],[971356.771948848,4],[971356.989614025,63],[971357.224352939,10],[971357.408670331,31],[971357.589797306,29],[971357.771999001,22],[971357.956233755,14],[971358.142101316,24],[971358.326284864,4],[971358.472885784,13],[971358.658489733,21],[971358.838096974,2],[971359.026490013,18],[971359.208845817,29],[971359.443490837,27],[971359.679810317,24],[971359.828651647,4],[971359.982673075,16],[971360.21224447,10],[971360.393315162,31],[971360.541588376,8],[971360.724150848,11],[971360.906289069,16],[971361.098162798,12],[971361.28071588,39],[971361.452222619,18],[971361.634044644,11],[971361.816112327,16],[971362.00361482,16],[971362.153102516,11],[971362.337105346,6],[971362.517688356,9],[971362.702908698,29],[971362.884773745,22],[971363.077412041,8],[971363.224396541,18],[971363.410566399,18],[971363.591862117,34],[971363.773966816,10],[971363.965721988,14],[971364.158298363,13],[971364.338258632,2],[971364.519869311,36],[971364.703603638,42],[971364.889703938,26],[971365.044024187,17],[971365.22722198,34],[971365.465856005,12],[971365.647588837,36],[971365.932255588,50],[971366.126771974,2],[971366.452415425,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-144967522a16f3c2ba297132f5c44d3d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.033393211,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.010644331,"time_to_first_token":0.122570897,"token_sha":"2b28aa2108de","tokens_per_second":25.47288581718367},"seed":1234,"sent":971356.315211104,"speculative":{"acceptance_rate":0.559228650137741,"accepted":203,"drafted":363,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12518807197920978,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":363,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.468614580615526,"done":971366.452821747,"finish_reason":"length","first":971356.440468251,"full_response_s":10.137268932070583,"last":971366.452791426,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971356.440468251,2],[971356.625353427,7],[971356.772190923,4],[971356.990235173,63],[971357.226979988,10],[971357.406940412,31],[971357.590014532,29],[971357.772201986,22],[971357.957938488,14],[971358.141703458,24],[971358.324043274,4],[971358.472465589,13],[971358.656911277,21],[971358.839864191,2],[971359.025893154,18],[971359.209260396,29],[971359.445211475,27],[971359.682212346,24],[971359.830802481,4],[971359.981279411,16],[971360.21174784,10],[971360.394284662,31],[971360.542717644,8],[971360.724467374,11],[971360.907868597,16],[971361.098052473,12],[971361.278895269,39],[971361.452547978,18],[971361.634654799,11],[971361.815398759,16],[971362.004812602,16],[971362.153373056,11],[971362.336043505,6],[971362.51762677,9],[971362.70392812,29],[971362.885962119,22],[971363.077018391,8],[971363.224191187,18],[971363.410011542,18],[971363.591992283,34],[971363.775190343,10],[971363.964393,14],[971364.152596553,13],[971364.337943369,2],[971364.519607443,36],[971364.707091251,42],[971364.887411146,26],[971365.043987929,17],[971365.227546635,34],[971365.464852808,12],[971365.648550624,36],[971365.933048296,50],[971366.126183276,2],[971366.452791426,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-6102822d0a24aa8b58059d5515f11c4f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.033540224,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.01258266,"time_to_first_token":0.121765275,"token_sha":"2b28aa2108de","tokens_per_second":25.46795453871439},"seed":1234,"sent":971356.315552815,"speculative":{"acceptance_rate":0.5607734806629834,"accepted":203,"drafted":362,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12491543602664024,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":362,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.468982607071528,"done":971366.452087074,"finish_reason":"length","first":971356.43988408,"full_response_s":10.136985095101409,"last":971366.452062577,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971356.43988408,2],[971356.625210684,7],[971356.773575563,4],[971356.991366473,63],[971357.223910391,10],[971357.407243962,31],[971357.590485193,29],[971357.771847042,22],[971357.957516053,14],[971358.143390863,24],[971358.324298533,4],[971358.472122229,13],[971358.657482231,21],[971358.838767965,2],[971359.026298533,18],[971359.209225274,29],[971359.443574648,27],[971359.679869519,24],[971359.830338283,4],[971359.981572801,16],[971360.210860823,10],[971360.393945574,31],[971360.541959577,8],[971360.723730428,11],[971360.907676764,16],[971361.097578019,12],[971361.279782205,39],[971361.451087048,18],[971361.633484538,11],[971361.815624129,16],[971362.004741703,16],[971362.152690801,11],[971362.336630108,6],[971362.518141081,9],[971362.702994734,29],[971362.886446605,22],[971363.076651175,8],[971363.225610788,18],[971363.409111501,18],[971363.591816819,34],[971363.774779669,10],[971363.963813934,14],[971364.15105194,13],[971364.337234665,2],[971364.517730046,36],[971364.706227724,42],[971364.886180243,26],[971365.044504049,17],[971365.229143619,34],[971365.466272008,12],[971365.651253818,36],[971365.932677127,50],[971366.128049616,2],[971366.452062577,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-42f5c9039378029701155568bee4cf1b","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.03328319,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.010461219,"time_to_first_token":0.122744984,"token_sha":"2b28aa2108de","tokens_per_second":25.473351768848204},"seed":1234,"sent":971356.315101979,"speculative":{"acceptance_rate":0.559228650137741,"accepted":203,"drafted":363,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1247821010183543,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":363,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":1,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.47475351800235,"done":971366.451044931,"finish_reason":"length","first":971356.441088456,"full_response_s":10.136296984972432,"last":971366.450998849,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971356.441088456,2],[971356.627052065,7],[971356.772257902,4],[971356.990150881,63],[971357.223754864,10],[971357.407144614,31],[971357.589709238,29],[971357.772244212,22],[971357.957390015,14],[971358.141783461,24],[971358.324177664,4],[971358.473771841,13],[971358.659174357,21],[971358.839056762,2],[971359.026552464,18],[971359.209791876,29],[971359.44439627,27],[971359.681676482,24],[971359.831154673,4],[971359.981784042,16],[971360.212069422,10],[971360.394406443,31],[971360.541287482,8],[971360.724581523,11],[971360.906831877,16],[971361.09705974,12],[971361.28080222,39],[971361.451353124,18],[971361.633691076,11],[971361.816682177,16],[971362.003253043,16],[971362.152802182,11],[971362.336195496,6],[971362.518695506,9],[971362.703302107,29],[971362.885766254,22],[971363.078071239,8],[971363.226157676,18],[971363.408148194,18],[971363.591756193,34],[971363.775345934,10],[971363.964724535,14],[971364.157941995,13],[971364.339452158,2],[971364.517923207,36],[971364.704918609,42],[971364.888802457,26],[971365.042300909,17],[971365.228827509,34],[971365.465170519,12],[971365.647931588,36],[971365.932811789,50],[971366.127192345,2],[971366.450998849,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-54ca44a1d5adf1cb1cbc48d133654321","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.033229443,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.01086647,"time_to_first_token":0.123185341,"token_sha":"2b28aa2108de","tokens_per_second":25.47232057925951},"seed":1234,"sent":971356.314747946,"speculative":{"acceptance_rate":0.5576923076923077,"accepted":203,"drafted":364,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12634050997439772,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":364,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.3991674870272,"done":971376.62962131,"finish_reason":"length","first":971366.589875799,"full_response_s":10.169193139998242,"last":971376.62957494,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971366.589875799,2],[971366.775594541,7],[971366.920395749,4],[971367.142926407,63],[971367.381762758,10],[971367.56240121,31],[971367.744701464,29],[971367.929410138,22],[971368.119226654,14],[971368.298571082,24],[971368.480011172,4],[971368.629250344,13],[971368.810867642,21],[971368.998528383,2],[971369.183135242,18],[971369.363358577,29],[971369.600897108,27],[971369.834533301,24],[971369.987594942,4],[971370.143454453,16],[971370.366561888,10],[971370.551704342,31],[971370.699811409,8],[971370.882929367,11],[971371.073402799,16],[971371.25706999,12],[971371.440140242,39],[971371.61282995,18],[971371.797181699,11],[971371.982849847,16],[971372.173101879,16],[971372.319655383,11],[971372.502793161,6],[971372.686124884,9],[971372.869472123,29],[971373.058274621,22],[971373.243783147,8],[971373.392182628,18],[971373.577335362,18],[971373.761892487,34],[971373.94574581,10],[971374.137867577,14],[971374.319285573,13],[971374.502912066,2],[971374.688676655,36],[971374.875902968,42],[971375.065673193,26],[971375.212928202,17],[971375.397669308,34],[971375.63850321,12],[971375.818548971,36],[971376.114411906,50],[971376.29823323,2],[971376.62957494,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-f25ed4ef1df4143e1222ceae57996983","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034856932,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.039954464,"time_to_first_token":0.127100115,"token_sha":"2b28aa2108de","tokens_per_second":25.39852156843408},"seed":1234,"sent":971366.46042817,"speculative":{"acceptance_rate":0.559228650137741,"accepted":203,"drafted":363,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1294476289767772,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":363,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.40403206437777,"done":971376.62805916,"finish_reason":"length","first":971366.59025036,"full_response_s":10.16695969493594,"last":971376.628027015,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971366.59025036,2],[971366.773226482,7],[971366.921088725,4],[971367.142384142,63],[971367.379860193,10],[971367.563244384,31],[971367.746140809,29],[971367.928396621,22],[971368.1173142,14],[971368.300862801,24],[971368.480419143,4],[971368.630510496,13],[971368.81148263,21],[971368.998869214,2],[971369.184751763,18],[971369.3641429,29],[971369.599927416,27],[971369.834211607,24],[971369.988314975,4],[971370.143907801,16],[971370.366910335,10],[971370.550742539,31],[971370.701423225,8],[971370.882554343,11],[971371.075162381,16],[971371.259670106,12],[971371.440659145,39],[971371.614330945,18],[971371.79625273,11],[971371.983371279,16],[971372.171833278,16],[971372.318355725,11],[971372.502236481,6],[971372.685662816,9],[971372.868200131,29],[971373.057976608,22],[971373.244965184,8],[971373.392950262,18],[971373.579154243,18],[971373.762221909,34],[971373.947274902,10],[971374.137031364,14],[971374.319331639,13],[971374.503630402,2],[971374.689559718,36],[971374.875837541,42],[971375.066028425,26],[971375.213245944,17],[971375.397734622,34],[971375.636037693,12],[971375.818941404,36],[971376.113089816,50],[971376.297635332,2],[971376.628027015,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-219b1b0fac4db4fd300e9f8e78a11c7f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.034707437,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.038147648,"time_to_first_token":0.127105395,"token_sha":"2b28aa2108de","tokens_per_second":25.40309317434738},"seed":1234,"sent":971366.461099465,"speculative":{"acceptance_rate":0.5576923076923077,"accepted":203,"drafted":364,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12915089493617415,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":364,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.407345860490953,"done":971376.627416828,"finish_reason":"length","first":971366.590925014,"full_response_s":10.166801704908721,"last":971376.627392475,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971366.590925014,2],[971366.774794184,7],[971366.920251423,4],[971367.142871668,63],[971367.381099416,10],[971367.563538589,31],[971367.746019028,29],[971367.929282789,22],[971368.117836271,14],[971368.299098066,24],[971368.480973584,4],[971368.62694728,13],[971368.810400197,21],[971368.999332515,2],[971369.183315842,18],[971369.363581115,29],[971369.600985528,27],[971369.835467903,24],[971369.990695401,4],[971370.140275478,16],[971370.367616383,10],[971370.55099863,31],[971370.700850496,8],[971370.886479846,11],[971371.073942615,16],[971371.257921468,12],[971371.441244467,39],[971371.613885453,18],[971371.797093679,11],[971371.98313738,16],[971372.176157983,16],[971372.318474467,11],[971372.50335277,6],[971372.685389779,9],[971372.868506288,29],[971373.059648922,22],[971373.245533049,8],[971373.392547396,18],[971373.578036402,18],[971373.762255671,34],[971373.946873924,10],[971374.13644073,14],[971374.321544361,13],[971374.503759624,2],[971374.688909417,36],[971374.874122361,42],[971375.065755469,26],[971375.212430371,17],[971375.398387659,34],[971375.638089944,12],[971375.819684797,36],[971376.113581725,50],[971376.297781514,2],[971376.627392475,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-a487b63615e86310e31cb8728cbf79b4","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.03459708,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.037909894,"time_to_first_token":0.126561002,"token_sha":"2b28aa2108de","tokens_per_second":25.403694862057108},"seed":1234,"sent":971366.460615123,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.13030989095568657,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.405392455111695,"done":971376.628820458,"finish_reason":"length","first":971366.591544322,"full_response_s":10.16701524995733,"last":971376.628783481,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971366.591544322,2],[971366.773573297,7],[971366.920669442,4],[971367.141712304,63],[971367.380558192,10],[971367.563683636,31],[971367.745120891,29],[971367.928903572,22],[971368.120503239,14],[971368.297823832,24],[971368.481134343,4],[971368.627742948,13],[971368.809594257,21],[971368.998439355,2],[971369.181761373,18],[971369.363812965,29],[971369.60121853,27],[971369.83481037,24],[971369.990773773,4],[971370.139362029,16],[971370.367199324,10],[971370.552432487,31],[971370.698438436,8],[971370.884902624,11],[971371.075466907,16],[971371.258540519,12],[971371.442034071,39],[971371.611966743,18],[971371.794810969,11],[971371.984160034,16],[971372.172814154,16],[971372.317944043,11],[971372.502332277,6],[971372.686847444,9],[971372.870083351,29],[971373.058461237,22],[971373.244493707,8],[971373.393707928,18],[971373.579516212,18],[971373.761260618,34],[971373.946794224,10],[971374.137389172,14],[971374.319682006,13],[971374.503810778,2],[971374.689092801,36],[971374.873349814,42],[971375.063897194,26],[971375.212209818,17],[971375.397305435,34],[971375.636511138,12],[971375.820477441,36],[971376.112229473,50],[971376.299072243,2],[971376.628783481,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-6b4e93ae9bad530327ee53d41390758a","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034780144,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.039117611,"time_to_first_token":0.126753907,"token_sha":"2b28aa2108de","tokens_per_second":25.400638769346916},"seed":1234,"sent":971366.461805208,"speculative":{"acceptance_rate":0.559228650137741,"accepted":203,"drafted":363,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12973911396693438,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":363,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.407275705399183,"done":971376.628115179,"finish_reason":"length","first":971366.590836626,"full_response_s":10.166930575040169,"last":971376.6273318,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971366.590836626,2],[971366.774284498,7],[971366.920709956,4],[971367.142470146,63],[971367.379167713,10],[971367.564287471,31],[971367.745500956,29],[971367.927499861,22],[971368.116470898,14],[971368.299542197,24],[971368.481697472,4],[971368.628914841,13],[971368.81091422,21],[971368.998157358,2],[971369.183920429,18],[971369.364212007,29],[971369.600741549,27],[971369.835954501,24],[971369.988233723,4],[971370.139126819,16],[971370.367157387,10],[971370.55202706,31],[971370.69921775,8],[971370.886905081,11],[971371.074702953,16],[971371.258893655,12],[971371.441655974,39],[971371.616224726,18],[971371.796368639,11],[971371.984054541,16],[971372.173809191,16],[971372.320185583,11],[971372.501403035,6],[971372.686777793,9],[971372.870436262,29],[971373.059163556,22],[971373.243273909,8],[971373.39232497,18],[971373.576902463,18],[971373.76178765,34],[971373.946723437,10],[971374.135599204,14],[971374.321055875,13],[971374.503553967,2],[971374.690622277,36],[971374.875080435,42],[971375.065369836,26],[971375.213069296,17],[971375.398528914,34],[971375.638403766,12],[971375.82033577,36],[971376.114158215,50],[971376.299345856,2],[971376.6273318,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-e3b1911b5906b43c924692cfc992bc95","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.034489011,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.037961384,"time_to_first_token":0.126750931,"token_sha":"2b28aa2108de","tokens_per_second":25.403564553103084},"seed":1234,"sent":971366.461184604,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12965202203486115,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.40233639910302,"done":971376.630153877,"finish_reason":"length","first":971366.591680712,"full_response_s":10.16855282196775,"last":971376.630127412,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971366.591680712,2],[971366.774851099,7],[971366.919896143,4],[971367.141640445,63],[971367.380139581,10],[971367.562833245,31],[971367.745198655,29],[971367.9276623,22],[971368.117637446,14],[971368.299158852,24],[971368.48139197,4],[971368.628403186,13],[971368.811026449,21],[971368.999197437,2],[971369.183807656,18],[971369.363410451,29],[971369.599818835,27],[971369.835198755,24],[971369.988709104,4],[971370.14066684,16],[971370.366645108,10],[971370.551451979,31],[971370.700648919,8],[971370.886133927,11],[971371.074044683,16],[971371.258446195,12],[971371.441772651,39],[971371.614193899,18],[971371.795714354,11],[971371.983647339,16],[971372.173608366,16],[971372.319577572,11],[971372.502458826,6],[971372.687014156,9],[971372.868393579,29],[971373.05867043,22],[971373.24423952,8],[971373.392600966,18],[971373.577580845,18],[971373.761746544,34],[971373.947342633,10],[971374.136020775,14],[971374.319643781,13],[971374.503089242,2],[971374.689042751,36],[971374.873130829,42],[971375.064454723,26],[971375.213176133,17],[971375.398486768,34],[971375.637543744,12],[971375.818906523,36],[971376.113465304,50],[971376.298567133,2],[971376.630127412,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-f96e27d920b1d49d5bf007bc5e5f816e","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.035002938,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.040368147,"time_to_first_token":0.126374258,"token_sha":"2b28aa2108de","tokens_per_second":25.39747509917676},"seed":1234,"sent":971366.461601055,"speculative":{"acceptance_rate":0.5607734806629834,"accepted":203,"drafted":362,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.13007965695578605,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":362,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.09254859631014,"done":971376.627920434,"finish_reason":"length","first":971366.464833665,"full_response_s":10.167393986950628,"last":971376.627213107,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971366.464833665,2],[971366.555587501,7],[971366.775483096,4],[971366.920113993,72],[971367.14197742,1],[971367.378525733,27],[971367.562735545,30],[971367.745439001,15],[971367.929956819,14],[971368.119915596,20],[971368.30009075,14],[971368.480496458,4],[971368.629586583,13],[971368.810483481,21],[971368.998035097,2],[971369.182610243,18],[971369.364302603,29],[971369.60130159,27],[971369.833950459,24],[971369.987742581,4],[971370.139708701,16],[971370.366849069,10],[971370.551674885,31],[971370.699710989,8],[971370.88241432,11],[971371.073865795,16],[971371.259881843,12],[971371.440977815,39],[971371.612544785,18],[971371.795516329,11],[971371.983460403,16],[971372.175460752,16],[971372.32096413,11],[971372.502725734,6],[971372.686229033,9],[971372.867968504,29],[971373.057916141,22],[971373.24620892,8],[971373.393911457,18],[971373.57826238,18],[971373.761846069,34],[971373.946184805,10],[971374.136683013,14],[971374.320080696,13],[971374.502994598,2],[971374.690110255,36],[971374.87280963,42],[971375.064132453,26],[971375.213608808,17],[971375.398772284,34],[971375.637857678,12],[971375.819037937,36],[971376.112715095,50],[971376.297129037,2],[971376.627213107,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-300eef97f38204384de9f50c7c7da97f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.002374924,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.162252412,"time_to_first_token":0.002762237,"token_sha":"2b28aa2108de","tokens_per_second":25.092862257474103},"seed":1234,"sent":971366.460526447,"speculative":{"acceptance_rate":0.543010752688172,"accepted":202,"drafted":372,"rounds":54,"tokens_per_round":4.7407407407407405},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.0043072180123999715,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":202,"drafted":372,"rounds":54},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.40159055510652,"done":971376.628626242,"finish_reason":"length","first":971366.589835589,"full_response_s":10.167090389993973,"last":971376.628577039,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971366.589835589,2],[971366.774991041,7],[971366.920458216,4],[971367.142309691,63],[971367.380702151,10],[971367.563720821,31],[971367.745819691,29],[971367.927571352,22],[971368.118469083,14],[971368.299235448,24],[971368.481272013,4],[971368.628613451,13],[971368.810332914,21],[971368.999103129,2],[971369.182345015,18],[971369.363702753,29],[971369.600273704,27],[971369.834952216,24],[971369.989437937,4],[971370.140528706,16],[971370.367452792,10],[971370.551375063,31],[971370.698733249,8],[971370.884157758,11],[971371.075107963,16],[971371.259165651,12],[971371.440506786,39],[971371.612652326,18],[971371.794913934,11],[971371.983016831,16],[971372.172032119,16],[971372.319332345,11],[971372.501164817,6],[971372.685143336,9],[971372.868974885,29],[971373.058043075,22],[971373.242832593,8],[971373.393050426,18],[971373.579631689,18],[971373.762705963,34],[971373.945602155,10],[971374.136217808,14],[971374.319060635,13],[971374.503914591,2],[971374.688608284,36],[971374.875393825,42],[971375.063684065,26],[971375.213881828,17],[971375.397843267,34],[971375.637617987,12],[971375.818587149,36],[971376.113665601,50],[971376.299194985,2],[971376.628577039,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-800e0af07c44ddc4bf038f88d788a946","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034743454,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.039005495,"time_to_first_token":0.12642298,"token_sha":"2b28aa2108de","tokens_per_second":25.40092244465895},"seed":1234,"sent":971366.461535852,"speculative":{"acceptance_rate":0.559228650137741,"accepted":203,"drafted":363,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1282997369999066,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":363,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.39867056870015,"done":971376.630094483,"finish_reason":"length","first":971366.590178869,"full_response_s":10.169279942987487,"last":971376.630074434,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971366.590178869,2],[971366.773098572,7],[971366.920752598,4],[971367.142066912,63],[971367.382101317,10],[971367.563847115,31],[971367.744807869,29],[971367.928353755,22],[971368.119590926,14],[971368.298882232,24],[971368.481205226,4],[971368.627545963,13],[971368.809948193,21],[971368.998271635,2],[971369.182691142,18],[971369.363626141,29],[971369.599639643,27],[971369.835371851,24],[971369.988927658,4],[971370.14155456,16],[971370.367566397,10],[971370.551420937,31],[971370.699926934,8],[971370.885560637,11],[971371.076077574,16],[971371.258808019,12],[971371.442138443,39],[971371.615098915,18],[971371.796473796,11],[971371.983196695,16],[971372.172260913,16],[971372.320675973,11],[971372.503317665,6],[971372.686438418,9],[971372.868761996,29],[971373.060263702,22],[971373.244744774,8],[971373.392276584,18],[971373.578138966,18],[971373.762997352,34],[971373.94567235,10],[971374.137209692,14],[971374.321616492,13],[971374.502670103,2],[971374.690914835,36],[971374.873080202,42],[971375.066270372,26],[971375.213531732,17],[971375.39832028,34],[971375.636664633,12],[971375.81916055,36],[971376.11403541,50],[971376.29746806,2],[971376.630074434,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-19108e1c0557672d1b1fe025b51a68e7","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034893733,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.040055589,"time_to_first_token":0.126644318,"token_sha":"2b28aa2108de","tokens_per_second":25.398265750578208},"seed":1234,"sent":971366.46081454,"speculative":{"acceptance_rate":0.559228650137741,"accepted":203,"drafted":363,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1293643289245665,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":363,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.407120733546325,"done":971376.628394423,"finish_reason":"length","first":971366.591813966,"full_response_s":10.167665167013183,"last":971376.628370358,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971366.591813966,2],[971366.776043873,7],[971366.919956706,4],[971367.141884488,63],[971367.378356029,10],[971367.563368965,31],[971367.746760037,29],[971367.927409137,22],[971368.118305444,14],[971368.299916726,24],[971368.480311266,4],[971368.627240973,13],[971368.810831177,21],[971368.999264816,2],[971369.182172943,18],[971369.363472182,29],[971369.601038122,27],[971369.83489519,24],[971369.987812536,4],[971370.141341046,16],[971370.368017313,10],[971370.551727207,31],[971370.699070608,8],[971370.885722756,11],[971371.074332936,16],[971371.257734547,12],[971371.441342392,39],[971371.613793977,18],[971371.796054225,11],[971371.984107967,16],[971372.173378883,16],[971372.319702489,11],[971372.501313031,6],[971372.686165238,9],[971372.86881755,29],[971373.060682456,22],[971373.243523712,8],[971373.393647077,18],[971373.577756725,18],[971373.761163462,34],[971373.946430912,10],[971374.134953016,14],[971374.319585842,13],[971374.504165658,2],[971374.69041054,36],[971374.872088158,42],[971375.065039533,26],[971375.21257905,17],[971375.397192982,34],[971375.635667532,12],[971375.818071846,36],[971376.111881362,50],[971376.296824608,2],[971376.628370358,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-e990d26e7eabb4766b2e1efc7a1f55df","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.034633689,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.037895366,"time_to_first_token":0.127002446,"token_sha":"2b28aa2108de","tokens_per_second":25.403731629214512},"seed":1234,"sent":971366.460729256,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1310847100103274,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.40875704406869,"done":971376.627663271,"finish_reason":"length","first":971366.59171977,"full_response_s":10.166284770006314,"last":971376.627629813,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971366.59171977,2],[971366.774898637,7],[971366.920489434,4],[971367.142439201,63],[971367.379747228,10],[971367.563462602,31],[971367.746819672,29],[971367.928186499,22],[971368.118906159,14],[971368.298464645,24],[971368.482041584,4],[971368.627851785,13],[971368.811237947,21],[971368.999022581,2],[971369.184636126,18],[971369.363922378,29],[971369.600357675,27],[971369.835683289,24],[971369.990529458,4],[971370.139837811,16],[971370.367786551,10],[971370.552562188,31],[971370.700128991,8],[971370.886598508,11],[971371.076253998,16],[971371.258978731,12],[971371.441423051,39],[971371.6120755,18],[971371.796760672,11],[971371.983303099,16],[971372.171979765,16],[971372.318218183,11],[971372.501599028,6],[971372.686054545,9],[971372.869746216,29],[971373.058093365,22],[971373.246159861,8],[971373.391840324,18],[971373.578298829,18],[971373.761704462,34],[971373.946242312,10],[971374.136823515,14],[971374.321446085,13],[971374.502530657,2],[971374.688376994,36],[971374.873497341,42],[971375.064034833,26],[971375.213295834,17],[971375.397518693,34],[971375.637201728,12],[971375.819442691,36],[971376.1137377,50],[971376.297581153,2],[971376.627629813,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-56bd3edd8a190b120f2b7b366d5c1aef","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.034671419,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.037933591,"time_to_first_token":0.126550858,"token_sha":"2b28aa2108de","tokens_per_second":25.403634890415365},"seed":1234,"sent":971366.461378501,"speculative":{"acceptance_rate":0.5576923076923077,"accepted":203,"drafted":364,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1303412689594552,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":364,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.39913364718131,"done":971376.630972522,"finish_reason":"length","first":971366.591172913,"full_response_s":10.170054137939587,"last":971376.63088543,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971366.591172913,2],[971366.77376801,7],[971366.920203149,4],[971367.141796436,63],[971367.379956453,10],[971367.563882748,31],[971367.746982111,29],[971367.929515839,22],[971368.11754053,14],[971368.299296874,24],[971368.482169413,4],[971368.627395876,13],[971368.811538632,21],[971368.998798747,2],[971369.183425431,18],[971369.363943931,29],[971369.600237958,27],[971369.835601061,24],[971369.989320316,4],[971370.140872977,16],[971370.367514171,10],[971370.552493785,31],[971370.699969784,8],[971370.885296433,11],[971371.074490239,16],[971371.257858761,12],[971371.440372636,39],[971371.61582634,18],[971371.796210248,11],[971371.983720462,16],[971372.171405067,16],[971372.319767916,11],[971372.503091527,6],[971372.685530282,9],[971372.869376455,29],[971373.058962924,22],[971373.244167789,8],[971373.393607043,18],[971373.578206553,18],[971373.762177843,34],[971373.945501783,10],[971374.135787805,14],[971374.320141547,13],[971374.503971649,2],[971374.689799473,36],[971374.874651952,42],[971375.065830496,26],[971375.214071308,17],[971375.398226788,34],[971375.636951381,12],[971375.82069937,36],[971376.114235194,50],[971376.299016465,2],[971376.63088543,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-eb1b24bc5e64c46f031bdb21bf1eeee7","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.035040556,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.041129748,"time_to_first_token":0.126296287,"token_sha":"2b28aa2108de","tokens_per_second":25.39554874796744},"seed":1234,"sent":971366.460918384,"speculative":{"acceptance_rate":0.5607734806629834,"accepted":203,"drafted":362,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.13025452895089984,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":362,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.403344068377404,"done":971376.629530538,"finish_reason":"length","first":971366.591438861,"full_response_s":10.168537926045246,"last":971376.629487368,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971366.591438861,2],[971366.773445196,7],[971366.921162312,4],[971367.143177122,63],[971367.378883973,10],[971367.562255539,31],[971367.7469139,29],[971367.929781323,22],[971368.118859357,14],[971368.298975356,24],[971368.4814281,4],[971368.627950205,13],[971368.809678805,21],[971368.998928113,2],[971369.18295389,18],[971369.364087106,29],[971369.599351838,27],[971369.834775584,24],[971369.989550182,4],[971370.139291034,16],[971370.366732791,10],[971370.551207344,31],[971370.701707366,8],[971370.883307576,11],[971371.072970203,16],[971371.256614801,12],[971371.440824304,39],[971371.613252945,18],[971371.796148117,11],[971371.983822659,16],[971372.172622434,16],[971372.318319292,11],[971372.502834507,6],[971372.684909438,9],[971372.867858595,29],[971373.058164472,22],[971373.242554405,8],[971373.393776955,18],[971373.577473449,18],[971373.761414897,34],[971373.946042911,10],[971374.135926739,14],[971374.318738972,13],[971374.501871924,2],[971374.688127414,36],[971374.872882546,42],[971375.063278303,26],[971375.213393358,17],[971375.397788769,34],[971375.636733356,12],[971375.818429574,36],[971376.113338563,50],[971376.297880175,2],[971376.629487368,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-5757d3fb2746b0a3e13de223e1076961","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034817986,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.039799097,"time_to_first_token":0.12686284,"token_sha":"2b28aa2108de","tokens_per_second":25.398914613360816},"seed":1234,"sent":971366.460992612,"speculative":{"acceptance_rate":0.559228650137741,"accepted":203,"drafted":363,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.1304462490370497,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":363,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.40250657694786,"done":971376.629885689,"finish_reason":"length","first":971366.591330392,"full_response_s":10.169005081988871,"last":971376.629709842,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971366.591330392,2],[971366.773675574,7],[971366.921395778,4],[971367.1426018,63],[971367.378810257,10],[971367.562560481,31],[971367.746281535,29],[971367.927303436,22],[971368.118677477,14],[971368.298097925,24],[971368.482240425,4],[971368.627109864,13],[971368.811596219,21],[971368.998373256,2],[971369.18374503,18],[971369.363876872,29],[971369.600013564,27],[971369.834646395,24],[971369.988868423,4],[971370.142593598,16],[971370.36697485,10],[971370.551768217,31],[971370.700933971,8],[971370.883093359,11],[971371.0736931,16],[971371.257227261,12],[971371.440738557,39],[971371.614996511,18],[971371.797616743,11],[971371.983777281,16],[971372.175801904,16],[971372.31918077,11],[971372.501514672,6],[971372.685598829,9],[971372.869038344,29],[971373.060353834,22],[971373.244397479,8],[971373.392634664,18],[971373.576988499,18],[971373.761928936,34],[971373.946474754,10],[971374.137659504,14],[971374.321386626,13],[971374.502309255,2],[971374.688745826,36],[971374.872398412,42],[971375.065478897,26],[971375.212772707,17],[971375.398858816,34],[971375.63746142,12],[971375.819997755,36],[971376.114587098,50],[971376.297839837,2],[971376.629709842,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-c7081a76480d48b5fec9ce8c1dd32010","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.034956712,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.0400365,"time_to_first_token":0.127085762,"token_sha":"2b28aa2108de","tokens_per_second":25.39831403999378},"seed":1234,"sent":971366.460880607,"speculative":{"acceptance_rate":0.5607734806629834,"accepted":203,"drafted":362,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.13044978503603488,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":362,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.403470325947918,"done":971376.627584307,"finish_reason":"length","first":971366.589564553,"full_response_s":10.166279440978542,"last":971376.62756317,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971366.589564553,2],[971366.774161068,7],[971366.920036293,4],[971367.142534597,63],[971367.382019234,10],[971367.563771944,31],[971367.746665889,29],[971367.929178096,22],[971368.116935687,14],[971368.300620118,24],[971368.481339056,4],[971368.630800621,13],[971368.810241262,21],[971368.998605826,2],[971369.184857976,18],[971369.364263178,29],[971369.601263348,27],[971369.835146033,24],[971369.987894604,4],[971370.141729432,16],[971370.367099,10],[971370.552341363,31],[971370.701134572,8],[971370.881849015,11],[971371.073547621,16],[971371.257469479,12],[971371.440044494,39],[971371.612160384,18],[971371.795382691,11],[971371.983539926,16],[971372.172733447,16],[971372.318998746,11],[971372.50253035,6],[971372.686540439,9],[971372.869139341,29],[971373.057694899,22],[971373.244290338,8],[971373.391922552,18],[971373.577656769,18],[971373.76259263,34],[971373.945307022,10],[971374.137772549,14],[971374.320812169,13],[971374.502604964,2],[971374.688531192,36],[971374.873804475,42],[971375.064199256,26],[971375.213827281,17],[971375.397915046,34],[971375.636393677,12],[971375.81783798,36],[971376.114670014,50],[971376.297924449,2],[971376.62756317,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-46791d66d1f80be3392f41b47e04f6c8","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.034551526,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.03791479,"time_to_first_token":0.126980013,"token_sha":"2b28aa2108de","tokens_per_second":25.403682471387068},"seed":1234,"sent":971366.461304866,"speculative":{"acceptance_rate":0.5546448087431693,"accepted":203,"drafted":366,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12825968698598444,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":366,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"code","streams":16,"burst":2,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":14,"case_id":null,"complete":true,"decode_tps":25.404299415470057,"done":971376.627270965,"finish_reason":"length","first":971366.589460916,"full_response_s":10.166925998055376,"last":971376.627131935,"output_sha256":"aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd","pieces":[[971366.589460916,2],[971366.775832647,7],[971366.920073671,4],[971367.141461877,63],[971367.381584174,10],[971367.562469933,31],[971367.744940339,29],[971367.928008795,22],[971368.118606002,14],[971368.29799112,24],[971368.481931131,4],[971368.627640431,13],[971368.810782294,21],[971368.999156395,2],[971369.184391379,18],[971369.363764179,29],[971369.600948134,27],[971369.834449442,24],[971369.990070829,4],[971370.1392426,16],[971370.367054038,10],[971370.551099275,31],[971370.700441389,8],[971370.881933451,11],[971371.07494322,16],[971371.259461985,12],[971371.439953209,39],[971371.6118,18],[971371.797275287,11],[971371.983607513,16],[971372.171237012,16],[971372.320582865,11],[971372.501724298,6],[971372.68692012,9],[971372.87079191,29],[971373.059547558,22],[971373.246250473,8],[971373.393435723,18],[971373.576718871,18],[971373.761522838,34],[971373.947072349,10],[971374.136522893,14],[971374.321956251,13],[971374.50173435,2],[971374.689149348,36],[971374.872756892,42],[971375.064774241,26],[971375.211851338,17],[971375.396965804,34],[971375.637326694,12],[971375.81797925,36],[971376.114777522,50],[971376.299141159,2],[971376.627131935,56]],"prompt":"code","prompt_tokens":14,"request_body":{"ignore_eos":true,"max_tokens":256,"model":"qwen27-pr608","prompt":"Write a short Python function that computes the Fibonacci sequence and explain it.","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01","response_id":"cmpl-74d253a75a2940e4cb78c730aea335fb","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.034450817,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":10.037917798,"time_to_first_token":0.127410945,"token_sha":"2b28aa2108de","tokens_per_second":25.40367485882454},"seed":1234,"sent":971366.460344967,"speculative":{"acceptance_rate":0.5516304347826086,"accepted":203,"drafted":368,"rounds":53,"tokens_per_round":4.830188679245283},"token_sha":"2b28aa2108de","tokens":256,"ttft_s":0.12911594903562218,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":14,"prompt_tokens_details":{"cached_tokens":14},"total_tokens":270},"work":{"accepted":203,"drafted":368,"rounds":53},"work_source":"speculative","request_path":"/v1/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":1,"burst":null,"stream":0,"phase":"warmup","request":{"cache_state":"cold","cached_tokens":0,"case_id":null,"complete":true,"decode_tps":57.22766244989475,"done":971377.062293609,"finish_reason":"length","first":971376.800139692,"full_response_s":0.4232278160052374,"last":971377.062250695,"output_sha256":"6bffe2c2436146ed3af0e8c4e21d88b3dddfbe4a47910e8940f3039340788c85","pieces":[[971376.800139692,3],[971376.888046162,26],[971376.972564978,15],[971377.062250695,30]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":16,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"c81230cadd07c8b22d2a507aa18b8b00964a157b29ba5c65c8fdf55148cf2238","response_id":"chatcmpl-03addac86b3dfbacebd53a67a198cb6d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.159237417,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":0.263050934,"time_to_first_token":0.160068206,"token_sha":"a9100b9c265b","tokens_per_second":57.02317711595732},"seed":1234,"sent":971376.639065793,"speculative":{"acceptance_rate":0.28888888888888886,"accepted":13,"drafted":45,"rounds":3,"tokens_per_round":5.333333333333333},"token_sha":"a9100b9c265b","tokens":16,"ttft_s":0.1610738990129903,"usage":{"completion_tokens":16,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":0},"total_tokens":47},"work":{"accepted":13,"drafted":45,"rounds":3},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":1,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":49.43869767863533,"done":971382.237653336,"finish_reason":"length","first":971377.079688268,"full_response_s":5.167487745988183,"last":971382.237591125,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971377.079688268,3],[971377.167871502,26],[971377.249527807,15],[971377.330140722,34],[971377.411732481,21],[971377.491413354,25],[971377.572993704,14],[971377.653774226,14],[971377.734706676,18],[971377.815111133,26],[971377.896529086,13],[971377.981486251,13],[971378.066494619,13],[971378.148097332,23],[971378.229151029,32],[971378.310072976,7],[971378.391478272,23],[971378.472046459,9],[971378.554696467,13],[971378.63602664,15],[971378.716784612,19],[971378.79696947,12],[971378.879191981,5],[971378.962263985,23],[971379.051681166,9],[971379.133242847,17],[971379.213945915,3],[971379.294459662,21],[971379.376149429,10],[971379.456771581,24],[971379.537388213,19],[971379.619137599,14],[971379.699086921,13],[971379.780184486,5],[971379.861846104,22],[971379.942226704,13],[971380.029106182,51],[971380.114136378,15],[971380.194842736,6],[971380.275444818,8],[971380.35724052,9],[971380.438246363,16],[971380.518723175,16],[971380.602438209,9],[971380.683221867,32],[971380.76423691,18],[971380.84539103,13],[971380.926274478,11],[971381.013362391,15],[971381.098320578,8],[971381.179265277,18],[971381.253685545,25],[971381.334324102,19],[971381.415782327,8],[971381.496826054,40],[971381.577587193,16],[971381.658931845,64],[971381.739990005,6],[971381.820355814,6],[971381.902928914,11],[971381.989135839,15],[971382.074513143,17],[971382.155337334,21],[971382.237591125,14]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-e7a954711c0b22c922163d53d469a2f9","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.008342866,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":5.158028751,"time_to_first_token":0.008790565,"token_sha":"8a91591c94a3","tokens_per_second":49.437491008665376},"seed":1234,"sent":971377.07016559,"speculative":{"acceptance_rate":0.2052910052910053,"accepted":194,"drafted":945,"rounds":63,"tokens_per_round":4.063492063492063},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.009522677981294692,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":194,"drafted":945,"rounds":63},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":1,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":49.400751113724176,"done":971387.411230478,"finish_reason":"length","first":971382.249300408,"full_response_s":5.165550902020186,"last":971387.411165243,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971382.249300408,3],[971382.337826586,26],[971382.419559361,15],[971382.500202921,34],[971382.582720628,21],[971382.663716651,25],[971382.745049905,14],[971382.825342968,14],[971382.90698119,18],[971382.992396362,26],[971383.077597252,13],[971383.15860359,13],[971383.239029151,13],[971383.319815127,23],[971383.401424275,32],[971383.482326529,7],[971383.562779227,23],[971383.643931811,9],[971383.724502306,13],[971383.804790469,15],[971383.886802718,19],[971383.96980805,12],[971384.056141895,5],[971384.139510107,23],[971384.220194122,9],[971384.300846822,17],[971384.382151312,3],[971384.463422584,21],[971384.546092621,10],[971384.626467438,24],[971384.708417092,19],[971384.788890361,14],[971384.870416776,13],[971384.951137218,5],[971385.038649653,22],[971385.123052624,13],[971385.203611396,51],[971385.285510337,15],[971385.366868935,6],[971385.447455084,8],[971385.528181686,9],[971385.609182813,16],[971385.689756225,16],[971385.771216939,9],[971385.85282929,32],[971385.933184638,18],[971386.020949654,13],[971386.104982124,11],[971386.185866167,15],[971386.266792901,8],[971386.347438022,18],[971386.422736574,25],[971386.503159894,19],[971386.58712436,8],[971386.667974818,40],[971386.749853225,16],[971386.830658944,64],[971386.912669447,6],[971386.99833571,6],[971387.084600447,11],[971387.16656474,15],[971387.247799817,17],[971387.328794004,21],[971387.411165243,14]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-a6e37d556d265c872d57aed9f6cebbd9","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.00223133,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":5.161575511,"time_to_first_token":0.002734024,"token_sha":"8a91591c94a3","tokens_per_second":49.40352019583193},"seed":1234,"sent":971382.245679576,"speculative":{"acceptance_rate":0.2052910052910053,"accepted":194,"drafted":945,"rounds":63,"tokens_per_round":4.063492063492063},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.0036208319943398237,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":194,"drafted":945,"rounds":63},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":1,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":49.507626444232194,"done":971392.57585729,"finish_reason":"length","first":971387.425091178,"full_response_s":5.154440063983202,"last":971392.57581276,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971387.425091178,3],[971387.513227036,26],[971387.593919466,15],[971387.674217526,34],[971387.756675169,21],[971387.836959547,25],[971387.918150473,14],[971388.00386742,14],[971388.088705224,18],[971388.169658364,26],[971388.250462873,13],[971388.330891877,13],[971388.412794658,13],[971388.493505099,23],[971388.576135656,32],[971388.657247746,7],[971388.737389042,23],[971388.818803977,9],[971388.899973904,13],[971388.984172331,15],[971389.070390238,19],[971389.151592615,12],[971389.232287529,5],[971389.312884679,23],[971389.394106961,9],[971389.47477581,17],[971389.555430451,3],[971389.635944238,21],[971389.71612577,10],[971389.797693283,24],[971389.879383452,19],[971389.960246544,14],[971390.04786521,13],[971390.130935102,5],[971390.211891942,22],[971390.293218863,13],[971390.374788961,51],[971390.455192146,15],[971390.536010628,6],[971390.618772715,8],[971390.699275328,9],[971390.779762148,16],[971390.861940574,16],[971390.942266037,9],[971391.029489767,32],[971391.113709351,18],[971391.195136734,13],[971391.275807637,11],[971391.356788169,15],[971391.437768652,8],[971391.518062114,18],[971391.592814569,25],[971391.672948776,19],[971391.753461943,8],[971391.834805705,40],[971391.91631643,16],[971392.001610087,64],[971392.086892559,6],[971392.16840578,6],[971392.249208907,11],[971392.330184665,15],[971392.411653516,17],[971392.492470291,21],[971392.57581276,14]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-38976262eabc9d374ab981cb7f40372a","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":16,"prefill_raised":[],"prefill_seconds":0.002250306,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":5.150594296,"time_to_first_token":0.002797226,"token_sha":"8a91591c94a3","tokens_per_second":49.5088499201025},"seed":1234,"sent":971387.421417226,"speculative":{"acceptance_rate":0.2052910052910053,"accepted":194,"drafted":945,"rounds":63,"tokens_per_round":4.063492063492063},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.0036739520728588104,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":194,"drafted":945,"rounds":63},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":0,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.907516857372187,"done":971406.283115818,"finish_reason":"length","first":971392.796394171,"full_response_s":13.693414730019867,"last":971406.283093769,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971392.796394171,3],[971392.944825781,11],[971393.13498076,30],[971393.319510328,19],[971393.499718893,21],[971393.681500966,15],[971393.826468584,19],[971393.978655177,17],[971394.165531281,12],[971394.348466896,5],[971394.495043374,5],[971394.677828358,27],[971394.860922824,12],[971395.049996114,13],[971395.231540104,5],[971395.379481847,16],[971395.56177867,5],[971395.744094709,14],[971395.926215579,9],[971396.0812252,22],[971396.232931112,10],[971396.411044926,7],[971396.597308466,23],[971396.743518413,5],[971396.891608307,9],[971397.085822416,14],[971397.229479875,20],[971397.378939007,8],[971397.529096426,12],[971397.678590776,5],[971397.825859445,14],[971398.011848052,14],[971398.163202504,8],[971398.344572193,13],[971398.519583689,3],[971398.703213763,10],[971398.850594634,11],[971399.041326311,9],[971399.223710799,10],[971399.407307979,20],[971399.553272894,14],[971399.736899803,14],[971399.96805947,13],[971400.158525539,5],[971400.341397444,22],[971400.574186488,3],[971400.80974901,32],[971400.996918894,33],[971401.184147579,11],[971401.369153851,6],[971401.515300497,8],[971401.662226777,9],[971401.811659963,13],[971401.960160476,8],[971402.118663191,20],[971402.265013196,17],[971402.449796053,20],[971402.599926683,13],[971402.772240818,6],[971402.957964841,13],[971403.115324392,9],[971403.265381009,11],[971403.413875127,8],[971403.597829105,15],[971403.780680555,16],[971403.99613581,27],[971404.239509193,4],[971404.386197768,8],[971404.571641957,25],[971404.756126472,18],[971404.905750878,13],[971405.097834551,55],[971405.246022829,11],[971405.432655583,10],[971405.616136555,11],[971405.765312363,15],[971405.915972433,17],[971406.072700966,14],[971406.283093769,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-2443462749cfce230929352efb1434f1","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.114197787,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.486980394,"time_to_first_token":0.199551318,"token_sha":"8a91591c94a3","tokens_per_second":18.907123207018433},"seed":1234,"sent":971392.589701088,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2066930829314515,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":1,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.910347320101017,"done":971406.281140502,"finish_reason":"length","first":971392.796439133,"full_response_s":13.691018226905726,"last":971406.281120069,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971392.796439133,3],[971392.945699435,11],[971393.135568161,30],[971393.320568998,19],[971393.501321154,21],[971393.682576852,15],[971393.827223577,19],[971393.979670709,17],[971394.165996805,12],[971394.348049038,5],[971394.495424095,5],[971394.679128654,27],[971394.860252491,12],[971395.051094593,13],[971395.231973242,5],[971395.381319926,16],[971395.56082202,5],[971395.743678563,14],[971395.927947254,9],[971396.081598305,22],[971396.231702963,10],[971396.412749927,7],[971396.596705672,23],[971396.744126167,5],[971396.8927409,9],[971397.086414041,14],[971397.231552908,20],[971397.378853948,8],[971397.527843252,12],[971397.677981726,5],[971397.826806686,14],[971398.012460222,14],[971398.164461773,8],[971398.345208428,13],[971398.519721455,3],[971398.702464771,10],[971398.852150524,11],[971399.040659466,9],[971399.22667379,10],[971399.407139524,20],[971399.553512824,14],[971399.737170982,14],[971399.968277096,13],[971400.160962075,5],[971400.342650889,22],[971400.574041234,3],[971400.810937589,32],[971400.997643132,33],[971401.184404502,11],[971401.368094765,6],[971401.517117791,8],[971401.663317287,9],[971401.811615561,13],[971401.961316717,8],[971402.117968729,20],[971402.266351013,17],[971402.449201516,20],[971402.601038026,13],[971402.772554671,6],[971402.95634914,13],[971403.116879274,9],[971403.263613606,11],[971403.414114689,8],[971403.596809653,15],[971403.779748659,16],[971403.99593921,27],[971404.235745705,4],[971404.386694046,8],[971404.57171148,25],[971404.757173701,18],[971404.904906458,13],[971405.096377417,55],[971405.247827801,11],[971405.43269912,10],[971405.615946291,11],[971405.763847004,15],[971405.914876531,17],[971406.073153769,14],[971406.281120069,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-312bf8e6e500470eb9b75d6861e2c160","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.113928879,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.484491425,"time_to_first_token":0.202105908,"token_sha":"8a91591c94a3","tokens_per_second":18.91061308602523},"seed":1234,"sent":971392.590122275,"speculative":{"acceptance_rate":0.4194312796208531,"accepted":177,"drafted":422,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.20631685794796795,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":422,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":2,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.910036886693835,"done":971406.281444627,"finish_reason":"length","first":971392.796508896,"full_response_s":13.689678488997743,"last":971406.281411201,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971392.796508896,3],[971392.944632685,11],[971393.135969667,30],[971393.320973207,19],[971393.499924198,21],[971393.681067203,15],[971393.827263531,19],[971393.979544063,17],[971394.166623296,12],[971394.346156636,5],[971394.496160623,5],[971394.679048171,27],[971394.860290557,12],[971395.050075797,13],[971395.232209061,5],[971395.379634414,16],[971395.560760162,5],[971395.744820244,14],[971395.925901934,9],[971396.082119335,22],[971396.233332457,10],[971396.411913011,7],[971396.596771291,23],[971396.742801582,5],[971396.891358456,9],[971397.084746881,14],[971397.230351832,20],[971397.381112525,8],[971397.528745979,12],[971397.675347197,5],[971397.825300669,14],[971398.012167714,14],[971398.16531533,8],[971398.345853287,13],[971398.520135473,3],[971398.702790817,10],[971398.849073513,11],[971399.039917147,9],[971399.225225712,10],[971399.407651722,20],[971399.556472134,14],[971399.735780075,14],[971399.967109046,13],[971400.159741527,5],[971400.34257863,22],[971400.574446483,3],[971400.809285534,32],[971400.997933209,33],[971401.184300642,11],[971401.370030848,6],[971401.515506218,8],[971401.662526134,9],[971401.811535238,13],[971401.9609023,8],[971402.117023473,20],[971402.268502,17],[971402.449011764,20],[971402.600067809,13],[971402.772793865,6],[971402.957795441,13],[971403.117231177,9],[971403.265303261,11],[971403.415168414,8],[971403.596326081,15],[971403.780322876,16],[971403.994661284,27],[971404.236019717,4],[971404.386858356,8],[971404.572730211,25],[971404.75571071,18],[971404.90579192,13],[971405.097224301,55],[971405.246751883,11],[971405.433394686,10],[971405.617844019,11],[971405.76610998,15],[971405.914203351,17],[971406.07259469,14],[971406.281411201,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-d8c5bbeead0343088da8b9b98b79fefe","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.113966785,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.484558931,"time_to_first_token":0.201979615,"token_sha":"8a91591c94a3","tokens_per_second":18.91051841627344},"seed":1234,"sent":971392.591766138,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2047427580691874,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":3,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.909375550081055,"done":971406.281297565,"finish_reason":"length","first":971392.795903814,"full_response_s":13.690105115994811,"last":971406.28127774,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971392.795903814,3],[971392.946184128,11],[971393.135157344,30],[971393.318074506,19],[971393.499498339,21],[971393.680567918,15],[971393.826622575,19],[971393.979112621,17],[971394.16490807,12],[971394.347328782,5],[971394.49461038,5],[971394.678563334,27],[971394.859794551,12],[971395.049601889,13],[971395.233015655,5],[971395.380765855,16],[971395.560367105,5],[971395.744201977,14],[971395.92864386,9],[971396.082071733,22],[971396.228416502,10],[971396.411870929,7],[971396.596044604,23],[971396.743308676,5],[971396.891073196,9],[971397.082581685,14],[971397.230134591,20],[971397.378374791,8],[971397.526772918,12],[971397.677671488,5],[971397.825137014,14],[971398.01151959,14],[971398.163653627,8],[971398.346639945,13],[971398.519442755,3],[971398.702898166,10],[971398.849993088,11],[971399.039362739,9],[971399.225977392,10],[971399.404806912,20],[971399.554907908,14],[971399.735255493,14],[971399.96842083,13],[971400.161890707,5],[971400.342309291,22],[971400.575396331,3],[971400.809336001,32],[971400.996871868,33],[971401.183394699,11],[971401.367296139,6],[971401.516161366,8],[971401.662411745,9],[971401.814642394,13],[971401.961392625,8],[971402.117282892,20],[971402.265829007,17],[971402.451928352,20],[971402.599274767,13],[971402.77139531,6],[971402.955996101,13],[971403.11763001,9],[971403.264580399,11],[971403.413068741,8],[971403.59749349,15],[971403.781207809,16],[971403.995208059,27],[971404.235831933,4],[971404.386308861,8],[971404.572065319,25],[971404.755618643,18],[971404.904540027,13],[971405.095725806,55],[971405.24793659,11],[971405.431517134,10],[971405.616798919,11],[971405.763784426,15],[971405.914664602,17],[971406.073362546,14],[971406.28127774,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-97b38e00cc1de6167252fa588f1a9e7c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.113828955,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.484480528,"time_to_first_token":0.202292381,"token_sha":"8a91591c94a3","tokens_per_second":18.910628367959923},"seed":1234,"sent":971392.591192449,"speculative":{"acceptance_rate":0.4164705882352941,"accepted":177,"drafted":425,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.20471136504784226,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":425,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":4,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.90854874008599,"done":971406.282018443,"finish_reason":"length","first":971392.796014683,"full_response_s":13.693312790011987,"last":971406.281978281,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971392.796014683,3],[971392.946657781,11],[971393.135349208,30],[971393.318438233,19],[971393.502832739,21],[971393.681715343,15],[971393.827654187,19],[971393.980020596,17],[971394.166566894,12],[971394.347100709,5],[971394.496424522,5],[971394.679213522,27],[971394.860769473,12],[971395.05056185,13],[971395.232447215,5],[971395.380895716,16],[971395.561711003,5],[971395.745858673,14],[971395.926881208,9],[971396.081983089,22],[971396.230762186,10],[971396.412884045,7],[971396.596575762,23],[971396.745957446,5],[971396.892425414,9],[971397.082854544,14],[971397.232138997,20],[971397.379046292,8],[971397.528346794,12],[971397.674709937,5],[971397.825403554,14],[971398.011781249,14],[971398.165746068,8],[971398.344918079,13],[971398.51950639,3],[971398.702125797,10],[971398.850304189,11],[971399.040575191,9],[971399.22405459,10],[971399.406064566,20],[971399.553673327,14],[971399.7362608,14],[971399.967840901,13],[971400.158303466,5],[971400.34159822,22],[971400.573846857,3],[971400.810577093,32],[971400.99740077,33],[971401.183607412,11],[971401.370795937,6],[971401.518652144,8],[971401.662975561,9],[971401.811269851,13],[971401.959955091,8],[971402.11889072,20],[971402.265686121,17],[971402.447939206,20],[971402.599136121,13],[971402.77182648,6],[971402.957222057,13],[971403.114787281,9],[971403.264618848,11],[971403.413989836,8],[971403.597768766,15],[971403.779454679,16],[971403.995284862,27],[971404.235972355,4],[971404.386266075,8],[971404.572231278,25],[971404.758104428,18],[971404.904660896,13],[971405.0962509,55],[971405.247537357,11],[971405.431737944,10],[971405.61803406,11],[971405.766419529,15],[971405.916031556,17],[971406.072186256,14],[971406.281978281,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-2723662e0ce351cd305eeed4c371514e","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.114080342,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.485782999,"time_to_first_token":0.200237028,"token_sha":"8a91591c94a3","tokens_per_second":18.908801959731132},"seed":1234,"sent":971392.588705653,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2073090299963951,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":5,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.907700599956613,"done":971406.282556386,"finish_reason":"length","first":971392.795965145,"full_response_s":13.687655217014253,"last":971406.282533681,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971392.795965145,3],[971392.945487554,11],[971393.135677862,30],[971393.31983439,19],[971393.501810535,21],[971393.681860085,15],[971393.826368644,19],[971393.979165487,17],[971394.166509563,12],[971394.346328787,5],[971394.495744269,5],[971394.678298363,27],[971394.860187576,12],[971395.049804138,13],[971395.231765313,5],[971395.380407871,16],[971395.562332245,5],[971395.746609057,14],[971395.927299258,9],[971396.081695845,22],[971396.230207587,10],[971396.411443615,7],[971396.597203581,23],[971396.743461082,5],[971396.892089704,9],[971397.086094715,14],[971397.232030785,20],[971397.379933866,8],[971397.528824862,12],[971397.679250948,5],[971397.8260219,14],[971398.011722495,14],[971398.166763504,8],[971398.345332737,13],[971398.518754054,3],[971398.703361194,10],[971398.851303976,11],[971399.039548955,9],[971399.22480483,10],[971399.407450465,20],[971399.554999015,14],[971399.73796604,14],[971399.967461461,13],[971400.159932191,5],[971400.342742317,22],[971400.574952424,3],[971400.809629389,32],[971400.998182947,33],[971401.183268118,11],[971401.367435313,6],[971401.517504991,8],[971401.663178817,9],[971401.812980244,13],[971401.960096985,8],[971402.119628016,20],[971402.266678131,17],[971402.450177813,20],[971402.599967549,13],[971402.771944325,6],[971402.956129531,13],[971403.117833954,9],[971403.264826745,11],[971403.414900275,8],[971403.597228311,15],[971403.77998787,16],[971403.99513644,27],[971404.238769945,4],[971404.386040146,8],[971404.57083589,25],[971404.755957217,18],[971404.904954732,13],[971405.097590541,55],[971405.24691149,11],[971405.431661284,10],[971405.617938615,11],[971405.767072629,15],[971405.91433526,17],[971406.072258068,14],[971406.282533681,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-261b5774b8aea2b56abd844a9281c013","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.114042084,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.485776855,"time_to_first_token":0.200178897,"token_sha":"8a91591c94a3","tokens_per_second":18.908810574413142},"seed":1234,"sent":971392.594901169,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.20106397604104131,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":6,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.907145796907876,"done":971406.283864665,"finish_reason":"length","first":971392.796861792,"full_response_s":13.690127321984619,"last":971406.283826072,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971392.796861792,3],[971392.94506512,11],[971393.135789403,30],[971393.318380119,19],[971393.498971869,21],[971393.680681491,15],[971393.827124341,19],[971393.979763593,17],[971394.164555095,12],[971394.348619382,5],[971394.496483052,5],[971394.678799088,18],[971394.860841861,21],[971395.050839814,13],[971395.232754284,5],[971395.380230888,16],[971395.562085227,5],[971395.744889399,14],[971395.927589222,9],[971396.081303044,22],[971396.230369402,10],[971396.413075445,7],[971396.597026694,23],[971396.743196719,5],[971396.892240334,9],[971397.081775362,14],[971397.229215288,20],[971397.378988034,8],[971397.527406993,12],[971397.674794165,5],[971397.823810765,14],[971398.011662668,14],[971398.167189938,8],[971398.346798864,13],[971398.519057619,3],[971398.702266059,10],[971398.84965797,11],[971399.040105075,9],[971399.226359056,10],[971399.407724349,20],[971399.554605319,14],[971399.737524822,14],[971399.967881399,13],[971400.158768622,5],[971400.340507134,22],[971400.574653964,3],[971400.809096646,32],[971400.996983872,33],[971401.185787857,11],[971401.368615892,6],[971401.516064338,8],[971401.664048262,9],[971401.813865945,13],[971401.96095843,8],[971402.117861237,20],[971402.268039997,17],[971402.448897919,20],[971402.598914784,13],[971402.771999143,6],[971402.956432087,13],[971403.117394912,9],[971403.263990662,11],[971403.413463798,8],[971403.596593596,15],[971403.779888265,16],[971403.994567888,27],[971404.237631849,4],[971404.38798778,8],[971404.572783925,25],[971404.756393139,18],[971404.905235352,13],[971405.097930459,55],[971405.246803198,11],[971405.434169823,10],[971405.617063506,11],[971405.765155188,15],[971405.914134196,17],[971406.072013113,14],[971406.283826072,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-64736af5fb4ca6bbccde30b0fb63bbac","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.114236173,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.487767547,"time_to_first_token":0.200058172,"token_sha":"8a91591c94a3","tokens_per_second":18.90601977765535},"seed":1234,"sent":971392.593737343,"speculative":{"acceptance_rate":0.4224343675417661,"accepted":177,"drafted":419,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2031244490062818,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":419,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":7,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.90591380425722,"done":971406.284082018,"finish_reason":"length","first":971392.796186994,"full_response_s":13.692402635933831,"last":971406.284030144,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971392.796186994,3],[971392.946557152,11],[971393.137030049,30],[971393.32155288,19],[971393.502545367,21],[971393.683577952,15],[971393.826427383,19],[971393.979240306,17],[971394.16537249,12],[971394.346471978,5],[971394.494989596,5],[971394.678739726,18],[971394.860699326,21],[971395.049447866,9],[971395.232542339,9],[971395.380342476,16],[971395.561279272,5],[971395.74356379,14],[971395.926525769,9],[971396.080705162,22],[971396.232228281,10],[971396.412619073,7],[971396.595977065,23],[971396.746362679,5],[971396.890941638,9],[971397.083150285,14],[971397.231104553,20],[971397.378627602,8],[971397.527496181,12],[971397.677322913,5],[971397.824781655,14],[971398.01206731,14],[971398.166093907,8],[971398.345573083,13],[971398.519947465,3],[971398.703168737,10],[971398.84979468,11],[971399.039399268,9],[971399.224407549,10],[971399.406965628,20],[971399.554038782,14],[971399.738039772,14],[971399.967794547,13],[971400.159430538,5],[971400.34026858,22],[971400.573948062,3],[971400.808867933,32],[971400.998681513,33],[971401.18308235,11],[971401.36783405,6],[971401.516426033,8],[971401.663103502,9],[971401.812494575,13],[971401.960368805,8],[971402.118758363,20],[971402.265230949,17],[971402.4481828,20],[971402.600343197,13],[971402.772291108,6],[971402.95751895,13],[971403.117671916,9],[971403.265132902,11],[971403.414320794,8],[971403.596049221,15],[971403.780475234,16],[971403.995482983,27],[971404.236474472,4],[971404.386151094,8],[971404.571338152,25],[971404.756181306,18],[971404.904852168,13],[971405.095887973,55],[971405.247194446,11],[971405.433078449,10],[971405.616285169,11],[971405.766749399,15],[971405.914551381,17],[971406.072946977,14],[971406.284030144,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-1c02a04b1201c06b55746b3cac727d31","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.114293135,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.487933522,"time_to_first_token":0.199451842,"token_sha":"8a91591c94a3","tokens_per_second":18.905787130702613},"seed":1234,"sent":971392.591679382,"speculative":{"acceptance_rate":0.4254807692307692,"accepted":177,"drafted":416,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2045076119247824,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":416,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":8,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.9114573373652,"done":971406.280755382,"finish_reason":"length","first":971392.796820766,"full_response_s":13.688827589037828,"last":971406.280710212,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971392.796820766,3],[971392.945130003,11],[971393.135907232,30],[971393.318941135,19],[971393.503174514,21],[971393.68178773,15],[971393.827710766,19],[971393.979050442,17],[971394.165824782,12],[971394.346607855,5],[971394.495159907,5],[971394.67926322,27],[971394.859525228,12],[971395.050771475,13],[971395.231669549,5],[971395.381030122,16],[971395.561328986,5],[971395.7454796,14],[971395.927360877,9],[971396.080964565,22],[971396.229983481,10],[971396.41250614,7],[971396.595800257,23],[971396.74527532,5],[971396.892183884,9],[971397.085547588,14],[971397.229912694,20],[971397.379764515,8],[971397.527277308,12],[971397.675418352,5],[971397.825948041,14],[971398.012121248,14],[971398.164935474,8],[971398.34503282,13],[971398.519336959,3],[971398.704663601,10],[971398.852493579,11],[971399.039454359,9],[971399.226788851,10],[971399.406604541,20],[971399.556071941,14],[971399.735968499,14],[971399.966935854,13],[971400.160364338,5],[971400.340593633,22],[971400.574375776,3],[971400.809927722,32],[971400.998368987,33],[971401.185043474,11],[971401.36833804,6],[971401.517961122,8],[971401.663787787,9],[971401.81275673,13],[971401.960785463,8],[971402.117114469,20],[971402.265904914,17],[971402.448420394,20],[971402.600797264,13],[971402.772977441,6],[971402.95686961,13],[971403.115949954,9],[971403.264255073,11],[971403.414241959,8],[971403.597696491,15],[971403.781838028,16],[971403.995759827,27],[971404.237384062,4],[971404.387682295,8],[971404.572684657,25],[971404.755808667,18],[971404.905015471,13],[971405.097299056,55],[971405.247461322,11],[971405.432829286,10],[971405.617304045,11],[971405.764384019,15],[971405.914948902,17],[971406.071919557,14],[971406.280710212,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-c4e4e8a1349c2b1d35930fa20ab97c25","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.11400389,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.484589557,"time_to_first_token":0.202009488,"token_sha":"8a91591c94a3","tokens_per_second":18.910475466984213},"seed":1234,"sent":971392.591927793,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.20489297294989228,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":9,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.908812705660072,"done":971406.282077614,"finish_reason":"length","first":971392.796283318,"full_response_s":13.692780990968458,"last":971406.282058653,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971392.796283318,3],[971392.94474445,11],[971393.135469469,30],[971393.318762631,19],[971393.501982175,21],[971393.682141282,15],[971393.827035025,19],[971393.980106408,17],[971394.166303267,12],[971394.348550163,5],[971394.496579649,5],[971394.679619347,27],[971394.861412205,12],[971395.049703557,13],[971395.232031453,5],[971395.380515252,16],[971395.561213925,5],[971395.743830137,14],[971395.925661859,9],[971396.082678527,22],[971396.230580723,10],[971396.412183631,7],[971396.596944226,23],[971396.74451068,5],[971396.891414619,9],[971397.08346449,14],[971397.231263952,20],[971397.380665066,8],[971397.529340868,12],[971397.677093816,5],[971397.823599652,14],[971398.011367056,14],[971398.165607919,8],[971398.345900313,13],[971398.518550781,3],[971398.703064733,10],[971398.850047138,11],[971399.040791312,9],[971399.225331732,10],[971399.406928267,20],[971399.557370973,14],[971399.735372986,14],[971399.967245404,13],[971400.161554661,5],[971400.339969287,22],[971400.573690259,3],[971400.808751336,32],[971400.998450591,33],[971401.186548306,11],[971401.370433953,6],[971401.515892234,8],[971401.663489727,9],[971401.812163729,13],[971401.960265601,8],[971402.118534049,20],[971402.267034562,17],[971402.450556053,20],[971402.599372852,13],[971402.771489746,6],[971402.957454211,13],[971403.114961704,9],[971403.263429886,11],[971403.41290563,8],[971403.598010168,15],[971403.781792106,16],[971403.994936112,27],[971404.239165834,4],[971404.386086596,8],[971404.572484296,25],[971404.755296021,18],[971404.905480387,13],[971405.096578322,55],[971405.246607397,11],[971405.432735842,10],[971405.616732052,11],[971405.763702406,15],[971405.913677312,17],[971406.071704156,14],[971406.282058653,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-f4dccd9a6fc1325079f12bf7b39ffa5f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.11412068,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.485926973,"time_to_first_token":0.200120895,"token_sha":"8a91591c94a3","tokens_per_second":18.908600091824034},"seed":1234,"sent":971392.589296623,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2069866949459538,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":10,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.90985146083834,"done":971406.28085473,"finish_reason":"length","first":971392.795784145,"full_response_s":13.692230408079922,"last":971406.28081868,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971392.795784145,3],[971392.944908217,11],[971393.136156763,30],[971393.318260082,19],[971393.501132154,21],[971393.683445978,15],[971393.827073602,19],[971393.978533396,17],[971394.166087801,12],[971394.348377772,5],[971394.496280372,5],[971394.679929249,27],[971394.860379201,12],[971395.050341505,13],[971395.231944569,5],[971395.380458193,16],[971395.561959861,5],[971395.744970602,14],[971395.929462551,9],[971396.081141629,22],[971396.228697442,10],[971396.412656435,7],[971396.596648629,23],[971396.747375971,5],[971396.891303862,9],[971397.086603281,14],[971397.232768848,20],[971397.379513912,8],[971397.528516353,12],[971397.676612547,5],[971397.824984528,14],[971398.012348138,14],[971398.164786683,8],[971398.346479826,13],[971398.519650588,3],[971398.70375417,10],[971398.849859962,11],[971399.03911356,9],[971399.223296653,10],[971399.407478226,20],[971399.553808308,14],[971399.737718334,14],[971399.968362779,13],[971400.158648232,5],[971400.34116889,22],[971400.574697646,3],[971400.80940978,32],[971400.997467861,33],[971401.184839913,11],[971401.369485913,6],[971401.516566599,8],[971401.663456541,9],[971401.814202312,13],[971401.960034647,8],[971402.1195327,20],[971402.267674013,17],[971402.451203889,20],[971402.599734051,13],[971402.772071562,6],[971402.956180973,13],[971403.118225763,9],[971403.264674227,11],[971403.414959285,8],[971403.598327222,15],[971403.78018695,16],[971403.994850012,27],[971404.237443105,4],[971404.385692819,8],[971404.571254548,25],[971404.75607351,18],[971404.905539045,13],[971405.097035157,55],[971405.247427448,11],[971405.434544223,10],[971405.617969161,11],[971405.764426981,15],[971405.914735709,17],[971406.072796314,14],[971406.28081868,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-d164fe492ec23add74711d7deff2020a","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.113790777,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.484474864,"time_to_first_token":0.202739936,"token_sha":"8a91591c94a3","tokens_per_second":18.91063631115387},"seed":1234,"sent":971392.588624322,"speculative":{"acceptance_rate":0.4154929577464789,"accepted":177,"drafted":426,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.2071598230395466,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":426,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":11,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.90690432845944,"done":971406.28288256,"finish_reason":"length","first":971392.79570707,"full_response_s":13.69286099402234,"last":971406.282843598,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971392.79570707,3],[971392.945429872,11],[971393.136488201,30],[971393.318528909,19],[971393.501417574,21],[971393.680923789,15],[971393.827463827,19],[971393.980301824,17],[971394.165143953,12],[971394.347662605,5],[971394.49480426,5],[971394.678348477,27],[971394.861230981,12],[971395.051322171,13],[971395.231284397,5],[971395.380012718,16],[971395.560301838,5],[971395.744730912,14],[971395.929018692,9],[971396.082377986,22],[971396.231400646,10],[971396.412327541,7],[971396.59545957,23],[971396.742989206,5],[971396.892051254,9],[971397.083704485,14],[971397.232652747,20],[971397.381491117,8],[971397.528296328,12],[971397.676058427,5],[971397.824035607,14],[971398.011463956,14],[971398.167079086,8],[971398.344291669,13],[971398.518454841,3],[971398.703469054,10],[971398.848902705,11],[971399.041056283,9],[971399.226988587,10],[971399.407067857,20],[971399.555688709,14],[971399.735912337,14],[971399.967748849,13],[971400.158138579,5],[971400.341496104,22],[971400.575263654,3],[971400.809804485,32],[971400.996540621,33],[971401.185379408,11],[971401.369584925,6],[971401.515394101,8],[971401.663869391,9],[971401.811167334,13],[971401.960831561,8],[971402.116840377,20],[971402.266944494,17],[971402.4496688,20],[971402.598794235,13],[971402.772343158,6],[971402.957042497,13],[971403.116107081,9],[971403.263885153,11],[971403.414841216,8],[971403.596926266,15],[971403.781523295,16],[971403.994778697,27],[971404.236159659,4],[971404.386918711,8],[971404.573039216,25],[971404.757576374,18],[971404.904240494,13],[971405.096747609,55],[971405.246530578,11],[971405.433743757,10],[971405.617545991,11],[971405.765811312,15],[971405.915471356,17],[971406.071365342,14],[971406.282843598,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-c243c27dc2d9a9da5f704cb4e56c6a3f","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.113754999,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.484503393,"time_to_first_token":0.203704762,"token_sha":"8a91591c94a3","tokens_per_second":18.910596302150374},"seed":1234,"sent":971392.590021566,"speculative":{"acceptance_rate":0.41451990632318503,"accepted":177,"drafted":427,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.20568550401367247,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":427,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":12,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.905073571516294,"done":971406.285085325,"finish_reason":"length","first":971392.796330649,"full_response_s":13.695489024976268,"last":971406.284773264,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971392.796330649,3],[971392.945570982,11],[971393.135855102,30],[971393.318651667,19],[971393.500637621,21],[971393.682102784,15],[971393.82668813,19],[971393.980634686,17],[971394.166380182,12],[971394.347772402,5],[971394.496090508,5],[971394.678039887,18],[971394.861673048,21],[971395.050624957,9],[971395.231470005,9],[971395.379336529,16],[971395.560669198,5],[971395.74621664,14],[971395.928401097,9],[971396.080812447,22],[971396.232495829,10],[971396.411266711,7],[971396.595715741,23],[971396.743854443,5],[971396.892126409,9],[971397.084864199,14],[971397.229994825,20],[971397.379846246,8],[971397.527587353,12],[971397.676691862,5],[971397.826437038,14],[971398.011977418,14],[971398.162458232,8],[971398.344854509,13],[971398.518714084,3],[971398.703634549,10],[971398.852774647,11],[971399.039622718,9],[971399.222757414,10],[971399.40738131,20],[971399.557664905,14],[971399.736031046,14],[971399.967163464,13],[971400.158866578,5],[971400.341851847,22],[971400.575310216,3],[971400.809898265,32],[971400.997261324,33],[971401.183769723,11],[971401.369961261,6],[971401.51833581,8],[971401.663925105,9],[971401.814543382,13],[971401.960638304,8],[971402.118161649,20],[971402.266140684,17],[971402.449747907,20],[971402.599420534,13],[971402.771545476,6],[971402.956074808,13],[971403.117715437,9],[971403.264703268,11],[971403.413816085,8],[971403.598274835,15],[971403.782587004,16],[971403.99504106,27],[971404.236644015,4],[971404.386575272,8],[971404.571416155,25],[971404.756451558,18],[971404.905324076,13],[971405.097151002,55],[971405.247261137,11],[971405.432302736,10],[971405.616404902,11],[971405.764855399,15],[971405.914285706,17],[971406.072513278,14],[971406.284773264,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-9feaddc95961112b8237975b4bb2e889","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.114325136,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.488595278,"time_to_first_token":0.200327143,"token_sha":"8a91591c94a3","tokens_per_second":18.90485960505516},"seed":1234,"sent":971392.5895963,"speculative":{"acceptance_rate":0.4254807692307692,"accepted":177,"drafted":416,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.20673434901982546,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":416,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":13,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.910393520826688,"done":971406.280532412,"finish_reason":"length","first":971392.795847668,"full_response_s":13.691420500981621,"last":971406.280495659,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971392.795847668,3],[971392.944541929,11],[971393.136210781,30],[971393.318800185,19],[971393.501187372,21],[971393.681195161,15],[971393.826556444,19],[971393.979814091,17],[971394.165703849,12],[971394.347486805,5],[971394.496021385,5],[971394.678639033,27],[971394.861834015,12],[971395.049349126,13],[971395.232924691,5],[971395.3798586,16],[971395.561363628,5],[971395.746315924,14],[971395.926720705,9],[971396.081904174,22],[971396.228933084,10],[971396.411793774,7],[971396.596422668,23],[971396.743750887,5],[971396.891215298,9],[971397.083643794,14],[971397.231217502,20],[971397.379314624,8],[971397.528110064,12],[971397.678862787,5],[971397.82448049,14],[971398.012408348,14],[971398.162774677,8],[971398.346081313,13],[971398.518642465,3],[971398.702401281,10],[971398.850361168,11],[971399.039311377,9],[971399.222497691,10],[971399.406320513,20],[971399.553746578,14],[971399.735428044,14],[971399.967643629,13],[971400.161467249,5],[971400.342092209,22],[971400.574595369,3],[971400.809844774,32],[971400.997877734,33],[971401.184239967,11],[971401.36801921,6],[971401.515627775,8],[971401.663402443,9],[971401.811841827,13],[971401.96118748,8],[971402.117446243,20],[971402.267338015,17],[971402.448706903,20],[971402.600723837,13],[971402.771755453,6],[971402.956954606,13],[971403.11731414,9],[971403.264067465,11],[971403.415834874,8],[971403.597407647,15],[971403.783028223,16],[971403.99622143,27],[971404.235441452,4],[971404.385476426,8],[971404.571106606,25],[971404.756870376,18],[971404.90606942,13],[971405.095977128,55],[971405.247121275,11],[971405.432178346,10],[971405.61780533,11],[971405.763920607,15],[971405.913521034,17],[971406.071622441,14],[971406.280495659,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-df6cc3ca8a8862b651f5af6bd6836545","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.113878861,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.484417389,"time_to_first_token":0.201914684,"token_sha":"8a91591c94a3","tokens_per_second":18.91071691447477},"seed":1234,"sent":971392.589111911,"speculative":{"acceptance_rate":0.4194312796208531,"accepted":177,"drafted":422,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.20673575694672763,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":422,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":14,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.909432359599663,"done":971406.28228359,"finish_reason":"length","first":971392.796929394,"full_response_s":13.690215742914006,"last":971406.282262806,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971392.796929394,3],[971392.945621432,11],[971393.135273093,30],[971393.317919491,19],[971393.500749673,21],[971393.681136374,15],[971393.827303244,19],[971393.980366515,17],[971394.165627333,12],[971394.347246091,5],[971394.4949006,5],[971394.678120067,27],[971394.860024657,12],[971395.050155385,13],[971395.230950686,5],[971395.381919184,16],[971395.561458032,5],[971395.74467283,14],[971395.927859234,9],[971396.081051705,22],[971396.230979588,10],[971396.412574543,7],[971396.596496207,23],[971396.746911391,5],[971396.891164688,9],[971397.086158222,14],[971397.231739988,20],[971397.380035406,8],[971397.527343199,12],[971397.675027295,5],[971397.824616832,14],[971398.011299133,14],[971398.164084157,8],[971398.346596455,13],[971398.519365504,3],[971398.704380293,10],[971398.84971138,11],[971399.039690161,9],[971399.22312607,10],[971399.40802169,20],[971399.55388324,14],[971399.738191746,14],[971399.967042243,13],[971400.160480519,5],[971400.340914367,22],[971400.574524774,3],[971400.808998274,32],[971400.996808041,33],[971401.186458078,11],[971401.369724323,6],[971401.516777376,8],[971401.663033195,9],[971401.811435698,13],[971401.961600409,8],[971402.119097657,20],[971402.265501089,17],[971402.448482509,20],[971402.599850056,13],[971402.772737175,6],[971402.956668066,13],[971403.117784608,9],[971403.26507626,11],[971403.413373506,8],[971403.598550687,15],[971403.782169402,16],[971403.995552058,27],[971404.236523978,4],[971404.385751221,8],[971404.572032469,25],[971404.756284879,18],[971404.90569582,13],[971405.096098221,55],[971405.246687609,11],[971405.432590556,10],[971405.616533004,11],[971405.764488712,15],[971405.915381768,17],[971406.073628573,14],[971406.282262806,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-6fdf6e7e6ef895356189ad21c102ffd3","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.114158889,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.485791576,"time_to_first_token":0.199562055,"token_sha":"8a91591c94a3","tokens_per_second":18.908789933681827},"seed":1234,"sent":971392.592067847,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.20486154698301107,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":0,"stream":15,"phase":"first_measured","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.634176192235675,"done":971406.28019275,"finish_reason":"length","first":971392.595599743,"full_response_s":13.691665392019786,"last":971406.280132795,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971392.595599743,3],[971392.68330488,26],[971392.944702016,15],[971393.13655774,19],[971393.318715813,21],[971393.500468381,15],[971393.682166035,19],[971393.826288177,17],[971393.978370301,6],[971394.166436888,11],[971394.346694915,5],[971394.49564564,18],[971394.678861523,21],[971394.859408007,5],[971395.049544254,8],[971395.232489313,5],[971395.379757491,16],[971395.56016948,5],[971395.743966127,14],[971395.926297615,9],[971396.080581733,22],[971396.229259898,10],[971396.411656296,7],[971396.596134255,23],[971396.744187338,5],[971396.891020394,9],[971397.083330133,14],[971397.230818284,20],[971397.380572214,8],[971397.527203769,12],[971397.674219868,5],[971397.824254784,14],[971398.011596697,14],[971398.166363343,8],[971398.346535301,13],[971398.518950126,3],[971398.70406676,10],[971398.850081652,11],[971399.039212748,9],[971399.223758689,10],[971399.404974663,20],[971399.553942506,14],[971399.735560818,14],[971399.966819001,13],[971400.159616562,5],[971400.340787434,22],[971400.575667927,3],[971400.809533369,32],[971400.996378358,33],[971401.184763686,11],[971401.369401093,6],[971401.519067522,8],[971401.663369098,9],[971401.813238399,13],[971401.960432792,8],[971402.118066333,20],[971402.26609361,17],[971402.449853335,20],[971402.600153333,13],[971402.771616359,6],[971402.955901505,13],[971403.11524514,9],[971403.264385494,11],[971403.414672441,8],[971403.59861149,15],[971403.779640495,16],[971403.994723175,27],[971404.235604819,4],[971404.38557827,8],[971404.57096436,25],[971404.755509918,18],[971404.904354371,13],[971405.096443964,55],[971405.246177539,11],[971405.432097415,10],[971405.617880245,11],[971405.765505443,15],[971405.914505587,17],[971406.071242553,14],[971406.280132795,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-11a12a57a4a059746b99aaf561aa3bc1","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.002265346,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.686082271,"time_to_first_token":0.002799257,"token_sha":"8a91591c94a3","tokens_per_second":18.632066865499556},"seed":1234,"sent":971392.588527358,"speculative":{"acceptance_rate":0.4018264840182648,"accepted":176,"drafted":438,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.007072384934872389,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":438,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.905949236607192,"done":971419.914269913,"finish_reason":"length","first":971406.426419095,"full_response_s":13.615871064946987,"last":971419.914236967,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971406.426419095,3],[971406.57641203,11],[971406.761323915,30],[971406.943838682,19],[971407.132617181,21],[971407.317101947,15],[971407.462096902,19],[971407.609576202,17],[971407.791513165,12],[971407.972635426,5],[971408.130498641,5],[971408.309951679,27],[971408.493687778,12],[971408.677341105,13],[971408.861984326,5],[971409.0108428,16],[971409.195825226,5],[971409.380825206,14],[971409.564144794,9],[971409.745992913,27],[971409.893676644,11],[971410.081430326,8],[971410.231709458,16],[971410.379307357,5],[971410.527801246,9],[971410.712905009,14],[971410.860441238,20],[971411.013913054,8],[971411.166086783,12],[971411.314532404,5],[971411.463089134,14],[971411.646708182,14],[971411.792781496,8],[971411.977073042,13],[971412.158812735,3],[971412.338352785,10],[971412.48603454,11],[971412.668369602,9],[971412.850845468,10],[971413.039313448,20],[971413.190058857,14],[971413.373774061,14],[971413.600785301,13],[971413.784596061,5],[971413.967705197,22],[971414.208800578,3],[971414.447208774,32],[971414.630685924,33],[971414.814399516,11],[971415.002330216,6],[971415.15581916,8],[971415.30581583,9],[971415.454977825,13],[971415.602900441,8],[971415.751944239,20],[971415.899991958,17],[971416.091027847,20],[971416.239650834,13],[971416.413055205,6],[971416.598900798,13],[971416.74889269,9],[971416.897051652,11],[971417.052662999,8],[971417.241526785,15],[971417.426198045,16],[971417.634713191,27],[971417.871896534,4],[971418.025110332,8],[971418.21051425,25],[971418.397731683,18],[971418.547287649,13],[971418.731730455,55],[971418.881411318,11],[971419.072322716,10],[971419.26097482,11],[971419.408643082,15],[971419.556078199,17],[971419.706062861,14],[971419.914236967,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-ef242c21b86197e7124b107e886cb972","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.033678464,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.489192539,"time_to_first_token":0.124654872,"token_sha":"8a91591c94a3","tokens_per_second":18.904022554555667},"seed":1234,"sent":971406.298398848,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12802024697884917,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.900102435770798,"done":971419.917432636,"finish_reason":"length","first":971406.42532948,"full_response_s":13.617638112977147,"last":971419.917319847,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971406.42532948,3],[971406.576067696,11],[971406.760049861,30],[971406.943172605,19],[971407.13083101,21],[971407.314029066,15],[971407.463066527,19],[971407.607951125,17],[971407.790663081,12],[971407.97405107,5],[971408.128278148,5],[971408.31215646,27],[971408.493051559,12],[971408.675207351,13],[971408.858219783,5],[971409.010943556,16],[971409.197394236,5],[971409.382301844,14],[971409.561655665,9],[971409.746769953,27],[971409.892839409,11],[971410.082654922,8],[971410.230688023,16],[971410.379922887,5],[971410.528290563,9],[971410.713969246,14],[971410.859674054,20],[971411.013978129,8],[971411.164992386,12],[971411.316399363,5],[971411.461857834,14],[971411.646282501,14],[971411.792385207,8],[971411.976997598,13],[971412.155122229,3],[971412.335779557,10],[971412.485949896,11],[971412.66797093,9],[971412.850039067,10],[971413.040326818,20],[971413.190302035,14],[971413.370408512,14],[971413.600972428,13],[971413.784117081,5],[971413.967749167,22],[971414.210130586,3],[971414.447723324,32],[971414.630998882,33],[971414.816083186,11],[971415.002862398,6],[971415.155897035,8],[971415.30374208,9],[971415.455654814,13],[971415.601461021,8],[971415.750848594,20],[971415.898705249,17],[971416.09114158,20],[971416.239807513,13],[971416.414782141,6],[971416.598340822,13],[971416.747095431,9],[971416.896415545,11],[971417.051887463,8],[971417.238903396,15],[971417.422857506,16],[971417.633557415,27],[971417.870264466,4],[971418.024893107,8],[971418.210986221,25],[971418.398186022,18],[971418.547377333,13],[971418.731809226,55],[971418.881131562,11],[971419.072173445,10],[971419.257669115,11],[971419.408324365,15],[971419.556500168,17],[971419.70734909,14],[971419.917319847,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-44bda776e3a2e1dd99def32874517a61","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.033783653,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.492254474,"time_to_first_token":0.123764642,"token_sha":"8a91591c94a3","tokens_per_second":18.899732471796543},"seed":1234,"sent":971406.299794523,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1255349569255486,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.90492079950856,"done":971419.914638552,"finish_reason":"length","first":971406.426039238,"full_response_s":13.615499145002104,"last":971419.914590854,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971406.426039238,3],[971406.577401128,11],[971406.760547626,30],[971406.943029239,19],[971407.130713357,21],[971407.314817531,15],[971407.462309055,19],[971407.609038115,17],[971407.791142781,12],[971407.973511111,5],[971408.128379064,5],[971408.311044173,27],[971408.494871684,12],[971408.675952358,13],[971408.861620887,5],[971409.012174776,16],[971409.196102406,5],[971409.380878936,14],[971409.562756176,9],[971409.746414515,27],[971409.894966074,11],[971410.081770613,8],[971410.232195463,16],[971410.38056933,5],[971410.52727988,9],[971410.712639222,14],[971410.862270163,20],[971411.01452276,8],[971411.165737857,12],[971411.315943855,5],[971411.463403707,14],[971411.646600226,14],[971411.792567839,8],[971411.976497817,13],[971412.156163056,3],[971412.338043188,10],[971412.485841156,11],[971412.667766441,9],[971412.850482205,10],[971413.040157371,20],[971413.189181524,14],[971413.372340369,14],[971413.600216877,13],[971413.785830128,5],[971413.96781125,22],[971414.208334254,3],[971414.447768878,32],[971414.632650902,33],[971414.817392937,11],[971415.00247251,6],[971415.15568229,8],[971415.305020261,9],[971415.455508375,13],[971415.601693255,8],[971415.75172783,20],[971415.899619751,17],[971416.091897707,20],[971416.239214496,13],[971416.413799124,6],[971416.599778818,13],[971416.748763404,9],[971416.898498848,11],[971417.051844629,8],[971417.240013378,15],[971417.425398748,16],[971417.634274197,27],[971417.871512902,4],[971418.025241073,8],[971418.210084344,25],[971418.398481282,18],[971418.547666257,13],[971418.732235964,55],[971418.881058487,11],[971419.073382119,10],[971419.259212139,11],[971419.407476122,15],[971419.556820005,17],[971419.708270088,14],[971419.914590854,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-d8d971968f260765015df2805683f31c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.03343983,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.489682127,"time_to_first_token":0.125191423,"token_sha":"8a91591c94a3","tokens_per_second":18.903336461102366},"seed":1234,"sent":971406.299139407,"speculative":{"acceptance_rate":0.4164705882352941,"accepted":177,"drafted":425,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1268998309969902,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":425,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.90387835088385,"done":971419.915870187,"finish_reason":"length","first":971406.426556652,"full_response_s":13.61646553594619,"last":971419.91585209,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971406.426556652,3],[971406.576907619,11],[971406.759187937,30],[971406.942617558,19],[971407.131925168,21],[971407.316613591,15],[971407.461529438,19],[971407.608819978,17],[971407.791320372,12],[971407.973083925,5],[971408.12980138,5],[971408.312502267,27],[971408.494041889,12],[971408.676211377,13],[971408.859772345,5],[971409.012040866,16],[971409.198684419,5],[971409.379487085,14],[971409.564682193,9],[971409.745599264,27],[971409.893524365,11],[971410.082935222,8],[971410.231436055,16],[971410.38051184,5],[971410.526997116,9],[971410.714172407,14],[971410.861060992,20],[971411.012429312,8],[971411.166145138,12],[971411.316128647,5],[971411.462853044,14],[971411.645787952,14],[971411.794238677,8],[971411.976381717,13],[971412.156055404,3],[971412.336511284,10],[971412.487255343,11],[971412.669853969,9],[971412.851607868,10],[971413.038530631,20],[971413.190196655,14],[971413.371330423,14],[971413.601197254,13],[971413.784485944,5],[971413.968237636,22],[971414.21095654,3],[971414.445812764,32],[971414.630839355,33],[971414.816029744,11],[971415.001614234,6],[971415.1548596,8],[971415.305096664,9],[971415.456382588,13],[971415.601524976,8],[971415.752362321,20],[971415.900567294,17],[971416.091986767,20],[971416.239093755,13],[971416.414831407,6],[971416.598831947,13],[971416.747534745,9],[971416.898088063,11],[971417.051781747,8],[971417.239227778,15],[971417.426538475,16],[971417.634472637,27],[971417.872007146,4],[971418.023256431,8],[971418.211086321,25],[971418.397122169,18],[971418.546311993,13],[971418.732706927,55],[971418.881250303,11],[971419.072513347,10],[971419.257811713,11],[971419.407687219,15],[971419.556752227,17],[971419.706768122,14],[971419.91585209,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-a24c21d07c74f418fc693572b66afa3c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.033751795,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.490051215,"time_to_first_token":0.124704106,"token_sha":"8a91591c94a3","tokens_per_second":18.902819265538273},"seed":1234,"sent":971406.299404651,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12715200090315193,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.904853342927346,"done":971419.914134979,"finish_reason":"length","first":971406.425494927,"full_response_s":13.615633615059778,"last":971419.914094673,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971406.425494927,3],[971406.579217733,11],[971406.760335169,30],[971406.942396525,19],[971407.132283967,21],[971407.316840768,15],[971407.460837073,19],[971407.608239249,17],[971407.790150579,12],[971407.974379659,5],[971408.128683877,5],[971408.311322009,27],[971408.49208435,12],[971408.67662421,13],[971408.85843304,5],[971409.011557566,16],[971409.197774492,5],[971409.381522003,14],[971409.564466376,9],[971409.745118028,27],[971409.892605223,11],[971410.082307643,8],[971410.230946786,16],[971410.379076516,5],[971410.528641553,9],[971410.711727456,14],[971410.860353203,20],[971411.013593265,8],[971411.165469014,12],[971411.314260793,5],[971411.465118707,14],[971411.645592216,14],[971411.792895804,8],[971411.977829233,13],[971412.157127705,3],[971412.336644745,10],[971412.484723941,11],[971412.66787603,9],[971412.85154481,10],[971413.040030358,20],[971413.188838502,14],[971413.37053079,14],[971413.600496616,13],[971413.783481742,5],[971413.968430316,22],[971414.206579557,3],[971414.444647243,32],[971414.633450632,33],[971414.816197399,11],[971415.002767546,6],[971415.155351188,8],[971415.304038828,9],[971415.454595953,13],[971415.602371779,8],[971415.750233736,20],[971415.899131459,17],[971416.089531545,20],[971416.239719429,13],[971416.413375506,6],[971416.598037034,13],[971416.747449062,9],[971416.896841771,11],[971417.053134971,8],[971417.239871069,15],[971417.425731561,16],[971417.635226925,27],[971417.872633764,4],[971418.024439584,8],[971418.210635855,25],[971418.396915841,18],[971418.547861785,13],[971418.732401715,55],[971418.880711577,11],[971419.073337958,10],[971419.260597412,11],[971419.407345172,15],[971419.557232247,17],[971419.706690535,14],[971419.914094673,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-95b8b179e412c0fe677ef21dee1c8b84","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.033402932,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.489202748,"time_to_first_token":0.124773389,"token_sha":"8a91591c94a3","tokens_per_second":18.904008247470966},"seed":1234,"sent":971406.298501364,"speculative":{"acceptance_rate":0.4154929577464789,"accepted":177,"drafted":426,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1269935630261898,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":426,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.903184038180342,"done":971419.915989904,"finish_reason":"length","first":971406.426173196,"full_response_s":13.617347157909535,"last":971419.915964095,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971406.426173196,3],[971406.579309689,11],[971406.759133454,30],[971406.943317172,19],[971407.131197745,21],[971407.315700752,15],[971407.461215841,19],[971407.609786083,17],[971407.791859115,12],[971407.973455557,5],[971408.130656328,5],[971408.312291378,27],[971408.491256891,12],[971408.676410745,13],[971408.860027091,5],[971409.012576361,16],[971409.198894572,5],[971409.379955201,14],[971409.565578759,9],[971409.746972378,27],[971409.893608881,11],[971410.081656832,8],[971410.232516468,16],[971410.381120937,5],[971410.527328442,9],[971410.714725838,14],[971410.860955324,20],[971411.011940235,8],[971411.16677734,12],[971411.316322223,5],[971411.464638383,14],[971411.64656328,14],[971411.793841748,8],[971411.976029958,13],[971412.156707271,3],[971412.337099772,10],[971412.487591533,11],[971412.670356246,9],[971412.851111272,10],[971413.039975955,20],[971413.19305423,14],[971413.371815387,14],[971413.601710411,13],[971413.784695473,5],[971413.967402561,22],[971414.207990976,3],[971414.447592086,32],[971414.631185753,33],[971414.817064283,11],[971415.002419276,6],[971415.155182573,8],[971415.305667488,9],[971415.45661495,13],[971415.602957835,8],[971415.75104193,20],[971415.901442915,17],[971416.091317955,20],[971416.240449636,13],[971416.413516168,6],[971416.599910344,13],[971416.747736145,9],[971416.898166738,11],[971417.052363403,8],[971417.239790345,15],[971417.423530766,16],[971417.636471393,27],[971417.872202434,4],[971418.023822326,8],[971418.210873817,25],[971418.397452071,18],[971418.548343213,13],[971418.73291772,55],[971418.881807622,11],[971419.073551406,10],[971419.258688261,11],[971419.407179181,15],[971419.556437734,17],[971419.706231636,14],[971419.915964095,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-6e412e423f231f766a6d6205ca4ca0d4","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.033605837,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.489490552,"time_to_first_token":0.125092795,"token_sha":"8a91591c94a3","tokens_per_second":18.903604922440365},"seed":1234,"sent":971406.298642746,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12753045000135899,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.735067154166206,"done":971419.913881945,"finish_reason":"length","first":971406.302991858,"full_response_s":13.615316929994151,"last":971419.913831782,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971406.302991858,3],[971406.392137885,26],[971406.577031833,15],[971406.760182267,19],[971406.941911928,21],[971407.131136271,15],[971407.314553552,19],[971407.460656761,17],[971407.608969248,6],[971407.791083786,11],[971407.973137719,5],[971408.129878823,18],[971408.309681828,21],[971408.492887312,5],[971408.676076923,8],[971408.858578358,5],[971409.010251863,16],[971409.197542691,5],[971409.380012451,14],[971409.561922957,9],[971409.74688175,27],[971409.893162654,11],[971410.082244169,8],[971410.231951868,16],[971410.380098655,5],[971410.526651918,9],[971410.714373951,14],[971410.861261641,20],[971411.012012783,8],[971411.168654459,12],[971411.315233106,5],[971411.464344994,14],[971411.646399449,14],[971411.792498796,8],[971411.976237519,13],[971412.158360428,3],[971412.33689818,10],[971412.485600458,11],[971412.669068384,9],[971412.850329271,10],[971413.038711838,20],[971413.188667391,14],[971413.372945019,14],[971413.602142573,13],[971413.784879449,5],[971413.967324062,22],[971414.20870131,3],[971414.444976601,32],[971414.631398914,33],[971414.816603672,11],[971415.002690487,6],[971415.155742949,8],[971415.305300897,9],[971415.45605003,13],[971415.600833315,8],[971415.75037915,20],[971415.899575797,17],[971416.08989908,20],[971416.238990791,13],[971416.412873437,6],[971416.598756328,13],[971416.747291391,9],[971416.89870164,11],[971417.052053374,8],[971417.240283486,15],[971417.424079925,16],[971417.633665516,27],[971417.871627867,4],[971418.023944523,8],[971418.210700465,25],[971418.397212029,18],[971418.546414237,13],[971418.732173225,55],[971418.880921489,11],[971419.073263459,10],[971419.258347751,11],[971419.406766204,15],[971419.557321002,17],[971419.70725187,14],[971419.913831782,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-c5e7d64d18befcc1aed63938b372bf94","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.002293921,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.610838964,"time_to_first_token":0.002715683,"token_sha":"8a91591c94a3","tokens_per_second":18.73506847553354},"seed":1234,"sent":971406.298565015,"speculative":{"acceptance_rate":0.4018264840182648,"accepted":176,"drafted":438,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.004426843021064997,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":438,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.899273009031464,"done":971419.919676904,"finish_reason":"length","first":971406.425926802,"full_response_s":13.620147672016174,"last":971419.918509288,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971406.425926802,3],[971406.578091349,11],[971406.759530143,30],[971406.942551987,19],[971407.132129881,21],[971407.315880424,15],[971407.462826197,19],[971407.609312063,17],[971407.791907869,12],[971407.97281625,5],[971408.130360812,5],[971408.311402908,18],[971408.49297418,21],[971408.676680597,9],[971408.858874707,9],[971409.011692996,16],[971409.196537048,5],[971409.379780378,14],[971409.562596777,9],[971409.744774333,27],[971409.893757351,11],[971410.081300737,8],[971410.230854606,16],[971410.380019531,5],[971410.526939146,9],[971410.713454936,14],[971410.86248646,20],[971411.011893066,8],[971411.167737077,12],[971411.314479682,5],[971411.4630403,14],[971411.64745367,14],[971411.792822953,8],[971411.976734195,13],[971412.155323629,3],[971412.337623906,10],[971412.486425708,11],[971412.668925786,9],[971412.850199937,10],[971413.039839038,20],[971413.1917632,14],[971413.371918912,14],[971413.600115833,13],[971413.783935713,5],[971413.967994282,22],[971414.207622801,3],[971414.445255221,32],[971414.630253346,33],[971414.814875424,11],[971415.001994138,6],[971415.155559149,8],[971415.303859604,9],[971415.456103024,13],[971415.600963,8],[971415.750166213,20],[971415.899199958,17],[971416.090099793,20],[971416.238891619,13],[971416.414291512,6],[971416.598478668,13],[971416.747790356,9],[971416.897340272,11],[971417.052127233,8],[971417.241907073,15],[971417.424143127,16],[971417.6346309,27],[971417.871384,4],[971418.024291882,8],[971418.210230814,25],[971418.397842135,18],[971418.546502752,13],[971418.732490711,55],[971418.881489705,11],[971419.07257431,10],[971419.258232434,11],[971419.407933037,15],[971419.556560507,17],[971419.708021598,14],[971419.918509288,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-33a8f1d961744f396f0c99cc7dbc17be","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.033901418,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.493304069,"time_to_first_token":0.123858198,"token_sha":"8a91591c94a3","tokens_per_second":18.898262330413655},"seed":1234,"sent":971406.299529232,"speculative":{"acceptance_rate":0.4254807692307692,"accepted":177,"drafted":416,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12639757001306862,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":416,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.903924766844096,"done":971419.91512406,"finish_reason":"length","first":971406.425816349,"full_response_s":13.616383102023974,"last":971419.915078666,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971406.425816349,3],[971406.578817556,11],[971406.761056528,30],[971406.943748966,19],[971407.131565393,21],[971407.316498482,15],[971407.462780275,19],[971407.60925326,17],[971407.792041971,12],[971407.973782466,5],[971408.131873532,5],[971408.310937433,27],[971408.494977256,12],[971408.676124317,13],[971408.859389689,5],[971409.011280994,16],[971409.198109226,5],[971409.380415044,14],[971409.562940039,9],[971409.745876012,27],[971409.894472245,11],[971410.081544555,8],[971410.231329682,16],[971410.380750538,5],[971410.528431752,9],[971410.714297692,14],[971410.860562652,20],[971411.014267197,8],[971411.16723872,12],[971411.316562217,5],[971411.46237592,14],[971411.646792714,14],[971411.793032434,8],[971411.975602628,13],[971412.159415513,3],[971412.338533256,10],[971412.484627601,11],[971412.66950213,9],[971412.85078641,10],[971413.038763025,20],[971413.190490331,14],[971413.374096251,14],[971413.601033839,13],[971413.785496802,5],[971413.967638891,22],[971414.21125444,3],[971414.444805906,32],[971414.631913816,33],[971414.815240319,11],[971415.002222644,6],[971415.1552484,8],[971415.304822829,9],[971415.455699423,13],[971415.601949297,8],[971415.751120029,20],[971415.901144327,17],[971416.091828873,20],[971416.240178792,13],[971416.413724289,6],[971416.600401068,13],[971416.747226972,9],[971416.899381445,11],[971417.051686015,8],[971417.240857285,15],[971417.424249564,16],[971417.633901654,27],[971417.870820345,4],[971418.024031103,8],[971418.210299297,25],[971418.397384804,18],[971418.547078408,13],[971418.732445973,55],[971418.881346691,11],[971419.07315515,10],[971419.260283191,11],[971419.408133669,15],[971419.55741403,17],[971419.70764019,14],[971419.915078666,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-c22d0043646bb33e448c994bc926212c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.033642319,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.489512008,"time_to_first_token":0.124863825,"token_sha":"8a91591c94a3","tokens_per_second":18.903574854951863},"seed":1234,"sent":971406.298740958,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.127075391006656,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.904952846097363,"done":971419.914205462,"finish_reason":"length","first":971406.425652278,"full_response_s":13.614976690965705,"last":971419.914181029,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971406.425652278,3],[971406.578029587,11],[971406.759015049,30],[971406.942313625,19],[971407.132696337,21],[971407.31413947,15],[971407.461892142,19],[971407.61001438,17],[971407.790892466,12],[971407.974576932,5],[971408.13130938,5],[971408.310417859,27],[971408.491495909,12],[971408.675432192,13],[971408.860394483,5],[971409.011362086,16],[971409.198200062,5],[971409.37902257,14],[971409.562689181,9],[971409.744592758,27],[971409.892512883,11],[971410.082837538,8],[971410.231895674,16],[971410.379824323,5],[971410.527849248,9],[971410.712374779,14],[971410.860268255,20],[971411.012985511,8],[971411.165108054,12],[971411.313377444,5],[971411.461648145,14],[971411.645017551,14],[971411.793512998,8],[971411.977321388,13],[971412.155409233,3],[971412.337302933,10],[971412.483968853,11],[971412.666879028,9],[971412.851479815,10],[971413.038839652,20],[971413.192380778,14],[971413.370754079,14],[971413.601994231,13],[971413.786632818,5],[971413.967873781,22],[971414.207772839,3],[971414.446860344,32],[971414.629943349,33],[971414.814217365,11],[971415.002149905,6],[971415.155859546,8],[971415.303947096,9],[971415.455981483,13],[971415.601271029,8],[971415.750787983,20],[971415.899913619,17],[971416.090687721,20],[971416.2406463,13],[971416.414107377,6],[971416.599488358,13],[971416.747930378,9],[971416.89672871,11],[971417.05344052,8],[971417.241801357,15],[971417.423975809,16],[971417.633490677,27],[971417.86974398,4],[971418.023495865,8],[971418.211388334,25],[971418.396662886,18],[971418.546821358,13],[971418.732952586,55],[971418.880827261,11],[971419.072830241,10],[971419.259835221,11],[971419.406350011,15],[971419.555778362,17],[971419.70646363,14],[971419.914181029,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-9c24360101d43520aca851a66973f181","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.033475863,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.489104295,"time_to_first_token":0.12459855,"token_sha":"8a91591c94a3","tokens_per_second":18.90414622226034},"seed":1234,"sent":971406.299228771,"speculative":{"acceptance_rate":0.4194312796208531,"accepted":177,"drafted":422,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1264235069975257,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":422,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.9038275601345,"done":971419.914747084,"finish_reason":"length","first":971406.425378394,"full_response_s":13.615912634064443,"last":971419.914710075,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971406.425378394,3],[971406.576558197,11],[971406.75878624,30],[971406.941740865,19],[971407.131661877,21],[971407.314393929,15],[971407.462573034,19],[971407.608373127,17],[971407.790794638,12],[971407.974134305,5],[971408.126813766,5],[971408.310086149,27],[971408.491754192,12],[971408.676258963,13],[971408.859946512,5],[971409.010734587,16],[971409.196928345,5],[971409.380760707,14],[971409.56142996,9],[971409.746269132,27],[971409.89463862,11],[971410.082889364,8],[971410.232576231,16],[971410.380370762,5],[971410.526552777,9],[971410.713690994,14],[971410.860141226,20],[971411.013069723,8],[971411.166321273,12],[971411.314678554,5],[971411.462701005,14],[971411.645902645,14],[971411.791719323,8],[971411.975880304,13],[971412.155719582,3],[971412.33671286,10],[971412.485291293,11],[971412.66846439,9],[971412.851918505,10],[971413.038669597,20],[971413.189775709,14],[971413.373269128,14],[971413.599902608,13],[971413.785285642,5],[971413.968081469,22],[971414.210465911,3],[971414.445717224,32],[971414.632172035,33],[971414.814021516,11],[971415.002058413,6],[971415.155630544,8],[971415.304933057,9],[971415.455748113,13],[971415.602528858,8],[971415.750448721,20],[971415.899494162,17],[971416.090309017,20],[971416.239445994,13],[971416.414343563,6],[971416.598961104,13],[971416.748409662,9],[971416.899060151,11],[971417.051975947,8],[971417.239049418,15],[971417.423805849,16],[971417.633283532,27],[971417.872458205,4],[971418.023641647,8],[971418.210388948,25],[971418.397024613,18],[971418.546607461,13],[971418.731932671,55],[971418.880022252,11],[971419.073612913,10],[971419.259919256,11],[971419.408369823,15],[971419.556268895,17],[971419.707105816,14],[971419.914710075,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-e692b5c520d92b326cf1bb6690c5c97b","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.033365635,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.489186235,"time_to_first_token":0.124802974,"token_sha":"8a91591c94a3","tokens_per_second":18.904031389110703},"seed":1234,"sent":971406.29883445,"speculative":{"acceptance_rate":0.41451990632318503,"accepted":177,"drafted":427,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12654394400306046,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":427,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.90107177361324,"done":971419.917596242,"finish_reason":"length","first":971406.426247567,"full_response_s":13.617938477080315,"last":971419.917546,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971406.426247567,3],[971406.57711206,11],[971406.761420191,30],[971406.941645069,19],[971407.13253297,21],[971407.315378131,15],[971407.46075891,19],[971407.608463755,17],[971407.790045487,12],[971407.972753223,5],[971408.130759901,5],[971408.309394088,18],[971408.492265318,21],[971408.677240668,13],[971408.857815782,5],[971409.011021287,16],[971409.198451385,5],[971409.379296149,14],[971409.561524716,9],[971409.744903891,27],[971409.892991319,11],[971410.081911803,8],[971410.229979994,16],[971410.378752678,5],[971410.527942212,9],[971410.71181674,14],[971410.859451773,20],[971411.014600235,8],[971411.164756008,12],[971411.315578608,5],[971411.462082484,14],[971411.646323846,14],[971411.794304936,8],[971411.97765137,13],[971412.157649279,3],[971412.338442869,10],[971412.486824061,11],[971412.667230035,9],[971412.852059919,10],[971413.03955645,20],[971413.189287721,14],[971413.371427115,14],[971413.601253496,13],[971413.785972102,5],[971413.967483428,22],[971414.206984966,3],[971414.444275532,32],[971414.630057994,33],[971414.816135029,11],[971415.002821533,6],[971415.154942323,8],[971415.304456333,9],[971415.455200843,13],[971415.601078589,8],[971415.750098242,20],[971415.898924666,17],[971416.08969216,20],[971416.239154494,13],[971416.414070671,6],[971416.600178867,13],[971416.749072137,9],[971416.898577763,11],[971417.052517393,8],[971417.23822356,15],[971417.424524631,16],[971417.635859559,27],[971417.872302903,4],[971418.025437257,8],[971418.210456567,25],[971418.398143124,18],[971418.548218488,13],[971418.731110605,55],[971418.8803995,11],[971419.073819114,10],[971419.259467333,11],[971419.408573671,15],[971419.557061679,17],[971419.705473621,14],[971419.917546,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-d59dbf32a4a0346df5ce6530eaf83d92","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.033820023,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.492400959,"time_to_first_token":0.124126898,"token_sha":"8a91591c94a3","tokens_per_second":18.89952728019873},"seed":1234,"sent":971406.299657765,"speculative":{"acceptance_rate":0.4224343675417661,"accepted":177,"drafted":419,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12658980209380388,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":419,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.904154273451592,"done":971419.915192767,"finish_reason":"length","first":971406.426067048,"full_response_s":13.616230327053927,"last":971419.915165598,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971406.426067048,3],[971406.576784206,11],[971406.760785572,30],[971406.943481979,19],[971407.131516751,21],[971407.31469439,15],[971407.462885367,19],[971407.609497767,17],[971407.790943237,12],[971407.973043603,5],[971408.130169316,5],[971408.310791283,27],[971408.49360955,12],[971408.676485212,13],[971408.859056475,5],[971409.012483413,16],[971409.197136546,5],[971409.379847452,14],[971409.562303021,9],[971409.74582441,27],[971409.893877292,11],[971410.081849736,8],[971410.232015119,16],[971410.381361252,5],[971410.527102321,9],[971410.712567299,14],[971410.861621512,20],[971411.013341574,8],[971411.167672914,12],[971411.31495815,5],[971411.46246706,14],[971411.64645758,14],[971411.794130496,8],[971411.975937986,13],[971412.156981747,3],[971412.336415264,10],[971412.485541863,11],[971412.669765229,9],[971412.85098269,10],[971413.039264149,20],[971413.189928563,14],[971413.37106638,14],[971413.599809932,13],[971413.786549983,5],[971413.967134886,22],[971414.209517664,3],[971414.446422453,32],[971414.630896909,33],[971414.815901387,11],[971415.00175824,6],[971415.155115418,8],[971415.304617732,9],[971415.455291918,13],[971415.602035461,8],[971415.751266931,20],[971415.900820825,17],[971416.09171274,20],[971416.23998872,13],[971416.414705834,6],[971416.599240908,13],[971416.747834342,9],[971416.897437412,11],[971417.052568115,8],[971417.239521406,15],[971417.426121562,16],[971417.634026763,27],[971417.871958664,4],[971418.023119673,8],[971418.211317451,25],[971418.397896218,18],[971418.547329411,13],[971418.732617308,55],[971418.881858872,11],[971419.072254313,10],[971419.257985064,11],[971419.407056824,15],[971419.556330257,17],[971419.706371066,14],[971419.915165598,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-b7d03648d5660cc2e2775b8fc72e09c8","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.033533226,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.489506456,"time_to_first_token":0.124993911,"token_sha":"8a91591c94a3","tokens_per_second":18.90358263526969},"seed":1234,"sent":971406.29896244,"speculative":{"acceptance_rate":0.4194312796208531,"accepted":177,"drafted":422,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12710460799280554,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":422,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.903351215491604,"done":971419.915592655,"finish_reason":"length","first":971406.425875568,"full_response_s":13.61613492993638,"last":971419.915547166,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971406.425875568,3],[971406.577975024,11],[971406.759239699,30],[971406.942981253,19],[971407.131742904,21],[971407.315501832,15],[971407.46181473,19],[971407.608883549,17],[971407.792343072,12],[971407.973172633,5],[971408.127494707,5],[971408.309840651,27],[971408.493138859,12],[971408.675562246,13],[971408.859841884,5],[971409.011091674,16],[971409.198375974,5],[971409.380064166,14],[971409.56508941,9],[971409.745478299,27],[971409.89324333,11],[971410.082576039,8],[971410.231796214,16],[971410.380616596,5],[971410.52671824,9],[971410.71301871,14],[971410.86101331,20],[971411.012638329,8],[971411.166848559,12],[971411.317139938,5],[971411.462737343,14],[971411.646497582,14],[971411.793910519,8],[971411.976159691,13],[971412.155875412,3],[971412.336338365,10],[971412.485405297,11],[971412.668531321,9],[971412.851413012,10],[971413.039471966,20],[971413.191320094,14],[971413.372689088,14],[971413.600567627,13],[971413.784804358,5],[971413.967565544,22],[971414.207207503,3],[971414.446273103,32],[971414.630782425,33],[971414.816420001,11],[971415.001683469,6],[971415.155510331,8],[971415.306076993,9],[971415.455362321,13],[971415.602151354,8],[971415.750653098,20],[971415.900612704,17],[971416.090912018,20],[971416.239577615,13],[971416.41453037,6],[971416.599666926,13],[971416.748948196,9],[971416.897538936,11],[971417.052871872,8],[971417.239320294,15],[971417.425131425,16],[971417.634078749,27],[971417.872678534,4],[971418.023313521,8],[971418.211228391,25],[971418.396794444,18],[971418.547645232,13],[971418.732669374,55],[971418.881305393,11],[971419.071988622,10],[971419.260780188,11],[971419.407254193,15],[971419.557108545,17],[971419.706501919,14],[971419.915547166,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-9365539e08e6b48cc4c0061a1aa8d85a","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.033569244,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.489531769,"time_to_first_token":0.125176319,"token_sha":"8a91591c94a3","tokens_per_second":18.903547162845932},"seed":1234,"sent":971406.299457725,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12641784292645752,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.89993901530186,"done":971419.91791992,"finish_reason":"length","first":971406.425759723,"full_response_s":13.618868531892076,"last":971419.91786675,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971406.425759723,3],[971406.57792979,11],[971406.759600994,30],[971406.941562105,19],[971407.130967304,21],[971407.313752318,15],[971407.461723862,19],[971407.609730704,17],[971407.791789432,12],[971407.9735446,5],[971408.129240973,5],[971408.311887057,18],[971408.492488079,21],[971408.677025219,9],[971408.861107345,9],[971409.011764455,16],[971409.198624048,5],[971409.3801138,14],[971409.563636405,9],[971409.746358496,27],[971409.894221067,11],[971410.082002623,8],[971410.231126538,16],[971410.38046339,5],[971410.526865943,9],[971410.712954403,14],[971410.861888163,20],[971411.012778463,8],[971411.166517106,12],[971411.313752275,5],[971411.462595065,14],[971411.647117352,14],[971411.792958799,8],[971411.976541531,13],[971412.157064086,3],[971412.337782761,10],[971412.485113125,11],[971412.668093495,9],[971412.850899471,10],[971413.039182818,20],[971413.192016523,14],[971413.372020788,14],[971413.60062275,13],[971413.786247122,5],[971413.967024913,22],[971414.208236314,3],[971414.44619462,32],[971414.633166636,33],[971414.815968302,11],[971415.002271782,6],[971415.155019414,8],[971415.304753258,9],[971415.456790861,13],[971415.602727522,8],[971415.751663844,20],[971415.899411342,17],[971416.091258481,20],[971416.240374496,13],[971416.414890801,6],[971416.59866178,13],[971416.747980508,9],[971416.897618699,11],[971417.052597045,8],[971417.241131025,15],[971417.424200234,16],[971417.635075911,27],[971417.871165767,4],[971418.023867864,8],[971418.210564188,25],[971418.39861924,18],[971418.547151915,13],[971418.732112359,55],[971418.881451335,11],[971419.073199488,10],[971419.258958976,11],[971419.407737493,15],[971419.55698782,17],[971419.707737586,14],[971419.91786675,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-db8f7f3b3df751b58f6f83cc95e31291","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.033861624,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.492704973,"time_to_first_token":0.123865959,"token_sha":"8a91591c94a3","tokens_per_second":18.899101441132505},"seed":1234,"sent":971406.299051388,"speculative":{"acceptance_rate":0.4254807692307692,"accepted":177,"drafted":416,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.12670833489391953,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":416,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":1,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.904854017108978,"done":971419.91502596,"finish_reason":"length","first":971406.426364996,"full_response_s":13.61672881199047,"last":971419.914964261,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971406.426364996,3],[971406.576272312,11],[971406.761492642,30],[971406.943385974,19],[971407.131283445,21],[971407.314907215,15],[971407.461460187,19],[971407.609667918,17],[971407.792780946,12],[971407.974496288,5],[971408.127685323,5],[971408.312231151,27],[971408.491829859,12],[971408.676582465,13],[971408.862325124,5],[971409.01221497,16],[971409.197930547,5],[971409.378740942,14],[971409.561776134,9],[971409.745371671,27],[971409.893095499,11],[971410.083197217,8],[971410.232116259,16],[971410.380843326,5],[971410.527042894,9],[971410.711996987,14],[971410.860027845,20],[971411.012876979,8],[971411.165631212,12],[971411.314339004,5],[971411.463754298,14],[971411.645364046,14],[971411.79184864,8],[971411.977203463,13],[971412.159683492,3],[971412.33590641,10],[971412.484143101,11],[971412.66883423,9],[971412.850391049,10],[971413.04012681,20],[971413.191666924,14],[971413.371229555,14],[971413.601447584,13],[971413.785903443,5],[971413.967231194,22],[971414.208892854,3],[971414.445505615,32],[971414.63152956,33],[971414.815594126,11],[971415.001890822,6],[971415.15543916,8],[971415.306146276,9],[971415.454842012,13],[971415.602848807,8],[971415.750932773,20],[971415.898857943,17],[971416.090401725,20],[971416.238806271,13],[971416.414017117,6],[971416.598553439,13],[971416.748326938,9],[971416.896193552,11],[971417.052425294,8],[971417.240513015,15],[971417.42271886,16],[971417.635406484,27],[971417.870482411,4],[971418.025026568,8],[971418.210922843,25],[971418.397584221,18],[971418.547610366,13],[971418.731362552,55],[971418.880994612,11],[971419.073083867,10],[971419.259593947,11],[971419.406600757,15],[971419.557152035,17],[971419.705594874,14],[971419.914964261,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-0409f373ff68fd5abe74b6953f915fca","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.033715762,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.489337441,"time_to_first_token":0.124539699,"token_sha":"8a91591c94a3","tokens_per_second":18.903819488193943},"seed":1234,"sent":971406.298297148,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.128067848039791,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":0,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.874016553842033,"done":971433.578967287,"finish_reason":"length","first":971420.068307197,"full_response_s":13.643892145948485,"last":971433.578944918,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971420.068307197,3],[971420.221437707,11],[971420.405311794,30],[971420.589751631,19],[971420.770675308,21],[971420.954907815,15],[971421.108406987,19],[971421.255846324,17],[971421.440065981,12],[971421.620503369,5],[971421.768250656,5],[971421.951228348,27],[971422.140879784,12],[971422.325741007,13],[971422.509289632,5],[971422.658712962,16],[971422.83977633,5],[971423.027878315,14],[971423.215431845,9],[971423.3998171,27],[971423.548039699,11],[971423.730105658,8],[971423.878475042,16],[971424.030442793,5],[971424.182604648,9],[971424.367998797,14],[971424.514988887,20],[971424.666610192,8],[971424.814704967,12],[971424.963155588,5],[971425.12075884,14],[971425.300984989,14],[971425.451613011,8],[971425.63178423,13],[971425.803672372,3],[971425.988706963,10],[971426.144131428,11],[971426.325523725,9],[971426.508759537,10],[971426.693738909,20],[971426.842335748,14],[971427.029588625,14],[971427.262492474,13],[971427.447504475,5],[971427.6291761,22],[971427.861052815,3],[971428.105630566,32],[971428.290354944,33],[971428.474220582,11],[971428.657959752,6],[971428.806832345,8],[971428.958050752,9],[971429.113283899,13],[971429.261595244,8],[971429.410980473,20],[971429.560566173,17],[971429.741693432,20],[971429.889797964,13],[971430.073777631,6],[971430.2589737,13],[971430.405471234,9],[971430.557610181,11],[971430.708656299,8],[971430.891142029,15],[971431.083333683,16],[971431.295380208,27],[971431.531835613,4],[971431.681071504,8],[971431.86592268,25],[971432.059922875,18],[971432.209501698,13],[971432.394666975,55],[971432.54582519,11],[971432.732469071,10],[971432.916616731,11],[971433.072388468,15],[971433.222581691,17],[971433.372033588,14],[971433.578944918,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-6090bedf983eeb8d1321ec5f4ce1e699","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.036315743,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.510631705,"time_to_first_token":0.131223333,"token_sha":"8a91591c94a3","tokens_per_second":18.874024958109832},"seed":1234,"sent":971419.935075141,"speculative":{"acceptance_rate":0.4154929577464789,"accepted":177,"drafted":426,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.13323205593042076,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":426,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":1,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.871431865215154,"done":971433.58210335,"finish_reason":"length","first":971420.069522575,"full_response_s":13.645546610932797,"last":971433.582010754,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971420.069522575,3],[971420.221499966,11],[971420.403462245,30],[971420.590269477,19],[971420.770431105,21],[971420.954721519,15],[971421.106857899,19],[971421.255396578,17],[971421.440607299,12],[971421.620524202,5],[971421.769105843,5],[971421.951656813,27],[971422.141206006,12],[971422.325939223,13],[971422.509875688,5],[971422.659570133,16],[971422.84128476,5],[971423.027354405,14],[971423.216527394,9],[971423.399651493,27],[971423.548745152,11],[971423.730733188,8],[971423.880243675,16],[971424.031517686,5],[971424.184038707,9],[971424.366503488,14],[971424.514628921,20],[971424.663934962,8],[971424.814072174,12],[971424.961944898,5],[971425.120860765,14],[971425.302453306,14],[971425.450155383,8],[971425.63304153,13],[971425.805491759,3],[971425.988438456,10],[971426.146217753,11],[971426.326337582,9],[971426.511215238,10],[971426.694916366,20],[971426.842243121,14],[971427.028923366,14],[971427.264140333,13],[971427.447301219,5],[971427.628910265,22],[971427.861756188,3],[971428.106671424,32],[971428.289427642,33],[971428.474636183,11],[971428.659759201,6],[971428.806437193,8],[971428.958251673,9],[971429.11285777,13],[971429.262732266,8],[971429.410253499,20],[971429.559469281,17],[971429.744683602,20],[971429.890404836,13],[971430.073161366,6],[971430.259236655,13],[971430.406100747,9],[971430.557764795,11],[971430.708095876,8],[971430.891983503,15],[971431.082308105,16],[971431.295740014,27],[971431.53413177,4],[971431.682636224,8],[971431.867949354,25],[971432.058527826,18],[971432.211320076,13],[971432.392994139,55],[971432.544050302,11],[971432.731970698,10],[971432.918599979,11],[971433.071901632,15],[971433.222676415,17],[971433.37192768,14],[971433.582010754,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-5d0142b7eb232d14a662e78bba88e1db","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.036948488,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.513217281,"time_to_first_token":0.130901959,"token_sha":"8a91591c94a3","tokens_per_second":18.870413662225197},"seed":1234,"sent":971419.936556739,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.13296583597548306,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":2,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.87476045254593,"done":971433.579618337,"finish_reason":"length","first":971420.069476477,"full_response_s":13.643202419974841,"last":971433.579581712,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971420.069476477,3],[971420.220418193,11],[971420.404142609,30],[971420.589457699,19],[971420.771284789,21],[971420.953125694,15],[971421.107153671,19],[971421.255507014,17],[971421.438394088,12],[971421.620310033,5],[971421.767611045,5],[971421.951304575,27],[971422.140728722,12],[971422.324933102,13],[971422.508184387,5],[971422.658287648,16],[971422.839994947,5],[971423.02743452,14],[971423.220293453,9],[971423.398483157,27],[971423.547202736,11],[971423.729545587,8],[971423.879952223,16],[971424.030586687,5],[971424.182063682,9],[971424.365764225,14],[971424.514476642,20],[971424.664613454,8],[971424.812358071,12],[971424.961478879,5],[971425.118369878,14],[971425.300894858,14],[971425.452064886,8],[971425.632059121,13],[971425.804262781,3],[971425.987740235,10],[971426.143484089,11],[971426.325150654,9],[971426.508960042,10],[971426.694308421,20],[971426.841412815,14],[971427.028454195,14],[971427.262803447,13],[971427.446884402,5],[971427.628803077,22],[971427.861724747,3],[971428.106912778,32],[971428.289463403,33],[971428.473911786,11],[971428.659318079,6],[971428.806208767,8],[971428.955268895,9],[971429.111497427,13],[971429.261518073,8],[971429.411412922,20],[971429.558834951,17],[971429.741894049,20],[971429.891800333,13],[971430.071814703,6],[971430.256886799,13],[971430.406060506,9],[971430.557109776,11],[971430.706815472,8],[971430.892213513,15],[971431.081708305,16],[971431.295354591,27],[971431.532865543,4],[971431.683074946,8],[971431.867864551,25],[971432.05895578,18],[971432.210435832,13],[971432.393124944,55],[971432.544864431,11],[971432.731253901,10],[971432.916344784,11],[971433.071007516,15],[971433.22171644,17],[971433.370349488,14],[971433.579581712,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-f3a0fafa5d3c10b322e83d6336f3370c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.036698622,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.510624424,"time_to_first_token":0.130910104,"token_sha":"8a91591c94a3","tokens_per_second":18.874035129495805},"seed":1234,"sent":971419.936415917,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.13306055997963995,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":3,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.87300804105003,"done":971433.579933454,"finish_reason":"length","first":971420.068549783,"full_response_s":13.644082313054241,"last":971433.579909469,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971420.068549783,3],[971420.220290284,11],[971420.404966563,30],[971420.588141341,19],[971420.771697814,21],[971420.953779,15],[971421.10823802,19],[971421.255321839,17],[971421.438478363,12],[971421.62060715,5],[971421.767666679,5],[971421.952715769,27],[971422.14053873,12],[971422.325122198,13],[971422.50889456,5],[971422.659325515,16],[971422.841433935,5],[971423.02849114,14],[971423.218180022,9],[971423.400832566,27],[971423.547110572,11],[971423.730935709,8],[971423.879427402,16],[971424.031036418,5],[971424.182212856,9],[971424.367112073,14],[971424.515965984,20],[971424.666422552,8],[971424.813468869,12],[971424.962888793,5],[971425.118771479,14],[971425.300599886,14],[971425.449963584,8],[971425.634175848,13],[971425.805243877,3],[971425.988313107,10],[971426.144945637,11],[971426.326147734,9],[971426.508346,10],[971426.693960182,20],[971426.840857624,14],[971427.028745151,14],[971427.264383207,13],[971427.445596365,5],[971427.629840463,22],[971427.860307265,3],[971428.106159948,32],[971428.28928418,33],[971428.473596733,11],[971428.660095391,6],[971428.805935716,8],[971428.95710673,9],[971429.113167751,13],[971429.26123867,8],[971429.410635115,20],[971429.55847116,17],[971429.744879754,20],[971429.890870615,13],[971430.072023816,6],[971430.258257319,13],[971430.4065039,9],[971430.557544658,11],[971430.707214257,8],[971430.89092634,15],[971431.081853799,16],[971431.294429417,27],[971431.532040965,4],[971431.680785477,8],[971431.866477998,25],[971432.060313147,18],[971432.210507419,13],[971432.394578059,55],[971432.544214901,11],[971432.730417531,10],[971432.916183753,11],[971433.073054015,15],[971433.222449926,17],[971433.370812643,14],[971433.579909469,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-c5a3940d4729b49ec1d53bf89feba608","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.0364517,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.510535653,"time_to_first_token":0.131377371,"token_sha":"8a91591c94a3","tokens_per_second":18.874159141379234},"seed":1234,"sent":971419.935851141,"speculative":{"acceptance_rate":0.4194312796208531,"accepted":177,"drafted":422,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.13269864197354764,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":422,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":4,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.86981787961284,"done":971433.582867621,"finish_reason":"length","first":971420.069132463,"full_response_s":13.647573990980163,"last":971433.582776401,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971420.069132463,3],[971420.221685525,11],[971420.40584828,30],[971420.588358822,19],[971420.771556816,21],[971420.954257724,15],[971421.10833076,19],[971421.255924328,17],[971421.437599351,12],[971421.619820317,5],[971421.766905304,5],[971421.952401548,18],[971422.14344501,21],[971422.326719047,9],[971422.510210902,9],[971422.658919146,16],[971422.839688359,5],[971423.02814543,14],[971423.215524056,9],[971423.401082624,27],[971423.5478811,11],[971423.729091009,8],[971423.880636843,16],[971424.03069474,5],[971424.183428282,9],[971424.365831188,14],[971424.515392104,20],[971424.663745658,8],[971424.816022974,12],[971424.961600196,5],[971425.120924623,14],[971425.302152861,14],[971425.451042284,8],[971425.633906381,13],[971425.805684695,3],[971425.987545443,10],[971426.144586679,11],[971426.327034491,9],[971426.509700216,10],[971426.692780646,20],[971426.841178437,14],[971427.028345982,14],[971427.263227528,13],[971427.446951941,5],[971427.62957346,22],[971427.860573932,3],[971428.106712226,32],[971428.289371623,33],[971428.47524504,11],[971428.659156072,6],[971428.807320781,8],[971428.955103192,9],[971429.11309818,13],[971429.262458927,8],[971429.411239843,20],[971429.561583255,17],[971429.74289769,20],[971429.890562747,13],[971430.072081802,6],[971430.257110216,13],[971430.405584982,9],[971430.557456862,11],[971430.707584096,8],[971430.891469386,15],[971431.083829607,16],[971431.29553551,27],[971431.532916681,4],[971431.681782493,8],[971431.866152481,25],[971432.058790637,18],[971432.209384414,13],[971432.393255813,55],[971432.544967364,11],[971432.731298079,10],[971432.916933384,11],[971433.07095081,15],[971433.224071207,17],[971433.371288758,14],[971433.582776401,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-209bdc410ac72a689ef525778a0f1a07","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.037017947,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.513908302,"time_to_first_token":0.130927528,"token_sha":"8a91591c94a3","tokens_per_second":18.8694487413579},"seed":1234,"sent":971419.93529363,"speculative":{"acceptance_rate":0.4254807692307692,"accepted":177,"drafted":416,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.13383883296046406,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":416,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":5,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.87055060804617,"done":971433.582076501,"finish_reason":"length","first":971420.068857507,"full_response_s":13.646605678950436,"last":971433.581976721,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971420.068857507,3],[971420.220137301,11],[971420.403520599,30],[971420.58881484,19],[971420.771925951,21],[971420.95395656,15],[971421.108099182,19],[971421.255567321,17],[971421.439137847,12],[971421.620848936,5],[971421.767246278,5],[971421.951800323,27],[971422.142110667,12],[971422.326219731,13],[971422.508365018,5],[971422.660661042,16],[971422.840699664,5],[971423.027257393,14],[971423.216361755,9],[971423.400472167,27],[971423.54869691,11],[971423.7313195,8],[971423.879673316,16],[971424.03192415,5],[971424.183490733,9],[971424.366262022,14],[971424.516106917,20],[971424.664549691,8],[971424.816095953,12],[971424.962765076,5],[971425.119990585,14],[971425.301965301,14],[971425.448957094,8],[971425.634635931,13],[971425.804502583,3],[971425.987868273,10],[971426.144051009,11],[971426.325033369,9],[971426.509038589,10],[971426.692931164,20],[971426.842072778,14],[971427.029288341,14],[971427.263417008,13],[971427.447451833,5],[971427.629600389,22],[971427.862854505,3],[971428.107473777,32],[971428.289325878,33],[971428.475084585,11],[971428.660049453,6],[971428.806935981,8],[971428.955927194,9],[971429.111373709,13],[971429.261874631,8],[971429.41150011,20],[971429.559547348,17],[971429.741991205,20],[971429.891471504,13],[971430.073399728,6],[971430.259855992,13],[971430.405525364,9],[971430.55720946,11],[971430.708034706,8],[971430.891575295,15],[971431.08298066,16],[971431.295232154,27],[971431.532241869,4],[971431.682362613,8],[971431.867515497,25],[971432.059184525,18],[971432.210601279,13],[971432.396402949,55],[971432.545241583,11],[971432.731193979,10],[971432.917067421,11],[971433.071772219,15],[971433.224011813,17],[971433.370750032,14],[971433.581976721,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-fdb8ca0489a30740062eef10abdfa0d8","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.036912135,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.51323277,"time_to_first_token":0.130045428,"token_sha":"8a91591c94a3","tokens_per_second":18.87039203277189},"seed":1234,"sent":971419.935470822,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.13338668493088335,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":6,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.871855003005777,"done":971433.580946199,"finish_reason":"length","first":971420.068724798,"full_response_s":13.644873416051269,"last":971433.580910005,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971420.068724798,3],[971420.220611737,11],[971420.403214027,30],[971420.588013719,19],[971420.772008099,21],[971420.952910725,15],[971421.107777921,19],[971421.256204531,17],[971421.438204848,12],[971421.620885369,5],[971421.767550515,5],[971421.952268214,27],[971422.142205551,12],[971422.324351366,13],[971422.509709777,5],[971422.659284873,16],[971422.839166385,5],[971423.027567246,14],[971423.216788316,9],[971423.401182308,27],[971423.546319404,11],[971423.729482881,8],[971423.878300347,16],[971424.031391136,5],[971424.182974135,9],[971424.365196954,14],[971424.514299035,20],[971424.665612807,8],[971424.815592652,12],[971424.963035567,5],[971425.118647474,14],[971425.302781575,14],[971425.449721206,8],[971425.632159221,13],[971425.804459893,3],[971425.989472978,10],[971426.144229912,11],[971426.327181697,9],[971426.507796474,10],[971426.695208281,20],[971426.841326635,14],[971427.028666284,14],[971427.263308443,13],[971427.447552157,5],[971427.629112561,22],[971427.861523059,3],[971428.106450647,32],[971428.288841858,33],[971428.474135171,11],[971428.659077765,6],[971428.806125468,8],[971428.955378483,9],[971429.111686538,13],[971429.262154803,8],[971429.411456668,20],[971429.560897291,17],[971429.745235897,20],[971429.890653806,13],[971430.071881362,6],[971430.256658246,13],[971430.406318564,9],[971430.558068487,11],[971430.709244675,8],[971430.891820409,15],[971431.082487696,16],[971431.295293196,27],[971431.533529906,4],[971431.681828863,8],[971431.866406684,25],[971432.060603462,18],[971432.209613623,13],[971432.395209397,55],[971432.545425014,11],[971432.731840597,10],[971432.91729567,11],[971433.072187628,15],[971433.222959722,17],[971433.370638652,14],[971433.580910005,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-2197db1b52dadb9790dc9a0a23532386","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.036643435,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.510512836,"time_to_first_token":0.13082226,"token_sha":"8a91591c94a3","tokens_per_second":18.874191016682143},"seed":1234,"sent":971419.936072783,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.13265201507601887,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":7,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.871476848281198,"done":971433.580846179,"finish_reason":"length","first":971420.068354159,"full_response_s":13.645695339073427,"last":971433.580810129,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971420.068354159,3],[971420.220046194,11],[971420.406267785,30],[971420.587758941,19],[971420.77121901,21],[971420.954946025,15],[971421.108995395,19],[971421.25554004,17],[971421.440155585,12],[971421.620472408,5],[971421.768186045,5],[971421.951163529,27],[971422.141634791,12],[971422.32644142,13],[971422.51079851,5],[971422.658636639,16],[971422.84152933,5],[971423.028346894,14],[971423.215125016,9],[971423.40011516,27],[971423.548828547,11],[971423.729937236,8],[971423.88000933,16],[971424.03144245,5],[971424.183704693,9],[971424.36772125,14],[971424.515110556,20],[971424.66530465,8],[971424.813080149,12],[971424.962956876,5],[971425.119395281,14],[971425.302521036,14],[971425.450514086,8],[971425.634504806,13],[971425.805539937,3],[971425.988511979,10],[971426.145798152,11],[971426.326550391,9],[971426.509743642,10],[971426.694837082,20],[971426.842019847,14],[971427.028807617,14],[971427.264556158,13],[971427.446618807,5],[971427.629358923,22],[971427.862084458,3],[971428.106847784,32],[971428.288943526,33],[971428.47549337,11],[971428.659034884,6],[971428.806596239,8],[971428.956034494,9],[971429.111850993,13],[971429.261931258,8],[971429.4101774,20],[971429.559370301,17],[971429.742743187,20],[971429.891075296,13],[971430.074057355,6],[971430.258490193,13],[971430.405362845,9],[971430.557693432,11],[971430.707160046,8],[971430.892255386,15],[971431.082905873,16],[971431.294918637,27],[971431.533158099,4],[971431.681869953,8],[971431.868302729,25],[971432.060530115,18],[971432.209263161,13],[971432.394617005,55],[971432.545790533,11],[971432.731891607,10],[971432.916866213,11],[971433.07272829,15],[971433.222840278,17],[971433.372369874,14],[971433.580810129,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-75cb9656f245574d6594719078f2310c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.036397986,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.510569911,"time_to_first_token":0.130999131,"token_sha":"8a91591c94a3","tokens_per_second":18.87411128322461},"seed":1234,"sent":971419.93515084,"speculative":{"acceptance_rate":0.4164705882352941,"accepted":177,"drafted":425,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.13320331904105842,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":425,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":8,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.871107622594568,"done":971433.581360184,"finish_reason":"length","first":971420.068616841,"full_response_s":13.645338124013506,"last":971433.581337191,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971420.068616841,3],[971420.221118702,11],[971420.403117303,30],[971420.587918627,19],[971420.77049626,21],[971420.952215112,15],[971421.10925435,19],[971421.255462949,17],[971421.437744061,12],[971421.620373812,5],[971421.766782051,5],[971421.950351383,27],[971422.142537693,12],[971422.327133209,13],[971422.508614164,5],[971422.661031697,16],[971422.839402827,5],[971423.028421857,14],[971423.213910934,9],[971423.398096085,27],[971423.549076813,11],[971423.72922351,8],[971423.877798279,16],[971424.031602473,5],[971424.183905694,9],[971424.367622334,14],[971424.513777158,20],[971424.664476616,8],[971424.813139335,12],[971424.96182763,5],[971425.119189816,14],[971425.301854257,14],[971425.44850258,8],[971425.633318309,13],[971425.803878173,3],[971425.987191989,10],[971426.145339637,11],[971426.326206313,9],[971426.508507479,10],[971426.694970272,20],[971426.841496514,14],[971427.028989609,14],[971427.264426937,13],[971427.447149565,5],[971427.630203502,22],[971427.861928755,3],[971428.107100738,32],[971428.290480053,33],[971428.474486257,11],[971428.658453628,6],[971428.807178471,8],[971428.956665336,9],[971429.111945253,13],[971429.262536914,8],[971429.410479684,20],[971429.560125067,17],[971429.744177198,20],[971429.891885985,13],[971430.073836978,6],[971430.257651935,13],[971430.405649465,9],[971430.556685647,11],[971430.707249618,8],[971430.891649698,15],[971431.082859023,16],[971431.295794881,27],[971431.53215121,4],[971431.682293874,8],[971431.867444246,25],[971432.059102121,18],[971432.210656657,13],[971432.393374906,55],[971432.545532043,11],[971432.73086731,10],[971432.917461773,11],[971433.070881559,15],[971433.221993107,17],[971433.372729776,14],[971433.581337191,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-0cd2506c28d74a52f5bad84a2102b1e4","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.036597561,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.51064249,"time_to_first_token":0.130958778,"token_sha":"8a91591c94a3","tokens_per_second":18.874009891738314},"seed":1234,"sent":971419.93602206,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.13259478099644184,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":9,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.87116972314211,"done":971433.581636515,"finish_reason":"length","first":971420.068921206,"full_response_s":13.646239903988317,"last":971433.581597089,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971420.068921206,3],[971420.221314294,11],[971420.404727177,30],[971420.587573333,19],[971420.770602264,21],[971420.952618089,15],[971421.107491781,19],[971421.256258277,17],[971421.44174189,12],[971421.620909546,5],[971421.769352445,5],[971421.950225346,27],[971422.143124949,12],[971422.324844266,13],[971422.507813363,5],[971422.657552866,16],[971422.838646236,5],[971423.028080867,14],[971423.21420789,9],[971423.401011709,27],[971423.546682699,11],[971423.730403991,8],[971423.878623401,16],[971424.03205998,5],[971424.183350087,9],[971424.365690734,14],[971424.513348804,20],[971424.665403406,8],[971424.813728767,12],[971424.962681393,5],[971425.120090013,14],[971425.301362525,14],[971425.448765326,8],[971425.633433994,13],[971425.805619492,3],[971425.987108018,10],[971426.146496549,11],[971426.325361702,9],[971426.511586389,10],[971426.69463701,20],[971426.842708484,14],[971427.029336423,14],[971427.264229345,13],[971427.447240337,5],[971427.629884417,22],[971427.861830319,3],[971428.106370884,32],[971428.289057883,33],[971428.475703459,11],[971428.658631907,6],[971428.806768598,8],[971428.956104545,9],[971429.112153805,13],[971429.263763588,8],[971429.412297022,20],[971429.559028447,17],[971429.744578814,20],[971429.891526466,13],[971430.073640746,6],[971430.261289091,13],[971430.406614928,9],[971430.558239294,11],[971430.706863666,8],[971430.890448161,15],[971431.082600005,16],[971431.294289347,27],[971431.533778412,4],[971431.681903218,8],[971431.867120361,25],[971432.059691361,18],[971432.208648384,13],[971432.393495919,55],[971432.545886937,11],[971432.730290678,10],[971432.916823347,11],[971433.073230054,15],[971433.223049102,17],[971433.372551321,14],[971433.581597089,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-82856ecae204b2ea13aecb5887c03a79","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.036787761,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.511086908,"time_to_first_token":0.130752336,"token_sha":"8a91591c94a3","tokens_per_second":18.873389071978576},"seed":1234,"sent":971419.935396611,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1335245950613171,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":10,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.69569459927435,"done":971433.579379287,"finish_reason":"length","first":971419.939395848,"full_response_s":13.6441486509284,"last":971433.57889978,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971419.939395848,3],[971420.032676443,26],[971420.221629123,15],[971420.403944585,19],[971420.589930647,21],[971420.771151455,15],[971420.952872755,19],[971421.107739919,17],[971421.255685902,6],[971421.438758311,11],[971421.620929867,5],[971421.767744795,18],[971421.952670199,21],[971422.140669167,5],[971422.325650715,8],[971422.508459102,5],[971422.658144538,16],[971422.840876216,5],[971423.027961262,14],[971423.217819735,9],[971423.399973362,27],[971423.547561055,11],[971423.730471578,8],[971423.878845714,16],[971424.031993561,5],[971424.182436369,9],[971424.36591844,14],[971424.514153221,20],[971424.665354492,8],[971424.813307438,12],[971424.962180268,5],[971425.119255563,14],[971425.303445746,14],[971425.451831404,8],[971425.632516916,13],[971425.80332671,3],[971425.987278825,10],[971426.143312466,11],[971426.326442819,9],[971426.510630494,10],[971426.693396879,20],[971426.841708555,14],[971427.02851911,14],[971427.265988457,13],[971427.445883081,5],[971427.629650391,22],[971427.861967621,3],[971428.106579885,32],[971428.289532046,33],[971428.474387645,11],[971428.65987279,6],[971428.807137493,8],[971428.956456495,9],[971429.1116266,13],[971429.261410949,8],[971429.410780432,20],[971429.559991942,17],[971429.74221995,20],[971429.891195316,13],[971430.071558069,6],[971430.26047597,13],[971430.405876306,9],[971430.557263415,11],[971430.70710934,8],[971430.89082552,15],[971431.081995628,16],[971431.296054779,27],[971431.533071151,4],[971431.680891865,8],[971431.866814492,25],[971432.058640663,18],[971432.209023551,13],[971432.39606828,55],[971432.543541242,11],[971432.730185218,10],[971432.915716326,11],[971433.072625486,15],[971433.221591523,17],[971433.370562504,14],[971433.57889978,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-9166597d8f57eb724baf17b2aaa2806a","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.00231496,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.639478651,"time_to_first_token":0.00269568,"token_sha":"8a91591c94a3","tokens_per_second":18.695729252181078},"seed":1234,"sent":971419.935230636,"speculative":{"acceptance_rate":0.4018264840182648,"accepted":176,"drafted":438,"rounds":79,"tokens_per_round":3.240506329113924},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.004165211925283074,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":176,"drafted":438,"rounds":79},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":11,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.86900292495517,"done":971433.583761257,"finish_reason":"length","first":971420.069197249,"full_response_s":13.64744580804836,"last":971433.583424843,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971420.069197249,3],[971420.220670908,11],[971420.403389922,30],[971420.589561383,19],[971420.771593153,21],[971420.954653677,15],[971421.108181778,19],[971421.255624891,17],[971421.440449997,12],[971421.621213399,5],[971421.768516859,5],[971421.950624339,18],[971422.141575285,21],[971422.32586978,9],[971422.508715608,9],[971422.659092641,16],[971422.841213653,5],[971423.027639313,14],[971423.219865803,9],[971423.399375738,27],[971423.54813351,11],[971423.730160717,8],[971423.879206545,16],[971424.031187128,5],[971424.183199345,9],[971424.366409932,14],[971424.515057594,20],[971424.664089753,8],[971424.814350345,12],[971424.963232647,5],[971425.121018611,14],[971425.300777797,14],[971425.449662803,8],[971425.632971479,13],[971425.804886134,3],[971425.988254305,10],[971426.143676497,11],[971426.326014865,9],[971426.50927303,10],[971426.694534142,20],[971426.842409815,14],[971427.029867341,14],[971427.263148517,13],[971427.446185173,5],[971427.629530995,22],[971427.861177924,3],[971428.105990581,32],[971428.288722093,33],[971428.474687225,11],[971428.6604287,6],[971428.807777455,8],[971428.956897825,9],[971429.111901347,13],[971429.261957931,8],[971429.411757352,20],[971429.561299659,17],[971429.745053153,20],[971429.891714554,13],[971430.071706651,6],[971430.257471687,13],[971430.40655627,9],[971430.556360546,11],[971430.70651418,8],[971430.891855498,15],[971431.082116529,16],[971431.296101485,27],[971431.534489721,4],[971431.682398598,8],[971431.866568434,25],[971432.060025199,18],[971432.210190702,13],[971432.394470391,55],[971432.54571837,11],[971432.731083719,10],[971432.916728943,11],[971433.071470495,15],[971433.221849197,17],[971433.371370521,14],[971433.583424843,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-e0f23b719ee10f1e1d5f48367416e56c","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.037061069,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.514540743,"time_to_first_token":0.129793529,"token_sha":"8a91591c94a3","tokens_per_second":18.86856570631747},"seed":1234,"sent":971419.936315449,"speculative":{"acceptance_rate":0.4254807692307692,"accepted":177,"drafted":416,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1328818000620231,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":416,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":12,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.872360222685263,"done":971433.580615241,"finish_reason":"length","first":971420.068769024,"full_response_s":13.645028574974276,"last":971433.580592505,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971420.068769024,3],[971420.221555472,11],[971420.403299854,30],[971420.588735413,19],[971420.770180775,21],[971420.953911614,15],[971421.106980816,19],[971421.255162472,17],[971421.439347343,12],[971421.620981837,5],[971421.767155026,5],[971421.951738673,27],[971422.14319988,12],[971422.324236625,13],[971422.510498722,5],[971422.658456823,16],[971422.840613773,5],[971423.027484891,14],[971423.219344966,9],[971423.400660879,27],[971423.546540517,11],[971423.729380973,8],[971423.878136453,16],[971424.0316783,5],[971424.182336941,9],[971424.366644646,14],[971424.51369653,20],[971424.664918843,8],[971424.812458587,12],[971424.962241983,5],[971425.120455116,14],[971425.301464881,14],[971425.452287807,8],[971425.633678692,13],[971425.805182258,3],[971425.988793783,10],[971426.144357165,11],[971426.326956648,9],[971426.509650006,10],[971426.693053809,20],[971426.842664386,14],[971427.029115582,14],[971427.264321717,13],[971427.446424175,5],[971427.630129819,22],[971427.863250857,3],[971428.107767277,32],[971428.290093973,33],[971428.475053528,11],[971428.658299637,6],[971428.806523676,8],[971428.955536762,9],[971429.112194815,13],[971429.261813701,8],[971429.410716462,20],[971429.558916154,17],[971429.743595446,20],[971429.891340794,13],[971430.071953477,6],[971430.258110417,13],[971430.405923908,9],[971430.55813409,11],[971430.707383816,8],[971430.891715364,15],[971431.082774652,16],[971431.296186592,27],[971431.535224359,4],[971431.68164444,8],[971431.867257774,25],[971432.059730435,18],[971432.210058489,13],[971432.395843934,55],[971432.54432321,11],[971432.731496247,10],[971432.91828027,11],[971433.072878424,15],[971433.223639206,17],[971433.371821499,14],[971433.580592505,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-6c023da69e079c5050f3cce2fe6a530d","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.036532504,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.510651385,"time_to_first_token":0.131286327,"token_sha":"8a91591c94a3","tokens_per_second":18.873997465666974},"seed":1234,"sent":971419.935586666,"speculative":{"acceptance_rate":0.4194312796208531,"accepted":177,"drafted":422,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.1331823579967022,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":422,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":13,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.873041544030645,"done":971433.580767024,"finish_reason":"length","first":971420.069409642,"full_response_s":13.6440688559087,"last":971433.580745343,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971420.069409642,3],[971420.221033899,11],[971420.405161147,30],[971420.589063059,19],[971420.771025018,21],[971420.953839195,15],[971421.107212138,19],[971421.255977674,17],[971421.439669485,12],[971421.620157835,5],[971421.76745019,5],[971421.951896327,27],[971422.142932605,12],[971422.326858685,13],[971422.509255391,5],[971422.657914417,16],[971422.840256174,5],[971423.027703203,14],[971423.217569549,9],[971423.401374348,27],[971423.547460491,11],[971423.730304387,8],[971423.878545429,16],[971424.031307517,5],[971424.183773128,9],[971424.367795941,14],[971424.515662435,20],[971424.666110668,8],[971424.815131625,12],[971424.961334361,5],[971425.119632394,14],[971425.30319388,14],[971425.449202144,8],[971425.633382375,13],[971425.803438395,3],[971425.987651896,10],[971426.144889187,11],[971426.32593875,9],[971426.510089304,10],[971426.694267283,20],[971426.842291859,14],[971427.029173728,14],[971427.263082546,13],[971427.44605648,5],[971427.629404333,22],[971427.861385325,3],[971428.105884064,32],[971428.290184521,33],[971428.475658673,11],[971428.658820875,6],[971428.807544182,8],[971428.957543356,9],[971429.112441977,13],[971429.263083865,8],[971429.412558041,20],[971429.558659744,17],[971429.742961628,20],[971429.890278671,13],[971430.072644401,6],[971430.260865201,13],[971430.406242673,9],[971430.557173843,11],[971430.706326204,8],[971430.891041081,15],[971431.082542515,16],[971431.294680931,27],[971431.534862568,4],[971431.681572293,8],[971431.867025445,25],[971432.058865056,18],[971432.208865369,13],[971432.394765187,55],[971432.544586948,11],[971432.730532656,10],[971432.917027195,11],[971433.071514721,15],[971433.224126202,17],[971433.37246815,14],[971433.580745343,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-36dfcda0f52d462eeb817d06a65bb5d9","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.036840212,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.51101508,"time_to_first_token":0.130937721,"token_sha":"8a91591c94a3","tokens_per_second":18.873489407725536},"seed":1234,"sent":971419.936698168,"speculative":{"acceptance_rate":0.42142857142857143,"accepted":177,"drafted":420,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.13271147396881133,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":420,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":14,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.870721611915524,"done":971433.58239789,"finish_reason":"length","first":971420.069312902,"full_response_s":13.646239952067845,"last":971433.582309662,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971420.069312902,3],[971420.221740904,11],[971420.404578275,30],[971420.589138646,19],[971420.771827211,21],[971420.952491427,15],[971421.108550929,19],[971421.255778114,17],[971421.441311344,12],[971421.620256479,5],[971421.76898651,5],[971421.950123198,18],[971422.142302467,21],[971422.325205305,13],[971422.507938408,5],[971422.658216317,16],[971422.840185851,5],[971423.028264155,14],[971423.21716926,9],[971423.399032604,27],[971423.54735879,11],[971423.730974462,8],[971423.877711507,16],[971424.031741055,5],[971424.183287572,9],[971424.364777529,14],[971424.514715548,20],[971424.665897027,8],[971424.812892381,12],[971424.96237298,5],[971425.12027202,14],[971425.301911299,14],[971425.450048771,8],[971425.632236392,13],[971425.805021932,3],[971425.989244393,10],[971426.144186214,11],[971426.326730894,9],[971426.508113767,10],[971426.693535589,20],[971426.843240585,14],[971427.029522591,14],[971427.264965199,13],[971427.447358805,5],[971427.628560123,22],[971427.860743315,3],[971428.107161989,32],[971428.288427793,33],[971428.474591445,11],[971428.658728855,6],[971428.806888635,8],[971428.955634254,9],[971429.113354702,13],[971429.260854174,8],[971429.410331518,20],[971429.561049873,17],[971429.745578087,20],[971429.889928465,13],[971430.073092835,6],[971430.259554476,13],[971430.405993623,9],[971430.556455798,11],[971430.708909558,8],[971430.891775863,15],[971431.082204805,16],[971431.295029329,27],[971431.533721242,4],[971431.682247344,8],[971431.868227782,25],[971432.059030455,18],[971432.211652378,13],[971432.393912464,55],[971432.545323058,11],[971432.732520305,10],[971432.918170538,11],[971433.071114256,15],[971433.223200116,17],[971433.371513823,14],[971433.582309662,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-93ab646f9522d1b31fc9d8bf05a57915","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":3,"prefill_raised":[],"prefill_seconds":0.03698057,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.513496332,"time_to_first_token":0.1304401,"token_sha":"8a91591c94a3","tokens_per_second":18.870023991952344},"seed":1234,"sent":971419.936157938,"speculative":{"acceptance_rate":0.4224343675417661,"accepted":177,"drafted":419,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.13315496407449245,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":419,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} +{"schema":"pr608_exact_cache_public_request_v1","arm":"candidate","prompt":"chat","streams":16,"burst":2,"stream":15,"phase":"repeat","request":{"cache_state":"reused","cached_tokens":31,"case_id":null,"complete":true,"decode_tps":18.872277756038123,"done":971433.580313373,"finish_reason":"length","first":971420.068397312,"full_response_s":13.645313738961704,"last":971433.580279836,"output_sha256":"d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503","pieces":[[971420.068397312,3],[971420.220961048,11],[971420.404071822,30],[971420.590011802,19],[971420.771750472,21],[971420.9536805,15],[971421.108881358,19],[971421.255257628,17],[971421.440979251,12],[971421.620950748,5],[971421.767501585,5],[971421.950723879,27],[971422.141729595,12],[971422.325017393,13],[971422.509013077,5],[971422.659875666,16],[971422.8403056,5],[971423.027785559,14],[971423.218670138,9],[971423.401142963,27],[971423.547296052,11],[971423.73115567,8],[971423.879118045,16],[971424.030821081,5],[971424.184547976,9],[971424.367207853,14],[971424.514841281,20],[971424.664799542,8],[971424.815928586,12],[971424.962303809,5],[971425.11856331,14],[971425.301564117,14],[971425.44981729,8],[971425.632401119,13],[971425.804359601,3],[971425.988367381,10],[971426.14383596,11],[971426.327453852,9],[971426.509545154,10],[971426.694214577,20],[971426.843881428,14],[971427.029226627,14],[971427.265640459,13],[971427.447618112,5],[971427.629457728,22],[971427.861450464,3],[971428.106801702,32],[971428.289954767,33],[971428.475443144,11],[971428.660348601,6],[971428.807202728,8],[971428.956267672,9],[971429.112548573,13],[971429.263469401,8],[971429.410083124,20],[971429.559331259,17],[971429.742385893,20],[971429.890966891,13],[971430.072378566,6],[971430.260172309,13],[971430.405827552,9],[971430.55680354,11],[971430.707444298,8],[971430.89190062,15],[971431.083670608,16],[971431.295082292,27],[971431.532437653,4],[971431.682075513,8],[971431.867566651,25],[971432.059975981,18],[971432.209873602,13],[971432.395521569,55],[971432.545488153,11],[971432.730598019,10],[971432.915988801,11],[971433.07076669,15],[971433.223948435,17],[971433.371891422,14],[971433.580279836,21]],"prompt":"chat","prompt_tokens":31,"request_body":{"chat_template_kwargs":{"enable_thinking":false},"ignore_eos":true,"max_tokens":256,"messages":[{"content":"Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.","role":"user"}],"model":"qwen27-pr608","seed":1234,"stream":true,"stream_options":{"include_usage":true},"temperature":0.0},"request_body_sha256":"8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c","response_id":"chatcmpl-7a3b1273f8fe53f156060e3b463cccc3","runtime":{"drafts":true,"enable_thinking":false,"engine":"lanes","min_rows":4,"prefill_raised":[],"prefill_seconds":0.036266141,"prefill_widths":[],"reasoning_effort":"none","sampling":"greedy","seconds":13.510803216,"time_to_first_token":0.131230213,"token_sha":"8a91591c94a3","tokens_per_second":18.873785364442245},"seed":1234,"sent":971419.934999634,"speculative":{"acceptance_rate":0.41451990632318503,"accepted":177,"drafted":427,"rounds":78,"tokens_per_round":3.282051282051282},"token_sha":"8a91591c94a3","tokens":256,"ttft_s":0.13339767791330814,"usage":{"completion_tokens":256,"completion_tokens_details":{"reasoning_tokens":0},"prompt_tokens":31,"prompt_tokens_details":{"cached_tokens":31},"total_tokens":287},"work":{"accepted":177,"drafted":427,"rounds":78},"work_source":"speculative","request_path":"/v1/chat/completions"}} diff --git a/validation/pr608-exact-cache/run_http.py b/validation/pr608-exact-cache/run_http.py new file mode 100644 index 000000000..24ce22f05 --- /dev/null +++ b/validation/pr608-exact-cache/run_http.py @@ -0,0 +1,375 @@ +"""Preserve raw SSE evidence for the original PR608 greedy code/chat protocol.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import math +import os +from pathlib import Path +import re +import signal +import statistics +import sys +import time +from typing import Any + +import bench_concurrent as bench + + +SCHEMA = "pr608_exact_cache_http_v1" +PARAMETERS = { + "prompts": ["code", "chat"], + "levels": [1, 16], + "repetitions": 3, + "warmup_tokens": 16, + "measured_tokens": 256, + "temperature": 0.0, + "seed": 1234, +} +EXPECTED_PROMPTS = { + "code": ("completion", "Write a short Python function that computes the Fibonacci sequence and explain it.", 14), + "chat": ("chat", "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", 31), +} + + +def sha(path: Path) -> str: + """Hash the exact source bytes.""" + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def source_hashes() -> dict[str, str]: + """Bind the runner and its copied SSE/evidence helpers.""" + root = Path(__file__).resolve().parent + return {name: sha(root / name) for name in ("run_http.py", "bench_concurrent.py", "bench_evidence.py")} + + +def prompts() -> dict[str, dict[str, Any]]: + """Require the upstream prompt text, kind and order exactly.""" + items = bench.PROMPTS + if [item.get("name") for item in items] != PARAMETERS["prompts"]: + raise ValueError("original prompt order changed") + for item in items: + kind, text, _ = EXPECTED_PROMPTS[item["name"]] + if item.get("kind") != kind or item.get("prompt") != text: + raise ValueError("original prompt text or route changed") + return {item["name"]: item for item in items} + + +def write_report(path: Path, report: dict[str, Any]) -> None: + """Atomically preserve partial evidence after each burst.""" + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text(json.dumps(report, indent=2, sort_keys=True, allow_nan=False) + "\n") + temporary.replace(path) + + +def expected_body(model: str, item: dict[str, Any], tokens: int) -> tuple[str, dict[str, Any]]: + """Rebuild the unchanged upstream greedy request body and route.""" + body: dict[str, Any] = { + "model": model, + "max_tokens": tokens, + "temperature": 0.0, + "stream": True, + "stream_options": {"include_usage": True}, + "ignore_eos": True, + "seed": 1234, + } + if item["kind"] == "chat": + body["messages"] = [{"role": "user", "content": item["prompt"]}] + body["chat_template_kwargs"] = {"enable_thinking": False} + return "/v1/chat/completions", body + body["prompt"] = item["prompt"] + return "/v1/completions", body + + +def validate_request( + row: dict[str, Any], *, item: dict[str, Any], model: str, base: str, + tokens: int, cached: int, +) -> None: + """Require one complete SSE response with literal work, cache and clock evidence.""" + if row.get("error") or row.get("complete") is not True or row.get("unmeasured"): + raise ValueError("failed, incomplete or unmeasured SSE request") + if row.get("prompt") != item["name"] or row.get("seed") != 1234: + raise ValueError("prompt/seed drift") + suffix, body = expected_body(model, item, tokens) + if row.get("request_body") != body or row.get("request_url") != base + suffix: + raise ValueError("literal HTTP request drift") + if row.get("request_body_sha256") != hashlib.sha256(json.dumps(body).encode()).hexdigest(): + raise ValueError("HTTP body hash drift") + if row.get("finish_reason") != "length" or row.get("tokens") != tokens: + raise ValueError("response did not complete forced output length") + usage = row.get("usage") + _, _, prompt_tokens = EXPECTED_PROMPTS[item["name"]] + if not isinstance(usage, dict) or usage.get("prompt_tokens") != prompt_tokens: + raise ValueError("prompt token count drift") + if usage.get("completion_tokens") != tokens or row.get("prompt_tokens") != prompt_tokens: + raise ValueError("completion/prompt usage drift") + details = usage.get("prompt_tokens_details") + if not isinstance(details, dict) or details.get("cached_tokens") != cached: + raise ValueError("actual cached-token count differs from predeclared arm") + if row.get("cached_tokens") != cached or row.get("cache_state") != ("reused" if cached else "cold"): + raise ValueError("normalized cache state drift") + if not isinstance(row.get("response_id"), str) or not row["response_id"]: + raise ValueError("missing response identity") + if not isinstance(row.get("output_sha256"), str) or not re.fullmatch(r"[0-9a-f]{64}", row["output_sha256"]): + raise ValueError("missing text output hash") + if not isinstance(row.get("token_sha"), str) or not re.fullmatch(r"(?:[0-9a-f]{12}|[0-9a-f]{64})", row["token_sha"]): + raise ValueError("missing token fingerprint") + runtime = row.get("runtime") + if not isinstance(runtime, dict) or runtime.get("token_sha") != row["token_sha"]: + raise ValueError("runtime token fingerprint mismatch") + work = row.get("work") + raw_work = row.get("speculative") or runtime + origin = "speculative" if row.get("speculative") else "tensorfold" + if row.get("work_source") != origin or work != {key: raw_work.get(key) for key in ("rounds", "accepted", "drafted")}: + raise ValueError("speculative work/raw provenance mismatch") + if not isinstance(work, dict) or any(type(work.get(key)) is not int or work[key] < 0 + for key in ("rounds", "accepted", "drafted")): + raise ValueError("missing actual speculative work") + if work["rounds"] <= 0 or work["accepted"] > work["drafted"]: + raise ValueError("invalid speculative work") + clocks = [row.get(key) for key in ("sent", "first", "last", "done")] + if any(type(value) not in (int, float) or not math.isfinite(value) for value in clocks): + raise ValueError("missing SSE or DONE timestamp") + sent, first, last, done = clocks + if not sent < first < last <= done: + raise ValueError("nonmonotonic SSE timestamps") + for key, actual in (("ttft_s", first - sent), ("full_response_s", done - sent), + ("decode_tps", (tokens - 1) / (last - first))): + value = row.get(key) + if type(value) not in (int, float) or not math.isclose(value, actual, rel_tol=1e-12): + raise ValueError("SSE timing arithmetic mismatch") + pieces = row.get("pieces") + if not isinstance(pieces, list) or len(pieces) < bench.MIN_PIECES or pieces[0][0] != first or pieces[-1][0] != last: + raise ValueError("missing nonempty SSE pieces") + previous = sent + for arrived, characters in pieces: + if type(arrived) not in (int, float) or not previous <= arrived <= done: + raise ValueError("invalid SSE piece arrival") + if type(characters) is not int or characters <= 0: + raise ValueError("empty or invalid SSE piece") + previous = arrived + + +def validate_report(report: dict[str, Any]) -> dict[str, int]: + """Validate all two warmups and 102 original-protocol measured requests.""" + if report.get("schema") != SCHEMA or report.get("complete") is not True: + raise ValueError("incomplete cache comparison arm") + if report.get("parameters") != PARAMETERS or report.get("source_sha256") != source_hashes(): + raise ValueError("parameters or source changed") + label = report.get("label") + if label not in ("off", "on", "python"): + raise ValueError("expected cache-off, cache-on or Python label") + items = prompts() + cells = report.get("cells", []) + if [cell.get("prompt") for cell in cells] != PARAMETERS["prompts"]: + raise ValueError("missing prompt cell") + ids: set[str] = set() + requests = 0 + total_prompt = 0 + total_output = 0 + for cell in cells: + item = items[cell["prompt"]] + prompt_n = EXPECTED_PROMPTS[item["name"]][2] + expected_cached = 0 if label == "off" else prompt_n - 1 if label == "python" else prompt_n + warmup = cell.get("warmup") + if not isinstance(warmup, dict): + raise ValueError("missing original 16-token warmup") + validate_request(warmup, item=item, model=report["model"], base=report["base"], tokens=16, cached=0) + ids.add(warmup["response_id"]) + requests += 1 + total_prompt += warmup["prompt_tokens"] + total_output += 16 + levels = cell.get("levels", []) + if [level.get("streams") for level in levels] != [1, 16]: + raise ValueError("original n1/n16 order changed") + for level in levels: + bursts = level.get("bursts", []) + if len(bursts) != 3: + raise ValueError("missing measured repetition") + for index, burst in enumerate(bursts): + if (burst.get("index") != index + or burst.get("phase") != ("first_measured" if index == 0 else "repeat")): + raise ValueError("repetition order changed") + rows = burst.get("requests", []) + if len(rows) != level["streams"]: + raise ValueError("missing simultaneous request") + for row in rows: + validate_request(row, item=item, model=report["model"], base=report["base"], + tokens=256, cached=expected_cached) + ids.add(row["response_id"]) + requests += 1 + total_prompt += row["prompt_tokens"] + total_output += 256 + if requests != 104 or len(ids) != 104 or total_output != 26144: + raise ValueError("request identity/count drift") + return {"requests": requests, "prompt_tokens": total_prompt, "output_tokens": total_output} + + +def compare_reports(off: dict[str, Any], on: dict[str, Any]) -> dict[str, Any]: + """Require literal matched requests and outputs while retaining work differences.""" + validate_report(off) + validate_report(on) + if (off["label"], on["label"]) != ("off", "on") or (off["model"], off["base"]) != (on["model"], on["base"]): + raise ValueError("arm identity mismatch") + observations = [] + work_differences = 0 + for left_cell, right_cell in zip(off["cells"], on["cells"]): + left_rows = [left_cell["warmup"]] + right_rows = [right_cell["warmup"]] + for left_level, right_level in zip(left_cell["levels"], right_cell["levels"]): + for left_burst, right_burst in zip(left_level["bursts"], right_level["bursts"]): + left_rows.extend(left_burst["requests"]) + right_rows.extend(right_burst["requests"]) + for left, right in zip(left_rows, right_rows): + if left["request_body"] != right["request_body"] or left["request_body_sha256"] != right["request_body_sha256"]: + raise ValueError("cross-arm HTTP body mismatch") + if left["output_sha256"] != right["output_sha256"] or left["token_sha"] != right["token_sha"]: + raise ValueError("cross-arm output mismatch") + work_differences += left["work"] != right["work"] + for left_level, right_level in zip(left_cell["levels"], right_cell["levels"]): + for left_burst, right_burst in zip(left_level["bursts"], right_level["bursts"]): + n = left_level["streams"] + left_t = [row["ttft_s"] for row in left_burst["requests"]] + right_t = [row["ttft_s"] for row in right_burst["requests"]] + observations.append({ + "prompt": left_cell["prompt"], "streams": n, "repetition": left_burst["index"], + "off_first_enqueued_ttft_s": min(left_burst["requests"], key=lambda row: row["sent"])["ttft_s"], + "on_first_enqueued_ttft_s": min(right_burst["requests"], key=lambda row: row["sent"])["ttft_s"], + "off_median_ttft_s": statistics.median(left_t), + "on_median_ttft_s": statistics.median(right_t), + "off_slowest_ttft_s": max(left_t), "on_slowest_ttft_s": max(right_t), + "off_batch_wall_s": max(row["done"] for row in left_burst["requests"]) - min(row["sent"] for row in left_burst["requests"]), + "on_batch_wall_s": max(row["done"] for row in right_burst["requests"]) - min(row["sent"] for row in right_burst["requests"]), + }) + return { + "schema": "pr608_exact_cache_http_comparison_v1", + "complete": True, + "matched_requests": 104, + "measured_requests": 102, + "unequal_speculative_work_requests": work_differences, + "observations": observations, + } + + +def compare_python(native: dict[str, Any], python: dict[str, Any]) -> dict[str, Any]: + """Retain Python-vs-native output/work differences without implying parity.""" + validate_report(native) + validate_report(python) + if native["label"] not in ("off", "on") or python["label"] != "python": + raise ValueError("wrong comparison arms") + observations = [] + unequal_outputs = 0 + unequal_tokens = 0 + unequal_work = 0 + for left_cell, right_cell in zip(native["cells"], python["cells"]): + for left_level, right_level in zip(left_cell["levels"], right_cell["levels"]): + for left_burst, right_burst in zip(left_level["bursts"], right_level["bursts"]): + for left, right in zip(left_burst["requests"], right_burst["requests"]): + left_body = {key: value for key, value in left["request_body"].items() if key != "model"} + right_body = {key: value for key, value in right["request_body"].items() if key != "model"} + if left_body != right_body: + raise ValueError("Python-vs-native request body drift") + unequal_outputs += left["output_sha256"] != right["output_sha256"] + unequal_tokens += left["token_sha"] != right["token_sha"] + unequal_work += left["work"] != right["work"] + left_t = [row["ttft_s"] for row in left_burst["requests"]] + right_t = [row["ttft_s"] for row in right_burst["requests"]] + observations.append({ + "prompt": left_cell["prompt"], "streams": left_level["streams"], + "repetition": left_burst["index"], + "native_first_enqueued_ttft_s": min(left_burst["requests"], key=lambda row: row["sent"])["ttft_s"], + "python_first_enqueued_ttft_s": min(right_burst["requests"], key=lambda row: row["sent"])["ttft_s"], + "native_median_ttft_s": statistics.median(left_t), + "python_median_ttft_s": statistics.median(right_t), + "native_slowest_ttft_s": max(left_t), "python_slowest_ttft_s": max(right_t), + "native_batch_wall_s": max(row["done"] for row in left_burst["requests"]) + - min(row["sent"] for row in left_burst["requests"]), + "python_batch_wall_s": max(row["done"] for row in right_burst["requests"]) + - min(row["sent"] for row in right_burst["requests"]), + }) + return { + "schema": "pr608_exact_cache_python_comparison_v1", "complete": True, + "native_label": native["label"], "matched_request_shapes": 102, + "unequal_output_hashes": unequal_outputs, "unequal_token_hashes": unequal_tokens, + "unequal_speculative_work": unequal_work, "observations": observations, + } + + +def run(args: argparse.Namespace) -> dict[str, Any]: + """Run the unchanged prompt/seed/arrival panel with richer SSE retention.""" + items = prompts() + base = args.base.rstrip("/") + report: dict[str, Any] = { + "schema": SCHEMA, "complete": False, "label": args.label, "model": args.model, + "base": base, "parameters": PARAMETERS, "source_sha256": source_hashes(), "cells": [], + } + write_report(args.output, report) + deadline = time.monotonic() + args.max_seconds + for name in PARAMETERS["prompts"]: + item = items[name] + cell: dict[str, Any] = {"prompt": name, "warmup": None, "levels": []} + report["cells"].append(cell) + if deadline - time.monotonic() <= 0: + raise TimeoutError("client deadline exceeded") + bench.REQUEST_TIMEOUT = min(1800, deadline - time.monotonic()) + cell["warmup"] = bench.together(base, args.model, [(item, 1234)], 16, 0.0)[0] + validate_request(cell["warmup"], item=item, model=args.model, base=base, tokens=16, cached=0) + write_report(args.output, report) + for streams in PARAMETERS["levels"]: + level: dict[str, Any] = {"streams": streams, "bursts": []} + cell["levels"].append(level) + for index in range(3): + if deadline - time.monotonic() <= 0: + raise TimeoutError("client deadline exceeded") + bench.REQUEST_TIMEOUT = min(1800, deadline - time.monotonic()) + rows = bench.together(base, args.model, [(item, 1234)] * streams, 256, 0.0) + burst = {"index": index, "phase": "first_measured" if index == 0 else "repeat", + "requests": rows, "aggregate": bench.aggregates(rows)} + level["bursts"].append(burst) + write_report(args.output, report) + prompt_n = EXPECTED_PROMPTS[name][2] + expected_cached = 0 if args.label == "off" else prompt_n - 1 if args.label == "python" else prompt_n + for row in rows: + validate_request(row, item=item, model=args.model, base=base, tokens=256, cached=expected_cached) + print(json.dumps({"label": args.label, "prompt": name, "streams": streams, + "repetition": index, "median_ttft_s": statistics.median(row["ttft_s"] for row in rows), + "slowest_ttft_s": max(row["ttft_s"] for row in rows)}), flush=True) + report["complete"] = True + report["health_totals"] = validate_report(report) + write_report(args.output, report) + return report + + +def main() -> None: + """Run one isolated cache arm with an explicit output and bounded deadline.""" + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--base", required=True) + parser.add_argument("--model", required=True) + parser.add_argument("--label", choices=("off", "on", "python"), required=True) + parser.add_argument("--output", type=Path, required=True) + parser.add_argument("--max-seconds", type=int, default=1200) + args = parser.parse_args() + if args.max_seconds <= 0: + parser.error("max-seconds must be positive") + + def expired(signum: int, frame: Any) -> None: + """Retain the partial report when the whole client window expires.""" + print("cache panel deadline exceeded; partial report retained", file=sys.stderr, flush=True) + os._exit(1) + + signal.signal(signal.SIGALRM, expired) + signal.alarm(args.max_seconds) + try: + run(args) + except Exception as exc: + print(f"{type(exc).__name__}: {exc}; partial report retained", file=sys.stderr) + raise SystemExit(1) from exc + finally: + signal.alarm(0) + + +if __name__ == "__main__": + main() diff --git a/validation/pr608-exact-cache/summary.json b/validation/pr608-exact-cache/summary.json new file mode 100644 index 000000000..f72c3980c --- /dev/null +++ b/validation/pr608-exact-cache/summary.json @@ -0,0 +1,979 @@ +{ + "schema": "pr608_exact_cache_public_summary_v1", + "complete": true, + "requests": 624, + "orders": { + "forward": { + "work_differences": { + "reset_off_candidate": 83, + "candidate_python_measured": 102, + "candidate_python_warmup": 1 + }, + "paired_reset_requests": 104, + "paired_python_measured_requests": 102, + "paired_python_warmup_requests": 2, + "paired_python_all_requests": 104, + "cells": { + "code_1": { + "reset_off": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.009321228018961847, + "slowest_ttft_s": 0.009321228018961847, + "batch_wall_s": 3.6764963960740715 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.005874473019503057, + "slowest_ttft_s": 0.005874473019503057, + "batch_wall_s": 3.659726492012851 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.004225832992233336, + "slowest_ttft_s": 0.004225832992233336, + "batch_wall_s": 3.6714752269908786 + } + ], + "first_median_ttft_s": 0.009321228018961847, + "first_slowest_ttft_s": 0.009321228018961847, + "first_batch_wall_s": 3.6764963960740715, + "max_three_slowest_ttft_s": 0.009321228018961847, + "warm_median_ttft_mean_s": 0.0050501530058681965, + "warm_slowest_ttft_mean_s": 0.0050501530058681965, + "warm_batch_wall_mean_s": 3.6656008595018648 + }, + "python": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.11166255408897996, + "slowest_ttft_s": 0.11166255408897996, + "batch_wall_s": 3.8725799859967083 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.11023893195670098, + "slowest_ttft_s": 0.11023893195670098, + "batch_wall_s": 3.867910148925148 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.11173029500059783, + "slowest_ttft_s": 0.11173029500059783, + "batch_wall_s": 3.8701736440416425 + } + ], + "first_median_ttft_s": 0.11166255408897996, + "first_slowest_ttft_s": 0.11166255408897996, + "first_batch_wall_s": 3.8725799859967083, + "max_three_slowest_ttft_s": 0.11173029500059783, + "warm_median_ttft_mean_s": 0.11098461347864941, + "warm_slowest_ttft_mean_s": 0.11098461347864941, + "warm_batch_wall_mean_s": 3.8690418964833952 + }, + "candidate": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.010005485964938998, + "slowest_ttft_s": 0.010005485964938998, + "batch_wall_s": 3.696219493052922 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.0029411360155791044, + "slowest_ttft_s": 0.0029411360155791044, + "batch_wall_s": 3.6782805050024763 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.002947150031104684, + "slowest_ttft_s": 0.002947150031104684, + "batch_wall_s": 3.687343891011551 + } + ], + "first_median_ttft_s": 0.010005485964938998, + "first_slowest_ttft_s": 0.010005485964938998, + "first_batch_wall_s": 3.696219493052922, + "max_three_slowest_ttft_s": 0.010005485964938998, + "warm_median_ttft_mean_s": 0.002944143023341894, + "warm_slowest_ttft_mean_s": 0.002944143023341894, + "warm_batch_wall_mean_s": 3.6828121980070136 + } + }, + "code_16": { + "reset_off": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.2451334890211001, + "slowest_ttft_s": 0.24770028400234878, + "batch_wall_s": 10.212774708983488 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.14415301545523107, + "slowest_ttft_s": 0.14556601096410304, + "batch_wall_s": 10.186080714920536 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.15262236102716997, + "slowest_ttft_s": 0.15440529200714082, + "batch_wall_s": 10.207751470967196 + } + ], + "first_median_ttft_s": 0.2451334890211001, + "first_slowest_ttft_s": 0.24770028400234878, + "first_batch_wall_s": 10.212774708983488, + "max_three_slowest_ttft_s": 0.24770028400234878, + "warm_median_ttft_mean_s": 0.14838768824120052, + "warm_slowest_ttft_mean_s": 0.14998565148562193, + "warm_batch_wall_mean_s": 10.196916092943866 + }, + "python": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.2954800195293501, + "slowest_ttft_s": 0.29729365196544677, + "batch_wall_s": 10.765969026018865 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.22982863598736003, + "slowest_ttft_s": 0.23162581108044833, + "batch_wall_s": 10.618905690964311 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.21611324197147042, + "slowest_ttft_s": 0.2179524260573089, + "batch_wall_s": 10.6848637140356 + } + ], + "first_median_ttft_s": 0.2954800195293501, + "first_slowest_ttft_s": 0.29729365196544677, + "first_batch_wall_s": 10.765969026018865, + "max_three_slowest_ttft_s": 0.29729365196544677, + "warm_median_ttft_mean_s": 0.22297093897941522, + "warm_slowest_ttft_mean_s": 0.22478911856887862, + "warm_batch_wall_mean_s": 10.651884702499956 + }, + "candidate": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.25291037443093956, + "slowest_ttft_s": 0.25382986303884536, + "batch_wall_s": 10.261773435981013 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.12858893355587497, + "slowest_ttft_s": 0.12985809100791812, + "batch_wall_s": 10.201076281024143 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.1302716710488312, + "slowest_ttft_s": 0.13197649898938835, + "batch_wall_s": 10.218946428969502 + } + ], + "first_median_ttft_s": 0.25291037443093956, + "first_slowest_ttft_s": 0.25382986303884536, + "first_batch_wall_s": 10.261773435981013, + "max_three_slowest_ttft_s": 0.25382986303884536, + "warm_median_ttft_mean_s": 0.12943030230235308, + "warm_slowest_ttft_mean_s": 0.13091729499865323, + "warm_batch_wall_mean_s": 10.210011354996823 + } + }, + "chat_1": { + "reset_off": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.012453451985493302, + "slowest_ttft_s": 0.012453451985493302, + "batch_wall_s": 5.1614946679910645 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.004140900913625956, + "slowest_ttft_s": 0.004140900913625956, + "batch_wall_s": 5.154151172959246 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.004495476023294032, + "slowest_ttft_s": 0.004495476023294032, + "batch_wall_s": 5.168879957054742 + } + ], + "first_median_ttft_s": 0.012453451985493302, + "first_slowest_ttft_s": 0.012453451985493302, + "first_batch_wall_s": 5.1614946679910645, + "max_three_slowest_ttft_s": 0.012453451985493302, + "warm_median_ttft_mean_s": 0.004318188468459994, + "warm_slowest_ttft_mean_s": 0.004318188468459994, + "warm_batch_wall_mean_s": 5.161515565006994 + }, + "python": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.11438823607750237, + "slowest_ttft_s": 0.11438823607750237, + "batch_wall_s": 5.185942225041799 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.12041176704224199, + "slowest_ttft_s": 0.12041176704224199, + "batch_wall_s": 5.212914303061552 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.11210278002545238, + "slowest_ttft_s": 0.11210278002545238, + "batch_wall_s": 5.187262702966109 + } + ], + "first_median_ttft_s": 0.11438823607750237, + "first_slowest_ttft_s": 0.11438823607750237, + "first_batch_wall_s": 5.185942225041799, + "max_three_slowest_ttft_s": 0.12041176704224199, + "warm_median_ttft_mean_s": 0.11625727353384718, + "warm_slowest_ttft_mean_s": 0.11625727353384718, + "warm_batch_wall_mean_s": 5.200088503013831 + }, + "candidate": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.008828009013086557, + "slowest_ttft_s": 0.008828009013086557, + "batch_wall_s": 5.169722569989972 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.0030991400126367807, + "slowest_ttft_s": 0.0030991400126367807, + "batch_wall_s": 5.164069456979632 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.004090688889846206, + "slowest_ttft_s": 0.004090688889846206, + "batch_wall_s": 5.175776579999365 + } + ], + "first_median_ttft_s": 0.008828009013086557, + "first_slowest_ttft_s": 0.008828009013086557, + "first_batch_wall_s": 5.169722569989972, + "max_three_slowest_ttft_s": 0.008828009013086557, + "warm_median_ttft_mean_s": 0.0035949144512414932, + "warm_slowest_ttft_mean_s": 0.0035949144512414932, + "warm_batch_wall_mean_s": 5.169923018489499 + } + }, + "chat_16": { + "reset_off": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.21584608999546617, + "slowest_ttft_s": 0.21819562802556902, + "batch_wall_s": 13.921975207980722 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.14473702647956088, + "slowest_ttft_s": 0.14621789706870914, + "batch_wall_s": 13.910518317949027 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.1546261394978501, + "slowest_ttft_s": 0.15614218497648835, + "batch_wall_s": 13.931163160013966 + } + ], + "first_median_ttft_s": 0.21584608999546617, + "first_slowest_ttft_s": 0.21819562802556902, + "first_batch_wall_s": 13.921975207980722, + "max_three_slowest_ttft_s": 0.21819562802556902, + "warm_median_ttft_mean_s": 0.14968158298870549, + "warm_slowest_ttft_mean_s": 0.15118004102259874, + "warm_batch_wall_mean_s": 13.920840738981497 + }, + "python": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.21682401897851378, + "slowest_ttft_s": 0.2195631458889693, + "batch_wall_s": 13.604332659975626 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.23789381800452247, + "slowest_ttft_s": 0.2412851060507819, + "batch_wall_s": 13.679095904924907 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.2211218905285932, + "slowest_ttft_s": 0.22319121600594372, + "batch_wall_s": 13.681349086924456 + } + ], + "first_median_ttft_s": 0.21682401897851378, + "first_slowest_ttft_s": 0.2195631458889693, + "first_batch_wall_s": 13.604332659975626, + "max_three_slowest_ttft_s": 0.2412851060507819, + "warm_median_ttft_mean_s": 0.22950785426655784, + "warm_slowest_ttft_mean_s": 0.2322381610283628, + "warm_batch_wall_mean_s": 13.680222495924681 + }, + "candidate": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.19794812449254096, + "slowest_ttft_s": 0.20031619595829397, + "batch_wall_s": 13.94929225195665 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.12661196902627125, + "slowest_ttft_s": 0.1281804849859327, + "batch_wall_s": 13.890317952027544 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.13621724146651104, + "slowest_ttft_s": 0.1378961899317801, + "batch_wall_s": 14.0290369320428 + } + ], + "first_median_ttft_s": 0.19794812449254096, + "first_slowest_ttft_s": 0.20031619595829397, + "first_batch_wall_s": 13.94929225195665, + "max_three_slowest_ttft_s": 0.20031619595829397, + "warm_median_ttft_mean_s": 0.13141460524639115, + "warm_slowest_ttft_mean_s": 0.1330383374588564, + "warm_batch_wall_mean_s": 13.959677442035172 + } + } + } + }, + "reverse": { + "work_differences": { + "reset_off_candidate": 93, + "candidate_python_measured": 102, + "candidate_python_warmup": 1 + }, + "paired_reset_requests": 104, + "paired_python_measured_requests": 102, + "paired_python_warmup_requests": 2, + "paired_python_all_requests": 104, + "cells": { + "code_1": { + "reset_off": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.011366614024154842, + "slowest_ttft_s": 0.011366614024154842, + "batch_wall_s": 3.685287144035101 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.004430609056726098, + "slowest_ttft_s": 0.004430609056726098, + "batch_wall_s": 3.688612314988859 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.004058724036440253, + "slowest_ttft_s": 0.004058724036440253, + "batch_wall_s": 3.688717187033035 + } + ], + "first_median_ttft_s": 0.011366614024154842, + "first_slowest_ttft_s": 0.011366614024154842, + "first_batch_wall_s": 3.685287144035101, + "max_three_slowest_ttft_s": 0.011366614024154842, + "warm_median_ttft_mean_s": 0.004244666546583176, + "warm_slowest_ttft_mean_s": 0.004244666546583176, + "warm_batch_wall_mean_s": 3.688664751010947 + }, + "python": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.11038088402710855, + "slowest_ttft_s": 0.11038088402710855, + "batch_wall_s": 3.8663069700123742 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.11243165796622634, + "slowest_ttft_s": 0.11243165796622634, + "batch_wall_s": 3.857510322937742 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.12050325295422226, + "slowest_ttft_s": 0.12050325295422226, + "batch_wall_s": 3.8645585019839928 + } + ], + "first_median_ttft_s": 0.11038088402710855, + "first_slowest_ttft_s": 0.11038088402710855, + "first_batch_wall_s": 3.8663069700123742, + "max_three_slowest_ttft_s": 0.12050325295422226, + "warm_median_ttft_mean_s": 0.1164674554602243, + "warm_slowest_ttft_mean_s": 0.1164674554602243, + "warm_batch_wall_mean_s": 3.8610344124608673 + }, + "candidate": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.009282023995183408, + "slowest_ttft_s": 0.009282023995183408, + "batch_wall_s": 3.6699776059249416 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.00325908197555691, + "slowest_ttft_s": 0.00325908197555691, + "batch_wall_s": 3.6726459950441495 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.0033654540311545134, + "slowest_ttft_s": 0.0033654540311545134, + "batch_wall_s": 3.675162165076472 + } + ], + "first_median_ttft_s": 0.009282023995183408, + "first_slowest_ttft_s": 0.009282023995183408, + "first_batch_wall_s": 3.6699776059249416, + "max_three_slowest_ttft_s": 0.009282023995183408, + "warm_median_ttft_mean_s": 0.0033122680033557117, + "warm_slowest_ttft_mean_s": 0.0033122680033557117, + "warm_batch_wall_mean_s": 3.6739040800603107 + } + }, + "code_16": { + "reset_off": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.2519208589801565, + "slowest_ttft_s": 0.25373164599295706, + "batch_wall_s": 10.246137654059567 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.14397549297427759, + "slowest_ttft_s": 0.14509940904099494, + "batch_wall_s": 10.22510295000393 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.15284264500951394, + "slowest_ttft_s": 0.15478629793506116, + "batch_wall_s": 10.308045050012879 + } + ], + "first_median_ttft_s": 0.2519208589801565, + "first_slowest_ttft_s": 0.25373164599295706, + "first_batch_wall_s": 10.246137654059567, + "max_three_slowest_ttft_s": 0.25373164599295706, + "warm_median_ttft_mean_s": 0.14840906899189577, + "warm_slowest_ttft_mean_s": 0.14994285348802805, + "warm_batch_wall_mean_s": 10.266574000008404 + }, + "python": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.30973247450310737, + "slowest_ttft_s": 0.3115335199981928, + "batch_wall_s": 10.356753214029595 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.21972485701553524, + "slowest_ttft_s": 0.2222381919855252, + "batch_wall_s": 10.257494757999666 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.21570463752141222, + "slowest_ttft_s": 0.21737337205559015, + "batch_wall_s": 10.312033434980549 + } + ], + "first_median_ttft_s": 0.30973247450310737, + "first_slowest_ttft_s": 0.3115335199981928, + "first_batch_wall_s": 10.356753214029595, + "max_three_slowest_ttft_s": 0.3115335199981928, + "warm_median_ttft_mean_s": 0.21771474726847373, + "warm_slowest_ttft_mean_s": 0.21980578202055767, + "warm_batch_wall_mean_s": 10.284764096490107 + }, + "candidate": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.23705968802096322, + "slowest_ttft_s": 0.23913420794997364, + "batch_wall_s": 10.13896927901078 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.12570065597537905, + "slowest_ttft_s": 0.12786105903796852, + "batch_wall_s": 10.138073801063001 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.12969556800089777, + "slowest_ttft_s": 0.1310847100103274, + "batch_wall_s": 10.170627554995008 + } + ], + "first_median_ttft_s": 0.23705968802096322, + "first_slowest_ttft_s": 0.23913420794997364, + "first_batch_wall_s": 10.13896927901078, + "max_three_slowest_ttft_s": 0.23913420794997364, + "warm_median_ttft_mean_s": 0.1276981119881384, + "warm_slowest_ttft_mean_s": 0.12947288452414796, + "warm_batch_wall_mean_s": 10.154350678029004 + } + }, + "chat_1": { + "reset_off": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.010750413057394326, + "slowest_ttft_s": 0.010750413057394326, + "batch_wall_s": 5.170678838039748 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.004458999959751964, + "slowest_ttft_s": 0.004458999959751964, + "batch_wall_s": 5.163522948976606 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.004657260957174003, + "slowest_ttft_s": 0.004657260957174003, + "batch_wall_s": 5.162194018019363 + } + ], + "first_median_ttft_s": 0.010750413057394326, + "first_slowest_ttft_s": 0.010750413057394326, + "first_batch_wall_s": 5.170678838039748, + "max_three_slowest_ttft_s": 0.010750413057394326, + "warm_median_ttft_mean_s": 0.004558130458462983, + "warm_slowest_ttft_mean_s": 0.004558130458462983, + "warm_batch_wall_mean_s": 5.162858483497985 + }, + "python": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.11341886292211711, + "slowest_ttft_s": 0.11341886292211711, + "batch_wall_s": 5.190338440006599 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.11421108397189528, + "slowest_ttft_s": 0.11421108397189528, + "batch_wall_s": 5.184694777941331 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.11264334805309772, + "slowest_ttft_s": 0.11264334805309772, + "batch_wall_s": 5.183799001039006 + } + ], + "first_median_ttft_s": 0.11341886292211711, + "first_slowest_ttft_s": 0.11341886292211711, + "first_batch_wall_s": 5.190338440006599, + "max_three_slowest_ttft_s": 0.11421108397189528, + "warm_median_ttft_mean_s": 0.1134272160124965, + "warm_slowest_ttft_mean_s": 0.1134272160124965, + "warm_batch_wall_mean_s": 5.1842468894901685 + }, + "candidate": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.009522677981294692, + "slowest_ttft_s": 0.009522677981294692, + "batch_wall_s": 5.167487745988183 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.0036208319943398237, + "slowest_ttft_s": 0.0036208319943398237, + "batch_wall_s": 5.165550902020186 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.0036739520728588104, + "slowest_ttft_s": 0.0036739520728588104, + "batch_wall_s": 5.154440063983202 + } + ], + "first_median_ttft_s": 0.009522677981294692, + "first_slowest_ttft_s": 0.009522677981294692, + "first_batch_wall_s": 5.167487745988183, + "max_three_slowest_ttft_s": 0.009522677981294692, + "warm_median_ttft_mean_s": 0.003647392033599317, + "warm_slowest_ttft_mean_s": 0.003647392033599317, + "warm_batch_wall_mean_s": 5.159995483001694 + } + }, + "chat_16": { + "reset_off": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.2407762390212156, + "slowest_ttft_s": 0.24191964196506888, + "batch_wall_s": 13.935204754932784 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.1534550779615529, + "slowest_ttft_s": 0.1560955800814554, + "batch_wall_s": 13.975830481969751 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.14458873157855123, + "slowest_ttft_s": 0.14564582600723952, + "batch_wall_s": 13.678456668974832 + } + ], + "first_median_ttft_s": 0.2407762390212156, + "first_slowest_ttft_s": 0.24191964196506888, + "first_batch_wall_s": 13.935204754932784, + "max_three_slowest_ttft_s": 0.24191964196506888, + "warm_median_ttft_mean_s": 0.14902190477005206, + "warm_slowest_ttft_mean_s": 0.15087070304434747, + "warm_batch_wall_mean_s": 13.827143575472292 + }, + "python": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.21395301196025684, + "slowest_ttft_s": 0.21628993598278612, + "batch_wall_s": 13.665136122028343 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.25065574451582506, + "slowest_ttft_s": 0.25213554804213345, + "batch_wall_s": 13.717169641051441 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.23881917347898707, + "slowest_ttft_s": 0.24087110697291791, + "batch_wall_s": 13.735604799934663 + } + ], + "first_median_ttft_s": 0.21395301196025684, + "first_slowest_ttft_s": 0.21628993598278612, + "first_batch_wall_s": 13.665136122028343, + "max_three_slowest_ttft_s": 0.25213554804213345, + "warm_median_ttft_mean_s": 0.24473745899740607, + "warm_slowest_ttft_mean_s": 0.24650332750752568, + "warm_batch_wall_mean_s": 13.726387220493052 + }, + "candidate": { + "repetitions": [ + { + "burst": 0, + "phase": "first_measured", + "median_ttft_s": 0.20528923848178238, + "slowest_ttft_s": 0.2073090299963951, + "batch_wall_s": 13.696557966992259 + }, + { + "burst": 1, + "phase": "repeat", + "median_ttft_s": 0.12680408294545487, + "slowest_ttft_s": 0.128067848039791, + "batch_wall_s": 13.62137975601945 + }, + { + "burst": 2, + "phase": "repeat", + "median_ttft_s": 0.1331077620270662, + "slowest_ttft_s": 0.13383883296046406, + "batch_wall_s": 13.648761622956954 + } + ], + "first_median_ttft_s": 0.20528923848178238, + "first_slowest_ttft_s": 0.2073090299963951, + "first_batch_wall_s": 13.696557966992259, + "max_three_slowest_ttft_s": 0.2073090299963951, + "warm_median_ttft_mean_s": 0.12995592248626053, + "warm_slowest_ttft_mean_s": 0.13095334050012752, + "warm_batch_wall_mean_s": 13.635070689488202 + } + } + } + } + }, + "balanced": { + "code_1": { + "arithmetic_means": { + "reset_off": { + "first_median_ttft_s": 0.010343921021558344, + "first_slowest_ttft_s": 0.010343921021558344, + "first_batch_wall_s": 3.6808917700545862, + "max_three_slowest_ttft_s": 0.010343921021558344, + "warm_median_ttft_mean_s": 0.004647409776225686, + "warm_slowest_ttft_mean_s": 0.004647409776225686, + "warm_batch_wall_mean_s": 3.677132805256406 + }, + "python": { + "first_median_ttft_s": 0.11102171905804425, + "first_slowest_ttft_s": 0.11102171905804425, + "first_batch_wall_s": 3.8694434780045412, + "max_three_slowest_ttft_s": 0.11611677397741005, + "warm_median_ttft_mean_s": 0.11372603446943685, + "warm_slowest_ttft_mean_s": 0.11372603446943685, + "warm_batch_wall_mean_s": 3.8650381544721313 + }, + "candidate": { + "first_median_ttft_s": 0.009643754980061203, + "first_slowest_ttft_s": 0.009643754980061203, + "first_batch_wall_s": 3.683098549488932, + "max_three_slowest_ttft_s": 0.009643754980061203, + "warm_median_ttft_mean_s": 0.003128205513348803, + "warm_slowest_ttft_mean_s": 0.003128205513348803, + "warm_batch_wall_mean_s": 3.678358139033662 + } + }, + "geometric_candidate_to_python": { + "first_median_ttft_s": 0.08680399720143679, + "first_slowest_ttft_s": 0.08680399720143679, + "first_batch_wall_s": 0.9518362030134053, + "max_three_slowest_ttft_s": 0.08305304865386795, + "warm_median_ttft_mean_s": 0.027466827875732958, + "warm_slowest_ttft_mean_s": 0.027466827875732958, + "warm_batch_wall_mean_s": 0.9517001563511502 + } + }, + "code_16": { + "arithmetic_means": { + "reset_off": { + "first_median_ttft_s": 0.2485271740006283, + "first_slowest_ttft_s": 0.2507159649976529, + "first_batch_wall_s": 10.229456181521527, + "max_three_slowest_ttft_s": 0.2507159649976529, + "warm_median_ttft_mean_s": 0.14839837861654814, + "warm_slowest_ttft_mean_s": 0.149964252486825, + "warm_batch_wall_mean_s": 10.231745046476135 + }, + "python": { + "first_median_ttft_s": 0.30260624701622874, + "first_slowest_ttft_s": 0.3044135859818198, + "first_batch_wall_s": 10.56136112002423, + "max_three_slowest_ttft_s": 0.3044135859818198, + "warm_median_ttft_mean_s": 0.22034284312394448, + "warm_slowest_ttft_mean_s": 0.22229745029471815, + "warm_batch_wall_mean_s": 10.468324399495032 + }, + "candidate": { + "first_median_ttft_s": 0.2449850312259514, + "first_slowest_ttft_s": 0.2464820354944095, + "first_batch_wall_s": 10.200371357495897, + "max_three_slowest_ttft_s": 0.2464820354944095, + "warm_median_ttft_mean_s": 0.12856420714524575, + "warm_slowest_ttft_mean_s": 0.1301950897614006, + "warm_batch_wall_mean_s": 10.182181016512914 + } + }, + "geometric_candidate_to_python": { + "first_median_ttft_s": 0.8093842440607647, + "first_slowest_ttft_s": 0.8095561971784627, + "first_batch_wall_s": 0.965983565263133, + "max_three_slowest_ttft_s": 0.8095561971784627, + "warm_median_ttft_mean_s": 0.5835017537447131, + "warm_slowest_ttft_mean_s": 0.5857074190081364, + "warm_batch_wall_mean_s": 0.9728117231298175 + } + }, + "chat_1": { + "arithmetic_means": { + "reset_off": { + "first_median_ttft_s": 0.011601932521443814, + "first_slowest_ttft_s": 0.011601932521443814, + "first_batch_wall_s": 5.166086753015406, + "max_three_slowest_ttft_s": 0.011601932521443814, + "warm_median_ttft_mean_s": 0.0044381594634614885, + "warm_slowest_ttft_mean_s": 0.0044381594634614885, + "warm_batch_wall_mean_s": 5.162187024252489 + }, + "python": { + "first_median_ttft_s": 0.11390354949980974, + "first_slowest_ttft_s": 0.11390354949980974, + "first_batch_wall_s": 5.188140332524199, + "max_three_slowest_ttft_s": 0.11731142550706863, + "warm_median_ttft_mean_s": 0.11484224477317184, + "warm_slowest_ttft_mean_s": 0.11484224477317184, + "warm_batch_wall_mean_s": 5.192167696252 + }, + "candidate": { + "first_median_ttft_s": 0.009175343497190624, + "first_slowest_ttft_s": 0.009175343497190624, + "first_batch_wall_s": 5.168605157989077, + "max_three_slowest_ttft_s": 0.009175343497190624, + "warm_median_ttft_mean_s": 0.003621153242420405, + "warm_slowest_ttft_mean_s": 0.003621153242420405, + "warm_batch_wall_mean_s": 5.164959250745596 + } + }, + "geometric_candidate_to_python": { + "first_median_ttft_s": 0.08049661299137865, + "first_slowest_ttft_s": 0.08049661299137865, + "first_batch_wall_s": 0.9962347141407267, + "max_three_slowest_ttft_s": 0.07818480217138245, + "warm_median_ttft_mean_s": 0.031533109529368816, + "warm_slowest_ttft_mean_s": 0.031533109529368816, + "warm_batch_wall_mean_s": 0.9947604117886473 + } + }, + "chat_16": { + "arithmetic_means": { + "reset_off": { + "first_median_ttft_s": 0.22831116450834088, + "first_slowest_ttft_s": 0.23005763499531895, + "first_batch_wall_s": 13.928589981456753, + "max_three_slowest_ttft_s": 0.23005763499531895, + "warm_median_ttft_mean_s": 0.14935174387937877, + "warm_slowest_ttft_mean_s": 0.1510253720334731, + "warm_batch_wall_mean_s": 13.873992157226894 + }, + "python": { + "first_median_ttft_s": 0.2153885154693853, + "first_slowest_ttft_s": 0.2179265409358777, + "first_batch_wall_s": 13.634734391001984, + "max_three_slowest_ttft_s": 0.24671032704645768, + "warm_median_ttft_mean_s": 0.23712265663198195, + "warm_slowest_ttft_mean_s": 0.23937074426794425, + "warm_batch_wall_mean_s": 13.703304858208867 + }, + "candidate": { + "first_median_ttft_s": 0.20161868148716167, + "first_slowest_ttft_s": 0.20381261297734454, + "first_batch_wall_s": 13.822925109474454, + "max_three_slowest_ttft_s": 0.20381261297734454, + "warm_median_ttft_mean_s": 0.13068526386632584, + "warm_slowest_ttft_mean_s": 0.13199583897949196, + "warm_batch_wall_mean_s": 13.797374065761687 + } + }, + "geometric_candidate_to_python": { + "first_median_ttft_s": 0.9359354347498265, + "first_slowest_ttft_s": 0.9351241296150701, + "first_batch_wall_s": 1.0137624574424005, + "max_three_slowest_ttft_s": 0.8261993413456155, + "warm_median_ttft_mean_s": 0.5514051982145686, + "warm_slowest_ttft_mean_s": 0.5516562084393412, + "warm_batch_wall_mean_s": 1.0067964722457223 + } + } + } +} diff --git a/validation/pr608-exact-cache/test_verify.py b/validation/pr608-exact-cache/test_verify.py new file mode 100644 index 000000000..75390e458 --- /dev/null +++ b/validation/pr608-exact-cache/test_verify.py @@ -0,0 +1,114 @@ +"""Exercise fail-closed validation of the portable evidence bundle.""" +from __future__ import annotations + +import json +from pathlib import Path +import shutil +import tempfile +import unittest + +import verify + + +class EvidenceTests(unittest.TestCase): + """Keep actual retained evidence as the valid control for each mutation.""" + + def setUp(self) -> None: + """Copy only small offline evidence, without runtime or model files.""" + self.temporary = tempfile.TemporaryDirectory() + self.addCleanup(self.temporary.cleanup) + self.root = Path(self.temporary.name) + source = Path(__file__).resolve().parent + for name in ( + 'provenance.json', 'qualification.json', 'evidence-forward.json', + 'evidence-reverse.json', 'requests-forward.jsonl', 'requests-reverse.jsonl', + ): + shutil.copyfile(source / name, self.root / name) + + def change_request(self, field: str, value: object, *, arm: str = "candidate", + warmup: bool = False) -> None: + """Mutate a row and renew the container hash to test semantic validation.""" + path = self.root / 'requests-forward.jsonl' + rows = [json.loads(line) for line in path.read_text().splitlines()] + row = next(r['request'] for r in rows + if r['arm'] == arm and (r['phase'] == 'warmup') == warmup) + row[field] = value + path.write_text(''.join(json.dumps(r) + '\n' for r in rows)) + receipt_path = self.root / 'evidence-forward.json' + receipt = json.loads(receipt_path.read_text()) + receipt['requests']['sha256'] = verify.sha(path) + receipt_path.write_text(json.dumps(receipt)) + + def test_valid_evidence(self) -> None: + """The control reconstructs all requests and both pairing populations.""" + result = verify.verify(self.root) + self.assertEqual(result['requests'], 624) + for order in result['orders'].values(): + self.assertEqual(order['paired_reset_requests'], 104) + self.assertEqual(order['paired_python_measured_requests'], 102) + self.assertEqual(order['paired_python_warmup_requests'], 2) + self.assertEqual(order['paired_python_all_requests'], 104) + + def test_output_mismatch(self) -> None: + """An otherwise valid fingerprint mismatch fails pairing.""" + self.change_request('output_sha256', '0' * 64) + with self.assertRaisesRegex(ValueError, 'paired output'): + verify.verify(self.root) + + def test_python_warmup_output_mismatch(self) -> None: + """A Python warmup mismatch fails parity without becoming a timed cell.""" + self.change_request('output_sha256', '0' * 64, arm='python', warmup=True) + with self.assertRaisesRegex(ValueError, 'paired output'): + verify.verify(self.root) + + def test_body_hash_mismatch(self) -> None: + """A rehashed envelope cannot hide a contradictory literal body digest.""" + self.change_request('request_body_sha256', '0' * 64) + with self.assertRaisesRegex(ValueError, 'body hash'): + verify.verify(self.root) + + def test_cache_mismatch(self) -> None: + """Native full-N cache evidence cannot silently become a cold result.""" + self.change_request('cached_tokens', 0) + with self.assertRaisesRegex(ValueError, 'cache state'): + verify.verify(self.root) + + def test_incomplete_response(self) -> None: + """Partial SSE output is not accepted as a timing measurement.""" + self.change_request('complete', False) + with self.assertRaisesRegex(ValueError, 'incomplete'): + verify.verify(self.root) + + def test_missing_record(self) -> None: + """Request count is enforced independently of a correct file digest.""" + path = self.root / 'requests-forward.jsonl' + path.write_text('\n'.join(path.read_text().splitlines()[:-1]) + '\n') + receipt_path = self.root / 'evidence-forward.json' + receipt = json.loads(receipt_path.read_text()) + receipt['requests']['sha256'] = verify.sha(path) + receipt_path.write_text(json.dumps(receipt)) + with self.assertRaisesRegex(ValueError, 'count drift'): + verify.verify(self.root) + + def test_wrong_target_repository(self) -> None: + """A revision alone cannot disguise an incorrect model repository owner.""" + path = self.root / 'provenance.json' + receipt = json.loads(path.read_text()) + receipt['models'][0]['repo'] = 'TensorFold/Qwen3.8-27B-MLX-4bit' + path.write_text(json.dumps(receipt)) + with self.assertRaisesRegex(ValueError, 'model identity drift'): + verify.verify(self.root) + + def test_flag_replacement(self) -> None: + """Five entries alone cannot substitute a different runtime flag.""" + path = self.root / 'provenance.json' + receipt = json.loads(path.read_text()) + flags = receipt['flag_values']['candidate'] + flags['UNKNOWN_FLAG'] = flags.pop('TF_PR608_EXACT_CACHE_LOGITS') + path.write_text(json.dumps(receipt)) + with self.assertRaisesRegex(ValueError, 'flags drift'): + verify.verify(self.root) + + +if __name__ == '__main__': + unittest.main() diff --git a/validation/pr608-exact-cache/verify.py b/validation/pr608-exact-cache/verify.py new file mode 100644 index 000000000..d994a6354 --- /dev/null +++ b/validation/pr608-exact-cache/verify.py @@ -0,0 +1,229 @@ +"""Validate sanitized HTTP evidence and reconstruct per-order TTFT/full-wall tables.""" +from __future__ import annotations + +import argparse +import hashlib +import json +import math +from pathlib import Path +import re +import statistics +from typing import Any + +import run_http + +ARMS = ("reset_off", "python", "candidate") +FLAGS = { + "TF_PR608_EXACT_PROMPT_CACHE", "TF_PR608_EXACT_CACHE_SEQ_REUSE", + "TF_PR608_EXACT_CACHE_LOGITS", "TF_PR608_EXACT_CACHE_DRAFT_REUSE", + "TF_PR608_EXACT_CACHE_SKIP_RESET", +} + + +def require(ok: bool, message: str) -> None: + """Reject a missing or contradictory evidence gate.""" + if not ok: + raise ValueError(message) + + +def sha(path: Path) -> str: + """Hash retained bytes without changing them.""" + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def read_order(path: Path) -> dict[str, Any]: + """Validate one derived receipt and all 312 retained requests.""" + evidence = json.loads(path.read_text()) + require(evidence.get("schema") == "pr608_exact_cache_public_order_v1" + and evidence.get("complete") is True and evidence.get("sanitized") is True, + "incomplete or wrong sanitized receipt") + order = evidence["order_name"] + expected = list(ARMS) if order == "forward" else ["candidate", "python", "reset_off"] + require(order in ("forward", "reverse") and evidence["process_order"] == expected, + "process-order drift") + require(set(evidence["reports"]) == set(ARMS), "missing arm") + info = evidence["requests"] + require(info["file"] == f"requests-{order}.jsonl", "unexpected evidence path") + data_path = path.parent / info["file"] + require(sha(data_path) == info["sha256"], "request evidence hash mismatch") + records = [json.loads(line) for line in data_path.read_text().splitlines()] + require(len(records) == info["count"] == 312, "request count drift") + slots: dict[tuple[Any, ...], dict[str, Any]] = {} + ids: dict[str, set[str]] = {arm: set() for arm in ARMS} + for record in records: + require(record.get("schema") == "pr608_exact_cache_public_request_v1", + "wrong request schema") + arm, prompt = record["arm"], record["prompt"] + require(arm in ARMS and prompt in ("code", "chat"), "unknown request identity") + n, burst, stream = record["streams"], record["burst"], record["stream"] + phase = record["phase"] + warmup = burst is None + require(type(n) is int and n in (1, 16) and type(stream) is int + and 0 <= stream < n, "bad stream geometry") + require((warmup and n == 1 and stream == 0 and phase == "warmup") or + (type(burst) is int and burst in (0, 1, 2) + and phase == ("first_measured" if burst == 0 else "repeat")), + "burst/warmup identity drift") + key = (arm, prompt, n, burst, stream) + require(key not in slots, "duplicate request slot") + row = record["request"] + require("request_url" not in row, "unsanitized endpoint") + report = evidence["reports"][arm] + require(report["parameters"] == run_http.PARAMETERS, "protocol drift") + require(report["reported_cache_label"] == ("python" if arm == "python" else "on"), + "cache-label drift") + item = run_http.prompts()[prompt] + route, _ = run_http.expected_body(report["model"], item, 16 if warmup else 256) + require(row["request_path"] == route, "route drift") + # The copied validator sees a synthetic string base; it never opens a connection. + checked = dict(row, request_url="receipt-base" + route) + prompt_n = run_http.EXPECTED_PROMPTS[prompt][2] + cached = 0 if warmup else prompt_n - 1 if arm == "python" else prompt_n + run_http.validate_request(checked, item=item, model=report["model"], + base="receipt-base", tokens=16 if warmup else 256, + cached=cached) + require(row["response_id"] not in ids[arm], "duplicate response identity") + ids[arm].add(row["response_id"]) + slots[key] = row + for arm in ARMS: + require(evidence["reports"][arm]["health_totals"] == + {"requests": 104, "prompt_tokens": 2340, "output_tokens": 26144}, + "health-count drift") + require(len(ids[arm]) == 104, "arm identity count drift") + for prompt in ("code", "chat"): + require((arm, prompt, 1, None, 0) in slots, "missing warmup") + for n in (1, 16): + for burst in range(3): + require(all((arm, prompt, n, burst, s) in slots for s in range(n)), + "missing measured request") + return {"receipt": evidence, "slots": slots} + + +def paired(left: dict[str, Any], right: dict[str, Any]) -> bool: + """Require literal prompt/settings and both output fingerprints; retain work differences.""" + require(left["request_body"] == right["request_body"] + and left["request_body_sha256"] == right["request_body_sha256"], + "paired literal request mismatch") + require(left["output_sha256"] == right["output_sha256"] + and left["token_sha"] == right["token_sha"], "paired output mismatch") + return left["work"] != right["work"] + + +def metrics(slots: dict[tuple[Any, ...], dict[str, Any]], arm: str, + prompt: str, n: int) -> dict[str, Any]: + """Keep each repetition and arithmetic means of the two warmed burst metrics.""" + repetitions = [] + for burst in range(3): + rows = [slots[(arm, prompt, n, burst, s)] for s in range(n)] + repetitions.append({ + "burst": burst, "phase": "first_measured" if burst == 0 else "repeat", + "median_ttft_s": statistics.median(row["ttft_s"] for row in rows), + "slowest_ttft_s": max(row["ttft_s"] for row in rows), + "batch_wall_s": max(row["done"] for row in rows) - min(row["sent"] for row in rows), + }) + return { + "repetitions": repetitions, + "first_median_ttft_s": repetitions[0]["median_ttft_s"], + "first_slowest_ttft_s": repetitions[0]["slowest_ttft_s"], + "first_batch_wall_s": repetitions[0]["batch_wall_s"], + "max_three_slowest_ttft_s": max(row["slowest_ttft_s"] for row in repetitions), + "warm_median_ttft_mean_s": statistics.mean(row["median_ttft_s"] for row in repetitions[1:]), + "warm_slowest_ttft_mean_s": statistics.mean(row["slowest_ttft_s"] for row in repetitions[1:]), + "warm_batch_wall_mean_s": statistics.mean(row["batch_wall_s"] for row in repetitions[1:]), + } + + +def verify(root: Path, source_root: Path | None = None) -> dict[str, Any]: + """Check provenance, complete work, output pairing and both process orders.""" + provenance = json.loads((root / "provenance.json").read_text()) + require(provenance["schema"] == "pr608_exact_cache_public_provenance_v1" + and provenance["sanitized"] is True, "bad provenance schema") + require(provenance["models"] == [ + {"name": "target", "repo": "Vontra/Qwen3.8-27B-MLX-4bit", + "revision": "70ae7fac63274ff2eac54152031433374cb80f2f"}, + {"name": "drafter", "repo": "z-lab/Qwen3.8-27B-DFlash2", + "revision": "50307d4c4cde6860d4eee73e2547cd786fe8e8a4"}, + ], "model identity drift") + sources = provenance["source_sha256"] + require(len(sources) == provenance["source_count"] == 19 + and all(re.fullmatch(r"[0-9a-f]{64}", h) for h in sources.values()), + "source inventory drift") + if source_root is not None: + for relative, digest in sources.items(): + require(relative.startswith("zig/src/families/qwen27/cuda/") + and ".." not in Path(relative).parts, "unsafe source path") + require(sha(source_root / relative) == digest, f"source changed: {relative}") + flags = provenance["flag_values"] + for arm in ("reset_off", "candidate"): + require(set(flags[arm]) == FLAGS and all(value == "1" for name, value in flags[arm].items() + if name != "TF_PR608_EXACT_CACHE_SKIP_RESET"), "preceding flags drift") + require(flags[arm]["TF_PR608_EXACT_CACHE_SKIP_RESET"] == + ("1" if arm == "candidate" else "0"), "reset arm drift") + qualification = json.loads((root / "qualification.json").read_text()) + require(qualification["passed"] is True and qualification["sanitized"] is True, + "missing device gate attestation") + reset = qualification["reset_skip"] + require(all(reset[k] is True for k in ( + "fresh_poisoned_full_state_raw_and_continuation_equal", + "pooled_poisoned_full_state_raw_and_continuation_equal", + "positive_hint_actual_miss_reset_before_target", "public_open_reset_domains_zero")), + "reset device gate failed") + require(reset["restored_fresh"] == 2 and reset["restored_pool"] == 1 + and reset["fallback_resets"] == 1 and reset["failed_deferred_transactions"] == 0 + and reset["avoided_fill_calls"] == 288 and reset["avoided_fill_bytes"] == 461832192, + "structural counter drift") + output: dict[str, Any] = {"schema": "pr608_exact_cache_public_summary_v1", "complete": True, + "requests": 624, "orders": {}, "balanced": {}} + for order in ("forward", "reverse"): + data = read_order(root / f"evidence-{order}.json") + slots = data["slots"] + work_diff = {"reset_off_candidate": 0, "candidate_python_measured": 0, + "candidate_python_warmup": 0} + for key, candidate in slots.items(): + arm, prompt, n, burst, stream = key + if arm != "candidate": + continue + work_diff["reset_off_candidate"] += paired( + slots[("reset_off", prompt, n, burst, stream)], candidate) + pair_type = "candidate_python_warmup" if burst is None else "candidate_python_measured" + work_diff[pair_type] += paired( + candidate, slots[("python", prompt, n, burst, stream)]) + output["orders"][order] = {"work_differences": work_diff, + "paired_reset_requests": 104, "paired_python_measured_requests": 102, + "paired_python_warmup_requests": 2, "paired_python_all_requests": 104, + "cells": {f"{prompt}_{n}": {arm: metrics(slots, arm, prompt, n) for arm in ARMS} + for prompt in ("code", "chat") for n in (1, 16)}} + fields = ("first_median_ttft_s", "first_slowest_ttft_s", "first_batch_wall_s", + "max_three_slowest_ttft_s", "warm_median_ttft_mean_s", + "warm_slowest_ttft_mean_s", "warm_batch_wall_mean_s") + for prompt in ("code", "chat"): + for n in (1, 16): + key = f"{prompt}_{n}" + cells = [output["orders"][order]["cells"][key] for order in ("forward", "reverse")] + output["balanced"][key] = { + "arithmetic_means": {arm: {field: statistics.mean(cell[arm][field] for cell in cells) + for field in fields} for arm in ARMS}, + "geometric_candidate_to_python": { + field: math.sqrt(math.prod(cell["candidate"][field] / cell["python"][field] + for cell in cells)) for field in fields}, + } + return output + + +def main() -> None: + """Run offline; optional source-root additionally rehashes all nineteen runtime files.""" + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--root", type=Path, default=Path(__file__).resolve().parent) + parser.add_argument("--source-root", type=Path) + parser.add_argument("--output", type=Path) + args = parser.parse_args() + result = verify(args.root, args.source_root) + text = json.dumps(result, indent=2, allow_nan=False) + "\n" + if args.output: + args.output.write_text(text) + else: + print(text, end="") + + +if __name__ == "__main__": + main() From 10c70be288c9a7f3b6cd995f84e1517d21b07bae Mon Sep 17 00:00:00 2001 From: Jonathan Regan-Beasley <197533392+jregan-beasley-smc@users.noreply.github.com> Date: Sun, 11 Oct 2026 22:51:31 +1100 Subject: [PATCH 4/4] docs(qwen27 cuda): add matched three-way TTFT and decode receipt --- validation/pr608-three-way/README.md | 62 + .../pr608-three-way/bench_concurrent.py | 275 +++ validation/pr608-three-way/bench_evidence.py | 54 + .../pr608-three-way/bundle-manifest.json | 28 + .../pr608-three-way/evidence-forward.json | 123 ++ .../pr608-three-way/evidence-reverse.json | 123 ++ validation/pr608-three-way/provenance.json | 101 + validation/pr608-three-way/qualification.json | 34 + .../pr608-three-way/requests-forward.jsonl | 312 +++ .../pr608-three-way/requests-reverse.jsonl | 312 +++ validation/pr608-three-way/run_http.py | 341 ++++ validation/pr608-three-way/summary.json | 1764 +++++++++++++++++ validation/pr608-three-way/test_verify.py | 108 + validation/pr608-three-way/verify.py | 373 ++++ 14 files changed, 4010 insertions(+) create mode 100644 validation/pr608-three-way/README.md create mode 100644 validation/pr608-three-way/bench_concurrent.py create mode 100644 validation/pr608-three-way/bench_evidence.py create mode 100644 validation/pr608-three-way/bundle-manifest.json create mode 100644 validation/pr608-three-way/evidence-forward.json create mode 100644 validation/pr608-three-way/evidence-reverse.json create mode 100644 validation/pr608-three-way/provenance.json create mode 100644 validation/pr608-three-way/qualification.json create mode 100644 validation/pr608-three-way/requests-forward.jsonl create mode 100644 validation/pr608-three-way/requests-reverse.jsonl create mode 100644 validation/pr608-three-way/run_http.py create mode 100644 validation/pr608-three-way/summary.json create mode 100644 validation/pr608-three-way/test_verify.py create mode 100644 validation/pr608-three-way/verify.py diff --git a/validation/pr608-three-way/README.md b/validation/pr608-three-way/README.md new file mode 100644 index 000000000..9cf0dd75e --- /dev/null +++ b/validation/pr608-three-way/README.md @@ -0,0 +1,62 @@ +## What this changes + +This is a fresh matched comparison of pinned Python v0.6.6, unmodified PR608 (`99bcc5b2`) and the complete exact-prompt-cache candidate (`474bd89b`). It supersedes the historical cross-run comparison for performance claims. Philip's Qwen27 engine and Python reference are the baseline; the candidate includes the earlier first-token handoff fix (`7acdc544`) and nineteen pinned cache/reuse runtime files. + +Every request uses the same literal greedy code/chat body, seed 1234, ignore_eos and 256 outputs. Each backend starts fresh: code first-use n1, then three n1 and three n16 bursts; chat first-use n1 follows that code traffic and has the same subsequent panel. Cold means prompt cached_tokens=0 after server readiness, not model-load time. There is no cold n16 measurement. After first use, stock remains uncached, Python reuses N−1 (13/30 tokens), candidate restores full N (14/31). + +The candidate's cache is opt-in and defaults off. It hits only an exact whole identical short prompt, not a growing conversation or arbitrary matching prefix. Changing/appending conversation turns does not automatically reuse this snapshot. The other reuse/reset mechanisms have their own short-capacity and ownership gates; this experiment is not general prefix-cache support. + +## Receipt + +All 624 requests preserve literal bodies/body hashes, output fingerprints, usage/work and sent/first/last/DONE clocks in sanitized JSONL. They include 312 requests per order, 104 per backend. Orders are Python→stock→candidate and candidate→stock→Python. The offline checker requires all three outputs to match, reports differing speculative work, and reproduces the independent summary. Its source revision, binaries, model revisions, source hashes and prior device gates are in provenance.json and qualification.json. Raw physical identities and operational restore logs are excluded. + +Tables are arithmetic means across the two orders. The cold first-use rows are single requests. Warm repeated rows average bursts 1 and 2 within each order; full per-repetition values, primed first bursts and maximum-three-burst TTFT remain in summary.json. + +Cold n1: **TTFT ms / decode tok/s / full response s**: + +| Prompt | Stock PR608 | Python | Candidate | +| --- | ---: | ---: | ---: | +| Code | 145.8 / 69.30 / 3.826 | 205.9 / 66.80 / 4.024 | 148.8 / 69.44 / 3.821 | +| Chat | 131.4 / 49.45 / 5.289 | 123.5 / 50.25 / 5.199 | 162.0 / 49.38 / 5.327 | + +Warm repeated: **median / slowest TTFT ms**: + +| Prompt / streams | Stock PR608 | Python | Candidate | +| --- | ---: | ---: | ---: | +| Code / 1 | 128.3 / 128.3 | 111.3 / 111.3 | 3.4 / 3.4 | +| Code / 16 | 681.8 / 683.2 | 219.5 / 221.0 | 126.2 / 127.5 | +| Chat / 1 | 135.5 / 135.5 | 114.2 / 114.2 | 3.8 / 3.8 | +| Chat / 16 | 833.5 / 835.4 | 233.0 / 235.0 | 126.8 / 128.5 | + +Warm repeated: **median per-stream decode tok/s / aggregate decode tok/s / full burst wall s**: + +| Prompt / streams | Stock PR608 | Python | Candidate | +| --- | ---: | ---: | ---: | +| Code / 1 | 68.80 / 68.80 / 3.836 | 68.11 / 68.11 / 3.856 | 69.45 / 69.45 / 3.675 | +| Code / 16 | 25.13 / 381.38 / 10.833 | 25.08 / 401.15 / 10.408 | 25.51 / 403.21 / 10.124 | +| Chat / 1 | 49.49 / 49.49 / 5.288 | 50.37 / 50.37 / 5.178 | 49.49 / 49.49 / 5.157 | +| Chat / 16 | 18.78 / 285.81 / 14.418 | 19.06 / 304.83 / 13.634 | 18.81 / 295.42 / 13.819 | + +Reconstruct offline with Python 3.11+ (stdlib only): + +```sh +python3 validation/pr608-three-way/verify.py --source-root . +python3 -B -m unittest discover -s validation/pr608-three-way -p test_verify.py +``` + +The standalone client requires your already-running isolated server and downloads/loads no model: + +```sh +python3 validation/pr608-three-way/run_http.py --base "$BASE_URL" \ + --model qwen27-pr608 --label candidate --output candidate.json --max-seconds 1200 +``` + +Repeat with stock and python labels on separate fresh processes, in both orders above. Geometry is parallel 16 / context 32768, BF16 KV/prefill, thinking off, same target/drafter revisions and 49-kernel AOT/native assets. Use the candidate configuration documented in ../pr608-exact-cache/README.md with all five flags 1; stock is the exact original binary with those flags absent/0. Python uses --drafter-bits 4 --kv-dtype bf16 --no-prefill-fp8 and its actual prefix-cache behavior. Client/cache gates distinguish backend states; matching CLI flags do not imply identical cache internals. + +## Limits + +TTFT is send→first nonempty SSE content; decode rate is 255/(last−first); full wall is last DONE−earliest send. Aggregate decode uses the sum of actual output-token intervals over the shared first-to-last span. It is not the character-estimated steady_tps field. No capture-time subtraction, equality-of-work assumption or universal no-regression claim is made. Cold candidate TTFT can be slower than stock: all three methods' cold TTFT and complete response time remain in the first table. Decode rate and wall results are retained even when an arm loses. This is a trade-off for review, not an automatic recommendation to enable the flags for every workload. + +Requests in a burst are correlated. Two fresh process orders are point estimates, not confidence intervals. Only two short prompts, greedy output and n1/n16 were measured; no general-prefix, long-context, sampled HTTP, other-model or FlashNext claim follows. Hash attestations do not reconstruct absent binaries/model weights or the omitted device qualifier. The content/reasoning composite SHA and server token fingerprint are retained; full token-ID sequences are not distributed. Driver/library versions were not independently retained beyond the pinned image/environment attestations. + +Jonathan Regan-Beasley contributed this work in a personal capacity. diff --git a/validation/pr608-three-way/bench_concurrent.py b/validation/pr608-three-way/bench_concurrent.py new file mode 100644 index 000000000..398d8d7b9 --- /dev/null +++ b/validation/pr608-three-way/bench_concurrent.py @@ -0,0 +1,275 @@ +"""Decode speed of an OpenAI-compatible server under concurrent requests (bench_openai's prompts and settings). + +Default: four cells (code and chat prompts, sampled and greedy). In each cell N requests of the same prompt start +at once, stream i with seed ``seed + i`` (greedy: all ``seed``), each ``--tokens`` long with ignore_eos. Per stream: decode tok/s = +(tokens - 1) / (last token - first token) and time to first token. Aggregate tok/s = the streams' tokens after +their first / (last token of any stream - first token of any stream). Medians over ``--reps``. + +``--mixed``: request i takes prompt i % 2 and seed seed + i // 2; also reports the steady aggregate, over the time +every stream is live (tokens split by the characters each stream delivered inside that window). +``--alone``: runs every request alone first and checks each concurrent reply's token-id hash (``token_sha``) +against it; ``--serial`` checks the alone runs against ``"draft": false``. ``--no-seed``: sampled requests carry +no seed (mlx_lm's server batches only those), for measuring a standard; no hash checks then. Run a standard with its +prompt cache off (mlx_lm: ``--prompt-cache-size 0``): a cached reply can arrive as one text piece. Tokens come from +the reply's usage. A request that fails to connect or errors counts in ``failed``; one whose text came in fewer than +``MIN_PIECES`` pieces counts in ``unmeasured``; neither enters the rates. ``--stagger-ms`` spaces the starts (a +server with a small listen backlog resets simultaneous connections; those resets are reported, not hidden). +Standard library only. + + python3 tools/bench_concurrent.py $BASE_URL MODEL --levels 1,2,4,8 --alone --output out.json +""" + +import argparse +import hashlib +import json +import statistics +import sys +import threading +import time +import urllib.request + +from bench_evidence import Evidence, token_equal + +if sys.version_info < (3, 11): + sys.exit(f"Python 3.11+ is required (this is {sys.version.split()[0]}); " + "TensorFold's tools use PEP 604 unions. Try: python3.12 tools/bench_concurrent.py ...") + +REQUEST_TIMEOUT = 180 + +MIN_PIECES = 4 # text pieces a reply needs before its span is timed + +PROMPTS = [ + {"name": "code", "kind": "completion", + "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it."}, + {"name": "chat", "kind": "chat", + "prompt": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example."}, +] + + +def stream(base: str, model: str, item: dict, tokens: int, temperature: float, seed: int | None, + draft: bool = True, gate: threading.Barrier | None = None) -> dict: + try: + return _stream(base, model, item, tokens, temperature, seed, draft, gate) + except Exception as exc: # noqa: BLE001 - a failed request is reported, not fatal + if gate is not None: + gate.abort() + return {"prompt": item["name"], "seed": seed, "sent": None, "first": None, "last": None, "tokens": None, + "pieces": [], "ttft_s": None, "decode_tps": None, "token_sha": None, + "error": type(exc).__name__, "complete": False, "prompt_tokens": None, + "cached_tokens": None, "cache_state": "unverified", "output_sha256": None} + + +def _stream(base: str, model: str, item: dict, tokens: int, temperature: float, seed: int | None, draft: bool, + gate: threading.Barrier | None) -> dict: + body = {"model": model, "max_tokens": tokens, "temperature": temperature, "stream": True, + "stream_options": {"include_usage": True}, "ignore_eos": True} + if seed is not None: + body["seed"] = seed + if not draft: + body["draft"] = False + if temperature > 0: + body.update(top_k=20, top_p=0.95) + if item["kind"] == "chat": + url = base + "/v1/chat/completions" + body["messages"] = [{"role": "user", "content": item["prompt"]}] + body["chat_template_kwargs"] = {"enable_thinking": False} + else: + url = base + "/v1/completions" + body["prompt"] = item["prompt"] + body_bytes = json.dumps(body).encode() + body_sha = hashlib.sha256(body_bytes).hexdigest() + req = urllib.request.Request(url, data=body_bytes, headers={"Content-Type": "application/json"}) + if gate is not None: + gate.wait(timeout=30) + sent = time.perf_counter() + response_id: str | None = None + pieces: list[tuple[float, int]] = [] # (arrival, characters) of every text chunk + usage: dict = {} + runtime: dict = {} + evidence = Evidence() + complete = False + done = None + finish_reason = None + speculative = {} + with urllib.request.urlopen(req, timeout=REQUEST_TIMEOUT) as resp: + for raw in resp: + line = raw.decode().strip() + if line == "data: [DONE]": + done = time.perf_counter() + complete = True + break + if not line.startswith("data:"): + continue + chunk = json.loads(line[5:]) + if "error" in chunk: + raise RuntimeError("server_stream_error") + usage = chunk.get("usage") or usage + runtime = chunk.get("tensorfold") or runtime + speculative = chunk.get("speculative") or speculative + for choice in chunk.get("choices", []): + evidence.add(choice) + reason = choice.get("finish_reason") + if reason is not None: + if finish_reason is not None and finish_reason != reason: + raise ValueError("finish reason changed within a stream") + finish_reason = reason + delta = choice.get("delta") or {} + # reasoning counts: its tokens are in completion_tokens, so the clock starts with them + piece = choice.get("text") or delta.get("content") or delta.get("reasoning_content") or "" + if piece: + pieces.append((time.perf_counter(), len(piece))) + if chunk.get("id") is not None: + if response_id is not None and response_id != chunk["id"]: + raise ValueError("response ID changed within a stream") + response_id = chunk["id"] + observed = evidence.finish(usage, runtime, complete) + n = observed["tokens"] + work_source = speculative if speculative else runtime + work = {k: work_source.get(k) for k in ("rounds", "accepted", "drafted")} + out = {"prompt": item["name"], "seed": seed, "sent": sent, "first": None, "last": None, "tokens": n, + "pieces": pieces, "ttft_s": None, "decode_tps": None, "response_id": response_id, + "case_id": item.get("case_id"), "request_body": body, "request_body_sha256": body_sha, "request_url": url, + "usage": usage, "runtime": runtime, "speculative": speculative, "finish_reason": finish_reason, + "work": work, "work_source": "speculative" if speculative else "tensorfold", + "done": done, "full_response_s": done - sent if done is not None else None, **observed} + if not complete: + out["error"] = "incomplete_stream" + if pieces: + first, last = pieces[0][0], pieces[-1][0] + out.update(first=first, last=last, ttft_s=first - sent if complete else None) + if complete and n is not None and n > 1 and last > first and len(pieces) >= MIN_PIECES: + out["decode_tps"] = (n - 1) / (last - first) + else: + out["unmeasured"] = True + else: + out["unmeasured"] = True + return out + + +def together(base: str, model: str, specs: list[tuple[dict, int | None]], tokens: int, temperature: float, + stagger_ms: float = 0.0) -> list[dict]: + gate = threading.Barrier(len(specs)) + out: list[dict | None] = [None] * len(specs) + + def run(i: int) -> None: + if stagger_ms: + gate.wait(timeout=30) + time.sleep(i * stagger_ms / 1e3) + out[i] = stream(base, model, specs[i][0], tokens, temperature, specs[i][1]) + else: + out[i] = stream(base, model, specs[i][0], tokens, temperature, specs[i][1], gate=gate) + + threads = [threading.Thread(target=run, args=(i,)) for i in range(len(specs))] + for t in threads: + t.start() + for t in threads: + t.join() + return [r for r in out if r is not None] + + +def aggregates(runs: list[dict]) -> dict: + done = [r for r in runs if r["decode_tps"] is not None] + out: dict = {"failed": sum(1 for r in runs if r.get("error")), "unmeasured": sum(1 for r in runs if r.get("unmeasured")), + "aggregate_tps": 0.0} + if not done: + return out + first = min(r["first"] for r in done) + last = max(r["last"] for r in done) + if last > first: + out["aggregate_tps"] = sum(r["tokens"] - 1 for r in done) / (last - first) + lo, hi = max(r["first"] for r in done), min(r["last"] for r in done) # every stream live + if len(done) > 1 and hi > lo: + share = 0.0 + for r in done: + chars = sum(c for _, c in r["pieces"]) or 1 + share += r["tokens"] * sum(c for t, c in r["pieces"] if lo <= t <= hi) / chars + out["steady_tps"] = share / (hi - lo) + return out + + +def main() -> None: + p = argparse.ArgumentParser() + p.add_argument("base") + p.add_argument("model") + p.add_argument("--levels", default="4", help="concurrent requests, a comma list") + p.add_argument("--tokens", type=int, default=256) + p.add_argument("--reps", type=int, default=3) + p.add_argument("--seed", type=int, default=1234) + p.add_argument("--temperatures", default="1.0,0") + p.add_argument("--mixed", action="store_true", help="request i takes prompt i %% 2 (sampled only)") + p.add_argument("--alone", action="store_true", help="check each reply's token_sha against its request alone") + p.add_argument("--serial", action="store_true", help="check the alone runs against \"draft\": false") + p.add_argument("--no-seed", action="store_true", help="sampled requests without a seed (standards; no checks)") + p.add_argument("--stagger-ms", type=float, default=0.0, help="start request i this many ms after request i - 1") + p.add_argument("--label", default="") + p.add_argument("--output") + args = p.parse_args() + if args.no_seed: + args.alone = args.serial = False + levels = [int(x) for x in args.levels.split(",")] + temps = [1.0] if args.mixed else [float(t) for t in args.temperatures.split(",")] + cells = [None] if args.mixed else PROMPTS + report: dict = {"label": args.label, "tokens": args.tokens, "mixed": args.mixed, "cells": []} + for temp in temps: + for item in cells: + specs: list[tuple[dict, int | None]] + if args.mixed or item is None: + specs = [(PROMPTS[i % 2], args.seed + i // 2) for i in range(max(levels))] + else: + specs = [(item, args.seed + i if temp > 0 else args.seed) for i in range(max(levels))] + if args.no_seed: + specs = [(spec[0], None) for spec in specs] + together(args.base, args.model, specs[:1], 16, temp) # warm-up + alone: dict[tuple[str, int | None], dict] = {} + if args.alone or args.serial: + for spec in specs: + key = (spec[0]["name"], spec[1]) + if key not in alone: + alone[key] = stream(args.base, args.model, spec[0], args.tokens, temp, spec[1]) + if args.serial: + for key, ref in alone.items(): + serial = stream(args.base, args.model, next(q for q in PROMPTS if q["name"] == key[0]), + args.tokens, temp, key[1], draft=False) + ref["serial_equal"] = token_equal(serial, ref) + for n in levels: + reps = [] + for _ in range(args.reps): + runs = together(args.base, args.model, specs[:n], args.tokens, temp, args.stagger_ms) + rep = aggregates(runs) + rep["per_stream_tps"] = [round(r["decode_tps"], 1) for r in runs if r["decode_tps"] is not None] + rep["ttft_s"] = [round(r["ttft_s"], 2) if r["ttft_s"] is not None else None for r in runs] + rep["errors"] = [r["error"] for r in runs if r.get("error")] + rep["evidence"] = [{k: r.get(k) for k in ("prompt_tokens", "cached_tokens", "tokens", + "cache_state", "complete", "token_sha", "output_sha256")} for r in runs] + if alone: + # None: the request or its solo run failed (not an exactness result) + rep["equal_alone"] = [token_equal(alone[(r["prompt"], r["seed"])], r) for r in runs] + reps.append(rep) + cell = {"prompt": "mixed" if args.mixed or item is None else item["name"], "temperature": temp, + "streams": n, "failed": sum(r["failed"] for r in reps), + "unmeasured": sum(r["unmeasured"] for r in reps), + "aggregate_tps": round(statistics.median(r["aggregate_tps"] for r in reps), 1), + "per_stream_tps": round(statistics.median([v for r in reps for v in r["per_stream_tps"]] or [0.0]), 1), + "ttft_s_max": max((t for r in reps for t in r["ttft_s"] if t is not None), default=None)} + if all("steady_tps" in r for r in reps): + cell["steady_tps"] = round(statistics.median(r["steady_tps"] for r in reps), 1) + if alone: + checks = [v for r in reps for v in r["equal_alone"]] + cell["alone"] = {"equal": checks.count(True), "unequal": checks.count(False), + "failed": checks.count(None)} + if args.serial: + checks = [v.get("serial_equal") for v in alone.values()] + cell["serial"] = {"equal": checks.count(True), "unequal": checks.count(False), + "failed": checks.count(None)} + errors = sorted({e for r in reps for e in r["errors"]}) + if errors: + cell["errors"] = errors[:3] + print(json.dumps({"label": args.label, **cell}), flush=True) + report["cells"].append({**cell, "reps": reps}) + if args.output: + with open(args.output, "w") as f: + json.dump(report, f, indent=1) + + +if __name__ == "__main__": + main() diff --git a/validation/pr608-three-way/bench_evidence.py b/validation/pr608-three-way/bench_evidence.py new file mode 100644 index 000000000..a9fe6c257 --- /dev/null +++ b/validation/pr608-three-way/bench_evidence.py @@ -0,0 +1,54 @@ +"""Validated usage and output fingerprints shared by the HTTP benchmark clients.""" +import hashlib +import re + + +def count(value): + """A server-reported nonnegative integer; missing, boolean and coerced numbers stay unknown.""" + return value if type(value) is int and value >= 0 else None + + +class Evidence: + """Hash content and reasoning independently so network chunk boundaries cannot alter the fingerprint.""" + + def __init__(self): + self.content = hashlib.sha256() + self.reasoning = hashlib.sha256() + + def add(self, choice): + delta = choice.get("delta") or {} + content = choice.get("text") or delta.get("content") or "" + reasoning = delta.get("reasoning_content") or "" + if not isinstance(content, str) or not isinstance(reasoning, str): + raise ValueError("invalid_text_chunk") + self.content.update(content.encode("utf-8")) + self.reasoning.update(reasoning.encode("utf-8")) + + def finish(self, usage, runtime, complete): + usage = usage if isinstance(usage, dict) else {} + runtime = runtime if isinstance(runtime, dict) else {} + details = usage.get("prompt_tokens_details") + details = details if isinstance(details, dict) else {} + prompt = count(usage.get("prompt_tokens")) + cached = count(details.get("cached_tokens")) + tokens = count(usage.get("completion_tokens")) + valid = prompt is not None and cached is not None and cached <= prompt + state = "cold" if valid and cached == 0 else "reused" if valid else "unverified" + if not complete: + state = "unverified" + token_sha = runtime.get("token_sha") + if not isinstance(token_sha, str) or not re.fullmatch(r"(?:[0-9a-f]{12}|[0-9a-f]{64})", token_sha): + token_sha = None + digest = hashlib.sha256(self.content.digest() + self.reasoning.digest()).hexdigest() + return {"prompt_tokens": prompt, "cached_tokens": cached, "tokens": tokens, "cache_state": state, + "complete": complete, "token_sha": token_sha if complete else None, + "output_sha256": digest if complete else None} + + +def token_equal(left, right): + """Missing token hashes or failed/incomplete streams are unverified, never an equality pass.""" + if left.get("error") or right.get("error") or not left.get("complete") or not right.get("complete"): + return None + if not left.get("token_sha") or not right.get("token_sha"): + return None + return left["token_sha"] == right["token_sha"] diff --git a/validation/pr608-three-way/bundle-manifest.json b/validation/pr608-three-way/bundle-manifest.json new file mode 100644 index 000000000..95ded9578 --- /dev/null +++ b/validation/pr608-three-way/bundle-manifest.json @@ -0,0 +1,28 @@ +{ + "files_sha256": { + "README.md": "98e5d2ffa4d5471b5226bd84ec3c10a3c85ceb41b2e9df35560abf33e7028e14", + "bench_concurrent.py": "4e336cb213fe55ca5879a51a99dc4185de0ed17fc9096949c9c9bd6f107f7d53", + "bench_evidence.py": "119c396f24f3c13e181429bc69acff39f34254efd4789c5673a3dcbc54738d93", + "evidence-forward.json": "0b52d1bf0cd44227294ce65a60354129acba8ca450d43ad3e98cba8b283ac642", + "evidence-reverse.json": "5becc76a34a5bc0e5456439c204100cbfc5610a2f144eaa6baaba6b7d9e6c578", + "provenance.json": "fb430555dea1087ce564f94edd222947d5cf35ee400939ed94e8910aaee167cf", + "qualification.json": "13bf795f292e1014424dabcc5b55776e935de32379c2af1eb85b637882b041c9", + "requests-forward.jsonl": "b3b6befe1c86947ddeaf8babf781e796d3a41ef191811f04b976bf40fcffb13e", + "requests-reverse.jsonl": "f0a5601f248f9558956b47cdd7cd7ee3bffddc4500ea5fcde0a43cff10ad4228", + "run_http.py": "97a3cfbdb5b5ae8f2b945abee6b245ae310876b57b1a4fa6183a7ef028348767", + "summary.json": "1833c6ff337a9380594b98faabd540b35786877fd91e7824dd8907dba600ce1e", + "test_verify.py": "b0693ebafca6810adf1c7834ada33deaec97e70fc2b1317fe9f92e8a6e820e11", + "verify.py": "9a8b03ebc093a68d0f9cd9637c482decaeb949924d72e1d958ec874f841f625e" + }, + "host_checks": { + "bytecode_files_included": false, + "mutation_tests_passed": 9, + "python_ast_target": "3.11", + "runtime_source_hashes_rechecked": 19, + "summary_matches_accepted_independent_analysis": true + }, + "requests": 624, + "runtime_commit": "474bd89b68dee96149898ad303626d5d9dce0291", + "sanitized": true, + "schema": "pr608_three_way_public_bundle_v1" +} diff --git a/validation/pr608-three-way/evidence-forward.json b/validation/pr608-three-way/evidence-forward.json new file mode 100644 index 000000000..05e7c052c --- /dev/null +++ b/validation/pr608-three-way/evidence-forward.json @@ -0,0 +1,123 @@ +{ + "complete": true, + "lifecycle_attestation": { + "all_jobs_passed": true, + "complete": true, + "jobs": { + "candidate": { + "passed": true + }, + "python": { + "passed": true + }, + "stock": { + "passed": true + } + }, + "restored": true + }, + "process_order": [ + "python", + "stock", + "candidate" + ], + "provenance_sha256": "9326f2f13e7425fc9672dccdacd8712529560c8e89ffe5523d26f733b3361a66", + "reports": { + "candidate": { + "health_totals": { + "output_tokens": 26624, + "prompt_tokens": 2340, + "requests": 104 + }, + "model": "qwen27-pr608", + "parameters": { + "levels": [ + 1, + 16 + ], + "measured_tokens": 256, + "prompts": [ + "code", + "chat" + ], + "repetitions": 3, + "seed": 1234, + "temperature": 0.0, + "uncached_first_use_tokens": 256 + }, + "source_report_sha256": "d093352f4066db9f06d4640aa0c0d4bbf54926d64e74a182756429267a4d4fa7", + "source_sha256": { + "bench_concurrent.py": "1bdd080554bb236532843f5f9490db97fbfd414c8e8618b3c2a1b582fd66e882", + "bench_evidence.py": "119c396f24f3c13e181429bc69acff39f34254efd4789c5673a3dcbc54738d93", + "run_http.py": "97a3cfbdb5b5ae8f2b945abee6b245ae310876b57b1a4fa6183a7ef028348767" + } + }, + "python": { + "health_totals": { + "output_tokens": 26624, + "prompt_tokens": 2340, + "requests": 104 + }, + "model": "qwen27-pr608", + "parameters": { + "levels": [ + 1, + 16 + ], + "measured_tokens": 256, + "prompts": [ + "code", + "chat" + ], + "repetitions": 3, + "seed": 1234, + "temperature": 0.0, + "uncached_first_use_tokens": 256 + }, + "source_report_sha256": "463f5fc88ec2e616270f2527bb5d45b942bec01f0205387a4720fb2f65e5d1c7", + "source_sha256": { + "bench_concurrent.py": "1bdd080554bb236532843f5f9490db97fbfd414c8e8618b3c2a1b582fd66e882", + "bench_evidence.py": "119c396f24f3c13e181429bc69acff39f34254efd4789c5673a3dcbc54738d93", + "run_http.py": "97a3cfbdb5b5ae8f2b945abee6b245ae310876b57b1a4fa6183a7ef028348767" + } + }, + "stock": { + "health_totals": { + "output_tokens": 26624, + "prompt_tokens": 2340, + "requests": 104 + }, + "model": "qwen27-pr608", + "parameters": { + "levels": [ + 1, + 16 + ], + "measured_tokens": 256, + "prompts": [ + "code", + "chat" + ], + "repetitions": 3, + "seed": 1234, + "temperature": 0.0, + "uncached_first_use_tokens": 256 + }, + "source_report_sha256": "200c016071bc876246e895a4ef01333491a9268e5ec6ba1c5c85f0c6ca6ad24a", + "source_sha256": { + "bench_concurrent.py": "1bdd080554bb236532843f5f9490db97fbfd414c8e8618b3c2a1b582fd66e882", + "bench_evidence.py": "119c396f24f3c13e181429bc69acff39f34254efd4789c5673a3dcbc54738d93", + "run_http.py": "97a3cfbdb5b5ae8f2b945abee6b245ae310876b57b1a4fa6183a7ef028348767" + } + } + }, + "requests": { + "count": 312, + "file": "requests-forward.jsonl", + "sha256": "b3b6befe1c86947ddeaf8babf781e796d3a41ef191811f04b976bf40fcffb13e" + }, + "sanitization": "Derived evidence, not raw operational logs. Endpoint URLs and machine/service identities omitted; routes, literal bodies, usage/runtime/work, output fingerprints and all SSE clocks retained.", + "sanitized": true, + "schema": "pr608_three_way_public_order_v1", + "status_sha256": "f24c0a2526605f9ed17200003a2afee98ec999a34d047c9fea33d6aa794ac4e0" +} diff --git a/validation/pr608-three-way/evidence-reverse.json b/validation/pr608-three-way/evidence-reverse.json new file mode 100644 index 000000000..b8e76f44a --- /dev/null +++ b/validation/pr608-three-way/evidence-reverse.json @@ -0,0 +1,123 @@ +{ + "complete": true, + "lifecycle_attestation": { + "all_jobs_passed": true, + "complete": true, + "jobs": { + "candidate": { + "passed": true + }, + "python": { + "passed": true + }, + "stock": { + "passed": true + } + }, + "restored": true + }, + "process_order": [ + "candidate", + "stock", + "python" + ], + "provenance_sha256": "966838354657c7b6c31fd0bc912cc561b584a818cf4ca65ce060708301dc985f", + "reports": { + "candidate": { + "health_totals": { + "output_tokens": 26624, + "prompt_tokens": 2340, + "requests": 104 + }, + "model": "qwen27-pr608", + "parameters": { + "levels": [ + 1, + 16 + ], + "measured_tokens": 256, + "prompts": [ + "code", + "chat" + ], + "repetitions": 3, + "seed": 1234, + "temperature": 0.0, + "uncached_first_use_tokens": 256 + }, + "source_report_sha256": "5e6746c9c52e67ac43801927ba015c86601e9294ba453e667cc4395fadaf7876", + "source_sha256": { + "bench_concurrent.py": "1bdd080554bb236532843f5f9490db97fbfd414c8e8618b3c2a1b582fd66e882", + "bench_evidence.py": "119c396f24f3c13e181429bc69acff39f34254efd4789c5673a3dcbc54738d93", + "run_http.py": "97a3cfbdb5b5ae8f2b945abee6b245ae310876b57b1a4fa6183a7ef028348767" + } + }, + "python": { + "health_totals": { + "output_tokens": 26624, + "prompt_tokens": 2340, + "requests": 104 + }, + "model": "qwen27-pr608", + "parameters": { + "levels": [ + 1, + 16 + ], + "measured_tokens": 256, + "prompts": [ + "code", + "chat" + ], + "repetitions": 3, + "seed": 1234, + "temperature": 0.0, + "uncached_first_use_tokens": 256 + }, + "source_report_sha256": "2b737254aa61a58e488023d30ab2e9802ba16130a4820dc869efe90962880b2a", + "source_sha256": { + "bench_concurrent.py": "1bdd080554bb236532843f5f9490db97fbfd414c8e8618b3c2a1b582fd66e882", + "bench_evidence.py": "119c396f24f3c13e181429bc69acff39f34254efd4789c5673a3dcbc54738d93", + "run_http.py": "97a3cfbdb5b5ae8f2b945abee6b245ae310876b57b1a4fa6183a7ef028348767" + } + }, + "stock": { + "health_totals": { + "output_tokens": 26624, + "prompt_tokens": 2340, + "requests": 104 + }, + "model": "qwen27-pr608", + "parameters": { + "levels": [ + 1, + 16 + ], + "measured_tokens": 256, + "prompts": [ + "code", + "chat" + ], + "repetitions": 3, + "seed": 1234, + "temperature": 0.0, + "uncached_first_use_tokens": 256 + }, + "source_report_sha256": "26c9714b8d9807eaceb024d934151f2d6ed25e93e1996b0a570eed49044e93b4", + "source_sha256": { + "bench_concurrent.py": "1bdd080554bb236532843f5f9490db97fbfd414c8e8618b3c2a1b582fd66e882", + "bench_evidence.py": "119c396f24f3c13e181429bc69acff39f34254efd4789c5673a3dcbc54738d93", + "run_http.py": "97a3cfbdb5b5ae8f2b945abee6b245ae310876b57b1a4fa6183a7ef028348767" + } + } + }, + "requests": { + "count": 312, + "file": "requests-reverse.jsonl", + "sha256": "f0a5601f248f9558956b47cdd7cd7ee3bffddc4500ea5fcde0a43cff10ad4228" + }, + "sanitization": "Derived evidence, not raw operational logs. Endpoint URLs and machine/service identities omitted; routes, literal bodies, usage/runtime/work, output fingerprints and all SSE clocks retained.", + "sanitized": true, + "schema": "pr608_three_way_public_order_v1", + "status_sha256": "3d54b21b1ba7e6acbf81dfffa7ad6b97269f9ff17609713997228b2bddc1041c" +} diff --git a/validation/pr608-three-way/provenance.json b/validation/pr608-three-way/provenance.json new file mode 100644 index 000000000..ba41c4ff2 --- /dev/null +++ b/validation/pr608-three-way/provenance.json @@ -0,0 +1,101 @@ +{ + "all_runtime_flags_default_off": true, + "analyzer_source_sha256": "915d7ad33eb9a61552f5a54db48e6b4df3356ed4537e44c22d26c2771845cef6", + "build_receipt_sha256": "eebf47b460876917d742cb88a442233e996c2cb508a9e8e2e2b6d96b1c737213", + "client_documentation_delta": "Only the documentation example endpoint is replaced by $BASE_URL; executable client behavior is unchanged.", + "cpu_checks": { + "host_tests": 334, + "native_build_steps": 6, + "qualifier_build_steps": 5 + }, + "environment": { + "capture_container_release": "NVIDIA's PyTorch 26.07 container", + "capture_image_sha256": "15b8de8baabe68e46afc51e88f3ccad5042013bafe8f244ec082ce0bb06d47e3", + "driver_library_versions": "not independently retained in this public bundle", + "hardware": "DGX Spark NVIDIA GB10 sm_121", + "native_backend": "CUDA", + "os": "Linux aarch64", + "zig": "0.17.0" + }, + "final_independent_verification_sha256": "6d76645814c4ff55b74503d77588fe52c19b1ee28a67183e1923c680b402e7b4", + "flags": { + "candidate": { + "TF_PR608_EXACT_CACHE_DRAFT_REUSE": "1", + "TF_PR608_EXACT_CACHE_LOGITS": "1", + "TF_PR608_EXACT_CACHE_SEQ_REUSE": "1", + "TF_PR608_EXACT_CACHE_SKIP_RESET": "1", + "TF_PR608_EXACT_PROMPT_CACHE": "1" + }, + "python": {}, + "stock": { + "TF_PR608_EXACT_CACHE_DRAFT_REUSE": "0", + "TF_PR608_EXACT_CACHE_LOGITS": "0", + "TF_PR608_EXACT_CACHE_SEQ_REUSE": "0", + "TF_PR608_EXACT_CACHE_SKIP_RESET": "0", + "TF_PR608_EXACT_PROMPT_CACHE": "0" + } + }, + "independent_analysis_sha256": "1833c6ff337a9380594b98faabd540b35786877fd91e7824dd8907dba600ce1e", + "model_manifest_sha256": "1a556f5bd87c302a86cec21e437e58cede87e7492492b78bf24df5c2882633e4", + "models": [ + { + "name": "target", + "repo": "Vontra/Qwen3.8-27B-MLX-4bit", + "revision": "70ae7fac63274ff2eac54152031433374cb80f2f" + }, + { + "name": "drafter", + "repo": "z-lab/Qwen3.8-27B-DFlash2", + "revision": "50307d4c4cde6860d4eee73e2547cd786fe8e8a4" + } + ], + "native_binary_sha256": "469b917ca87959fbf3f38964cd91388da433e1395a5773556560d4982fc7d761", + "pr608_head": "99bcc5b29805e29a4baf2cd4beade0f7fe1a5fe8", + "publication_parent": "7acdc54473b5c9f54582b5d3c465e89b92daf886", + "python_commit": "cb2ebf0540f42604e2759b2ddef497861e928248", + "qualification_sha256": "13bf795f292e1014424dabcc5b55776e935de32379c2af1eb85b637882b041c9", + "qualifier_included": false, + "raw_operational_receipts_included": false, + "runtime_commit": "474bd89b68dee96149898ad303626d5d9dce0291", + "runtime_prerequisite": "7acdc54473b5c9f54582b5d3c465e89b92daf886", + "sanitized": true, + "schema": "pr608_three_way_public_provenance_v1", + "server_settings": { + "context": 32768, + "generic_prompt_cache_gib": 0, + "kv": "BF16", + "parallel": 16, + "prefill": "BF16", + "temperature": 0, + "thinking": false + }, + "source_count": 19, + "source_manifest_sha256": "a045512152eabdd1c8a21f3120b822a96f92a3caa0a603dc93c3a4d9eb6bd276", + "source_sha256": { + "zig/src/families/qwen27/cuda/draft_pool.zig": "3ca8a67b16ff5d019998c5242caea5a351dff94ddeaa461027108dcac0b8fff5", + "zig/src/families/qwen27/cuda/draft_pool_test.zig": "2e5792ccd7c8fbef33c50644fa721be9af284cdfcf2bedb78e920330fb28b88c", + "zig/src/families/qwen27/cuda/drafts.zig": "fcbc5ffcc643104380f2289d4f9a64444a31627719467f259dedbc31204c1c86", + "zig/src/families/qwen27/cuda/engine.zig": "f674145954a3dd59b08b99b5f884ce32b53f7b5d10c282305d65f83e4e19117f", + "zig/src/families/qwen27/cuda/exact_cache_policy.zig": "5e550ddcbdd1db0ca50dbc543488b88516809945b8665820a06a0bc3150ca4ab", + "zig/src/families/qwen27/cuda/exact_cache_test.zig": "16becde3ec100dec1abeeedb1827181265d8ea1d3a93c30b4eaec2e357b8635a", + "zig/src/families/qwen27/cuda/exact_draft_reuse.zig": "2274324c29765e9f425e6d2fa045d1cc6596681c16999fc5a79e58ac599b2ad3", + "zig/src/families/qwen27/cuda/exact_first_logits.zig": "eb99f17648837d5026238ee9270cd30895b39a32c9646597fff5953ef511b103", + "zig/src/families/qwen27/cuda/exact_logits_policy.zig": "c12f1d89bedfeb9192330c9eca0967abf7fe44886c9e736b09be9747f1ed57ca", + "zig/src/families/qwen27/cuda/exact_prompt_cache.zig": "79a88a49ff0908651b8126569b54c15cb4708f003583d1a7755ad6bc35d66d01", + "zig/src/families/qwen27/cuda/exact_seq_reuse.zig": "1452fdfc4d1407e1fee62828aff4cb0c5a033f9d637ac124da86a2642d8fb261", + "zig/src/families/qwen27/cuda/lanes.zig": "eb3b6539c806a12a83370455785e1468430d0098bc8e4c0c97b784788a32535d", + "zig/src/families/qwen27/cuda/reset_skip.zig": "715816eddb923dbada206179405e8863fd0d82da66fa6db5050b44c9d88e46e2", + "zig/src/families/qwen27/cuda/reset_skip_factory_test.zig": "003658aae413decc868f5aa4792d23aec9fe6000df903afc613d518a0425e239", + "zig/src/families/qwen27/cuda/reset_skip_test.zig": "5386b56c2191d840d216d160deac31705f2b4ff5df6fec4f7ef0f7cbe2bbf058", + "zig/src/families/qwen27/cuda/restore_proof.zig": "73357234268ab6c7a5f0fb72bb8fdc980be08743144a5364c56a0c9b8fd2e7bb", + "zig/src/families/qwen27/cuda/seq_pool.zig": "88978229ebd42339041992ea489c4cdf82f7cf64ff99295039d8f75508b6ca95", + "zig/src/families/qwen27/cuda/seq_pool_test.zig": "362733783b4bd6e5f647eee93f6eab44c34bd94c136398c1c8bcfc382a0819ef", + "zig/src/families/qwen27/cuda/state.zig": "b0bb5a6d24c661b72909c1e4c9c89e1125971d01c17c8b2e22238cd5bfdf9caf" + }, + "stock_binary_sha256": "73a0e0434ce5adf3031a22fe2a70cbc9c671150464e4a6ecc4016b8defc12c8d", + "tested_client_source_sha256": { + "bench_concurrent.py": "1bdd080554bb236532843f5f9490db97fbfd414c8e8618b3c2a1b582fd66e882", + "bench_evidence.py": "119c396f24f3c13e181429bc69acff39f34254efd4789c5673a3dcbc54738d93", + "run_http.py": "97a3cfbdb5b5ae8f2b945abee6b245ae310876b57b1a4fa6183a7ef028348767" + } +} diff --git a/validation/pr608-three-way/qualification.json b/validation/pr608-three-way/qualification.json new file mode 100644 index 000000000..ecf0c19c9 --- /dev/null +++ b/validation/pr608-three-way/qualification.json @@ -0,0 +1,34 @@ +{ + "schema": "pr608_exact_cache_public_qualification_v1", + "sanitized": true, + "passed": true, + "source_receipt_sha256": "bd2778db23c4d4a69cf16b3792cf81b9197c2c3da3b5abac6a058b1500dea554", + "qualifier_source_sha256": "b6fe9373d6f6b0b9c24e08afb8e8feacd6d534005acc554fffb22c01566b47a3", + "qualification_binary_sha256": "ebbc73e0ffa97ee31b18ab6c426568a883ade108128278d246448bf4b96b4772", + "qualification_log_sha256": "dbee317d06bfc51c7c86529e337b644e341e3d758989c841556882bb643f0bfd", + "qualification_audit_sha256": "7053754523ed26f726d0c187ecbb3117985df026da9515f0018fc971add18186", + "source_pins_sha256": "a045512152eabdd1c8a21f3120b822a96f92a3caa0a603dc93c3a4d9eb6bd276", + "primitive_hashes_match_previous": true, + "integrated_snapshot_hash_matches_previous": true, + "reset_skip": { + "avoided_fill_bytes": 461832192, + "avoided_fill_calls": 288, + "failed_deferred_transactions": 0, + "fallback_resets": 1, + "fresh_poisoned_full_state_raw_and_continuation_equal": true, + "pooled_poisoned_full_state_raw_and_continuation_equal": true, + "positive_hint_actual_miss_reset_before_target": true, + "public_open_reset_domains_zero": true, + "reset_domain_bytes": 153944064, + "reset_domain_calls": 96, + "restored_fresh": 2, + "restored_pool": 1, + "schema": "pr608_exact_cache_reset_skip_v1" + }, + "earlier_state_gates": "Code 14 plain/drafted, chat 31 drafted, full-N packed target/draft/head state, immutable snapshot, 16 independent live owners, first/raw logits and direct 8-token continuation; target/draft reuse and cold cross-key Context poison gates.", + "limits": [ + "This is a sanitized gate attestation; the 968-line device checker and raw logs are not distributed here.", + "Direct 8-token continuation is not the full speculative verify/keep loop; HTTP evidence is separate.", + "Structural avoided-fill counters are not phase timing." + ] +} diff --git a/validation/pr608-three-way/requests-forward.jsonl b/validation/pr608-three-way/requests-forward.jsonl new file mode 100644 index 000000000..1fcb940f0 --- /dev/null +++ b/validation/pr608-three-way/requests-forward.jsonl @@ -0,0 +1,312 @@ +{"arm": "stock", "burst": null, "phase": "uncached_first_use", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 69.3467691433056, "done": 975126.447974348, "finish_reason": "length", "first": 975122.770757006, "full_response_s": 3.8202944709919393, "last": 975126.447929038, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975122.770757006, 2], [975122.851503848, 7], [975122.938646682, 4], [975123.022025547, 73], [975123.103975471, 51], [975123.18463352, 21], [975123.265277073, 14], [975123.345451815, 20], [975123.426185956, 16], [975123.507130167, 15], [975123.587146693, 23], [975123.667987437, 23], [975123.749076377, 25], [975123.829271104, 36], [975123.915213503, 14], [975123.999758496, 6], [975124.081207712, 18], [975124.161105817, 18], [975124.242148924, 19], [975124.322497424, 8], [975124.403212866, 11], [975124.483819946, 18], [975124.564260089, 15], [975124.644593902, 39], [975124.728300597, 30], [975124.808802434, 14], [975124.89512842, 15], [975124.979421589, 8], [975125.060731313, 6], [975125.1408701, 15], [975125.222137922, 23], [975125.303197625, 22], [975125.383721114, 26], [975125.464338662, 35], [975125.545281843, 31], [975125.626097718, 12], [975125.706763967, 13], [975125.788077723, 38], [975125.869684477, 47], [975125.956310535, 25], [975126.039310745, 11], [975126.120085699, 34], [975126.200703652, 12], [975126.282074146, 36], [975126.362841692, 60], [975126.447929038, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-1dc1ccd73308786375dad365c50f18a7", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.128234399, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 3.677510048, "time_to_first_token": 0.128742855, "token_sha": "2b28aa2108de", "tokens_per_second": 69.34039517816703}, "seed": 1234, "sent": 975122.627679877, "speculative": {"acceptance_rate": 0.31555555555555553, "accepted": 213, "drafted": 675, "rounds": 45, "tokens_per_round": 5.688888888888889}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.14307712903246284, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 213, "drafted": 675, "rounds": 45}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 69.31728211845895, "done": 975130.257618367, "finish_reason": "length", "first": 975126.578845552, "full_response_s": 3.8071185839362442, "last": 975130.257581824, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975126.578845552, 2], [975126.660108739, 7], [975126.744664061, 4], [975126.825653214, 73], [975126.911238766, 51], [975126.995206472, 21], [975127.076284857, 14], [975127.156475763, 20], [975127.237391915, 16], [975127.317852344, 15], [975127.398155117, 23], [975127.478591899, 23], [975127.55901521, 25], [975127.638969935, 36], [975127.720514266, 14], [975127.801333671, 6], [975127.884919128, 18], [975127.971242154, 18], [975128.052437963, 19], [975128.132717861, 8], [975128.213808442, 11], [975128.295738808, 18], [975128.376784688, 15], [975128.45702958, 39], [975128.537721667, 30], [975128.618093098, 14], [975128.700448708, 15], [975128.78246603, 8], [975128.863599557, 6], [975128.95036356, 15], [975129.032309003, 23], [975129.113370294, 22], [975129.194066322, 26], [975129.275473742, 35], [975129.356082702, 31], [975129.436719421, 12], [975129.517334957, 13], [975129.597693753, 38], [975129.678423748, 47], [975129.759544236, 25], [975129.840381716, 11], [975129.9269989, 34], [975130.010474277, 12], [975130.091692638, 36], [975130.171870855, 60], [975130.257581824, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-0576c5a0c7d050699925e2e950276c65", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.126677751, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 3.679306118, "time_to_first_token": 0.127276715, "token_sha": "2b28aa2108de", "tokens_per_second": 69.30654634918312}, "seed": 1234, "sent": 975126.450499783, "speculative": {"acceptance_rate": 0.31555555555555553, "accepted": 213, "drafted": 675, "rounds": 45, "tokens_per_round": 5.688888888888889}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12834576901514083, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 213, "drafted": 675, "rounds": 45}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 69.39164790811509, "done": 975134.070468786, "finish_reason": "length", "first": 975130.395644744, "full_response_s": 3.8016050670994446, "last": 975134.07043858, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975130.395644744, 2], [975130.476673146, 7], [975130.55808545, 4], [975130.638128426, 73], [975130.721329751, 51], [975130.802072406, 21], [975130.885031731, 14], [975130.971088962, 20], [975131.052291201, 16], [975131.133080419, 15], [975131.213051226, 23], [975131.294199708, 23], [975131.374604479, 25], [975131.454839083, 36], [975131.535454661, 14], [975131.615877383, 6], [975131.696722791, 18], [975131.777548183, 18], [975131.858304765, 19], [975131.945179259, 8], [975132.027965206, 11], [975132.109179785, 18], [975132.189432313, 15], [975132.270320571, 39], [975132.350823839, 30], [975132.431271893, 14], [975132.5121478, 15], [975132.592594943, 8], [975132.673235564, 6], [975132.756538463, 15], [975132.837214093, 23], [975132.923308564, 22], [975133.006891152, 26], [975133.088244449, 35], [975133.168802855, 31], [975133.250172696, 12], [975133.330709104, 13], [975133.411104173, 38], [975133.49169709, 47], [975133.572261208, 25], [975133.653121633, 11], [975133.734159521, 34], [975133.814738902, 12], [975133.900219263, 36], [975133.984412548, 60], [975134.07043858, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-e95e8244e18bc3e5f620e1654df31505", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.125313125, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 3.674926517, "time_to_first_token": 0.125806894, "token_sha": "2b28aa2108de", "tokens_per_second": 69.38914256390831}, "seed": 1234, "sent": 975130.268863719, "speculative": {"acceptance_rate": 0.31555555555555553, "accepted": 213, "drafted": 675, "rounds": 45, "tokens_per_round": 5.688888888888889}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12678102508652955, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 213, "drafted": 675, "rounds": 45}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 69.47421208284278, "done": 975137.882012912, "finish_reason": "length", "first": 975134.211534162, "full_response_s": 3.8000317589612678, "last": 975137.881960819, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975134.211534162, 2], [975134.292288004, 7], [975134.372519038, 4], [975134.453273696, 73], [975134.533743423, 51], [975134.614216094, 21], [975134.695211878, 14], [975134.778353866, 20], [975134.858864634, 16], [975134.946114199, 15], [975135.028532866, 23], [975135.109627081, 23], [975135.19004736, 25], [975135.270847045, 36], [975135.35165145, 14], [975135.432164332, 6], [975135.512462168, 18], [975135.592678647, 18], [975135.673297093, 19], [975135.754380349, 8], [975135.834791397, 11], [975135.92080768, 18], [975136.004382122, 15], [975136.085360556, 39], [975136.165837397, 30], [975136.247149271, 14], [975136.327741178, 15], [975136.408297903, 8], [975136.488615935, 6], [975136.569364955, 15], [975136.649670668, 23], [975136.733261734, 22], [975136.813597173, 26], [975136.898329328, 35], [975136.983874294, 31], [975137.065352421, 12], [975137.146037209, 13], [975137.227276276, 38], [975137.308088002, 47], [975137.388464116, 25], [975137.469056668, 11], [975137.549486092, 34], [975137.630069109, 12], [975137.71068494, 36], [975137.791907447, 60], [975137.881960819, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-a4d11ca76a50e0291de75c13fc21ae58", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.127907788, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 3.670932618, "time_to_first_token": 0.128408965, "token_sha": "2b28aa2108de", "tokens_per_second": 69.4646365203318}, "seed": 1234, "sent": 975134.081981153, "speculative": {"acceptance_rate": 0.31555555555555553, "accepted": 213, "drafted": 675, "rounds": 45, "tokens_per_round": 5.688888888888889}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1295530090574175, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 213, "drafted": 675, "rounds": 45}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.692429133794004, "done": 975148.450433405, "finish_reason": "length", "first": 975138.525284796, "full_response_s": 10.5617544290144, "last": 975148.450387583, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975138.525284796, 2], [975138.648012115, 7], [975138.800319539, 4], [975139.015999871, 63], [975139.24858796, 10], [975139.430576999, 31], [975139.611567634, 29], [975139.793837844, 22], [975139.982955415, 14], [975140.169193295, 24], [975140.346169484, 4], [975140.49335636, 13], [975140.673913378, 21], [975140.858796379, 2], [975141.048107666, 18], [975141.228841039, 29], [975141.460389779, 27], [975141.694284988, 22], [975141.877854668, 6], [975142.030161201, 16], [975142.212147568, 10], [975142.394916075, 31], [975142.542355901, 8], [975142.72746163, 11], [975142.91428156, 16], [975143.10093371, 12], [975143.283611688, 39], [975143.465990241, 18], [975143.646345253, 11], [975143.82805286, 16], [975144.01675408, 16], [975144.164433593, 11], [975144.345990593, 6], [975144.529750789, 9], [975144.713921911, 29], [975144.900668681, 22], [975145.088163087, 8], [975145.236471396, 18], [975145.418693657, 18], [975145.602613313, 34], [975145.78488186, 10], [975145.975161925, 14], [975146.161142683, 13], [975146.345087709, 2], [975146.526186847, 36], [975146.709556027, 42], [975146.897102799, 26], [975147.049668069, 17], [975147.233974513, 34], [975147.415261862, 12], [975147.599215362, 36], [975147.888150317, 50], [975148.076983113, 2], [975148.450387583, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-b9b41236588cf311b2a83a135090411d", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.421093845, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.925739429, "time_to_first_token": 0.631407481, "token_sha": "2b28aa2108de", "tokens_per_second": 25.690781208195666}, "seed": 1234, "sent": 975137.888678976, "speculative": {"acceptance_rate": 0.5638888888888889, "accepted": 203, "drafted": 360, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6366058200364932, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 360, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.693674250461815, "done": 975148.448334299, "finish_reason": "length", "first": 975138.523684389, "full_response_s": 10.560912818065844, "last": 975148.448306205, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975138.523684389, 2], [975138.650074661, 7], [975138.797735145, 4], [975139.015775097, 63], [975139.248108158, 10], [975139.429757836, 31], [975139.610567776, 29], [975139.794400474, 22], [975139.98206512, 14], [975140.167485981, 24], [975140.34578619, 4], [975140.492760483, 13], [975140.674742349, 21], [975140.857292863, 2], [975141.047528604, 18], [975141.228287256, 29], [975141.462886753, 27], [975141.692761218, 22], [975141.877723426, 6], [975142.030422757, 16], [975142.211622328, 10], [975142.395975595, 31], [975142.544258118, 8], [975142.72852387, 11], [975142.914683894, 16], [975143.101756521, 12], [975143.285120228, 39], [975143.46511964, 18], [975143.648420118, 11], [975143.828537398, 16], [975144.016654405, 16], [975144.16480676, 11], [975144.346537128, 6], [975144.529334952, 9], [975144.714756257, 29], [975144.901575616, 22], [975145.090522181, 8], [975145.237401194, 18], [975145.421200311, 18], [975145.603350015, 34], [975145.786991604, 10], [975145.976333056, 14], [975146.161642276, 13], [975146.345302099, 2], [975146.526486674, 36], [975146.709962633, 42], [975146.896749871, 26], [975147.049402545, 17], [975147.231840849, 34], [975147.417303129, 12], [975147.599479126, 36], [975147.887194489, 50], [975148.075885338, 2], [975148.448306205, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-4d47d7deeb7254809b724a6d83411326", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.42105175, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.925518623, "time_to_first_token": 0.633535305, "token_sha": "2b28aa2108de", "tokens_per_second": 25.691352732853563}, "seed": 1234, "sent": 975137.887421481, "speculative": {"acceptance_rate": 0.559228650137741, "accepted": 203, "drafted": 363, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6362629079958424, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 363, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.694864637385294, "done": 975148.449616769, "finish_reason": "length", "first": 975138.525430133, "full_response_s": 10.562041006982327, "last": 975148.449592163, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975138.525430133, 2], [975138.651474533, 7], [975138.800052111, 4], [975139.017281253, 63], [975139.247688433, 10], [975139.428473463, 31], [975139.61119226, 29], [975139.793965022, 22], [975139.983584251, 14], [975140.166461579, 24], [975140.347113585, 4], [975140.492359525, 13], [975140.674998145, 21], [975140.857938962, 2], [975141.047629159, 18], [975141.227682675, 29], [975141.462704042, 27], [975141.692563915, 22], [975141.878286809, 6], [975142.030048118, 16], [975142.211021987, 10], [975142.394016356, 31], [975142.541873955, 8], [975142.727376738, 11], [975142.915041621, 16], [975143.099405907, 12], [975143.28467012, 39], [975143.466840458, 18], [975143.649310574, 11], [975143.828794442, 16], [975144.017460592, 16], [975144.165793115, 11], [975144.348395844, 6], [975144.530124324, 9], [975144.71420793, 29], [975144.902350477, 22], [975145.088315976, 8], [975145.23818447, 18], [975145.422306629, 18], [975145.604590903, 34], [975145.785684655, 10], [975145.976382014, 14], [975146.16404252, 13], [975146.347526766, 2], [975146.527015802, 36], [975146.711527522, 42], [975146.898009462, 26], [975147.04897666, 17], [975147.232963631, 34], [975147.416900812, 12], [975147.599530372, 36], [975147.887091229, 50], [975148.076327526, 2], [975148.449592163, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-76458badf24ff7203d7a4d1a32565733", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.421094981, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.92580237, "time_to_first_token": 0.631512148, "token_sha": "2b28aa2108de", "tokens_per_second": 25.690618299102805}, "seed": 1234, "sent": 975137.887575762, "speculative": {"acceptance_rate": 0.5638888888888889, "accepted": 203, "drafted": 360, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6378543709870428, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 360, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.695131039905693, "done": 975148.448879171, "finish_reason": "length", "first": 975138.524791874, "full_response_s": 10.560737675055861, "last": 975148.448851012, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975138.524791874, 2], [975138.649919148, 7], [975138.800474044, 4], [975139.018644855, 63], [975139.247074621, 10], [975139.429412028, 31], [975139.611443896, 29], [975139.793353482, 22], [975139.982802462, 14], [975140.169122546, 24], [975140.346018979, 4], [975140.493133074, 13], [975140.674911221, 21], [975140.858566421, 2], [975141.047206283, 18], [975141.228933834, 29], [975141.460613913, 27], [975141.693850768, 22], [975141.87866692, 6], [975142.028876123, 16], [975142.212608523, 10], [975142.397044219, 31], [975142.543345072, 8], [975142.72839866, 11], [975142.91449395, 16], [975143.100269868, 12], [975143.283404738, 39], [975143.467644629, 18], [975143.649057785, 11], [975143.830563834, 16], [975144.017346406, 16], [975144.165034893, 11], [975144.346607701, 6], [975144.530060711, 9], [975144.713578854, 29], [975144.9009559, 22], [975145.087881292, 8], [975145.236145043, 18], [975145.421962021, 18], [975145.606311545, 34], [975145.785949955, 10], [975145.976743294, 14], [975146.161335314, 13], [975146.343751225, 2], [975146.526618572, 36], [975146.710493009, 42], [975146.897320005, 26], [975147.049054128, 17], [975147.232239119, 34], [975147.416398418, 12], [975147.599079816, 36], [975147.889605036, 50], [975148.076797169, 2], [975148.448851012, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-adfec8a231e3cb7fdd2c5c9c56101a0c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.421096053, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.925849775, "time_to_first_token": 0.631645631, "token_sha": "2b28aa2108de", "tokens_per_second": 25.690495602931893}, "seed": 1234, "sent": 975137.888141496, "speculative": {"acceptance_rate": 0.5654596100278552, "accepted": 203, "drafted": 359, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6366503780009225, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 359, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.6926887371028, "done": 975148.449551764, "finish_reason": "length", "first": 975138.524502912, "full_response_s": 10.56180682592094, "last": 975148.449505414, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975138.524502912, 2], [975138.648372739, 7], [975138.798466488, 4], [975139.017872682, 63], [975139.250088692, 10], [975139.429460042, 31], [975139.611969472, 29], [975139.794922306, 22], [975139.982225145, 14], [975140.168181469, 24], [975140.346424369, 4], [975140.492262666, 13], [975140.674463961, 21], [975140.858145032, 2], [975141.046921975, 18], [975141.228659367, 29], [975141.463461079, 27], [975141.693893886, 22], [975141.878189389, 6], [975142.030635467, 16], [975142.211394498, 10], [975142.396830436, 31], [975142.542656607, 8], [975142.727499501, 11], [975142.913881642, 16], [975143.09979693, 12], [975143.283206283, 39], [975143.466532216, 18], [975143.647297913, 11], [975143.829271157, 16], [975144.017063074, 16], [975144.165115162, 11], [975144.34747123, 6], [975144.531385195, 9], [975144.713398367, 29], [975144.901756856, 22], [975145.089500355, 8], [975145.237936177, 18], [975145.420370845, 18], [975145.601827812, 34], [975145.786859162, 10], [975145.975386731, 14], [975146.162212075, 13], [975146.344465081, 2], [975146.527370154, 36], [975146.71174308, 42], [975146.896559559, 26], [975147.04853532, 17], [975147.231697576, 34], [975147.415056687, 12], [975147.597764659, 36], [975147.889153072, 50], [975148.076251945, 2], [975148.449505414, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-5fa54d25954c36e0b66b50d9e01ec014", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.421092613, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.925704518, "time_to_first_token": 0.632585892, "token_sha": "2b28aa2108de", "tokens_per_second": 25.690871568619066}, "seed": 1234, "sent": 975137.887744938, "speculative": {"acceptance_rate": 0.5638888888888889, "accepted": 203, "drafted": 360, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6367579739307985, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 360, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.694430353153145, "done": 975148.450219926, "finish_reason": "length", "first": 975138.525860833, "full_response_s": 10.5627062729327, "last": 975148.4501906, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975138.525860833, 2], [975138.649366229, 7], [975138.800412527, 4], [975139.016375902, 63], [975139.247832843, 10], [975139.43029074, 31], [975139.610875586, 29], [975139.793085094, 22], [975139.983361541, 14], [975140.16513452, 24], [975140.3463481, 4], [975140.494117477, 13], [975140.675669458, 21], [975140.857876245, 2], [975141.04685697, 18], [975141.227826221, 29], [975141.463834358, 27], [975141.693223805, 22], [975141.878426307, 6], [975142.029634297, 16], [975142.21346266, 10], [975142.395772068, 31], [975142.541972206, 8], [975142.727055953, 11], [975142.914396787, 16], [975143.099916604, 12], [975143.282578599, 39], [975143.465473704, 18], [975143.648103157, 11], [975143.828465817, 16], [975144.016496108, 16], [975144.164120887, 11], [975144.345895125, 6], [975144.529075732, 9], [975144.713292867, 29], [975144.900808003, 22], [975145.088892702, 8], [975145.236020648, 18], [975145.422530363, 18], [975145.601960366, 34], [975145.789489827, 10], [975145.976023054, 14], [975146.162890124, 13], [975146.343446855, 2], [975146.527736697, 36], [975146.709895148, 42], [975146.898442194, 26], [975147.048626388, 17], [975147.233426746, 34], [975147.418009898, 12], [975147.598115556, 36], [975147.887416735, 50], [975148.076399699, 2], [975148.4501906, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-c025471b8e411d6197a8affdf9ed5492", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.421050006, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.925825601, "time_to_first_token": 0.633555303, "token_sha": "2b28aa2108de", "tokens_per_second": 25.690558171232574}, "seed": 1234, "sent": 975137.887513653, "speculative": {"acceptance_rate": 0.559228650137741, "accepted": 203, "drafted": 363, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6383471799781546, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 363, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.696252253771974, "done": 975148.449952834, "finish_reason": "length", "first": 975138.526311693, "full_response_s": 10.56184773601126, "last": 975148.449937811, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975138.526311693, 2], [975138.651363226, 7], [975138.799735534, 4], [975139.01825428, 63], [975139.246708718, 10], [975139.429560421, 31], [975139.612060604, 29], [975139.792875216, 22], [975139.983397907, 14], [975140.166697169, 24], [975140.346882556, 4], [975140.492055171, 13], [975140.673611616, 21], [975140.857624544, 2], [975141.046620229, 18], [975141.227525371, 29], [975141.463519284, 27], [975141.693398213, 22], [975141.878773683, 6], [975142.028753889, 16], [975142.212345367, 10], [975142.395472434, 31], [975142.543616324, 8], [975142.728161838, 11], [975142.915491009, 16], [975143.101569857, 12], [975143.284307337, 39], [975143.467831661, 18], [975143.646943065, 11], [975143.828272418, 16], [975144.016963943, 16], [975144.16492461, 11], [975144.34681422, 6], [975144.531238034, 9], [975144.714380482, 29], [975144.901071111, 22], [975145.089838067, 8], [975145.236871746, 18], [975145.419844773, 18], [975145.606638234, 34], [975145.786554648, 10], [975145.975827847, 14], [975146.161403695, 13], [975146.345688961, 2], [975146.526740342, 36], [975146.710107602, 42], [975146.898268218, 26], [975147.049329204, 17], [975147.232552737, 34], [975147.4154723, 12], [975147.597628138, 36], [975147.887050895, 50], [975148.076607929, 2], [975148.449937811, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-bbce2bd2115e47fd0a6be13270cff674", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.421053094, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.925837152, "time_to_first_token": 0.633733263, "token_sha": "2b28aa2108de", "tokens_per_second": 25.690528274344995}, "seed": 1234, "sent": 975137.888105098, "speculative": {"acceptance_rate": 0.559228650137741, "accepted": 203, "drafted": 363, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6382065949728712, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 363, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.6872055827797, "done": 975148.450636052, "finish_reason": "length", "first": 975138.523457487, "full_response_s": 10.562970725935884, "last": 975148.450578566, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975138.523457487, 2], [975138.648751202, 7], [975138.799956436, 4], [975139.017382784, 63], [975139.248950904, 10], [975139.430122139, 31], [975139.612098186, 29], [975139.794662238, 22], [975139.982717858, 14], [975140.166277524, 24], [975140.347644873, 4], [975140.492652488, 13], [975140.674518247, 21], [975140.85833208, 2], [975141.047371171, 18], [975141.228572507, 29], [975141.45997831, 27], [975141.692660806, 22], [975141.878967386, 6], [975142.029541629, 16], [975142.213397655, 10], [975142.394613945, 31], [975142.544706466, 8], [975142.727928185, 11], [975142.914043443, 16], [975143.100837026, 12], [975143.282457149, 39], [975143.464754905, 18], [975143.647572973, 11], [975143.828134264, 16], [975144.016404592, 16], [975144.164488086, 11], [975144.348299416, 6], [975144.530347498, 9], [975144.71318348, 29], [975144.900876384, 22], [975145.089193345, 8], [975145.238768492, 18], [975145.420110393, 18], [975145.605438385, 34], [975145.78508577, 10], [975145.975533844, 14], [975146.160939684, 13], [975146.346500429, 2], [975146.527608239, 36], [975146.709323525, 42], [975146.896803548, 26], [975147.048473579, 17], [975147.232460853, 34], [975147.414879255, 12], [975147.597889214, 36], [975147.887457581, 50], [975148.076111808, 2], [975148.450578566, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-e32d980a8d8f4b9befbcc5796b7cf37c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.421046135, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.925762963, "time_to_first_token": 0.633187128, "token_sha": "2b28aa2108de", "tokens_per_second": 25.690720295311973}, "seed": 1234, "sent": 975137.887665326, "speculative": {"acceptance_rate": 0.5561643835616439, "accepted": 203, "drafted": 365, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6357921609887853, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 365, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.69416024200489, "done": 975148.448642669, "finish_reason": "length", "first": 975138.52417635, "full_response_s": 10.560231073061004, "last": 975148.448610447, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975138.52417635, 2], [975138.649245803, 7], [975138.799323697, 4], [975139.01708019, 63], [975139.247980724, 10], [975139.428404794, 31], [975139.611387419, 29], [975139.794728875, 22], [975139.982139068, 14], [975140.166561735, 24], [975140.346583514, 4], [975140.493230942, 13], [975140.675038463, 21], [975140.857554243, 2], [975141.048389685, 18], [975141.228054515, 29], [975141.460522253, 27], [975141.693513359, 22], [975141.87871215, 6], [975142.02983016, 16], [975142.212783427, 10], [975142.395358167, 31], [975142.542763114, 8], [975142.72865308, 11], [975142.914543292, 16], [975143.100640955, 12], [975143.285765879, 39], [975143.467031121, 18], [975143.647223389, 11], [975143.829222663, 16], [975144.017405763, 16], [975144.165238356, 11], [975144.347790911, 6], [975144.531746267, 9], [975144.713873193, 29], [975144.90298184, 22], [975145.08859126, 8], [975145.238119881, 18], [975145.421021183, 18], [975145.605113728, 34], [975145.786455996, 10], [975145.975635952, 14], [975146.160611651, 13], [975146.34739402, 2], [975146.528226275, 36], [975146.710586748, 42], [975146.898122641, 26], [975147.049294374, 17], [975147.233675038, 34], [975147.418367161, 12], [975147.598255197, 36], [975147.888221786, 50], [975148.076045459, 2], [975148.448610447, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-ae1233ab34d32ce377f8010834f151cb", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.421049831, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.925614202, "time_to_first_token": 0.633474171, "token_sha": "2b28aa2108de", "tokens_per_second": 25.691105337200973}, "seed": 1234, "sent": 975137.888411596, "speculative": {"acceptance_rate": 0.5623268698060941, "accepted": 203, "drafted": 361, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6357647540280595, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 361, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.69424619135252, "done": 975148.449173813, "finish_reason": "length", "first": 975138.524726421, "full_response_s": 10.560637839022093, "last": 975148.44912732, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975138.524726421, 2], [975138.65153605, 7], [975138.798319918, 4], [975139.016512728, 63], [975139.247428861, 10], [975139.429049516, 31], [975139.611921058, 29], [975139.794868645, 22], [975139.983463872, 14], [975140.165467929, 24], [975140.347257179, 4], [975140.493603421, 13], [975140.674962115, 21], [975140.858077611, 2], [975141.046165386, 18], [975141.227441134, 29], [975141.462799109, 27], [975141.692868733, 22], [975141.878086226, 6], [975142.030108131, 16], [975142.212729365, 10], [975142.394164558, 31], [975142.543469882, 8], [975142.726970997, 11], [975142.915244444, 16], [975143.101658781, 12], [975143.2837161, 39], [975143.466444716, 18], [975143.647070756, 11], [975143.828722302, 16], [975144.017563212, 16], [975144.166162266, 11], [975144.34737605, 6], [975144.529921549, 9], [975144.714441599, 29], [975144.901248015, 22], [975145.09133448, 8], [975145.23590139, 18], [975145.419294605, 18], [975145.602156085, 34], [975145.789319467, 10], [975145.976444107, 14], [975146.164354666, 13], [975146.344542501, 2], [975146.52851615, 36], [975146.709846142, 42], [975146.89686449, 26], [975147.049195674, 17], [975147.233146982, 34], [975147.418267038, 12], [975147.598167633, 36], [975147.889077988, 50], [975148.077365767, 2], [975148.44912732, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-2b5dbd39ee007adb1067df66f1ef6554", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.421091413, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.925678104, "time_to_first_token": 0.632255507, "token_sha": "2b28aa2108de", "tokens_per_second": 25.69093993661111}, "seed": 1234, "sent": 975137.888535974, "speculative": {"acceptance_rate": 0.5638888888888889, "accepted": 203, "drafted": 360, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.636190447025001, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 360, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.45530077305952, "done": 975148.448259263, "finish_reason": "length", "first": 975138.021010816, "full_response_s": 10.560407785931602, "last": 975148.448198049, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975138.021010816, 2], [975138.102878051, 7], [975138.649467009, 4], [975138.799183239, 72], [975139.01746694, 1], [975139.247911911, 27], [975139.428153109, 30], [975139.612430539, 15], [975139.793907537, 14], [975139.982679684, 20], [975140.165771595, 14], [975140.347598875, 4], [975140.492182109, 13], [975140.673761017, 21], [975140.85737006, 2], [975141.0458446, 18], [975141.227275062, 29], [975141.460465856, 27], [975141.692450896, 22], [975141.87862297, 6], [975142.028981558, 16], [975142.212974026, 10], [975142.395235245, 31], [975142.542104856, 8], [975142.726768638, 11], [975142.913947575, 16], [975143.101411144, 12], [975143.282349554, 39], [975143.464539682, 18], [975143.646240633, 11], [975143.829311859, 16], [975144.016347299, 16], [975144.165690208, 11], [975144.347317973, 6], [975144.531146374, 9], [975144.713096012, 29], [975144.90030225, 22], [975145.087669814, 8], [975145.236630157, 18], [975145.420667087, 18], [975145.605949338, 34], [975145.785345535, 10], [975145.976484985, 14], [975146.163301785, 13], [975146.343305165, 2], [975146.526275579, 36], [975146.710019958, 42], [975146.898069267, 26], [975147.049260935, 17], [975147.233042235, 34], [975147.415184873, 12], [975147.598561727, 36], [975147.88712278, 50], [975148.077111155, 2], [975148.448198049, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-11c821c592017511e827e990b328a72a", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.130766008, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.427616814, "time_to_first_token": 0.131465465, "token_sha": "2b28aa2108de", "tokens_per_second": 24.45429330100046}, "seed": 1234, "sent": 975137.887851477, "speculative": {"acceptance_rate": 0.5489130434782609, "accepted": 202, "drafted": 368, "rounds": 54, "tokens_per_round": 4.7407407407407405}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1331593389622867, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 202, "drafted": 368, "rounds": 54}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.685174522736368, "done": 975148.452436418, "finish_reason": "length", "first": 975138.524353718, "full_response_s": 10.56418031908106, "last": 975148.452259786, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975138.524353718, 2], [975138.651630238, 7], [975138.799563974, 4], [975139.018467743, 63], [975139.24920694, 10], [975139.428336317, 31], [975139.611031451, 29], [975139.794800328, 22], [975139.983518318, 14], [975140.166059518, 24], [975140.347422163, 4], [975140.493869361, 13], [975140.673866133, 21], [975140.8577075, 2], [975141.045959539, 18], [975141.227611383, 29], [975141.464022318, 27], [975141.694220383, 22], [975141.879095284, 6], [975142.029770227, 16], [975142.212070723, 10], [975142.396373241, 31], [975142.542246866, 8], [975142.727568857, 11], [975142.913677971, 16], [975143.100726055, 12], [975143.282703826, 39], [975143.467241272, 18], [975143.647401701, 11], [975143.829923863, 16], [975144.016559145, 16], [975144.164262496, 11], [975144.34619452, 6], [975144.531083465, 9], [975144.713486507, 29], [975144.900459619, 22], [975145.087316374, 8], [975145.23721949, 18], [975145.41893595, 18], [975145.603707791, 34], [975145.787843901, 10], [975145.977445774, 14], [975146.162530012, 13], [975146.345632292, 2], [975146.526806195, 36], [975146.71111178, 42], [975146.896395855, 26], [975147.048140426, 17], [975147.232905233, 34], [975147.415953766, 12], [975147.59942676, 36], [975147.889214733, 50], [975148.075957191, 2], [975148.452259786, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-5e8947e198b6a4161564af57f403f672", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.421099828, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.929563593, "time_to_first_token": 0.630306203, "token_sha": "2b28aa2108de", "tokens_per_second": 25.680886940465967}, "seed": 1234, "sent": 975137.888256099, "speculative": {"acceptance_rate": 0.5654596100278552, "accepted": 203, "drafted": 359, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6360976190771908, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 359, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.690539080148387, "done": 975148.449914996, "finish_reason": "length", "first": 975138.524033461, "full_response_s": 10.561927285045385, "last": 975148.449866438, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975138.524033461, 2], [975138.649110465, 7], [975138.798931635, 4], [975139.018073297, 63], [975139.249532589, 10], [975139.428923506, 31], [975139.61073684, 29], [975139.794219363, 22], [975139.982875147, 14], [975140.165376077, 24], [975140.346772641, 4], [975140.493276396, 13], [975140.675437165, 21], [975140.857815223, 2], [975141.046281669, 18], [975141.228602794, 29], [975141.461015159, 27], [975141.693079843, 22], [975141.877801839, 6], [975142.02986499, 16], [975142.211906139, 10], [975142.395562494, 31], [975142.542914276, 8], [975142.72917288, 11], [975142.914101312, 16], [975143.10044114, 12], [975143.283536524, 39], [975143.467145772, 18], [975143.64745101, 11], [975143.82839998, 16], [975144.017620345, 16], [975144.164861541, 11], [975144.346501594, 6], [975144.532145737, 9], [975144.714029698, 29], [975144.901175138, 22], [975145.090181972, 8], [975145.236548432, 18], [975145.419400585, 18], [975145.60398845, 34], [975145.786383728, 10], [975145.975934162, 14], [975146.161784062, 13], [975146.345045903, 2], [975146.527673388, 36], [975146.71104428, 42], [975146.896242918, 26], [975147.048272132, 17], [975147.233507286, 34], [975147.417795779, 12], [975147.598459796, 36], [975147.888953001, 50], [975148.077154017, 2], [975148.449866438, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-af3d44edbc5c27112cf3d148f1b63107", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.421093349, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.925910013, "time_to_first_token": 0.633317443, "token_sha": "2b28aa2108de", "tokens_per_second": 25.690339693390893}, "seed": 1234, "sent": 975137.887987711, "speculative": {"acceptance_rate": 0.5638888888888889, "accepted": 203, "drafted": 360, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6360457499977201, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 360, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.694499201076656, "done": 975148.448432183, "finish_reason": "length", "first": 975138.524086882, "full_response_s": 10.5605265799677, "last": 975148.448390057, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975138.524086882, 2], [975138.649617178, 7], [975138.798208772, 4], [975139.018380003, 63], [975139.24658818, 10], [975139.428066905, 31], [975139.612503448, 29], [975139.794558371, 22], [975139.982290726, 14], [975140.1685635, 24], [975140.346269448, 4], [975140.492514942, 13], [975140.673987487, 21], [975140.857743387, 2], [975141.04854131, 18], [975141.227194522, 29], [975141.46067575, 27], [975141.693972651, 22], [975141.87812384, 6], [975142.029464304, 16], [975142.212845344, 10], [975142.394484815, 31], [975142.544918824, 8], [975142.729516609, 11], [975142.913556825, 16], [975143.099244459, 12], [975143.284224461, 39], [975143.464657805, 18], [975143.647845936, 11], [975143.829612773, 16], [975144.016288134, 16], [975144.16435598, 11], [975144.348221228, 6], [975144.529665833, 9], [975144.71433418, 29], [975144.901685579, 22], [975145.088091603, 8], [975145.238698767, 18], [975145.422595704, 18], [975145.603050189, 34], [975145.786036143, 10], [975145.97491864, 14], [975146.160244244, 13], [975146.3443124, 2], [975146.527979294, 36], [975146.709638519, 42], [975146.89667237, 26], [975147.049134285, 17], [975147.234054845, 34], [975147.415639205, 12], [975147.599030826, 36], [975147.887676355, 50], [975148.07687115, 2], [975148.448390057, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-11928b026c07a3423c0699f9de0bd8ab", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.421050598, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.925675224, "time_to_first_token": 0.633016096, "token_sha": "2b28aa2108de", "tokens_per_second": 25.690947391006432}, "seed": 1234, "sent": 975137.887905603, "speculative": {"acceptance_rate": 0.559228650137741, "accepted": 203, "drafted": 363, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6361812789691612, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 363, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.69247804853747, "done": 975148.450257717, "finish_reason": "length", "first": 975138.525158274, "full_response_s": 10.562316692085005, "last": 975148.450242165, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975138.525158274, 2], [975138.650698777, 7], [975138.7985589, 4], [975139.016969523, 63], [975139.248502332, 10], [975139.428586513, 31], [975139.612003487, 29], [975139.793189586, 22], [975139.981959621, 14], [975140.165643489, 24], [975140.347384373, 4], [975140.493321226, 13], [975140.674353822, 21], [975140.858019246, 2], [975141.046750223, 18], [975141.228335686, 29], [975141.463909011, 27], [975141.69315544, 22], [975141.877618503, 6], [975142.029070866, 16], [975142.212232316, 10], [975142.396216192, 31], [975142.543029102, 8], [975142.726878953, 11], [975142.913750144, 16], [975143.100190848, 12], [975143.284094355, 39], [975143.465015789, 18], [975143.647744549, 11], [975143.829566119, 16], [975144.017148943, 16], [975144.165301377, 11], [975144.34644934, 6], [975144.532661361, 9], [975144.714269143, 29], [975144.902057578, 22], [975145.089708777, 8], [975145.237699292, 18], [975145.42088327, 18], [975145.602840998, 34], [975145.788701958, 10], [975145.975889188, 14], [975146.162823871, 13], [975146.343877683, 2], [975146.527092902, 36], [975146.709219578, 42], [975146.897633511, 26], [975147.048386207, 17], [975147.233722796, 34], [975147.416668118, 12], [975147.598941326, 36], [975147.889435059, 50], [975148.076571899, 2], [975148.450242165, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-7d66204baeaad0b96f84f76a65d2fee7", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.421053622, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.925607355, "time_to_first_token": 0.633345169, "token_sha": "2b28aa2108de", "tokens_per_second": 25.69112305974348}, "seed": 1234, "sent": 975137.887941025, "speculative": {"acceptance_rate": 0.5623268698060941, "accepted": 203, "drafted": 361, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6372172490227968, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 361, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.690282874416166, "done": 975148.4513349, "finish_reason": "length", "first": 975138.525369064, "full_response_s": 10.563979975995608, "last": 975148.45130103, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975138.525369064, 2], [975138.650000089, 7], [975138.797963999, 4], [975139.017996708, 63], [975139.248832269, 10], [975139.428241137, 31], [975139.610951567, 29], [975139.793612734, 22], [975139.982402592, 14], [975140.167148108, 24], [975140.347341607, 4], [975140.493978844, 13], [975140.675259253, 21], [975140.858467322, 2], [975141.047797216, 18], [975141.227760576, 29], [975141.461114866, 27], [975141.693463906, 22], [975141.878375397, 6], [975142.030249021, 16], [975142.211206107, 10], [975142.396733145, 31], [975142.544102365, 8], [975142.728700982, 11], [975142.914836399, 16], [975143.099644376, 12], [975143.285487715, 39], [975143.465580867, 18], [975143.647652569, 11], [975143.829665571, 16], [975144.017518654, 16], [975144.164767306, 11], [975144.347162316, 6], [975144.529986395, 9], [975144.714478814, 29], [975144.902814728, 22], [975145.091064908, 8], [975145.238437403, 18], [975145.421143274, 18], [975145.602909475, 34], [975145.786303155, 10], [975145.977175034, 14], [975146.163574365, 13], [975146.346063105, 2], [975146.526924974, 36], [975146.711307788, 42], [975146.897761985, 26], [975147.048883944, 17], [975147.232367882, 34], [975147.416596393, 12], [975147.598076629, 36], [975147.887795581, 50], [975148.077241389, 2], [975148.45130103, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8155d2f1746c54edeb52c02ec4e6dc8d", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.421099061, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.926345802, "time_to_first_token": 0.631638927, "token_sha": "2b28aa2108de", "tokens_per_second": 25.68921182945506}, "seed": 1234, "sent": 975137.887354924, "speculative": {"acceptance_rate": 0.5654596100278552, "accepted": 203, "drafted": 359, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6380141399567947, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 359, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.607612197613413, "done": 975159.087128412, "finish_reason": "length", "first": 975149.12913038, "full_response_s": 10.62007119692862, "last": 975159.087106861, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975149.12913038, 2], [975149.286059887, 7], [975149.43421395, 4], [975149.646468885, 63], [975149.880377872, 10], [975150.070456746, 31], [975150.254847139, 29], [975150.434954844, 22], [975150.616525828, 14], [975150.800017254, 24], [975150.991514522, 4], [975151.135736394, 13], [975151.318824553, 21], [975151.503618203, 2], [975151.68468738, 18], [975151.866686518, 29], [975152.108744266, 27], [975152.345700658, 24], [975152.495666825, 4], [975152.643852224, 16], [975152.826866013, 10], [975153.018982221, 31], [975153.165599875, 8], [975153.351348639, 11], [975153.535187538, 16], [975153.717800203, 12], [975153.902885866, 39], [975154.092417592, 18], [975154.274797543, 11], [975154.45666358, 16], [975154.639176404, 16], [975154.788430429, 11], [975154.979029093, 6], [975155.161352672, 9], [975155.345327426, 29], [975155.529832667, 22], [975155.710133105, 8], [975155.856387691, 18], [975156.04706958, 18], [975156.230465746, 34], [975156.415670503, 10], [975156.599523513, 14], [975156.783721627, 13], [975156.974272539, 2], [975157.160797425, 36], [975157.342715427, 42], [975157.527923827, 26], [975157.677880214, 17], [975157.859013039, 34], [975158.053463294, 12], [975158.233159806, 36], [975158.520758986, 50], [975158.705256468, 2], [975159.087106861, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-1942bdae38abf7e1deb84ec7bbaeb852", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.449419476, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.958437467, "time_to_first_token": 0.658900813, "token_sha": "2b28aa2108de", "tokens_per_second": 25.60642679587155}, "seed": 1234, "sent": 975148.467057215, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6620731649454683, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.608616712240142, "done": 975159.087407407, "finish_reason": "length", "first": 975149.127517669, "full_response_s": 10.620478890021332, "last": 975159.085103542, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975149.127517669, 2], [975149.290090522, 7], [975149.434995082, 4], [975149.646698234, 63], [975149.880278309, 10], [975150.071039055, 31], [975150.253507455, 29], [975150.43380464, 22], [975150.616089464, 14], [975150.80076546, 24], [975150.990438394, 4], [975151.135806023, 13], [975151.319196488, 21], [975151.503105074, 2], [975151.684416192, 18], [975151.866023924, 29], [975152.10904558, 27], [975152.348685196, 24], [975152.498438349, 4], [975152.64225284, 16], [975152.830336706, 10], [975153.017309848, 31], [975153.165957715, 8], [975153.349303387, 11], [975153.535067991, 16], [975153.716404729, 12], [975153.904170769, 39], [975154.093249683, 18], [975154.275323055, 11], [975154.458176712, 16], [975154.638724808, 16], [975154.788381023, 11], [975154.978774384, 6], [975155.164730169, 9], [975155.344622385, 29], [975155.527319756, 22], [975155.707729437, 8], [975155.855664972, 18], [975156.048651205, 18], [975156.231307836, 34], [975156.416077381, 10], [975156.599436813, 14], [975156.784362031, 13], [975156.97422563, 2], [975157.158448457, 36], [975157.342516428, 42], [975157.529310645, 26], [975157.677203141, 17], [975157.858606081, 34], [975158.054746357, 12], [975158.232296356, 36], [975158.521315921, 50], [975158.704288879, 2], [975159.085103542, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-e393e384234728b7743f1a20d72eae7b", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.449413573, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.957954208, "time_to_first_token": 0.659307225, "token_sha": "2b28aa2108de", "tokens_per_second": 25.607669474432672}, "seed": 1234, "sent": 975148.466928517, "speculative": {"acceptance_rate": 0.5561643835616439, "accepted": 203, "drafted": 365, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6605891520157456, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 365, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.603345245619455, "done": 975159.088049715, "finish_reason": "length", "first": 975149.128379854, "full_response_s": 10.62106689705979, "last": 975159.088015892, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975149.128379854, 2], [975149.286504715, 7], [975149.435876179, 4], [975149.646545537, 63], [975149.880182441, 10], [975150.07191044, 31], [975150.253127584, 29], [975150.433910571, 22], [975150.61763613, 14], [975150.80058478, 24], [975150.990526838, 4], [975151.135924818, 13], [975151.319522697, 21], [975151.501555351, 2], [975151.683953557, 18], [975151.865959735, 29], [975152.10816362, 27], [975152.34609392, 24], [975152.496028281, 4], [975152.643734421, 16], [975152.827247372, 10], [975153.018242926, 31], [975153.165504887, 8], [975153.352123069, 11], [975153.532577479, 16], [975153.717061772, 12], [975153.903236347, 39], [975154.09136372, 18], [975154.274420551, 11], [975154.456274429, 16], [975154.639018763, 16], [975154.788088908, 11], [975154.980604878, 6], [975155.161028991, 9], [975155.344921316, 29], [975155.529145018, 22], [975155.70947899, 8], [975155.857130778, 18], [975156.048450142, 18], [975156.230376854, 34], [975156.414677476, 10], [975156.598179621, 14], [975156.784952708, 13], [975156.974105747, 2], [975157.159216119, 36], [975157.341860633, 42], [975157.526340842, 26], [975157.674752322, 17], [975157.86051278, 34], [975158.051288239, 12], [975158.233267433, 36], [975158.519957246, 50], [975158.705450156, 2], [975159.088015892, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-fb094a306de0efbea5efe9c43e012e03", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.449416756, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.958243604, "time_to_first_token": 0.659605692, "token_sha": "2b28aa2108de", "tokens_per_second": 25.606925291280515}, "seed": 1234, "sent": 975148.466982818, "speculative": {"acceptance_rate": 0.559228650137741, "accepted": 203, "drafted": 363, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6613970360485837, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 363, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.610292013454334, "done": 975159.087957671, "finish_reason": "length", "first": 975149.130984456, "full_response_s": 10.620238870033063, "last": 975159.087918952, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975149.130984456, 2], [975149.289376362, 7], [975149.438174459, 4], [975149.64622776, 63], [975149.880023024, 10], [975150.070536454, 31], [975150.25361201, 29], [975150.434123042, 22], [975150.618214488, 14], [975150.802478199, 24], [975150.99088087, 4], [975151.135686605, 13], [975151.319033151, 21], [975151.501964869, 2], [975151.684146812, 18], [975151.866529517, 29], [975152.109857848, 27], [975152.346296535, 24], [975152.495721398, 4], [975152.644477796, 16], [975152.828759609, 10], [975153.018010552, 31], [975153.166106876, 8], [975153.350163316, 11], [975153.532191896, 16], [975153.71656997, 12], [975153.903886062, 39], [975154.093026221, 18], [975154.275277841, 11], [975154.455924861, 16], [975154.639382107, 16], [975154.788902136, 11], [975154.979191902, 6], [975155.16274285, 9], [975155.344261553, 29], [975155.525979272, 22], [975155.708542808, 8], [975155.858051969, 18], [975156.046970512, 18], [975156.231238656, 34], [975156.416026503, 10], [975156.598470888, 14], [975156.787909072, 13], [975156.973557563, 2], [975157.160089008, 36], [975157.343499584, 42], [975157.526553824, 26], [975157.676769304, 17], [975157.861067971, 34], [975158.051766905, 12], [975158.232828653, 36], [975158.521194295, 50], [975158.704348317, 2], [975159.087918952, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-d7a983db22ab550f87678abc73f9aad4", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.449407237, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.958267234, "time_to_first_token": 0.659855937, "token_sha": "2b28aa2108de", "tokens_per_second": 25.606864528536313}, "seed": 1234, "sent": 975148.467718801, "speculative": {"acceptance_rate": 0.553133514986376, "accepted": 203, "drafted": 367, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6632656550500542, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 367, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.60984252007139, "done": 975159.087869675, "finish_reason": "length", "first": 975149.130736212, "full_response_s": 10.62044369301293, "last": 975159.087845468, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975149.130736212, 2], [975149.287095233, 7], [975149.435966783, 4], [975149.649105086, 63], [975149.880650724, 10], [975150.069535411, 31], [975150.254024808, 29], [975150.435567873, 22], [975150.618935624, 14], [975150.801173074, 24], [975150.99008985, 4], [975151.136562965, 13], [975151.321263339, 21], [975151.500797129, 2], [975151.685280409, 18], [975151.865493676, 29], [975152.109151127, 27], [975152.345386352, 24], [975152.495415508, 4], [975152.642851453, 16], [975152.82744514, 10], [975153.018596862, 31], [975153.166432862, 8], [975153.350626336, 11], [975153.533742882, 16], [975153.717734206, 12], [975153.903654488, 39], [975154.093740317, 18], [975154.274111717, 11], [975154.456544769, 16], [975154.641261879, 16], [975154.788297427, 11], [975154.978689988, 6], [975155.161479147, 9], [975155.345039103, 29], [975155.527650461, 22], [975155.710447667, 8], [975155.858327893, 18], [975156.048265431, 18], [975156.231473189, 34], [975156.414740449, 10], [975156.599024447, 14], [975156.785938728, 13], [975156.974985996, 2], [975157.159508122, 36], [975157.341207958, 42], [975157.528928198, 26], [975157.67645631, 17], [975157.861776004, 34], [975158.050862786, 12], [975158.234177729, 36], [975158.520864885, 50], [975158.705391246, 2], [975159.087845468, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-bb22c247dec567671c083deb8d8f1a3d", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.449422853, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.95795288, "time_to_first_token": 0.658082369, "token_sha": "2b28aa2108de", "tokens_per_second": 25.607672889490512}, "seed": 1234, "sent": 975148.467425982, "speculative": {"acceptance_rate": 0.5623268698060941, "accepted": 203, "drafted": 361, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6633102300111204, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 361, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.604628346550875, "done": 975159.08706859, "finish_reason": "length", "first": 975149.127894132, "full_response_s": 10.619915907038376, "last": 975159.087031072, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975149.127894132, 2], [975149.28643739, 7], [975149.437907959, 4], [975149.648288931, 63], [975149.881869005, 10], [975150.071715121, 31], [975150.25454984, 29], [975150.43625349, 22], [975150.615627773, 14], [975150.801609966, 24], [975150.989934209, 4], [975151.135387018, 13], [975151.319983077, 21], [975151.502288454, 2], [975151.683804187, 18], [975151.866369028, 29], [975152.10881679, 27], [975152.346206203, 24], [975152.497276913, 4], [975152.64247099, 16], [975152.826485807, 10], [975153.019939346, 31], [975153.165234179, 8], [975153.349956622, 11], [975153.53311747, 16], [975153.717486329, 12], [975153.904624109, 39], [975154.093821098, 18], [975154.275778075, 11], [975154.456743416, 16], [975154.640502697, 16], [975154.788977812, 11], [975154.978207162, 6], [975155.161672706, 9], [975155.344170933, 29], [975155.526953676, 22], [975155.708866394, 8], [975155.857905383, 18], [975156.048027265, 18], [975156.23073583, 34], [975156.416314171, 10], [975156.598962306, 14], [975156.788252065, 13], [975156.97520653, 2], [975157.158103225, 36], [975157.341573398, 42], [975157.525549133, 26], [975157.677296032, 17], [975157.859212422, 34], [975158.051410089, 12], [975158.232591495, 36], [975158.52012719, 50], [975158.706237481, 2], [975159.087031072, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8055a10e943ed242513f61dd2fe266fc", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.449415604, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.958011582, "time_to_first_token": 0.659004647, "token_sha": "2b28aa2108de", "tokens_per_second": 25.60752193348875}, "seed": 1234, "sent": 975148.467152683, "speculative": {"acceptance_rate": 0.5561643835616439, "accepted": 203, "drafted": 365, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6607414491008967, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 365, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.613911051103894, "done": 975159.085707227, "finish_reason": "length", "first": 975149.130146302, "full_response_s": 10.61851540999487, "last": 975159.085673964, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975149.130146302, 2], [975149.286979526, 7], [975149.434706167, 4], [975149.64585648, 63], [975149.880332002, 10], [975150.071444621, 31], [975150.255325965, 29], [975150.433288951, 22], [975150.615803269, 14], [975150.801021593, 24], [975150.989258575, 4], [975151.136315328, 13], [975151.320460671, 21], [975151.502080816, 2], [975151.684540874, 18], [975151.866466864, 29], [975152.10963149, 27], [975152.345598806, 24], [975152.494449392, 4], [975152.643922445, 16], [975152.83095103, 10], [975153.019608993, 31], [975153.166365617, 8], [975153.35112009, 11], [975153.532019376, 16], [975153.716893363, 12], [975153.903467664, 39], [975154.090963274, 18], [975154.27432886, 11], [975154.45558398, 16], [975154.640223925, 16], [975154.789514668, 11], [975154.980110149, 6], [975155.164274462, 9], [975155.345593878, 29], [975155.525829246, 22], [975155.709123598, 8], [975155.856473143, 18], [975156.048849469, 18], [975156.231631214, 34], [975156.415177901, 10], [975156.599680098, 14], [975156.786715686, 13], [975156.97543236, 2], [975157.162190675, 36], [975157.342270535, 42], [975157.525677319, 26], [975157.675560878, 17], [975157.860866204, 34], [975158.051967696, 12], [975158.23396217, 36], [975158.52053274, 50], [975158.705562135, 2], [975159.085673964, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-836c2266e6cf35f1736d6a74fd2d868a", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.449426676, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.958019533, "time_to_first_token": 0.658681574, "token_sha": "2b28aa2108de", "tokens_per_second": 25.607501487113222}, "seed": 1234, "sent": 975148.467191817, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6629544850438833, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.613947273865865, "done": 975159.086846728, "finish_reason": "length", "first": 975149.12960767, "full_response_s": 10.619361068005674, "last": 975159.085121253, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975149.12960767, 2], [975149.285866824, 7], [975149.432756943, 4], [975149.646361578, 63], [975149.880492363, 10], [975150.07094826, 31], [975150.254345017, 29], [975150.433701333, 22], [975150.618589096, 14], [975150.801687883, 24], [975150.989118614, 4], [975151.135851797, 13], [975151.319377696, 21], [975151.501895736, 2], [975151.683119706, 18], [975151.865330323, 29], [975152.108638974, 27], [975152.347067444, 24], [975152.496276702, 4], [975152.644550145, 16], [975152.827154945, 10], [975153.017940923, 31], [975153.166033839, 8], [975153.349102692, 11], [975153.531877078, 16], [975153.716849413, 12], [975153.902554553, 39], [975154.092952352, 18], [975154.276600502, 11], [975154.456464293, 16], [975154.639850438, 16], [975154.789581769, 11], [975154.980974334, 6], [975155.162077728, 9], [975155.344052571, 29], [975155.526630571, 22], [975155.708052078, 8], [975155.855735704, 18], [975156.047505753, 18], [975156.231195314, 34], [975156.415578331, 10], [975156.59829384, 14], [975156.785874283, 13], [975156.973987224, 2], [975157.15856986, 36], [975157.343106594, 42], [975157.526860786, 26], [975157.675400773, 17], [975157.861946764, 34], [975158.050614765, 12], [975158.232420351, 36], [975158.51968657, 50], [975158.703602318, 2], [975159.085121253, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-a3545a4affef05e2a3b2644c1a4f08a4", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.44942554, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.957937089, "time_to_first_token": 0.658846894, "token_sha": "2b28aa2108de", "tokens_per_second": 25.60771349737536}, "seed": 1234, "sent": 975148.46748566, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6621220100205392, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.60621151289412, "done": 975159.086635713, "finish_reason": "length", "first": 975149.128091947, "full_response_s": 10.619396473979577, "last": 975159.086613139, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975149.128091947, 2], [975149.285959508, 7], [975149.432865994, 4], [975149.646768983, 63], [975149.880737584, 10], [975150.070051468, 31], [975150.255436984, 29], [975150.434291914, 22], [975150.616610817, 14], [975150.800251051, 24], [975150.989378682, 4], [975151.13556989, 13], [975151.322193666, 21], [975151.501105788, 2], [975151.683653874, 18], [975151.865683555, 29], [975152.109565845, 27], [975152.348994974, 24], [975152.496417319, 4], [975152.643311848, 16], [975152.828202946, 10], [975153.017524206, 31], [975153.165362765, 8], [975153.349410934, 11], [975153.534344503, 16], [975153.715936718, 12], [975153.904563839, 39], [975154.092680269, 18], [975154.274918145, 11], [975154.457306399, 16], [975154.639635647, 16], [975154.789654934, 11], [975154.977762477, 6], [975155.161519849, 9], [975155.34313618, 29], [975155.527692747, 22], [975155.709286039, 8], [975155.857043422, 18], [975156.049155311, 18], [975156.230823874, 34], [975156.415734772, 10], [975156.598384764, 14], [975156.786642249, 13], [975156.974767973, 2], [975157.159734592, 36], [975157.342107662, 42], [975157.527313646, 26], [975157.676824709, 17], [975157.859893656, 34], [975158.055292764, 12], [975158.232630885, 36], [975158.519849715, 50], [975158.704162469, 2], [975159.086613139, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-7e6991aa7d1ea109157acc8347068734", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.449425172, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.958099786, "time_to_first_token": 0.657257734, "token_sha": "2b28aa2108de", "tokens_per_second": 25.60729511452598}, "seed": 1234, "sent": 975148.467239239, "speculative": {"acceptance_rate": 0.5623268698060941, "accepted": 203, "drafted": 361, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6608527079224586, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 361, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.605964026323694, "done": 975159.086480504, "finish_reason": "length", "first": 975149.127826375, "full_response_s": 10.61885758698918, "last": 975159.086443818, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975149.127826375, 2], [975149.290637137, 7], [975149.436615217, 4], [975149.647693534, 63], [975149.879913285, 10], [975150.06982199, 31], [975150.25223332, 29], [975150.434908319, 22], [975150.615494099, 14], [975150.801220752, 24], [975150.988905119, 4], [975151.136120585, 13], [975151.320700213, 21], [975151.500631937, 2], [975151.682937346, 18], [975151.865933336, 29], [975152.107932622, 27], [975152.346815584, 24], [975152.498582214, 4], [975152.644704378, 16], [975152.828987198, 10], [975153.017858735, 31], [975153.165791258, 8], [975153.351847833, 11], [975153.53383579, 16], [975153.715531808, 12], [975153.903097281, 39], [975154.093491944, 18], [975154.274609999, 11], [975154.458639171, 16], [975154.638897457, 16], [975154.788490554, 11], [975154.979552589, 6], [975155.160885429, 9], [975155.343449622, 29], [975155.525703172, 22], [975155.70827626, 8], [975155.856902548, 18], [975156.049221676, 18], [975156.23087224, 34], [975156.414078606, 10], [975156.597993805, 14], [975156.78642885, 13], [975156.975625551, 2], [975157.160480239, 36], [975157.340739515, 42], [975157.52602124, 26], [975157.67451958, 17], [975157.859123002, 34], [975158.05391153, 12], [975158.234085029, 36], [975158.520330141, 50], [975158.706131469, 2], [975159.086443818, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-5b383426fa9030b16ecd73f5ecf24667", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.449422293, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.957932673, "time_to_first_token": 0.65797983, "token_sha": "2b28aa2108de", "tokens_per_second": 25.60772485351388}, "seed": 1234, "sent": 975148.467622917, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6602034579264, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.614313389284195, "done": 975159.085799975, "finish_reason": "length", "first": 975149.130403123, "full_response_s": 10.618260893970728, "last": 975159.085774408, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975149.130403123, 2], [975149.289688492, 7], [975149.433356068, 4], [975149.648808379, 63], [975149.881146574, 10], [975150.071150458, 31], [975150.255761498, 29], [975150.433427217, 22], [975150.616862325, 14], [975150.80240633, 24], [975150.989540467, 4], [975151.135499605, 13], [975151.32014035, 21], [975151.503513215, 2], [975151.684621831, 18], [975151.865712418, 29], [975152.109754652, 27], [975152.349784138, 24], [975152.495044581, 4], [975152.643982714, 16], [975152.8288665, 10], [975153.017426578, 31], [975153.165649105, 8], [975153.351416204, 11], [975153.534027558, 16], [975153.716953249, 12], [975153.902356498, 39], [975154.091498898, 18], [975154.275407435, 11], [975154.455990426, 16], [975154.639815431, 16], [975154.789276407, 11], [975154.979080323, 6], [975155.160827688, 9], [975155.34334449, 29], [975155.526517904, 22], [975155.709367331, 8], [975155.856790985, 18], [975156.047845561, 18], [975156.230512928, 34], [975156.414430367, 10], [975156.600008915, 14], [975156.788512517, 13], [975156.974167008, 2], [975157.16255613, 36], [975157.342296486, 42], [975157.528222054, 26], [975157.675706695, 17], [975157.861435587, 34], [975158.05030857, 12], [975158.23342685, 36], [975158.521271651, 50], [975158.706293526, 2], [975159.085774408, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-b283e442f10320a40d0f88f3cb2c4c78", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.449418756, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.958292497, "time_to_first_token": 0.659111635, "token_sha": "2b28aa2108de", "tokens_per_second": 25.606799566976004}, "seed": 1234, "sent": 975148.467539081, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.662864041980356, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.617244739287482, "done": 975159.08590917, "finish_reason": "length", "first": 975149.130835839, "full_response_s": 10.618608318036422, "last": 975159.085067943, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975149.130835839, 2], [975149.288356648, 7], [975149.438084751, 4], [975149.647339038, 63], [975149.8801287, 10], [975150.071309075, 31], [975150.254281644, 29], [975150.436982305, 22], [975150.616664654, 14], [975150.801099301, 24], [975150.990158871, 4], [975151.136496056, 13], [975151.320076145, 21], [975151.503686968, 2], [975151.683201559, 18], [975151.865266758, 29], [975152.1104831, 27], [975152.347345576, 24], [975152.49546333, 4], [975152.643029621, 16], [975152.827813779, 10], [975153.019347804, 31], [975153.166233718, 8], [975153.349181968, 11], [975153.533187035, 16], [975153.716144021, 12], [975153.902482492, 39], [975154.091204927, 18], [975154.276695202, 11], [975154.456199729, 16], [975154.639298815, 16], [975154.788764926, 11], [975154.978427264, 6], [975155.160717165, 9], [975155.343570576, 29], [975155.525599929, 22], [975155.709716244, 8], [975155.856332686, 18], [975156.04661752, 18], [975156.230582605, 34], [975156.415790978, 10], [975156.597838452, 14], [975156.784083579, 13], [975156.973891372, 2], [975157.15781295, 36], [975157.341443884, 42], [975157.526256269, 26], [975157.67487838, 17], [975157.858697453, 34], [975158.055060087, 12], [975158.232952791, 36], [975158.521103947, 50], [975158.704079961, 2], [975159.085067943, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8d98779ab4f1675186bb31f6a1848e00", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.449414596, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.957952561, "time_to_first_token": 0.659640043, "token_sha": "2b28aa2108de", "tokens_per_second": 25.607673709824574}, "seed": 1234, "sent": 975148.467300852, "speculative": {"acceptance_rate": 0.5561643835616439, "accepted": 203, "drafted": 365, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.663534987019375, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 365, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.614896954683203, "done": 975159.088977609, "finish_reason": "length", "first": 975149.130891821, "full_response_s": 10.621648293919861, "last": 975159.0860363, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975149.130891821, 2], [975149.28631946, 7], [975149.433690789, 4], [975149.647597698, 63], [975149.880953863, 10], [975150.072393411, 31], [975150.254966445, 29], [975150.433986968, 22], [975150.615979901, 14], [975150.802213171, 24], [975150.988795636, 4], [975151.136046077, 13], [975151.319762703, 21], [975151.503736261, 2], [975151.684460942, 18], [975151.865142108, 29], [975152.111513821, 27], [975152.347297594, 24], [975152.494677109, 4], [975152.64354179, 16], [975152.83046254, 10], [975153.01770999, 31], [975153.165425579, 8], [975153.350725915, 11], [975153.532940118, 16], [975153.716618256, 12], [975153.904221663, 39], [975154.092752153, 18], [975154.274846404, 11], [975154.458710848, 16], [975154.641561785, 16], [975154.788017919, 11], [975154.980892306, 6], [975155.163908526, 9], [975155.345733424, 29], [975155.528140135, 22], [975155.710517792, 8], [975155.859352199, 18], [975156.048578265, 18], [975156.230937197, 34], [975156.414964423, 10], [975156.598874374, 14], [975156.78723859, 13], [975156.974822739, 2], [975157.158890806, 36], [975157.342687412, 42], [975157.526437525, 26], [975157.675290634, 17], [975157.859820763, 34], [975158.051063769, 12], [975158.232762144, 36], [975158.519891473, 50], [975158.705797276, 2], [975159.0860363, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-47e7baf9b2d7cd64cb65bb1f1ccdeedd", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.44941818, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.95851092, "time_to_first_token": 0.659415749, "token_sha": "2b28aa2108de", "tokens_per_second": 25.606237925378505}, "seed": 1234, "sent": 975148.467329315, "speculative": {"acceptance_rate": 0.559228650137741, "accepted": 203, "drafted": 363, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6635625059716403, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 363, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.305321462517345, "done": 975159.087215512, "finish_reason": "length", "first": 975148.595649431, "full_response_s": 10.619529461953789, "last": 975159.087179049, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975148.595649431, 2], [975148.678872829, 7], [975149.288179056, 4], [975149.434784564, 72], [975149.645967787, 1], [975149.881607369, 27], [975150.070298769, 30], [975150.252488285, 15], [975150.433599449, 14], [975150.616058233, 20], [975150.801285629, 14], [975150.989015402, 4], [975151.135985007, 13], [975151.320925819, 21], [975151.501741807, 2], [975151.685061587, 18], [975151.86663756, 29], [975152.108931233, 27], [975152.347814931, 24], [975152.495262203, 4], [975152.642618823, 16], [975152.828537603, 10], [975153.016269494, 31], [975153.165715118, 8], [975153.349351945, 11], [975153.533034866, 16], [975153.715812948, 12], [975153.904344825, 39], [975154.092183731, 18], [975154.274198801, 11], [975154.455789283, 16], [975154.638518418, 16], [975154.787803865, 11], [975154.977989155, 6], [975155.162143933, 9], [975155.343228128, 29], [975155.525510909, 22], [975155.707945011, 8], [975155.858739474, 18], [975156.0468929, 18], [975156.230658697, 34], [975156.415837104, 10], [975156.600080864, 14], [975156.784291538, 13], [975156.973832671, 2], [975157.159573655, 36], [975157.341677905, 42], [975157.525343398, 26], [975157.677608355, 17], [975157.858834855, 34], [975158.050042678, 12], [975158.232673796, 36], [975158.520799016, 50], [975158.704640256, 2], [975159.087179049, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-6d86e8f856b080c11daf5144bd50056a", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.127052958, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.489419424, "time_to_first_token": 0.12747761, "token_sha": "2b28aa2108de", "tokens_per_second": 24.310211051009645}, "seed": 1234, "sent": 975148.46768605, "speculative": {"acceptance_rate": 0.5459459459459459, "accepted": 202, "drafted": 370, "rounds": 54, "tokens_per_round": 4.7407407407407405}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12796338100451976, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 202, "drafted": 370, "rounds": 54}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.614808239555344, "done": 975159.085996606, "finish_reason": "length", "first": 975149.130783825, "full_response_s": 10.618633517064154, "last": 975159.085962783, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975149.130783825, 2], [975149.288259084, 7], [975149.43437887, 4], [975149.647093993, 63], [975149.881560331, 10], [975150.069687228, 31], [975150.252861916, 29], [975150.435150052, 22], [975150.616190819, 14], [975150.800401333, 24], [975150.990384301, 4], [975151.135630527, 13], [975151.321626955, 21], [975151.503173551, 2], [975151.685551885, 18], [975151.865212248, 29], [975152.111782257, 27], [975152.347955901, 24], [975152.498653907, 4], [975152.644203616, 16], [975152.82994058, 10], [975153.016723634, 31], [975153.165887606, 8], [975153.350097303, 11], [975153.532468475, 16], [975153.716312957, 12], [975153.9030353, 39], [975154.092070872, 18], [975154.273872928, 11], [975154.457757643, 16], [975154.638639964, 16], [975154.787925011, 11], [975154.980317771, 6], [975155.16047084, 9], [975155.34302884, 29], [975155.52875822, 22], [975155.708807132, 8], [975155.85588661, 18], [975156.046765178, 18], [975156.23101497, 34], [975156.416622685, 10], [975156.599929927, 14], [975156.78621566, 13], [975156.974898816, 2], [975157.161162256, 36], [975157.342445327, 42], [975157.526685642, 26], [975157.675852337, 17], [975157.859572358, 34], [975158.052549639, 12], [975158.233708501, 36], [975158.520185364, 50], [975158.706360371, 2], [975159.085962783, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-065e95772fffef8b737a4b62473653bb", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.449412245, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.958125672, "time_to_first_token": 0.659695241, "token_sha": "2b28aa2108de", "tokens_per_second": 25.6072285487421}, "seed": 1234, "sent": 975148.467363089, "speculative": {"acceptance_rate": 0.5561643835616439, "accepted": 203, "drafted": 365, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6634207359747961, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 365, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.612407398038464, "done": 975159.085626286, "finish_reason": "length", "first": 975149.129489516, "full_response_s": 10.618796917027794, "last": 975159.085601647, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975149.129489516, 2], [975149.28692292, 7], [975149.434965996, 4], [975149.648538312, 63], [975149.881660263, 10], [975150.070220916, 31], [975150.2519749, 29], [975150.436682047, 22], [975150.615720633, 14], [975150.801728425, 24], [975150.990030477, 4], [975151.136080859, 13], [975151.320533404, 21], [975151.501435309, 2], [975151.684214089, 18], [975151.866880174, 29], [975152.110845771, 27], [975152.346474575, 24], [975152.495137329, 4], [975152.643391157, 16], [975152.829085034, 10], [975153.01703322, 31], [975153.166166985, 8], [975153.35164237, 11], [975153.533284759, 16], [975153.716232161, 12], [975153.902950951, 39], [975154.091775973, 18], [975154.274719434, 11], [975154.458377951, 16], [975154.63943988, 16], [975154.790085043, 11], [975154.978565146, 6], [975155.162887484, 9], [975155.344698654, 29], [975155.526776852, 22], [975155.709238201, 8], [975155.857575766, 18], [975156.048075503, 18], [975156.231532578, 34], [975156.416783478, 10], [975156.599093804, 14], [975156.784188598, 13], [975156.973739283, 2], [975157.159655268, 36], [975157.342360339, 42], [975157.527688766, 26], [975157.676198241, 17], [975157.860148156, 34], [975158.053118429, 12], [975158.233850799, 36], [975158.521388878, 50], [975158.70372868, 2], [975159.085601647, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-b6de7d39212020e4d7087d610dc52eb3", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.449425908, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.958075291, "time_to_first_token": 0.6568694, "token_sha": "2b28aa2108de", "tokens_per_second": 25.607358103675537}, "seed": 1234, "sent": 975148.466829369, "speculative": {"acceptance_rate": 0.5623268698060941, "accepted": 203, "drafted": 361, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6626601470634341, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 361, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.993445564728948, "done": 975169.960623593, "finish_reason": "length", "first": 975159.757866973, "full_response_s": 10.854658818920143, "last": 975169.960541884, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975159.757866973, 2], [975159.920119877, 7], [975160.072418523, 4], [975160.282082093, 63], [975160.512467207, 10], [975160.694087542, 31], [975160.88052394, 29], [975161.072563679, 22], [975161.256766982, 14], [975161.439223931, 24], [975161.621733053, 4], [975161.769185314, 13], [975161.957669172, 21], [975162.142936679, 2], [975162.322417482, 18], [975162.507673309, 29], [975162.735843171, 27], [975162.97018317, 24], [975163.142442334, 2], [975163.333127404, 18], [975163.555996042, 10], [975163.739662222, 31], [975163.927488113, 8], [975164.114998102, 11], [975164.298562601, 16], [975164.484082373, 12], [975164.667066034, 39], [975164.8539641, 18], [975165.045620989, 11], [975165.229694516, 16], [975165.380219587, 13], [975165.565848342, 8], [975165.748850348, 12], [975165.935620371, 9], [975166.12444386, 29], [975166.307154625, 22], [975166.492733392, 12], [975166.675920201, 14], [975166.86225105, 18], [975167.055227038, 34], [975167.240022267, 10], [975167.424161988, 14], [975167.612917922, 13], [975167.797654865, 2], [975167.985776724, 36], [975168.173338706, 45], [975168.345856308, 23], [975168.532860906, 17], [975168.71647042, 34], [975168.90190954, 12], [975169.093815517, 36], [975169.381610214, 50], [975169.569548893, 2], [975169.960541884, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-1b20aaacafeeea3f88fa4228b0cb1efa", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.418228733, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.204233754, "time_to_first_token": 0.649337161, "token_sha": "2b28aa2108de", "tokens_per_second": 24.989627457332745}, "seed": 1234, "sent": 975159.105964774, "speculative": {"acceptance_rate": 0.5427807486631016, "accepted": 203, "drafted": 374, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6519021990243345, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 374, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.992128263511166, "done": 975169.961707193, "finish_reason": "length", "first": 975159.758382982, "full_response_s": 10.855334469000809, "last": 975169.961595662, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975159.758382982, 2], [975159.920389161, 7], [975160.072866135, 4], [975160.28373218, 63], [975160.511022855, 10], [975160.694278845, 27], [975160.880323852, 30], [975161.072157313, 16], [975161.255889373, 13], [975161.441215299, 20], [975161.62159074, 14], [975161.769630367, 4], [975161.956243923, 17], [975162.142499194, 17], [975162.322361244, 2], [975162.507980271, 18], [975162.736751819, 21], [975162.97156778, 9], [975163.145769467, 28], [975163.330314968, 22], [975163.557010237, 4], [975163.740505241, 20], [975163.927711079, 18], [975164.114876203, 19], [975164.297715182, 8], [975164.482314739, 10], [975164.666652004, 6], [975164.853760989, 23], [975165.046742651, 41], [975165.229351379, 27], [975165.381436301, 16], [975165.565026762, 16], [975165.746869155, 17], [975165.936525291, 9], [975166.12479906, 29], [975166.307030839, 22], [975166.491644928, 12], [975166.675148251, 14], [975166.862745844, 18], [975167.057308307, 34], [975167.239682058, 10], [975167.423571422, 14], [975167.614445982, 13], [975167.797115016, 2], [975167.985820083, 36], [975168.173151562, 45], [975168.344506479, 23], [975168.530129826, 17], [975168.714629461, 34], [975168.901146406, 12], [975169.092622737, 36], [975169.380938339, 50], [975169.565768051, 2], [975169.961595662, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8931a6f090a6adcc16cf2d0c0753f4cd", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.418227981, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.205276109, "time_to_first_token": 0.64886123, "token_sha": "2b28aa2108de", "tokens_per_second": 24.98707504592809}, "seed": 1234, "sent": 975159.106372724, "speculative": {"acceptance_rate": 0.571830985915493, "accepted": 203, "drafted": 355, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6520102579379454, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 355, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.99213081105953, "done": 975169.961212831, "finish_reason": "length", "first": 975159.757707188, "full_response_s": 10.855169995920733, "last": 975169.960918828, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975159.757707188, 2], [975159.919454851, 7], [975160.071940528, 4], [975160.283170556, 63], [975160.512095719, 10], [975160.695159094, 27], [975160.881355471, 30], [975161.072385319, 16], [975161.255636457, 13], [975161.440571151, 20], [975161.620826822, 14], [975161.769551218, 4], [975161.958389764, 17], [975162.140595678, 17], [975162.323391039, 2], [975162.507805111, 18], [975162.735712937, 21], [975162.970546833, 9], [975163.145837736, 28], [975163.331576032, 22], [975163.555919165, 4], [975163.740018766, 20], [975163.929444602, 18], [975164.114486108, 19], [975164.297641409, 8], [975164.483060355, 10], [975164.665866887, 6], [975164.854160908, 23], [975165.047242373, 41], [975165.229900635, 27], [975165.378619482, 16], [975165.565455511, 16], [975165.748891162, 17], [975165.93641824, 9], [975166.125596961, 29], [975166.308062137, 22], [975166.49332783, 12], [975166.679373537, 14], [975166.862861775, 18], [975167.057732944, 34], [975167.240482038, 10], [975167.424563154, 14], [975167.612575041, 13], [975167.797842008, 2], [975167.986575233, 36], [975168.174017748, 45], [975168.345277869, 23], [975168.532253284, 17], [975168.714697506, 34], [975168.901672094, 12], [975169.091241406, 36], [975169.379830708, 50], [975169.566264141, 2], [975169.960918828, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-fd25ccebec41a6b42badecec368c3228", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.418226988, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.204610538, "time_to_first_token": 0.648714389, "token_sha": "2b28aa2108de", "tokens_per_second": 24.988704767362673}, "seed": 1234, "sent": 975159.106042835, "speculative": {"acceptance_rate": 0.571830985915493, "accepted": 203, "drafted": 355, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6516643529757857, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 355, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.99949919885053, "done": 975169.957682762, "finish_reason": "length", "first": 975159.757218666, "full_response_s": 10.851272375904955, "last": 975169.957422997, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975159.757218666, 2], [975159.919195023, 7], [975160.072925876, 4], [975160.282483595, 63], [975160.512189379, 10], [975160.694890402, 31], [975160.880444567, 34], [975161.071517758, 21], [975161.257698445, 20], [975161.439122735, 14], [975161.623991369, 4], [975161.768697528, 17], [975161.958193565, 17], [975162.140970718, 2], [975162.324031346, 18], [975162.505960745, 29], [975162.736235554, 27], [975162.970591248, 24], [975163.143319943, 2], [975163.329666229, 18], [975163.557063947, 10], [975163.7397111, 31], [975163.927173023, 8], [975164.115656009, 11], [975164.300195248, 16], [975164.481969715, 12], [975164.668322811, 41], [975164.854353715, 27], [975165.045771398, 16], [975165.230440691, 16], [975165.38064632, 11], [975165.565769641, 6], [975165.74852321, 9], [975165.935535495, 29], [975166.12488, 22], [975166.308198195, 8], [975166.491046171, 18], [975166.677610303, 18], [975166.863351434, 34], [975167.055658219, 10], [975167.24043436, 14], [975167.423450723, 2], [975167.611500048, 13], [975167.797700079, 36], [975167.985049252, 42], [975168.172774426, 24], [975168.345595999, 8], [975168.532566407, 11], [975168.713868167, 34], [975168.901747835, 12], [975169.093438478, 36], [975169.381531465, 50], [975169.570486148, 2], [975169.957422997, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-2530128159f74f31da4de247388286a6", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.41821291, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.201089059, "time_to_first_token": 0.649213231, "token_sha": "2b28aa2108de", "tokens_per_second": 24.997331022713112}, "seed": 1234, "sent": 975159.106410386, "speculative": {"acceptance_rate": 0.5370370370370371, "accepted": 203, "drafted": 378, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6508082799846306, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 378, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.99760306812804, "done": 975169.958443385, "finish_reason": "length", "first": 975159.757369619, "full_response_s": 10.85233576898463, "last": 975169.958347661, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975159.757369619, 2], [975159.919914271, 7], [975160.073259237, 4], [975160.283628632, 63], [975160.51148485, 10], [975160.693816738, 31], [975160.880857557, 29], [975161.072263309, 22], [975161.256618397, 14], [975161.43950675, 24], [975161.622832237, 4], [975161.769364234, 13], [975161.956152567, 21], [975162.141938147, 2], [975162.323012111, 18], [975162.50605722, 29], [975162.735594398, 27], [975162.971340414, 24], [975163.14234605, 2], [975163.328711519, 18], [975163.556706058, 10], [975163.740648082, 31], [975163.927812275, 8], [975164.116180737, 11], [975164.296675772, 16], [975164.486208167, 12], [975164.666592999, 41], [975164.852361499, 27], [975165.046657503, 16], [975165.229187626, 16], [975165.379964478, 11], [975165.564626012, 6], [975165.746949216, 9], [975165.936717299, 29], [975166.127220169, 22], [975166.30572344, 8], [975166.494120339, 18], [975166.674505495, 18], [975166.864254594, 34], [975167.053801357, 10], [975167.241536584, 14], [975167.424508276, 2], [975167.6157633, 13], [975167.796332251, 36], [975167.986351563, 42], [975168.171268189, 24], [975168.346247251, 8], [975168.530689753, 11], [975168.71679679, 34], [975168.901056585, 12], [975169.091034855, 36], [975169.382295432, 50], [975169.567642881, 2], [975169.958347661, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-5c95c9909147165db6100c105fb87190", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.418219789, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.201722744, "time_to_first_token": 0.649354649, "token_sha": "2b28aa2108de", "tokens_per_second": 24.99577830126531}, "seed": 1234, "sent": 975159.106107616, "speculative": {"acceptance_rate": 0.5413333333333333, "accepted": 203, "drafted": 375, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6512620029971004, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 375, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.00013559131565, "done": 975169.958967202, "finish_reason": "length", "first": 975159.75898494, "full_response_s": 10.852419045986608, "last": 975169.958929619, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975159.75898494, 2], [975159.919053829, 7], [975160.071679164, 4], [975160.28169227, 63], [975160.510428369, 10], [975160.69592466, 31], [975160.880219249, 29], [975161.072426133, 22], [975161.256209599, 14], [975161.440211471, 24], [975161.621076282, 4], [975161.768814659, 13], [975161.957091694, 21], [975162.140697258, 2], [975162.322556675, 18], [975162.506238348, 29], [975162.736343261, 27], [975162.972372497, 24], [975163.141866376, 2], [975163.332697343, 18], [975163.555833265, 10], [975163.739522564, 31], [975163.928958064, 8], [975164.115132496, 11], [975164.299387492, 16], [975164.482577496, 12], [975164.667019124, 41], [975164.852029994, 27], [975165.045306475, 16], [975165.229545002, 16], [975165.379772407, 11], [975165.56389326, 6], [975165.747281921, 9], [975165.936481533, 29], [975166.123186843, 22], [975166.30562642, 8], [975166.492291764, 18], [975166.675221064, 18], [975166.861836444, 34], [975167.053985157, 10], [975167.239781685, 14], [975167.424327532, 2], [975167.616159891, 13], [975167.798481628, 36], [975167.985578509, 42], [975168.172901365, 24], [975168.343796462, 8], [975168.530526032, 11], [975168.714150682, 34], [975168.901400794, 12], [975169.09191656, 36], [975169.382360661, 50], [975169.564842187, 2], [975169.958929619, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-ae116640ac7b2c7837e5d4f30e2c2c9b", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.418218493, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.201284476, "time_to_first_token": 0.649659339, "token_sha": "2b28aa2108de", "tokens_per_second": 24.996852170912835}, "seed": 1234, "sent": 975159.106548156, "speculative": {"acceptance_rate": 0.5398936170212766, "accepted": 203, "drafted": 376, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6524367840029299, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 376, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.99773499429866, "done": 975169.960806177, "finish_reason": "length", "first": 975159.759821174, "full_response_s": 10.85409057198558, "last": 975169.96074538, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975159.759821174, 2], [975159.920606784, 7], [975160.072052843, 4], [975160.283787601, 63], [975160.510521197, 10], [975160.693712935, 31], [975160.881544614, 29], [975161.073693981, 22], [975161.255950475, 14], [975161.44001884, 24], [975161.62167768, 4], [975161.77081769, 13], [975161.956871831, 21], [975162.142850106, 2], [975162.3241671, 18], [975162.50687896, 29], [975162.736114711, 27], [975162.972642437, 24], [975163.142193993, 2], [975163.331488148, 18], [975163.555558445, 10], [975163.739591585, 31], [975163.927850609, 8], [975164.113950324, 11], [975164.298054671, 16], [975164.485068074, 12], [975164.666536345, 39], [975164.85482379, 18], [975165.046525189, 11], [975165.22924452, 16], [975165.378955803, 13], [975165.565962784, 8], [975165.748730625, 12], [975165.936775616, 9], [975166.125269759, 29], [975166.30840249, 22], [975166.492211639, 12], [975166.677370601, 14], [975166.86294062, 18], [975167.057484203, 34], [975167.240194915, 10], [975167.426041425, 14], [975167.613508072, 13], [975167.796692683, 2], [975167.987023822, 36], [975168.170986777, 45], [975168.344351302, 23], [975168.52966999, 17], [975168.716315019, 34], [975168.901622049, 12], [975169.091325882, 36], [975169.382786754, 50], [975169.566023672, 2], [975169.96074538, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-9d1e5e99b34fa64e3af044feac2ff9fa", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.418225917, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.204407122, "time_to_first_token": 0.649034439, "token_sha": "2b28aa2108de", "tokens_per_second": 24.989202895505567}, "seed": 1234, "sent": 975159.106715605, "speculative": {"acceptance_rate": 0.5427807486631016, "accepted": 203, "drafted": 374, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6531055689556524, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 374, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.998816215352385, "done": 975169.957840995, "finish_reason": "length", "first": 975159.757333621, "full_response_s": 10.851671526092105, "last": 975169.957816628, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975159.757333621, 2], [975159.91960998, 7], [975160.07068836, 4], [975160.281543653, 63], [975160.509924968, 10], [975160.695247538, 31], [975160.880967472, 34], [975161.071901021, 21], [975161.255168253, 20], [975161.440098356, 14], [975161.621784315, 4], [975161.769876308, 17], [975161.956807978, 17], [975162.140773286, 2], [975162.323808252, 18], [975162.506599196, 29], [975162.735076325, 27], [975162.971785531, 24], [975163.143698935, 2], [975163.330718902, 18], [975163.556774343, 10], [975163.738993772, 31], [975163.928067959, 8], [975164.116855508, 11], [975164.298688147, 16], [975164.483927708, 12], [975164.666226551, 41], [975164.854053904, 27], [975165.046115863, 16], [975165.22961276, 16], [975165.379377992, 11], [975165.563397426, 6], [975165.748927193, 9], [975165.93569456, 29], [975166.125971056, 22], [975166.306147134, 8], [975166.492069486, 18], [975166.678843624, 18], [975166.861618806, 34], [975167.054475983, 10], [975167.240737819, 14], [975167.425160904, 2], [975167.611379189, 13], [975167.796418839, 36], [975167.987353503, 42], [975168.172179237, 24], [975168.343922809, 8], [975168.533220106, 11], [975168.714812189, 34], [975168.902204743, 12], [975169.092823065, 36], [975169.379700154, 50], [975169.565075601, 2], [975169.957816628, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-16501215703126e272db7d4ce1eaf894", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.418217613, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.201221694, "time_to_first_token": 0.64949821, "token_sha": "2b28aa2108de", "tokens_per_second": 24.997006010562643}, "seed": 1234, "sent": 975159.106169469, "speculative": {"acceptance_rate": 0.5370370370370371, "accepted": 203, "drafted": 378, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6511641520773992, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 378, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.9940292425473, "done": 975169.962166133, "finish_reason": "length", "first": 975159.759654334, "full_response_s": 10.855676342034712, "last": 975169.962090985, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975159.759654334, 2], [975159.919757254, 7], [975160.072188901, 1], [975160.282691346, 3], [975160.511594253, 63], [975160.694791319, 10], [975160.880178483, 31], [975161.073350588, 34], [975161.256832228, 17], [975161.439581227, 14], [975161.62125821, 24], [975161.769704187, 4], [975161.957486332, 17], [975162.141069113, 17], [975162.323219126, 2], [975162.506999371, 18], [975162.734674631, 21], [975162.970637309, 9], [975163.143225468, 28], [975163.328956868, 22], [975163.556901826, 4], [975163.740583893, 20], [975163.927571821, 18], [975164.11589307, 19], [975164.299658152, 8], [975164.483565628, 10], [975164.666304228, 6], [975164.854107374, 23], [975165.045883137, 41], [975165.230754389, 27], [975165.378845696, 16], [975165.564096931, 16], [975165.748451486, 17], [975165.937249323, 9], [975166.123371283, 29], [975166.308130534, 22], [975166.494843859, 12], [975166.676566941, 14], [975166.862592523, 18], [975167.056725164, 34], [975167.239846562, 10], [975167.42493141, 14], [975167.615418052, 13], [975167.797482808, 2], [975167.985662425, 36], [975168.172967346, 45], [975168.344292409, 23], [975168.531733387, 17], [975168.714064574, 34], [975168.902335233, 12], [975169.094966011, 36], [975169.381781742, 50], [975169.566580159, 2], [975169.962090985, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-c5423c24cf99cb7040d0b83f455eb119", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.418230381, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.205759879, "time_to_first_token": 0.648223851, "token_sha": "2b28aa2108de", "tokens_per_second": 24.985890616994006}, "seed": 1234, "sent": 975159.106489791, "speculative": {"acceptance_rate": 0.5501355013550135, "accepted": 203, "drafted": 369, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6531645430950448, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 369, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 23.81764647647562, "done": 975169.958722892, "finish_reason": "length", "first": 975159.25115995, "full_response_s": 10.852482561953366, "last": 975169.957507458, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975159.25115995, 2], [975159.339683039, 7], [975159.919137985, 4], [975160.070895566, 72], [975160.282414222, 1], [975160.511687561, 27], [975160.694126388, 30], [975160.879798916, 15], [975161.072823828, 14], [975161.256656715, 20], [975161.438977382, 14], [975161.622238503, 4], [975161.769991023, 17], [975161.957734625, 17], [975162.1416332, 2], [975162.323175448, 18], [975162.50756181, 29], [975162.734493711, 27], [975162.97188079, 24], [975163.143647417, 2], [975163.330065059, 18], [975163.556328939, 10], [975163.739366827, 31], [975163.929189046, 8], [975164.116345882, 11], [975164.29944789, 16], [975164.485410283, 12], [975164.666044015, 41], [975164.854748066, 27], [975165.045947662, 16], [975165.228924646, 16], [975165.379497907, 11], [975165.564701224, 6], [975165.747379613, 9], [975165.935409053, 29], [975166.12451896, 22], [975166.307278076, 8], [975166.492442141, 18], [975166.678510615, 18], [975166.862781443, 34], [975167.055455588, 10], [975167.241054317, 14], [975167.423762053, 2], [975167.615168991, 13], [975167.797018717, 36], [975167.986850821, 42], [975168.173668595, 24], [975168.346325055, 8], [975168.529520284, 11], [975168.715870607, 34], [975168.902756127, 12], [975169.093662372, 36], [975169.383208639, 50], [975169.568396448, 2], [975169.957507458, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-1b63d8acedc9ffecd10ad5b607c5baa0", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.141984567, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.707651465, "time_to_first_token": 0.142715143, "token_sha": "2b28aa2108de", "tokens_per_second": 23.81474600975911}, "seed": 1234, "sent": 975159.10624033, "speculative": {"acceptance_rate": 0.520618556701031, "accepted": 202, "drafted": 388, "rounds": 54, "tokens_per_round": 4.7407407407407405}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.14491962001193315, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 202, "drafted": 388, "rounds": 54}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.993654897540512, "done": 975169.961181008, "finish_reason": "length", "first": 975159.75829825, "full_response_s": 10.85441486199852, "last": 975169.960887709, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975159.75829825, 2], [975159.919819587, 7], [975160.072741244, 4], [975160.282584454, 63], [975160.510355141, 10], [975160.693283674, 31], [975160.879432628, 29], [975161.073774106, 22], [975161.257357964, 14], [975161.44068129, 24], [975161.623324887, 4], [975161.771743937, 13], [975161.957932664, 21], [975162.141306031, 2], [975162.322686206, 18], [975162.505826431, 29], [975162.734945451, 27], [975162.970777447, 24], [975163.143480832, 2], [975163.33117949, 18], [975163.557375917, 10], [975163.739216322, 31], [975163.928278366, 8], [975164.114775663, 11], [975164.298207848, 16], [975164.483283705, 12], [975164.667947259, 39], [975164.855314841, 18], [975165.047042158, 11], [975165.229983335, 16], [975165.379338298, 13], [975165.563757714, 8], [975165.747191925, 12], [975165.936104622, 9], [975166.122791996, 29], [975166.305975189, 22], [975166.492939639, 12], [975166.678145383, 14], [975166.863655068, 18], [975167.056978129, 34], [975167.23884995, 10], [975167.425051021, 14], [975167.610831917, 13], [975167.798423503, 2], [975167.985909567, 36], [975168.171515266, 45], [975168.345791879, 23], [975168.5313535, 17], [975168.717117304, 34], [975168.901990145, 12], [975169.095884002, 36], [975169.381348721, 50], [975169.566770695, 2], [975169.960887709, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-2810b925622caf8f117c3ec92e8eafa5", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.418225005, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.204332805, "time_to_first_token": 0.649079109, "token_sha": "2b28aa2108de", "tokens_per_second": 24.98938488903979}, "seed": 1234, "sent": 975159.106766146, "speculative": {"acceptance_rate": 0.5427807486631016, "accepted": 203, "drafted": 374, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6515321040060371, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 374, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.994931667299046, "done": 975169.961861715, "finish_reason": "length", "first": 975159.759773209, "full_response_s": 10.854844251996838, "last": 975169.961841508, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975159.759773209, 2], [975159.921071515, 7], [975160.071766872, 1], [975160.283294007, 3], [975160.51270582, 63], [975160.693611707, 10], [975160.879833458, 31], [975161.072736312, 34], [975161.256129123, 17], [975161.440972077, 14], [975161.62379821, 24], [975161.76942564, 4], [975161.956038284, 17], [975162.141891189, 17], [975162.322931587, 2], [975162.506941037, 18], [975162.735149298, 21], [975162.970094102, 9], [975163.145480904, 28], [975163.328822826, 22], [975163.556957327, 4], [975163.74006278, 20], [975163.928822406, 18], [975164.115496304, 19], [975164.298148363, 8], [975164.486538201, 10], [975164.667545501, 6], [975164.855992699, 23], [975165.046297343, 41], [975165.23123048, 27], [975165.381626773, 16], [975165.564424708, 16], [975165.748153963, 17], [975165.936967304, 9], [975166.125321469, 29], [975166.307645291, 22], [975166.4944697, 12], [975166.676252298, 14], [975166.864609394, 18], [975167.056499878, 34], [975167.241457227, 10], [975167.423623355, 14], [975167.614870828, 13], [975167.797359998, 2], [975167.987294242, 36], [975168.173933191, 45], [975168.34502452, 23], [975168.532018383, 17], [975168.715805442, 34], [975168.902409022, 12], [975169.092178485, 36], [975169.380699934, 50], [975169.566407127, 2], [975169.961841508, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-6107a0f383387a01a57d16ac142f660c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.418229085, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.205436389, "time_to_first_token": 0.648665831, "token_sha": "2b28aa2108de", "tokens_per_second": 24.986682615047553}, "seed": 1234, "sent": 975159.107017463, "speculative": {"acceptance_rate": 0.5501355013550135, "accepted": 203, "drafted": 369, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6527557460358366, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 369, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.999699261011898, "done": 975169.958090216, "finish_reason": "length", "first": 975159.757945194, "full_response_s": 10.851787777035497, "last": 975169.958067897, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975159.757945194, 2], [975159.920875668, 7], [975160.071166642, 4], [975160.281443865, 63], [975160.510253353, 10], [975160.694214816, 31], [975160.881412844, 29], [975161.072041222, 22], [975161.255268633, 14], [975161.439790242, 24], [975161.623454433, 4], [975161.770261843, 13], [975161.957299444, 21], [975162.141729068, 2], [975162.322499318, 18], [975162.505296998, 29], [975162.736903636, 27], [975162.970971839, 24], [975163.144930288, 2], [975163.329193946, 18], [975163.555384021, 10], [975163.74012401, 31], [975163.927397269, 8], [975164.115989658, 11], [975164.296827029, 16], [975164.482447054, 12], [975164.667471232, 41], [975164.853224693, 27], [975165.046034139, 16], [975165.230376374, 16], [975165.381041903, 11], [975165.565312909, 6], [975165.747655137, 9], [975165.936196842, 29], [975166.126845978, 22], [975166.306393331, 8], [975166.490503235, 18], [975166.674622562, 18], [975166.861428382, 34], [975167.055915488, 10], [975167.239139169, 14], [975167.424982784, 2], [975167.611108785, 13], [975167.796182673, 36], [975167.986140084, 42], [975168.173429246, 24], [975168.344433186, 8], [975168.529254392, 11], [975168.715253402, 34], [975168.901333405, 12], [975169.094229803, 36], [975169.380310127, 50], [975169.566733848, 2], [975169.958067897, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-84d9b0403795e744b148b403dc29f085", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.418219517, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.201465875, "time_to_first_token": 0.649403847, "token_sha": "2b28aa2108de", "tokens_per_second": 24.996407685380802}, "seed": 1234, "sent": 975159.106302439, "speculative": {"acceptance_rate": 0.5398936170212766, "accepted": 203, "drafted": 376, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6516427550232038, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 376, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 23.815306788713333, "done": 975169.957656907, "finish_reason": "length", "first": 975159.250230088, "full_response_s": 10.850822284002788, "last": 975169.95762942, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975159.250230088, 2], [975159.338922368, 7], [975159.919701224, 4], [975160.070576573, 72], [975160.283985896, 1], [975160.511104659, 27], [975160.695638849, 30], [975160.879603916, 15], [975161.072495474, 14], [975161.255386964, 20], [975161.438791902, 14], [975161.620910674, 4], [975161.768944973, 17], [975161.956335631, 17], [975162.140471268, 2], [975162.322623185, 18], [975162.507917986, 29], [975162.734572828, 27], [975162.970480596, 24], [975163.141580324, 2], [975163.328500377, 18], [975163.555652025, 10], [975163.738712776, 31], [975163.927311321, 8], [975164.114139804, 11], [975164.296416583, 16], [975164.481729341, 12], [975164.665472328, 41], [975164.855171951, 27], [975165.047548008, 16], [975165.229299829, 16], [975165.378391204, 11], [975165.564231213, 6], [975165.748799614, 9], [975165.935769021, 29], [975166.125188435, 22], [975166.307804452, 8], [975166.490624717, 18], [975166.675413775, 18], [975166.862486848, 34], [975167.056024475, 10], [975167.240669438, 14], [975167.423669641, 2], [975167.610557897, 13], [975167.796824997, 36], [975167.984908763, 42], [975168.172675055, 24], [975168.34494262, 8], [975168.53108308, 11], [975168.716616942, 34], [975168.901479559, 12], [975169.091549473, 36], [975169.383502179, 50], [975169.569122304, 2], [975169.95762942, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-3886b3956f295aba5b33432a972c30a2", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.141978248, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.707641673, "time_to_first_token": 0.142424403, "token_sha": "2b28aa2108de", "tokens_per_second": 23.81476778803672}, "seed": 1234, "sent": 975159.106834623, "speculative": {"acceptance_rate": 0.520618556701031, "accepted": 202, "drafted": 388, "rounds": 54, "tokens_per_round": 4.7407407407407405}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.14339546498376876, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 202, "drafted": 388, "rounds": 54}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.997134558855, "done": 975169.959977157, "finish_reason": "length", "first": 975159.758694888, "full_response_s": 10.853635935927741, "last": 975169.959864122, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975159.758694888, 2], [975159.921136456, 7], [975160.072314735, 4], [975160.282528137, 63], [975160.510932251, 10], [975160.695769819, 31], [975160.879525328, 29], [975161.073606097, 22], [975161.256549072, 14], [975161.439356261, 24], [975161.62294388, 4], [975161.769764953, 13], [975161.956740637, 21], [975162.142426349, 2], [975162.323279635, 18], [975162.50552022, 29], [975162.735251357, 27], [975162.971444346, 24], [975163.143537566, 2], [975163.330620091, 18], [975163.55649074, 10], [975163.739899171, 31], [975163.928126773, 8], [975164.116305708, 11], [975164.297804442, 16], [975164.485819065, 12], [975164.666698258, 39], [975164.855389925, 18], [975165.045174241, 11], [975165.231036713, 16], [975165.381320787, 13], [975165.56430105, 8], [975165.747761596, 12], [975165.937361063, 9], [975166.124289722, 29], [975166.307888721, 22], [975166.493771091, 12], [975166.677095141, 14], [975166.865504171, 18], [975167.05423649, 34], [975167.239575838, 10], [975167.424102934, 14], [975167.611932013, 13], [975167.797577972, 2], [975167.985464242, 36], [975168.172461656, 45], [975168.346116665, 23], [975168.530767126, 17], [975168.715419923, 34], [975168.90205515, 12], [975169.092296832, 36], [975169.383332218, 50], [975169.56729376, 2], [975169.959864122, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-6bee180ca3c0db56f9a8329459471770", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.418227853, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.203446748, "time_to_first_token": 0.649572831, "token_sha": "2b28aa2108de", "tokens_per_second": 24.991554941959503}, "seed": 1234, "sent": 975159.106341221, "speculative": {"acceptance_rate": 0.5427807486631016, "accepted": 203, "drafted": 374, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6523536669556051, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 374, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.00030986188026, "done": 975169.959778766, "finish_reason": "length", "first": 975159.758912991, "full_response_s": 10.853912884020247, "last": 975169.958786569, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975159.758912991, 2], [975159.919542127, 7], [975160.071278333, 4], [975160.281620257, 63], [975160.512267792, 10], [975160.693547134, 31], [975160.880286046, 29], [975161.071378212, 22], [975161.256512242, 14], [975161.441517413, 24], [975161.622368881, 4], [975161.769097846, 13], [975161.956573253, 21], [975162.141159029, 2], [975162.323608629, 18], [975162.506776628, 29], [975162.736821672, 27], [975162.970371673, 24], [975163.141813162, 2], [975163.329814094, 18], [975163.556544882, 10], [975163.740724175, 31], [975163.928328044, 8], [975164.11558758, 11], [975164.297327615, 16], [975164.482966215, 12], [975164.666117004, 41], [975164.853865865, 27], [975165.04710126, 16], [975165.23081629, 16], [975165.379229135, 11], [975165.566365871, 6], [975165.747088746, 9], [975165.936273078, 29], [975166.123845758, 22], [975166.307435557, 8], [975166.493639176, 18], [975166.675651557, 18], [975166.863098341, 34], [975167.054879262, 10], [975167.240975537, 14], [975167.425713359, 2], [975167.613666049, 13], [975167.798187145, 36], [975167.985141296, 42], [975168.172022363, 24], [975168.344639913, 8], [975168.531194435, 11], [975168.714270197, 34], [975168.902603862, 12], [975169.094586203, 36], [975169.379496018, 50], [975169.569940476, 2], [975169.958786569, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-d6e9a83f71eb83a2f409448d9b5651f5", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.418225389, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.201944062, "time_to_first_token": 0.649204575, "token_sha": "2b28aa2108de", "tokens_per_second": 24.995236050138615}, "seed": 1234, "sent": 975159.105865882, "speculative": {"acceptance_rate": 0.5413333333333333, "accepted": 203, "drafted": 375, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6530471090227365, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 375, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "stock", "burst": null, "phase": "uncached_first_use", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 49.450674171111686, "done": 975175.267274663, "finish_reason": "length", "first": 975170.11057566, "full_response_s": 5.28751365293283, "last": 975175.267229321, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975170.11057566, 3], [975170.192110358, 26], [975170.274051198, 15], [975170.354631778, 34], [975170.435367679, 21], [975170.516693666, 25], [975170.597663573, 14], [975170.678283159, 14], [975170.762823757, 18], [975170.843967306, 26], [975170.928924259, 13], [975171.014038933, 13], [975171.095714813, 13], [975171.176365922, 23], [975171.258156198, 32], [975171.338760045, 7], [975171.419365253, 23], [975171.500175571, 9], [975171.581354577, 13], [975171.661760545, 15], [975171.743141686, 19], [975171.823922615, 12], [975171.905863752, 5], [975171.992643238, 23], [975172.076239759, 9], [975172.157306647, 17], [975172.238127593, 3], [975172.318723445, 21], [975172.399541592, 10], [975172.480409768, 24], [975172.561443681, 19], [975172.642283571, 14], [975172.724742238, 13], [975172.807368913, 5], [975172.888410558, 22], [975172.975859268, 13], [975173.059378581, 51], [975173.140393107, 15], [975173.221165004, 6], [975173.302444015, 8], [975173.383202441, 9], [975173.464151546, 16], [975173.545129802, 16], [975173.626368639, 9], [975173.70718023, 32], [975173.788799338, 18], [975173.869881993, 13], [975173.956086506, 11], [975174.040852793, 15], [975174.121950265, 8], [975174.202897519, 18], [975174.277984276, 25], [975174.358736483, 19], [975174.439729127, 8], [975174.520747193, 40], [975174.601751853, 16], [975174.682887339, 64], [975174.767413189, 6], [975174.84823493, 6], [975174.933233068, 11], [975175.019118575, 15], [975175.10093266, 17], [975175.181748356, 21], [975175.267229321, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-5f7b4bac099ff933ece6ee42c81214e5", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.129531266, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 5.15701227, "time_to_first_token": 0.130001294, "token_sha": "8a91591c94a3", "tokens_per_second": 49.44723546294762}, "seed": 1234, "sent": 975169.97976101, "speculative": {"acceptance_rate": 0.2052910052910053, "accepted": 194, "drafted": 945, "rounds": 63, "tokens_per_round": 4.063492063492063}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.13081464997958392, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 194, "drafted": 945, "rounds": 63}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 49.496096210048464, "done": 975180.558685083, "finish_reason": "length", "first": 975175.406719438, "full_response_s": 5.28274655691348, "last": 975180.558640893, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975175.406719438, 3], [975175.48914476, 26], [975175.569547659, 15], [975175.650415192, 34], [975175.732179615, 21], [975175.813948134, 25], [975175.894879222, 14], [975175.982283964, 14], [975176.066250968, 18], [975176.146408505, 26], [975176.227244749, 13], [975176.30865252, 13], [975176.389200584, 13], [975176.469842005, 23], [975176.550832834, 32], [975176.631788128, 7], [975176.713367668, 23], [975176.796419223, 9], [975176.876916126, 13], [975176.962917078, 15], [975177.047684547, 19], [975177.128756273, 12], [975177.209325413, 5], [975177.292179382, 23], [975177.372835622, 9], [975177.453463639, 17], [975177.534076921, 3], [975177.614602255, 21], [975177.695820455, 10], [975177.777058638, 24], [975177.858173949, 19], [975177.943722605, 14], [975178.028373701, 13], [975178.109796648, 5], [975178.190309955, 22], [975178.271769333, 13], [975178.352105607, 51], [975178.433137803, 15], [975178.513812767, 6], [975178.595133079, 8], [975178.676278823, 9], [975178.760349975, 16], [975178.841329519, 16], [975178.924976327, 9], [975179.011585934, 32], [975179.09355547, 18], [975179.1743836, 13], [975179.255836583, 11], [975179.336737941, 15], [975179.417307058, 8], [975179.498146051, 18], [975179.572682869, 25], [975179.653275889, 19], [975179.734357496, 8], [975179.816193054, 40], [975179.897110497, 16], [975179.984401983, 64], [975180.06836099, 6], [975180.149202643, 6], [975180.230148244, 11], [975180.311799847, 15], [975180.392941487, 17], [975180.473845234, 21], [975180.558640893, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-35d40bfbab6b94b7b624e0e5bf40e9af", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.12888789, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 5.152304414, "time_to_first_token": 0.129333711, "token_sha": "8a91591c94a3", "tokens_per_second": 49.49241727781188}, "seed": 1234, "sent": 975175.275938526, "speculative": {"acceptance_rate": 0.2052910052910053, "accepted": 194, "drafted": 945, "rounds": 63, "tokens_per_round": 4.063492063492063}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.13078091200441122, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 194, "drafted": 945, "rounds": 63}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 49.55497011356417, "done": 975185.854939642, "finish_reason": "length", "first": 975180.709088382, "full_response_s": 5.277474235976115, "last": 975185.854889084, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975180.709088382, 3], [975180.793526936, 26], [975180.874560089, 15], [975180.960536229, 34], [975181.045048769, 21], [975181.126656777, 25], [975181.206986106, 14], [975181.288295535, 14], [975181.368927603, 18], [975181.449218628, 26], [975181.52971059, 13], [975181.610447756, 13], [975181.690357966, 13], [975181.771449918, 23], [975181.852831155, 32], [975181.936464569, 7], [975182.022273521, 23], [975182.104303804, 9], [975182.184722765, 13], [975182.265992233, 15], [975182.346742251, 19], [975182.427647335, 12], [975182.509335745, 5], [975182.589837358, 23], [975182.670509796, 9], [975182.753886021, 17], [975182.835028952, 3], [975182.915960135, 21], [975183.002896867, 10], [975183.086353414, 24], [975183.16707587, 19], [975183.247825093, 14], [975183.328595883, 13], [975183.409316163, 5], [975183.489712649, 22], [975183.570168669, 13], [975183.65058549, 51], [975183.731427605, 15], [975183.813026439, 6], [975183.892644211, 8], [975183.979343519, 9], [975184.065231645, 16], [975184.146114194, 16], [975184.226844414, 9], [975184.30813981, 32], [975184.388917981, 18], [975184.469567628, 13], [975184.55025185, 11], [975184.630826717, 15], [975184.711594936, 8], [975184.794065593, 18], [975184.86932874, 25], [975184.954462647, 19], [975185.03924137, 8], [975185.122098911, 40], [975185.203268397, 16], [975185.284902486, 64], [975185.365520572, 6], [975185.446201551, 6], [975185.526871762, 11], [975185.607797562, 15], [975185.688876172, 17], [975185.770207107, 21], [975185.854889084, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-0017c53944efee7509ed8482f2869e00", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.129449918, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 5.146028164, "time_to_first_token": 0.130540687, "token_sha": "8a91591c94a3", "tokens_per_second": 49.552779711525886}, "seed": 1234, "sent": 975180.577465406, "speculative": {"acceptance_rate": 0.2052910052910053, "accepted": 194, "drafted": 945, "rounds": 63, "tokens_per_round": 4.063492063492063}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.13162297592498362, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 194, "drafted": 945, "rounds": 63}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 49.573482114673375, "done": 975191.156505487, "finish_reason": "length", "first": 975186.012581784, "full_response_s": 5.283225465100259, "last": 975191.156460913, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975186.012581784, 3], [975186.094947318, 26], [975186.17603926, 15], [975186.257026518, 34], [975186.337643488, 21], [975186.417732161, 25], [975186.499025837, 14], [975186.579633704, 14], [975186.66020138, 18], [975186.74350993, 26], [975186.823980699, 13], [975186.904715972, 13], [975186.991446812, 13], [975187.075070442, 23], [975187.155764805, 32], [975187.235925399, 7], [975187.317479261, 23], [975187.398201767, 9], [975187.478411974, 13], [975187.55875672, 15], [975187.639154584, 19], [975187.719818948, 12], [975187.801115334, 5], [975187.8815448, 23], [975187.967824368, 9], [975188.052922515, 17], [975188.133482776, 3], [975188.213748938, 21], [975188.295711971, 10], [975188.376327878, 24], [975188.456985415, 19], [975188.537457184, 14], [975188.618147359, 13], [975188.698538363, 5], [975188.781998324, 22], [975188.862284136, 13], [975188.947907273, 51], [975189.033403712, 15], [975189.114710089, 6], [975189.194943809, 8], [975189.276924109, 9], [975189.358388672, 16], [975189.439554432, 16], [975189.5215515, 9], [975189.601820626, 32], [975189.682745132, 18], [975189.764065093, 13], [975189.844726508, 11], [975189.927152378, 15], [975190.014656032, 8], [975190.096483255, 18], [975190.170690453, 25], [975190.251745341, 19], [975190.332433206, 8], [975190.413252793, 40], [975190.494121497, 16], [975190.574681607, 64], [975190.655630757, 6], [975190.738814131, 6], [975190.82005058, 11], [975190.900774511, 15], [975190.98840058, 17], [975191.072103744, 21], [975191.156460913, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-306cde0cd6cf6d67639c8688dc926800", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.137696055, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 5.144189691, "time_to_first_token": 0.138260526, "token_sha": "8a91591c94a3", "tokens_per_second": 49.5704892932184}, "seed": 1234, "sent": 975185.873280022, "speculative": {"acceptance_rate": 0.2052910052910053, "accepted": 194, "drafted": 945, "rounds": 63, "tokens_per_round": 4.063492063492063}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.13930176210124046, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 194, "drafted": 945, "rounds": 63}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.89392711833197, "done": 975205.525404968, "finish_reason": "length", "first": 975192.028896224, "full_response_s": 14.341070092981681, "last": 975205.525296332, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975192.028896224, 3], [975192.157093304, 11], [975192.337168877, 30], [975192.519109891, 19], [975192.700164767, 21], [975192.88367503, 15], [975193.036183179, 19], [975193.187280843, 17], [975193.36633831, 12], [975193.547013451, 5], [975193.694896869, 5], [975193.876501815, 18], [975194.068109413, 21], [975194.24979281, 9], [975194.433316528, 9], [975194.579026526, 16], [975194.765347181, 5], [975194.949543518, 14], [975195.133229272, 9], [975195.317327856, 27], [975195.464694879, 11], [975195.64626077, 8], [975195.795651132, 16], [975195.945140776, 5], [975196.096602402, 9], [975196.279624481, 14], [975196.427631325, 20], [975196.575342134, 8], [975196.724773429, 12], [975196.874055487, 5], [975197.028474915, 14], [975197.214271399, 14], [975197.361956616, 8], [975197.543832114, 13], [975197.715879116, 3], [975197.89569133, 10], [975198.051188401, 11], [975198.234981219, 9], [975198.417890187, 10], [975198.5996337, 20], [975198.748154042, 14], [975198.933721448, 14], [975199.166046786, 13], [975199.349414896, 5], [975199.534335884, 22], [975199.766881037, 3], [975200.0014233, 32], [975200.187374527, 33], [975200.37287662, 11], [975200.555247742, 6], [975200.699810395, 8], [975200.850618563, 9], [975201.00576769, 13], [975201.158987169, 8], [975201.306036877, 20], [975201.454365875, 17], [975201.638434072, 20], [975201.787354597, 13], [975201.975432904, 6], [975202.165796877, 13], [975202.312341158, 9], [975202.462938645, 11], [975202.613518372, 8], [975202.796354934, 15], [975202.986239976, 16], [975203.201738263, 27], [975203.43534838, 4], [975203.586561241, 8], [975203.768869658, 25], [975203.95645287, 18], [975204.110032391, 13], [975204.292783568, 55], [975204.443066587, 11], [975204.628991119, 10], [975204.815338049, 11], [975204.966222491, 15], [975205.122148498, 17], [975205.268068765, 14], [975205.525296332, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-5ca80d3a7e4255f582b3e223d2717f96", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.630242957, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.498053959, "time_to_first_token": 0.834384871, "token_sha": "8a91591c94a3", "tokens_per_second": 18.891612137168522}, "seed": 1234, "sent": 975191.184334875, "speculative": {"acceptance_rate": 0.423444976076555, "accepted": 177, "drafted": 418, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8445613490184769, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 418, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.893424053911787, "done": 975205.524197275, "finish_reason": "length", "first": 975192.027421982, "full_response_s": 14.337161635048687, "last": 975205.524181451, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975192.027421982, 3], [975192.155797983, 11], [975192.336079372, 30], [975192.517880856, 19], [975192.701394091, 21], [975192.884221615, 15], [975193.036580106, 19], [975193.185470664, 17], [975193.365503513, 12], [975193.548632295, 5], [975193.694654719, 5], [975193.875823491, 27], [975194.067470288, 12], [975194.252275136, 13], [975194.432392599, 5], [975194.579483594, 16], [975194.762990498, 5], [975194.949437203, 14], [975195.13434988, 9], [975195.315782785, 27], [975195.464561509, 11], [975195.647267431, 8], [975195.795959374, 16], [975195.945186022, 5], [975196.096997809, 9], [975196.280120684, 14], [975196.426268647, 20], [975196.574425789, 8], [975196.725753548, 12], [975196.873849303, 5], [975197.029803323, 14], [975197.216210245, 14], [975197.360085752, 8], [975197.543702136, 13], [975197.715012337, 3], [975197.896983307, 10], [975198.050692118, 11], [975198.232811199, 9], [975198.416332701, 10], [975198.599712224, 20], [975198.747947139, 14], [975198.933656539, 14], [975199.167998959, 13], [975199.349710947, 5], [975199.530720005, 22], [975199.761159167, 3], [975200.002649888, 32], [975200.186514099, 33], [975200.371405083, 11], [975200.553512663, 6], [975200.699242131, 8], [975200.850277889, 9], [975201.006748352, 13], [975201.155406696, 8], [975201.307305672, 20], [975201.454784546, 17], [975201.639169385, 20], [975201.787805778, 13], [975201.975052568, 6], [975202.164905315, 13], [975202.31477144, 9], [975202.462478872, 11], [975202.611401533, 8], [975202.795773854, 15], [975202.985773404, 16], [975203.201452339, 27], [975203.43707658, 4], [975203.586073869, 8], [975203.770852615, 25], [975203.956357322, 18], [975204.108733822, 13], [975204.295760547, 55], [975204.444570796, 11], [975204.628859252, 10], [975204.814908163, 11], [975204.968207624, 15], [975205.121900077, 17], [975205.269110401, 14], [975205.524181451, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-7384a25b144aa4f9f6517af0aa6698cd", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.630231038, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.496869912, "time_to_first_token": 0.835071017, "token_sha": "8a91591c94a3", "tokens_per_second": 18.893269451554897}, "seed": 1234, "sent": 975191.18703564, "speculative": {"acceptance_rate": 0.4194312796208531, "accepted": 177, "drafted": 422, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8403863420244306, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 422, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.895447963586903, "done": 975205.524068608, "finish_reason": "length", "first": 975192.028720999, "full_response_s": 14.337720618932508, "last": 975205.524034817, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975192.028720999, 3], [975192.157144806, 11], [975192.336371695, 30], [975192.51820321, 19], [975192.699719538, 21], [975192.8828734, 15], [975193.035718782, 19], [975193.186306085, 17], [975193.367263278, 12], [975193.550160453, 5], [975193.693812803, 5], [975193.877783184, 27], [975194.068643343, 12], [975194.249097639, 13], [975194.431668022, 5], [975194.58048328, 16], [975194.762911429, 5], [975194.948971111, 14], [975195.134859011, 9], [975195.316306731, 27], [975195.466378247, 11], [975195.649610244, 8], [975195.79501991, 16], [975195.944907954, 5], [975196.096474327, 9], [975196.279335789, 14], [975196.426781681, 20], [975196.574986933, 8], [975196.724840754, 12], [975196.873666847, 5], [975197.028402294, 14], [975197.214550107, 14], [975197.360995681, 8], [975197.54304178, 13], [975197.713751734, 3], [975197.896075105, 10], [975198.050628568, 11], [975198.234695583, 9], [975198.418871265, 10], [975198.599339152, 20], [975198.74774014, 14], [975198.932680628, 14], [975199.168096091, 13], [975199.349520011, 5], [975199.531232607, 22], [975199.762179668, 3], [975200.001751206, 32], [975200.188265033, 33], [975200.371203091, 11], [975200.55250853, 6], [975200.700413202, 8], [975200.84968553, 9], [975201.006384944, 13], [975201.158616113, 8], [975201.306692002, 20], [975201.453680496, 17], [975201.638632175, 20], [975201.788091318, 13], [975201.975493126, 6], [975202.164816919, 13], [975202.315512897, 9], [975202.462890263, 11], [975202.612491567, 8], [975202.797226081, 15], [975202.987999406, 16], [975203.203442223, 27], [975203.434813779, 4], [975203.584550461, 8], [975203.770402426, 25], [975203.956620079, 18], [975204.11010874, 13], [975204.29549947, 55], [975204.443869706, 11], [975204.629466555, 10], [975204.812838058, 11], [975204.967455575, 15], [975205.12147571, 17], [975205.268977494, 14], [975205.524034817, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-54568d7386721d3c021c265192a1b099", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.630234526, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.496272689, "time_to_first_token": 0.836591656, "token_sha": "8a91591c94a3", "tokens_per_second": 18.894105496833593}, "seed": 1234, "sent": 975191.186347989, "speculative": {"acceptance_rate": 0.4194312796208531, "accepted": 177, "drafted": 422, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8423730100039393, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 422, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.894889557361484, "done": 975205.523566005, "finish_reason": "length", "first": 975192.027821757, "full_response_s": 14.336670695105568, "last": 975205.523534406, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975192.027821757, 3], [975192.156661818, 11], [975192.335594145, 30], [975192.520753885, 19], [975192.70127936, 21], [975192.88503494, 15], [975193.036962777, 19], [975193.187168896, 17], [975193.366666744, 12], [975193.550508855, 5], [975193.695246454, 5], [975193.87796876, 27], [975194.068794104, 12], [975194.249897173, 13], [975194.432827733, 5], [975194.581729467, 16], [975194.761920879, 5], [975194.94913272, 14], [975195.133024369, 9], [975195.318722852, 27], [975195.464901926, 11], [975195.648517618, 8], [975195.794122764, 16], [975195.944694155, 5], [975196.098971213, 9], [975196.280272789, 14], [975196.428916598, 20], [975196.576616192, 8], [975196.724236972, 12], [975196.874808959, 5], [975197.02939142, 14], [975197.215155473, 14], [975197.361534218, 8], [975197.543669513, 13], [975197.714035418, 3], [975197.895740688, 10], [975198.050054017, 11], [975198.237979908, 9], [975198.418813572, 10], [975198.599785853, 20], [975198.747427817, 14], [975198.934098088, 14], [975199.165457387, 13], [975199.34926935, 5], [975199.530964395, 22], [975199.76145829, 3], [975200.002297215, 32], [975200.187700209, 33], [975200.371101255, 11], [975200.555315899, 6], [975200.699165719, 8], [975200.850479881, 9], [975201.006435037, 13], [975201.154690167, 8], [975201.306105563, 20], [975201.453917014, 17], [975201.637970395, 20], [975201.787897614, 13], [975201.975183667, 6], [975202.16416829, 13], [975202.313971138, 9], [975202.461236524, 11], [975202.612425362, 8], [975202.796154638, 15], [975202.985965492, 16], [975203.202951812, 27], [975203.436446958, 4], [975203.585301326, 8], [975203.770640432, 25], [975203.957127274, 18], [975204.107808084, 13], [975204.292940233, 55], [975204.443946838, 11], [975204.626272881, 10], [975204.814521331, 11], [975204.967853463, 15], [975205.119736711, 17], [975205.269882336, 14], [975205.523534406, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-c9e6f4e457aaed9f70230c1e31ba76c7", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.63023219, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.494613303, "time_to_first_token": 0.836787264, "token_sha": "8a91591c94a3", "tokens_per_second": 18.896428839743834}, "seed": 1234, "sent": 975191.18689531, "speculative": {"acceptance_rate": 0.4194312796208531, "accepted": 177, "drafted": 422, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8409264470683411, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 422, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 17.952453616478486, "done": 975205.52387228, "finish_reason": "length", "first": 975191.317195734, "full_response_s": 14.339423313969746, "last": 975205.521382273, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975191.317195734, 3], [975191.397898082, 26], [975192.155476173, 15], [975192.336322705, 19], [975192.521103406, 21], [975192.699891931, 15], [975192.883934859, 19], [975193.035767852, 17], [975193.185724989, 6], [975193.367528211, 11], [975193.546028213, 5], [975193.69482596, 18], [975193.875969165, 21], [975194.06696023, 5], [975194.250126252, 8], [975194.433770413, 5], [975194.580423795, 16], [975194.762385467, 5], [975194.94804091, 14], [975195.133690132, 9], [975195.316168273, 27], [975195.46734507, 11], [975195.648263485, 8], [975195.796683872, 16], [975195.944315195, 5], [975196.099123223, 9], [975196.279211218, 14], [975196.426653542, 20], [975196.57598785, 8], [975196.725249761, 12], [975196.874940057, 5], [975197.028661307, 14], [975197.214649815, 14], [975197.361063822, 8], [975197.543125088, 13], [975197.716268523, 3], [975197.894702811, 10], [975198.050858703, 11], [975198.23339303, 9], [975198.418191694, 10], [975198.599226341, 20], [975198.747052281, 14], [975198.932518923, 14], [975199.16745671, 13], [975199.347853298, 5], [975199.530645752, 22], [975199.765214676, 3], [975200.00312454, 32], [975200.188478592, 33], [975200.372004273, 11], [975200.552329849, 6], [975200.699302273, 8], [975200.849485347, 9], [975201.005566274, 13], [975201.154927853, 8], [975201.305247807, 20], [975201.453998659, 17], [975201.638539043, 20], [975201.78721705, 13], [975201.97682771, 6], [975202.163920924, 13], [975202.31523942, 9], [975202.46254063, 11], [975202.612091888, 8], [975202.796966428, 15], [975202.985320207, 16], [975203.201970141, 27], [975203.43473159, 4], [975203.585118501, 8], [975203.769768933, 25], [975203.955393682, 18], [975204.108876056, 13], [975204.296070166, 55], [975204.441396961, 11], [975204.63020278, 10], [975204.81350051, 11], [975204.966430578, 15], [975205.11943314, 17], [975205.268216726, 14], [975205.521382273, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-20231f509b1d40d9b462e09e2da6225b", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.130018947, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 14.204835359, "time_to_first_token": 0.13119485, "token_sha": "8a91591c94a3", "tokens_per_second": 17.951633620197878}, "seed": 1234, "sent": 975191.184448966, "speculative": {"acceptance_rate": 0.4, "accepted": 176, "drafted": 440, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.13274676795117557, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 440, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.897969715956396, "done": 975205.523021932, "finish_reason": "length", "first": 975192.029136997, "full_response_s": 14.335413563996553, "last": 975205.522649995, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975192.029136997, 3], [975192.15691024, 11], [975192.335720891, 30], [975192.521813904, 19], [975192.700821795, 21], [975192.883807264, 15], [975193.035656673, 19], [975193.187838212, 17], [975193.366112079, 12], [975193.548297765, 5], [975193.694394346, 5], [975193.877113213, 27], [975194.068163635, 12], [975194.250962552, 13], [975194.433167446, 5], [975194.581135316, 16], [975194.76359012, 5], [975194.949499664, 14], [975195.135722046, 9], [975195.320071435, 27], [975195.464845208, 11], [975195.648087797, 8], [975195.797664902, 16], [975195.944638813, 5], [975196.096260832, 9], [975196.279578019, 14], [975196.429596474, 20], [975196.576431095, 8], [975196.725504998, 12], [975196.874600952, 5], [975197.029724238, 14], [975197.215669452, 14], [975197.361596472, 8], [975197.54359902, 13], [975197.714155701, 3], [975197.895500826, 10], [975198.050223418, 11], [975198.233341544, 9], [975198.418108898, 10], [975198.600412195, 20], [975198.746943309, 14], [975198.932606839, 14], [975199.165904072, 13], [975199.349457102, 5], [975199.533903263, 22], [975199.767212063, 3], [975200.002708125, 32], [975200.186738409, 33], [975200.371481543, 11], [975200.553023308, 6], [975200.700267928, 8], [975200.85040862, 9], [975201.006909321, 13], [975201.157891296, 8], [975201.307630154, 20], [975201.454881038, 17], [975201.638858214, 20], [975201.787408402, 13], [975201.975685374, 6], [975202.164739434, 13], [975202.314080605, 9], [975202.463244344, 11], [975202.611147352, 8], [975202.795886537, 15], [975202.987231214, 16], [975203.203692693, 27], [975203.436040047, 4], [975203.584656953, 8], [975203.767977584, 25], [975203.957012255, 18], [975204.10795099, 13], [975204.291523669, 55], [975204.442279068, 11], [975204.626454297, 10], [975204.817775851, 11], [975204.967934947, 15], [975205.120966388, 17], [975205.267916019, 14], [975205.522649995, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-57d17f5244bb9309736f9d1195f25d29", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.630224143, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.494238134, "time_to_first_token": 0.838683279, "token_sha": "8a91591c94a3", "tokens_per_second": 18.896954201327127}, "seed": 1234, "sent": 975191.187608368, "speculative": {"acceptance_rate": 0.41451990632318503, "accepted": 177, "drafted": 427, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8415286289528012, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 427, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.891391396550897, "done": 975205.525929778, "finish_reason": "length", "first": 975192.027484828, "full_response_s": 14.337791320984252, "last": 975205.525696508, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975192.027484828, 3], [975192.157625105, 11], [975192.335931954, 30], [975192.522139346, 19], [975192.700064259, 21], [975192.883588522, 15], [975193.036774641, 19], [975193.187892865, 17], [975193.366176589, 12], [975193.547924629, 5], [975193.694716461, 5], [975193.876587731, 18], [975194.068561938, 21], [975194.24950831, 9], [975194.432441797, 9], [975194.580903246, 16], [975194.762789274, 5], [975194.947900564, 14], [975195.135753101, 9], [975195.315951802, 27], [975195.465197785, 11], [975195.649508008, 8], [975195.796211668, 16], [975195.944499571, 5], [975196.096370443, 9], [975196.278958477, 14], [975196.42714677, 20], [975196.574362031, 8], [975196.724073123, 12], [975196.874744177, 5], [975197.028540016, 14], [975197.215394295, 14], [975197.360476599, 8], [975197.542039134, 13], [975197.714870407, 3], [975197.895949895, 10], [975198.050450768, 11], [975198.237380286, 9], [975198.416135461, 10], [975198.600725142, 20], [975198.746742614, 14], [975198.933546927, 14], [975199.166262393, 13], [975199.348063097, 5], [975199.531985664, 22], [975199.761725735, 3], [975200.001970141, 32], [975200.187784285, 33], [975200.372547706, 11], [975200.552411462, 6], [975200.699099113, 8], [975200.849297531, 9], [975201.005685789, 13], [975201.156709825, 8], [975201.305761417, 20], [975201.454412577, 17], [975201.638022857, 20], [975201.789011919, 13], [975201.976076733, 6], [975202.163633496, 13], [975202.312616587, 9], [975202.462124935, 11], [975202.611835707, 8], [975202.796326503, 15], [975202.985481192, 16], [975203.202345773, 27], [975203.436713907, 4], [975203.583933063, 8], [975203.767780072, 25], [975203.955254904, 18], [975204.107562767, 13], [975204.291396778, 55], [975204.442681707, 11], [975204.626618146, 10], [975204.814659213, 11], [975204.966735414, 15], [975205.1210484, 17], [975205.26831429, 14], [975205.525696508, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4fc012c510cf41c35c41d7c10b633f3d", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.630244829, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.498472325, "time_to_first_token": 0.834235917, "token_sha": "8a91591c94a3", "tokens_per_second": 18.89102661845106}, "seed": 1234, "sent": 975191.188138457, "speculative": {"acceptance_rate": 0.423444976076555, "accepted": 177, "drafted": 418, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8393463710090145, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 418, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.899909031004967, "done": 975205.52173453, "finish_reason": "length", "first": 975192.029332045, "full_response_s": 14.336267270962708, "last": 975205.521460477, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975192.029332045, 3], [975192.155373409, 11], [975192.335263071, 30], [975192.522409479, 19], [975192.700218957, 21], [975192.882590388, 15], [975193.035607619, 19], [975193.187596606, 17], [975193.365854922, 12], [975193.548350547, 5], [975193.693336391, 5], [975193.875899648, 27], [975194.066715552, 12], [975194.248992876, 13], [975194.431262055, 5], [975194.578637982, 16], [975194.764472755, 5], [975194.948649796, 14], [975195.132688703, 9], [975195.32038811, 27], [975195.464640641, 11], [975195.649206469, 8], [975195.793428298, 16], [975195.944570064, 5], [975196.097286149, 9], [975196.279717661, 14], [975196.429249496, 20], [975196.574472619, 8], [975196.725431817, 12], [975196.873454312, 5], [975197.028741, 14], [975197.215342233, 14], [975197.359981308, 8], [975197.543262266, 13], [975197.714722221, 3], [975197.894903395, 10], [975198.05016526, 11], [975198.233611389, 9], [975198.415488768, 10], [975198.599156312, 20], [975198.747548452, 14], [975198.934159893, 14], [975199.164812966, 13], [975199.350482195, 5], [975199.531813543, 22], [975199.76061271, 3], [975200.002231842, 32], [975200.187250868, 33], [975200.370462578, 11], [975200.553850729, 6], [975200.700366724, 8], [975200.850337807, 9], [975201.007155295, 13], [975201.156274196, 8], [975201.308543524, 20], [975201.453504952, 17], [975201.638506436, 20], [975201.787763923, 13], [975201.976462653, 6], [975202.163397746, 13], [975202.31354394, 9], [975202.463305877, 11], [975202.610822213, 8], [975202.797048585, 15], [975202.985628082, 16], [975203.202709566, 27], [975203.434159054, 4], [975203.584025491, 8], [975203.767850325, 25], [975203.957217686, 18], [975204.109071487, 13], [975204.292486268, 55], [975204.442745705, 11], [975204.625976685, 10], [975204.815652692, 11], [975204.967020586, 15], [975205.120209331, 17], [975205.267761977, 14], [975205.521460477, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4a96d519eb24881447a981a2f5eb674a", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.630223423, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.494130571, "time_to_first_token": 0.840819444, "token_sha": "8a91591c94a3", "tokens_per_second": 18.897104830748862}, "seed": 1234, "sent": 975191.185467259, "speculative": {"acceptance_rate": 0.4135514018691589, "accepted": 177, "drafted": 428, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8438647859729826, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 428, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.897685257424367, "done": 975205.522988061, "finish_reason": "length", "first": 975192.02924936, "full_response_s": 14.334633036982268, "last": 975205.52296547, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975192.02924936, 3], [975192.155687716, 11], [975192.33710304, 30], [975192.518592521, 19], [975192.700291034, 21], [975192.88451717, 15], [975193.036069519, 19], [975193.186882428, 17], [975193.365768158, 12], [975193.5482218, 5], [975193.694290383, 5], [975193.877397569, 27], [975194.068952001, 12], [975194.251944718, 13], [975194.433134952, 5], [975194.579749823, 16], [975194.76217202, 5], [975194.948605062, 14], [975195.13502494, 9], [975195.319629278, 27], [975195.466989837, 11], [975195.647954138, 8], [975195.794563162, 16], [975195.945241428, 5], [975196.097982455, 9], [975196.280212072, 14], [975196.427262141, 20], [975196.575534493, 8], [975196.725801114, 12], [975196.874558969, 5], [975197.030080671, 14], [975197.213261441, 14], [975197.36116625, 8], [975197.543636282, 13], [975197.714779131, 3], [975197.895302578, 10], [975198.050954651, 11], [975198.237782381, 9], [975198.418475346, 10], [975198.599048813, 20], [975198.7491472, 14], [975198.932927465, 14], [975199.168555768, 13], [975199.348367196, 5], [975199.531714091, 22], [975199.766276903, 3], [975200.003010769, 32], [975200.186867188, 33], [975200.373357912, 11], [975200.555844757, 6], [975200.700718149, 8], [975200.850754637, 9], [975201.005418584, 13], [975201.158298639, 8], [975201.305357274, 20], [975201.454731796, 17], [975201.637903342, 20], [975201.787074784, 13], [975201.976584872, 6], [975202.165448604, 13], [975202.313035353, 9], [975202.461744151, 11], [975202.610635389, 8], [975202.796064578, 15], [975202.986039553, 16], [975203.201634171, 27], [975203.436606599, 4], [975203.584231099, 8], [975203.768552616, 25], [975203.956272814, 18], [975204.109315589, 13], [975204.294558165, 55], [975204.442454389, 11], [975204.628419191, 10], [975204.815192103, 11], [975204.967798825, 15], [975205.120556965, 17], [975205.269806084, 14], [975205.52296547, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-349741107235893562150a341930d253", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.630225471, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.494266997, "time_to_first_token": 0.837543328, "token_sha": "8a91591c94a3", "tokens_per_second": 18.896913782474492}, "seed": 1234, "sent": 975191.188355024, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8408943359972909, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.895422269472533, "done": 975205.523355822, "finish_reason": "length", "first": 975192.027997462, "full_response_s": 14.334712026990019, "last": 975205.523329631, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975192.027997462, 3], [975192.155918266, 11], [975192.336961126, 30], [975192.51951189, 19], [975192.699980967, 21], [975192.884581215, 15], [975193.035892983, 19], [975193.187226926, 17], [975193.36709287, 12], [975193.549119298, 5], [975193.693901679, 5], [975193.877145595, 27], [975194.066495994, 12], [975194.250320979, 13], [975194.433478105, 5], [975194.581274014, 16], [975194.765256465, 5], [975194.948125243, 14], [975195.134067444, 9], [975195.317795644, 27], [975195.464349486, 11], [975195.647059712, 8], [975195.797041345, 16], [975195.944956592, 5], [975196.095581613, 9], [975196.279417914, 14], [975196.427918737, 20], [975196.575698646, 8], [975196.724747174, 12], [975196.874660469, 5], [975197.029609235, 14], [975197.215028359, 14], [975197.361651077, 8], [975197.542888058, 13], [975197.713951054, 3], [975197.89586441, 10], [975198.050512797, 11], [975198.233707241, 9], [975198.417043343, 10], [975198.599289794, 20], [975198.748918426, 14], [975198.93276064, 14], [975199.167201249, 13], [975199.349370914, 5], [975199.531325819, 22], [975199.761585645, 3], [975200.002806441, 32], [975200.18694944, 33], [975200.371673343, 11], [975200.554551388, 6], [975200.699408684, 8], [975200.850198853, 9], [975201.00655972, 13], [975201.155136484, 8], [975201.307947805, 20], [975201.454656727, 17], [975201.637831105, 20], [975201.787156909, 13], [975201.975809497, 6], [975202.165919288, 13], [975202.312507615, 9], [975202.462351453, 11], [975202.611645539, 8], [975202.795553063, 15], [975202.98753005, 16], [975203.201160303, 27], [975203.436579768, 4], [975203.584167229, 8], [975203.768095083, 25], [975203.956077878, 18], [975204.10825013, 13], [975204.295276055, 55], [975204.443580614, 11], [975204.629700689, 10], [975204.813747588, 11], [975204.966650697, 15], [975205.123545639, 17], [975205.269698904, 14], [975205.523329631, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-7bc5dcb62f0783f228d1e64b863fe0d1", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.630227071, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.494324562, "time_to_first_token": 0.836878828, "token_sha": "8a91591c94a3", "tokens_per_second": 18.89683317074496}, "seed": 1234, "sent": 975191.188643795, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8393536669900641, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.897476250543868, "done": 975205.523618163, "finish_reason": "length", "first": 975192.028830466, "full_response_s": 14.335818955907598, "last": 975205.522695817, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975192.028830466, 3], [975192.156343048, 11], [975192.33706501, 30], [975192.519948992, 19], [975192.700358407, 21], [975192.882729838, 15], [975193.03582753, 19], [975193.1855721, 17], [975193.366271801, 12], [975193.549215758, 5], [975193.695717906, 5], [975193.87789086, 27], [975194.066197351, 12], [975194.250210808, 13], [975194.433085018, 5], [975194.578537315, 16], [975194.762305679, 5], [975194.948276228, 14], [975195.135269393, 9], [975195.316441285, 27], [975195.465127772, 11], [975195.646466313, 8], [975195.796047563, 16], [975195.944016472, 5], [975196.0974863, 9], [975196.280015088, 14], [975196.428588276, 20], [975196.575072273, 8], [975196.725344957, 12], [975196.87331803, 5], [975197.029673648, 14], [975197.212646955, 14], [975197.360633408, 8], [975197.54270133, 13], [975197.715374161, 3], [975197.897197266, 10], [975198.051374489, 11], [975198.233101747, 9], [975198.417536634, 10], [975198.598422551, 20], [975198.748110892, 14], [975198.934039642, 14], [975199.165178278, 13], [975199.350100883, 5], [975199.53193557, 22], [975199.760885034, 3], [975200.001888016, 32], [975200.188010644, 33], [975200.370917807, 11], [975200.552880722, 6], [975200.699534711, 8], [975200.849339497, 9], [975201.006496811, 13], [975201.158773978, 8], [975201.306148553, 20], [975201.453803787, 17], [975201.63766436, 20], [975201.786961413, 13], [975201.976405104, 6], [975202.163855183, 13], [975202.313438872, 9], [975202.461101746, 11], [975202.611596437, 8], [975202.795936071, 15], [975202.988316737, 16], [975203.200810686, 27], [975203.435841607, 4], [975203.585657615, 8], [975203.769174622, 25], [975203.956692076, 18], [975204.1074385, 13], [975204.293560015, 55], [975204.442105188, 11], [975204.626359261, 10], [975204.81611512, 11], [975204.966902863, 15], [975205.119576606, 17], [975205.268754576, 14], [975205.522695817, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-7bc9ca1006de7316e652124f63f6c500", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.630230334, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.494358178, "time_to_first_token": 0.836738674, "token_sha": "8a91591c94a3", "tokens_per_second": 18.89678609655769}, "seed": 1234, "sent": 975191.187799207, "speculative": {"acceptance_rate": 0.4194312796208531, "accepted": 177, "drafted": 422, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8410312589257956, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 422, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.89747414431079, "done": 975205.521815582, "finish_reason": "length", "first": 975192.027916665, "full_response_s": 14.335359148913994, "last": 975205.52178352, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975192.027916665, 3], [975192.155098285, 11], [975192.335845846, 30], [975192.518804784, 19], [975192.699259846, 21], [975192.882803563, 15], [975193.037162161, 19], [975193.185613394, 17], [975193.367677965, 12], [975193.546559375, 5], [975193.693607724, 5], [975193.876667472, 27], [975194.065812103, 12], [975194.248909727, 13], [975194.43177877, 5], [975194.580271209, 16], [975194.763356466, 5], [975194.948750672, 14], [975195.134423493, 9], [975195.319142674, 27], [975195.465745074, 11], [975195.650666599, 8], [975195.793643377, 16], [975195.944735769, 5], [975196.095388677, 9], [975196.278868433, 14], [975196.428188789, 20], [975196.574568582, 8], [975196.725067929, 12], [975196.873550932, 5], [975197.02907497, 14], [975197.214732675, 14], [975197.360711005, 8], [975197.542633509, 13], [975197.714467544, 3], [975197.895833244, 10], [975198.050906205, 11], [975198.234406987, 9], [975198.41724031, 10], [975198.59806471, 20], [975198.747347468, 14], [975198.934584083, 14], [975199.167337019, 13], [975199.347724023, 5], [975199.532431229, 22], [975199.76164537, 3], [975200.001827187, 32], [975200.187945894, 33], [975200.37350261, 11], [975200.553152023, 6], [975200.700563052, 8], [975200.849127186, 9], [975201.006306739, 13], [975201.154314534, 8], [975201.305303404, 20], [975201.453436587, 17], [975201.637336534, 20], [975201.787857295, 13], [975201.975725596, 6], [975202.1643938, 13], [975202.31222014, 9], [975202.461496225, 11], [975202.61147409, 8], [975202.796449426, 15], [975202.986736771, 16], [975203.200649365, 27], [975203.434446034, 4], [975203.583846203, 8], [975203.769656905, 25], [975203.955753139, 18], [975204.108684304, 13], [975204.29195741, 55], [975204.441906668, 11], [975204.628045894, 10], [975204.817195299, 11], [975204.967556067, 15], [975205.122836213, 17], [975205.268930216, 14], [975205.52178352, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-05b1168c86aca44ef7af29ef8b8ce3b2", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.63023163, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.494295332, "time_to_first_token": 0.836711267, "token_sha": "8a91591c94a3", "tokens_per_second": 18.896874103184924}, "seed": 1234, "sent": 975191.186456433, "speculative": {"acceptance_rate": 0.4194312796208531, "accepted": 177, "drafted": 422, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8414602319244295, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 422, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.89737540213991, "done": 975205.522414021, "finish_reason": "length", "first": 975192.028448531, "full_response_s": 14.335829689982347, "last": 975205.522385894, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975192.028448531, 3], [975192.156374167, 11], [975192.336015871, 30], [975192.519563952, 19], [975192.699360737, 21], [975192.883987801, 15], [975193.036012802, 19], [975193.18734828, 17], [975193.366500703, 12], [975193.545607191, 5], [975193.694444536, 5], [975193.876428874, 27], [975194.067869359, 12], [975194.250653909, 13], [975194.431458895, 5], [975194.581815431, 16], [975194.763398448, 5], [975194.949196765, 14], [975195.13464582, 9], [975195.318183259, 27], [975195.464162662, 11], [975195.646169382, 8], [975195.794375282, 16], [975195.945436283, 5], [975196.097173673, 9], [975196.279058297, 14], [975196.427820181, 20], [975196.57490908, 8], [975196.726172906, 12], [975196.874900523, 5], [975197.028820084, 14], [975197.21368392, 14], [975197.362336136, 8], [975197.543187197, 13], [975197.715220248, 3], [975197.8947958, 10], [975198.051624398, 11], [975198.236670108, 9], [975198.41657405, 10], [975198.598279805, 20], [975198.746557246, 14], [975198.934702062, 14], [975199.165742783, 13], [975199.349762369, 5], [975199.533512831, 22], [975199.764798629, 3], [975200.003174138, 32], [975200.187437196, 33], [975200.371873703, 11], [975200.554876142, 6], [975200.699913367, 8], [975200.849223214, 9], [975201.005972897, 13], [975201.154187324, 8], [975201.306795757, 20], [975201.454072944, 17], [975201.638289294, 20], [975201.787287767, 13], [975201.976148714, 6], [975202.164118324, 13], [975202.313747579, 9], [975202.462446873, 11], [975202.61237194, 8], [975202.795438572, 15], [975202.98635082, 16], [975203.200942872, 27], [975203.43539073, 4], [975203.583683874, 8], [975203.767913731, 25], [975203.956166402, 18], [975204.109764386, 13], [975204.292567273, 55], [975204.445042248, 11], [975204.627526364, 10], [975204.812720143, 11], [975204.966563373, 15], [975205.120848297, 17], [975205.270077928, 14], [975205.522385894, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-a387a2d615b44d4273ddb6cbc67f3acb", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.630227998, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.494295076, "time_to_first_token": 0.837011734, "token_sha": "8a91591c94a3", "tokens_per_second": 18.89687446167714}, "seed": 1234, "sent": 975191.186584331, "speculative": {"acceptance_rate": 0.4194312796208531, "accepted": 177, "drafted": 422, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8418642000760883, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 422, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.894416479851586, "done": 975205.52369088, "finish_reason": "length", "first": 975192.027602839, "full_response_s": 14.338080507004634, "last": 975205.523653393, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975192.027602839, 3], [975192.157436761, 11], [975192.33725537, 30], [975192.52121585, 19], [975192.699155882, 21], [975192.884816725, 15], [975193.035530038, 19], [975193.186941274, 17], [975193.366535741, 12], [975193.54778849, 5], [975193.694866534, 5], [975193.877619575, 27], [975194.06822448, 12], [975194.251353719, 13], [975194.432580607, 5], [975194.579639588, 16], [975194.762843848, 5], [975194.94979194, 14], [975195.136647927, 9], [975195.316933936, 27], [975195.467255746, 11], [975195.647619864, 8], [975195.793911893, 16], [975195.944214671, 5], [975196.09975798, 9], [975196.280056479, 14], [975196.428255379, 20], [975196.575416818, 8], [975196.724409061, 12], [975196.873911653, 5], [975197.029032827, 14], [975197.213429466, 14], [975197.360927332, 8], [975197.542964295, 13], [975197.715278149, 3], [975197.895226341, 10], [975198.050283655, 11], [975198.235174251, 9], [975198.418557951, 10], [975198.598654909, 20], [975198.748410895, 14], [975198.933066483, 14], [975199.165564342, 13], [975199.348756652, 5], [975199.532808429, 22], [975199.76297013, 3], [975200.003062782, 32], [975200.18819286, 33], [975200.371913333, 11], [975200.554444912, 6], [975200.700657976, 8], [975200.850540966, 9], [975201.006960951, 13], [975201.158392427, 8], [975201.305656301, 20], [975201.45363005, 17], [975201.639220246, 20], [975201.788765417, 13], [975201.975308398, 6], [975202.163539468, 13], [975202.313627328, 9], [975202.462618306, 11], [975202.614057085, 8], [975202.795992405, 15], [975202.985829273, 16], [975203.201841778, 27], [975203.434904159, 4], [975203.584985691, 8], [975203.7693042, 25], [975203.955661223, 18], [975204.108438842, 13], [975204.291665327, 55], [975204.445162787, 11], [975204.628323387, 10], [975204.816811411, 11], [975204.966338166, 15], [975205.122593631, 17], [975205.268822509, 14], [975205.523653393, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-d34f4dace2504401e011a58e7a828404", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.630229598, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.496235427, "time_to_first_token": 0.835877622, "token_sha": "8a91591c94a3", "tokens_per_second": 18.8941576619105}, "seed": 1234, "sent": 975191.185610373, "speculative": {"acceptance_rate": 0.4194312796208531, "accepted": 177, "drafted": 422, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8419924660120159, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 422, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.89216419261028, "done": 975205.525332395, "finish_reason": "length", "first": 975192.027550265, "full_response_s": 14.337838231003843, "last": 975205.525209792, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975192.027550265, 3], [975192.155602247, 11], [975192.336286035, 30], [975192.518553035, 19], [975192.699621206, 21], [975192.884682315, 15], [975193.036134637, 19], [975193.186438335, 17], [975193.366741221, 12], [975193.547567524, 5], [975193.69410935, 5], [975193.877066863, 18], [975194.068606288, 21], [975194.249274752, 13], [975194.433966836, 5], [975194.580230027, 16], [975194.762534245, 5], [975194.949689192, 14], [975195.134761719, 9], [975195.316709626, 27], [975195.464751948, 11], [975195.648022583, 8], [975195.793985618, 16], [975195.944825397, 5], [975196.096024922, 9], [975196.279764507, 14], [975196.427013511, 20], [975196.57590427, 8], [975196.724165967, 12], [975196.874701683, 5], [975197.029141303, 14], [975197.216708448, 14], [975197.361413855, 8], [975197.543749702, 13], [975197.714970018, 3], [975197.895797517, 10], [975198.050769394, 11], [975198.23628342, 9], [975198.416712125, 10], [975198.600252458, 20], [975198.748661109, 14], [975198.93362726, 14], [975199.165671602, 13], [975199.348665488, 5], [975199.531158275, 22], [975199.764082035, 3], [975200.00275246, 32], [975200.187118857, 33], [975200.373166032, 11], [975200.553942997, 6], [975200.699998035, 8], [975200.850683488, 9], [975201.00728401, 13], [975201.155837622, 8], [975201.305973104, 20], [975201.454275159, 17], [975201.639410366, 20], [975201.787943468, 13], [975201.975256752, 6], [975202.166192509, 13], [975202.314386992, 9], [975202.462789803, 11], [975202.611341744, 8], [975202.796535854, 15], [975202.986173435, 16], [975203.201390245, 27], [975203.435217426, 4], [975203.585146388, 8], [975203.768654323, 25], [975203.955820545, 18], [975204.108330143, 13], [975204.293154752, 55], [975204.4442874, 11], [975204.630296552, 10], [975204.815502826, 11], [975204.967235761, 15], [975205.122498291, 17], [975205.268676499, 14], [975205.525209792, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-42a9d5749be130b25a7f2c13cd3aa16a", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.630241997, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.498019624, "time_to_first_token": 0.834721544, "token_sha": "8a91591c94a3", "tokens_per_second": 18.891660191884753}, "seed": 1234, "sent": 975191.187494164, "speculative": {"acceptance_rate": 0.42042755344418054, "accepted": 177, "drafted": 421, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8400561009766534, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 421, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.897612885082804, "done": 975205.522117474, "finish_reason": "length", "first": 975192.028311176, "full_response_s": 14.338362429989502, "last": 975205.522078963, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975192.028311176, 3], [975192.15628961, 11], [975192.33641035, 30], [975192.518322565, 19], [975192.701200595, 21], [975192.883476798, 15], [975193.036331252, 19], [975193.185663408, 17], [975193.365639316, 12], [975193.547869623, 5], [975193.694753195, 5], [975193.876353677, 27], [975194.067156094, 12], [975194.251182975, 13], [975194.432019047, 5], [975194.581646479, 16], [975194.764834915, 5], [975194.948825517, 14], [975195.137224478, 9], [975195.317866425, 27], [975195.463793333, 11], [975195.650217162, 8], [975195.793324814, 16], [975195.944128867, 5], [975196.097626582, 9], [975196.279940915, 14], [975196.427873139, 20], [975196.575467792, 8], [975196.726317332, 12], [975196.874154618, 5], [975197.030148764, 14], [975197.213843305, 14], [975197.360399962, 8], [975197.54278963, 13], [975197.713463346, 3], [975197.896514495, 10], [975198.050375347, 11], [975198.232971592, 9], [975198.415781732, 10], [975198.598223007, 20], [975198.747110582, 14], [975198.932843069, 14], [975199.165967941, 13], [975199.349867805, 5], [975199.530426258, 22], [975199.7610437, 3], [975200.002485063, 32], [975200.18762426, 33], [975200.370632635, 11], [975200.556037101, 6], [975200.700614921, 8], [975200.850119944, 9], [975201.006042926, 13], [975201.158514181, 8], [975201.305164914, 20], [975201.453346046, 17], [975201.63808143, 20], [975201.786794972, 13], [975201.976525434, 6], [975202.165136073, 13], [975202.314844861, 9], [975202.460993399, 11], [975202.61041767, 8], [975202.79744348, 15], [975202.986410785, 16], [975203.20351462, 27], [975203.433832076, 4], [975203.583328641, 8], [975203.769533006, 25], [975203.95621552, 18], [975204.108039387, 13], [975204.296672509, 55], [975204.44123556, 11], [975204.62882383, 10], [975204.817532149, 11], [975204.967732748, 15], [975205.123161736, 17], [975205.269402309, 14], [975205.522078963, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-65dc2b1cb5f8ae39cef98757539e5b3b", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.630219151, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.494102284, "time_to_first_token": 0.84091656, "token_sha": "8a91591c94a3", "tokens_per_second": 18.897144443788182}, "seed": 1234, "sent": 975191.183755044, "speculative": {"acceptance_rate": 0.4125874125874126, "accepted": 177, "drafted": 429, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8445561319822446, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 429, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.866273258178634, "done": 975219.901200884, "finish_reason": "length", "first": 975206.384967794, "full_response_s": 14.350642043049447, "last": 975219.901150694, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975206.384967794, 3], [975206.511361269, 11], [975206.691572892, 30], [975206.878711651, 19], [975207.067475598, 21], [975207.248985767, 15], [975207.397236111, 19], [975207.546942187, 17], [975207.729357838, 12], [975207.910809359, 5], [975208.067510815, 5], [975208.248893975, 27], [975208.432984606, 12], [975208.61249802, 13], [975208.798878636, 5], [975208.949975756, 16], [975209.136294688, 5], [975209.318192109, 14], [975209.503449277, 9], [975209.683630993, 27], [975209.832040963, 11], [975210.020725054, 8], [975210.170600394, 16], [975210.317940911, 5], [975210.467945942, 9], [975210.648376313, 14], [975210.797985312, 20], [975210.948820715, 8], [975211.102720567, 12], [975211.249874668, 5], [975211.400979469, 14], [975211.582914602, 14], [975211.726335035, 8], [975211.908492436, 13], [975212.090856106, 3], [975212.270427875, 10], [975212.416739779, 11], [975212.59924253, 9], [975212.782747944, 10], [975212.970702926, 20], [975213.12247173, 14], [975213.302819205, 14], [975213.5334512, 13], [975213.715893932, 5], [975213.900880611, 22], [975214.136708707, 3], [975214.373849004, 32], [975214.558463639, 33], [975214.742787278, 11], [975214.927088492, 6], [975215.082247413, 8], [975215.233115982, 9], [975215.382383146, 13], [975215.530128325, 8], [975215.679347619, 20], [975215.829178233, 17], [975216.018866261, 20], [975216.170184692, 13], [975216.353429227, 6], [975216.539246599, 13], [975216.687536323, 9], [975216.840466801, 11], [975216.994217363, 8], [975217.181210473, 15], [975217.365224553, 16], [975217.576682668, 27], [975217.811531337, 4], [975217.964005208, 8], [975218.153085249, 25], [975218.335143468, 18], [975218.487074161, 13], [975218.669530043, 55], [975218.821575628, 11], [975219.012205631, 10], [975219.197327301, 11], [975219.349117463, 15], [975219.495660018, 17], [975219.64504308, 14], [975219.901150694, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b4548b7a847b20095bffd7fac360f4ba", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.597104836, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.516172964, "time_to_first_token": 0.831281148, "token_sha": "8a91591c94a3", "tokens_per_second": 18.866287127220577}, "seed": 1234, "sent": 975205.550558841, "speculative": {"acceptance_rate": 0.4154929577464789, "accepted": 177, "drafted": 426, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.834408952970989, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 426, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.87064479576528, "done": 975219.898820902, "finish_reason": "length", "first": 975206.385734113, "full_response_s": 14.348773382953368, "last": 975219.89878588, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975206.385734113, 3], [975206.511670936, 11], [975206.693707458, 30], [975206.878539451, 19], [975207.066994498, 21], [975207.250697743, 15], [975207.399706648, 19], [975207.548790909, 17], [975207.729462682, 12], [975207.909820809, 5], [975208.068053544, 5], [975208.248960308, 27], [975208.43436538, 12], [975208.61557386, 13], [975208.799327929, 5], [975208.949771973, 16], [975209.134846429, 5], [975209.317051004, 14], [975209.501756067, 9], [975209.684405024, 27], [975209.83220334, 11], [975210.023223606, 8], [975210.170092959, 16], [975210.317474691, 5], [975210.465902635, 9], [975210.649727904, 14], [975210.797626735, 20], [975210.948941494, 8], [975211.103838073, 12], [975211.249159066, 5], [975211.400045156, 14], [975211.581666238, 14], [975211.726708667, 8], [975211.908709403, 13], [975212.0914836, 3], [975212.269553, 10], [975212.417308475, 11], [975212.59983129, 9], [975212.785057656, 10], [975212.970865671, 20], [975213.121862412, 14], [975213.302895602, 14], [975213.532608851, 13], [975213.716045526, 5], [975213.900129906, 22], [975214.138035868, 3], [975214.373350497, 32], [975214.557413347, 33], [975214.742079244, 11], [975214.928760887, 6], [975215.083287865, 8], [975215.233331413, 9], [975215.383711235, 13], [975215.530466615, 8], [975215.679222184, 20], [975215.828394329, 17], [975216.020180063, 20], [975216.169552318, 13], [975216.353599316, 6], [975216.539539371, 13], [975216.687153827, 9], [975216.840533982, 11], [975216.995874047, 8], [975217.181368978, 15], [975217.364561157, 16], [975217.577685731, 27], [975217.811083212, 4], [975217.963196522, 8], [975218.151741769, 25], [975218.336050198, 18], [975218.487991819, 13], [975218.669605032, 55], [975218.823936075, 11], [975219.012945072, 10], [975219.197851759, 11], [975219.349745454, 15], [975219.496609691, 17], [975219.64564392, 14], [975219.89878588, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-e4651926eecc3a7b0b3d698b11cc9cb4", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.597095861, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.516045529, "time_to_first_token": 0.831888386, "token_sha": "8a91591c94a3", "tokens_per_second": 18.866465006563683}, "seed": 1234, "sent": 975205.550047519, "speculative": {"acceptance_rate": 0.4125874125874126, "accepted": 177, "drafted": 429, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8356865940149873, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 429, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.86723440217787, "done": 975219.899740656, "finish_reason": "length", "first": 975206.384224833, "full_response_s": 14.349628180032596, "last": 975219.899719185, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975206.384224833, 3], [975206.510410477, 11], [975206.691870575, 30], [975206.876692104, 19], [975207.066722317, 21], [975207.249968574, 15], [975207.39927881, 19], [975207.546300198, 17], [975207.728143729, 12], [975207.911411078, 5], [975208.069188376, 5], [975208.249019457, 27], [975208.433040748, 12], [975208.614418996, 13], [975208.802748282, 5], [975208.949814323, 16], [975209.13566889, 5], [975209.318017476, 14], [975209.500067786, 9], [975209.684233063, 27], [975209.833320942, 11], [975210.021748739, 8], [975210.170282423, 16], [975210.317666987, 5], [975210.468321222, 9], [975210.647711812, 14], [975210.797826934, 20], [975210.950756602, 8], [975211.10457281, 12], [975211.248296942, 5], [975211.39975472, 14], [975211.581511877, 14], [975211.727596118, 8], [975211.909051181, 13], [975212.09076091, 3], [975212.269603077, 10], [975212.419430115, 11], [975212.601599216, 9], [975212.784545838, 10], [975212.971311236, 20], [975213.123734734, 14], [975213.303106649, 14], [975213.534040376, 13], [975213.716207855, 5], [975213.901866698, 22], [975214.13822842, 3], [975214.375953605, 32], [975214.557761604, 33], [975214.74240539, 11], [975214.927891819, 6], [975215.082620357, 8], [975215.231216013, 9], [975215.383432559, 13], [975215.530371227, 8], [975215.680216495, 20], [975215.829280901, 17], [975216.018948946, 20], [975216.17029016, 13], [975216.35292464, 6], [975216.538683151, 13], [975216.68830562, 9], [975216.839380238, 11], [975216.99545824, 8], [975217.180434537, 15], [975217.364805387, 16], [975217.579414619, 27], [975217.813689552, 4], [975217.963958346, 8], [975218.154497655, 25], [975218.337423982, 18], [975218.487113039, 13], [975218.669954602, 55], [975218.823816784, 11], [975219.013230693, 10], [975219.198520291, 11], [975219.347955079, 15], [975219.495553271, 17], [975219.645848247, 14], [975219.899719185, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-1aa1a597de9c604a1b73b76532f83c70", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.597097909, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.516380587, "time_to_first_token": 0.831264988, "token_sha": "8a91591c94a3", "tokens_per_second": 18.865997325146196}, "seed": 1234, "sent": 975205.550112476, "speculative": {"acceptance_rate": 0.41451990632318503, "accepted": 177, "drafted": 427, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8341123569989577, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 427, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 17.958051716460005, "done": 975219.899667779, "finish_reason": "length", "first": 975205.69942708, "full_response_s": 14.34927336301189, "last": 975219.899185719, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975205.69942708, 3], [975205.786769834, 26], [975206.509699979, 15], [975206.692309837, 19], [975206.87688328, 21], [975207.066566132, 15], [975207.252505364, 19], [975207.399625915, 17], [975207.548431676, 6], [975207.728585087, 11], [975207.9097335, 5], [975208.067369172, 18], [975208.248495479, 21], [975208.433539879, 5], [975208.614069219, 8], [975208.798639414, 5], [975208.94860039, 16], [975209.135738103, 5], [975209.318570365, 14], [975209.499442628, 9], [975209.684145323, 27], [975209.831240388, 11], [975210.020011836, 8], [975210.16981657, 16], [975210.318714367, 5], [975210.466045813, 9], [975210.648631294, 14], [975210.797126148, 20], [975210.950317501, 8], [975211.10255555, 12], [975211.247884911, 5], [975211.398269901, 14], [975211.58158725, 14], [975211.726659357, 8], [975211.908085749, 13], [975212.088587112, 3], [975212.269683186, 10], [975212.417402007, 11], [975212.600834624, 9], [975212.78410856, 10], [975212.970437161, 20], [975213.123487032, 14], [975213.302744904, 14], [975213.533665591, 13], [975213.715367906, 5], [975213.901617428, 22], [975214.137324729, 3], [975214.375745262, 32], [975214.55767636, 33], [975214.742662724, 11], [975214.927166921, 6], [975215.082931368, 8], [975215.23177455, 9], [975215.383017088, 13], [975215.529404995, 8], [975215.678888902, 20], [975215.828198242, 17], [975216.019359745, 20], [975216.168993909, 13], [975216.35349252, 6], [975216.538376635, 13], [975216.687962818, 9], [975216.840013668, 11], [975216.994827914, 8], [975217.180362988, 15], [975217.365111534, 16], [975217.5769888, 27], [975217.812190158, 4], [975217.965150553, 8], [975218.152408669, 25], [975218.334667903, 18], [975218.486960278, 13], [975218.668718765, 55], [975218.822358828, 11], [975219.012677371, 10], [975219.198959361, 11], [975219.347129017, 15], [975219.497918629, 17], [975219.646707524, 14], [975219.899185719, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-9e09163084ad47a730d1dbe3ca465cca", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.146163232, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 14.200474545, "time_to_first_token": 0.147245123, "token_sha": "8a91591c94a3", "tokens_per_second": 17.95714637506855}, "seed": 1234, "sent": 975205.550394416, "speculative": {"acceptance_rate": 0.40274599542334094, "accepted": 176, "drafted": 437, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.14903266401961446, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 437, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.86847769373889, "done": 975219.8999434, "finish_reason": "length", "first": 975206.385314867, "full_response_s": 14.349255188019015, "last": 975219.899918649, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975206.385314867, 3], [975206.51124801, 11], [975206.690670273, 30], [975206.878115532, 19], [975207.06685292, 21], [975207.251080079, 15], [975207.397579409, 19], [975207.547274205, 17], [975207.728349096, 12], [975207.910708292, 5], [975208.06866315, 5], [975208.250519875, 27], [975208.43379766, 12], [975208.614773269, 13], [975208.798716723, 5], [975208.948744624, 16], [975209.135306873, 5], [975209.318826738, 14], [975209.500654833, 9], [975209.683802985, 27], [975209.830542417, 11], [975210.02196473, 8], [975210.168228205, 16], [975210.317134801, 5], [975210.46534901, 9], [975210.649072876, 14], [975210.797905875, 20], [975210.949758836, 8], [975211.102490689, 12], [975211.248115397, 5], [975211.397842095, 14], [975211.579918167, 14], [975211.725741619, 8], [975211.909924793, 13], [975212.089420709, 3], [975212.270784372, 10], [975212.420352061, 11], [975212.599154422, 9], [975212.783950054, 10], [975212.971773409, 20], [975213.123224307, 14], [975213.303353711, 14], [975213.533539821, 13], [975213.714882486, 5], [975213.900265148, 22], [975214.137903937, 3], [975214.374384246, 32], [975214.559926987, 33], [975214.743829363, 11], [975214.927234198, 6], [975215.081887347, 8], [975215.232133031, 9], [975215.383935498, 13], [975215.529689175, 8], [975215.679817184, 20], [975215.827763844, 17], [975216.01943275, 20], [975216.170562933, 13], [975216.353080121, 6], [975216.53902712, 13], [975216.686977675, 9], [975216.839556439, 11], [975216.995992746, 8], [975217.181934011, 15], [975217.365808497, 16], [975217.577061181, 27], [975217.814729093, 4], [975217.964870805, 8], [975218.153810163, 25], [975218.336753337, 18], [975218.486632275, 13], [975218.671279683, 55], [975218.822147972, 11], [975219.012108451, 10], [975219.198068262, 11], [975219.348398645, 15], [975219.49572616, 17], [975219.646320804, 14], [975219.899918649, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-f7b2528ba9cce9878ea589808cec46a2", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.597100069, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.516236049, "time_to_first_token": 0.831052564, "token_sha": "8a91591c94a3", "tokens_per_second": 18.866199071661388}, "seed": 1234, "sent": 975205.550688212, "speculative": {"acceptance_rate": 0.41843971631205673, "accepted": 177, "drafted": 423, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8346266549779102, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 423, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 17.95735949914289, "done": 975219.900692137, "finish_reason": "length", "first": 975205.699276222, "full_response_s": 14.350512095959857, "last": 975219.899582231, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975205.699276222, 3], [975205.786910948, 26], [975206.509808006, 15], [975206.692410536, 19], [975206.876798963, 21], [975207.068215215, 15], [975207.250839945, 19], [975207.398451996, 17], [975207.546093742, 6], [975207.729103769, 11], [975207.910203001, 5], [975208.06684161, 18], [975208.248303071, 21], [975208.432141921, 5], [975208.613979366, 8], [975208.798333683, 5], [975208.949062514, 16], [975209.13715926, 5], [975209.317943367, 14], [975209.503962391, 9], [975209.683902549, 27], [975209.832761733, 11], [975210.022296892, 8], [975210.170844576, 16], [975210.316662613, 5], [975210.465949945, 9], [975210.648458501, 14], [975210.798757552, 20], [975210.949105087, 8], [975211.10433962, 12], [975211.248230161, 5], [975211.399187127, 14], [975211.580822961, 14], [975211.727956231, 8], [975211.910555311, 13], [975212.088333843, 3], [975212.269749887, 10], [975212.41901706, 11], [975212.599609395, 9], [975212.782973839, 10], [975212.971148155, 20], [975213.120346459, 14], [975213.30298659, 14], [975213.534563602, 13], [975213.715472893, 5], [975213.901550743, 22], [975214.137187087, 3], [975214.374952559, 32], [975214.559569546, 33], [975214.743169439, 11], [975214.926686445, 6], [975215.083337655, 8], [975215.232079385, 9], [975215.383886764, 13], [975215.530824569, 8], [975215.680163474, 20], [975215.829389872, 17], [975216.019902938, 20], [975216.171016082, 13], [975216.353355646, 6], [975216.540493444, 13], [975216.687354187, 9], [975216.839932647, 11], [975216.994338366, 8], [975217.180983362, 15], [975217.365172779, 16], [975217.578540784, 27], [975217.812813445, 4], [975217.963413825, 8], [975218.152282642, 25], [975218.335854398, 18], [975218.486901784, 13], [975218.670158609, 55], [975218.822418937, 11], [975219.013734192, 10], [975219.199182968, 11], [975219.348784469, 15], [975219.497785387, 17], [975219.645800441, 14], [975219.899582231, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-27f07a88a360df2696cff15b07eaeea7", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.146171184, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 14.20059118, "time_to_first_token": 0.147284049, "token_sha": "8a91591c94a3", "tokens_per_second": 17.956998886013984}, "seed": 1234, "sent": 975205.550180041, "speculative": {"acceptance_rate": 0.40274599542334094, "accepted": 176, "drafted": 437, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1490961810341105, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 437, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.86696777545791, "done": 975219.9000317, "finish_reason": "length", "first": 975206.38430075, "full_response_s": 14.349810941028409, "last": 975219.899986102, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975206.38430075, 3], [975206.510707905, 11], [975206.692457207, 30], [975206.877357004, 19], [975207.067415296, 21], [975207.249452195, 15], [975207.397697004, 19], [975207.544924735, 17], [975207.727810447, 12], [975207.910328691, 5], [975208.069975736, 5], [975208.248420091, 27], [975208.434947068, 12], [975208.613609462, 13], [975208.80213354, 5], [975208.949431331, 16], [975209.136413003, 5], [975209.317422925, 14], [975209.501422481, 9], [975209.684774289, 27], [975209.831132681, 11], [975210.021094255, 8], [975210.169201076, 16], [975210.316755185, 5], [975210.466143505, 9], [975210.648747753, 14], [975210.798100811, 20], [975210.947899969, 8], [975211.103513078, 12], [975211.249361265, 5], [975211.399667619, 14], [975211.581795625, 14], [975211.727543768, 8], [975211.910232988, 13], [975212.092425993, 3], [975212.269169031, 10], [975212.416894876, 11], [975212.59935203, 9], [975212.785898725, 10], [975212.97108179, 20], [975213.122151632, 14], [975213.302661979, 14], [975213.533163084, 13], [975213.716253421, 5], [975213.900697226, 22], [975214.137038021, 3], [975214.374670762, 32], [975214.559425903, 33], [975214.743286106, 11], [975214.926764634, 6], [975215.082850924, 8], [975215.231050836, 9], [975215.382059304, 13], [975215.530781178, 8], [975215.680030487, 20], [975215.829429823, 17], [975216.019109291, 20], [975216.169806916, 13], [975216.353314416, 6], [975216.540123459, 13], [975216.687472614, 9], [975216.839142328, 11], [975216.993928639, 8], [975217.182012408, 15], [975217.364870696, 16], [975217.579674209, 27], [975217.814492527, 4], [975217.963822576, 8], [975218.152548215, 25], [975218.335799985, 18], [975218.486225252, 13], [975218.669791744, 55], [975218.821042866, 11], [975219.013105514, 10], [975219.199093388, 11], [975219.347638116, 15], [975219.497048825, 17], [975219.646120012, 14], [975219.899986102, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-199b70bd79a765cf8bbd306140fc1254", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.597092085, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.516182755, "time_to_first_token": 0.831945983, "token_sha": "8a91591c94a3", "tokens_per_second": 18.866273460653574}, "seed": 1234, "sent": 975205.550220759, "speculative": {"acceptance_rate": 0.4125874125874126, "accepted": 177, "drafted": 429, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8340799909783527, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 429, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.86848278689941, "done": 975219.900260427, "finish_reason": "length", "first": 975206.385629606, "full_response_s": 14.349825788056478, "last": 975219.90022974, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975206.385629606, 3], [975206.510274819, 11], [975206.690584517, 30], [975206.87615091, 19], [975207.067096941, 21], [975207.249137985, 15], [975207.398385359, 19], [975207.544811652, 17], [975207.728062148, 12], [975207.909085207, 5], [975208.07088709, 5], [975208.248085097, 18], [975208.432835172, 21], [975208.615719006, 13], [975208.801794226, 5], [975208.949714599, 16], [975209.136108664, 5], [975209.316846933, 14], [975209.499338728, 9], [975209.683763579, 27], [975209.830827205, 11], [975210.021463983, 8], [975210.168706697, 16], [975210.318236947, 5], [975210.467512696, 9], [975210.648140243, 14], [975210.798047773, 20], [975210.947575407, 8], [975211.103979107, 12], [975211.248611681, 5], [975211.400371526, 14], [975211.58330737, 14], [975211.725880174, 8], [975211.910290938, 13], [975212.089697642, 3], [975212.27050736, 10], [975212.418117146, 11], [975212.598692025, 9], [975212.784602347, 10], [975212.97080201, 20], [975213.121159849, 14], [975213.303613044, 14], [975213.534169891, 13], [975213.714995761, 5], [975213.901217317, 22], [975214.137615453, 3], [975214.373668996, 32], [975214.55704805, 33], [975214.74331596, 11], [975214.927388128, 6], [975215.083493921, 8], [975215.230585703, 9], [975215.382157796, 13], [975215.529316343, 8], [975215.678742332, 20], [975215.829110396, 17], [975216.019505003, 20], [975216.16990392, 13], [975216.354131262, 6], [975216.540793399, 13], [975216.68722424, 9], [975216.839242388, 11], [975216.996561347, 8], [975217.181484414, 15], [975217.365297782, 16], [975217.57915863, 27], [975217.812120961, 4], [975217.96479532, 8], [975218.151527329, 25], [975218.33556457, 18], [975218.488738412, 13], [975218.668642768, 55], [975218.821929597, 11], [975219.013440588, 10], [975219.198191185, 11], [975219.3469632, 15], [975219.495227844, 17], [975219.646914715, 14], [975219.90022974, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-c949b2e40c68d9867b7e4078d088f58b", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.597102229, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.516366684, "time_to_first_token": 0.830273558, "token_sha": "8a91591c94a3", "tokens_per_second": 18.866016730802095}, "seed": 1234, "sent": 975205.550434639, "speculative": {"acceptance_rate": 0.42042755344418054, "accepted": 177, "drafted": 421, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.835194966988638, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 421, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.867918983118454, "done": 975219.89954356, "finish_reason": "length", "first": 975206.383871616, "full_response_s": 14.348759799962863, "last": 975219.898875588, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975206.383871616, 3], [975206.509542321, 11], [975206.691511326, 30], [975206.878624775, 19], [975207.068974271, 21], [975207.250397676, 15], [975207.399918735, 19], [975207.546601801, 17], [975207.728446308, 12], [975207.911660348, 5], [975208.068293102, 5], [975208.252182125, 27], [975208.432466196, 12], [975208.615281424, 13], [975208.799965742, 5], [975208.948815277, 16], [975209.135880721, 5], [975209.318090817, 14], [975209.500577876, 9], [975209.683852791, 27], [975209.83023531, 11], [975210.020359357, 8], [975210.169274417, 16], [975210.316384224, 5], [975210.467136632, 9], [975210.648577728, 14], [975210.798365888, 20], [975210.948515496, 8], [975211.103067449, 12], [975211.248770058, 5], [975211.401308127, 14], [975211.583376375, 14], [975211.726109652, 8], [975211.909869275, 13], [975212.090054331, 3], [975212.269038685, 10], [975212.416645479, 11], [975212.598427972, 9], [975212.785321981, 10], [975212.971363202, 20], [975213.123990851, 14], [975213.303924375, 14], [975213.532175317, 13], [975213.715674453, 5], [975213.90281701, 22], [975214.139470304, 3], [975214.373436541, 32], [975214.55657703, 33], [975214.743745911, 11], [975214.927749361, 6], [975215.083815876, 8], [975215.231856258, 9], [975215.381538669, 13], [975215.530940964, 8], [975215.680373737, 20], [975215.828560563, 17], [975216.01976952, 20], [975216.168880106, 13], [975216.353175413, 6], [975216.539741123, 13], [975216.68674274, 9], [975216.838879171, 11], [975216.994428171, 8], [975217.179907471, 15], [975217.365909197, 16], [975217.578118481, 27], [975217.814418434, 4], [975217.96531549, 8], [975218.154166197, 25], [975218.334456552, 18], [975218.485700298, 13], [975218.670399127, 55], [975218.823488877, 11], [975219.012787639, 10], [975219.19972701, 11], [975219.348363238, 15], [975219.496072481, 17], [975219.645166979, 14], [975219.898875588, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-e8b9b4abaac3db76e0729cce3e6bcd58", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.597100805, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.516323902, "time_to_first_token": 0.830710244, "token_sha": "8a91591c94a3", "tokens_per_second": 18.866076445701914}, "seed": 1234, "sent": 975205.55078376, "speculative": {"acceptance_rate": 0.41843971631205673, "accepted": 177, "drafted": 423, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8330878559499979, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 423, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.862915407512155, "done": 975219.90232535, "finish_reason": "length", "first": 975206.383609978, "full_response_s": 14.351574804983102, "last": 975219.902198939, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975206.383609978, 3], [975206.510210677, 11], [975206.692960193, 30], [975206.876625275, 19], [975207.068356089, 21], [975207.249805957, 15], [975207.39851417, 19], [975207.546690837, 17], [975207.727709027, 12], [975207.910885148, 5], [975208.068361611, 5], [975208.250225311, 18], [975208.432601582, 21], [975208.613105755, 9], [975208.800368286, 9], [975208.949497184, 16], [975209.136841465, 5], [975209.318796435, 14], [975209.500952005, 9], [975209.684099117, 27], [975209.83283789, 11], [975210.022565649, 8], [975210.169761725, 16], [975210.315973953, 5], [975210.464964498, 9], [975210.647297718, 14], [975210.798304003, 20], [975210.949546285, 8], [975211.101693906, 12], [975211.248061, 5], [975211.398117636, 14], [975211.579729055, 14], [975211.726199472, 8], [975211.909991446, 13], [975212.088144634, 3], [975212.269925672, 10], [975212.420777163, 11], [975212.601266926, 9], [975212.784233131, 10], [975212.971650038, 20], [975213.122343336, 14], [975213.304179132, 14], [975213.532437114, 13], [975213.718608779, 5], [975213.899871229, 22], [975214.136438174, 3], [975214.373051053, 32], [975214.55642798, 33], [975214.743354759, 11], [975214.927707251, 6], [975215.084856921, 8], [975215.231571582, 9], [975215.383777552, 13], [975215.529510543, 8], [975215.680288284, 20], [975215.828776154, 17], [975216.018782217, 20], [975216.169725255, 13], [975216.354019139, 6], [975216.538878247, 13], [975216.688074573, 9], [975216.840070402, 11], [975216.994256034, 8], [975217.182180225, 15], [975217.364497303, 16], [975217.579792508, 27], [975217.812902417, 4], [975217.963896477, 8], [975218.151132162, 25], [975218.335755219, 18], [975218.487287992, 13], [975218.669915323, 55], [975218.824022615, 11], [975219.011849757, 10], [975219.197418289, 11], [975219.348008725, 15], [975219.495808748, 17], [975219.64627871, 14], [975219.902198939, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-3bba1daef8565048551cf39f2acd015f", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.597104501, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.519646116, "time_to_first_token": 0.830484877, "token_sha": "8a91591c94a3", "tokens_per_second": 18.861440440975517}, "seed": 1234, "sent": 975205.550750545, "speculative": {"acceptance_rate": 0.423444976076555, "accepted": 177, "drafted": 418, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.832859433023259, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 418, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.86842774788461, "done": 975219.89932093, "finish_reason": "length", "first": 975206.384652783, "full_response_s": 14.348819509963505, "last": 975219.899292339, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975206.384652783, 3], [975206.508930795, 11], [975206.691386707, 30], [975206.875554791, 19], [975207.068154897, 21], [975207.251898189, 15], [975207.396947131, 19], [975207.545721838, 17], [975207.729054011, 12], [975207.909667631, 5], [975208.066621844, 5], [975208.250321323, 18], [975208.431024736, 21], [975208.612997887, 13], [975208.797950275, 5], [975208.948486538, 16], [975209.133974193, 5], [975209.316460997, 14], [975209.500770572, 9], [975209.683193379, 27], [975209.833637968, 11], [975210.020999123, 8], [975210.169862537, 16], [975210.316514427, 5], [975210.464691549, 9], [975210.647882109, 14], [975210.79842051, 20], [975210.950051768, 8], [975211.102951998, 12], [975211.249821294, 5], [975211.39940571, 14], [975211.58013003, 14], [975211.726909107, 8], [975211.908194049, 13], [975212.08927174, 3], [975212.269230709, 10], [975212.422107156, 11], [975212.600294983, 9], [975212.78343558, 10], [975212.970263712, 20], [975213.12128106, 14], [975213.303057403, 14], [975213.53336362, 13], [975213.716350025, 5], [975213.901019613, 22], [975214.139209483, 3], [975214.373798142, 32], [975214.559049375, 33], [975214.743236044, 11], [975214.927824862, 6], [975215.084984275, 8], [975215.231688137, 9], [975215.383502908, 13], [975215.531010209, 8], [975215.679757666, 20], [975215.829249254, 17], [975216.020275611, 20], [975216.169457714, 13], [975216.353540278, 6], [975216.54073641, 13], [975216.688213367, 9], [975216.839298177, 11], [975216.993825524, 8], [975217.181734211, 15], [975217.364713246, 16], [975217.577317938, 27], [975217.813433883, 4], [975217.964211728, 8], [975218.153007284, 25], [975218.335375378, 18], [975218.487019651, 13], [975218.669722419, 55], [975218.821171597, 11], [975219.011967449, 10], [975219.198660846, 11], [975219.347797454, 15], [975219.495877769, 17], [975219.647242478, 14], [975219.899292339, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-6284e25908707edfb8fdf3966017876c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.597101653, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.51642033, "time_to_first_token": 0.830535578, "token_sha": "8a91591c94a3", "tokens_per_second": 18.86594185252006}, "seed": 1234, "sent": 975205.55050142, "speculative": {"acceptance_rate": 0.42042755344418054, "accepted": 177, "drafted": 421, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8341513630002737, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 421, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.86777482576488, "done": 975219.899072268, "finish_reason": "length", "first": 975206.383935821, "full_response_s": 14.34879363910295, "last": 975219.899043053, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975206.383935821, 3], [975206.511735766, 11], [975206.69352553, 30], [975206.877541252, 19], [975207.069065179, 21], [975207.250578564, 15], [975207.398982742, 19], [975207.545318575, 17], [975207.728771863, 12], [975207.911269996, 5], [975208.068914356, 5], [975208.252585005, 27], [975208.43274924, 12], [975208.613502522, 13], [975208.798521899, 5], [975208.948668035, 16], [975209.134978343, 5], [975209.317650339, 14], [975209.500686224, 9], [975209.683704701, 27], [975209.831362847, 11], [975210.020823354, 8], [975210.170477215, 16], [975210.318482537, 5], [975210.465471469, 9], [975210.648677196, 14], [975210.797480725, 20], [975210.949325942, 8], [975211.103431882, 12], [975211.247987579, 5], [975211.397582026, 14], [975211.582394688, 14], [975211.727894426, 8], [975211.909379999, 13], [975212.088923066, 3], [975212.269282691, 10], [975212.422572608, 11], [975212.600780738, 9], [975212.782868643, 10], [975212.970552564, 20], [975213.120241775, 14], [975213.302599998, 14], [975213.534273294, 13], [975213.71824905, 5], [975213.902622155, 22], [975214.139281512, 3], [975214.374093506, 32], [975214.558594594, 33], [975214.744085721, 11], [975214.927646341, 6], [975215.082080939, 8], [975215.230955912, 9], [975215.38383627, 13], [975215.53089471, 8], [975215.679880413, 20], [975215.828666766, 17], [975216.018663758, 20], [975216.171658615, 13], [975216.35394703, 6], [975216.540215839, 13], [975216.688149242, 9], [975216.840266649, 11], [975216.995341285, 8], [975217.181793537, 15], [975217.36505808, 16], [975217.576871524, 27], [975217.810769401, 4], [975217.963296309, 8], [975218.150984024, 25], [975218.335961882, 18], [975218.486108249, 13], [975218.669427615, 55], [975218.820728703, 11], [975219.013031597, 10], [975219.196974387, 11], [975219.346834565, 15], [975219.497856376, 17], [975219.64572414, 14], [975219.899043053, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-1dd297205b05d419ae810d5b8bfdd91a", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.597099173, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.516122629, "time_to_first_token": 0.831028437, "token_sha": "8a91591c94a3", "tokens_per_second": 18.866357386612908}, "seed": 1234, "sent": 975205.550278629, "speculative": {"acceptance_rate": 0.4154929577464789, "accepted": 177, "drafted": 426, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8336571920663118, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 426, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.86660163821708, "done": 975219.9005212, "finish_reason": "length", "first": 975206.384553939, "full_response_s": 14.35018247703556, "last": 975219.900501585, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975206.384553939, 3], [975206.50923891, 11], [975206.69222248, 30], [975206.87602578, 19], [975207.067761634, 21], [975207.249231533, 15], [975207.398074652, 19], [975207.545412747, 17], [975207.72798236, 12], [975207.909020522, 5], [975208.067050418, 5], [975208.249808769, 18], [975208.431338579, 21], [975208.614610764, 9], [975208.802500149, 9], [975208.94893916, 16], [975209.137365396, 5], [975209.318243402, 14], [975209.50236537, 9], [975209.68468914, 27], [975209.831851211, 11], [975210.0202013, 8], [975210.169445882, 16], [975210.318015932, 5], [975210.468404483, 9], [975210.649499226, 14], [975210.79880355, 20], [975210.948206916, 8], [975211.101983238, 12], [975211.247936045, 5], [975211.398607839, 14], [975211.582087773, 14], [975211.726773944, 8], [975211.910335832, 13], [975212.090313136, 3], [975212.269108122, 10], [975212.421672742, 11], [975212.599762861, 9], [975212.784050962, 10], [975212.971706388, 20], [975213.122728728, 14], [975213.303406525, 14], [975213.534476454, 13], [975213.71752532, 5], [975213.901444443, 22], [975214.137817765, 3], [975214.376048705, 32], [975214.559625911, 33], [975214.74299359, 11], [975214.928299546, 6], [975215.085309606, 8], [975215.233052721, 9], [975215.38359436, 13], [975215.531637223, 8], [975215.680095604, 20], [975215.828730716, 17], [975216.019054606, 20], [975216.171347636, 13], [975216.353234531, 6], [975216.540173681, 13], [975216.688012224, 9], [975216.839753199, 11], [975216.996480278, 8], [975217.180830841, 15], [975217.365544044, 16], [975217.578714856, 27], [975217.813162406, 4], [975217.96310227, 8], [975218.152907177, 25], [975218.337061613, 18], [975218.488819993, 13], [975218.669860477, 55], [975218.821685895, 11], [975219.012580367, 10], [975219.197939211, 11], [975219.348296601, 15], [975219.496155742, 17], [975219.646047839, 14], [975219.900501585, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-a18cdc0c12c60c3af4a86a6730a15176", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.597102757, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.51756497, "time_to_first_token": 0.830596248, "token_sha": "8a91591c94a3", "tokens_per_second": 18.864344322807423}, "seed": 1234, "sent": 975205.550338723, "speculative": {"acceptance_rate": 0.423444976076555, "accepted": 177, "drafted": 418, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8342152159893885, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 418, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.86642748601309, "done": 975219.900881937, "finish_reason": "length", "first": 975206.384759786, "full_response_s": 14.349902473040856, "last": 975219.900832195, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975206.384759786, 3], [975206.509370937, 11], [975206.693461196, 30], [975206.876956173, 19], [975207.068588591, 21], [975207.249345608, 15], [975207.39874136, 19], [975207.545494983, 17], [975207.729530855, 12], [975207.910670725, 5], [975208.069861308, 5], [975208.248193396, 27], [975208.431897051, 12], [975208.613307506, 13], [975208.803123146, 5], [975208.948880602, 16], [975209.136535542, 5], [975209.318509231, 14], [975209.502744794, 9], [975209.684826015, 27], [975209.831443852, 11], [975210.021520797, 8], [975210.168920352, 16], [975210.316976759, 5], [975210.466106386, 9], [975210.648998239, 14], [975210.798688082, 20], [975210.949841408, 8], [975211.104647335, 12], [975211.247798994, 5], [975211.398042935, 14], [975211.58202288, 14], [975211.727115258, 8], [975211.909103675, 13], [975212.091964188, 3], [975212.270705464, 10], [975212.419339815, 11], [975212.601016153, 9], [975212.783056027, 10], [975212.972111731, 20], [975213.121520186, 14], [975213.304379556, 14], [975213.534213761, 13], [975213.715169834, 5], [975213.902355286, 22], [975214.139544845, 3], [975214.375386525, 32], [975214.55834406, 33], [975214.743601309, 11], [975214.928065204, 6], [975215.08303234, 8], [975215.231900545, 9], [975215.38288471, 13], [975215.529618714, 8], [975215.680509299, 20], [975215.829030175, 17], [975216.020113154, 20], [975216.170749805, 13], [975216.352979214, 6], [975216.541045949, 13], [975216.687601729, 9], [975216.840840546, 11], [975216.996257647, 8], [975217.180172324, 15], [975217.364649281, 16], [975217.577432237, 27], [975217.814059121, 4], [975217.964707051, 8], [975218.154930725, 25], [975218.3356246, 18], [975218.48865464, 13], [975218.670440118, 55], [975218.821748965, 11], [975219.0138239, 10], [975219.198256366, 11], [975219.347881562, 15], [975219.496708967, 17], [975219.64529051, 14], [975219.900832195, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-a5ee09edb8458c33905f8c4a18bdb5e9", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.597096869, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.516237233, "time_to_first_token": 0.831570127, "token_sha": "8a91591c94a3", "tokens_per_second": 18.86619741901359}, "seed": 1234, "sent": 975205.550979464, "speculative": {"acceptance_rate": 0.41451990632318503, "accepted": 177, "drafted": 427, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8337803219910711, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 427, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.861869992320564, "done": 975219.903979746, "finish_reason": "length", "first": 975206.383722934, "full_response_s": 14.352640377008356, "last": 975219.90306116, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975206.383722934, 3], [975206.510848555, 11], [975206.692798344, 30], [975206.875755647, 19], [975207.06770386, 21], [975207.25126644, 15], [975207.398290899, 19], [975207.547998014, 17], [975207.727625399, 12], [975207.908919422, 5], [975208.070276427, 5], [975208.249231113, 18], [975208.433136088, 21], [975208.615837561, 9], [975208.798122027, 9], [975208.950206963, 16], [975209.13755078, 5], [975209.318431011, 14], [975209.503091548, 9], [975209.684738642, 27], [975209.832100896, 11], [975210.023140201, 8], [975210.168518545, 16], [975210.318187253, 5], [975210.465241943, 9], [975210.64780672, 14], [975210.797359034, 20], [975210.950539107, 8], [975211.102184637, 12], [975211.249285845, 5], [975211.398528787, 14], [975211.583670123, 14], [975211.727305106, 8], [975211.908290925, 13], [975212.090156695, 3], [975212.270367894, 10], [975212.418742943, 11], [975212.598806261, 9], [975212.784371653, 10], [975212.970368364, 20], [975213.122541231, 14], [975213.302532545, 14], [975213.532874696, 13], [975213.716580175, 5], [975213.902565725, 22], [975214.139091104, 3], [975214.373604087, 32], [975214.558036393, 33], [975214.742596086, 11], [975214.928504274, 6], [975215.082474491, 8], [975215.232188613, 9], [975215.381792707, 13], [975215.530419033, 8], [975215.679525404, 20], [975215.829331603, 17], [975216.020017334, 20], [975216.171270423, 13], [975216.354072256, 6], [975216.540827766, 13], [975216.687409161, 9], [975216.839632004, 11], [975216.99473563, 8], [975217.182071013, 15], [975217.365255048, 16], [975217.578916768, 27], [975217.812338072, 4], [975217.96445615, 8], [975218.153382997, 25], [975218.334974611, 18], [975218.486444699, 13], [975218.669197161, 55], [975218.823404833, 11], [975219.013506713, 10], [975219.200024533, 11], [975219.347283475, 15], [975219.496566221, 17], [975219.646879005, 14], [975219.90306116, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b0417425285debbe93765e0472c51ac3", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.597105045, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.520511041, "time_to_first_token": 0.830106173, "token_sha": "8a91591c94a3", "tokens_per_second": 18.86023384964743}, "seed": 1234, "sent": 975205.551339369, "speculative": {"acceptance_rate": 0.423444976076555, "accepted": 177, "drafted": 418, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8323835650226101, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 418, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.86626262624538, "done": 975219.902265912, "finish_reason": "length", "first": 975206.385947145, "full_response_s": 14.35232242103666, "last": 975219.902137662, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975206.385947145, 3], [975206.508843535, 11], [975206.693231046, 30], [975206.877054761, 19], [975207.069363119, 21], [975207.250943077, 15], [975207.39783743, 19], [975207.545953476, 17], [975207.727177673, 12], [975207.909295775, 5], [975208.068490006, 5], [975208.249634888, 18], [975208.430869878, 21], [975208.613810221, 9], [975208.801363492, 9], [975208.950032826, 16], [975209.134257765, 5], [975209.317178999, 14], [975209.499605901, 9], [975209.682993899, 27], [975209.83075396, 11], [975210.02279844, 8], [975210.17127283, 16], [975210.318819355, 5], [975210.465066286, 9], [975210.647035121, 14], [975210.798136921, 20], [975210.948306112, 8], [975211.103577763, 12], [975211.248478774, 5], [975211.398957025, 14], [975211.581944803, 14], [975211.727072268, 8], [975211.908903763, 13], [975212.090687697, 3], [975212.269812701, 10], [975212.418375295, 11], [975212.598853731, 9], [975212.783737679, 10], [975212.971932667, 20], [975213.123026555, 14], [975213.303861418, 14], [975213.53311779, 13], [975213.717789581, 5], [975213.901136104, 22], [975214.1385086, 3], [975214.37279692, 32], [975214.55728788, 33], [975214.742308866, 11], [975214.92729426, 6], [975215.085696374, 8], [975215.232515511, 9], [975215.382669774, 13], [975215.530311646, 8], [975215.678661856, 20], [975215.82799001, 17], [975216.01932853, 20], [975216.170369821, 13], [975216.353854185, 6], [975216.539917564, 13], [975216.688473325, 9], [975216.839032556, 11], [975216.994884376, 8], [975217.180780763, 15], [975217.36534834, 16], [975217.577819677, 27], [975217.812423989, 4], [975217.965250901, 8], [975218.152466347, 25], [975218.335201753, 18], [975218.486290577, 13], [975218.670744441, 55], [975218.822664127, 11], [975219.013164695, 10], [975219.198316668, 11], [975219.347209782, 15], [975219.496524607, 17], [975219.646477085, 14], [975219.902137662, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-37a72ccae3a1d2eba792d595d127cfe0", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.597103669, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.519582119, "time_to_first_token": 0.830235447, "token_sha": "8a91591c94a3", "tokens_per_second": 18.86152972447506}, "seed": 1234, "sent": 975205.549943491, "speculative": {"acceptance_rate": 0.423444976076555, "accepted": 177, "drafted": 418, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.836003654054366, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 418, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.836223917377783, "done": 975234.301226066, "finish_reason": "length", "first": 975220.76333746, "full_response_s": 14.366530047962442, "last": 975234.301082664, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975220.76333746, 3], [975220.889988045, 11], [975221.080652002, 30], [975221.263141047, 19], [975221.444134185, 21], [975221.626608414, 15], [975221.775346126, 19], [975221.921706933, 17], [975222.112281064, 12], [975222.295724719, 5], [975222.442876167, 5], [975222.625591292, 18], [975222.809612699, 21], [975223.000103435, 9], [975223.182704254, 9], [975223.329382081, 16], [975223.514054847, 5], [975223.695266587, 14], [975223.878904294, 9], [975224.069762177, 27], [975224.217240443, 11], [975224.398967579, 8], [975224.54650493, 16], [975224.694163285, 5], [975224.844630551, 9], [975225.036475698, 14], [975225.186835246, 20], [975225.332174727, 8], [975225.479625738, 12], [975225.630374949, 5], [975225.78081211, 14], [975225.964650105, 14], [975226.116162157, 8], [975226.298148965, 13], [975226.471567354, 3], [975226.654480412, 10], [975226.802261369, 11], [975226.99080419, 9], [975227.176459017, 10], [975227.362819208, 20], [975227.508690554, 14], [975227.691433436, 14], [975227.921811389, 13], [975228.113633142, 5], [975228.297391224, 22], [975228.528243884, 3], [975228.769948277, 32], [975228.955726604, 33], [975229.147688041, 11], [975229.328921883, 6], [975229.478506597, 8], [975229.625011596, 9], [975229.77547381, 13], [975229.923707016, 8], [975230.082467397, 20], [975230.232485892, 17], [975230.418608329, 20], [975230.567035337, 13], [975230.749091923, 6], [975230.934797102, 13], [975231.090757764, 9], [975231.238865513, 11], [975231.388114127, 8], [975231.572014935, 15], [975231.754421979, 16], [975231.971878313, 27], [975232.208637484, 4], [975232.355207622, 8], [975232.540394339, 25], [975232.726014303, 18], [975232.875887062, 13], [975233.069086872, 55], [975233.217191308, 11], [975233.403596209, 10], [975233.586864661, 11], [975233.73744922, 15], [975233.886565634, 17], [975234.044649738, 14], [975234.301082664, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b4c86c1cceb51093920ac9553cd9e6ba", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.584896111, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.539206936, "time_to_first_token": 0.823690557, "token_sha": "8a91591c94a3", "tokens_per_second": 18.834190304158007}, "seed": 1234, "sent": 975219.934696018, "speculative": {"acceptance_rate": 0.423444976076555, "accepted": 177, "drafted": 418, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8286414419999346, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 418, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.835056274992763, "done": 975234.301835066, "finish_reason": "length", "first": 975220.763203737, "full_response_s": 14.366353960009292, "last": 975234.301788187, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975220.763203737, 3], [975220.89083649, 11], [975221.079011093, 30], [975221.26232164, 19], [975221.443714506, 21], [975221.626095299, 15], [975221.775606835, 19], [975221.923473565, 17], [975222.112021522, 12], [975222.294960414, 5], [975222.442746508, 5], [975222.625151134, 18], [975222.811495662, 21], [975222.999602559, 13], [975223.182450504, 5], [975223.329592376, 16], [975223.512078816, 5], [975223.693849477, 14], [975223.877938878, 9], [975224.068048103, 27], [975224.216684945, 11], [975224.400232567, 8], [975224.546860196, 16], [975224.694611859, 5], [975224.845243646, 9], [975225.036904384, 14], [975225.186033167, 20], [975225.33146242, 8], [975225.479249977, 12], [975225.628957599, 5], [975225.78052361, 14], [975225.964785139, 14], [975226.11652435, 8], [975226.297822258, 13], [975226.470521653, 3], [975226.652517404, 10], [975226.80361413, 11], [975226.991383574, 9], [975227.179167323, 10], [975227.363473613, 20], [975227.508582814, 14], [975227.692210172, 14], [975227.921916185, 13], [975228.113055934, 5], [975228.297327195, 22], [975228.528144272, 3], [975228.768797028, 32], [975228.956260342, 33], [975229.144616406, 11], [975229.328798288, 6], [975229.476396715, 8], [975229.625986036, 9], [975229.776506824, 13], [975229.923409077, 8], [975230.084237597, 20], [975230.2337748, 17], [975230.417608177, 20], [975230.564185933, 13], [975230.750200678, 6], [975230.934456572, 13], [975231.091621969, 9], [975231.2391699, 11], [975231.389820538, 8], [975231.571864077, 15], [975231.754773181, 16], [975231.971689537, 27], [975232.206731305, 4], [975232.355917369, 8], [975232.541911334, 25], [975232.725698171, 18], [975232.876662071, 13], [975233.068076593, 55], [975233.216629843, 11], [975233.402889405, 10], [975233.586295276, 11], [975233.737323593, 15], [975233.8869277, 17], [975234.044718247, 14], [975234.301788187, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4b3295f1b81d4bce74ef6ceb2ef79ab0", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.584894255, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.539119372, "time_to_first_token": 0.824539898, "token_sha": "8a91591c94a3", "tokens_per_second": 18.83431211392971}, "seed": 1234, "sent": 975219.935481106, "speculative": {"acceptance_rate": 0.42042755344418054, "accepted": 177, "drafted": 421, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8277226309292018, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 421, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.83339059760006, "done": 975234.301741517, "finish_reason": "length", "first": 975220.761934142, "full_response_s": 14.366225981037132, "last": 975234.301715982, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975220.761934142, 3], [975220.889914928, 11], [975221.080363566, 30], [975221.262891393, 19], [975221.443877748, 21], [975221.628222028, 15], [975221.775132967, 19], [975221.922331548, 17], [975222.113144788, 12], [975222.295181093, 5], [975222.442038873, 5], [975222.626381052, 18], [975222.810274976, 21], [975223.001029573, 9], [975223.182619057, 9], [975223.330020519, 16], [975223.512658904, 5], [975223.69426498, 14], [975223.878569924, 9], [975224.067739731, 27], [975224.217910703, 11], [975224.39936433, 8], [975224.546604766, 16], [975224.696276271, 5], [975224.84587562, 9], [975225.036137936, 14], [975225.183357436, 20], [975225.333308904, 8], [975225.480111478, 12], [975225.628552288, 5], [975225.779272637, 14], [975225.965474775, 14], [975226.119759578, 8], [975226.298428905, 13], [975226.470681791, 3], [975226.653525603, 10], [975226.803550356, 11], [975226.991543712, 9], [975227.177203339, 10], [975227.361901773, 20], [975227.508947632, 14], [975227.691898217, 14], [975227.922092673, 13], [975228.113519435, 5], [975228.297434167, 22], [975228.530592284, 3], [975228.767956694, 32], [975228.957117715, 33], [975229.146499466, 11], [975229.330595463, 6], [975229.4771579, 8], [975229.624653755, 9], [975229.77670088, 13], [975229.924247698, 8], [975230.084451204, 20], [975230.231491853, 17], [975230.417310318, 20], [975230.564750982, 13], [975230.748761536, 6], [975230.935491682, 13], [975231.092134732, 9], [975231.237961229, 11], [975231.389017434, 8], [975231.5710951, 15], [975231.755224795, 16], [975231.970629916, 27], [975232.209204197, 4], [975232.356725113, 8], [975232.541407066, 25], [975232.727158752, 18], [975232.874894879, 13], [975233.068989852, 55], [975233.217013635, 11], [975233.40192826, 10], [975233.587205895, 11], [975233.736831853, 15], [975233.887449198, 17], [975234.04484493, 14], [975234.301715982, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-dbc9186b8c1471f257646fda7075c852", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.584900159, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.539757153, "time_to_first_token": 0.823513749, "token_sha": "8a91591c94a3", "tokens_per_second": 18.833424936539554}, "seed": 1234, "sent": 975219.935515536, "speculative": {"acceptance_rate": 0.423444976076555, "accepted": 177, "drafted": 418, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.826418605982326, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 418, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.835088037865937, "done": 975234.301382716, "finish_reason": "length", "first": 975220.762647456, "full_response_s": 14.366626859991811, "last": 975234.301209075, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975220.762647456, 3], [975220.889134016, 11], [975221.07919107, 30], [975221.262203277, 19], [975221.44492892, 21], [975221.628820307, 15], [975221.777166867, 19], [975221.922248191, 17], [975222.112378052, 12], [975222.296758036, 5], [975222.442107335, 5], [975222.626206723, 18], [975222.813769681, 21], [975223.000048061, 13], [975223.184642814, 5], [975223.330828406, 16], [975223.514818512, 5], [975223.695067875, 14], [975223.877057346, 9], [975224.069697235, 27], [975224.21619143, 11], [975224.400963705, 8], [975224.54818099, 16], [975224.695481999, 5], [975224.845691883, 9], [975225.035424893, 14], [975225.184595561, 20], [975225.333062899, 8], [975225.47912443, 12], [975225.629211845, 5], [975225.778842303, 14], [975225.966411809, 14], [975226.115954485, 8], [975226.298523029, 13], [975226.470614609, 3], [975226.653708892, 10], [975226.803414394, 11], [975226.990351217, 9], [975227.176312495, 10], [975227.36370482, 20], [975227.509469866, 14], [975227.68919148, 14], [975227.920612526, 13], [975228.113837678, 5], [975228.296301029, 22], [975228.528828372, 3], [975228.767298241, 32], [975228.954565467, 33], [975229.14697799, 11], [975229.328655878, 6], [975229.47744096, 8], [975229.626537998, 9], [975229.775915488, 13], [975229.92348333, 8], [975230.084305962, 20], [975230.23422723, 17], [975230.419074262, 20], [975230.564668953, 13], [975230.750112137, 6], [975230.936108601, 13], [975231.091671295, 9], [975231.23853343, 11], [975231.387349486, 8], [975231.570563346, 15], [975231.755890592, 16], [975231.971627252, 27], [975232.208748551, 4], [975232.356017621, 8], [975232.540886815, 25], [975232.725871588, 18], [975232.87506876, 13], [975233.06667193, 55], [975233.217765173, 11], [975233.403144659, 10], [975233.58678692, 11], [975233.73714928, 15], [975233.887212984, 17], [975234.04459774, 14], [975234.301209075, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-a200f5d1d951d3427cb67ffb55958522", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.584895183, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.539246214, "time_to_first_token": 0.823995153, "token_sha": "8a91591c94a3", "tokens_per_second": 18.834135665272274}, "seed": 1234, "sent": 975219.934755856, "speculative": {"acceptance_rate": 0.42042755344418054, "accepted": 177, "drafted": 421, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8278915999690071, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 421, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.832345556755264, "done": 975234.303277711, "finish_reason": "length", "first": 975220.762306494, "full_response_s": 14.366584655013867, "last": 975234.302839681, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975220.762306494, 3], [975220.889040452, 11], [975221.079083458, 30], [975221.262949582, 19], [975221.445286378, 21], [975221.627071163, 15], [975221.774905872, 19], [975221.922598993, 17], [975222.113771162, 12], [975222.294872706, 5], [975222.442143541, 5], [975222.626890231, 18], [975222.810636353, 21], [975223.001250732, 9], [975223.183868878, 9], [975223.332510273, 16], [975223.512517598, 5], [975223.696629315, 14], [975223.878252401, 9], [975224.068937602, 27], [975224.216911576, 11], [975224.399108149, 8], [975224.548631003, 16], [975224.695423969, 5], [975224.845320186, 9], [975225.035060108, 14], [975225.185974481, 20], [975225.333509152, 8], [975225.479193083, 12], [975225.629965622, 5], [975225.779885236, 14], [975225.965988418, 14], [975226.116598011, 8], [975226.29797382, 13], [975226.4703631, 3], [975226.65398872, 10], [975226.803317246, 11], [975226.991821205, 9], [975227.175843938, 10], [975227.362497621, 20], [975227.507596503, 14], [975227.690557264, 14], [975227.922356519, 13], [975228.114155969, 5], [975228.298394735, 22], [975228.529176358, 3], [975228.769041882, 32], [975228.955057447, 33], [975229.144891899, 11], [975229.329407016, 6], [975229.47989918, 8], [975229.626797043, 9], [975229.775545183, 13], [975229.92332244, 8], [975230.083477388, 20], [975230.23186523, 17], [975230.41817705, 20], [975230.565518183, 13], [975230.750304513, 6], [975230.934352288, 13], [975231.089895527, 9], [975231.237865217, 11], [975231.389884359, 8], [975231.57267134, 15], [975231.755969965, 16], [975231.971284658, 27], [975232.20859099, 4], [975232.3563458, 8], [975232.541677295, 25], [975232.726618022, 18], [975232.876305238, 13], [975233.067938599, 55], [975233.216482649, 11], [975233.401466983, 10], [975233.586675836, 11], [975233.737887426, 15], [975233.886500773, 17], [975234.04478986, 14], [975234.302839681, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-613762f96553f076b9f533046156cb91", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.584902238, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.541021471, "time_to_first_token": 0.823297997, "token_sha": "8a91591c94a3", "tokens_per_second": 18.83166646963217}, "seed": 1234, "sent": 975219.936693056, "speculative": {"acceptance_rate": 0.423444976076555, "accepted": 177, "drafted": 418, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8256134380353615, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 418, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.836693019421244, "done": 975234.300161581, "finish_reason": "length", "first": 975220.762724045, "full_response_s": 14.364924416993745, "last": 975234.30013211, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975220.762724045, 3], [975220.888971575, 11], [975221.078914201, 30], [975221.263400604, 19], [975221.444398094, 21], [975221.627853291, 15], [975221.775950773, 19], [975221.921371235, 17], [975222.113850215, 12], [975222.294730407, 5], [975222.442175124, 5], [975222.626114647, 27], [975222.810495863, 12], [975223.000366176, 13], [975223.184715595, 5], [975223.331142841, 16], [975223.511229939, 5], [975223.694652916, 14], [975223.877279465, 9], [975224.070421558, 27], [975224.218711007, 11], [975224.400269909, 8], [975224.547719169, 16], [975224.695637033, 5], [975224.844796432, 9], [975225.036397573, 14], [975225.185744954, 20], [975225.330625078, 8], [975225.480522597, 12], [975225.628696906, 5], [975225.779027111, 14], [975225.966594025, 14], [975226.117477303, 8], [975226.298598322, 13], [975226.471197033, 3], [975226.65277261, 10], [975226.8032648, 11], [975226.992326272, 9], [975227.178492134, 10], [975227.363655702, 20], [975227.507846428, 14], [975227.689798191, 14], [975227.921416669, 13], [975228.113386144, 5], [975228.296838495, 22], [975228.530660729, 3], [975228.769675264, 32], [975228.956676501, 33], [975229.145271692, 11], [975229.330198695, 6], [975229.478181346, 8], [975229.626970684, 9], [975229.77605761, 13], [975229.92316915, 8], [975230.082852597, 20], [975230.232326459, 17], [975230.419237455, 20], [975230.56527688, 13], [975230.748907178, 6], [975230.934058236, 13], [975231.091165092, 9], [975231.238092024, 11], [975231.38847752, 8], [975231.571724963, 15], [975231.755126159, 16], [975231.97260206, 27], [975232.20765378, 4], [975232.354978015, 8], [975232.54012363, 25], [975232.726668548, 18], [975232.876578218, 13], [975233.068688552, 55], [975233.217420083, 11], [975233.403759658, 10], [975233.587626838, 11], [975233.736541817, 15], [975233.886419032, 17], [975234.045058153, 14], [975234.30013211, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-0c1d7a64dcb49fb7b8121e666ad87a61", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.584883887, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.538266654, "time_to_first_token": 0.825318907, "token_sha": "8a91591c94a3", "tokens_per_second": 18.83549840737241}, "seed": 1234, "sent": 975219.935237164, "speculative": {"acceptance_rate": 0.4154929577464789, "accepted": 177, "drafted": 426, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8274868809385225, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 426, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.837237306964226, "done": 975234.299025579, "finish_reason": "length", "first": 975220.76198014, "full_response_s": 14.363622726057656, "last": 975234.298997052, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975220.76198014, 3], [975220.890467961, 11], [975221.08093639, 30], [975221.262785077, 19], [975221.445047795, 21], [975221.626751961, 15], [975221.778152363, 19], [975221.922386041, 17], [975222.112444673, 12], [975222.296505647, 5], [975222.442933509, 5], [975222.626826777, 27], [975222.814103251, 12], [975222.999792023, 13], [975223.184032903, 5], [975223.330902307, 16], [975223.511882904, 5], [975223.694433997, 14], [975223.876919032, 9], [975224.07011509, 27], [975224.218367037, 11], [975224.401925522, 8], [975224.546400055, 16], [975224.693916143, 5], [975224.845402743, 9], [975225.034380616, 14], [975225.186369809, 20], [975225.332674722, 8], [975225.479361652, 12], [975225.631026443, 5], [975225.778426656, 14], [975225.9650662, 14], [975226.118673894, 8], [975226.299239688, 13], [975226.471068655, 3], [975226.653070774, 10], [975226.803365948, 11], [975226.989981216, 9], [975227.175552062, 10], [975227.361629944, 20], [975227.50887741, 14], [975227.693524071, 14], [975227.921251796, 13], [975228.113136331, 5], [975228.29618209, 22], [975228.530814579, 3], [975228.767641667, 32], [975228.95474818, 33], [975229.147438084, 11], [975229.3284156, 6], [975229.47671371, 8], [975229.627059417, 9], [975229.776646418, 13], [975229.924294033, 8], [975230.082624158, 20], [975230.234515698, 17], [975230.418410113, 20], [975230.565429914, 13], [975230.749545552, 6], [975230.93503746, 13], [975231.08956474, 9], [975231.238625042, 11], [975231.38694803, 8], [975231.572593471, 15], [975231.756448857, 16], [975231.970738184, 27], [975232.2091138, 4], [975232.357125112, 8], [975232.540535261, 25], [975232.725614015, 18], [975232.875273519, 13], [975233.0661364, 55], [975233.217660297, 11], [975233.402784354, 10], [975233.58815384, 11], [975233.738890889, 15], [975233.887822895, 17], [975234.044448834, 14], [975234.298997052, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-c0880243c7392696c786b87077028e04", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.584886831, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.536492997, "time_to_first_token": 0.825422758, "token_sha": "8a91591c94a3", "tokens_per_second": 18.837966381433795}, "seed": 1234, "sent": 975219.935402853, "speculative": {"acceptance_rate": 0.41451990632318503, "accepted": 177, "drafted": 427, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8265772870508954, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 427, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.83624551190409, "done": 975234.300917231, "finish_reason": "length", "first": 975220.76315022, "full_response_s": 14.365301779005677, "last": 975234.300879904, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975220.76315022, 3], [975220.889551471, 11], [975221.079926384, 30], [975221.263433595, 19], [975221.444211462, 21], [975221.6264733, 15], [975221.775415163, 19], [975221.92339328, 17], [975222.112970219, 12], [975222.29558234, 5], [975222.441915871, 5], [975222.626021098, 27], [975222.810947317, 12], [975222.999868964, 13], [975223.183458927, 5], [975223.331386959, 16], [975223.510614668, 5], [975223.69576479, 14], [975223.875772471, 9], [975224.069606391, 27], [975224.215565855, 11], [975224.401348569, 8], [975224.547129609, 16], [975224.693828867, 5], [975224.844687316, 9], [975225.034327498, 14], [975225.183580883, 20], [975225.331631821, 8], [975225.480272415, 12], [975225.630442707, 5], [975225.778239511, 14], [975225.965152644, 14], [975226.115762909, 8], [975226.299905629, 13], [975226.469921934, 3], [975226.652933579, 10], [975226.802569516, 11], [975226.991096274, 9], [975227.177981131, 10], [975227.361159884, 20], [975227.50805274, 14], [975227.69379574, 14], [975227.921877498, 13], [975228.114100707, 5], [975228.297871829, 22], [975228.528323928, 3], [975228.768104688, 32], [975228.954667751, 33], [975229.147832596, 11], [975229.329999232, 6], [975229.479397745, 8], [975229.624589629, 9], [975229.775689481, 13], [975229.92397347, 8], [975230.084637549, 20], [975230.23328746, 17], [975230.417806185, 20], [975230.564845682, 13], [975230.749017302, 6], [975230.934143497, 13], [975231.092045504, 9], [975231.239423442, 11], [975231.388038498, 8], [975231.571526059, 15], [975231.756495655, 16], [975231.971545095, 27], [975232.208380774, 4], [975232.355821309, 8], [975232.542224585, 25], [975232.726930201, 18], [975232.877093958, 13], [975233.066326072, 55], [975233.217717927, 11], [975233.403532195, 10], [975233.587771552, 11], [975233.7369422, 15], [975233.887491901, 17], [975234.045264497, 14], [975234.300879904, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-46e4db0bcc70937c7b04911742a2def2", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.584892255, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.538457334, "time_to_first_token": 0.824636711, "token_sha": "8a91591c94a3", "tokens_per_second": 18.83523312213734}, "seed": 1234, "sent": 975219.935615452, "speculative": {"acceptance_rate": 0.41843971631205673, "accepted": 177, "drafted": 423, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8275347680319101, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 423, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.837749206956655, "done": 975234.299206692, "finish_reason": "length", "first": 975220.762246657, "full_response_s": 14.36437944706995, "last": 975234.298895712, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975220.762246657, 3], [975220.888434093, 11], [975221.078785039, 30], [975221.263816715, 19], [975221.444353632, 21], [975221.626173216, 15], [975221.774530496, 19], [975221.923540202, 17], [975222.111060874, 12], [975222.296282792, 5], [975222.442439737, 5], [975222.625370309, 27], [975222.810774236, 12], [975222.999960033, 13], [975223.184212912, 5], [975223.328844423, 16], [975223.513808729, 5], [975223.695723416, 14], [975223.876472506, 9], [975224.06855205, 27], [975224.216247523, 11], [975224.399221696, 8], [975224.54784214, 16], [975224.695944812, 5], [975224.84493769, 9], [975225.035911961, 14], [975225.185442391, 20], [975225.332468763, 8], [975225.479883215, 12], [975225.630698616, 5], [975225.779361465, 14], [975225.96628855, 14], [975226.118305461, 8], [975226.300360602, 13], [975226.471474846, 3], [975226.652104093, 10], [975226.803498278, 11], [975226.990168504, 9], [975227.178046041, 10], [975227.360163732, 20], [975227.508504146, 14], [975227.690748808, 14], [975227.921665955, 13], [975228.113671381, 5], [975228.296509468, 22], [975228.530512415, 3], [975228.768519055, 32], [975228.954939084, 33], [975229.144515787, 11], [975229.329538834, 6], [975229.478783546, 8], [975229.625465018, 9], [975229.775739175, 13], [975229.924123096, 8], [975230.083821518, 20], [975230.234932353, 17], [975230.418652007, 20], [975230.565370605, 13], [975230.749593294, 6], [975230.935886818, 13], [975231.089334398, 9], [975231.237367685, 11], [975231.389494519, 8], [975231.571352018, 15], [975231.755623131, 16], [975231.972312376, 27], [975232.206047141, 4], [975232.355868907, 8], [975232.541575555, 25], [975232.725930514, 18], [975232.876960651, 13], [975233.067497113, 55], [975233.218107431, 11], [975233.402533148, 10], [975233.5872685, 11], [975233.738535176, 15], [975233.888690636, 17], [975234.044064241, 14], [975234.298895712, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-ba4c495e6a0c718a1cedfe09c99aebe6", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.584882975, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.537061118, "time_to_first_token": 0.82562035, "token_sha": "8a91591c94a3", "tokens_per_second": 18.83717579297406}, "seed": 1234, "sent": 975219.934827245, "speculative": {"acceptance_rate": 0.41451990632318503, "accepted": 177, "drafted": 427, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8274194120895118, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 427, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.836911639009074, "done": 975234.299452474, "finish_reason": "length", "first": 975220.762176964, "full_response_s": 14.364427685039118, "last": 975234.299427915, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975220.762176964, 3], [975220.889648683, 11], [975221.081079264, 30], [975221.264232138, 19], [975221.444678691, 21], [975221.627300562, 15], [975221.776167244, 19], [975221.92265603, 17], [975222.113907621, 12], [975222.295624307, 5], [975222.442496183, 5], [975222.625285801, 27], [975222.811857711, 12], [975223.000660244, 13], [975223.183089998, 5], [975223.33039108, 16], [975223.513286238, 5], [975223.696369933, 14], [975223.876190166, 9], [975224.070913649, 27], [975224.217473329, 11], [975224.399527716, 8], [975224.546942048, 16], [975224.694032442, 5], [975224.845442581, 9], [975225.034591039, 14], [975225.184269175, 20], [975225.331359656, 8], [975225.480769435, 12], [975225.629357327, 5], [975225.780912458, 14], [975225.966786865, 14], [975226.120063886, 8], [975226.299076095, 13], [975226.471830336, 3], [975226.655431077, 10], [975226.802802819, 11], [975226.991469763, 9], [975227.17899309, 10], [975227.360842233, 20], [975227.507740161, 14], [975227.690916177, 14], [975227.921031149, 13], [975228.113486764, 5], [975228.298653045, 22], [975228.528061683, 3], [975228.768878657, 32], [975228.95685715, 33], [975229.145759144, 11], [975229.330053357, 6], [975229.479084238, 8], [975229.625131815, 9], [975229.775158095, 13], [975229.924679025, 8], [975230.082769033, 20], [975230.233845885, 17], [975230.417914709, 20], [975230.565750205, 13], [975230.749413285, 6], [975230.934529161, 13], [975231.090571228, 9], [975231.238828202, 11], [975231.389168724, 8], [975231.572151025, 15], [975231.75569428, 16], [975231.97236127, 27], [975232.207787566, 4], [975232.357364735, 8], [975232.540263352, 25], [975232.72552693, 18], [975232.87702532, 13], [975233.068428243, 55], [975233.217142318, 11], [975233.402154011, 10], [975233.586509827, 11], [975233.738326592, 15], [975233.88626907, 17], [975234.043764493, 14], [975234.299427915, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-3dae50949be95e74c1969910b3945979", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.584880623, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.536406425, "time_to_first_token": 0.825505394, "token_sha": "8a91591c94a3", "tokens_per_second": 18.83808685952631}, "seed": 1234, "sent": 975219.935024789, "speculative": {"acceptance_rate": 0.4125874125874126, "accepted": 177, "drafted": 429, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8271521750139073, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 429, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.837107218891962, "done": 975234.300393012, "finish_reason": "length", "first": 975220.76308115, "full_response_s": 14.365334560978226, "last": 975234.300191548, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975220.76308115, 3], [975220.888264164, 11], [975221.079973374, 30], [975221.263686176, 19], [975221.444738992, 21], [975221.626548081, 15], [975221.775843402, 19], [975221.921950219, 17], [975222.11143529, 12], [975222.296095823, 5], [975222.442849064, 5], [975222.625084001, 27], [975222.81296669, 12], [975222.999255581, 13], [975223.183822496, 5], [975223.330113539, 16], [975223.513196514, 5], [975223.696192021, 14], [975223.875967519, 9], [975224.070197663, 27], [975224.215376903, 11], [975224.401049605, 8], [975224.548009573, 16], [975224.695983403, 5], [975224.844385169, 9], [975225.03426502, 14], [975225.18668938, 20], [975225.332087226, 8], [975225.479015203, 12], [975225.629483322, 5], [975225.778365186, 14], [975225.967055846, 14], [975226.11882864, 8], [975226.298343757, 13], [975226.470217281, 3], [975226.65483939, 10], [975226.802163885, 11], [975226.992154007, 9], [975227.177306647, 10], [975227.362214385, 20], [975227.508749576, 14], [975227.689701635, 14], [975227.921171815, 13], [975228.112069126, 5], [975228.296949034, 22], [975228.52873644, 3], [975228.768364454, 32], [975228.955544659, 33], [975229.145930577, 11], [975229.329040279, 6], [975229.476606418, 8], [975229.624499537, 9], [975229.776191749, 13], [975229.924329023, 8], [975230.08313353, 20], [975230.232565137, 17], [975230.417092294, 20], [975230.566955868, 13], [975230.749240605, 6], [975230.933918738, 13], [975231.091497014, 9], [975231.238796588, 11], [975231.389550421, 8], [975231.570717228, 15], [975231.754970965, 16], [975231.972118384, 27], [975232.20724986, 4], [975232.356863379, 8], [975232.542796658, 25], [975232.724825727, 18], [975232.875381963, 13], [975233.067199525, 55], [975233.216256818, 11], [975233.401727356, 10], [975233.587138633, 11], [975233.738587686, 15], [975233.887315124, 17], [975234.043855322, 14], [975234.300191548, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b8eed6d83ebd6c03de5e0f3e8acc827c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.584893311, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.538391433, "time_to_first_token": 0.824622295, "token_sha": "8a91591c94a3", "tokens_per_second": 18.835324806640934}, "seed": 1234, "sent": 975219.935058451, "speculative": {"acceptance_rate": 0.41843971631205673, "accepted": 177, "drafted": 423, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8280226989882067, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 423, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.834966819085206, "done": 975234.3016768, "finish_reason": "length", "first": 975220.762994418, "full_response_s": 14.366555279004388, "last": 975234.301643169, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975220.762994418, 3], [975220.887966128, 11], [975221.078653044, 30], [975221.264117838, 19], [975221.443782567, 21], [975221.626341401, 15], [975221.775763997, 19], [975221.922540403, 17], [975222.114016464, 12], [975222.295475289, 5], [975222.442245265, 5], [975222.626062425, 18], [975222.81003553, 21], [975223.00080219, 9], [975223.182956515, 9], [975223.329052191, 16], [975223.5144128, 5], [975223.695511041, 14], [975223.876781725, 9], [975224.069467581, 27], [975224.215739368, 11], [975224.399279582, 8], [975224.546680667, 16], [975224.694833098, 5], [975224.844501564, 9], [975225.035650724, 14], [975225.185019768, 20], [975225.331928865, 8], [975225.480436536, 12], [975225.628292171, 5], [975225.778458878, 14], [975225.965280943, 14], [975226.118094766, 8], [975226.298244225, 13], [975226.471760914, 3], [975226.652351923, 10], [975226.803831321, 11], [975226.990591463, 9], [975227.176740382, 10], [975227.363404784, 20], [975227.508388822, 14], [975227.688937426, 14], [975227.921115033, 13], [975228.112765738, 5], [975228.298207543, 22], [975228.529639315, 3], [975228.769199236, 32], [975228.954719061, 33], [975229.147132416, 11], [975229.329076645, 6], [975229.476807066, 8], [975229.625765389, 9], [975229.774905401, 13], [975229.924496568, 8], [975230.084368471, 20], [975230.232253358, 17], [975230.418226232, 20], [975230.56581785, 13], [975230.749347272, 6], [975230.935317817, 13], [975231.091723133, 9], [975231.238170869, 11], [975231.387937318, 8], [975231.572252093, 15], [975231.756778924, 16], [975231.971340463, 27], [975232.208701177, 4], [975232.355691939, 8], [975232.543166883, 25], [975232.725765033, 18], [975232.875576467, 13], [975233.06819326, 55], [975233.216560869, 11], [975233.403223344, 10], [975233.588841429, 11], [975233.736735553, 15], [975233.886678782, 17], [975234.044273417, 14], [975234.301643169, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-0562b115f7ad354478ad2541b74366a1", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.584897039, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.53964871, "time_to_first_token": 0.823508629, "token_sha": "8a91591c94a3", "tokens_per_second": 18.8335757789391}, "seed": 1234, "sent": 975219.935121521, "speculative": {"acceptance_rate": 0.423444976076555, "accepted": 177, "drafted": 418, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8278728970326483, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 418, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 17.946206620628146, "done": 975234.298578957, "finish_reason": "length", "first": 975220.089406565, "full_response_s": 14.363421006011777, "last": 975234.298537519, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975220.089406565, 3], [975220.178510786, 26], [975220.890555589, 15], [975221.080024076, 19], [975221.263471289, 21], [975221.445228124, 15], [975221.627243972, 19], [975221.777468599, 17], [975221.921639576, 6], [975222.113672446, 11], [975222.295977556, 5], [975222.442328222, 18], [975222.626591587, 21], [975222.809785668, 5], [975222.999507171, 8], [975223.182789898, 5], [975223.329906875, 16], [975223.5127693, 5], [975223.694091515, 14], [975223.876712816, 9], [975224.068317052, 27], [975224.217562894, 11], [975224.399825912, 8], [975224.547037245, 16], [975224.695324294, 5], [975224.845163921, 9], [975225.034990863, 14], [975225.18486299, 20], [975225.332880362, 8], [975225.479831217, 12], [975225.630886113, 5], [975225.777833992, 14], [975225.965923941, 14], [975226.119063622, 8], [975226.298975011, 13], [975226.470307646, 3], [975226.653162498, 10], [975226.802984475, 11], [975226.990991862, 9], [975227.175656698, 10], [975227.363174681, 20], [975227.509231844, 14], [975227.692981421, 14], [975227.920953248, 13], [975228.114439941, 5], [975228.29871293, 22], [975228.527834604, 3], [975228.767597477, 32], [975228.957243934, 33], [975229.145394919, 11], [975229.330480348, 6], [975229.476501591, 8], [975229.627494103, 9], [975229.776261298, 13], [975229.924066314, 8], [975230.083549913, 20], [975230.234772855, 17], [975230.416571964, 20], [975230.565463321, 13], [975230.749482275, 6], [975230.93498855, 13], [975231.09124696, 9], [975231.237548526, 11], [975231.386832243, 8], [975231.57193265, 15], [975231.755327559, 16], [975231.971117592, 27], [975232.208191294, 4], [975232.356173823, 8], [975232.540468368, 25], [975232.724699476, 18], [975232.875918805, 13], [975233.066439331, 55], [975233.21722553, 11], [975233.401617217, 10], [975233.587335426, 11], [975233.737268939, 15], [975233.886034264, 17], [975234.044351078, 14], [975234.298537519, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4ee30fbd52f8525508d86ee0c60c7185", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.152236217, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 14.209145513, "time_to_first_token": 0.152626088, "token_sha": "8a91591c94a3", "tokens_per_second": 17.946188232550618}, "seed": 1234, "sent": 975219.935157951, "speculative": {"acceptance_rate": 0.40274599542334094, "accepted": 176, "drafted": 437, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.15424861398059875, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 437, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.836190035888194, "done": 975234.300416515, "finish_reason": "length", "first": 975220.762497814, "full_response_s": 14.364979070960544, "last": 975234.300267369, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975220.762497814, 3], [975220.890189429, 11], [975221.07985885, 30], [975221.262509697, 19], [975221.44498143, 21], [975221.627627077, 15], [975221.776094335, 19], [975221.92148907, 17], [975222.11329331, 12], [975222.294251835, 5], [975222.442295759, 5], [975222.625668377, 27], [975222.811450912, 12], [975222.999707627, 13], [975223.181953996, 5], [975223.332739879, 16], [975223.511793692, 5], [975223.695937967, 14], [975223.879147485, 9], [975224.069145146, 27], [975224.216873706, 11], [975224.40065727, 8], [975224.547776526, 16], [975224.694776076, 5], [975224.845363273, 9], [975225.035520009, 14], [975225.186612119, 20], [975225.330840173, 8], [975225.478770157, 12], [975225.628092883, 5], [975225.777914132, 14], [975225.964886687, 14], [975226.116856129, 8], [975226.29972234, 13], [975226.471991065, 3], [975226.654309795, 10], [975226.802673304, 11], [975226.990923801, 9], [975227.178250432, 10], [975227.361371827, 20], [975227.507481467, 14], [975227.690140577, 14], [975227.920693898, 13], [975228.113566217, 5], [975228.296405168, 22], [975228.527935384, 3], [975228.767406301, 32], [975228.955602609, 33], [975229.146115161, 11], [975229.329767145, 6], [975229.478258319, 8], [975229.625811596, 9], [975229.77597107, 13], [975229.923264314, 8], [975230.082711515, 20], [975230.231383537, 17], [975230.419350059, 20], [975230.564531759, 13], [975230.748540937, 6], [975230.934212726, 13], [975231.090420786, 9], [975231.23833755, 11], [975231.388659129, 8], [975231.572805687, 15], [975231.755556253, 16], [975231.972153454, 27], [975232.207074987, 4], [975232.35540427, 8], [975232.540941725, 25], [975232.726475436, 18], [975232.875980531, 13], [975233.068266265, 55], [975233.216801308, 11], [975233.402432752, 10], [975233.588645565, 11], [975233.737690474, 15], [975233.886737659, 17], [975234.044179629, 14], [975234.300267369, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-17545672c7b825f94243d09b4918311e", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.584890719, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.538417608, "time_to_first_token": 0.82488486, "token_sha": "8a91591c94a3", "tokens_per_second": 18.835288390669653}, "seed": 1234, "sent": 975219.935437444, "speculative": {"acceptance_rate": 0.4154929577464789, "accepted": 177, "drafted": 426, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8270603700075299, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 426, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 17.946798246869324, "done": 975234.298208668, "finish_reason": "length", "first": 975220.089510976, "full_response_s": 14.363023597979918, "last": 975234.298173518, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975220.089510976, 3], [975220.178220094, 26], [975220.888550424, 15], [975221.07967313, 19], [975221.26256315, 21], [975221.444066524, 15], [975221.627147768, 19], [975221.77481882, 17], [975221.921579083, 6], [975222.11256766, 11], [975222.29758301, 5], [975222.442792347, 18], [975222.624961254, 21], [975222.812492725, 5], [975223.000722529, 8], [975223.183618536, 5], [975223.331708482, 16], [975223.511533302, 5], [975223.695612973, 14], [975223.876828971, 9], [975224.069849773, 27], [975224.216491017, 11], [975224.398574603, 8], [975224.547477291, 16], [975224.695876671, 5], [975224.844880348, 9], [975225.035818061, 14], [975225.183871351, 20], [975225.332206918, 8], [975225.478654641, 12], [975225.629133688, 5], [975225.777707437, 14], [975225.965716189, 14], [975226.117240257, 8], [975226.300198369, 13], [975226.469814786, 3], [975226.654632214, 10], [975226.803093191, 11], [975226.990259556, 9], [975227.175753958, 10], [975227.360469944, 20], [975227.506857701, 14], [975227.691084394, 14], [975227.922645643, 13], [975228.112434231, 5], [975228.296764626, 22], [975228.530750662, 3], [975228.76895027, 32], [975228.95612374, 33], [975229.146026749, 11], [975229.329319195, 6], [975229.477722037, 8], [975229.627128262, 9], [975229.775051075, 13], [975229.924170742, 8], [975230.083406671, 20], [975230.233116139, 17], [975230.416448785, 20], [975230.56405853, 13], [975230.748663556, 6], [975230.934582551, 13], [975231.090252441, 9], [975231.238587348, 11], [975231.387637938, 8], [975231.571191672, 15], [975231.756151413, 16], [975231.971202741, 27], [975232.206353944, 4], [975232.356059252, 8], [975232.541346668, 25], [975232.726207719, 18], [975232.875665855, 13], [975233.067617108, 55], [975233.216065577, 11], [975233.401245728, 10], [975233.586933138, 11], [975233.736622821, 15], [975233.88776253, 17], [975234.04395247, 14], [975234.298173518, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-d538a48809f2b223ec24bb482da50740", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.152231673, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 14.209002223, "time_to_first_token": 0.153146643, "token_sha": "8a91591c94a3", "tokens_per_second": 17.946369210023313}, "seed": 1234, "sent": 975219.93518507, "speculative": {"acceptance_rate": 0.40274599542334094, "accepted": 176, "drafted": 437, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.15432590595446527, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 437, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.838129987260462, "done": 975234.298405284, "finish_reason": "length", "first": 975220.762007834, "full_response_s": 14.363775022909977, "last": 975234.298383269, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975220.762007834, 3], [975220.888139865, 11], [975221.081161021, 30], [975221.263776476, 19], [975221.444639364, 21], [975221.62801842, 15], [975221.774244827, 19], [975221.923034143, 17], [975222.113034985, 12], [975222.295824474, 5], [975222.442397899, 5], [975222.626163397, 27], [975222.813511483, 12], [975223.001109457, 13], [975223.184508628, 5], [975223.331638757, 16], [975223.512393571, 5], [975223.694829229, 14], [975223.877654266, 9], [975224.070677451, 27], [975224.216096522, 11], [975224.400433071, 8], [975224.548362678, 16], [975224.695023538, 5], [975224.845980863, 9], [975225.036671642, 14], [975225.184935484, 20], [975225.331527361, 8], [975225.479406275, 12], [975225.630039827, 5], [975225.779579312, 14], [975225.966342179, 14], [975226.117811898, 8], [975226.299659847, 13], [975226.470571795, 3], [975226.655108147, 10], [975226.804088926, 11], [975226.991605133, 9], [975227.179421793, 10], [975227.362651039, 20], [975227.509528136, 14], [975227.692649882, 14], [975227.921364463, 13], [975228.113754737, 5], [975228.298586536, 22], [975228.52878815, 3], [975228.769569956, 32], [975228.955660735, 33], [975229.14633792, 11], [975229.32949018, 6], [975229.477962971, 8], [975229.626676712, 9], [975229.775811796, 13], [975229.924736351, 8], [975230.083336353, 20], [975230.232681052, 17], [975230.419120852, 20], [975230.565705183, 13], [975230.750022797, 6], [975230.934628421, 13], [975231.091040761, 9], [975231.238947061, 11], [975231.387710815, 8], [975231.572290636, 15], [975231.757048849, 16], [975231.971922792, 27], [975232.20788729, 4], [975232.356427397, 8], [975232.540849553, 25], [975232.725067189, 18], [975232.876112589, 13], [975233.068508768, 55], [975233.217595195, 11], [975233.404070318, 10], [975233.588580095, 11], [975233.738073018, 15], [975233.888357418, 17], [975234.044542766, 14], [975234.298383269, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b72d382a2a1250389eae59331195bb42", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.584885359, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.536496197, "time_to_first_token": 0.825585951, "token_sha": "8a91591c94a3", "tokens_per_second": 18.837961928177094}, "seed": 1234, "sent": 975219.934630261, "speculative": {"acceptance_rate": 0.4125874125874126, "accepted": 177, "drafted": 429, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8273775730049238, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 429, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "python", "burst": null, "phase": "uncached_first_use", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 66.91543941169725, "done": 975005.406122906, "finish_reason": "length", "first": 975001.594747243, "full_response_s": 4.018838191987015, "last": 975005.405526971, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975001.594747243, 2], [975001.744034883, 7], [975001.831992339, 4], [975001.915924085, 73], [975001.997307668, 51], [975002.078506397, 21], [975002.159110951, 14], [975002.238970762, 20], [975002.319172745, 16], [975002.399238113, 15], [975002.479503453, 23], [975002.559479306, 23], [975002.639605966, 25], [975002.722110143, 36], [975002.806549701, 14], [975002.891360318, 6], [975002.971365711, 18], [975003.051777881, 18], [975003.131828104, 19], [975003.212381307, 8], [975003.292194023, 11], [975003.372722091, 18], [975003.4529412, 15], [975003.532653505, 39], [975003.612783691, 30], [975003.694317512, 14], [975003.775270741, 15], [975003.861884735, 8], [975003.944128827, 6], [975004.023697018, 12], [975004.105088534, 26], [975004.18594867, 22], [975004.266717835, 18], [975004.346100741, 38], [975004.426261363, 22], [975004.506479759, 10], [975004.58656845, 14], [975004.669458794, 15], [975004.750609171, 38], [975004.837631579, 47], [975004.921578177, 25], [975005.001990184, 11], [975005.08256879, 34], [975005.163523903, 12], [975005.243186703, 36], [975005.326063759, 60], [975005.405526971, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-72091293893a4b4799a37925", "runtime": {"accepted": 209, "cached": 0, "decode_s": 3.8161, "drafted": 690, "drafts": true, "min_rows": 16, "prefill_s": 0.1703, "rounds": 46, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975001.387284714, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.20746252895332873, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 209, "drafted": 690, "rounds": 46}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 68.23875411554083, "done": 975009.254509552, "finish_reason": "length", "first": 975005.516061454, "full_response_s": 3.8472263420699164, "last": 975009.252940934, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975005.516061454, 2], [975005.598817877, 7], [975005.680147034, 4], [975005.759439679, 73], [975005.846183741, 51], [975005.929452798, 21], [975006.009214367, 14], [975006.089725799, 20], [975006.171393584, 16], [975006.251494127, 15], [975006.331148966, 23], [975006.411219494, 23], [975006.491329652, 25], [975006.571696116, 36], [975006.653990602, 14], [975006.734848639, 6], [975006.820265387, 18], [975006.903988682, 18], [975006.98403661, 19], [975007.06426048, 8], [975007.144343653, 11], [975007.225349336, 18], [975007.305025493, 15], [975007.384992705, 39], [975007.465084182, 30], [975007.545496921, 14], [975007.625501731, 15], [975007.706208487, 8], [975007.786928138, 6], [975007.872429564, 12], [975007.954262569, 26], [975008.034273832, 22], [975008.11586069, 18], [975008.196598746, 38], [975008.276678166, 22], [975008.356533487, 10], [975008.436551262, 14], [975008.516872493, 15], [975008.597100737, 38], [975008.680123165, 47], [975008.760463098, 25], [975008.847744432, 11], [975008.930558781, 34], [975009.010417212, 12], [975009.090875513, 36], [975009.172769785, 60], [975009.252940934, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-2b61185fd24146b9b3372d4f", "runtime": {"accepted": 209, "cached": 13, "decode_s": 3.7368, "drafted": 690, "drafts": true, "min_rows": 16, "prefill_s": 0.106, "rounds": 46, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975005.40728321, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.10877824400085956, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 209, "drafted": 690, "rounds": 46}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 68.246555769264, "done": 975013.113722468, "finish_reason": "length", "first": 975009.375895991, "full_response_s": 3.848474205005914, "last": 975013.112348287, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975009.375895991, 2], [975009.458077175, 7], [975009.538821637, 4], [975009.620325033, 73], [975009.701050392, 51], [975009.781345007, 21], [975009.867907636, 14], [975009.950643644, 20], [975010.030532207, 16], [975010.111567172, 15], [975010.192460064, 23], [975010.272550232, 23], [975010.352627344, 25], [975010.432490293, 36], [975010.513084657, 14], [975010.593318337, 6], [975010.67599534, 18], [975010.755986266, 18], [975010.842320368, 19], [975010.925338367, 8], [975011.005129389, 11], [975011.085675938, 18], [975011.166125245, 15], [975011.246110129, 39], [975011.326834156, 30], [975011.406137365, 14], [975011.486622718, 15], [975011.566437163, 8], [975011.647077435, 6], [975011.727389485, 12], [975011.810543605, 26], [975011.895706566, 22], [975011.976763957, 18], [975012.057074798, 38], [975012.137202016, 22], [975012.217413837, 10], [975012.297410807, 14], [975012.377527562, 15], [975012.457797172, 38], [975012.538135787, 47], [975012.619268279, 25], [975012.702960039, 11], [975012.78308353, 34], [975012.869451742, 12], [975012.951265851, 36], [975013.031346822, 60], [975013.112348287, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-d92a4c95d1c84f86959f0b83", "runtime": {"accepted": 209, "cached": 13, "decode_s": 3.736, "drafted": 690, "drafts": true, "min_rows": 16, "prefill_s": 0.1081, "rounds": 46, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975009.265248263, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.11064772796817124, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 209, "drafted": 690, "rounds": 46}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 68.30781291142482, "done": 975016.971422447, "finish_reason": "length", "first": 975013.236933789, "full_response_s": 3.8465182329528034, "last": 975016.970035306, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975013.236933789, 2], [975013.318198728, 7], [975013.398972317, 4], [975013.478743961, 73], [975013.558815908, 51], [975013.63909498, 21], [975013.719473311, 14], [975013.801084391, 20], [975013.886338095, 16], [975013.967818724, 15], [975014.048411674, 23], [975014.128430782, 23], [975014.209139965, 25], [975014.289196256, 36], [975014.369456135, 14], [975014.450058892, 6], [975014.530832391, 18], [975014.610957606, 18], [975014.694033205, 19], [975014.773873955, 8], [975014.859870904, 11], [975014.94217671, 18], [975015.021937295, 15], [975015.102688434, 39], [975015.183508961, 30], [975015.26317867, 14], [975015.344638539, 15], [975015.424630359, 8], [975015.504662417, 6], [975015.585043896, 12], [975015.66595989, 26], [975015.74606436, 22], [975015.831907657, 18], [975015.915575989, 38], [975015.995401104, 22], [975016.076097948, 10], [975016.156893362, 14], [975016.236871877, 15], [975016.316950947, 38], [975016.397149386, 47], [975016.47760965, 25], [975016.557780203, 11], [975016.637943348, 34], [975016.721302544, 12], [975016.80317774, 36], [975016.888500165, 60], [975016.970035306, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-e8dee9b7e16947afb842df85", "runtime": {"accepted": 209, "cached": 13, "decode_s": 3.7329, "drafted": 690, "drafts": true, "min_rows": 16, "prefill_s": 0.1086, "rounds": 46, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975013.124904214, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.11202957492787391, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 209, "drafted": 690, "rounds": 46}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.448436408575642, "done": 975027.317944398, "finish_reason": "length", "first": 975017.280633364, "full_response_s": 10.330607720999978, "last": 975027.300895352, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975017.280633364, 2], [975017.478304597, 7], [975017.624119121, 4], [975017.865026539, 53], [975018.036813756, 47], [975018.223567768, 30], [975018.376772065, 15], [975018.556309969, 14], [975018.711178673, 20], [975018.903815223, 14], [975019.083532475, 4], [975019.231176779, 13], [975019.410161799, 21], [975019.589325849, 2], [975019.771785577, 18], [975019.962702255, 29], [975020.210075057, 27], [975020.380028687, 15], [975020.527605229, 11], [975020.714437937, 18], [975020.902942898, 10], [975021.083577456, 31], [975021.233979411, 8], [975021.417980492, 11], [975021.600241955, 16], [975021.780070812, 12], [975021.972420995, 39], [975022.152333717, 18], [975022.329600549, 11], [975022.478205427, 16], [975022.661632361, 16], [975022.817421367, 11], [975023.056124097, 6], [975023.224597268, 9], [975023.403977856, 29], [975023.587470721, 22], [975023.772049255, 8], [975023.930573815, 18], [975024.110405449, 18], [975024.293100722, 34], [975024.47997654, 10], [975024.665351158, 14], [975024.855864737, 13], [975025.039622095, 2], [975025.221388727, 36], [975025.403372835, 42], [975025.586152245, 26], [975025.744839963, 17], [975025.930714833, 34], [975026.114627877, 12], [975026.298145597, 36], [975026.597978791, 50], [975026.774082186, 2], [975027.063797361, 54], [975027.300895352, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-5e0164afe0ed49d4b9df8ac8", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0194, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2541, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975016.987336677, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.29329668695572764, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.455762896215777, "done": 975027.317523316, "finish_reason": "length", "first": 975017.283174971, "full_response_s": 10.331033697002567, "last": 975027.300553002, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975017.283174971, 2], [975017.479106649, 7], [975017.624750479, 4], [975017.865179699, 53], [975018.034993198, 47], [975018.22137851, 30], [975018.374924805, 15], [975018.557406582, 14], [975018.71283604, 20], [975018.90310387, 14], [975019.085333739, 4], [975019.23172699, 13], [975019.411091829, 21], [975019.58997327, 2], [975019.773158831, 18], [975019.964451265, 29], [975020.21102027, 27], [975020.380532627, 15], [975020.530187219, 11], [975020.712151132, 18], [975020.903044749, 10], [975021.082258183, 31], [975021.232036731, 8], [975021.417178775, 11], [975021.599349859, 16], [975021.780321471, 12], [975021.972373989, 39], [975022.153035311, 18], [975022.328854477, 11], [975022.478767925, 16], [975022.660556051, 16], [975022.818252091, 11], [975023.055685368, 6], [975023.225555377, 9], [975023.406034978, 29], [975023.587312473, 22], [975023.770578758, 8], [975023.930887351, 18], [975024.110287743, 18], [975024.292293245, 34], [975024.480472049, 10], [975024.66485016, 14], [975024.856661574, 13], [975025.040886827, 2], [975025.220308512, 36], [975025.403140783, 42], [975025.586184243, 26], [975025.745409629, 17], [975025.930793917, 34], [975026.118778584, 12], [975026.300098501, 36], [975026.598759006, 50], [975026.775298234, 2], [975027.063739749, 54], [975027.300553002, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-e3ebefca7e724d058d0d162c", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0193, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2541, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975016.986489619, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2966853519901633, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.451418200641225, "done": 975027.317679052, "finish_reason": "length", "first": 975017.281909983, "full_response_s": 10.325644964003004, "last": 975027.300998035, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975017.281909983, 2], [975017.47824284, 7], [975017.624384866, 4], [975017.86531166, 53], [975018.035755733, 47], [975018.220295416, 30], [975018.374323413, 15], [975018.556825462, 14], [975018.714981941, 20], [975018.902680692, 14], [975019.086769933, 4], [975019.233140322, 13], [975019.409895925, 21], [975019.592078725, 2], [975019.773907687, 18], [975019.963558849, 29], [975020.211940013, 27], [975020.380885009, 15], [975020.527822226, 11], [975020.71348778, 18], [975020.904075429, 10], [975021.081927144, 31], [975021.232942922, 8], [975021.417416186, 11], [975021.59816389, 16], [975021.779761741, 12], [975021.972091396, 39], [975022.153566115, 18], [975022.331028712, 11], [975022.478125319, 16], [975022.660997067, 16], [975022.817961242, 11], [975023.055273374, 6], [975023.226496686, 9], [975023.404296447, 29], [975023.586993466, 22], [975023.770781179, 8], [975023.928057854, 18], [975024.112638818, 18], [975024.294258612, 34], [975024.47926477, 10], [975024.666407165, 14], [975024.856968022, 13], [975025.038907925, 2], [975025.219762029, 36], [975025.402959257, 42], [975025.585955488, 26], [975025.743893454, 17], [975025.930880201, 34], [975026.116249967, 12], [975026.299545443, 36], [975026.600613003, 50], [975026.775967766, 2], [975027.067958532, 54], [975027.300998035, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-1284139bc75e42e1965fe138", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0195, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2541, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975016.992034088, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.289875895017758, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.441684588083074, "done": 975027.312935224, "finish_reason": "length", "first": 975017.281116218, "full_response_s": 10.325948095996864, "last": 975027.304037425, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975017.281116218, 2], [975017.478506746, 7], [975017.624304423, 4], [975017.864496504, 53], [975018.036964244, 47], [975018.220168095, 30], [975018.374119584, 15], [975018.560285675, 14], [975018.711947128, 20], [975018.903584436, 14], [975019.083791566, 4], [975019.232914606, 13], [975019.411013961, 21], [975019.590140237, 2], [975019.773304983, 18], [975019.962938002, 29], [975020.209073991, 27], [975020.379532937, 15], [975020.528077044, 11], [975020.713053131, 18], [975020.901583947, 10], [975021.084185087, 31], [975021.233108705, 8], [975021.417088572, 11], [975021.598380663, 16], [975021.781958583, 12], [975021.9729274, 39], [975022.154279853, 18], [975022.328955239, 11], [975022.479218797, 16], [975022.66169983, 16], [975022.818186062, 11], [975023.055342954, 6], [975023.224458459, 9], [975023.405188592, 29], [975023.588489258, 22], [975023.770223865, 8], [975023.929014955, 18], [975024.111398004, 18], [975024.292403943, 34], [975024.478739262, 10], [975024.665654677, 14], [975024.856541532, 13], [975025.038631603, 2], [975025.2204574, 36], [975025.404438314, 42], [975025.585681502, 26], [975025.743429383, 17], [975025.935437974, 34], [975026.115805462, 12], [975026.300482737, 36], [975026.599193191, 50], [975026.773906916, 2], [975027.06341943, 54], [975027.304037425, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-d5c45f4a0c2f4f3c9ed409ce", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0193, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2541, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975016.986987128, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2941290899179876, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.444766719396593, "done": 975027.319288454, "finish_reason": "length", "first": 975017.280980849, "full_response_s": 10.326314256992191, "last": 975027.302687977, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975017.280980849, 2], [975017.479494596, 7], [975017.62469541, 4], [975017.866820699, 53], [975018.038918459, 47], [975018.222403175, 30], [975018.374765149, 15], [975018.558294759, 14], [975018.712541064, 20], [975018.903497769, 14], [975019.08464424, 4], [975019.232700682, 13], [975019.411398724, 21], [975019.590735469, 2], [975019.772264367, 18], [975019.963835666, 29], [975020.210721182, 27], [975020.380188278, 15], [975020.529068351, 11], [975020.713685993, 18], [975020.902729917, 10], [975021.082866022, 31], [975021.232594829, 8], [975021.418973335, 11], [975021.599087745, 16], [975021.781232926, 12], [975021.971590207, 39], [975022.152407441, 18], [975022.328511823, 11], [975022.479785518, 16], [975022.661258957, 16], [975022.819612066, 11], [975023.055860847, 6], [975023.226849628, 9], [975023.406861846, 29], [975023.589513268, 22], [975023.771047117, 8], [975023.930153022, 18], [975024.112077072, 18], [975024.292637515, 34], [975024.480170289, 10], [975024.666881844, 14], [975024.856909705, 13], [975025.041119519, 2], [975025.221614539, 36], [975025.403454031, 42], [975025.585793448, 26], [975025.744424417, 17], [975025.934304466, 34], [975026.115541444, 12], [975026.301792427, 36], [975026.598701825, 50], [975026.773751644, 2], [975027.067302487, 54], [975027.302687977, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-ff06fc2be7074430b4b7b57e", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0195, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2541, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975016.992974197, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2880066520301625, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.448412223337375, "done": 975027.318726676, "finish_reason": "length", "first": 975017.283902131, "full_response_s": 10.332024669041857, "last": 975027.304173642, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975017.283902131, 2], [975017.478066497, 7], [975017.624230875, 4], [975017.864575827, 53], [975018.035649995, 47], [975018.22125562, 30], [975018.374184173, 15], [975018.558178125, 14], [975018.712652578, 20], [975018.903691326, 14], [975019.083847995, 4], [975019.231608148, 13], [975019.410234659, 21], [975019.589594698, 2], [975019.772366186, 18], [975019.96401908, 29], [975020.211534435, 27], [975020.380977596, 15], [975020.528783438, 11], [975020.711970453, 18], [975020.901503967, 10], [975021.081846109, 31], [975021.232526032, 8], [975021.41749647, 11], [975021.598787377, 16], [975021.78137287, 12], [975021.971937516, 39], [975022.152973811, 18], [975022.329459932, 11], [975022.478547217, 16], [975022.660756712, 16], [975022.817548224, 11], [975023.055419142, 6], [975023.224746908, 9], [975023.403312612, 29], [975023.586882688, 22], [975023.770739485, 8], [975023.929104566, 18], [975024.110512515, 18], [975024.293543018, 34], [975024.482086187, 10], [975024.664994649, 14], [975024.858117336, 13], [975025.039445208, 2], [975025.220060253, 36], [975025.402790738, 42], [975025.586572655, 26], [975025.742545846, 17], [975025.932289598, 34], [975026.11795778, 12], [975026.298859895, 36], [975026.598632532, 50], [975026.773846423, 2], [975027.063508001, 54], [975027.304173642, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-dba01cbaa2424f65b6d27fb8", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0194, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2541, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975016.986702007, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.29720012401230633, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.45381775885717, "done": 975027.319095185, "finish_reason": "length", "first": 975017.282285867, "full_response_s": 10.330170769011602, "last": 975027.300429409, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975017.282285867, 2], [975017.478571638, 7], [975017.627060882, 4], [975017.865371497, 53], [975018.036629526, 47], [975018.222220672, 30], [975018.376643496, 15], [975018.557013452, 14], [975018.712065394, 20], [975018.901749687, 14], [975019.086550953, 4], [975019.233262395, 13], [975019.41114989, 21], [975019.590293397, 2], [975019.771612754, 18], [975019.966201923, 29], [975020.211439048, 27], [975020.38063075, 15], [975020.527358219, 11], [975020.712493497, 18], [975020.903686138, 10], [975021.082777291, 31], [975021.232186099, 8], [975021.419345299, 11], [975021.602106943, 16], [975021.780708042, 12], [975021.971820227, 39], [975022.154201617, 18], [975022.329104415, 11], [975022.480238758, 16], [975022.661326234, 16], [975022.817690905, 11], [975023.055501954, 6], [975023.225366763, 9], [975023.404561665, 29], [975023.587576347, 22], [975023.771222723, 8], [975023.931136265, 18], [975024.111828525, 18], [975024.293714657, 34], [975024.478597333, 10], [975024.667358235, 14], [975024.855757494, 13], [975025.038530377, 2], [975025.221914171, 36], [975025.403859561, 42], [975025.586910925, 26], [975025.743295326, 17], [975025.932059738, 34], [975026.114451118, 12], [975026.301155789, 36], [975026.598945764, 50], [975026.774306478, 2], [975027.06663953, 54], [975027.300429409, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-e5111f4f9c5b4a3286901f6c", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0194, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2541, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975016.988924416, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2933614510111511, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.454117029726035, "done": 975027.316923028, "finish_reason": "length", "first": 975017.282614377, "full_response_s": 10.330371237010695, "last": 975027.300640133, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975017.282614377, 2], [975017.479451511, 7], [975017.624879528, 4], [975017.865255615, 53], [975018.035263552, 47], [975018.223170221, 30], [975018.375099147, 15], [975018.556919889, 14], [975018.712221529, 20], [975018.903029906, 14], [975019.084141227, 4], [975019.231668817, 13], [975019.411825997, 21], [975019.593027986, 2], [975019.771984206, 18], [975019.963267312, 29], [975020.209355239, 27], [975020.381923913, 15], [975020.527752485, 11], [975020.71277321, 18], [975020.902283093, 10], [975021.08339993, 31], [975021.233347956, 8], [975021.417612704, 11], [975021.602177675, 16], [975021.78130329, 12], [975021.973088559, 39], [975022.1525822, 18], [975022.330372268, 11], [975022.479592265, 16], [975022.661057112, 16], [975022.818902136, 11], [975023.05553768, 6], [975023.225117192, 9], [975023.403845687, 29], [975023.58680946, 22], [975023.771566561, 8], [975023.931522453, 18], [975024.110116345, 18], [975024.293475854, 34], [975024.478682673, 10], [975024.665158416, 14], [975024.856226045, 13], [975025.038955922, 2], [975025.223175655, 36], [975025.40305002, 42], [975025.587114386, 26], [975025.747664213, 17], [975025.931588467, 34], [975026.115031583, 12], [975026.299652733, 36], [975026.598384946, 50], [975026.77306232, 2], [975027.064015174, 54], [975027.300640133, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8ccba640c7f3460cb38b5c9a", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0194, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2541, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975016.986551791, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.296062586014159, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.442927031731692, "done": 975027.318515039, "finish_reason": "length", "first": 975017.281456279, "full_response_s": 10.32922877103556, "last": 975027.303888041, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975017.281456279, 2], [975017.479169366, 7], [975017.626560765, 4], [975017.865111255, 53], [975018.035822306, 47], [975018.220691667, 30], [975018.375196438, 15], [975018.558560248, 14], [975018.71231578, 20], [975018.903237367, 14], [975019.083916391, 4], [975019.231470396, 13], [975019.411314281, 21], [975019.590218681, 2], [975019.771903411, 18], [975019.963764838, 29], [975020.21034725, 27], [975020.381957015, 15], [975020.528573513, 11], [975020.712207049, 18], [975020.902029091, 10], [975021.082195866, 31], [975021.232653306, 8], [975021.420218596, 11], [975021.599636387, 16], [975021.780778038, 12], [975021.974225858, 39], [975022.153373629, 18], [975022.330076219, 11], [975022.478478868, 16], [975022.660351566, 16], [975022.817739862, 11], [975023.05786658, 6], [975023.225053964, 9], [975023.404679099, 29], [975023.587074358, 22], [975023.77326271, 8], [975023.928554947, 18], [975024.110717944, 18], [975024.294639328, 34], [975024.479673484, 10], [975024.667237649, 14], [975024.855949004, 13], [975025.040061671, 2], [975025.220629455, 36], [975025.403509276, 42], [975025.587447344, 26], [975025.743541633, 17], [975025.931051296, 34], [975026.116962377, 12], [975026.299204949, 36], [975026.599867939, 50], [975026.775355463, 2], [975027.064367715, 54], [975027.303888041, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-3f4da152aefc4cd885899408", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0194, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2541, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975016.989286268, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.29217001097276807, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.44445235353265, "done": 975027.309109923, "finish_reason": "length", "first": 975017.281939469, "full_response_s": 10.320547743933275, "last": 975027.303770415, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975017.281939469, 2], [975017.480712995, 7], [975017.62461375, 4], [975017.865744069, 53], [975018.036100803, 47], [975018.220981219, 30], [975018.378346173, 15], [975018.557706134, 14], [975018.711419572, 20], [975018.901591807, 14], [975019.084058367, 4], [975019.23153692, 13], [975019.409620116, 21], [975019.590356353, 2], [975019.772046587, 18], [975019.964574778, 29], [975020.210952514, 27], [975020.37985028, 15], [975020.52836978, 11], [975020.713252417, 18], [975020.901409236, 10], [975021.082327779, 31], [975021.231754602, 8], [975021.417291057, 11], [975021.600687179, 16], [975021.780946589, 12], [975021.974082218, 39], [975022.154075784, 18], [975022.330531379, 11], [975022.481404664, 16], [975022.660627135, 16], [975022.817624508, 11], [975023.057538693, 6], [975023.22493997, 9], [975023.408707651, 29], [975023.587909785, 22], [975023.770295349, 8], [975023.929196513, 18], [975024.112555638, 18], [975024.293161055, 34], [975024.479835987, 10], [975024.665218909, 14], [975024.855694842, 13], [975025.040421924, 2], [975025.222197996, 36], [975025.403616886, 42], [975025.585437259, 26], [975025.742420924, 17], [975025.933642406, 34], [975026.115892466, 12], [975026.300032489, 36], [975026.599246564, 50], [975026.773435805, 2], [975027.064905463, 54], [975027.303770415, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-129bc912f64549cd9a373a3c", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0194, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2541, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975016.988562179, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.29337729001417756, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.43764731019816, "done": 975027.318184353, "finish_reason": "length", "first": 975017.282053623, "full_response_s": 10.330438497941941, "last": 975027.306565595, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975017.282053623, 2], [975017.478616932, 7], [975017.626238718, 4], [975017.866959907, 53], [975018.039995793, 47], [975018.222482658, 30], [975018.377891285, 15], [975018.559272626, 14], [975018.713827091, 20], [975018.900920115, 14], [975019.085242864, 4], [975019.23246967, 13], [975019.409963362, 21], [975019.589453426, 2], [975019.773238971, 18], [975019.964516349, 29], [975020.209558461, 27], [975020.381562652, 15], [975020.527238193, 11], [975020.711756449, 18], [975020.903956156, 10], [975021.082577734, 31], [975021.233427808, 8], [975021.418639673, 11], [975021.598944233, 16], [975021.780488358, 12], [975021.975296505, 39], [975022.153794599, 18], [975022.329256343, 11], [975022.479654965, 16], [975022.661449923, 16], [975022.817892222, 11], [975023.055465044, 6], [975023.224668816, 9], [975023.404923918, 29], [975023.588889541, 22], [975023.770418062, 8], [975023.929848606, 18], [975024.109951345, 18], [975024.295359657, 34], [975024.479901616, 10], [975024.667097704, 14], [975024.856410515, 13], [975025.039196933, 2], [975025.221133076, 36], [975025.402436565, 42], [975025.586832689, 26], [975025.746619277, 17], [975025.931815975, 34], [975026.115603633, 12], [975026.299761655, 36], [975026.597858606, 50], [975026.773202361, 2], [975027.063233919, 54], [975027.306565595, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-5fe46866f952451ab35fe9dd", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0194, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2541, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975016.987745855, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2943077679956332, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.447216744416416, "done": 975027.317356429, "finish_reason": "length", "first": 975017.280554168, "full_response_s": 10.330561450915411, "last": 975027.301296419, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975017.280554168, 2], [975017.477502928, 7], [975017.625525509, 4], [975017.864724251, 53], [975018.039050004, 47], [975018.220040182, 30], [975018.37580399, 15], [975018.556718731, 14], [975018.711299259, 20], [975018.902346662, 14], [975019.084285251, 4], [975019.231330355, 13], [975019.411672918, 21], [975019.589535421, 2], [975019.773457727, 18], [975019.964337479, 29], [975020.210572342, 27], [975020.379433774, 15], [975020.527459653, 11], [975020.71165687, 18], [975020.901279531, 10], [975021.081476177, 31], [975021.231267908, 8], [975021.417562739, 11], [975021.598620394, 16], [975021.779918164, 12], [975021.971441575, 39], [975022.154319163, 18], [975022.328448339, 11], [975022.477971711, 16], [975022.660692939, 16], [975022.818010952, 11], [975023.054904018, 6], [975023.22643981, 9], [975023.403468012, 29], [975023.586626958, 22], [975023.7704635, 8], [975023.928459064, 18], [975024.110028061, 18], [975024.29333383, 34], [975024.480788352, 10], [975024.665436945, 14], [975024.856117379, 13], [975025.038421279, 2], [975025.219902646, 36], [975025.402191666, 42], [975025.585850405, 26], [975025.742819479, 17], [975025.931697773, 34], [975026.114556793, 12], [975026.298347955, 36], [975026.597598171, 50], [975026.772894745, 2], [975027.063334426, 54], [975027.301296419, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8e745d43b10041669b889c15", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0193, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2541, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975016.986794978, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.29375919001176953, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.448475169624768, "done": 975027.315864076, "finish_reason": "length", "first": 975017.281993514, "full_response_s": 10.325115679064766, "last": 975027.30224024, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975017.281993514, 2], [975017.479384682, 7], [975017.624522283, 4], [975017.865950538, 53], [975018.036200109, 47], [975018.226289269, 30], [975018.375972493, 15], [975018.55841088, 14], [975018.713194709, 20], [975018.901832818, 14], [975019.083712754, 4], [975019.231848423, 13], [975019.410295056, 21], [975019.590793626, 2], [975019.772118759, 18], [975019.964403187, 29], [975020.211123049, 27], [975020.38120128, 15], [975020.528202013, 11], [975020.71449635, 18], [975020.902089456, 10], [975021.08204053, 31], [975021.231021409, 8], [975021.417774711, 11], [975021.600123033, 16], [975021.78156294, 12], [975021.972798574, 39], [975022.153322704, 18], [975022.330166823, 11], [975022.478056363, 16], [975022.66113234, 16], [975022.818439281, 11], [975023.056080083, 6], [975023.224533159, 9], [975023.404628078, 29], [975023.587240957, 22], [975023.773158092, 8], [975023.92819447, 18], [975024.109871926, 18], [975024.292593565, 34], [975024.479778374, 10], [975024.665567114, 14], [975024.85740891, 13], [975025.039954749, 2], [975025.219569336, 36], [975025.402293853, 42], [975025.585744907, 26], [975025.745486521, 17], [975025.930496045, 34], [975026.118319408, 12], [975026.30163362, 36], [975026.598583335, 50], [975026.773658241, 2], [975027.065909441, 54], [975027.30224024, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-51b3e966a75e49788c9fbc7c", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0195, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2541, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975016.990748397, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2912451170850545, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.448775732010876, "done": 975027.319023428, "finish_reason": "length", "first": 975017.283986239, "full_response_s": 10.332383000990376, "last": 975027.304114621, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975017.283986239, 2], [975017.478851351, 7], [975017.626097718, 4], [975017.866028677, 53], [975018.037133611, 47], [975018.220552602, 30], [975018.374377474, 15], [975018.556561236, 14], [975018.716316589, 20], [975018.902421906, 14], [975019.083626998, 4], [975019.231790762, 13], [975019.410104778, 21], [975019.593140268, 2], [975019.772543504, 18], [975019.964749745, 29], [975020.211990762, 27], [975020.381498176, 15], [975020.528639622, 11], [975020.712683119, 18], [975020.904907385, 10], [975021.08364974, 31], [975021.231498344, 8], [975021.419640083, 11], [975021.59824883, 16], [975021.779988769, 12], [975021.973825847, 39], [975022.153274115, 18], [975022.332830296, 11], [975022.479718338, 16], [975022.662504538, 16], [975022.818679764, 11], [975023.055901117, 6], [975023.226671173, 9], [975023.404190933, 29], [975023.588433581, 22], [975023.770901301, 8], [975023.929270653, 18], [975024.110166406, 18], [975024.295635435, 34], [975024.480073367, 10], [975024.668780335, 14], [975024.856483168, 13], [975025.041946435, 2], [975025.219673218, 36], [975025.402378568, 42], [975025.585896899, 26], [975025.742753323, 17], [975025.930316247, 34], [975026.114307654, 12], [975026.298439582, 36], [975026.598180412, 50], [975026.774467622, 2], [975027.064961108, 54], [975027.304114621, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-6b904c7e90d541978e54d84a", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0194, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2541, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975016.986640427, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.29734581196680665, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.45019467652268, "done": 975027.317877361, "finish_reason": "length", "first": 975017.281157271, "full_response_s": 10.328484474914148, "last": 975027.300726993, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975017.281157271, 2], [975017.479838898, 7], [975017.624956979, 4], [975017.86493272, 53], [975018.039180621, 47], [975018.221452074, 30], [975018.377967185, 15], [975018.559142233, 14], [975018.712935107, 20], [975018.902234268, 14], [975019.085821056, 4], [975019.232627949, 13], [975019.41002163, 21], [975019.591274176, 2], [975019.771717709, 18], [975019.96302043, 29], [975020.210476811, 27], [975020.379339763, 15], [975020.528939126, 11], [975020.712070048, 18], [975020.901659799, 10], [975021.081355015, 31], [975021.231380622, 8], [975021.417356766, 11], [975021.598091334, 16], [975021.779874631, 12], [975021.972636935, 39], [975022.152211787, 18], [975022.328585067, 11], [975022.478654827, 16], [975022.660193974, 16], [975022.817815362, 11], [975023.054581091, 6], [975023.224203049, 9], [975023.404046861, 29], [975023.586729896, 22], [975023.770075985, 8], [975023.929931722, 18], [975024.109763243, 18], [975024.292526801, 34], [975024.480717844, 10], [975024.666516071, 14], [975024.856038359, 13], [975025.041051026, 2], [975025.220239844, 36], [975025.403552825, 42], [975025.585288979, 26], [975025.742614546, 17], [975025.930417969, 34], [975026.114723728, 12], [975026.300227679, 36], [975026.599059742, 50], [975026.776752044, 2], [975027.064432512, 54], [975027.300726993, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-a4fbe1885f2c434cb2bcb94e", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0194, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2541, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975016.989392886, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.29176438495051116, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.44530061640699, "done": 975027.308596127, "finish_reason": "length", "first": 975017.280825337, "full_response_s": 10.322193159954622, "last": 975027.302322188, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975017.280825337, 2], [975017.478017268, 7], [975017.624458366, 4], [975017.864377022, 53], [975018.034814552, 47], [975018.221873715, 30], [975018.373993095, 15], [975018.557486178, 14], [975018.7116542, 20], [975018.901199668, 14], [975019.083985859, 4], [975019.234278293, 13], [975019.410731464, 21], [975019.590537767, 2], [975019.77150516, 18], [975019.962831528, 29], [975020.209740115, 27], [975020.38108111, 15], [975020.527703832, 11], [975020.711869867, 18], [975020.901948615, 10], [975021.082631571, 31], [975021.23384889, 8], [975021.419775884, 11], [975021.599439902, 16], [975021.780202597, 12], [975021.973242487, 39], [975022.153205158, 18], [975022.329844072, 11], [975022.482104626, 16], [975022.661389174, 16], [975022.818315815, 11], [975023.057756809, 6], [975023.225994537, 9], [975023.403183355, 29], [975023.588657841, 22], [975023.770375249, 8], [975023.928786711, 18], [975024.111305225, 18], [975024.295033659, 34], [975024.479367372, 10], [975024.665941414, 14], [975024.85557456, 13], [975025.03831226, 2], [975025.220823237, 36], [975025.403929317, 42], [975025.588710525, 26], [975025.743805458, 17], [975025.933876377, 34], [975026.114124032, 12], [975026.298755181, 36], [975026.599531812, 50], [975026.773374928, 2], [975027.066497682, 54], [975027.302322188, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-59d8dae15c014af491eadd18", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0193, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2541, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975016.986402967, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.29442237003240734, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.55448569251108, "done": 975037.549782775, "finish_reason": "length", "first": 975027.553166088, "full_response_s": 10.21609639795497, "last": 975037.531844707, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975027.553166088, 2], [975027.724471031, 7], [975027.877550916, 4], [975028.103698657, 53], [975028.283742222, 47], [975028.468325737, 30], [975028.617851497, 15], [975028.79739472, 14], [975028.956049062, 20], [975029.135509471, 14], [975029.316328335, 4], [975029.464332843, 13], [975029.646294031, 21], [975029.842521906, 2], [975030.022384754, 18], [975030.202516357, 29], [975030.434262907, 27], [975030.621799798, 15], [975030.774403849, 11], [975030.966421378, 18], [975031.148195019, 10], [975031.327787511, 31], [975031.480098533, 8], [975031.661206417, 11], [975031.85353096, 16], [975032.041705557, 12], [975032.217760505, 39], [975032.390880088, 18], [975032.573317787, 11], [975032.726939776, 16], [975032.92126116, 16], [975033.071252151, 11], [975033.25008767, 6], [975033.432928145, 9], [975033.615054498, 29], [975033.802321445, 22], [975033.995195933, 8], [975034.148544263, 18], [975034.326805057, 18], [975034.509066424, 34], [975034.700628886, 10], [975034.893461592, 14], [975035.078837513, 13], [975035.259869759, 2], [975035.442847278, 36], [975035.623817623, 42], [975035.81186046, 26], [975035.973759995, 17], [975036.158068946, 34], [975036.341617857, 12], [975036.525739826, 36], [975036.81337089, 50], [975037.011348674, 2], [975037.294265383, 54], [975037.531844707, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-b68c2ce578c7446e83fb3837", "runtime": {"accepted": 201, "cached": 13, "decode_s": 9.979, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1898, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975027.333686377, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21947971091140062, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.550438753267045, "done": 975037.549079612, "finish_reason": "length", "first": 975027.552739423, "full_response_s": 10.215304392040707, "last": 975037.532998567, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975027.552739423, 2], [975027.723717615, 7], [975027.879239195, 4], [975028.102301356, 53], [975028.283267703, 47], [975028.467851938, 30], [975028.619247999, 15], [975028.798186518, 14], [975028.957384159, 20], [975029.134251106, 14], [975029.316523829, 4], [975029.464491459, 13], [975029.645384751, 21], [975029.841429835, 2], [975030.02340294, 18], [975030.203804032, 29], [975030.434336935, 27], [975030.620408815, 15], [975030.77446383, 11], [975030.96539076, 18], [975031.146778022, 10], [975031.327252307, 31], [975031.478097135, 8], [975031.660960606, 11], [975031.853724086, 16], [975032.04228655, 12], [975032.220810584, 39], [975032.390607318, 18], [975032.574939318, 11], [975032.727464612, 16], [975032.92183753, 16], [975033.068078062, 11], [975033.25254042, 6], [975033.433678426, 9], [975033.615273223, 29], [975033.803045151, 22], [975033.995390579, 8], [975034.15154796, 18], [975034.327771598, 18], [975034.508705899, 34], [975034.701440524, 10], [975034.891647383, 14], [975035.078281894, 13], [975035.260617447, 2], [975035.443140847, 36], [975035.625270539, 42], [975035.81256028, 26], [975035.974266545, 17], [975036.155662416, 34], [975036.342075817, 12], [975036.525685493, 36], [975036.81628629, 50], [975037.01478867, 2], [975037.29558005, 54], [975037.532998567, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-6089f760815540619372e46a", "runtime": {"accepted": 201, "cached": 13, "decode_s": 9.979, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1898, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975027.33377522, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21896420302800834, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.55419487394316, "done": 975037.546349531, "finish_reason": "length", "first": 975027.552478125, "full_response_s": 10.211519359028898, "last": 975037.531270306, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975027.552478125, 2], [975027.723271543, 7], [975027.877820038, 4], [975028.103110273, 53], [975028.282967655, 47], [975028.469683937, 30], [975028.619099303, 15], [975028.79962353, 14], [975028.956259131, 20], [975029.134754887, 14], [975029.31736836, 4], [975029.465603816, 13], [975029.645076096, 21], [975029.84165472, 2], [975030.025234555, 18], [975030.202428393, 29], [975030.436893776, 27], [975030.62289494, 15], [975030.77570466, 11], [975030.965838753, 18], [975031.146926974, 10], [975031.329448319, 31], [975031.478740813, 8], [975031.660234245, 11], [975031.85712285, 16], [975032.039943106, 12], [975032.219914999, 39], [975032.392354746, 18], [975032.5743601, 11], [975032.732077249, 16], [975032.922371341, 16], [975033.071378224, 11], [975033.250861997, 6], [975033.434851516, 9], [975033.615674514, 29], [975033.802806043, 22], [975033.995605832, 8], [975034.148096798, 18], [975034.32791855, 18], [975034.507037987, 34], [975034.699823537, 10], [975034.892129454, 14], [975035.084082501, 13], [975035.262414873, 2], [975035.441323806, 36], [975035.62437929, 42], [975035.812197355, 26], [975035.972865194, 17], [975036.156990731, 34], [975036.342208578, 12], [975036.525336503, 36], [975036.813819219, 50], [975037.011435358, 2], [975037.292378282, 54], [975037.531270306, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-64bf6297197e4279bec61d56", "runtime": {"accepted": 201, "cached": 13, "decode_s": 9.9791, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1898, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975027.334830172, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21764795295894146, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.55414034064608, "done": 975037.548961154, "finish_reason": "length", "first": 975027.552373186, "full_response_s": 10.214589852956124, "last": 975037.531186662, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975027.552373186, 2], [975027.722394934, 7], [975027.87770662, 4], [975028.102523696, 53], [975028.283597397, 47], [975028.468926553, 30], [975028.618946671, 15], [975028.797699824, 14], [975028.956691428, 20], [975029.136940483, 14], [975029.317189698, 4], [975029.464983385, 13], [975029.64532885, 21], [975029.84122543, 2], [975030.022701873, 18], [975030.202605616, 29], [975030.434193615, 27], [975030.622212912, 15], [975030.774281728, 11], [975030.9659271, 18], [975031.15028862, 10], [975031.327498886, 31], [975031.479771271, 8], [975031.661622699, 11], [975031.85379381, 16], [975032.039833319, 12], [975032.218310796, 39], [975032.392553824, 18], [975032.573750309, 11], [975032.726280354, 16], [975032.921507515, 16], [975033.068439227, 11], [975033.250436931, 6], [975033.433182788, 9], [975033.616480711, 29], [975033.802733391, 22], [975033.995128481, 8], [975034.146954682, 18], [975034.326705206, 18], [975034.507268519, 34], [975034.701540006, 10], [975034.891459105, 14], [975035.077500559, 13], [975035.259247087, 2], [975035.441534339, 36], [975035.62406617, 42], [975035.8120225, 26], [975035.972243995, 17], [975036.155464203, 34], [975036.342147429, 12], [975036.527043853, 36], [975036.814737939, 50], [975037.011748285, 2], [975037.295351006, 54], [975037.531186662, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-1825a4d19d074774a9a85c6e", "runtime": {"accepted": 201, "cached": 13, "decode_s": 9.979, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1898, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975027.334371301, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21800188499037176, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.55266963777696, "done": 975037.54983626, "finish_reason": "length", "first": 975027.552207771, "full_response_s": 10.215375188039616, "last": 975037.531595585, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975027.552207771, 2], [975027.723070898, 7], [975027.877913185, 4], [975028.102770195, 53], [975028.283677329, 47], [975028.470238004, 30], [975028.618675533, 15], [975028.797304389, 14], [975028.95646248, 20], [975029.133911428, 14], [975029.316427242, 4], [975029.464937035, 13], [975029.646964236, 21], [975029.841346624, 2], [975030.022239514, 18], [975030.2032775, 29], [975030.434408276, 27], [975030.620599269, 15], [975030.775214302, 11], [975030.965289534, 18], [975031.146847794, 10], [975031.327371389, 31], [975031.479140152, 8], [975031.660629568, 11], [975031.854176878, 16], [975032.040614222, 12], [975032.219316199, 39], [975032.391433339, 18], [975032.574991091, 11], [975032.727063785, 16], [975032.921014757, 16], [975033.071482971, 11], [975033.252374909, 6], [975033.433518082, 9], [975033.615854296, 29], [975033.80259919, 22], [975033.995521084, 8], [975034.151130159, 18], [975034.326581197, 18], [975034.507535017, 34], [975034.702305742, 10], [975034.891336104, 14], [975035.084354135, 13], [975035.263655064, 2], [975035.442954777, 36], [975035.625631256, 42], [975035.811400644, 26], [975035.975040648, 17], [975036.158228842, 34], [975036.344860695, 12], [975036.526172395, 36], [975036.813672235, 50], [975037.013666201, 2], [975037.293021576, 54], [975037.531595585, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-14581a731d184ca6aafe46d2", "runtime": {"accepted": 201, "cached": 13, "decode_s": 9.9791, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1898, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975027.334461072, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21774669899605215, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.55723388166052, "done": 975037.548320964, "finish_reason": "length", "first": 975027.553734586, "full_response_s": 10.213674925966188, "last": 975037.53134019, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975027.553734586, 2], [975027.723882599, 7], [975027.878598557, 4], [975028.104981229, 53], [975028.28314051, 47], [975028.468500768, 30], [975028.618556932, 15], [975028.798334158, 14], [975028.961768103, 20], [975029.13568495, 14], [975029.317300092, 4], [975029.466962448, 13], [975029.647440099, 21], [975029.841820791, 2], [975030.026824455, 18], [975030.202975228, 29], [975030.436117241, 27], [975030.621066493, 15], [975030.775468225, 11], [975030.968413401, 18], [975031.147527262, 10], [975031.327609041, 31], [975031.478286693, 8], [975031.661555343, 11], [975031.855387102, 16], [975032.040431848, 12], [975032.217941951, 39], [975032.389803057, 18], [975032.573389736, 11], [975032.732971073, 16], [975032.9203514, 16], [975033.070017848, 11], [975033.250919882, 6], [975033.434898105, 9], [975033.616015424, 29], [975033.802934597, 22], [975033.994703591, 8], [975034.146647018, 18], [975034.328834214, 18], [975034.507705024, 34], [975034.701061056, 10], [975034.891531565, 14], [975035.084451522, 13], [975035.260901225, 2], [975035.441855858, 36], [975035.624492836, 42], [975035.813417707, 26], [975035.973330754, 17], [975036.157297259, 34], [975036.342420775, 12], [975036.525561467, 36], [975036.813613262, 50], [975037.012285841, 2], [975037.294772764, 54], [975037.53134019, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-3302413e085c472c9f5780a6", "runtime": {"accepted": 201, "cached": 13, "decode_s": 9.979, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1898, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975027.334646038, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21908854797948152, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.55316481072834, "done": 975037.546734615, "finish_reason": "length", "first": 975027.55233474, "full_response_s": 10.212865096051246, "last": 975037.531529172, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975027.55233474, 2], [975027.722469906, 7], [975027.878164676, 4], [975028.101983804, 53], [975028.28493491, 47], [975028.468999685, 30], [975028.619305916, 15], [975028.798270305, 14], [975028.958263409, 20], [975029.134822515, 14], [975029.316826677, 4], [975029.465476047, 13], [975029.645589205, 21], [975029.84360452, 2], [975030.024802018, 18], [975030.205403804, 29], [975030.434048151, 27], [975030.621503877, 15], [975030.77453341, 11], [975030.965475252, 18], [975031.147771441, 10], [975031.328732741, 31], [975031.478672705, 8], [975031.661684456, 11], [975031.853995479, 16], [975032.040070987, 12], [975032.220171338, 39], [975032.38963537, 18], [975032.573233648, 11], [975032.728494414, 16], [975032.921112736, 16], [975033.070310712, 11], [975033.25432295, 6], [975033.434569611, 9], [975033.615149373, 29], [975033.803804167, 22], [975033.994589085, 8], [975034.147464351, 18], [975034.327087618, 18], [975034.507444286, 34], [975034.699202929, 10], [975034.894117589, 14], [975035.082571957, 13], [975035.259947147, 2], [975035.442088422, 36], [975035.62662018, 42], [975035.811497087, 26], [975035.972729425, 17], [975036.158503179, 34], [975036.341276851, 12], [975036.52584438, 36], [975036.813749447, 50], [975037.015389023, 2], [975037.29309658, 54], [975037.531529172, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-dd68b11a43974695aa5b70d4", "runtime": {"accepted": 201, "cached": 13, "decode_s": 9.9791, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1898, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975027.333869519, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21846522099804133, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.54599489725355, "done": 975037.547440466, "finish_reason": "length", "first": 975027.552300262, "full_response_s": 10.213433034019545, "last": 975037.534295523, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975027.552300262, 2], [975027.723565351, 7], [975027.87822528, 4], [975028.10304634, 53], [975028.284872818, 47], [975028.468590395, 30], [975028.620522091, 15], [975028.7972402, 14], [975028.956121458, 20], [975029.134363372, 14], [975029.317843119, 4], [975029.464610685, 13], [975029.645206249, 21], [975029.844086607, 2], [975030.023852853, 18], [975030.204022677, 29], [975030.434952791, 27], [975030.622548286, 15], [975030.774631453, 11], [975030.967792393, 18], [975031.149957918, 10], [975031.32742505, 31], [975031.477993845, 8], [975031.660878851, 11], [975031.855790329, 16], [975032.040364555, 12], [975032.221291215, 39], [975032.392070841, 18], [975032.573969129, 11], [975032.72636883, 16], [975032.922948991, 16], [975033.068272932, 11], [975033.250501728, 6], [975033.433834193, 9], [975033.615925253, 29], [975033.802043299, 22], [975033.997129752, 8], [975034.148392623, 18], [975034.326853726, 18], [975034.507957395, 34], [975034.700535563, 10], [975034.891040615, 14], [975035.082423293, 13], [975035.261122589, 2], [975035.44177935, 36], [975035.624692329, 42], [975035.811601626, 26], [975035.973663744, 17], [975036.157823215, 34], [975036.343071989, 12], [975036.525901033, 36], [975036.813881152, 50], [975037.012360797, 2], [975037.293685733, 54], [975037.534295523, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-dff64c755bb24eec87b406b5", "runtime": {"accepted": 201, "cached": 13, "decode_s": 9.979, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1898, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975027.334007432, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21829283004626632, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.554154845133468, "done": 975037.548380961, "finish_reason": "length", "first": 975027.55226044, "full_response_s": 10.214448212995194, "last": 975037.531068252, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975027.55226044, 2], [975027.721941118, 7], [975027.878793042, 4], [975028.102202369, 53], [975028.282890443, 47], [975028.468399813, 30], [975028.619816801, 15], [975028.799193888, 14], [975028.95563934, 20], [975029.134895679, 14], [975029.316245364, 4], [975029.465738849, 13], [975029.645437229, 21], [975029.842121511, 2], [975030.027013949, 18], [975030.207061028, 29], [975030.434131538, 27], [975030.620336179, 15], [975030.776324531, 11], [975030.966718978, 18], [975031.146675499, 10], [975031.327132186, 31], [975031.477826765, 8], [975031.660147193, 11], [975031.854094146, 16], [975032.039645985, 12], [975032.217630576, 39], [975032.389301307, 18], [975032.574264169, 11], [975032.72602616, 16], [975032.920771618, 16], [975033.068143515, 11], [975033.249882192, 6], [975033.434238268, 9], [975033.61482971, 29], [975033.803110619, 22], [975033.994822177, 8], [975034.14787673, 18], [975034.326423237, 18], [975034.508807846, 34], [975034.702427336, 10], [975034.892051538, 14], [975035.078635172, 13], [975035.259513281, 2], [975035.442390118, 36], [975035.624159573, 42], [975035.811932952, 26], [975035.973884581, 17], [975036.156376827, 34], [975036.340888823, 12], [975036.52509066, 36], [975036.813096457, 50], [975037.011847032, 2], [975037.292289582, 54], [975037.531068252, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-b17ed8a590ec4e2d8359e88d", "runtime": {"accepted": 201, "cached": 13, "decode_s": 9.979, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1898, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975027.333932748, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21832769201137125, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.55285705844857, "done": 975037.545848102, "finish_reason": "length", "first": 975027.554045705, "full_response_s": 10.21115203492809, "last": 975037.533360324, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975027.554045705, 2], [975027.723200555, 7], [975027.8779991, 4], [975028.103473837, 53], [975028.284717498, 47], [975028.469087169, 30], [975028.619022011, 15], [975028.799673031, 14], [975028.957103886, 20], [975029.134696218, 14], [975029.31823905, 4], [975029.46506442, 13], [975029.646688522, 21], [975029.843441009, 2], [975030.022806892, 18], [975030.20233067, 29], [975030.434847932, 27], [975030.62066661, 15], [975030.775129219, 11], [975030.965561055, 18], [975031.14948975, 10], [975031.327311744, 31], [975031.47823556, 8], [975031.661163812, 11], [975031.854922151, 16], [975032.040141751, 12], [975032.218125814, 39], [975032.389512736, 18], [975032.573825553, 11], [975032.726437738, 16], [975032.920515471, 16], [975033.069257984, 11], [975033.250976247, 6], [975033.433255616, 9], [975033.615435806, 29], [975033.8033176, 22], [975033.995439601, 8], [975034.148202089, 18], [975034.326356728, 18], [975034.50809126, 34], [975034.700145968, 10], [975034.89186126, 14], [975035.078524922, 13], [975035.260219676, 2], [975035.44270247, 36], [975035.624628428, 42], [975035.811157009, 26], [975035.973948593, 17], [975036.158689666, 34], [975036.342269071, 12], [975036.525995012, 36], [975036.814988502, 50], [975037.015075519, 2], [975037.292646268, 54], [975037.533360324, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-0b8f87b4b8d84fe19538f4ec", "runtime": {"accepted": 201, "cached": 13, "decode_s": 9.9791, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1898, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975027.334696067, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2193496379768476, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.54999422838621, "done": 975037.547612457, "finish_reason": "length", "first": 975027.552055811, "full_response_s": 10.212879111990333, "last": 975037.532488594, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975027.552055811, 2], [975027.722119572, 7], [975027.878645658, 4], [975028.104716363, 53], [975028.283195915, 47], [975028.469389153, 30], [975028.619882621, 15], [975028.797574582, 14], [975028.960752125, 20], [975029.135254268, 14], [975029.316591921, 4], [975029.465419298, 13], [975029.645663313, 21], [975029.841718204, 2], [975030.026557093, 18], [975030.204490828, 29], [975030.436041117, 27], [975030.623655428, 15], [975030.779104848, 11], [975030.966951814, 18], [975031.150507105, 10], [975031.328668361, 31], [975031.479608847, 8], [975031.661028683, 11], [975031.855110749, 16], [975032.040810292, 12], [975032.218449397, 39], [975032.389573789, 18], [975032.574009239, 11], [975032.727305548, 16], [975032.921402257, 16], [975033.073148707, 11], [975033.25133554, 6], [975033.43378114, 9], [975033.6172935, 29], [975033.803441178, 22], [975033.995747024, 8], [975034.151969122, 18], [975034.32799685, 18], [975034.508197046, 34], [975034.700709522, 10], [975034.892368913, 14], [975035.082686031, 13], [975035.261328162, 2], [975035.441951373, 36], [975035.624801571, 42], [975035.813265235, 26], [975035.974206708, 17], [975036.157744531, 34], [975036.342365514, 12], [975036.525182319, 36], [975036.813288511, 50], [975037.011947523, 2], [975037.292520402, 54], [975037.532488594, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-984de1c938d440789d27ce10", "runtime": {"accepted": 201, "cached": 13, "decode_s": 9.9791, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1898, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975027.334733345, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.217322466080077, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.552627727161124, "done": 975037.548754109, "finish_reason": "length", "first": 975027.552798843, "full_response_s": 10.214667688938789, "last": 975037.532203025, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975027.552798843, 2], [975027.723507706, 7], [975027.879140304, 4], [975028.102701878, 53], [975028.283336387, 47], [975028.469529113, 30], [975028.618273363, 15], [975028.7974619, 14], [975028.958989978, 20], [975029.13624884, 14], [975029.316760825, 4], [975029.464870911, 13], [975029.645806921, 21], [975029.842187955, 2], [975030.023092861, 18], [975030.204397953, 29], [975030.435553831, 27], [975030.621546547, 15], [975030.775809999, 11], [975030.967394302, 18], [975031.150072792, 10], [975031.328075176, 31], [975031.47891906, 8], [975031.661923148, 11], [975031.854257962, 16], [975032.039568149, 12], [975032.218039786, 39], [975032.390248761, 18], [975032.574420625, 11], [975032.727811506, 16], [975032.921662435, 16], [975033.069670442, 11], [975033.252146937, 6], [975033.434475872, 9], [975033.615556616, 29], [975033.8024136, 22], [975033.996092078, 8], [975034.149823939, 18], [975034.329246608, 18], [975034.507855608, 34], [975034.700034022, 10], [975034.891764689, 14], [975035.083293743, 13], [975035.259600125, 2], [975035.442456643, 36], [975035.625035607, 42], [975035.81178968, 26], [975035.974035021, 17], [975036.156474806, 34], [975036.341963247, 12], [975036.527344446, 36], [975036.814068454, 50], [975037.012568962, 2], [975037.294453949, 54], [975037.532203025, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-dbe17ccd73ae4250bbc28a0b", "runtime": {"accepted": 201, "cached": 13, "decode_s": 9.9792, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1898, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975027.33408642, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21871242299675941, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.547652178275346, "done": 975037.547664742, "finish_reason": "length", "first": 975027.552414288, "full_response_s": 10.213499238016084, "last": 975037.533762015, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975027.552414288, 2], [975027.722338649, 7], [975027.878729078, 4], [975028.103878056, 53], [975028.283073585, 47], [975028.468674327, 30], [975028.61994585, 15], [975028.797835033, 14], [975028.956558459, 20], [975029.135023305, 14], [975029.318051412, 4], [975029.465817981, 13], [975029.645534392, 21], [975029.843034166, 2], [975030.02254537, 18], [975030.202667949, 29], [975030.435698159, 27], [975030.621217589, 15], [975030.778831599, 11], [975030.966334423, 18], [975031.15021392, 10], [975031.328548399, 31], [975031.478442093, 8], [975031.661451349, 11], [975031.853662265, 16], [975032.039430301, 12], [975032.217867891, 39], [975032.389428533, 18], [975032.573142789, 11], [975032.726173704, 16], [975032.920851454, 16], [975033.068207335, 11], [975033.250213135, 6], [975033.434513934, 9], [975033.615493819, 29], [975033.803860436, 22], [975033.996342705, 8], [975034.150441955, 18], [975034.325940862, 18], [975034.507600022, 34], [975034.700788222, 10], [975034.890847825, 14], [975035.083107385, 13], [975035.259145717, 2], [975035.441594864, 36], [975035.624214002, 42], [975035.812272119, 26], [975035.972586297, 17], [975036.155862838, 34], [975036.341065998, 12], [975036.526761132, 36], [975036.814485808, 50], [975037.0112342, 2], [975037.292155238, 54], [975037.533762015, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-eae5f9a4d9a74be8b8959eb4", "runtime": {"accepted": 201, "cached": 13, "decode_s": 9.979, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1898, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975027.334165504, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21824878407642245, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.55282043712492, "done": 975037.550014827, "finish_reason": "length", "first": 975027.552586599, "full_response_s": 10.214982105069794, "last": 975037.53191552, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975027.552586599, 2], [975027.722938137, 7], [975027.878465188, 4], [975028.102616987, 53], [975028.284781559, 47], [975028.469600197, 30], [975028.619346106, 15], [975028.798777623, 14], [975028.956377973, 20], [975029.135299946, 14], [975029.318688338, 4], [975029.466574452, 13], [975029.646101065, 21], [975029.843227868, 2], [975030.024960282, 18], [975030.207696338, 29], [975030.436271041, 27], [975030.620481164, 15], [975030.776075025, 11], [975030.966499374, 18], [975031.150763123, 10], [975031.329731536, 31], [975031.478165899, 8], [975031.661503634, 11], [975031.854325222, 16], [975032.039117853, 12], [975032.219505533, 39], [975032.391762585, 18], [975032.574486798, 11], [975032.732576374, 16], [975032.921970979, 16], [975033.068906626, 11], [975033.250812063, 6], [975033.433569615, 9], [975033.618142656, 29], [975033.801825327, 22], [975033.995282889, 8], [975034.150692534, 18], [975034.328398125, 18], [975034.509347898, 34], [975034.702553057, 10], [975034.892444829, 14], [975035.082920291, 13], [975035.26125415, 2], [975035.443864521, 36], [975035.624917549, 42], [975035.814447332, 26], [975035.974106601, 17], [975036.157592635, 34], [975036.341535029, 12], [975036.525615848, 36], [975036.81540336, 50], [975037.012233748, 2], [975037.294044066, 54], [975037.53191552, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-45a883f1001e4d2e98e47050", "runtime": {"accepted": 201, "cached": 13, "decode_s": 9.9792, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1898, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975027.335032722, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21755387703888118, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.549975550327265, "done": 975037.549594033, "finish_reason": "length", "first": 975027.552976802, "full_response_s": 10.21503666206263, "last": 975037.533416881, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975027.552976802, 2], [975027.723348563, 7], [975027.878106295, 4], [975028.102967144, 53], [975028.283976769, 47], [975028.469466573, 30], [975028.61876956, 15], [975028.798406554, 14], [975028.956815694, 20], [975029.13462419, 14], [975029.318568169, 4], [975029.465545163, 13], [975029.646172822, 21], [975029.842291822, 2], [975030.022639397, 18], [975030.202850739, 29], [975030.435316404, 27], [975030.621140281, 15], [975030.777898016, 11], [975030.966616648, 18], [975031.150374904, 10], [975031.327712427, 31], [975031.478517849, 8], [975031.661865999, 11], [975031.853889645, 16], [975032.040289231, 12], [975032.218645546, 39], [975032.392175268, 18], [975032.573505074, 11], [975032.726527077, 16], [975032.920916506, 16], [975033.06852911, 11], [975033.251122207, 6], [975033.435010099, 9], [975033.616411371, 29], [975033.802670418, 22], [975033.998196175, 8], [975034.148920355, 18], [975034.327277768, 18], [975034.508500182, 34], [975034.700984788, 10], [975034.893384892, 14], [975035.08316815, 13], [975035.260103698, 2], [975035.442215279, 36], [975035.625692309, 42], [975035.811049511, 26], [975035.974650989, 17], [975036.157954072, 34], [975036.343137857, 12], [975036.525449201, 36], [975036.815100992, 50], [975037.012819973, 2], [975037.294577895, 54], [975037.533416881, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8ff055359dd340f38af17b4e", "runtime": {"accepted": 201, "cached": 13, "decode_s": 9.9791, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1898, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975027.334557371, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21841943101026118, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.555142331692654, "done": 975037.54988741, "finish_reason": "length", "first": 975027.553214245, "full_response_s": 10.21631835505832, "last": 975037.531636462, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975027.553214245, 2], [975027.723427183, 7], [975027.878518065, 4], [975028.103518699, 53], [975028.283777228, 47], [975028.468229566, 30], [975028.61884666, 15], [975028.798087387, 14], [975028.955890175, 20], [975029.134952188, 14], [975029.318947765, 4], [975029.464811618, 13], [975029.646046188, 21], [975029.841588803, 2], [975030.022895991, 18], [975030.203557853, 29], [975030.434530413, 27], [975030.620218569, 15], [975030.778648744, 11], [975030.965655802, 18], [975031.147446242, 10], [975031.327644991, 31], [975031.479233715, 8], [975031.660517814, 11], [975031.85610388, 16], [975032.041022665, 12], [975032.218263214, 39], [975032.391107868, 18], [975032.574621207, 11], [975032.727233056, 16], [975032.922212262, 16], [975033.069749078, 11], [975033.251045827, 6], [975033.434411827, 9], [975033.616526869, 29], [975033.803241044, 22], [975033.996705022, 8], [975034.149713385, 18], [975034.326055448, 18], [975034.509562126, 34], [975034.699565022, 10], [975034.893159512, 14], [975035.077969255, 13], [975035.261750908, 2], [975035.441416137, 36], [975035.623955648, 42], [975035.812618084, 26], [975035.972434097, 17], [975036.158360611, 34], [975036.341139162, 12], [975036.525399908, 36], [975036.813558497, 50], [975037.011564535, 2], [975037.293523902, 54], [975037.531636462, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-18f6afcf00df4df19b07e7c2", "runtime": {"accepted": 201, "cached": 13, "decode_s": 9.9791, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1898, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975027.333569055, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21964519005268812, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.471104069357178, "done": 975047.807090903, "finish_reason": "length", "first": 975037.782552576, "full_response_s": 10.240784338093363, "last": 975047.793897169, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975037.782552576, 2], [975037.956899049, 7], [975038.105385726, 4], [975038.327188374, 53], [975038.512564624, 47], [975038.697517856, 30], [975038.858048882, 15], [975039.036381305, 14], [975039.187808879, 20], [975039.368405473, 14], [975039.551269404, 4], [975039.702564248, 13], [975039.894234525, 21], [975040.073220032, 2], [975040.253708612, 18], [975040.437901223, 29], [975040.674152045, 27], [975040.868680953, 15], [975041.019879856, 11], [975041.201430618, 18], [975041.387086254, 10], [975041.565964788, 31], [975041.719496898, 8], [975041.91385716, 11], [975042.095305892, 16], [975042.2792352, 12], [975042.459819801, 39], [975042.632449216, 18], [975042.826368357, 11], [975042.980327252, 16], [975043.16144187, 16], [975043.312667691, 11], [975043.492723789, 6], [975043.677888421, 9], [975043.869190435, 29], [975044.054405942, 22], [975044.240734128, 8], [975044.388077376, 18], [975044.570964956, 18], [975044.756779793, 34], [975044.949475306, 10], [975045.133211111, 14], [975045.325572965, 13], [975045.506149366, 2], [975045.691878668, 36], [975045.88704187, 42], [975046.071561104, 26], [975046.226378532, 17], [975046.409646582, 34], [975046.5937048, 12], [975046.782919711, 36], [975047.075674114, 50], [975047.266238761, 2], [975047.549605731, 54], [975047.793897169, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-e07b0a40b4824fdd94df37ce", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0078, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.191, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975037.566306565, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21624601108487695, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.48261528098812, "done": 975047.805168075, "finish_reason": "length", "first": 975037.783839132, "full_response_s": 10.23860121902544, "last": 975047.79066132, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975037.783839132, 2], [975037.958668109, 7], [975038.103807248, 4], [975038.326622371, 53], [975038.511222278, 47], [975038.69762153, 30], [975038.857347814, 15], [975039.036547889, 14], [975039.186734999, 20], [975039.366282864, 14], [975039.553693549, 4], [975039.699372447, 13], [975039.895652819, 21], [975040.074877657, 2], [975040.256360458, 18], [975040.437501276, 29], [975040.674254488, 27], [975040.867768248, 15], [975041.018583348, 11], [975041.201541605, 18], [975041.384128921, 10], [975041.566943169, 31], [975041.718776231, 8], [975041.913691072, 11], [975042.096367325, 16], [975042.277517337, 12], [975042.457978457, 39], [975042.632525933, 18], [975042.824304608, 11], [975042.977721995, 16], [975043.16095572, 16], [975043.30972226, 11], [975043.49220156, 6], [975043.676029846, 9], [975043.871161213, 29], [975044.054014858, 22], [975044.239822415, 8], [975044.386981769, 18], [975044.569246742, 18], [975044.7573201, 34], [975044.949330641, 10], [975045.132704657, 14], [975045.327526464, 13], [975045.507591499, 2], [975045.692990706, 36], [975045.886288149, 42], [975046.071443846, 26], [975046.225112821, 17], [975046.409508813, 34], [975046.59506009, 12], [975046.781943762, 36], [975047.075164365, 50], [975047.267087917, 2], [975047.548337877, 54], [975047.79066132, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-2a5df3d6080d4596ac137330", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0077, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.191, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975037.566566856, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21727227605879307, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.479835984045696, "done": 975047.806502934, "finish_reason": "length", "first": 975037.782895246, "full_response_s": 10.238888932974078, "last": 975047.790808961, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975037.782895246, 2], [975037.956797486, 7], [975038.103927786, 4], [975038.327304671, 53], [975038.512169588, 47], [975038.696834484, 30], [975038.856211762, 15], [975039.040219153, 14], [975039.188499547, 20], [975039.370192915, 14], [975039.553279667, 4], [975039.702936069, 13], [975039.892846854, 21], [975040.07556391, 2], [975040.254463725, 18], [975040.436543486, 29], [975040.674493483, 27], [975040.866682545, 15], [975041.020389286, 11], [975041.202317644, 18], [975041.387000035, 10], [975041.567282719, 31], [975041.717859031, 8], [975041.914573411, 11], [975042.094809774, 16], [975042.277680689, 12], [975042.461334298, 39], [975042.632999108, 18], [975042.825078744, 11], [975042.978233136, 16], [975043.161176412, 16], [975043.310741343, 11], [975043.493384954, 6], [975043.679410342, 9], [975043.868224021, 29], [975044.056140844, 22], [975044.240549001, 8], [975044.387369365, 18], [975044.569723981, 18], [975044.757394097, 34], [975044.951175793, 10], [975045.133267652, 14], [975045.325751388, 13], [975045.507641865, 2], [975045.692264888, 36], [975045.885597673, 42], [975046.071507555, 26], [975046.226085923, 17], [975046.409327959, 34], [975046.596112419, 12], [975046.785152572, 36], [975047.076829062, 50], [975047.265531422, 2], [975047.546899471, 54], [975047.790808961, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-061cd6dd0b4d4e2180e3da63", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0078, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.191, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975037.567614001, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.215281245065853, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.47850207581792, "done": 975047.807022459, "finish_reason": "length", "first": 975037.783213629, "full_response_s": 10.239977019955404, "last": 975047.791651301, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975037.783213629, 2], [975037.958574977, 7], [975038.106579103, 4], [975038.326052657, 53], [975038.511025632, 47], [975038.699367007, 30], [975038.856296109, 15], [975039.037535965, 14], [975039.187701301, 20], [975039.367828911, 14], [975039.55470428, 4], [975039.69984823, 13], [975039.893503635, 21], [975040.072961693, 2], [975040.253338935, 18], [975040.438075566, 29], [975040.674861144, 27], [975040.869013239, 15], [975041.018533959, 11], [975041.205796151, 18], [975041.384048941, 10], [975041.565514267, 31], [975041.717947059, 8], [975041.914048494, 11], [975042.097134949, 16], [975042.277575318, 12], [975042.459274085, 39], [975042.632740193, 18], [975042.824205286, 11], [975042.977807302, 16], [975043.161261512, 16], [975043.310615893, 11], [975043.493245106, 6], [975043.676702067, 9], [975043.869757941, 29], [975044.054931995, 22], [975044.243655576, 8], [975044.38753574, 18], [975044.571045384, 18], [975044.757668386, 34], [975044.95166012, 10], [975045.135071174, 14], [975045.326140456, 13], [975045.505958464, 2], [975045.694369947, 36], [975045.886973618, 42], [975046.071179844, 26], [975046.225255486, 17], [975046.408527808, 34], [975046.594845189, 12], [975046.783656249, 36], [975047.074512862, 50], [975047.266858361, 2], [975047.546536066, 54], [975047.791651301, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-2ecbb137fe074382940bedbc", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0078, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.191, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975037.567045439, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21616819000337273, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.482164355084812, "done": 975047.806826389, "finish_reason": "length", "first": 975037.783590906, "full_response_s": 10.240127603989094, "last": 975047.790590172, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975037.783590906, 2], [975037.957636979, 7], [975038.10576545, 4], [975038.32667808, 53], [975038.511796904, 47], [975038.697969272, 30], [975038.85602566, 15], [975039.036236129, 14], [975039.187029096, 20], [975039.366442071, 14], [975039.551740547, 4], [975039.70005126, 13], [975039.892305234, 21], [975040.073924843, 2], [975040.254783724, 18], [975040.435739224, 29], [975040.676413831, 27], [975040.867329007, 15], [975041.020016489, 11], [975041.204467404, 18], [975041.386350181, 10], [975041.566652432, 31], [975041.71991798, 8], [975041.914443529, 11], [975042.099171883, 16], [975042.277396639, 12], [975042.461084311, 39], [975042.633323891, 18], [975042.827176667, 11], [975042.977900882, 16], [975043.161534714, 16], [975043.311474793, 11], [975043.491915207, 6], [975043.678477399, 9], [975043.869117591, 29], [975044.053916623, 22], [975044.24119004, 8], [975044.38727329, 18], [975044.569646705, 18], [975044.757264823, 34], [975044.951495089, 10], [975045.133059855, 14], [975045.324928774, 13], [975045.506409081, 2], [975045.691470833, 36], [975045.886058977, 42], [975046.07072262, 26], [975046.225736213, 17], [975046.408455396, 34], [975046.595232689, 12], [975046.782649101, 36], [975047.074651527, 50], [975047.265933177, 2], [975047.549222023, 54], [975047.790590172, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8f7756b59d3b461b9e8b6c39", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0077, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.191, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975037.566698785, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21689212089404464, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.4797376947581, "done": 975047.805959074, "finish_reason": "length", "first": 975037.782785892, "full_response_s": 10.238514567958191, "last": 975047.790738213, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975037.782785892, 2], [975037.960365412, 7], [975038.104437312, 4], [975038.327498165, 53], [975038.510667379, 47], [975038.699299331, 30], [975038.855839573, 15], [975039.03709546, 14], [975039.189655247, 20], [975039.36770183, 14], [975039.551619705, 4], [975039.700233042, 13], [975039.89326344, 21], [975040.073076711, 2], [975040.25501544, 18], [975040.436263356, 29], [975040.6775363, 27], [975040.866523545, 15], [975041.018463274, 11], [975041.202440806, 18], [975041.386688707, 10], [975041.567208851, 31], [975041.718510517, 8], [975041.914957615, 11], [975042.094873547, 16], [975042.277462844, 12], [975042.458979013, 39], [975042.633137549, 18], [975042.82458613, 11], [975042.979392116, 16], [975043.161914214, 16], [975043.310931285, 11], [975043.492381375, 6], [975043.677226904, 9], [975043.869026907, 29], [975044.057338622, 22], [975044.242665787, 8], [975044.388297269, 18], [975044.570697818, 18], [975044.757523866, 34], [975044.949763563, 10], [975045.134921582, 14], [975045.325918403, 13], [975045.50711034, 2], [975045.692342212, 36], [975045.887668558, 42], [975046.073237626, 26], [975046.224986828, 17], [975046.409146816, 34], [975046.594338703, 12], [975046.782779238, 36], [975047.076425067, 50], [975047.266586023, 2], [975047.548089218, 54], [975047.790738213, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-a1820f4f712947b2b708b29c", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0077, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.191, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975037.567444506, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21534138603601605, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.479897573693673, "done": 975047.808011, "finish_reason": "length", "first": 975037.782363786, "full_response_s": 10.241607544012368, "last": 975047.79025331, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975037.782363786, 2], [975037.957906324, 7], [975038.10484921, 4], [975038.327887457, 53], [975038.510323237, 47], [975038.700132199, 30], [975038.857171488, 15], [975039.038771709, 14], [975039.18718624, 20], [975039.366707321, 14], [975039.552446382, 4], [975039.699714749, 13], [975039.893056011, 21], [975040.07313834, 2], [975040.253961591, 18], [975040.436131363, 29], [975040.67574217, 27], [975040.867144265, 15], [975041.018336833, 11], [975041.2019412, 18], [975041.384844147, 10], [975041.567398009, 31], [975041.719199505, 8], [975041.913756621, 11], [975042.095805914, 16], [975042.278571234, 12], [975042.458755744, 39], [975042.632681364, 18], [975042.823993201, 11], [975042.978363945, 16], [975043.161374434, 16], [975043.310419456, 11], [975043.492790153, 6], [975043.679809233, 9], [975043.868773608, 29], [975044.057400683, 22], [975044.240114144, 8], [975044.387604697, 18], [975044.570462982, 18], [975044.761160493, 34], [975044.948978963, 10], [975045.133306114, 14], [975045.324796061, 13], [975045.507149842, 2], [975045.692564264, 36], [975045.885445105, 42], [975046.074763947, 26], [975046.226006999, 17], [975046.408980265, 34], [975046.593840345, 12], [975046.785083023, 36], [975047.076905475, 50], [975047.266322245, 2], [975047.547025081, 54], [975047.79025331, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-f935064e5f6343adb8043803", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0077, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.191, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975037.566403456, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21596032998058945, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.480223445768907, "done": 975047.805464891, "finish_reason": "length", "first": 975037.783125858, "full_response_s": 10.238675998989493, "last": 975047.790887389, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975037.783125858, 2], [975037.958279937, 7], [975038.10530381, 4], [975038.326790762, 53], [975038.512062218, 47], [975038.698250169, 30], [975038.855533381, 15], [975039.036702793, 14], [975039.188870152, 20], [975039.367071014, 14], [975039.550952284, 4], [975039.699191017, 13], [975039.893388458, 21], [975040.072555155, 2], [975040.255615601, 18], [975040.437027845, 29], [975040.67404821, 27], [975040.868789043, 15], [975041.018173545, 11], [975041.205240756, 18], [975041.38424861, 10], [975041.567348412, 31], [975041.719362409, 8], [975041.913486059, 11], [975042.094578602, 16], [975042.278637007, 12], [975042.458113138, 39], [975042.632631543, 18], [975042.823829545, 11], [975042.977576674, 16], [975043.161319589, 16], [975043.310481772, 11], [975043.492527239, 6], [975043.676457968, 9], [975043.867979538, 29], [975044.053599696, 22], [975044.240402321, 8], [975044.388396128, 18], [975044.571118916, 18], [975044.756071477, 34], [975044.948709921, 10], [975045.132248697, 14], [975045.325104509, 13], [975045.506921678, 2], [975045.691763026, 36], [975045.885938376, 42], [975046.070857077, 26], [975046.226511261, 17], [975046.408318235, 34], [975046.594975598, 12], [975046.786532564, 36], [975047.075316805, 50], [975047.265816223, 2], [975047.549352224, 54], [975047.790887389, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-5545ed2032894cda9fd7aba6", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0076, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.191, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975037.566788892, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21633696602657437, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.47548127088707, "done": 975047.808060661, "finish_reason": "length", "first": 975037.782730167, "full_response_s": 10.241124080959707, "last": 975047.792354609, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975037.782730167, 2], [975037.957307012, 7], [975038.105084334, 4], [975038.326283317, 53], [975038.51145913, 47], [975038.697833487, 30], [975038.855746202, 15], [975039.036781893, 14], [975039.186959868, 20], [975039.366365707, 14], [975039.553095772, 4], [975039.701345272, 13], [975039.89254207, 21], [975040.074089155, 2], [975040.254413983, 18], [975040.43661281, 29], [975040.674794779, 27], [975040.869116802, 15], [975041.018254549, 11], [975041.202660346, 18], [975041.384585313, 10], [975041.567610702, 31], [975041.718416954, 8], [975041.913926084, 11], [975042.095679569, 16], [975042.278835412, 12], [975042.458249579, 39], [975042.634276065, 18], [975042.826138337, 11], [975042.97797371, 16], [975043.160761282, 16], [975043.310360675, 11], [975043.492852966, 6], [975043.676580841, 9], [975043.867678881, 29], [975044.054276013, 22], [975044.241500568, 8], [975044.388127838, 18], [975044.569920355, 18], [975044.756837997, 34], [975044.94984599, 10], [975045.132866697, 14], [975045.325443052, 13], [975045.506458422, 2], [975045.692169693, 36], [975045.886533065, 42], [975046.07233908, 26], [975046.225945242, 17], [975046.408828145, 34], [975046.594717148, 12], [975046.781767435, 36], [975047.07421619, 50], [975047.26586798, 2], [975047.546734936, 54], [975047.792354609, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-dd3684c901d8434f9afb0381", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0077, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.191, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975037.56693658, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2157935870345682, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.482345649931567, "done": 975047.805394927, "finish_reason": "length", "first": 975037.784099375, "full_response_s": 10.237862442038022, "last": 975047.791027446, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975037.784099375, 2], [975037.957760716, 7], [975038.104914983, 4], [975038.326859399, 53], [975038.513294809, 47], [975038.698606823, 30], [975038.857030663, 15], [975039.038538729, 14], [975039.188710736, 20], [975039.368825067, 14], [975039.552655779, 4], [975039.700911151, 13], [975039.892148394, 21], [975040.072684172, 2], [975040.256545904, 18], [975040.436055751, 29], [975040.674964211, 27], [975040.867471256, 15], [975041.018086798, 11], [975041.202599085, 18], [975041.38495275, 10], [975041.567553873, 31], [975041.718958462, 8], [975041.913990401, 11], [975042.09811693, 16], [975042.278115242, 12], [975042.460349853, 39], [975042.634804278, 18], [975042.823905493, 11], [975042.978557535, 16], [975043.161088225, 16], [975043.310249481, 11], [975043.493798821, 6], [975043.676946214, 9], [975043.869823058, 29], [975044.058765972, 22], [975044.241360175, 8], [975044.387487119, 18], [975044.570258929, 18], [975044.756616921, 34], [975044.950670284, 10], [975045.133552085, 14], [975045.325216375, 13], [975045.506812804, 2], [975045.692925718, 36], [975045.887797191, 42], [975046.071256656, 26], [975046.225564638, 17], [975046.409261482, 34], [975046.594773193, 12], [975046.786068268, 36], [975047.076146954, 50], [975047.265663015, 2], [975047.546593647, 54], [975047.791027446, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8dfd21b98a71471d8ec6082d", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0077, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.191, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975037.567532485, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21656689001247287, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.477132184653293, "done": 975047.80828393, "finish_reason": "length", "first": 975037.782316396, "full_response_s": 10.241069395910017, "last": 975047.791292216, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975037.782316396, 2], [975037.957096543, 7], [975038.104629989, 4], [975038.327065596, 53], [975038.510454942, 47], [975038.697192129, 30], [975038.858494027, 15], [975039.03648538, 14], [975039.189539413, 20], [975039.366515012, 14], [975039.551087557, 4], [975039.699434716, 13], [975039.892614802, 21], [975040.072296928, 2], [975040.2537868, 18], [975040.435975564, 29], [975040.674352499, 27], [975040.866853912, 15], [975041.018661872, 11], [975041.202045146, 18], [975041.385607484, 10], [975041.566711661, 31], [975041.721609764, 8], [975041.91435931, 11], [975042.096653902, 16], [975042.281592805, 12], [975042.459521849, 39], [975042.635592829, 18], [975042.825402935, 11], [975042.978849296, 16], [975043.162185816, 16], [975043.309815743, 11], [975043.493464038, 6], [975043.676819757, 9], [975043.871866552, 29], [975044.05721186, 22], [975044.240616646, 8], [975044.39029003, 18], [975044.570124424, 18], [975044.761347603, 34], [975044.949973312, 10], [975045.132974611, 14], [975045.327060664, 13], [975045.506539522, 2], [975045.691157745, 36], [975045.88682361, 42], [975046.073429424, 26], [975046.226666277, 17], [975046.408731062, 34], [975046.594623953, 12], [975046.786342718, 36], [975047.074327336, 50], [975047.266954964, 2], [975047.54646015, 54], [975047.791292216, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-26b05272a3e446f7883c8d71", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0078, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.191, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975037.567214534, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21510186197701842, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.478077523208302, "done": 975047.80719853, "finish_reason": "length", "first": 975037.782823906, "full_response_s": 10.239436120958999, "last": 975047.791428353, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975037.782823906, 2], [975037.957415294, 7], [975038.104164126, 4], [975038.329486669, 53], [975038.511904114, 47], [975038.697902364, 30], [975038.856553168, 15], [975039.037455009, 14], [975039.189261171, 20], [975039.366937741, 14], [975039.552493388, 4], [975039.703935057, 13], [975039.89391539, 21], [975040.075699055, 2], [975040.254924069, 18], [975040.437633493, 29], [975040.675240244, 27], [975040.866361202, 15], [975041.018734716, 11], [975041.204097087, 18], [975041.386300295, 10], [975041.566086653, 31], [975041.721025042, 8], [975041.915677161, 11], [975042.097406663, 16], [975042.277161132, 12], [975042.459402287, 39], [975042.635742597, 18], [975042.826557099, 11], [975042.981860612, 16], [975043.162353167, 16], [975043.310550569, 11], [975043.493313086, 6], [975043.676364404, 9], [975043.868599906, 29], [975044.054544431, 22], [975044.241960576, 8], [975044.387809454, 18], [975044.570370523, 18], [975044.756903866, 34], [975044.94962829, 10], [975045.133706989, 14], [975045.324661124, 13], [975045.507337784, 2], [975045.691250893, 36], [975045.887557524, 42], [975046.07465504, 26], [975046.225852655, 17], [975046.409443281, 34], [975046.594293794, 12], [975046.783534639, 36], [975047.07525484, 50], [975047.26733464, 2], [975047.547261788, 54], [975047.791428353, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-22252620d06c4b1a9df0702c", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0078, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.191, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975037.567762409, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21506149705965072, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.476789243952457, "done": 975047.80819499, "finish_reason": "length", "first": 975037.783386772, "full_response_s": 10.241715186042711, "last": 975047.792497322, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975037.783386772, 2], [975037.961886964, 7], [975038.104016502, 4], [975038.326549031, 53], [975038.510372434, 47], [975038.698305911, 30], [975038.85532184, 15], [975039.038484124, 14], [975039.186824147, 20], [975039.366657324, 14], [975039.551546893, 4], [975039.703280563, 13], [975039.891917718, 21], [975040.072826197, 2], [975040.255511398, 18], [975040.436199744, 29], [975040.676333083, 27], [975040.867408139, 15], [975041.017980163, 11], [975041.202521922, 18], [975041.38433347, 10], [975041.566583827, 31], [975041.718106362, 8], [975041.913616308, 11], [975042.095521145, 16], [975042.27730138, 12], [975042.460963134, 39], [975042.633603444, 18], [975042.824133177, 11], [975042.978285486, 16], [975043.160863308, 16], [975043.310309557, 11], [975043.492034337, 6], [975043.676290456, 9], [975043.867592182, 29], [975044.053841427, 22], [975044.241274164, 8], [975044.389152025, 18], [975044.570202084, 18], [975044.756707556, 34], [975044.950379115, 10], [975045.134509316, 14], [975045.32625349, 13], [975045.506095033, 2], [975045.692457166, 36], [975045.887426203, 42], [975046.070597586, 26], [975046.226573834, 17], [975046.409576794, 34], [975046.593989633, 12], [975046.782559538, 36], [975047.075833114, 50], [975047.26575349, 2], [975047.547300218, 54], [975047.792497322, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-38c446c6a9ca4699b3f6dfb6", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0077, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.191, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975037.566479804, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21690696803852916, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.477253831565537, "done": 975047.80769476, "finish_reason": "length", "first": 975037.783265867, "full_response_s": 10.239813877036795, "last": 975047.792193897, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975037.783265867, 2], [975037.956985781, 7], [975038.104219115, 4], [975038.326916564, 53], [975038.510223658, 47], [975038.698562697, 30], [975038.856113719, 15], [975039.037227565, 14], [975039.188643028, 20], [975039.366869873, 14], [975039.551841406, 4], [975039.70013164, 13], [975039.892050431, 21], [975040.073815217, 2], [975040.254356562, 18], [975040.436467234, 29], [975040.677215613, 27], [975040.866640371, 15], [975041.018899971, 11], [975041.201857252, 18], [975041.385385831, 10], [975041.566466617, 31], [975041.718579554, 8], [975041.914274178, 11], [975042.09658549, 16], [975042.278716603, 12], [975042.460488086, 39], [975042.635672729, 18], [975042.82466595, 11], [975042.979163456, 16], [975043.161026532, 16], [975043.310805916, 11], [975043.492310994, 6], [975043.677039121, 9], [975043.867880743, 29], [975044.053764135, 22], [975044.240930853, 8], [975044.388823866, 18], [975044.570312286, 18], [975044.757601174, 34], [975044.949711325, 10], [975045.133116476, 14], [975045.3263671, 13], [975045.507023881, 2], [975045.692516507, 36], [975045.886710512, 42], [975046.071040187, 26], [975046.226145184, 17], [975046.409052933, 34], [975046.5945553, 12], [975046.784180526, 36], [975047.074404452, 50], [975047.267174249, 2], [975047.547188432, 54], [975047.792193897, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-66e3d955f53344398b0a3c9b", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0077, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.191, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975037.567880883, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21538498403970152, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.470550689471285, "done": 975047.808498639, "finish_reason": "length", "first": 975037.782647211, "full_response_s": 10.241661110077985, "last": 975047.794209313, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975037.782647211, 2], [975037.957575958, 7], [975038.105483033, 4], [975038.326724542, 53], [975038.510830378, 47], [975038.698035269, 30], [975038.855665086, 15], [975039.036626173, 14], [975039.186411528, 20], [975039.366981067, 14], [975039.554452661, 4], [975039.704037707, 13], [975039.893319453, 21], [975040.073388823, 2], [975040.256195762, 18], [975040.437351892, 29], [975040.674546872, 27], [975040.866755005, 15], [975041.019381002, 11], [975041.202917341, 18], [975041.384658173, 10], [975041.566884212, 31], [975041.718033566, 8], [975041.915043994, 11], [975042.095146957, 16], [975042.279834384, 12], [975042.458527308, 39], [975042.632930951, 18], [975042.825172195, 11], [975042.97923382, 16], [975043.161613237, 16], [975043.309880396, 11], [975043.493055644, 6], [975043.676785918, 9], [975043.868120922, 29], [975044.053548467, 22], [975044.24046123, 8], [975044.388187867, 18], [975044.569974352, 18], [975044.75748486, 34], [975044.949080958, 10], [975045.133831447, 14], [975045.326571921, 13], [975045.507069798, 2], [975045.692106048, 36], [975045.885741458, 42], [975046.071730872, 26], [975046.225405414, 17], [975046.411792647, 34], [975046.595889887, 12], [975046.787117046, 36], [975047.074951784, 50], [975047.267644384, 2], [975047.54695742, 54], [975047.794209313, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-51327150402845929f01e738", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0078, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.191, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975037.566837529, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21580968203488737, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 25.47553644347587, "done": 975047.807866159, "finish_reason": "length", "first": 975037.783083236, "full_response_s": 10.241636933991686, "last": 975047.792686, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975037.783083236, 2], [975037.959266253, 7], [975038.104085842, 4], [975038.326186202, 53], [975038.510744831, 47], [975038.698090002, 30], [975038.858254679, 15], [975039.037045127, 14], [975039.186517939, 20], [975039.36676663, 14], [975039.551379862, 4], [975039.699284228, 13], [975039.892385022, 21], [975040.072394987, 2], [975040.253470481, 18], [975040.436693862, 29], [975040.674729695, 27], [975040.866597461, 15], [975041.019475413, 11], [975041.201320704, 18], [975041.384398347, 10], [975041.565664723, 31], [975041.717731806, 8], [975041.913335715, 11], [975042.094717763, 16], [975042.278188022, 12], [975042.457865231, 39], [975042.632260554, 18], [975042.82373691, 11], [975042.977445001, 16], [975043.162586083, 16], [975043.311136442, 11], [975043.492471722, 6], [975043.676190701, 9], [975043.867402448, 29], [975044.053398682, 22], [975044.238994538, 8], [975044.386751525, 18], [975044.569521511, 18], [975044.756403524, 34], [975044.948554089, 10], [975045.132549129, 14], [975045.325653953, 13], [975045.506329901, 2], [975045.693064527, 36], [975045.886147997, 42], [975046.070418556, 26], [975046.225671864, 17], [975046.407982268, 34], [975046.594081405, 12], [975046.781598947, 36], [975047.074039975, 50], [975047.266517915, 2], [975047.546357259, 54], [975047.792686, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-0015e503242d44c096c2dff4", "runtime": {"accepted": 201, "cached": 13, "decode_s": 10.0076, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.191, "rounds": 54, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975037.566229225, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21685401094146073, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 201, "drafted": 352, "rounds": 54}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "python", "burst": null, "phase": "uncached_first_use", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 50.394547279094006, "done": 975053.011802196, "finish_reason": "length", "first": 975047.951074048, "full_response_s": 5.185988562996499, "last": 975053.011145301, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975047.951074048, 3], [975048.035391424, 26], [975048.117635147, 15], [975048.198526556, 34], [975048.279488537, 21], [975048.360620542, 25], [975048.441074565, 14], [975048.522873992, 14], [975048.604161092, 18], [975048.686696176, 26], [975048.767657182, 13], [975048.852171318, 13], [975048.936860266, 13], [975049.017512589, 23], [975049.100051806, 32], [975049.180453438, 7], [975049.260727877, 23], [975049.343701424, 9], [975049.423603338, 13], [975049.503722905, 15], [975049.584179958, 19], [975049.665057021, 17], [975049.746441819, 23], [975049.82944415, 9], [975049.9157495, 17], [975049.997770798, 3], [975050.080746656, 21], [975050.160861428, 10], [975050.243119722, 24], [975050.322887249, 19], [975050.403653012, 14], [975050.483783527, 13], [975050.564717698, 5], [975050.643789916, 22], [975050.727564404, 13], [975050.80742039, 51], [975050.895170727, 15], [975050.978439696, 6], [975051.058600183, 8], [975051.139676592, 9], [975051.22201948, 16], [975051.301704072, 16], [975051.383487293, 9], [975051.463558009, 32], [975051.543897416, 18], [975051.6244383, 13], [975051.705693164, 11], [975051.785836741, 15], [975051.871464632, 8], [975051.955358038, 18], [975052.036308987, 25], [975052.110721791, 19], [975052.191545851, 8], [975052.273962213, 40], [975052.354075973, 16], [975052.43524755, 64], [975052.515456906, 6], [975052.596257398, 6], [975052.678840311, 11], [975052.760169833, 15], [975052.845105156, 17], [975052.930156685, 21], [975053.011145301, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-aa04720ea3664118bc9b8c70", "runtime": {"accepted": 193, "cached": 0, "decode_s": 5.0599, "drafted": 930, "drafts": true, "min_rows": 16, "prefill_s": 0.1172, "rounds": 62, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975047.825813633, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1252604149049148, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 193, "drafted": 930, "rounds": 62}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 50.562689637348726, "done": 975058.180087648, "finish_reason": "length", "first": 975053.136321237, "full_response_s": 5.157443576026708, "last": 975058.17956561, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975053.136321237, 3], [975053.217912639, 26], [975053.29844016, 15], [975053.378937154, 34], [975053.459839327, 21], [975053.539867145, 25], [975053.620072042, 14], [975053.701216027, 14], [975053.78123143, 18], [975053.867474357, 26], [975053.951110156, 13], [975054.031661841, 13], [975054.112202247, 13], [975054.193711259, 23], [975054.274502851, 32], [975054.35544866, 7], [975054.437076786, 23], [975054.517786815, 9], [975054.598060082, 13], [975054.680143289, 15], [975054.761875025, 19], [975054.845925462, 17], [975054.931056022, 23], [975055.011577394, 9], [975055.092341298, 17], [975055.172202752, 3], [975055.253748584, 21], [975055.333545993, 10], [975055.414615513, 24], [975055.495523922, 19], [975055.575721535, 14], [975055.656395875, 13], [975055.736953613, 5], [975055.818070491, 22], [975055.903872112, 13], [975055.986951423, 51], [975056.068129471, 15], [975056.148305971, 6], [975056.229361818, 8], [975056.308738854, 9], [975056.389912614, 16], [975056.470885937, 16], [975056.551145984, 9], [975056.631280838, 32], [975056.714702676, 18], [975056.795100716, 13], [975056.881775401, 11], [975056.965110609, 15], [975057.046153646, 8], [975057.126410019, 18], [975057.208269526, 25], [975057.281377496, 19], [975057.361698442, 8], [975057.441687724, 40], [975057.523073096, 16], [975057.603271168, 64], [975057.685007338, 6], [975057.764682924, 6], [975057.851282353, 11], [975057.936514382, 15], [975058.01773172, 17], [975058.098375791, 21], [975058.17956561, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-6d37ff54043f45109751ef26", "runtime": {"accepted": 193, "cached": 30, "decode_s": 5.044, "drafted": 930, "drafts": true, "min_rows": 16, "prefill_s": 0.1088, "rounds": 62, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975053.022644072, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.11367716500535607, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 193, "drafted": 930, "rounds": 62}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 50.52897724159633, "done": 975063.357937243, "finish_reason": "length", "first": 975058.310344025, "full_response_s": 5.159980249009095, "last": 975063.356953197, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975058.310344025, 3], [975058.391826038, 26], [975058.472524618, 15], [975058.553629881, 34], [975058.634737513, 21], [975058.717438871, 25], [975058.797710065, 14], [975058.88453461, 14], [975058.967490521, 18], [975059.048519906, 26], [975059.128483442, 13], [975059.20920361, 13], [975059.289555094, 13], [975059.369757097, 23], [975059.45027382, 32], [975059.531472637, 7], [975059.611225175, 23], [975059.692600014, 9], [975059.772638377, 13], [975059.858503184, 15], [975059.942392158, 19], [975060.02284489, 17], [975060.10360391, 23], [975060.184596071, 9], [975060.264533965, 17], [975060.344985545, 3], [975060.42588483, 21], [975060.506345578, 10], [975060.58664035, 24], [975060.667400586, 19], [975060.750206591, 14], [975060.832594538, 13], [975060.918013808, 5], [975060.99987433, 22], [975061.080888975, 13], [975061.161562822, 51], [975061.242943016, 15], [975061.322824439, 6], [975061.402952681, 8], [975061.483369148, 9], [975061.56441408, 16], [975061.644999787, 16], [975061.726231157, 9], [975061.80646965, 32], [975061.893945365, 18], [975061.977045462, 13], [975062.058660627, 11], [975062.138955874, 15], [975062.219930415, 8], [975062.300304858, 18], [975062.380951831, 25], [975062.454705954, 19], [975062.534906486, 8], [975062.615932576, 40], [975062.699199081, 16], [975062.77965744, 64], [975062.866088668, 6], [975062.951278505, 6], [975063.031902766, 11], [975063.114856572, 15], [975063.196244169, 17], [975063.276582092, 21], [975063.356953197, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-828e50acdd084a6a9d5a40f1", "runtime": {"accepted": 193, "cached": 30, "decode_s": 5.0463, "drafted": 930, "drafts": true, "min_rows": 16, "prefill_s": 0.1097, "rounds": 62, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975058.197956994, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.11238703108392656, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 193, "drafted": 930, "rounds": 62}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 50.534107316899856, "done": 975068.536021539, "finish_reason": "length", "first": 975063.488862353, "full_response_s": 5.159138308954425, "last": 975068.534959208, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975063.488862353, 3], [975063.570627579, 26], [975063.651289101, 15], [975063.731910066, 34], [975063.813171366, 21], [975063.899804752, 25], [975063.982757749, 14], [975064.063731245, 14], [975064.143964698, 18], [975064.224599364, 26], [975064.304914717, 13], [975064.385020737, 13], [975064.465228352, 13], [975064.545499419, 23], [975064.626287117, 32], [975064.709682667, 7], [975064.789692755, 23], [975064.875614118, 9], [975064.958831379, 13], [975065.038727271, 15], [975065.119597754, 19], [975065.200608358, 17], [975065.282081643, 23], [975065.36257752, 9], [975065.442592638, 17], [975065.523660183, 3], [975065.603880955, 21], [975065.685413085, 10], [975065.765380493, 24], [975065.849864157, 19], [975065.934224614, 14], [975066.015921716, 13], [975066.096758207, 5], [975066.177005575, 22], [975066.257340106, 13], [975066.337729291, 51], [975066.418565093, 15], [975066.499871384, 6], [975066.580096177, 8], [975066.661197646, 9], [975066.744161629, 16], [975066.825619609, 16], [975066.912105885, 9], [975066.994248907, 32], [975067.075456184, 18], [975067.156095266, 13], [975067.236915683, 11], [975067.31716736, 15], [975067.397371984, 8], [975067.477777829, 18], [975067.558398704, 25], [975067.631531987, 19], [975067.713231703, 8], [975067.795244908, 40], [975067.881833312, 16], [975067.965502135, 64], [975068.047155875, 6], [975068.127411558, 6], [975068.210243671, 11], [975068.29220714, 15], [975068.373455909, 17], [975068.454545341, 21], [975068.534959208, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-9c35ff31cbe94b81bc74c6e7", "runtime": {"accepted": 193, "cached": 30, "decode_s": 5.0458, "drafted": 930, "drafts": true, "min_rows": 16, "prefill_s": 0.1088, "rounds": 62, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975063.37688323, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.11197912297211587, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 193, "drafted": 930, "rounds": 62}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.08971466391959, "done": 975082.15877568, "finish_reason": "length", "first": 975068.782919399, "full_response_s": 13.596029818989336, "last": 975082.140898001, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975068.782919399, 3], [975068.925928483, 11], [975069.156072032, 30], [975069.326192158, 19], [975069.475076677, 21], [975069.65680627, 15], [975069.807155195, 19], [975069.967170991, 17], [975070.110690845, 6], [975070.260295387, 11], [975070.406452789, 5], [975070.589108571, 27], [975070.77595488, 12], [975070.967756039, 13], [975071.150475175, 5], [975071.300627059, 16], [975071.479207186, 5], [975071.660557318, 16], [975071.860933095, 7], [975072.010426958, 22], [975072.158802654, 10], [975072.340807182, 7], [975072.526936464, 23], [975072.677597373, 5], [975072.831216264, 9], [975073.011933093, 14], [975073.162699991, 20], [975073.30971274, 8], [975073.4581966, 12], [975073.608535407, 5], [975073.759871717, 14], [975073.920591999, 11], [975074.07194147, 7], [975074.249454023, 17], [975074.422215724, 3], [975074.604902323, 10], [975074.757393321, 11], [975074.951374343, 9], [975075.131940916, 10], [975075.317447611, 20], [975075.465766092, 14], [975075.653862994, 14], [975075.895488024, 13], [975076.04399009, 5], [975076.216201522, 14], [975076.443073439, 11], [975076.682136175, 32], [975076.875952715, 33], [975077.066939883, 11], [975077.248569212, 6], [975077.398194128, 8], [975077.547088728, 9], [975077.698943085, 13], [975077.856391616, 8], [975078.008882864, 20], [975078.158126945, 17], [975078.307799516, 20], [975078.458530867, 13], [975078.607443972, 2], [975078.760929571, 16], [975078.955943859, 6], [975079.104544237, 15], [975079.255217282, 8], [975079.439420859, 15], [975079.623855674, 16], [975079.859950785, 22], [975080.148753225, 9], [975080.292197628, 8], [975080.477126958, 25], [975080.632568033, 18], [975080.785655992, 13], [975080.977045831, 55], [975081.12896309, 11], [975081.317334967, 10], [975081.48984937, 11], [975081.641466548, 15], [975081.791798605, 17], [975081.95807755, 14], [975082.140898001, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4ff71f8c936d42ccbb103a75", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.358, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975068.562745861, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2201735379640013, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.08974541669328, "done": 975082.156770451, "finish_reason": "length", "first": 975068.783237111, "full_response_s": 13.591236553969793, "last": 975082.141194194, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975068.783237111, 3], [975068.92550404, 11], [975069.156498586, 30], [975069.327717554, 19], [975069.475013016, 21], [975069.657996082, 15], [975069.807940164, 19], [975069.966684616, 17], [975070.112513234, 6], [975070.259985098, 11], [975070.407050471, 5], [975070.588152555, 27], [975070.776948334, 12], [975070.970215564, 13], [975071.148691152, 5], [975071.298356005, 16], [975071.481148545, 5], [975071.663108983, 16], [975071.8617072, 7], [975072.010881432, 22], [975072.158364275, 10], [975072.341372897, 7], [975072.527504387, 23], [975072.677754261, 5], [975072.832536854, 9], [975073.01169656, 14], [975073.160742152, 20], [975073.308572925, 8], [975073.459744203, 12], [975073.60760923, 5], [975073.760109929, 14], [975073.922919787, 11], [975074.072571791, 7], [975074.250072808, 17], [975074.422653542, 3], [975074.605474198, 10], [975074.757562337, 11], [975074.948326351, 9], [975075.13641615, 10], [975075.317974001, 20], [975075.46780495, 14], [975075.653714041, 14], [975075.89574462, 13], [975076.043933741, 5], [975076.217887182, 14], [975076.445356078, 11], [975076.682232251, 32], [975076.87576082, 33], [975077.065335835, 11], [975077.249865596, 6], [975077.398360376, 8], [975077.548365032, 9], [975077.703069584, 13], [975077.856459148, 8], [975078.008151684, 20], [975078.158885531, 17], [975078.308549319, 20], [975078.458474246, 13], [975078.609560299, 2], [975078.762739481, 16], [975078.956981999, 6], [975079.105068691, 15], [975079.256019178, 8], [975079.440038573, 15], [975079.622990437, 16], [975079.861065562, 22], [975080.149878209, 9], [975080.293351603, 8], [975080.476987077, 25], [975080.633266559, 18], [975080.785288522, 13], [975080.977474642, 55], [975081.13049839, 11], [975081.316143234, 10], [975081.492136537, 11], [975081.641978731, 15], [975081.793679536, 17], [975081.958888838, 14], [975082.141194194, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-0dd8c757d5804aaa9c4b828e", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3583, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975068.565533897, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21770321403164417, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.089161776238488, "done": 975082.156991784, "finish_reason": "length", "first": 975068.783273989, "full_response_s": 13.586230100947432, "last": 975082.141639484, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975068.783273989, 3], [975068.925030848, 11], [975069.156260502, 30], [975069.327425552, 19], [975069.476096946, 21], [975069.658133563, 15], [975069.807836313, 19], [975069.9676454, 17], [975070.11199294, 6], [975070.260599979, 11], [975070.407166097, 5], [975070.589026143, 27], [975070.777126213, 12], [975070.969254684, 13], [975071.149338096, 5], [975071.298034501, 16], [975071.479939869, 5], [975071.660775963, 16], [975071.860326725, 7], [975072.01026551, 22], [975072.158684083, 10], [975072.342075726, 7], [975072.527972252, 23], [975072.67801188, 5], [975072.831741614, 9], [975073.011568919, 14], [975073.161221136, 20], [975073.310454719, 8], [975073.45943481, 12], [975073.608190865, 5], [975073.760727051, 14], [975073.92133481, 11], [975074.071366235, 7], [975074.249972173, 17], [975074.423471677, 3], [975074.604596578, 10], [975074.758077047, 11], [975074.950899375, 9], [975075.132211975, 10], [975075.319763864, 20], [975075.467382123, 14], [975075.65365742, 14], [975075.897555378, 13], [975076.04413653, 5], [975076.219945848, 14], [975076.446759048, 11], [975076.684838745, 32], [975076.875628859, 33], [975077.065531073, 11], [975077.250917304, 6], [975077.398292683, 8], [975077.547839107, 9], [975077.698584335, 13], [975077.8559042, 8], [975078.00997729, 20], [975078.160903287, 17], [975078.308872087, 20], [975078.457889603, 13], [975078.608124227, 2], [975078.760750012, 16], [975078.957193109, 6], [975079.106075202, 15], [975079.256128804, 8], [975079.43972958, 15], [975079.623281638, 16], [975079.860046956, 22], [975080.152709365, 9], [975080.293126622, 8], [975080.477645269, 25], [975080.630703885, 18], [975080.785515743, 13], [975080.977865742, 55], [975081.12933184, 11], [975081.316933915, 10], [975081.492990879, 11], [975081.63995843, 15], [975081.793799035, 17], [975081.956464061, 14], [975082.141639484, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-cb472dcbe2f642c89d0511de", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3582, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975068.570761683, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21251230593770742, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.090262940372945, "done": 975082.155302619, "finish_reason": "length", "first": 975068.783522584, "full_response_s": 13.588338633999228, "last": 975082.141117542, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975068.783522584, 3], [975068.924860296, 11], [975069.156137564, 30], [975069.326309864, 19], [975069.474911949, 21], [975069.656581561, 15], [975069.805510398, 19], [975069.965182035, 17], [975070.110825015, 6], [975070.259841089, 11], [975070.408201741, 5], [975070.588866599, 27], [975070.775848597, 12], [975070.969379494, 13], [975071.149214262, 5], [975071.29717992, 16], [975071.480298988, 5], [975071.660593637, 16], [975071.859794112, 7], [975072.009427904, 22], [975072.159231576, 10], [975072.34151385, 7], [975072.52913733, 23], [975072.677213168, 5], [975072.830788845, 9], [975073.012478505, 14], [975073.160676364, 20], [975073.308382902, 8], [975073.459655663, 12], [975073.607109383, 5], [975073.759415052, 14], [975073.921813458, 11], [975074.070829637, 7], [975074.25046914, 17], [975074.422303543, 3], [975074.60478844, 10], [975074.757697338, 11], [975074.949245281, 9], [975075.132029888, 10], [975075.318943505, 20], [975075.469742422, 14], [975075.653794197, 14], [975075.895095036, 13], [975076.044722661, 5], [975076.217380439, 14], [975076.443610277, 11], [975076.68405504, 32], [975076.875117892, 33], [975077.066140771, 11], [975077.248344839, 6], [975077.399270794, 8], [975077.54719997, 9], [975077.700612122, 13], [975077.855231161, 8], [975078.008251711, 20], [975078.158981814, 17], [975078.307968596, 20], [975078.45840081, 13], [975078.607175138, 2], [975078.761032238, 16], [975078.955857335, 6], [975079.105288441, 15], [975079.254615743, 8], [975079.439907267, 15], [975079.62360207, 16], [975079.861370202, 22], [975080.148455031, 9], [975080.293262647, 8], [975080.478139212, 25], [975080.631104585, 18], [975080.783598174, 13], [975080.97738799, 55], [975081.129247636, 11], [975081.315851504, 10], [975081.490022642, 11], [975081.639879026, 15], [975081.793344513, 17], [975081.957525353, 14], [975082.141117542, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-d0ddec6d1f97482581f39974", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3581, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975068.566963985, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21655859902966768, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.08727128938644, "done": 975082.15772226, "finish_reason": "length", "first": 975068.783033633, "full_response_s": 13.589416582020931, "last": 975082.142722199, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975068.783033633, 3], [975068.92561909, 11], [975069.155943494, 30], [975069.32662436, 19], [975069.476050004, 21], [975069.657427167, 15], [975069.805679477, 19], [975069.966525136, 17], [975070.111319758, 6], [975070.259896783, 11], [975070.406598237, 5], [975070.588539368, 27], [975070.780425264, 12], [975070.968083111, 13], [975071.148578854, 5], [975071.29728713, 16], [975071.47957072, 5], [975071.662632207, 16], [975071.860130655, 7], [975072.011301795, 22], [975072.159375745, 10], [975072.341653443, 7], [975072.527205314, 23], [975072.677963947, 5], [975072.832218102, 9], [975073.012325937, 14], [975073.160816469, 20], [975073.308752468, 8], [975073.45879953, 12], [975073.608724646, 5], [975073.759054638, 14], [975073.920981099, 11], [975074.071479989, 7], [975074.251644394, 17], [975074.422128832, 3], [975074.605107256, 10], [975074.758875279, 11], [975074.949054651, 9], [975075.133132473, 10], [975075.322249068, 20], [975075.467023373, 14], [975075.652736442, 14], [975075.8960623, 13], [975076.044683223, 5], [975076.217287132, 14], [975076.445094539, 11], [975076.68201031, 32], [975076.876867278, 33], [975077.065264958, 11], [975077.250526011, 6], [975077.398780131, 8], [975077.547281854, 9], [975077.698814755, 13], [975077.856687569, 8], [975078.009526704, 20], [975078.159446127, 17], [975078.308056319, 20], [975078.458086089, 13], [975078.610587577, 2], [975078.760853703, 16], [975078.960182945, 6], [975079.105692853, 15], [975079.25707711, 8], [975079.441315902, 15], [975079.623933366, 16], [975079.861583536, 22], [975080.152141489, 9], [975080.295530743, 8], [975080.478268374, 25], [975080.630542565, 18], [975080.785436131, 13], [975080.981580711, 55], [975081.130195781, 11], [975081.317497503, 10], [975081.491551366, 11], [975081.640354139, 15], [975081.791912856, 17], [975081.956069185, 14], [975082.142722199, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4bdf5b659db7461d87cf31ed", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3582, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975068.568305678, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21472795505542308, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.0872343270428, "done": 975082.157860221, "finish_reason": "length", "first": 975068.783474843, "full_response_s": 13.591449999948964, "last": 975082.14318928, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975068.783474843, 3], [975068.924920117, 11], [975069.156448429, 30], [975069.327234282, 19], [975069.475763315, 21], [975069.657467053, 15], [975069.80646019, 19], [975069.966307387, 17], [975070.111512548, 6], [975070.260665704, 11], [975070.407111812, 5], [975070.588953283, 27], [975070.776401434, 12], [975070.968482835, 13], [975071.150016574, 5], [975071.299611206, 16], [975071.479326284, 5], [975071.661143801, 16], [975071.861458701, 7], [975072.010202521, 22], [975072.159014739, 10], [975072.342785259, 7], [975072.527145125, 23], [975072.677801907, 5], [975072.831385247, 9], [975073.011473692, 14], [975073.162784163, 20], [975073.31039261, 8], [975073.457719088, 12], [975073.60860366, 5], [975073.75996888, 14], [975073.921496178, 11], [975074.072756229, 7], [975074.250655755, 17], [975074.422504941, 3], [975074.605699947, 10], [975074.758642235, 11], [975074.951674808, 9], [975075.13390429, 10], [975075.317808681, 20], [975075.466335183, 14], [975075.653271727, 14], [975075.897949742, 13], [975076.044049335, 5], [975076.216814531, 14], [975076.443980226, 11], [975076.682609048, 32], [975076.877237851, 33], [975077.066381831, 11], [975077.250407169, 6], [975077.401413152, 8], [975077.547551489, 9], [975077.699278908, 13], [975077.855721537, 8], [975078.008747638, 20], [975078.158738338, 17], [975078.308166842, 20], [975078.459190578, 13], [975078.608597163, 2], [975078.762138487, 16], [975078.956352655, 6], [975079.105154511, 15], [975079.254814566, 8], [975079.439627457, 15], [975079.624070399, 16], [975079.862551072, 22], [975080.150864736, 9], [975080.2935706, 8], [975080.475685158, 25], [975080.630967328, 18], [975080.784052839, 13], [975080.977958138, 55], [975081.130072523, 11], [975081.318155886, 10], [975081.491204311, 11], [975081.640748615, 15], [975081.793199432, 17], [975081.955229706, 14], [975082.14318928, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-077cdec2c54841159e9a9bbe", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3582, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975068.566410221, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2170646219747141, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.087242349204775, "done": 975082.156704998, "finish_reason": "length", "first": 975068.783345313, "full_response_s": 13.591334852972068, "last": 975082.143054135, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975068.783345313, 3], [975068.924618564, 11], [975069.156559239, 30], [975069.327172813, 19], [975069.475921755, 21], [975069.656676708, 15], [975069.80598287, 19], [975069.965407656, 17], [975070.11118994, 6], [975070.259759542, 11], [975070.406269438, 5], [975070.58821668, 27], [975070.776326077, 12], [975070.968829025, 13], [975071.14878422, 5], [975071.300234775, 16], [975071.479491092, 5], [975071.660149899, 16], [975071.859531981, 7], [975072.009286599, 22], [975072.159306804, 10], [975072.341580231, 7], [975072.527359819, 23], [975072.678220334, 5], [975072.832400109, 9], [975073.010801693, 14], [975073.16087557, 20], [975073.308805521, 8], [975073.458918756, 12], [975073.607823331, 5], [975073.761557921, 14], [975073.92020805, 11], [975074.07407042, 7], [975074.251282652, 17], [975074.422855756, 3], [975074.604717628, 10], [975074.759071366, 11], [975074.950466356, 9], [975075.13347804, 10], [975075.320531122, 20], [975075.466554804, 14], [975075.654157091, 14], [975075.895186919, 13], [975076.044387238, 5], [975076.217463667, 14], [975076.444292963, 11], [975076.681861165, 32], [975076.875346889, 33], [975077.066436884, 11], [975077.249953751, 6], [975077.399121506, 8], [975077.548032441, 9], [975077.698701225, 13], [975077.855143566, 8], [975078.008396504, 20], [975078.157915931, 17], [975078.309520215, 20], [975078.458908912, 13], [975078.608710757, 2], [975078.761423194, 16], [975078.95620719, 6], [975079.104819424, 15], [975079.255038026, 8], [975079.439125722, 15], [975079.622284296, 16], [975079.861434551, 22], [975080.149394713, 9], [975080.294575175, 8], [975080.475975639, 25], [975080.631391243, 18], [975080.78536743, 13], [975080.978747059, 55], [975081.130120921, 11], [975081.318748145, 10], [975081.490227767, 11], [975081.640192515, 15], [975081.793274004, 17], [975081.955641558, 14], [975082.143054135, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-6f77254b574e4201ade14f4b", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.358, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975068.565370145, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21797516802325845, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.09043036487751, "done": 975082.156518496, "finish_reason": "length", "first": 975068.783555543, "full_response_s": 13.591762415948324, "last": 975082.141033354, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975068.783555543, 3], [975068.925417948, 11], [975069.156389952, 30], [975069.326949736, 19], [975069.475661192, 21], [975069.657874888, 15], [975069.807213896, 19], [975069.965943949, 17], [975070.111252737, 6], [975070.261640023, 11], [975070.407229006, 5], [975070.588354929, 27], [975070.779927513, 12], [975070.968399975, 13], [975071.15022434, 5], [975071.296885118, 16], [975071.480129156, 5], [975071.660074527, 16], [975071.859295305, 7], [975072.009828364, 22], [975072.159442638, 10], [975072.341267495, 7], [975072.528333066, 23], [975072.679216444, 5], [975072.831545335, 9], [975073.012132315, 14], [975073.161045513, 20], [975073.308641657, 8], [975073.457910694, 12], [975073.607696425, 5], [975073.759122203, 14], [975073.923253162, 11], [975074.072123525, 7], [975074.251971273, 17], [975074.424036961, 3], [975074.604192486, 10], [975074.760093315, 11], [975074.950620605, 9], [975075.133827574, 10], [975075.318739675, 20], [975075.467677597, 14], [975075.652018686, 14], [975075.894654626, 13], [975076.04494385, 5], [975076.217828657, 14], [975076.44663211, 11], [975076.684739102, 32], [975076.878185084, 33], [975077.065400008, 11], [975077.251090751, 6], [975077.398834656, 8], [975077.548204496, 9], [975077.70042226, 13], [975077.855319957, 8], [975078.010309657, 20], [975078.158455696, 17], [975078.30824831, 20], [975078.459669419, 13], [975078.60817368, 2], [975078.762077066, 16], [975078.956024079, 6], [975079.106469118, 15], [975079.25554133, 8], [975079.440400699, 15], [975079.622859115, 16], [975079.860204772, 22], [975080.152287578, 9], [975080.29273125, 8], [975080.475854781, 25], [975080.630149481, 18], [975080.784990473, 13], [975080.979385139, 55], [975081.131311054, 11], [975081.317018487, 10], [975081.490148715, 11], [975081.642235102, 15], [975081.793102445, 17], [975081.955581881, 14], [975082.141033354, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-fd9b77b19c5c477d91bff72f", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.358, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975068.56475608, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21879946300759912, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.089141610177176, "done": 975082.157834911, "finish_reason": "length", "first": 975068.783188345, "full_response_s": 13.591744082048535, "last": 975082.141567952, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975068.783188345, 3], [975068.925311138, 11], [975069.155996403, 30], [975069.327010677, 19], [975069.475702358, 21], [975069.658210423, 15], [975069.805606409, 19], [975069.965862097, 17], [975070.112425015, 6], [975070.261465392, 11], [975070.4086246, 5], [975070.587948821, 27], [975070.776855747, 12], [975070.969714837, 13], [975071.149152857, 5], [975071.300784347, 16], [975071.479839202, 5], [975071.66255661, 16], [975071.860697779, 7], [975072.011484522, 22], [975072.158254441, 10], [975072.341094687, 7], [975072.527043786, 23], [975072.677520305, 5], [975072.830985187, 9], [975073.011373552, 14], [975073.160379882, 20], [975073.308508, 8], [975073.459186167, 12], [975073.609934842, 5], [975073.760663662, 14], [975073.922603482, 11], [975074.070320031, 7], [975074.251073462, 17], [975074.423143134, 3], [975074.605595712, 10], [975074.758807699, 11], [975074.949431672, 9], [975075.13419458, 10], [975075.318283314, 20], [975075.46721466, 14], [975075.652303232, 14], [975075.89678268, 13], [975076.042986572, 5], [975076.217169794, 14], [975076.444158521, 11], [975076.682382419, 32], [975076.876334712, 33], [975077.065766966, 11], [975077.249638007, 6], [975077.39935287, 8], [975077.547380553, 9], [975077.699700087, 13], [975077.855991156, 8], [975078.009903581, 20], [975078.159606247, 17], [975078.309402829, 20], [975078.458149238, 13], [975078.607348217, 2], [975078.762299631, 16], [975078.957098442, 6], [975079.10623961, 15], [975079.254678764, 8], [975079.439526022, 15], [975079.623450622, 16], [975079.860479302, 22], [975080.151280636, 9], [975080.293059617, 8], [975080.476717139, 25], [975080.631755113, 18], [975080.784416117, 13], [975080.977590796, 55], [975081.129696126, 11], [975081.31759185, 10], [975081.490835305, 11], [975081.640690202, 15], [975081.792983091, 17], [975081.95706576, 14], [975082.141567952, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-d108f0e0c55742e1bdfc1841", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3583, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975068.566090829, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21709751605521888, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.089899589656575, "done": 975082.152668893, "finish_reason": "length", "first": 975068.784020575, "full_response_s": 13.588375973980874, "last": 975082.141869777, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975068.784020575, 3], [975068.925246533, 11], [975069.156209609, 30], [975069.326048821, 19], [975069.476997733, 21], [975069.657183531, 15], [975069.806265336, 19], [975069.966219679, 17], [975070.111439768, 6], [975070.261285161, 11], [975070.406389032, 5], [975070.589930322, 27], [975070.778748916, 12], [975070.968575822, 13], [975071.15146495, 5], [975071.297231949, 16], [975071.480377688, 5], [975071.661738763, 16], [975071.860476478, 7], [975072.009764367, 22], [975072.159739471, 10], [975072.341433502, 7], [975072.527819364, 23], [975072.676952669, 5], [975072.832147305, 9], [975073.011127469, 14], [975073.161441685, 20], [975073.309651735, 8], [975073.45955714, 12], [975073.608255197, 5], [975073.759763307, 14], [975073.921060615, 11], [975074.071643005, 7], [975074.250761317, 17], [975074.423687762, 3], [975074.606087128, 10], [975074.757957069, 11], [975074.949682332, 9], [975075.132639041, 10], [975075.320410472, 20], [975075.466673407, 14], [975075.653939918, 14], [975075.896447593, 13], [975076.04463281, 5], [975076.218376518, 14], [975076.443187962, 11], [975076.687047867, 32], [975076.876759219, 33], [975077.066707511, 11], [975077.249579642, 6], [975077.399058053, 8], [975077.547783957, 9], [975077.699105253, 13], [975077.855814092, 8], [975078.0086291, 20], [975078.157800705, 17], [975078.309038927, 20], [975078.459433206, 13], [975078.607667465, 2], [975078.763346795, 16], [975078.956131434, 6], [975079.106177741, 15], [975079.257306522, 8], [975079.442379705, 15], [975079.625622882, 16], [975079.861268335, 22], [975080.151934156, 9], [975080.292589641, 8], [975080.477066641, 25], [975080.630624961, 18], [975080.785599499, 13], [975080.979088482, 55], [975081.130661598, 11], [975081.317748866, 10], [975081.490293156, 11], [975081.641230688, 15], [975081.792717392, 17], [975081.955483454, 14], [975082.141869777, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-9b1500eb7f2e4b81a3f46edd", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.358, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975068.564292919, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21972765598911792, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.085944723781303, "done": 975082.157314392, "finish_reason": "length", "first": 975068.78312926, "full_response_s": 13.587208373006433, "last": 975082.143746389, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975068.78312926, 3], [975068.924966819, 11], [975069.15685412, 30], [975069.326505486, 19], [975069.476687429, 21], [975069.657912502, 15], [975069.807544648, 19], [975069.967096915, 17], [975070.113032856, 6], [975070.261057029, 11], [975070.406725847, 5], [975070.588685744, 27], [975070.780222842, 12], [975070.969435507, 13], [975071.149073949, 5], [975071.299265991, 16], [975071.479618862, 5], [975071.660461963, 16], [975071.859427282, 7], [975072.009694419, 22], [975072.158946838, 10], [975072.342142955, 7], [975072.526787895, 23], [975072.678599243, 5], [975072.832346479, 9], [975073.011206601, 14], [975073.160092617, 20], [975073.308309674, 8], [975073.459072332, 12], [975073.606948831, 5], [975073.759636913, 14], [975073.92080498, 11], [975074.070990605, 7], [975074.249590864, 17], [975074.422351717, 3], [975074.604967743, 10], [975074.757765479, 11], [975074.950058777, 9], [975075.13319135, 10], [975075.317930003, 20], [975075.466056829, 14], [975075.653035403, 14], [975075.897887009, 13], [975076.043579774, 5], [975076.216324268, 14], [975076.444091741, 11], [975076.683565864, 32], [975076.878045315, 33], [975077.064983644, 11], [975077.25033986, 6], [975077.399667591, 8], [975077.547344315, 9], [975077.700950873, 13], [975077.854911897, 8], [975078.008023578, 20], [975078.157697574, 17], [975078.309112555, 20], [975078.458856067, 13], [975078.607577774, 2], [975078.760425772, 16], [975078.95568032, 6], [975079.104917611, 15], [975079.254348301, 8], [975079.439270243, 15], [975079.622465423, 16], [975079.863100421, 22], [975080.148898897, 9], [975080.293776846, 8], [975080.477954501, 25], [975080.630326256, 18], [975080.783977371, 13], [975080.978850382, 55], [975081.129875333, 11], [975081.316852847, 10], [975081.490765981, 11], [975081.639791655, 15], [975081.792771533, 17], [975081.955813101, 14], [975082.143746389, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-441ce3acb7ff49a6890e2261", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3581, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975068.570106019, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21302324091084301, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.09110824995693, "done": 975082.158722387, "finish_reason": "length", "first": 975068.784257316, "full_response_s": 13.587459002039395, "last": 975082.141260831, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975068.784257316, 3], [975068.925187912, 11], [975069.157122459, 30], [975069.327804621, 19], [975069.47522123, 21], [975069.65783793, 15], [975069.80638325, 19], [975069.967467249, 17], [975070.112670186, 6], [975070.260999015, 11], [975070.406822242, 5], [975070.589863013, 27], [975070.776125479, 12], [975070.969318041, 13], [975071.149461578, 5], [975071.300311523, 16], [975071.479665947, 5], [975071.662981469, 16], [975071.860381426, 7], [975072.010088591, 22], [975072.161802072, 10], [975072.342410702, 7], [975072.528611612, 23], [975072.679563035, 5], [975072.831685648, 9], [975073.012756395, 14], [975073.160502244, 20], [975073.308191312, 8], [975073.458837592, 12], [975073.60932012, 5], [975073.759187127, 14], [975073.921442212, 11], [975074.070540628, 7], [975074.249295375, 17], [975074.423422576, 3], [975074.604108634, 10], [975074.759459522, 11], [975074.951073766, 9], [975075.13250484, 10], [975075.318132777, 20], [975075.466452458, 14], [975075.652167526, 14], [975075.896685949, 13], [975076.045586522, 5], [975076.218192047, 14], [975076.444371823, 11], [975076.6830956, 32], [975076.876212846, 33], [975077.064875186, 11], [975077.249177198, 6], [975077.398499905, 8], [975077.548758405, 9], [975077.699907437, 13], [975077.857457547, 8], [975078.009182001, 20], [975078.160286966, 17], [975078.308615252, 20], [975078.459135733, 13], [975078.60825174, 2], [975078.760562133, 16], [975078.956282418, 6], [975079.10534871, 15], [975079.255849554, 8], [975079.439358207, 15], [975079.623348339, 16], [975079.85983719, 22], [975080.148659213, 9], [975080.2925167, 8], [975080.475347238, 25], [975080.629789786, 18], [975080.78326251, 13], [975080.977235213, 55], [975081.13041025, 11], [975081.315923885, 10], [975081.489638244, 11], [975081.639653949, 15], [975081.792579783, 17], [975081.956249704, 14], [975082.141260831, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-ec85c038eb6040d588e6a918", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3582, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975068.571263385, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21299393102526665, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.09089249581469, "done": 975082.156046871, "finish_reason": "length", "first": 975068.783625779, "full_response_s": 13.58917852898594, "last": 975082.140780247, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975068.783625779, 3], [975068.924765437, 11], [975069.156987394, 30], [975069.327319798, 19], [975069.475615962, 21], [975069.65687233, 15], [975069.806618486, 19], [975069.967867404, 17], [975070.113115812, 6], [975070.260372151, 11], [975070.407604395, 5], [975070.58809395, 27], [975070.775745914, 12], [975070.969927227, 13], [975071.149273155, 5], [975071.298560971, 16], [975071.479748887, 5], [975071.66041315, 16], [975071.859710164, 7], [975072.009584472, 22], [975072.158461343, 10], [975072.342187481, 7], [975072.528030265, 23], [975072.677663402, 5], [975072.832463258, 9], [975073.010675411, 14], [975073.159934929, 20], [975073.307917726, 8], [975073.457423807, 12], [975073.6094824, 5], [975073.759531174, 14], [975073.921395591, 11], [975074.07242199, 7], [975074.250285229, 17], [975074.424250934, 3], [975074.605747017, 10], [975074.758257198, 11], [975074.949547378, 9], [975075.131758749, 10], [975075.319647262, 20], [975075.46840908, 14], [975075.654847153, 14], [975075.895578676, 13], [975076.045445489, 5], [975076.218025719, 14], [975076.44463709, 11], [975076.682791615, 32], [975076.875434901, 33], [975077.064730105, 11], [975077.251482412, 6], [975077.401652916, 8], [975077.548266157, 9], [975077.698757046, 13], [975077.855484365, 8], [975078.009593709, 20], [975078.158803887, 17], [975078.310236051, 20], [975078.45956432, 13], [975078.608766179, 2], [975078.761538341, 16], [975078.95689282, 6], [975079.104990535, 15], [975079.255087544, 8], [975079.441654797, 15], [975079.622361236, 16], [975079.860647582, 22], [975080.152361862, 9], [975080.292113072, 8], [975080.475459745, 25], [975080.629975633, 18], [975080.783453541, 13], [975080.977159345, 55], [975081.129134713, 11], [975081.315307275, 10], [975081.489535034, 11], [975081.640588047, 15], [975081.792339906, 17], [975081.956168364, 14], [975082.140780247, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-3e4633d41f954ccb9176d225", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3581, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975068.566868342, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2167574369814247, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.089194036102846, "done": 975082.157176335, "finish_reason": "length", "first": 975068.782981716, "full_response_s": 13.59091858600732, "last": 975082.141324636, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975068.782981716, 3], [975068.925679359, 11], [975069.156603685, 30], [975069.327643525, 19], [975069.475361959, 21], [975069.656925224, 15], [975069.807390512, 19], [975069.967570571, 17], [975070.110899587, 6], [975070.261224188, 11], [975070.407699238, 5], [975070.588415502, 27], [975070.77675652, 12], [975070.96893894, 13], [975071.152517441, 5], [975071.299016932, 16], [975071.479880736, 5], [975071.66304689, 16], [975071.862577797, 7], [975072.010153564, 22], [975072.15948302, 10], [975072.343187463, 7], [975072.530636263, 23], [975072.677864336, 5], [975072.832264708, 9], [975073.011849129, 14], [975073.160561105, 20], [975073.308707382, 8], [975073.458436908, 12], [975073.609044982, 5], [975073.759704126, 14], [975073.920712857, 11], [975074.070200933, 7], [975074.249728777, 17], [975074.42353065, 3], [975074.605223587, 10], [975074.758528529, 11], [975074.950535921, 9], [975075.132356527, 10], [975075.317607379, 20], [975075.467920273, 14], [975075.652930624, 14], [975075.89707505, 13], [975076.044847967, 5], [975076.21969378, 14], [975076.444927667, 11], [975076.6838155, 32], [975076.875270573, 33], [975077.06451194, 11], [975077.250454495, 6], [975077.399184863, 8], [975077.548650826, 9], [975077.699538783, 13], [975077.856972467, 8], [975078.011403891, 20], [975078.158526861, 17], [975078.309296194, 20], [975078.458343276, 13], [975078.607501521, 2], [975078.762226787, 16], [975078.956616034, 6], [975079.111381099, 15], [975079.254937199, 8], [975079.439842503, 15], [975079.624418894, 16], [975079.863669081, 22], [975080.148591345, 9], [975080.29265127, 8], [975080.475525629, 25], [975080.63203566, 18], [975080.784144179, 13], [975080.979303783, 55], [975081.129608802, 11], [975081.31808157, 10], [975081.489947637, 11], [975081.641181842, 15], [975081.792647683, 17], [975081.955701779, 14], [975082.141324636, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-98c0c20b630343c88c22b15d", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3581, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975068.566257749, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21672396699432284, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.087630333703096, "done": 975082.158539868, "finish_reason": "length", "first": 975068.783419582, "full_response_s": 13.590793250012212, "last": 975082.142856848, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975068.783419582, 3], [975068.925367055, 11], [975069.155854811, 30], [975069.327373603, 19], [975069.475558829, 21], [975069.65702997, 15], [975069.80746046, 19], [975069.967269034, 17], [975070.112365738, 6], [975070.260220238, 11], [975070.407780466, 5], [975070.588478075, 27], [975070.777527665, 12], [975070.969107332, 13], [975071.148929748, 5], [975071.299304725, 16], [975071.480764836, 5], [975071.663395497, 16], [975071.859857341, 7], [975072.011364, 22], [975072.160024161, 10], [975072.343684126, 7], [975072.52881221, 23], [975072.678324441, 5], [975072.831484123, 9], [975073.011628596, 14], [975073.161345658, 20], [975073.310664693, 8], [975073.458334657, 12], [975073.60844746, 5], [975073.758912853, 14], [975073.920492356, 11], [975074.071424008, 7], [975074.250187378, 17], [975074.422775536, 3], [975074.604844358, 10], [975074.758727783, 11], [975074.948475416, 9], [975075.13294181, 10], [975075.317744573, 20], [975075.465964706, 14], [975075.652488294, 14], [975075.894891462, 13], [975076.043265182, 5], [975076.217947339, 14], [975076.444564197, 11], [975076.682307687, 32], [975076.875495362, 33], [975077.064630222, 11], [975077.248673463, 6], [975077.398645833, 8], [975077.547022443, 9], [975077.698404216, 13], [975077.855402577, 8], [975078.0094489, 20], [975078.160155164, 17], [975078.307896087, 20], [975078.45899206, 13], [975078.608485617, 2], [975078.76111025, 16], [975078.956442938, 6], [975079.106012357, 15], [975079.25621856, 8], [975079.440557091, 15], [975079.624301028, 16], [975079.860406522, 22], [975080.149656268, 9], [975080.296921475, 8], [975080.476237066, 25], [975080.630422043, 18], [975080.785095988, 13], [975080.982190201, 55], [975081.132334076, 11], [975081.3184404, 10], [975081.490709168, 11], [975081.640897376, 15], [975081.794729949, 17], [975081.955905193, 14], [975082.142856848, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-a93bafec77e940de964ddf99", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3581, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975068.567746618, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21567296399734914, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.09073665893171, "done": 975082.157806096, "finish_reason": "length", "first": 975068.784118491, "full_response_s": 13.595205796067603, "last": 975082.141381993, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975068.784118491, 3], [975068.924370465, 11], [975069.156729183, 30], [975069.32710968, 19], [975069.475477665, 21], [975069.657372257, 15], [975069.80582747, 19], [975069.966040472, 17], [975070.113413413, 6], [975070.260722549, 11], [975070.406530369, 5], [975070.5882953, 27], [975070.776243361, 12], [975070.969004281, 13], [975071.149403677, 5], [975071.297105139, 16], [975071.480215552, 5], [975071.660240582, 16], [975071.859641719, 7], [975072.011994224, 22], [975072.158581193, 10], [975072.341981011, 7], [975072.527277455, 23], [975072.677364729, 5], [975072.831065887, 9], [975073.012949858, 14], [975073.160933759, 20], [975073.309364741, 8], [975073.459352078, 12], [975073.609769378, 5], [975073.761125911, 14], [975073.92041052, 11], [975074.071546466, 7], [975074.250819507, 17], [975074.42306277, 3], [975074.605047115, 10], [975074.757838259, 11], [975074.949797974, 9], [975075.133321375, 10], [975075.31767104, 20], [975075.466134857, 14], [975075.651868741, 14], [975075.894817258, 13], [975076.043426438, 5], [975076.220057794, 14], [975076.443549688, 11], [975076.685766827, 32], [975076.875551199, 33], [975077.065927182, 11], [975077.249530076, 6], [975077.398421845, 8], [975077.547149973, 9], [975077.699342937, 13], [975077.855054242, 8], [975078.008317756, 20], [975078.158286393, 17], [975078.308390799, 20], [975078.459064489, 13], [975078.608063094, 2], [975078.761904179, 16], [975078.959139957, 6], [975079.105633976, 15], [975079.254477334, 8], [975079.440450169, 15], [975079.622664389, 16], [975079.860122568, 22], [975080.151531839, 9], [975080.292996756, 8], [975080.479053695, 25], [975080.6300739, 18], [975080.783886144, 13], [975080.977319817, 55], [975081.129404332, 11], [975081.315765844, 10], [975081.490435245, 11], [975081.642127827, 15], [975081.792493275, 17], [975081.955383827, 14], [975082.141381993, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4a2f896a43754a7f91087793", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.358, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975068.5626003, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.22151819104328752, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.127960809370162, "done": 975095.748120887, "finish_reason": "length", "first": 975082.400491023, "full_response_s": 13.565447231987491, "last": 975095.731760495, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975082.400491023, 3], [975082.536188515, 11], [975082.726718426, 30], [975082.915644264, 19], [975083.069443834, 21], [975083.245082843, 15], [975083.39376033, 19], [975083.544366298, 17], [975083.693140564, 6], [975083.842653036, 11], [975084.000940748, 5], [975084.181690942, 27], [975084.364289412, 12], [975084.549530201, 13], [975084.735577222, 5], [975084.888975404, 16], [975085.076307542, 5], [975085.258667493, 16], [975085.443932613, 7], [975085.591061475, 22], [975085.745116734, 10], [975085.933225595, 7], [975086.123826818, 23], [975086.269717303, 5], [975086.418568203, 9], [975086.593258045, 14], [975086.74874694, 20], [975086.909537149, 8], [975087.05699144, 12], [975087.206769808, 5], [975087.35590232, 14], [975087.506305331, 11], [975087.656114914, 7], [975087.843925008, 17], [975088.02654543, 3], [975088.207621319, 10], [975088.355542845, 11], [975088.540631242, 9], [975088.730321271, 10], [975088.926081186, 20], [975089.07250449, 14], [975089.262467766, 14], [975089.487960141, 13], [975089.637765872, 5], [975089.813210848, 14], [975090.050466216, 11], [975090.283967271, 32], [975090.471284945, 33], [975090.654529392, 11], [975090.844092975, 6], [975091.000763511, 8], [975091.148762022, 9], [975091.298616795, 13], [975091.449451504, 8], [975091.599716048, 20], [975091.749075901, 17], [975091.910305774, 20], [975092.06473675, 13], [975092.213927469, 2], [975092.364754556, 16], [975092.546891786, 6], [975092.702069333, 15], [975092.853470219, 8], [975093.044057739, 15], [975093.230457526, 16], [975093.46249889, 22], [975093.738770988, 9], [975093.895839116, 8], [975094.083380411, 25], [975094.236510431, 18], [975094.387349649, 13], [975094.568336398, 55], [975094.728733953, 11], [975094.926940532, 10], [975095.096401243, 11], [975095.248470572, 15], [975095.395285115, 17], [975095.546472678, 14], [975095.731760495, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-0ebcbde7844a401ab02cd83a", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3307, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975082.182673655, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2178173679858446, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.126932503895127, "done": 975095.750554002, "finish_reason": "length", "first": 975082.400863196, "full_response_s": 13.568055378040299, "last": 975095.732849386, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975082.400863196, 3], [975082.536549793, 11], [975082.72310974, 30], [975082.915562508, 19], [975083.066402, 21], [975083.245264146, 15], [975083.395688491, 19], [975083.547093012, 17], [975083.6933882, 6], [975083.843099398, 11], [975084.000887567, 5], [975084.181759626, 27], [975084.366633233, 12], [975084.549421358, 13], [975084.736378414, 5], [975084.890312618, 16], [975085.076626471, 5], [975085.258341669, 16], [975085.443085886, 7], [975085.591194221, 22], [975085.741259115, 10], [975085.933488862, 7], [975086.121642764, 23], [975086.26859011, 5], [975086.417806976, 9], [975086.590777686, 14], [975086.748311041, 20], [975086.909193454, 8], [975087.05792861, 12], [975087.204798481, 5], [975087.355503844, 14], [975087.504915335, 11], [975087.658101984, 7], [975087.843517252, 17], [975088.02630261, 3], [975088.205457985, 10], [975088.355078803, 11], [975088.540257068, 9], [975088.72944077, 10], [975088.924414532, 20], [975089.072609349, 14], [975089.262082873, 14], [975089.486250736, 13], [975089.638344275, 5], [975089.813093446, 14], [975090.051511941, 11], [975090.284394131, 32], [975090.469140457, 33], [975090.655368184, 11], [975090.841435824, 6], [975091.000168868, 8], [975091.151079717, 9], [975091.299316329, 13], [975091.449260745, 8], [975091.600475595, 20], [975091.750171191, 17], [975091.910506772, 20], [975092.063735791, 13], [975092.214168881, 2], [975092.363510536, 16], [975092.54724796, 6], [975092.701947147, 15], [975092.854203112, 8], [975093.043490359, 15], [975093.231463621, 16], [975093.461918038, 22], [975093.738504729, 9], [975093.895486157, 8], [975094.08543772, 25], [975094.23595281, 18], [975094.384863977, 13], [975094.56839342, 55], [975094.728292631, 11], [975094.926083789, 10], [975095.096960976, 11], [975095.246419007, 15], [975095.394489137, 17], [975095.545377019, 14], [975095.732849386, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-f375031bdde44a6fbb91816c", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3308, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975082.182498624, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21836457203608006, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.12856007031171, "done": 975095.74708321, "finish_reason": "length", "first": 975082.400687605, "full_response_s": 13.564803967019543, "last": 975095.731539434, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975082.400687605, 3], [975082.535974429, 11], [975082.72506102, 30], [975082.91546576, 19], [975083.067986642, 21], [975083.244656912, 15], [975083.394873251, 19], [975083.545010186, 17], [975083.693330586, 6], [975083.843560255, 11], [975084.001917804, 5], [975084.181016751, 27], [975084.365454283, 12], [975084.548794173, 13], [975084.735447356, 5], [975084.889902574, 16], [975085.076422385, 5], [975085.261786924, 16], [975085.442910663, 7], [975085.591648694, 22], [975085.741863902, 10], [975085.931506047, 7], [975086.121173875, 23], [975086.268486691, 5], [975086.421129261, 9], [975086.592207808, 14], [975086.749529029, 20], [975086.906442805, 8], [975087.057437882, 12], [975087.205744754, 5], [975087.35747074, 14], [975087.508163512, 11], [975087.654595836, 7], [975087.843460423, 17], [975088.026120731, 3], [975088.206100642, 10], [975088.355262842, 11], [975088.540940875, 9], [975088.731170509, 10], [975088.927211739, 20], [975089.075957234, 14], [975089.261408218, 14], [975089.48665438, 13], [975089.638210858, 5], [975089.812567775, 14], [975090.0500703, 11], [975090.282913419, 32], [975090.468524455, 33], [975090.654774565, 11], [975090.841242201, 6], [975090.998538676, 8], [975091.149163043, 9], [975091.298908221, 13], [975091.449498253, 8], [975091.599772925, 20], [975091.749278243, 17], [975091.910085881, 20], [975092.063907239, 13], [975092.212927246, 2], [975092.363445964, 16], [975092.54702002, 6], [975092.701585549, 15], [975092.853201065, 8], [975093.042530149, 15], [975093.229798742, 16], [975093.46113598, 22], [975093.740726813, 9], [975093.897116046, 8], [975094.087234032, 25], [975094.23689638, 18], [975094.385981683, 13], [975094.572244353, 55], [975094.730657412, 11], [975094.924610293, 10], [975095.096037581, 11], [975095.245239992, 15], [975095.395574365, 17], [975095.544505941, 14], [975095.731539434, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-7de0de0aa2eb40188a33c444", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3308, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975082.182279243, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21840836200863123, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.13114287523976, "done": 975095.748246001, "finish_reason": "length", "first": 975082.40256604, "full_response_s": 13.566534793935716, "last": 975095.731618134, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975082.40256604, 3], [975082.53734545, 11], [975082.723521448, 30], [975082.916157998, 19], [975083.06665218, 21], [975083.245017646, 15], [975083.394927712, 19], [975083.545324555, 17], [975083.693093542, 6], [975083.842743399, 11], [975084.00069732, 5], [975084.181848598, 27], [975084.36595693, 12], [975084.550401918, 13], [975084.734754158, 5], [975084.891824448, 16], [975085.0774064, 5], [975085.258810206, 16], [975085.443401327, 7], [975085.590777985, 22], [975085.743280872, 10], [975085.932914666, 7], [975086.122374633, 23], [975086.269767012, 5], [975086.421417215, 9], [975086.59230046, 14], [975086.749746907, 20], [975086.907373927, 8], [975087.056219845, 12], [975087.206310023, 5], [975087.356384361, 14], [975087.504623973, 11], [975087.655415668, 7], [975087.842988334, 17], [975088.026185767, 3], [975088.207266441, 10], [975088.355611753, 11], [975088.541242092, 9], [975088.728881821, 10], [975088.924963737, 20], [975089.073812315, 14], [975089.261925649, 14], [975089.487493635, 13], [975089.637224538, 5], [975089.812696489, 14], [975090.052789015, 11], [975090.285584681, 32], [975090.468922916, 33], [975090.656890701, 11], [975090.841754304, 6], [975090.9987818, 8], [975091.150243902, 9], [975091.300218973, 13], [975091.449145694, 8], [975091.598686626, 20], [975091.750871125, 17], [975091.911341164, 20], [975092.063457932, 13], [975092.214400998, 2], [975092.363857368, 16], [975092.547691763, 6], [975092.701091557, 15], [975092.85328858, 8], [975093.043016558, 15], [975093.230678651, 16], [975093.461992771, 22], [975093.738605684, 9], [975093.895052146, 8], [975094.082337566, 25], [975094.236597322, 18], [975094.38468373, 13], [975094.569029885, 55], [975094.729036963, 11], [975094.926868903, 10], [975095.095632304, 11], [975095.245996771, 15], [975095.396016887, 17], [975095.545274368, 14], [975095.731618134, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-1415f7ffda9f49cf892460ba", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3308, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975082.181711207, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.22085483302362263, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.127710752490433, "done": 975095.750060601, "finish_reason": "length", "first": 975082.4003853, "full_response_s": 13.56825304706581, "last": 975095.731829052, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975082.4003853, 3], [975082.536234001, 11], [975082.724665167, 30], [975082.917100336, 19], [975083.067123517, 21], [975083.246519188, 15], [975083.395154917, 19], [975083.544755223, 17], [975083.692745575, 6], [975083.84292547, 11], [975084.000444149, 5], [975084.182324318, 27], [975084.366304577, 12], [975084.548855258, 13], [975084.735627731, 5], [975084.889536912, 16], [975085.076943543, 5], [975085.25789889, 16], [975085.442741711, 7], [975085.591437505, 22], [975085.742846045, 10], [975085.932228988, 7], [975086.12369388, 23], [975086.269092997, 5], [975086.42071421, 9], [975086.592536176, 14], [975086.749110074, 20], [975086.907011321, 8], [975087.058531156, 12], [975087.206071378, 5], [975087.358882383, 14], [975087.505252886, 11], [975087.657875435, 7], [975087.844117446, 17], [975088.026023823, 3], [975088.205555324, 10], [975088.354935514, 11], [975088.540885038, 9], [975088.729712548, 10], [975088.924078804, 20], [975089.071914759, 14], [975089.260482375, 14], [975089.486569857, 13], [975089.637299239, 5], [975089.81284357, 14], [975090.050707181, 11], [975090.284881867, 32], [975090.468870422, 33], [975090.65548853, 11], [975090.841587256, 6], [975091.000248, 8], [975091.15012538, 9], [975091.30098004, 13], [975091.449201292, 8], [975091.598613142, 20], [975091.749449322, 17], [975091.909866516, 20], [975092.063398847, 13], [975092.214940844, 2], [975092.363345312, 16], [975092.547595592, 6], [975092.702301786, 15], [975092.853071215, 8], [975093.043103401, 15], [975093.231394664, 16], [975093.461588566, 22], [975093.739873942, 9], [975093.89591772, 8], [975094.084327421, 25], [975094.237657303, 18], [975094.385266566, 13], [975094.569869684, 55], [975094.728816493, 11], [975094.924448157, 10], [975095.096481383, 11], [975095.245036146, 15], [975095.398038261, 17], [975095.544300111, 14], [975095.731829052, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-94b598ae65144ef88798e44d", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3308, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975082.181807554, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21857774606905878, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.128467529111198, "done": 975095.746748842, "finish_reason": "length", "first": 975082.400208636, "full_response_s": 13.56488343491219, "last": 975095.731124958, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975082.400208636, 3], [975082.534369276, 11], [975082.722960115, 30], [975082.916076946, 19], [975083.066544553, 21], [975083.244450906, 15], [975083.393533717, 19], [975083.544904991, 17], [975083.692284862, 6], [975083.843398247, 11], [975084.000021337, 5], [975084.180420332, 27], [975084.365058718, 12], [975084.548136621, 13], [975084.734979507, 5], [975084.889132756, 16], [975085.076035268, 5], [975085.257519213, 16], [975085.442811692, 7], [975085.59067239, 22], [975085.741372342, 10], [975085.931293289, 7], [975086.121030922, 23], [975086.268103222, 5], [975086.418099986, 9], [975086.590537282, 14], [975086.747992945, 20], [975086.9071069, 8], [975087.055995136, 12], [975087.204574108, 5], [975087.355106151, 14], [975087.504315236, 11], [975087.655559037, 7], [975087.842330254, 17], [975088.025412269, 3], [975088.205210205, 10], [975088.355869309, 11], [975088.541112451, 9], [975088.729046981, 10], [975088.922852656, 20], [975089.072884744, 14], [975089.26164691, 14], [975089.485472822, 13], [975089.63759356, 5], [975089.813657178, 14], [975090.049885413, 11], [975090.282696917, 32], [975090.468420668, 33], [975090.655885662, 11], [975090.841990917, 6], [975090.999472502, 8], [975091.148582095, 9], [975091.29994649, 13], [975091.448767185, 8], [975091.600309507, 20], [975091.750957665, 17], [975091.909688812, 20], [975092.063313203, 13], [975092.213857696, 2], [975092.36454591, 16], [975092.546741121, 6], [975092.700940908, 15], [975092.852998722, 8], [975093.043357597, 15], [975093.231207986, 16], [975093.462085902, 22], [975093.738849064, 9], [975093.894873786, 8], [975094.082115976, 25], [975094.235697622, 18], [975094.384756847, 13], [975094.568212324, 55], [975094.728885962, 11], [975094.924323139, 10], [975095.09804422, 11], [975095.244870218, 15], [975095.394161745, 17], [975095.54540865, 14], [975095.731124958, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-41477559bd974c40b9c937d9", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3307, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975082.181865407, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2183432289166376, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.124514310336696, "done": 975095.75049554, "finish_reason": "length", "first": 975082.400783888, "full_response_s": 13.567962885950692, "last": 975095.734455837, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975082.400783888, 3], [975082.536495604, 11], [975082.724296321, 30], [975082.916253338, 19], [975083.06730682, 21], [975083.244555173, 15], [975083.394263473, 19], [975083.543740905, 17], [975083.694095061, 6], [975083.842831443, 11], [975084.000103925, 5], [975084.180898692, 27], [975084.367055996, 12], [975084.548922183, 13], [975084.734884104, 5], [975084.889587038, 16], [975085.076111264, 5], [975085.257681157, 16], [975085.441876937, 7], [975085.59052315, 22], [975085.741177663, 10], [975085.932093506, 7], [975086.121292046, 23], [975086.270406149, 5], [975086.422054448, 9], [975086.591616909, 14], [975086.748414572, 20], [975086.908453426, 8], [975087.056314673, 12], [975087.205247931, 5], [975087.356758807, 14], [975087.505480715, 11], [975087.655313993, 7], [975087.842497318, 17], [975088.027551253, 3], [975088.206718787, 10], [975088.35456518, 11], [975088.54037695, 9], [975088.729332903, 10], [975088.923915484, 20], [975089.071754191, 14], [975089.261116008, 14], [975089.48593152, 13], [975089.639422927, 5], [975089.812047609, 14], [975090.050766794, 11], [975090.283375876, 32], [975090.468596756, 33], [975090.654413814, 11], [975090.841086353, 6], [975090.999034283, 8], [975091.152386086, 9], [975091.299759587, 13], [975091.44886654, 8], [975091.598753775, 20], [975091.750327024, 17], [975091.908361709, 20], [975092.063198313, 13], [975092.213219983, 2], [975092.363643346, 16], [975092.547495628, 6], [975092.700805619, 15], [975092.853368352, 8], [975093.043626416, 15], [975093.231529826, 16], [975093.461411103, 22], [975093.741121754, 9], [975093.895687427, 8], [975094.083636911, 25], [975094.236427267, 18], [975094.384552296, 13], [975094.569987838, 55], [975094.727817326, 11], [975094.92385081, 10], [975095.095475912, 11], [975095.246905383, 15], [975095.39607858, 17], [975095.545223474, 14], [975095.734455837, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-c4d635f73f394ed2bf5442c7", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3307, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975082.182532654, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21825123392045498, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.12822609108265, "done": 975095.749538979, "finish_reason": "length", "first": 975082.401228618, "full_response_s": 13.567428192007355, "last": 975095.732313204, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975082.401228618, 3], [975082.536290078, 11], [975082.723846856, 30], [975082.916752929, 19], [975083.068704751, 21], [975083.244952881, 15], [975083.395088792, 19], [975083.545259054, 17], [975083.694392534, 6], [975083.842276782, 11], [975084.001682632, 5], [975084.182844981, 27], [975084.364853384, 12], [975084.550551159, 13], [975084.73528746, 5], [975084.888744439, 16], [975085.077185883, 5], [975085.259697602, 16], [975085.442849642, 7], [975085.590599194, 22], [975085.742361669, 10], [975085.932834622, 7], [975086.123994281, 23], [975086.270719909, 5], [975086.420025075, 9], [975086.590966205, 14], [975086.75262803, 20], [975086.907790067, 8], [975087.056608274, 12], [975087.206132911, 5], [975087.356141269, 14], [975087.505116669, 11], [975087.655464385, 7], [975087.843214803, 17], [975088.025532791, 3], [975088.205704245, 10], [975088.354652408, 11], [975088.540789842, 9], [975088.729238844, 10], [975088.923580556, 20], [975089.072092207, 14], [975089.260023725, 14], [975089.486462262, 13], [975089.637914024, 5], [975089.812164643, 14], [975090.052888386, 11], [975090.284727538, 32], [975090.46946113, 33], [975090.656059846, 11], [975090.841947943, 6], [975091.00169929, 8], [975091.148936046, 9], [975091.301959752, 13], [975091.448649975, 8], [975091.599183434, 20], [975091.749162472, 17], [975091.908946768, 20], [975092.063578199, 13], [975092.21341471, 2], [975092.363704015, 16], [975092.547183276, 6], [975092.701450851, 15], [975092.853824186, 8], [975093.042416939, 15], [975093.230387385, 16], [975093.461377328, 22], [975093.740102283, 9], [975093.896111678, 8], [975094.084016172, 25], [975094.236711685, 18], [975094.385121309, 13], [975094.570461863, 55], [975094.728388162, 11], [975094.924283381, 10], [975095.097939201, 11], [975095.24568861, 15], [975095.395044262, 17], [975095.545168853, 14], [975095.732313204, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-2dd243d218594f3e8e586b4c", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3307, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975082.182110787, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21911783097311854, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.127731847973163, "done": 975095.74959936, "finish_reason": "length", "first": 975082.400937753, "full_response_s": 13.567668020026758, "last": 975095.732366802, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975082.400937753, 3], [975082.535034988, 11], [975082.723366847, 30], [975082.917498652, 19], [975083.068131403, 21], [975083.244860166, 15], [975083.394041596, 19], [975083.544157316, 17], [975083.692347099, 6], [975083.842982491, 11], [975083.999804932, 5], [975084.183778615, 27], [975084.364774908, 12], [975084.548727232, 13], [975084.735503593, 5], [975084.889495282, 16], [975085.076494285, 5], [975085.259835052, 16], [975085.443023569, 7], [975085.590377749, 22], [975085.74202215, 10], [975085.932567003, 7], [975086.121374458, 23], [975086.270292762, 5], [975086.42050678, 9], [975086.591530002, 14], [975086.749676286, 20], [975086.906577358, 8], [975087.057303024, 12], [975087.206195388, 5], [975087.356065304, 14], [975087.50599245, 11], [975087.65414525, 7], [975087.843286463, 17], [975088.025173369, 3], [975088.20659305, 10], [975088.354476353, 11], [975088.540511696, 9], [975088.7298739, 10], [975088.923283915, 20], [975089.072976995, 14], [975089.260589506, 14], [975089.488932925, 13], [975089.638561785, 5], [975089.814138259, 14], [975090.050272386, 11], [975090.283560155, 32], [975090.468969458, 33], [975090.654692841, 11], [975090.843124814, 6], [975090.998939648, 8], [975091.148425687, 9], [975091.29854123, 13], [975091.44935802, 8], [975091.59836253, 20], [975091.750101019, 17], [975091.910875347, 20], [975092.0641974, 13], [975092.214711831, 2], [975092.363576949, 16], [975092.548168732, 6], [975092.701162194, 15], [975092.853530025, 8], [975093.044122632, 15], [975093.229600352, 16], [975093.46089076, 22], [975093.738292483, 9], [975093.895176028, 8], [975094.083565826, 25], [975094.238234491, 18], [975094.385088334, 13], [975094.568756474, 55], [975094.728139086, 11], [975094.925324978, 10], [975095.097160374, 11], [975095.248198761, 15], [975095.397721429, 17], [975095.545126999, 14], [975095.732366802, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-01732e2820e84406bf10b19a", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3307, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975082.18193134, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21900641301181167, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.126694524869624, "done": 975095.749789031, "finish_reason": "length", "first": 975082.40081907, "full_response_s": 13.567815852933563, "last": 975095.73297114, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975082.40081907, 3], [975082.534828742, 11], [975082.723989953, 30], [975082.91535575, 19], [975083.066967828, 21], [975083.246348717, 15], [975083.393951344, 19], [975083.545098006, 17], [975083.693038857, 6], [975083.8433035, 11], [975084.001155858, 5], [975084.183720986, 27], [975084.36445406, 12], [975084.550150538, 13], [975084.73504936, 5], [975084.889418854, 16], [975085.077812765, 5], [975085.257960407, 16], [975085.442542377, 7], [975085.591304039, 22], [975085.741780914, 10], [975085.931208078, 7], [975086.122558096, 23], [975086.268713816, 5], [975086.419892858, 9], [975086.591747431, 14], [975086.750657086, 20], [975086.906853521, 8], [975087.056155097, 12], [975087.205117985, 5], [975087.35845082, 14], [975087.504710993, 11], [975087.655070021, 7], [975087.843346812, 17], [975088.025855048, 3], [975088.206420402, 10], [975088.35797663, 11], [975088.54252403, 9], [975088.730026997, 10], [975088.922499729, 20], [975089.0731283, 14], [975089.261849668, 14], [975089.486406232, 13], [975089.637699747, 5], [975089.812488259, 14], [975090.050195174, 11], [975090.285871339, 32], [975090.469322592, 33], [975090.656702023, 11], [975090.841511244, 6], [975090.998673389, 8], [975091.148999243, 9], [975091.300404372, 13], [975091.449315446, 8], [975091.59889956, 20], [975091.749560757, 17], [975091.908681949, 20], [975092.064039808, 13], [975092.212765925, 2], [975092.364437803, 16], [975092.547290838, 6], [975092.701667113, 15], [975092.853770269, 8], [975093.042817815, 15], [975093.230782806, 16], [975093.46307995, 22], [975093.741512455, 9], [975093.895347107, 8], [975094.083437144, 25], [975094.237076579, 18], [975094.386213912, 13], [975094.5692073, 55], [975094.729805981, 11], [975094.924524057, 10], [975095.095949105, 11], [975095.246290565, 15], [975095.395728341, 17], [975095.54532371, 14], [975095.73297114, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-f3d4f71177414bbe849b1419", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3308, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975082.181973178, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21884589199908078, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.127924263198686, "done": 975095.748437768, "finish_reason": "length", "first": 975082.400170382, "full_response_s": 13.565621223999187, "last": 975095.731465325, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975082.400170382, 3], [975082.535154566, 11], [975082.723440812, 30], [975082.916958119, 19], [975083.066789037, 21], [975083.245751962, 15], [975083.394825189, 19], [975083.546123059, 17], [975083.693523265, 6], [975083.845203166, 11], [975084.002111651, 5], [975084.18111665, 27], [975084.366573604, 12], [975084.548986227, 13], [975084.735213144, 5], [975084.89014925, 16], [975085.075583674, 5], [975085.258611703, 16], [975085.443525833, 7], [975085.591360677, 22], [975085.741691382, 10], [975085.931368502, 7], [975086.124254541, 23], [975086.269168337, 5], [975086.41948067, 9], [975086.592642667, 14], [975086.748907156, 20], [975086.906923293, 8], [975087.056534342, 12], [975087.205500094, 5], [975087.356701001, 14], [975087.504979779, 11], [975087.657799855, 7], [975087.844180899, 17], [975088.025933204, 3], [975088.209654084, 10], [975088.355732547, 11], [975088.54099484, 9], [975088.732772271, 10], [975088.924737124, 20], [975089.073543768, 14], [975089.261555859, 14], [975089.488103142, 13], [975089.64213913, 5], [975089.813719079, 14], [975090.053598896, 11], [975090.285178124, 32], [975090.46874862, 33], [975090.656413989, 11], [975090.842151037, 6], [975091.000494612, 8], [975091.149420662, 9], [975091.299043526, 13], [975091.452218857, 8], [975091.599547512, 20], [975091.750239908, 17], [975091.908770777, 20], [975092.063666674, 13], [975092.213785044, 2], [975092.364980929, 16], [975092.548262231, 6], [975092.701754389, 15], [975092.85370472, 8], [975093.043837382, 15], [975093.231054585, 16], [975093.465038607, 22], [975093.739304258, 9], [975093.89496367, 8], [975094.082454584, 25], [975094.238524077, 18], [975094.385015906, 13], [975094.572981677, 55], [975094.733256902, 11], [975094.924192921, 10], [975095.098261377, 11], [975095.245545481, 15], [975095.395930491, 17], [975095.544736906, 14], [975095.731465325, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b6444401cba145c8a6b702f7", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3308, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975082.182816544, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21735383803024888, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.128971154823216, "done": 975095.747266945, "finish_reason": "length", "first": 975082.401132287, "full_response_s": 13.564664869918488, "last": 975095.731697634, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975082.401132287, 3], [975082.53571841, 11], [975082.723778859, 30], [975082.916422625, 19], [975083.068264196, 21], [975083.245500119, 15], [975083.394758649, 19], [975083.544966636, 17], [975083.692434359, 6], [975083.843057608, 11], [975084.000755157, 5], [975084.181312208, 27], [975084.364387567, 12], [975084.549891863, 13], [975084.735693536, 5], [975084.889974043, 16], [975085.0754668, 5], [975085.258167405, 16], [975085.443890279, 7], [975085.590891996, 22], [975085.742152048, 10], [975085.931055029, 7], [975086.122272638, 23], [975086.270231725, 5], [975086.419263577, 9], [975086.591100823, 14], [975086.752849571, 20], [975086.906774069, 8], [975087.056672383, 12], [975087.205686837, 5], [975087.356336091, 14], [975087.507115131, 11], [975087.655237916, 7], [975087.843130231, 17], [975088.02699416, 3], [975088.20563316, 10], [975088.355196781, 11], [975088.542690965, 9], [975088.729570219, 10], [975088.924322328, 20], [975089.072682418, 14], [975089.260904211, 14], [975089.486332908, 13], [975089.637511468, 5], [975089.811801125, 14], [975090.050626944, 11], [975090.286531739, 32], [975090.470179191, 33], [975090.654885375, 11], [975090.84188105, 6], [975090.999102536, 8], [975091.149554704, 9], [975091.298789906, 13], [975091.45276515, 8], [975091.600129548, 20], [975091.751307744, 17], [975091.909993485, 20], [975092.06457871, 13], [975092.214826945, 2], [975092.363751357, 16], [975092.546639398, 6], [975092.701888894, 15], [975092.854279972, 8], [975093.043297648, 15], [975093.229989325, 16], [975093.46170552, 22], [975093.739981761, 9], [975093.896423423, 8], [975094.083907042, 25], [975094.237179806, 18], [975094.385184602, 13], [975094.573114215, 55], [975094.730898841, 11], [975094.92735216, 10], [975095.09857789, 11], [975095.246809292, 15], [975095.395238445, 17], [975095.544557027, 14], [975095.731697634, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-a853dda6c81b46078bbaa03f", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3308, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975082.182602075, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.218530211946927, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.128140578064226, "done": 975095.750344444, "finish_reason": "length", "first": 975082.400738274, "full_response_s": 13.567987972986884, "last": 975095.731882457, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975082.400738274, 3], [975082.535801286, 11], [975082.724240484, 30], [975082.916885498, 19], [975083.06720972, 21], [975083.245317647, 15], [975083.394424969, 19], [975083.544867249, 17], [975083.693791092, 6], [975083.843429221, 11], [975084.000375224, 5], [975084.182583378, 27], [975084.364955459, 12], [975084.549261334, 13], [975084.736044927, 5], [975084.890023737, 16], [975085.077543898, 5], [975085.258266536, 16], [975085.442038674, 7], [975085.592213851, 22], [975085.741572396, 10], [975085.934678819, 7], [975086.122653131, 23], [975086.27120307, 5], [975086.419158878, 9], [975086.591808372, 14], [975086.75005774, 20], [975086.906696888, 8], [975087.056785354, 12], [975087.206886059, 5], [975087.357086183, 14], [975087.505185513, 11], [975087.657529468, 7], [975087.842923281, 17], [975088.025682736, 3], [975088.206281305, 10], [975088.355341014, 11], [975088.541726133, 9], [975088.729524174, 10], [975088.923706182, 20], [975089.075149001, 14], [975089.262164069, 14], [975089.488156099, 13], [975089.638934215, 5], [975089.813357385, 14], [975090.050390348, 11], [975090.28449739, 32], [975090.468816137, 33], [975090.655294027, 11], [975090.843039074, 6], [975090.998855908, 8], [975091.15058227, 9], [975091.300325912, 13], [975091.451534714, 8], [975091.600628324, 20], [975091.749801657, 17], [975091.909121528, 20], [975092.0637895, 13], [975092.213117044, 2], [975092.364370815, 16], [975092.5480784, 6], [975092.703101795, 15], [975092.85408651, 8], [975093.043162583, 15], [975093.230307229, 16], [975093.462693617, 22], [975093.738434364, 9], [975093.896021107, 8], [975094.0852712, 25], [975094.236069668, 18], [975094.385360561, 13], [975094.569270481, 55], [975094.72852382, 11], [975094.926558087, 10], [975095.097072426, 11], [975095.247128973, 15], [975095.394577837, 17], [975095.546820069, 14], [975095.731882457, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-3db20314e3df4aa89da211ca", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3308, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975082.182356471, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21838180301710963, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.130949846874564, "done": 975095.74617119, "finish_reason": "length", "first": 975082.402029507, "full_response_s": 13.564122064039111, "last": 975095.731216089, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975082.402029507, 3], [975082.534449944, 11], [975082.723176361, 30], [975082.917445663, 19], [975083.067762093, 21], [975083.24717218, 15], [975083.393475512, 19], [975083.544053161, 17], [975083.692200226, 6], [975083.843731127, 11], [975083.999925086, 5], [975084.181253491, 27], [975084.364211448, 12], [975084.548024915, 13], [975084.73536056, 5], [975084.888883552, 16], [975085.075678357, 5], [975085.258108384, 16], [975085.442656899, 7], [975085.591743586, 22], [975085.743362084, 10], [975085.930889709, 7], [975086.121842819, 23], [975086.270481969, 5], [975086.420221546, 9], [975086.591334171, 14], [975086.7485785, 20], [975086.908062054, 8], [975087.055855383, 12], [975087.205816527, 5], [975087.355965773, 14], [975087.50574691, 11], [975087.654909309, 7], [975087.842604016, 17], [975088.025329217, 3], [975088.205320456, 10], [975088.355409363, 11], [975088.541309305, 9], [975088.730597257, 10], [975088.924655272, 20], [975089.072354818, 14], [975089.261992189, 14], [975089.485696075, 13], [975089.637089297, 5], [975089.812629868, 14], [975090.051666174, 11], [975090.284564826, 32], [975090.4682677, 33], [975090.65597417, 11], [975090.841342932, 6], [975091.000917312, 8], [975091.149729463, 9], [975091.298448979, 13], [975091.449066994, 8], [975091.598442302, 20], [975091.749503784, 17], [975091.908541892, 20], [975092.066712046, 13], [975092.214479618, 2], [975092.364138618, 16], [975092.546488925, 6], [975092.701494673, 15], [975092.854652914, 8], [975093.042773017, 15], [975093.229867155, 16], [975093.460973924, 22], [975093.739555126, 9], [975093.89475552, 8], [975094.08438689, 25], [975094.238368853, 18], [975094.384821483, 13], [975094.571118311, 55], [975094.730043378, 11], [975094.923723744, 10], [975095.099388427, 11], [975095.245303701, 15], [975095.394913901, 17], [975095.544870708, 14], [975095.731216089, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-a666aea8cf9545ee80d33fe1", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3307, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975082.182049126, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21998038096353412, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.128497396586372, "done": 975095.748602048, "finish_reason": "length", "first": 975082.401178445, "full_response_s": 13.566170140984468, "last": 975095.732073952, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975082.401178445, 3], [975082.536609774, 11], [975082.723915236, 30], [975082.91819265, 19], [975083.068079294, 21], [975083.245171271, 15], [975083.394501925, 19], [975083.544822499, 17], [975083.694963306, 6], [975083.843344618, 11], [975084.000619212, 5], [975084.182071755, 27], [975084.365609443, 12], [975084.548632229, 13], [975084.73687151, 5], [975084.889324763, 16], [975085.079246838, 5], [975085.258512172, 16], [975085.443840697, 7], [975085.590997622, 22], [975085.742110674, 10], [975085.931648552, 7], [975086.12144775, 23], [975086.268832962, 5], [975086.420622102, 9], [975086.593876735, 14], [975086.749605218, 20], [975086.907486978, 8], [975087.057670142, 12], [975087.206022661, 5], [975087.355768503, 14], [975087.506917365, 11], [975087.655846271, 7], [975087.843597072, 17], [975088.025606852, 3], [975088.206534476, 10], [975088.358239545, 11], [975088.541183231, 9], [975088.729944105, 10], [975088.923160209, 20], [975089.075810489, 14], [975089.264994635, 14], [975089.489185889, 13], [975089.639500363, 5], [975089.8134661, 14], [975090.051263057, 11], [975090.283471472, 32], [975090.469885141, 33], [975090.655725926, 11], [975090.842083712, 6], [975090.99922717, 8], [975091.148883488, 9], [975091.298969674, 13], [975091.449679204, 8], [975091.599446509, 20], [975091.750706605, 17], [975091.911028043, 20], [975092.064485626, 13], [975092.21510706, 2], [975092.364068589, 16], [975092.547828252, 6], [975092.702181648, 15], [975092.854435341, 8], [975093.043050396, 15], [975093.23007452, 16], [975093.461021874, 22], [975093.740221717, 9], [975093.895407376, 8], [975094.083518709, 25], [975094.237806496, 18], [975094.386074607, 13], [975094.571218963, 55], [975094.733733487, 11], [975094.927710127, 10], [975095.096872852, 11], [975095.246503147, 15], [975095.396956746, 17], [975095.546115415, 14], [975095.732073952, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-957b1f0714b8416abc2870a1", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3308, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975082.182431907, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2187465379247442, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.12734735199318, "done": 975095.743911619, "finish_reason": "length", "first": 975082.400440641, "full_response_s": 13.562280391925015, "last": 975095.732137677, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975082.400440641, 3], [975082.535317294, 11], [975082.723255045, 30], [975082.915219564, 19], [975083.067669314, 21], [975083.244905172, 15], [975083.393382412, 19], [975083.543887377, 17], [975083.692543825, 6], [975083.842542497, 11], [975084.000828066, 5], [975084.18323893, 27], [975084.366776698, 12], [975084.54824252, 13], [975084.735128636, 5], [975084.89137975, 16], [975085.075876635, 5], [975085.259060561, 16], [975085.443597829, 7], [975085.59238589, 22], [975085.741498992, 10], [975085.93143805, 7], [975086.125676519, 23], [975086.269242046, 5], [975086.420913352, 9], [975086.591460885, 14], [975086.74899072, 20], [975086.907212975, 8], [975087.056393581, 12], [975087.206511229, 5], [975087.356272302, 14], [975087.506236086, 11], [975087.65471927, 7], [975087.843840596, 17], [975088.025758812, 3], [975088.207405538, 10], [975088.354210446, 11], [975088.540716614, 9], [975088.729794608, 10], [975088.926183741, 20], [975089.071635429, 14], [975089.261769288, 14], [975089.486159589, 13], [975089.639701441, 5], [975089.812769206, 14], [975090.050546788, 11], [975090.284318902, 32], [975090.469396093, 33], [975090.657518351, 11], [975090.842693571, 6], [975090.999827733, 8], [975091.150518913, 9], [975091.301471632, 13], [975091.450487869, 8], [975091.59963234, 20], [975091.75212652, 17], [975091.909350509, 20], [975092.064663298, 13], [975092.21422555, 2], [975092.363923524, 16], [975092.546823677, 6], [975092.701835041, 15], [975092.853597141, 8], [975093.043967919, 15], [975093.233052872, 16], [975093.461642228, 22], [975093.73893762, 9], [975093.895273111, 8], [975094.082608577, 25], [975094.238105793, 18], [975094.384916039, 13], [975094.568450185, 55], [975094.728630758, 11], [975094.925081998, 10], [975095.099256593, 11], [975095.245387585, 15], [975095.394642602, 17], [975095.546037035, 14], [975095.732137677, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b730b61f5dba48f4b776a92b", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3307, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.1895, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975082.181631227, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21880941395647824, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.09255912257571, "done": 975109.404212359, "finish_reason": "length", "first": 975096.034273982, "full_response_s": 13.620092349941842, "last": 975109.390262478, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975096.034273982, 3], [975096.173843476, 11], [975096.35354076, 30], [975096.537552235, 19], [975096.687157356, 21], [975096.883307449, 15], [975097.030817626, 19], [975097.179686361, 17], [975097.329619476, 6], [975097.476680827, 11], [975097.624996324, 5], [975097.810314372, 27], [975098.005265584, 12], [975098.185787811, 13], [975098.371251623, 5], [975098.521611848, 16], [975098.707182328, 5], [975098.897713902, 16], [975099.085827599, 7], [975099.233531498, 22], [975099.383785306, 10], [975099.565161487, 7], [975099.74793061, 23], [975099.908169351, 5], [975100.061481709, 9], [975100.230135362, 14], [975100.381569075, 20], [975100.532696115, 8], [975100.680478307, 12], [975100.829937812, 5], [975100.993092619, 14], [975101.141875013, 11], [975101.288882612, 7], [975101.472150438, 17], [975101.64689813, 3], [975101.828716571, 10], [975101.988104562, 11], [975102.171182809, 9], [975102.355650957, 10], [975102.540223405, 20], [975102.695666945, 14], [975102.884463147, 14], [975103.118101817, 13], [975103.269923333, 5], [975103.446943178, 14], [975103.673385969, 11], [975103.914923596, 32], [975104.109889394, 33], [975104.300913893, 11], [975104.484322836, 6], [975104.630715485, 8], [975104.783186371, 9], [975104.943592566, 13], [975105.09162529, 8], [975105.242227667, 20], [975105.397243994, 17], [975105.545460821, 20], [975105.697702895, 13], [975105.851583183, 2], [975106.009628351, 16], [975106.193018214, 6], [975106.342582474, 15], [975106.494402179, 8], [975106.684879928, 15], [975106.880673109, 16], [975107.115145479, 22], [975107.391549165, 9], [975107.543669729, 8], [975107.727447218, 25], [975107.887322202, 18], [975108.040952848, 13], [975108.226261107, 55], [975108.379935623, 11], [975108.567438691, 10], [975108.744325927, 11], [975108.904073392, 15], [975109.055309537, 17], [975109.205579921, 14], [975109.390262478, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-e9363485b45d4228b6ec1c3c", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3557, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.2035, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975095.784120009, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2501539730001241, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.09263077710508, "done": 975109.407582343, "finish_reason": "length", "first": 975096.034493811, "full_response_s": 13.621893369941972, "last": 975109.390432182, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975096.034493811, 3], [975096.171904674, 11], [975096.353638067, 30], [975096.539249128, 19], [975096.688472189, 21], [975096.880912845, 15], [975097.034248676, 19], [975097.180336857, 17], [975097.331555847, 6], [975097.47698686, 11], [975097.625696931, 5], [975097.810450158, 27], [975098.004120519, 12], [975098.186109171, 13], [975098.370172043, 5], [975098.521111872, 16], [975098.705461419, 5], [975098.897115739, 16], [975099.086470417, 7], [975099.235379041, 22], [975099.383533878, 10], [975099.56469631, 7], [975099.74950423, 23], [975099.911452809, 5], [975100.06379371, 9], [975100.230836657, 14], [975100.381136904, 20], [975100.531880714, 8], [975100.679723527, 12], [975100.831368543, 5], [975100.992464122, 14], [975101.14034899, 11], [975101.288811016, 7], [975101.47203198, 17], [975101.644572993, 3], [975101.82772817, 10], [975101.989094418, 11], [975102.17195794, 9], [975102.358388026, 10], [975102.539808241, 20], [975102.697250805, 14], [975102.885712799, 14], [975103.116022013, 13], [975103.270721231, 5], [975103.447899756, 14], [975103.671201385, 11], [975103.914523263, 32], [975104.106643629, 33], [975104.302502665, 11], [975104.483885929, 6], [975104.630500311, 8], [975104.785826085, 9], [975104.940620564, 13], [975105.091695495, 8], [975105.243366941, 20], [975105.398548827, 17], [975105.545860417, 20], [975105.697348896, 13], [975105.849991627, 2], [975106.011346365, 16], [975106.192113153, 6], [975106.343389844, 15], [975106.495086482, 8], [975106.685057728, 15], [975106.877997252, 16], [975107.119255828, 22], [975107.39144653, 9], [975107.549417312, 8], [975107.729123858, 25], [975107.886482066, 18], [975108.040746218, 13], [975108.22415756, 55], [975108.379664724, 11], [975108.566819168, 10], [975108.744711812, 11], [975108.90452777, 15], [975109.055406797, 17], [975109.205509012, 14], [975109.390432182, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-dd898855282445e1b4c3ec23", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3556, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.2035, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975095.785688973, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.24880483793094754, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.09038864948258, "done": 975109.405871832, "finish_reason": "length", "first": 975096.033902272, "full_response_s": 13.618814781075343, "last": 975109.391409271, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975096.033902272, 3], [975096.173018316, 11], [975096.353402894, 30], [975096.538249705, 19], [975096.687890153, 21], [975096.88237663, 15], [975097.03130965, 19], [975097.182997433, 17], [975097.32996018, 6], [975097.477152036, 11], [975097.625319525, 5], [975097.81127743, 27], [975098.004171028, 12], [975098.186236013, 13], [975098.370403744, 5], [975098.520867724, 16], [975098.706756412, 5], [975098.898861415, 16], [975099.084740308, 7], [975099.233737808, 22], [975099.383236724, 10], [975099.565446817, 7], [975099.748522069, 23], [975099.908800089, 5], [975100.063068881, 9], [975100.232137042, 14], [975100.380581203, 20], [975100.530863387, 8], [975100.678743814, 12], [975100.830494873, 5], [975100.992819481, 14], [975101.140719101, 11], [975101.289112633, 7], [975101.47273297, 17], [975101.64556389, 3], [975101.83097547, 10], [975101.988523358, 11], [975102.172789196, 9], [975102.355496485, 10], [975102.54129793, 20], [975102.69527642, 14], [975102.884823946, 14], [975103.115652399, 13], [975103.272055279, 5], [975103.449098595, 14], [975103.676511483, 11], [975103.915793266, 32], [975104.106558465, 33], [975104.300064925, 11], [975104.485045089, 6], [975104.632081803, 8], [975104.786592464, 9], [975104.941505162, 13], [975105.093612971, 8], [975105.243472424, 20], [975105.397996022, 17], [975105.545796725, 20], [975105.698085293, 13], [975105.850866193, 2], [975106.011190308, 16], [975106.193134624, 6], [975106.341672886, 15], [975106.495781313, 8], [975106.686669875, 15], [975106.87825828, 16], [975107.115944753, 22], [975107.391917244, 9], [975107.542626003, 8], [975107.727322168, 25], [975107.885706103, 18], [975108.040315166, 13], [975108.225442378, 55], [975108.380950599, 11], [975108.568966234, 10], [975108.744607433, 11], [975108.903982436, 15], [975109.054633473, 17], [975109.205985117, 14], [975109.391409271, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-2816c90395634b728917617a", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3557, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.2035, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975095.787057051, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.24684522103052586, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.092730521364988, "done": 975109.407138988, "finish_reason": "length", "first": 975096.034337147, "full_response_s": 13.620228714076802, "last": 975109.390205744, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975096.034337147, 3], [975096.174166965, 11], [975096.352608277, 30], [975096.539679444, 19], [975096.687572408, 21], [975096.881038887, 15], [975097.032092892, 19], [975097.180708391, 17], [975097.330437309, 6], [975097.477225184, 11], [975097.625987077, 5], [975097.809443614, 27], [975098.005487541, 12], [975098.185599628, 13], [975098.369757855, 5], [975098.52374189, 16], [975098.705166697, 5], [975098.896960322, 16], [975099.084642777, 7], [975099.233933495, 22], [975099.383279298, 10], [975099.567069667, 7], [975099.748410171, 23], [975099.909175111, 5], [975100.061219914, 9], [975100.231714471, 14], [975100.383184853, 20], [975100.531461102, 8], [975100.679823362, 12], [975100.830621011, 5], [975100.992284418, 14], [975101.141409228, 11], [975101.288489831, 7], [975101.475113144, 17], [975101.645365675, 3], [975101.82748967, 10], [975101.987904027, 11], [975102.172270565, 9], [975102.356229218, 10], [975102.541920828, 20], [975102.695586869, 14], [975102.884879927, 14], [975103.115168726, 13], [975103.272281428, 5], [975103.448261339, 14], [975103.671593895, 11], [975103.91486675, 32], [975104.110116983, 33], [975104.300538199, 11], [975104.48554049, 6], [975104.631200661, 8], [975104.783719945, 9], [975104.941357329, 13], [975105.092617835, 8], [975105.243418266, 20], [975105.398473471, 17], [975105.545232352, 20], [975105.697061038, 13], [975105.852356634, 2], [975106.011505509, 16], [975106.192450177, 6], [975106.342136272, 15], [975106.493454736, 8], [975106.68552681, 15], [975106.877667444, 16], [975107.11526917, 22], [975107.394081557, 9], [975107.543458156, 8], [975107.727666856, 25], [975107.885609611, 18], [975108.040849893, 13], [975108.226760124, 55], [975108.382842109, 11], [975108.570567854, 10], [975108.745132704, 11], [975108.906239193, 15], [975109.055771595, 17], [975109.206206179, 14], [975109.390205744, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-31f44b38ed3447f895b691c3", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3557, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.2035, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975095.786910274, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.24742687307298183, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.09501952422006, "done": 975109.407824508, "finish_reason": "length", "first": 975096.035446277, "full_response_s": 13.623541627079248, "last": 975109.389713848, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975096.035446277, 3], [975096.172482358, 11], [975096.352090958, 30], [975096.537385411, 19], [975096.687084128, 21], [975096.881913548, 15], [975097.03040955, 19], [975097.181275212, 17], [975097.330039408, 6], [975097.477403256, 11], [975097.626097615, 5], [975097.810229352, 27], [975098.005555474, 12], [975098.185165537, 13], [975098.369877498, 5], [975098.521047139, 16], [975098.704137195, 5], [975098.896608179, 16], [975099.085251195, 7], [975099.234118494, 22], [975099.38253103, 10], [975099.564512526, 7], [975099.748246978, 23], [975099.908422475, 5], [975100.063386546, 9], [975100.232248717, 14], [975100.380859973, 20], [975100.531985381, 8], [975100.678835778, 12], [975100.830191991, 5], [975100.992068189, 14], [975101.139971153, 11], [975101.290440025, 7], [975101.47240457, 17], [975101.645441864, 3], [975101.82828304, 10], [975101.988016006, 11], [975102.171388159, 9], [975102.356708219, 10], [975102.543591788, 20], [975102.695141962, 14], [975102.884695424, 14], [975103.114211316, 13], [975103.270121451, 5], [975103.445705701, 14], [975103.67131266, 11], [975103.913622698, 32], [975104.10946527, 33], [975104.300475098, 11], [975104.486805677, 6], [975104.630223508, 8], [975104.783285278, 9], [975104.943865881, 13], [975105.092985545, 8], [975105.242924466, 20], [975105.397423217, 17], [975105.550397561, 20], [975105.697115723, 13], [975105.85043063, 2], [975106.009273888, 16], [975106.191221868, 6], [975106.341294968, 15], [975106.493779505, 8], [975106.68463394, 15], [975106.878346788, 16], [975107.115637392, 22], [975107.393156705, 9], [975107.54479982, 8], [975107.727158384, 25], [975107.885354791, 18], [975108.042019021, 13], [975108.223994287, 55], [975108.379854011, 11], [975108.566934123, 10], [975108.745069315, 11], [975108.902753598, 15], [975109.054934499, 17], [975109.205383658, 14], [975109.389713848, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b8c999a7764f479683433434", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3556, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.2035, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975095.784282881, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2511633960530162, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.092570076828785, "done": 975109.404715247, "finish_reason": "length", "first": 975096.034652123, "full_response_s": 13.617893000948243, "last": 975109.390632956, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975096.034652123, 3], [975096.172686396, 11], [975096.35286564, 30], [975096.541116638, 19], [975096.690240679, 21], [975096.881504816, 15], [975097.033869302, 19], [975097.180655722, 17], [975097.330782204, 6], [975097.477302701, 11], [975097.626474429, 5], [975097.809698834, 27], [975098.00563139, 12], [975098.185841904, 13], [975098.370327396, 5], [975098.521385267, 16], [975098.706069054, 5], [975098.898692959, 16], [975099.084132881, 7], [975099.234510411, 22], [975099.384294449, 10], [975099.566239275, 7], [975099.748863797, 23], [975099.908038733, 5], [975100.060415777, 9], [975100.230375367, 14], [975100.381510758, 20], [975100.529555977, 8], [975100.678975611, 12], [975100.83005259, 5], [975100.993181335, 14], [975101.139806248, 11], [975101.288622705, 7], [975101.472339069, 17], [975101.645814822, 3], [975101.827073178, 10], [975101.987229964, 11], [975102.173384607, 9], [975102.357070297, 10], [975102.540692503, 20], [975102.694841977, 14], [975102.884379439, 14], [975103.116976479, 13], [975103.275069822, 5], [975103.450514495, 14], [975103.672367762, 11], [975103.916704166, 32], [975104.106910432, 33], [975104.301947187, 11], [975104.483960709, 6], [975104.631393276, 8], [975104.782980749, 9], [975104.943681394, 13], [975105.093286923, 8], [975105.24229096, 20], [975105.399044755, 17], [975105.548377881, 20], [975105.696921173, 13], [975105.851144884, 2], [975106.009742745, 16], [975106.191880924, 6], [975106.340937161, 15], [975106.494219868, 8], [975106.686282774, 15], [975106.878709346, 16], [975107.120573285, 22], [975107.393948491, 9], [975107.543168857, 8], [975107.726942586, 25], [975107.886123891, 18], [975108.043972864, 13], [975108.226877574, 55], [975108.381692596, 11], [975108.568798818, 10], [975108.744870525, 11], [975108.906423344, 15], [975109.05596797, 17], [975109.208670718, 14], [975109.390632956, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4745056059b744ed93ef8634", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3557, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.2035, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975095.786822246, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.24782987695652992, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.092325954601602, "done": 975109.4070492, "finish_reason": "length", "first": 975096.034414631, "full_response_s": 13.622641380992718, "last": 975109.390566239, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975096.034414631, 3], [975096.172930544, 11], [975096.353950884, 30], [975096.539075921, 19], [975096.690993347, 21], [975096.883155937, 15], [975097.03193842, 19], [975097.180383367, 17], [975097.330567335, 6], [975097.478949565, 11], [975097.626406272, 5], [975097.809998739, 27], [975098.00422549, 12], [975098.185239117, 13], [975098.375955685, 5], [975098.523785855, 16], [975098.704055855, 5], [975098.896724638, 16], [975099.085723828, 7], [975099.234803549, 22], [975099.382991776, 10], [975099.564316536, 7], [975099.748183846, 23], [975099.908508999, 5], [975100.060513404, 9], [975100.230606908, 14], [975100.381895395, 20], [975100.532766415, 8], [975100.679144179, 12], [975100.832253205, 5], [975100.992133833, 14], [975101.141309664, 11], [975101.291351838, 7], [975101.473423337, 17], [975101.645614735, 3], [975101.830584833, 10], [975101.987551228, 11], [975102.171111308, 9], [975102.355360491, 10], [975102.541049045, 20], [975102.696681104, 14], [975102.885132427, 14], [975103.114579426, 13], [975103.271367552, 5], [975103.447343591, 14], [975103.672433454, 11], [975103.917565693, 32], [975104.11064859, 33], [975104.301038111, 11], [975104.484198746, 6], [975104.630373853, 8], [975104.782851011, 9], [975104.941577606, 13], [975105.093181424, 8], [975105.242611009, 20], [975105.396731698, 17], [975105.546076919, 20], [975105.69627466, 13], [975105.851064119, 2], [975106.011293695, 16], [975106.191794848, 6], [975106.341341589, 15], [975106.493527453, 8], [975106.68685089, 15], [975106.877837852, 16], [975107.117198822, 22], [975107.392359111, 9], [975107.5429493, 8], [975107.728514447, 25], [975107.885905405, 18], [975108.042761674, 13], [975108.224261523, 55], [975108.380378642, 11], [975108.567631113, 10], [975108.745283657, 11], [975108.904299925, 15], [975109.054819321, 17], [975109.208418362, 14], [975109.390566239, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-247e676d464d4798b1368bb3", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3557, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.2035, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975095.784407819, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2500068119261414, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.091440561378437, "done": 975109.406314211, "finish_reason": "length", "first": 975096.034027401, "full_response_s": 13.62106643198058, "last": 975109.39079842, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975096.034027401, 3], [975096.171971727, 11], [975096.352335778, 30], [975096.538037763, 19], [975096.688227528, 21], [975096.881393638, 15], [975097.032556918, 19], [975097.180472531, 17], [975097.330303555, 6], [975097.477852978, 11], [975097.625166316, 5], [975097.809191722, 27], [975098.003622271, 12], [975098.185109075, 13], [975098.370850251, 5], [975098.52095044, 16], [975098.704377919, 5], [975098.897544902, 16], [975099.084992424, 7], [975099.233341715, 22], [975099.382626561, 10], [975099.564950057, 7], [975099.749937345, 23], [975099.908738204, 5], [975100.064087856, 9], [975100.232187408, 14], [975100.380471, 20], [975100.529812029, 8], [975100.67953248, 12], [975100.831029807, 5], [975100.992863206, 14], [975101.140904052, 11], [975101.289672446, 7], [975101.473552355, 17], [975101.646441576, 3], [975101.828340477, 10], [975101.986092722, 11], [975102.172351265, 9], [975102.358326909, 10], [975102.539607579, 20], [975102.696792827, 14], [975102.884750381, 14], [975103.115366796, 13], [975103.270176521, 5], [975103.446495871, 14], [975103.671928327, 11], [975103.913465009, 32], [975104.107978973, 33], [975104.301823449, 11], [975104.483740336, 6], [975104.632192262, 8], [975104.783104119, 9], [975104.941091086, 13], [975105.091308777, 8], [975105.242139991, 20], [975105.396878059, 17], [975105.544562143, 20], [975105.696615459, 13], [975105.849606957, 2], [975106.01388378, 16], [975106.19221926, 6], [975106.343229883, 15], [975106.494826911, 8], [975106.686171787, 15], [975106.877455262, 16], [975107.115421738, 22], [975107.391651736, 9], [975107.542533144, 8], [975107.727384581, 25], [975107.884894861, 18], [975108.040644095, 13], [975108.225289234, 55], [975108.381049011, 11], [975108.568423028, 10], [975108.74479736, 11], [975108.902874393, 15], [975109.05714593, 17], [975109.205821685, 14], [975109.39079842, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-a09bf2027a9146979fadc939", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3557, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.2035, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975095.785247779, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.24877962202299386, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.092403828785173, "done": 975109.402436652, "finish_reason": "length", "first": 975096.034786293, "full_response_s": 13.617564438958652, "last": 975109.390883424, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975096.034786293, 3], [975096.171814982, 11], [975096.354480794, 30], [975096.537497005, 19], [975096.686975205, 21], [975096.881146322, 15], [975097.030263941, 19], [975097.179597629, 17], [975097.329697537, 6], [975097.476591391, 11], [975097.625104815, 5], [975097.80910411, 27], [975098.003881298, 12], [975098.186893949, 13], [975098.370914664, 5], [975098.521320038, 16], [975098.706700335, 5], [975098.898567637, 16], [975099.086397444, 7], [975099.233796269, 22], [975099.38277281, 10], [975099.566320391, 7], [975099.748354285, 23], [975099.908662991, 5], [975100.061021892, 9], [975100.232101124, 14], [975100.382104297, 20], [975100.532219273, 8], [975100.680594813, 12], [975100.830278323, 5], [975100.994146937, 14], [975101.140991248, 11], [975101.290387356, 7], [975101.473317678, 17], [975101.646661853, 3], [975101.828052843, 10], [975101.988388516, 11], [975102.172472987, 9], [975102.356092616, 10], [975102.539492272, 20], [975102.694387838, 14], [975102.884143994, 14], [975103.114444024, 13], [975103.270793483, 5], [975103.446025238, 14], [975103.671861754, 11], [975103.915351063, 32], [975104.108111879, 33], [975104.299912341, 11], [975104.485948726, 6], [975104.630560932, 8], [975104.783488004, 9], [975104.94217705, 13], [975105.093433828, 8], [975105.243186053, 20], [975105.3976126, 17], [975105.544812324, 20], [975105.697910853, 13], [975105.84929766, 2], [975106.009409817, 16], [975106.192714612, 6], [975106.341467903, 15], [975106.492684853, 8], [975106.687223497, 15], [975106.878118462, 16], [975107.116543925, 22], [975107.392910284, 9], [975107.548382865, 8], [975107.727951562, 25], [975107.885059862, 18], [975108.045441962, 13], [975108.225219685, 55], [975108.380704467, 11], [975108.568866991, 10], [975108.745440722, 11], [975108.904457869, 15], [975109.055880774, 17], [975109.206268944, 14], [975109.390883424, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-f97aa603076342d68e51bc4f", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3556, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.2035, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975095.784872213, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2499140800209716, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.092647656944862, "done": 975109.404870712, "finish_reason": "length", "first": 975096.034223952, "full_response_s": 13.618279270012863, "last": 975109.390150515, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975096.034223952, 3], [975096.172397898, 11], [975096.352804411, 30], [975096.540041666, 19], [975096.688551225, 21], [975096.882907965, 15], [975097.031650786, 19], [975097.180109684, 17], [975097.330935637, 6], [975097.47850797, 11], [975097.62674104, 5], [975097.809833467, 27], [975098.004359211, 12], [975098.187532942, 13], [975098.370669763, 5], [975098.520689717, 16], [975098.70486276, 5], [975098.896231926, 16], [975099.084567068, 7], [975099.234044561, 22], [975099.38227829, 10], [975099.564448402, 7], [975099.749279489, 23], [975099.910048237, 5], [975100.060669013, 9], [975100.231063558, 14], [975100.383976895, 20], [975100.530779167, 8], [975100.68015117, 12], [975100.830403597, 5], [975100.991721725, 14], [975101.14052167, 11], [975101.288991871, 7], [975101.472235762, 17], [975101.645502517, 3], [975101.828412761, 10], [975101.988331751, 11], [975102.17261298, 9], [975102.355155669, 10], [975102.540939867, 20], [975102.695347856, 14], [975102.886879703, 14], [975103.116577778, 13], [975103.271715567, 5], [975103.448627561, 14], [975103.672215961, 11], [975103.914964826, 32], [975104.110326285, 33], [975104.302911429, 11], [975104.484818908, 6], [975104.630643488, 8], [975104.783574832, 9], [975104.943453757, 13], [975105.094442131, 8], [975105.242986623, 20], [975105.398324838, 17], [975105.544982747, 20], [975105.697421277, 13], [975105.849690729, 2], [975106.01031267, 16], [975106.19276637, 6], [975106.343513438, 15], [975106.493041652, 8], [975106.685590871, 15], [975106.878410001, 16], [975107.117518038, 22], [975107.392805729, 9], [975107.542679361, 8], [975107.727612042, 25], [975107.887732342, 18], [975108.043868645, 13], [975108.227058238, 55], [975108.382764609, 11], [975108.568226237, 10], [975108.74521294, 11], [975108.905276407, 15], [975109.056493929, 17], [975109.205898721, 14], [975109.390150515, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-2393897178f6426d8fd0b582", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3557, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.2035, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975095.786591442, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2476325100287795, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.09352961525728, "done": 975109.406105821, "finish_reason": "length", "first": 975096.034681754, "full_response_s": 13.619361363002099, "last": 975109.389991387, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975096.034681754, 3], [975096.172631807, 11], [975096.352681329, 30], [975096.539013396, 19], [975096.687954598, 21], [975096.883490912, 15], [975097.031008625, 19], [975097.180257629, 17], [975097.330864504, 6], [975097.477742823, 11], [975097.625908536, 5], [975097.809748927, 27], [975098.00404873, 12], [975098.186577485, 13], [975098.371331188, 5], [975098.521177581, 16], [975098.704958931, 5], [975098.898948579, 16], [975099.085076596, 7], [975099.233671651, 22], [975099.382898068, 10], [975099.564860958, 7], [975099.74875921, 23], [975099.90897448, 5], [975100.060205755, 9], [975100.231529263, 14], [975100.382266034, 20], [975100.530352467, 8], [975100.6807909, 12], [975100.830450411, 5], [975100.993501208, 14], [975101.140635553, 11], [975101.28976657, 7], [975101.473038284, 17], [975101.645131351, 3], [975101.831114712, 10], [975101.987625481, 11], [975102.174440509, 9], [975102.356435176, 10], [975102.541502464, 20], [975102.696319506, 14], [975102.884951732, 14], [975103.11487426, 13], [975103.270856104, 5], [975103.445821872, 14], [975103.672853962, 11], [975103.913875006, 32], [975104.10872009, 33], [975104.300586324, 11], [975104.485846507, 6], [975104.633985424, 8], [975104.783647261, 9], [975104.943525849, 13], [975105.093362679, 8], [975105.243258946, 20], [975105.39810776, 17], [975105.546935982, 20], [975105.699304419, 13], [975105.850945965, 2], [975106.009518004, 16], [975106.191433602, 6], [975106.341081314, 15], [975106.494323143, 8], [975106.686046369, 15], [975106.87846531, 16], [975107.120475498, 22], [975107.391846943, 9], [975107.54243606, 8], [975107.727534878, 25], [975107.885272667, 18], [975108.042486407, 13], [975108.227535639, 55], [975108.380032003, 11], [975108.567047669, 10], [975108.744964424, 11], [975108.90381854, 15], [975109.056282403, 17], [975109.208346365, 14], [975109.389991387, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-c03e8148f85240548fc3c4e4", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3557, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.2035, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975095.786744458, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2479372959351167, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.091601968528014, "done": 975109.40525687, "finish_reason": "length", "first": 975096.033837267, "full_response_s": 13.620667155948468, "last": 975109.390495363, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975096.033837267, 3], [975096.172569106, 11], [975096.352534184, 30], [975096.54150454, 19], [975096.68876699, 21], [975096.880693927, 15], [975097.031575461, 19], [975097.183658441, 17], [975097.330120364, 6], [975097.477651788, 11], [975097.626679219, 5], [975097.80960215, 27], [975098.007240688, 12], [975098.186457618, 13], [975098.370791678, 5], [975098.520800431, 16], [975098.704196872, 5], [975098.89704731, 16], [975099.084851934, 7], [975099.234225688, 22], [975099.383476056, 10], [975099.565045861, 7], [975099.749398235, 23], [975099.909056188, 5], [975100.061386914, 9], [975100.231856928, 14], [975100.382651823, 20], [975100.5314156, 8], [975100.679896063, 12], [975100.830135082, 5], [975100.992761403, 14], [975101.141522422, 11], [975101.28842601, 7], [975101.472942704, 17], [975101.644987853, 3], [975101.827588897, 10], [975101.98847368, 11], [975102.171639091, 9], [975102.359626463, 10], [975102.540614394, 20], [975102.694619011, 14], [975102.883862152, 14], [975103.117342126, 13], [975103.270553239, 5], [975103.44626625, 14], [975103.67139616, 11], [975103.915673608, 32], [975104.107235761, 33], [975104.301453851, 11], [975104.489694355, 6], [975104.631466473, 8], [975104.78629547, 9], [975104.940705152, 13], [975105.093742645, 8], [975105.242863253, 20], [975105.399214811, 17], [975105.545039545, 20], [975105.697982386, 13], [975105.849429685, 2], [975106.009823013, 16], [975106.192541261, 6], [975106.341192749, 15], [975106.493862285, 8], [975106.68517881, 15], [975106.879971318, 16], [975107.11584103, 22], [975107.392192351, 9], [975107.542824906, 8], [975107.727721269, 25], [975107.885459314, 18], [975108.041506694, 13], [975108.226437467, 55], [975108.380410545, 11], [975108.567206926, 10], [975108.7490981, 11], [975108.905444543, 15], [975109.056055902, 17], [975109.207260977, 14], [975109.390495363, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-f02a699ab6544e0dbbfc54c1", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3556, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.2035, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975095.784589714, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.24924755294341594, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.092525318805844, "done": 975109.40150108, "finish_reason": "length", "first": 975096.034069927, "full_response_s": 13.616843817057088, "last": 975109.39008207, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975096.034069927, 3], [975096.171736602, 11], [975096.353136331, 30], [975096.538434528, 19], [975096.689120205, 21], [975096.882055206, 15], [975097.030908293, 19], [975097.18077738, 17], [975097.330369872, 6], [975097.476759095, 11], [975097.62629239, 5], [975097.809311476, 27], [975098.004455399, 12], [975098.185892238, 13], [975098.370264007, 5], [975098.521823918, 16], [975098.704696464, 5], [975098.897460986, 16], [975099.085665143, 7], [975099.234972996, 22], [975099.383063116, 10], [975099.565737987, 7], [975099.748605809, 23], [975099.908590483, 5], [975100.063566953, 9], [975100.231986889, 14], [975100.382399195, 20], [975100.531822061, 8], [975100.679916334, 12], [975100.830340176, 5], [975100.992587156, 14], [975101.139877893, 11], [975101.289818743, 7], [975101.473158422, 17], [975101.645244497, 3], [975101.827199188, 10], [975101.987123857, 11], [975102.172414926, 9], [975102.355262592, 10], [975102.540898253, 20], [975102.694700271, 14], [975102.884600372, 14], [975103.115486263, 13], [975103.274190105, 5], [975103.447233612, 14], [975103.676844939, 11], [975103.913812353, 32], [975104.106333836, 33], [975104.300161833, 11], [975104.486710706, 6], [975104.632615346, 8], [975104.784276607, 9], [975104.940913414, 13], [975105.093114579, 8], [975105.244401787, 20], [975105.397899386, 17], [975105.54471468, 20], [975105.697287811, 13], [975105.850543744, 2], [975106.012567202, 16], [975106.192376837, 6], [975106.341416754, 15], [975106.493148303, 8], [975106.684944325, 15], [975106.878588296, 16], [975107.116132776, 22], [975107.393015991, 9], [975107.542902902, 8], [975107.728354215, 25], [975107.888300715, 18], [975108.040432857, 13], [975108.224825144, 55], [975108.380455871, 11], [975108.569114355, 10], [975108.746379077, 11], [975108.903079919, 15], [975109.05504411, 17], [975109.20564331, 14], [975109.39008207, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-35abf1eecab14c4ca5b4ed32", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3556, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.2035, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975095.784657263, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.24941266397945583, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.089769665383763, "done": 975109.407514826, "finish_reason": "length", "first": 975096.034102006, "full_response_s": 13.622373986057937, "last": 975109.392042121, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975096.034102006, 3], [975096.171597409, 11], [975096.352746814, 30], [975096.53789321, 19], [975096.691599478, 21], [975096.882144897, 15], [975097.031067262, 19], [975097.179747894, 17], [975097.33049465, 6], [975097.478434134, 11], [975097.626345507, 5], [975097.809260103, 27], [975098.006484677, 12], [975098.184984793, 13], [975098.371045025, 5], [975098.523297335, 16], [975098.705375759, 5], [975098.896407469, 16], [975099.084918283, 7], [975099.233879737, 22], [975099.384132617, 10], [975099.568692821, 7], [975099.749722859, 23], [975099.911954113, 5], [975100.061944871, 9], [975100.231931932, 14], [975100.380791144, 20], [975100.530627494, 8], [975100.679598237, 12], [975100.830917605, 5], [975100.991854183, 14], [975101.140414379, 11], [975101.288585394, 7], [975101.474077674, 17], [975101.64485522, 3], [975101.827270384, 10], [975101.987053108, 11], [975102.172730959, 9], [975102.358163269, 10], [975102.539988072, 20], [975102.694147194, 14], [975102.884534536, 14], [975103.117109657, 13], [975103.270635683, 5], [975103.446346262, 14], [975103.673175275, 11], [975103.913715829, 32], [975104.105644509, 33], [975104.300415757, 11], [975104.48540016, 6], [975104.633880277, 8], [975104.785071561, 9], [975104.941942453, 13], [975105.094584093, 8], [975105.242339566, 20], [975105.399864716, 17], [975105.544918175, 20], [975105.696512376, 13], [975105.849523841, 2], [975106.010740778, 16], [975106.191688405, 6], [975106.341761873, 15], [975106.493944953, 8], [975106.687637237, 15], [975106.879040419, 16], [975107.118925171, 22], [975107.391793122, 9], [975107.542741006, 8], [975107.727049669, 25], [975107.885197359, 18], [975108.043058508, 13], [975108.2244063, 55], [975108.379537658, 11], [975108.566717733, 10], [975108.74934348, 11], [975108.903580983, 15], [975109.056139226, 17], [975109.20521821, 14], [975109.392042121, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-3d5966f428044066a91c96fd", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3557, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.2035, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975095.78514084, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2489611660130322, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.09344512151501, "done": 975109.405547544, "finish_reason": "length", "first": 975096.034448725, "full_response_s": 13.619443902978674, "last": 975109.389817459, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975096.034448725, 3], [975096.173691948, 11], [975096.354020481, 30], [975096.538391394, 19], [975096.691406463, 21], [975096.881784019, 15], [975097.030625667, 19], [975097.181057095, 17], [975097.329882856, 6], [975097.478053784, 11], [975097.625502412, 5], [975097.809651204, 27], [975098.005109575, 12], [975098.186181344, 13], [975098.372042913, 5], [975098.521266889, 16], [975098.703952628, 5], [975098.896497001, 16], [975099.083951018, 7], [975099.234307924, 22], [975099.384447706, 10], [975099.565543373, 7], [975099.748970032, 23], [975099.908881349, 5], [975100.060884922, 9], [975100.231765332, 14], [975100.382922994, 20], [975100.530953606, 8], [975100.679663994, 12], [975100.831484841, 5], [975100.992664416, 14], [975101.140084027, 11], [975101.28871166, 7], [975101.472588689, 17], [975101.645743801, 3], [975101.828773768, 10], [975101.98688974, 11], [975102.170947524, 9], [975102.355916641, 10], [975102.540837456, 20], [975102.695986274, 14], [975102.884287763, 14], [975103.115270145, 13], [975103.27049353, 5], [975103.446794113, 14], [975103.675658996, 11], [975103.916157937, 32], [975104.106740457, 33], [975104.302081101, 11], [975104.488644357, 6], [975104.632912356, 8], [975104.784785574, 9], [975104.943115565, 13], [975105.092225453, 8], [975105.242528309, 20], [975105.397538699, 17], [975105.546671739, 20], [975105.697256133, 13], [975105.85067889, 2], [975106.010223058, 16], [975106.191361541, 6], [975106.341848413, 15], [975106.494475072, 8], [975106.686418767, 15], [975106.877759968, 16], [975107.116301728, 22], [975107.3941852, 9], [975107.546581623, 8], [975107.727763395, 25], [975107.88581333, 18], [975108.043142168, 13], [975108.224345647, 55], [975108.380292598, 11], [975108.567833744, 10], [975108.744494975, 11], [975108.903412175, 15], [975109.056414429, 17], [975109.207118152, 14], [975109.389817459, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-ada9b79c49a84e93ba1a8bf7", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3557, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.2035, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975095.786103641, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2483450840227306, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.09285313506639, "done": 975109.406813276, "finish_reason": "length", "first": 975096.034590862, "full_response_s": 13.623111678985879, "last": 975109.390373688, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975096.034590862, 3], [975096.172282944, 11], [975096.352445789, 30], [975096.53868058, 19], [975096.688161788, 21], [975096.88271847, 15], [975097.032206583, 19], [975097.179519697, 17], [975097.329776765, 6], [975097.477081879, 11], [975097.625242025, 5], [975097.809388385, 27], [975098.006968685, 12], [975098.187229917, 13], [975098.375831627, 5], [975098.522992246, 16], [975098.705751645, 5], [975098.896857223, 16], [975099.08623478, 7], [975099.233119566, 22], [975099.382697118, 10], [975099.566415011, 7], [975099.74986858, 23], [975099.907739324, 5], [975100.060787935, 9], [975100.232044615, 14], [975100.380728539, 20], [975100.532286966, 8], [975100.679207856, 12], [975100.831315809, 5], [975100.992928931, 14], [975101.140147272, 11], [975101.288319711, 7], [975101.471904418, 17], [975101.64655493, 3], [975101.827363516, 10], [975101.986364885, 11], [975102.172087837, 9], [975102.355780519, 10], [975102.539725141, 20], [975102.694980674, 14], [975102.885785324, 14], [975103.116100649, 13], [975103.271301235, 5], [975103.450899996, 14], [975103.67178179, 11], [975103.914608715, 32], [975104.11022189, 33], [975104.301729934, 11], [975104.484089263, 6], [975104.630443114, 8], [975104.784102663, 9], [975104.940468667, 13], [975105.093837776, 8], [975105.243306848, 20], [975105.397803503, 17], [975105.545327387, 20], [975105.696800026, 13], [975105.850614125, 2], [975106.010143926, 16], [975106.191593482, 6], [975106.342397203, 15], [975106.493363893, 8], [975106.684788813, 15], [975106.879438736, 16], [975107.11854023, 22], [975107.391718341, 9], [975107.545267525, 8], [975107.731327017, 25], [975107.886325385, 18], [975108.040549523, 13], [975108.22666248, 55], [975108.379777311, 11], [975108.566462289, 10], [975108.745608682, 11], [975108.903318068, 15], [975109.055178823, 17], [975109.206153941, 14], [975109.390373688, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-9796bd6a5a90443aa593d210", "runtime": {"accepted": 177, "cached": 30, "decode_s": 13.3557, "drafted": 386, "drafts": true, "min_rows": 4, "prefill_s": 0.2035, "rounds": 78, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975095.783701597, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2508892649784684, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 386, "rounds": 78}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "candidate", "burst": null, "phase": "uncached_first_use", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 69.1970505168244, "done": 975250.459048034, "finish_reason": "length", "first": 975246.773813007, "full_response_s": 3.8389058320317417, "last": 975250.458941175, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975246.773813007, 2], [975246.862322587, 7], [975246.942383272, 4], [975247.029337764, 73], [975247.113792019, 51], [975247.194072376, 21], [975247.275108158, 14], [975247.355570892, 20], [975247.435726214, 16], [975247.516304815, 15], [975247.596179076, 23], [975247.678871545, 23], [975247.75949632, 25], [975247.840380831, 36], [975247.921293871, 14], [975248.007221351, 6], [975248.092466075, 18], [975248.173315101, 18], [975248.253886234, 19], [975248.334650784, 8], [975248.415272683, 11], [975248.495341724, 18], [975248.575641748, 15], [975248.655868799, 39], [975248.737983183, 30], [975248.820865105, 14], [975248.901057745, 15], [975248.986643644, 8], [975249.072464908, 6], [975249.15318276, 15], [975249.233684652, 23], [975249.315172041, 22], [975249.395917411, 26], [975249.476334122, 35], [975249.55735057, 31], [975249.637431598, 12], [975249.718768545, 13], [975249.800175649, 38], [975249.880919247, 47], [975249.962462318, 25], [975250.05025986, 11], [975250.132506343, 34], [975250.213428126, 12], [975250.294219834, 36], [975250.374997591, 60], [975250.458941175, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-fb1bb9bb5dd047feaf21cf6a4810af19", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.128077761, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 3.685321088, "time_to_first_token": 0.12918778, "token_sha": "2b28aa2108de", "tokens_per_second": 69.19342817382213}, "seed": 1234, "sent": 975246.620142202, "speculative": {"acceptance_rate": 0.31555555555555553, "accepted": 213, "drafted": 675, "rounds": 45, "tokens_per_round": 5.688888888888889}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.15367080504074693, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 213, "drafted": 675, "rounds": 45}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 69.16417465259032, "done": 975254.15560797, "finish_reason": "length", "first": 975250.468691972, "full_response_s": 3.695488329976797, "last": 975254.155571795, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975250.468691972, 2], [975250.557796583, 7], [975250.638543509, 4], [975250.718713594, 73], [975250.802335542, 51], [975250.883083607, 21], [975250.96527616, 14], [975251.052058627, 20], [975251.134438453, 16], [975251.214721081, 15], [975251.296453588, 23], [975251.376183742, 23], [975251.4570371, 25], [975251.53708105, 36], [975251.617889322, 14], [975251.698412309, 6], [975251.780303977, 18], [975251.860574081, 18], [975251.940793019, 19], [975252.028310725, 8], [975252.112153345, 11], [975252.192137125, 18], [975252.273458564, 15], [975252.353675711, 39], [975252.434771367, 30], [975252.515295494, 14], [975252.595536112, 15], [975252.676755763, 8], [975252.759321073, 6], [975252.840343758, 15], [975252.921460633, 23], [975253.007016437, 22], [975253.092824838, 26], [975253.174830063, 35], [975253.255405535, 31], [975253.336449245, 12], [975253.417380704, 13], [975253.497757096, 38], [975253.578718905, 47], [975253.659178303, 25], [975253.739474794, 11], [975253.821693002, 34], [975253.902304781, 12], [975253.987455309, 36], [975254.073065339, 60], [975254.155571795, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-104723ffed3fa62d030fe8524951a329", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.007705823, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 3.686499614, "time_to_first_token": 0.008007714, "token_sha": "2b28aa2108de", "tokens_per_second": 69.17130793438895}, "seed": 1234, "sent": 975250.46011964, "speculative": {"acceptance_rate": 0.31555555555555553, "accepted": 213, "drafted": 675, "rounds": 45, "tokens_per_round": 5.688888888888889}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.008572331978939474, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 213, "drafted": 675, "rounds": 45}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 69.3822845686003, "done": 975257.845974047, "finish_reason": "length", "first": 975254.170637969, "full_response_s": 3.679035292007029, "last": 975257.845927729, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975254.170637969, 2], [975254.259987275, 7], [975254.341221269, 4], [975254.421313965, 73], [975254.502376542, 51], [975254.582708476, 21], [975254.663020491, 14], [975254.744051197, 20], [975254.827213965, 16], [975254.907368886, 15], [975254.99280947, 23], [975255.078223944, 23], [975255.159071285, 25], [975255.239248637, 36], [975255.320816094, 14], [975255.401346537, 6], [975255.481738408, 18], [975255.562331728, 18], [975255.642684721, 19], [975255.723112063, 8], [975255.803897311, 11], [975255.884792766, 18], [975255.966601866, 15], [975256.054081078, 39], [975256.136758223, 30], [975256.216990505, 14], [975256.298311944, 15], [975256.379023615, 8], [975256.459501295, 6], [975256.540222549, 15], [975256.620418304, 23], [975256.700882929, 22], [975256.784612465, 26], [975256.865957105, 35], [975256.946152592, 31], [975257.033785755, 12], [975257.11753731, 13], [975257.198528557, 38], [975257.279876191, 47], [975257.360297685, 25], [975257.441305028, 11], [975257.522039278, 34], [975257.602179007, 12], [975257.683349383, 36], [975257.7638051, 60], [975257.845927729, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-a67530d1f7b2570c9aab60ff89c532ca", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.002291893, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 3.675244882, "time_to_first_token": 0.003028889, "token_sha": "2b28aa2108de", "tokens_per_second": 69.38313178773376}, "seed": 1234, "sent": 975254.166938755, "speculative": {"acceptance_rate": 0.31555555555555553, "accepted": 213, "drafted": 675, "rounds": 45, "tokens_per_round": 5.688888888888889}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.0036992140812799335, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 213, "drafted": 675, "rounds": 45}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 69.22458854592682, "done": 975261.543597105, "finish_reason": "length", "first": 975257.85985171, "full_response_s": 3.6870737599674612, "last": 975261.543513908, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975257.85985171, 2], [975257.948447351, 7], [975258.035599433, 4], [975258.119210981, 73], [975258.200337331, 51], [975258.281652746, 21], [975258.361737777, 14], [975258.442261975, 20], [975258.522127687, 16], [975258.602890035, 15], [975258.683260271, 23], [975258.766482715, 23], [975258.847198395, 25], [975258.927803585, 36], [975259.013815764, 14], [975259.098887035, 6], [975259.179736168, 18], [975259.260076153, 18], [975259.341749941, 19], [975259.421744756, 8], [975259.502163106, 11], [975259.582281339, 18], [975259.662869042, 15], [975259.743527479, 39], [975259.824766037, 30], [975259.905273363, 14], [975259.990803293, 15], [975260.076987436, 8], [975260.157831917, 6], [975260.238218096, 15], [975260.319325095, 23], [975260.39974916, 22], [975260.48046875, 26], [975260.561555014, 35], [975260.641849836, 31], [975260.722395433, 12], [975260.80654508, 13], [975260.886888352, 38], [975260.968497111, 47], [975261.05643071, 25], [975261.138704179, 11], [975261.21923434, 34], [975261.30057215, 12], [975261.381313599, 36], [975261.461500669, 60], [975261.543513908, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-501d0d2c8d46322a429af4df86f3a99d", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.002220937, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 3.683665958, "time_to_first_token": 0.002633177, "token_sha": "2b28aa2108de", "tokens_per_second": 69.22451788718894}, "seed": 1234, "sent": 975257.856523345, "speculative": {"acceptance_rate": 0.31555555555555553, "accepted": 213, "drafted": 675, "rounds": 45, "tokens_per_round": 5.688888888888889}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.0033283650409430265, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 213, "drafted": 675, "rounds": 45}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.8472819792396, "done": 975271.664646229, "finish_reason": "length", "first": 975261.796271026, "full_response_s": 10.104741521994583, "last": 975271.661911839, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975261.796271026, 2], [975261.94519023, 7], [975262.102567823, 4], [975262.317623947, 63], [975262.542172707, 10], [975262.723486678, 31], [975262.909230143, 29], [975263.103083153, 22], [975263.283477471, 14], [975263.46807337, 24], [975263.64698485, 4], [975263.792956544, 13], [975263.977746619, 21], [975264.166176009, 2], [975264.347361698, 18], [975264.527151456, 29], [975264.762233331, 27], [975265.002401465, 24], [975265.15476814, 4], [975265.304498358, 16], [975265.484642591, 10], [975265.666927893, 31], [975265.812594029, 8], [975265.997320876, 11], [975266.185317436, 16], [975266.366021832, 12], [975266.55058371, 39], [975266.723108104, 18], [975266.907385438, 11], [975267.098579931, 16], [975267.279790716, 16], [975267.426740239, 11], [975267.607766871, 6], [975267.79278642, 9], [975267.978779251, 29], [975268.166440642, 22], [975268.348215493, 8], [975268.496827151, 18], [975268.678326141, 18], [975268.865371046, 34], [975269.052454548, 10], [975269.235731782, 14], [975269.418835758, 13], [975269.601118534, 2], [975269.785672886, 36], [975269.969073386, 42], [975270.162239494, 26], [975270.312155995, 17], [975270.493763638, 34], [975270.676940996, 12], [975270.86316907, 36], [975271.15395538, 50], [975271.338807114, 2], [975271.661911839, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-61e84d3b722eab29120e742082cc2394", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.145093235, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.86784007, "time_to_first_token": 0.230997985, "token_sha": "2b28aa2108de", "tokens_per_second": 25.841521365475476}, "seed": 1234, "sent": 975261.559904707, "speculative": {"acceptance_rate": 0.571830985915493, "accepted": 203, "drafted": 355, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.23636631900444627, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 355, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.844237304136268, "done": 975271.666185161, "finish_reason": "length", "first": 975261.795992701, "full_response_s": 10.106540923938155, "last": 975271.662795772, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975261.795992701, 2], [975261.944243195, 7], [975262.100606092, 4], [975262.315990427, 63], [975262.542914694, 10], [975262.723346267, 31], [975262.909306172, 29], [975263.102042201, 22], [975263.283121229, 14], [975263.465590523, 24], [975263.646198513, 4], [975263.79230881, 13], [975263.976330835, 21], [975264.164900923, 2], [975264.348576914, 18], [975264.528519931, 29], [975264.761528335, 27], [975265.001442462, 24], [975265.154067511, 4], [975265.303594313, 16], [975265.483520123, 10], [975265.666153235, 31], [975265.812293496, 8], [975265.997542132, 11], [975266.187165557, 16], [975266.367382564, 12], [975266.550440724, 39], [975266.722377637, 18], [975266.908945841, 11], [975267.098278455, 16], [975267.279538053, 16], [975267.425570221, 11], [975267.608174007, 6], [975267.791360699, 9], [975267.978630696, 29], [975268.169454317, 22], [975268.348516585, 8], [975268.49740964, 18], [975268.679096927, 18], [975268.864864954, 34], [975269.051951656, 10], [975269.235654569, 14], [975269.417855716, 13], [975269.601924151, 2], [975269.787328742, 36], [975269.967999444, 42], [975270.160793502, 26], [975270.311813528, 17], [975270.491439104, 34], [975270.677878383, 12], [975270.863515072, 36], [975271.152921196, 50], [975271.338028904, 2], [975271.662795772, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-155d9969c925cee4824571ac99eeb5fd", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.145241534, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.867790089, "time_to_first_token": 0.229758675, "token_sha": "2b28aa2108de", "tokens_per_second": 25.841652254465586}, "seed": 1234, "sent": 975261.559644237, "speculative": {"acceptance_rate": 0.5734463276836158, "accepted": 203, "drafted": 354, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.23634846392087638, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 354, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.84151008905454, "done": 975271.664250308, "finish_reason": "length", "first": 975261.796369918, "full_response_s": 10.10451007494703, "last": 975271.664214294, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975261.796369918, 2], [975261.945306513, 7], [975262.100730119, 4], [975262.314371994, 63], [975262.543086208, 10], [975262.723597553, 31], [975262.909412376, 29], [975263.100641424, 22], [975263.28244348, 14], [975263.466448745, 24], [975263.646659407, 4], [975263.79393985, 13], [975263.977907797, 21], [975264.165525843, 2], [975264.348916757, 18], [975264.527535073, 29], [975264.762657763, 27], [975265.002952292, 24], [975265.154903399, 4], [975265.306534214, 16], [975265.485056127, 10], [975265.666757643, 31], [975265.813131976, 8], [975265.998442625, 11], [975266.188129695, 16], [975266.368309663, 12], [975266.551137241, 39], [975266.721942934, 18], [975266.90965575, 11], [975267.099382044, 16], [975267.28123362, 16], [975267.427427877, 11], [975267.610019824, 6], [975267.792276536, 9], [975267.977329499, 29], [975268.166325334, 22], [975268.349194527, 8], [975268.496084956, 18], [975268.679825299, 18], [975268.866339329, 34], [975269.052179119, 10], [975269.236563941, 14], [975269.419533875, 13], [975269.599845399, 2], [975269.785095324, 36], [975269.967921095, 42], [975270.161189278, 26], [975270.310603895, 17], [975270.492113989, 34], [975270.675310531, 12], [975270.862247265, 36], [975271.152791617, 50], [975271.338109973, 2], [975271.664214294, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-f99a7c4abee2c1d8995e30990d3416ba", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.145203343, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.867816519, "time_to_first_token": 0.230060343, "token_sha": "2b28aa2108de", "tokens_per_second": 25.84158304007882}, "seed": 1234, "sent": 975261.559740233, "speculative": {"acceptance_rate": 0.5734463276836158, "accepted": 203, "drafted": 354, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.23662968503776938, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 354, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.843203112759326, "done": 975271.662638131, "finish_reason": "length", "first": 975261.795217803, "full_response_s": 10.100688543985598, "last": 975271.662415723, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975261.795217803, 2], [975261.94436703, 7], [975262.10248829, 4], [975262.314920853, 63], [975262.543340998, 10], [975262.723388777, 31], [975262.910661383, 29], [975263.10150963, 22], [975263.282645408, 14], [975263.466369052, 24], [975263.644545713, 4], [975263.79358964, 13], [975263.976518907, 21], [975264.165361977, 2], [975264.349473679, 18], [975264.527633453, 29], [975264.761882433, 27], [975265.001851134, 24], [975265.155550605, 4], [975265.303509452, 16], [975265.483807263, 10], [975265.665520252, 31], [975265.812684009, 8], [975265.998567772, 11], [975266.186680103, 16], [975266.368578021, 12], [975266.550678347, 39], [975266.722716408, 18], [975266.90672604, 11], [975267.097559235, 16], [975267.278944733, 16], [975267.426793613, 11], [975267.608135897, 6], [975267.791312509, 9], [975267.978356419, 29], [975268.167483657, 22], [975268.350402, 8], [975268.495784519, 18], [975268.678528917, 18], [975268.865076226, 34], [975269.052110258, 10], [975269.2352546, 14], [975269.41940212, 13], [975269.600933981, 2], [975269.787094431, 36], [975269.967958821, 42], [975270.165534246, 26], [975270.312976811, 17], [975270.493894945, 34], [975270.67646871, 12], [975270.86275051, 36], [975271.153885255, 50], [975271.338282894, 2], [975271.662415723, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-81a85989363ce0afea47b1dd7e501765", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.145279996, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.867792504, "time_to_first_token": 0.230526852, "token_sha": "2b28aa2108de", "tokens_per_second": 25.841645930093627}, "seed": 1234, "sent": 975261.561949587, "speculative": {"acceptance_rate": 0.5734463276836158, "accepted": 203, "drafted": 354, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.23326821601949632, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 354, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.841883623845067, "done": 975271.663035827, "finish_reason": "length", "first": 975261.795285049, "full_response_s": 10.10015920503065, "last": 975271.662986789, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975261.795285049, 2], [975261.945654452, 7], [975262.102060707, 4], [975262.316052712, 63], [975262.54487017, 10], [975262.724000066, 31], [975262.910382898, 29], [975263.100307133, 22], [975263.284150725, 14], [975263.467971726, 24], [975263.644833222, 4], [975263.791968567, 13], [975263.977374122, 21], [975264.168259848, 2], [975264.349140876, 18], [975264.528282916, 29], [975264.762063482, 27], [975265.001630727, 24], [975265.153774979, 4], [975265.304801962, 16], [975265.484872118, 10], [975265.664973105, 31], [975265.813277634, 8], [975265.998511198, 11], [975266.184333763, 16], [975266.367979036, 12], [975266.549026619, 39], [975266.722538671, 18], [975266.906602956, 11], [975267.097710045, 16], [975267.278334228, 16], [975267.425389556, 11], [975267.60943895, 6], [975267.791940149, 9], [975267.977662702, 29], [975268.169146153, 22], [975268.35044867, 8], [975268.496275268, 18], [975268.679133182, 18], [975268.865301721, 34], [975269.052389751, 10], [975269.23685713, 14], [975269.419225519, 13], [975269.601471432, 2], [975269.785605849, 36], [975269.969921658, 42], [975270.164911262, 26], [975270.310654533, 17], [975270.492784459, 34], [975270.677665784, 12], [975270.862191172, 36], [975271.153070838, 50], [975271.338506037, 2], [975271.662986789, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-9b65d3d9189fd1bc38bc16443ea6eb2c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.14534145, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.867802695, "time_to_first_token": 0.228981937, "token_sha": "2b28aa2108de", "tokens_per_second": 25.841619242063697}, "seed": 1234, "sent": 975261.562876622, "speculative": {"acceptance_rate": 0.5734463276836158, "accepted": 203, "drafted": 354, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.23240842705126852, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 354, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.84564777344294, "done": 975271.662745694, "finish_reason": "length", "first": 975261.796455243, "full_response_s": 10.102924456004985, "last": 975271.662719855, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975261.796455243, 2], [975261.944092289, 7], [975262.103696387, 4], [975262.318047754, 63], [975262.544042234, 10], [975262.724472767, 31], [975262.910170763, 29], [975263.099833455, 22], [975263.284457449, 14], [975263.467875442, 24], [975263.646700237, 4], [975263.79404807, 13], [975263.978097262, 21], [975264.164556472, 2], [975264.346942946, 18], [975264.527410614, 29], [975264.762336687, 27], [975265.002340811, 24], [975265.156320096, 4], [975265.305134429, 16], [975265.484153746, 10], [975265.665423823, 31], [975265.812772422, 8], [975265.998094478, 11], [975266.185622913, 16], [975266.3678724, 12], [975266.548861905, 39], [975266.721812763, 18], [975266.906283241, 11], [975267.097260814, 16], [975267.279317358, 16], [975267.427358663, 11], [975267.610104716, 6], [975267.791805338, 9], [975267.978701942, 29], [975268.166676728, 22], [975268.350823552, 8], [975268.497048902, 18], [975268.678632049, 18], [975268.864268785, 34], [975269.052925074, 10], [975269.235974748, 14], [975269.420271238, 13], [975269.602099904, 2], [975269.786160627, 36], [975269.970388695, 42], [975270.162552825, 26], [975270.310038605, 17], [975270.493040498, 34], [975270.676052582, 12], [975270.862042377, 36], [975271.155072905, 50], [975271.340431179, 2], [975271.662719855, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-3bdca98131b5bdd2e8744ebabfeadf00", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.145164865, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.867944834, "time_to_first_token": 0.229914156, "token_sha": "2b28aa2108de", "tokens_per_second": 25.841247016440306}, "seed": 1234, "sent": 975261.559821238, "speculative": {"acceptance_rate": 0.5734463276836158, "accepted": 203, "drafted": 354, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.23663400497753173, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 354, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.841995540291812, "done": 975271.662535015, "finish_reason": "length", "first": 975261.794829643, "full_response_s": 10.105810296023265, "last": 975271.662488648, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975261.794829643, 2], [975261.945936857, 7], [975262.101247027, 4], [975262.314267966, 63], [975262.542805627, 10], [975262.722838239, 31], [975262.910734821, 29], [975263.100913589, 22], [975263.285099392, 14], [975263.464852728, 24], [975263.645672789, 4], [975263.793542858, 13], [975263.977653199, 21], [975264.165779705, 2], [975264.348836296, 18], [975264.527331097, 29], [975264.761678953, 27], [975265.002764235, 24], [975265.155425266, 4], [975265.305819858, 16], [975265.485330708, 10], [975265.666342988, 31], [975265.81301118, 8], [975265.998036848, 11], [975266.186841201, 16], [975266.368053353, 12], [975266.550040403, 39], [975266.722800884, 18], [975266.909048797, 11], [975267.099302575, 16], [975267.279616082, 16], [975267.426832732, 11], [975267.608633653, 6], [975267.792658249, 9], [975267.977828248, 29], [975268.168646812, 22], [975268.349871685, 8], [975268.496161833, 18], [975268.680147174, 18], [975268.865176094, 34], [975269.051160614, 10], [975269.236378669, 14], [975269.419707596, 13], [975269.60059593, 2], [975269.786810394, 36], [975269.970176048, 42], [975270.160686018, 26], [975270.30959507, 17], [975270.493648314, 34], [975270.675378736, 12], [975270.861978844, 36], [975271.154232921, 50], [975271.339820675, 2], [975271.662488648, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-e0e26eeade9bc84b3e0bccc079b24e29", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.144939545, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.867902643, "time_to_first_token": 0.2342033, "token_sha": "2b28aa2108de", "tokens_per_second": 25.84135750274041}, "seed": 1234, "sent": 975261.556724719, "speculative": {"acceptance_rate": 0.5686274509803921, "accepted": 203, "drafted": 357, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2381049239775166, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 357, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.242282532742454, "done": 975271.665181888, "finish_reason": "length", "first": 975261.56135625, "full_response_s": 10.108134270063601, "last": 975271.663453779, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975261.56135625, 2], [975261.649698329, 7], [975261.944306488, 4], [975262.10398412, 72], [975262.315872719, 1], [975262.543694952, 27], [975262.722735907, 30], [975262.909904389, 15], [975263.101594987, 14], [975263.283639369, 20], [975263.467263129, 14], [975263.645252854, 4], [975263.79241047, 13], [975263.977585266, 21], [975264.167415993, 2], [975264.34750574, 18], [975264.528949306, 29], [975264.762589221, 27], [975265.001924044, 24], [975265.153417217, 4], [975265.303405456, 16], [975265.485525452, 10], [975265.665697973, 31], [975265.813204709, 8], [975265.997608113, 11], [975266.184668694, 16], [975266.36814207, 12], [975266.551633925, 39], [975266.722244522, 18], [975266.908075171, 11], [975267.098993531, 16], [975267.279234417, 16], [975267.42575015, 11], [975267.607686138, 6], [975267.791661504, 9], [975267.97709418, 29], [975268.167898825, 22], [975268.349406343, 8], [975268.495447908, 18], [975268.679642906, 18], [975268.867468021, 34], [975269.051250387, 10], [975269.234315725, 14], [975269.418919931, 13], [975269.600020897, 2], [975269.786417113, 36], [975269.96829676, 42], [975270.161336985, 26], [975270.310198791, 17], [975270.49237006, 34], [975270.675144585, 12], [975270.860510901, 36], [975271.153430408, 50], [975271.340106903, 2], [975271.663453779, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-65afdff24290f2fadcc26e1db8b87729", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.002251239, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.100981429, "time_to_first_token": 0.002590906, "token_sha": "2b28aa2108de", "tokens_per_second": 25.24507165886801}, "seed": 1234, "sent": 975261.557047618, "speculative": {"acceptance_rate": 0.5580110497237569, "accepted": 202, "drafted": 362, "rounds": 54, "tokens_per_round": 4.7407407407407405}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.0043086319928988814, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 202, "drafted": 362, "rounds": 54}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.83825959348352, "done": 975271.663924305, "finish_reason": "length", "first": 975261.794793548, "full_response_s": 10.1039457450388, "last": 975271.663879315, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975261.794793548, 2], [975261.945729713, 7], [975262.103036461, 4], [975262.314972243, 63], [975262.543932847, 10], [975262.724880911, 31], [975262.910553324, 29], [975263.102747758, 22], [975263.285412948, 14], [975263.466299711, 24], [975263.646117668, 4], [975263.793140665, 13], [975263.976731059, 21], [975264.165614447, 2], [975264.347897629, 18], [975264.527952833, 29], [975264.762711681, 27], [975265.001699188, 24], [975265.154444457, 4], [975265.303129627, 16], [975265.484245854, 10], [975265.664459509, 31], [975265.811890424, 8], [975265.997462231, 11], [975266.187530166, 16], [975266.368481577, 12], [975266.549882346, 39], [975266.721328766, 18], [975266.909172969, 11], [975267.099441113, 16], [975267.278216585, 16], [975267.4276387, 11], [975267.607436884, 6], [975267.791999491, 9], [975267.977723708, 29], [975268.168967391, 22], [975268.349500211, 8], [975268.495655852, 18], [975268.67788083, 18], [975268.863884208, 34], [975269.052854437, 10], [975269.23608084, 14], [975269.418602023, 13], [975269.601849962, 2], [975269.784670637, 36], [975269.968932672, 42], [975270.160433324, 26], [975270.311087556, 17], [975270.491840608, 34], [975270.677411249, 12], [975270.861449696, 36], [975271.153786539, 50], [975271.339250409, 2], [975271.663879315, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-39fc925ccfc06ccad759f79a3c4a7be4", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.144978231, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.867863109, "time_to_first_token": 0.233019747, "token_sha": "2b28aa2108de", "tokens_per_second": 25.841461031966166}, "seed": 1234, "sent": 975261.55997856, "speculative": {"acceptance_rate": 0.5686274509803921, "accepted": 203, "drafted": 357, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2348149879835546, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 357, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.839603597705214, "done": 975271.664032717, "finish_reason": "length", "first": 975261.795400468, "full_response_s": 10.104777041007765, "last": 975271.663972911, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975261.795400468, 2], [975261.946051156, 7], [975262.101153719, 4], [975262.314528324, 63], [975262.544213828, 10], [975262.725083463, 31], [975262.909992929, 29], [975263.101314902, 22], [975263.284252001, 14], [975263.465328421, 24], [975263.64602852, 4], [975263.79343939, 13], [975263.978274871, 21], [975264.165915667, 2], [975264.347030798, 18], [975264.528331906, 29], [975264.762285745, 27], [975265.001589865, 24], [975265.156414348, 4], [975265.305479631, 16], [975265.484493125, 10], [975265.666464391, 31], [975265.813778415, 8], [975265.998628169, 11], [975266.18630351, 16], [975266.367497391, 12], [975266.548709591, 39], [975266.722836995, 18], [975266.907223972, 11], [975267.096743826, 16], [975267.278428177, 16], [975267.426046986, 11], [975267.609673229, 6], [975267.792902159, 9], [975267.978111277, 29], [975268.167177445, 22], [975268.351423096, 8], [975268.496521051, 18], [975268.679598699, 18], [975268.864521575, 34], [975269.052714618, 10], [975269.235565132, 14], [975269.418038189, 13], [975269.601532982, 2], [975269.787644298, 36], [975269.96918031, 42], [975270.161919298, 26], [975270.309758728, 17], [975270.49411772, 34], [975270.677136156, 12], [975270.860980338, 36], [975271.153241344, 50], [975271.338890902, 2], [975271.663972911, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-1f44837d000fe3c5921fac7f77c04ce3", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.145016742, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.867868565, "time_to_first_token": 0.233092, "token_sha": "2b28aa2108de", "tokens_per_second": 25.841446744077096}, "seed": 1234, "sent": 975261.559255676, "speculative": {"acceptance_rate": 0.5686274509803921, "accepted": 203, "drafted": 357, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.23614479205571115, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 357, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.84284701640728, "done": 975271.662044617, "finish_reason": "length", "first": 975261.794656609, "full_response_s": 10.105115970014594, "last": 975271.661990492, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975261.794656609, 2], [975261.943801164, 7], [975262.101737008, 4], [975262.317111311, 63], [975262.545054771, 10], [975262.724822193, 31], [975262.908861614, 29], [975263.102878313, 22], [975263.283773412, 14], [975263.465432929, 24], [975263.646924357, 4], [975263.793201479, 13], [975263.976819504, 21], [975264.16523051, 2], [975264.346549489, 18], [975264.529596913, 29], [975264.761767541, 27], [975265.002595041, 24], [975265.155120702, 4], [975265.303461182, 16], [975265.485770803, 10], [975265.666506325, 31], [975265.812131071, 8], [975265.997702509, 11], [975266.188880306, 16], [975266.366713358, 12], [975266.551461148, 39], [975266.722767574, 18], [975266.907486458, 11], [975267.098448832, 16], [975267.279569588, 16], [975267.426488313, 11], [975267.607555167, 6], [975267.791240864, 9], [975267.977891045, 29], [975268.168571743, 22], [975268.349322522, 8], [975268.495343912, 18], [975268.678286062, 18], [975268.863756613, 34], [975269.052784727, 10], [975269.23504576, 14], [975269.418282467, 13], [975269.600523117, 2], [975269.785536651, 36], [975269.96840234, 42], [975270.161077971, 26], [975270.310311826, 17], [975270.49215674, 34], [975270.677193002, 12], [975270.861346676, 36], [975271.154978364, 50], [975271.339329094, 2], [975271.661990492, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-a5ba6290dddda706b1774cce0053e531", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.144871675, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.867970673, "time_to_first_token": 0.234979446, "token_sha": "2b28aa2108de", "tokens_per_second": 25.841179351871386}, "seed": 1234, "sent": 975261.556928647, "speculative": {"acceptance_rate": 0.5654596100278552, "accepted": 203, "drafted": 359, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.23772796196863055, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 359, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.844563975875616, "done": 975271.662377101, "finish_reason": "length", "first": 975261.795639787, "full_response_s": 10.09976342797745, "last": 975271.662318143, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975261.795639787, 2], [975261.944992253, 7], [975262.101370702, 4], [975262.315240296, 63], [975262.542473832, 10], [975262.724719765, 31], [975262.908471757, 29], [975263.101442609, 22], [975263.286201621, 14], [975263.466841322, 24], [975263.647288502, 4], [975263.793035837, 13], [975263.976897069, 21], [975264.167878263, 2], [975264.348329036, 18], [975264.529140099, 29], [975264.7615991, 27], [975265.002722317, 24], [975265.155765877, 4], [975265.304653791, 16], [975265.48666072, 10], [975265.664698748, 31], [975265.814309114, 8], [975265.998401682, 11], [975266.185770491, 16], [975266.368219539, 12], [975266.549586181, 39], [975266.721459337, 18], [975266.907845788, 11], [975267.096412527, 16], [975267.278545228, 16], [975267.426680562, 11], [975267.608844637, 6], [975267.792721766, 9], [975267.977784905, 29], [975268.167987606, 22], [975268.350509612, 8], [975268.495731305, 18], [975268.679037537, 18], [975268.865687322, 34], [975269.052278251, 10], [975269.234833705, 14], [975269.418427006, 13], [975269.602140655, 2], [975269.785434975, 36], [975269.968570446, 42], [975270.163710061, 26], [975270.310425646, 17], [975270.492951845, 34], [975270.676293037, 12], [975270.861184394, 36], [975271.153150227, 50], [975271.33968228, 2], [975271.662318143, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-57013596d6fe192940b9dc22e8cbadcb", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.145380136, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.867783641, "time_to_first_token": 0.227767472, "token_sha": "2b28aa2108de", "tokens_per_second": 25.841669140422937}, "seed": 1234, "sent": 975261.562613673, "speculative": {"acceptance_rate": 0.5750708215297451, "accepted": 203, "drafted": 353, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.23302611394319683, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 353, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.842683385949094, "done": 975271.663327992, "finish_reason": "length", "first": 975261.795904928, "full_response_s": 10.103083762922324, "last": 975271.663301289, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975261.795904928, 2], [975261.944477954, 7], [975262.102716378, 4], [975262.317344326, 63], [975262.542353772, 10], [975262.722891661, 31], [975262.910911534, 29], [975263.101917966, 22], [975263.283411298, 14], [975263.46427331, 24], [975263.644951234, 4], [975263.793654261, 13], [975263.977155762, 21], [975264.16805736, 2], [975264.346261628, 18], [975264.528215687, 29], [975264.762015132, 27], [975265.002657727, 24], [975265.15354582, 4], [975265.306270097, 16], [975265.48405303, 10], [975265.667064303, 31], [975265.812489505, 8], [975265.998158716, 11], [975266.188430787, 16], [975266.367087871, 12], [975266.551544393, 39], [975266.723401901, 18], [975266.907075066, 11], [975267.097987554, 16], [975267.280319895, 16], [975267.42697295, 11], [975267.608275235, 6], [975267.79304105, 9], [975267.979034057, 29], [975268.166983388, 22], [975268.349978545, 8], [975268.495133745, 18], [975268.677713893, 18], [975268.865922769, 34], [975269.051499225, 10], [975269.236316639, 14], [975269.419360858, 13], [975269.600407138, 2], [975269.785853215, 36], [975269.967870601, 42], [975270.16160371, 26], [975270.311279725, 17], [975270.493357557, 34], [975270.67676721, 12], [975270.860783738, 36], [975271.154574652, 50], [975271.33884876, 2], [975271.663301289, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-0621aaf975e01d83f963a0a5c5967c48", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.145131361, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.86780412, "time_to_first_token": 0.230762091, "token_sha": "2b28aa2108de", "tokens_per_second": 25.84161551030058}, "seed": 1234, "sent": 975261.560244229, "speculative": {"acceptance_rate": 0.571830985915493, "accepted": 203, "drafted": 355, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2356606989633292, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 355, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.841721764983753, "done": 975271.663682122, "finish_reason": "length", "first": 975261.794916007, "full_response_s": 10.104533690027893, "last": 975271.662679553, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975261.794916007, 2], [975261.943893144, 7], [975262.101843228, 4], [975262.314808569, 63], [975262.543048289, 10], [975262.724578651, 31], [975262.909026087, 29], [975263.102476504, 22], [975263.283203322, 14], [975263.465700646, 24], [975263.646557059, 4], [975263.792764296, 13], [975263.976124987, 21], [975264.16749631, 2], [975264.346832454, 18], [975264.529504516, 29], [975264.762516712, 27], [975265.001518395, 24], [975265.15501181, 4], [975265.302971265, 16], [975265.48640633, 10], [975265.667124237, 31], [975265.813955784, 8], [975265.997878086, 11], [975266.18593874, 16], [975266.367627434, 12], [975266.551377775, 39], [975266.723719265, 18], [975266.910058998, 11], [975267.097884646, 16], [975267.280665578, 16], [975267.425979613, 11], [975267.608716594, 6], [975267.792477024, 9], [975267.977964386, 29], [975268.167316288, 22], [975268.351284446, 8], [975268.496243766, 18], [975268.678098982, 18], [975268.866551912, 34], [975269.051058442, 10], [975269.234502597, 14], [975269.420579642, 13], [975269.600296118, 2], [975269.786739773, 36], [975269.968994893, 42], [975270.160573702, 26], [975270.310836558, 17], [975270.491697414, 34], [975270.675809167, 12], [975270.861538253, 36], [975271.155248818, 50], [975271.338183442, 2], [975271.662679553, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-40c254ebafe3ad439b83f4c1ed8df44f", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.145457669, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.867633758, "time_to_first_token": 0.227252036, "token_sha": "2b28aa2108de", "tokens_per_second": 25.842061658729836}, "seed": 1234, "sent": 975261.559148432, "speculative": {"acceptance_rate": 0.5750708215297451, "accepted": 203, "drafted": 353, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.235767574980855, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 353, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.8414154420214, "done": 975271.664416286, "finish_reason": "length", "first": 975261.796506697, "full_response_s": 10.102700834046118, "last": 975271.664387215, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975261.796506697, 2], [975261.943969653, 7], [975262.103502619, 4], [975262.318185701, 63], [975262.544763886, 10], [975262.723067718, 31], [975262.909611536, 29], [975263.100058231, 22], [975263.286776398, 14], [975263.466205763, 24], [975263.647744197, 4], [975263.793881756, 13], [975263.976242134, 21], [975264.166095308, 2], [975264.347662582, 18], [975264.529072373, 29], [975264.761920463, 27], [975265.002888374, 24], [975265.156033499, 4], [975265.30324175, 16], [975265.48435961, 10], [975265.665831071, 31], [975265.813387662, 8], [975265.997951092, 11], [975266.18497785, 16], [975266.366363579, 12], [975266.549271281, 39], [975266.721642689, 18], [975266.907977559, 11], [975267.096041054, 16], [975267.279074552, 16], [975267.427593246, 11], [975267.610163786, 6], [975267.791486342, 9], [975267.977226911, 29], [975268.166767189, 22], [975268.349817831, 8], [975268.495848261, 18], [975268.677996554, 18], [975268.867797656, 34], [975269.052995087, 10], [975269.235152652, 14], [975269.41853633, 13], [975269.601015018, 2], [975269.785220584, 36], [975269.969468987, 42], [975270.162935435, 26], [975270.311571138, 17], [975270.491568891, 34], [975270.675876893, 12], [975270.862815995, 36], [975271.154532606, 50], [975271.337782321, 2], [975271.664387215, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-a0b4a78833fa056e75792250471ca2f1", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.145420374, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.867752986, "time_to_first_token": 0.227660484, "token_sha": "2b28aa2108de", "tokens_per_second": 25.84174941972955}, "seed": 1234, "sent": 975261.561715452, "speculative": {"acceptance_rate": 0.5750708215297451, "accepted": 203, "drafted": 353, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.23479124496225268, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 353, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.840890133378394, "done": 975271.66415316, "finish_reason": "length", "first": 975261.796044763, "full_response_s": 10.107533220900223, "last": 975271.664125881, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975261.796044763, 2], [975261.944946255, 7], [975262.101922121, 4], [975262.3151403, 63], [975262.543764437, 10], [975262.722923692, 31], [975262.909491141, 29], [975263.101042272, 22], [975263.285490273, 14], [975263.467020003, 24], [975263.645567226, 4], [975263.793253093, 13], [975263.976410335, 21], [975264.166928044, 2], [975264.348080229, 18], [975264.528664309, 29], [975264.76292724, 27], [975265.002548707, 24], [975265.153857439, 4], [975265.302646718, 16], [975265.485953228, 10], [975265.6653001, 31], [975265.814052804, 8], [975265.99779233, 11], [975266.188728056, 16], [975266.368400172, 12], [975266.550961968, 39], [975266.722470817, 18], [975266.909775873, 11], [975267.098780515, 16], [975267.280032578, 16], [975267.425892704, 11], [975267.610236743, 6], [975267.792087295, 9], [975267.978058031, 29], [975268.1660676, 22], [975268.348975991, 8], [975268.496415871, 18], [975268.680838811, 18], [975268.86815065, 34], [975269.051330672, 10], [975269.234631056, 14], [975269.419926196, 13], [975269.601191907, 2], [975269.784884421, 36], [975269.968686297, 42], [975270.161667308, 26], [975270.309307257, 17], [975270.491959659, 34], [975270.676232415, 12], [975270.861931998, 36], [975271.154438401, 50], [975271.340378941, 2], [975271.664125881, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-aedab48ed4169acc4d7cdc9fa22deff9", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.145054948, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.867895508, "time_to_first_token": 0.232134549, "token_sha": "2b28aa2108de", "tokens_per_second": 25.841376187381492}, "seed": 1234, "sent": 975261.556619939, "speculative": {"acceptance_rate": 0.5686274509803921, "accepted": 203, "drafted": 357, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2394248238997534, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 357, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.719119605037537, "done": 975281.721708012, "finish_reason": "length", "first": 975271.806874042, "full_response_s": 10.04077172500547, "last": 975281.721676878, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975271.806874042, 2], [975271.991680602, 7], [975272.145132965, 4], [975272.355894715, 63], [975272.588731212, 10], [975272.772693501, 31], [975272.954226338, 29], [975273.145605693, 22], [975273.328680648, 14], [975273.510915556, 24], [975273.692305344, 4], [975273.839342011, 13], [975274.02760487, 21], [975274.213637736, 2], [975274.395387695, 18], [975274.578126688, 29], [975274.812840654, 27], [975275.056228874, 24], [975275.206408616, 4], [975275.353182201, 16], [975275.53617212, 10], [975275.719908811, 31], [975275.865956138, 8], [975276.057791086, 11], [975276.240844996, 16], [975276.423120135, 12], [975276.604470398, 39], [975276.778254231, 18], [975276.961628712, 11], [975277.15205697, 16], [975277.335410877, 16], [975277.483590501, 11], [975277.66451602, 6], [975277.850155297, 9], [975278.036953735, 29], [975278.221959123, 22], [975278.404414432, 8], [975278.551290449, 18], [975278.73286112, 18], [975278.917986683, 34], [975279.111139543, 10], [975279.293799781, 14], [975279.478839128, 13], [975279.661465878, 2], [975279.843033231, 36], [975280.0309575, 42], [975280.217739012, 26], [975280.368086878, 17], [975280.550440784, 34], [975280.732056382, 12], [975280.919091105, 36], [975281.211463552, 50], [975281.397478846, 2], [975281.721676878, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-aa564f7308a634a354ed4254d9e6c1bf", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.034502458, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.912324418, "time_to_first_token": 0.123084857, "token_sha": "2b28aa2108de", "tokens_per_second": 25.725550259123892}, "seed": 1234, "sent": 975271.680936287, "speculative": {"acceptance_rate": 0.5670391061452514, "accepted": 203, "drafted": 358, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1259377549868077, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 358, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.723591914794074, "done": 975281.720816079, "finish_reason": "length", "first": 975271.807700762, "full_response_s": 10.039505053893663, "last": 975281.720779808, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975271.807700762, 2], [975271.991256651, 7], [975272.144672103, 4], [975272.356589888, 63], [975272.588281725, 10], [975272.772536595, 31], [975272.952918692, 29], [975273.145658171, 22], [975273.327768603, 14], [975273.51164636, 24], [975273.69323982, 4], [975273.838837198, 13], [975274.028108835, 21], [975274.214590084, 2], [975274.395272244, 18], [975274.57723389, 29], [975274.813559459, 27], [975275.056542958, 24], [975275.208144565, 4], [975275.352859909, 16], [975275.538327573, 10], [975275.717024682, 31], [975275.868243778, 8], [975276.057192005, 11], [975276.241338433, 16], [975276.422209258, 12], [975276.605793883, 39], [975276.779438762, 18], [975276.961985178, 11], [975277.151255193, 16], [975277.335709137, 16], [975277.483741695, 11], [975277.665217178, 6], [975277.848873938, 9], [975278.036609253, 29], [975278.222868048, 22], [975278.406681417, 8], [975278.551656227, 18], [975278.732573387, 18], [975278.919270778, 34], [975279.112493492, 10], [975279.298263386, 14], [975279.478274733, 13], [975279.663257762, 2], [975279.844709631, 36], [975280.030384594, 42], [975280.217207113, 26], [975280.370138304, 17], [975280.55278159, 34], [975280.733707006, 12], [975280.919652076, 36], [975281.211560205, 50], [975281.397219992, 2], [975281.720779808, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-86d697236b3827864bbc4f3bb6b79465", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.034533769, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.912446733, "time_to_first_token": 0.122653066, "token_sha": "2b28aa2108de", "tokens_per_second": 25.72523281775299}, "seed": 1234, "sent": 975271.681311025, "speculative": {"acceptance_rate": 0.5670391061452514, "accepted": 203, "drafted": 358, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12638973689172417, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 358, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.72638174772439, "done": 975281.719337815, "finish_reason": "length", "first": 975271.807312073, "full_response_s": 10.03790138696786, "last": 975281.71931612, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975271.807312073, 2], [975271.991336024, 7], [975272.146607548, 4], [975272.357062894, 63], [975272.588551555, 10], [975272.771507771, 31], [975272.954423898, 29], [975273.145536319, 22], [975273.330144496, 14], [975273.512320862, 24], [975273.693971696, 4], [975273.838704595, 13], [975274.028269101, 21], [975274.214258416, 2], [975274.395653349, 18], [975274.579761489, 29], [975274.813843752, 27], [975275.056772373, 24], [975275.205594887, 4], [975275.355359605, 16], [975275.53795258, 10], [975275.719497595, 31], [975275.866291917, 8], [975276.056774677, 11], [975276.240237467, 16], [975276.423347182, 12], [975276.605614338, 39], [975276.77922397, 18], [975276.961907469, 11], [975277.153275019, 16], [975277.335283649, 16], [975277.481924501, 11], [975277.664863079, 6], [975277.850663853, 9], [975278.037416022, 29], [975278.223622963, 22], [975278.404935676, 8], [975278.551376254, 18], [975278.733280432, 18], [975278.920616791, 34], [975279.111441148, 10], [975279.295658238, 14], [975279.479220617, 13], [975279.66044195, 2], [975279.841969064, 36], [975280.0316876, 42], [975280.21843065, 26], [975280.370934321, 17], [975280.551701695, 34], [975280.733195458, 12], [975280.920879613, 36], [975281.210613681, 50], [975281.397813106, 2], [975281.71931612, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-5306bad6edc9e758eeebb9b46aeba423", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.034428765, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.912482076, "time_to_first_token": 0.123245139, "token_sha": "2b28aa2108de", "tokens_per_second": 25.725141094318182}, "seed": 1234, "sent": 975271.681436428, "speculative": {"acceptance_rate": 0.5654596100278552, "accepted": 203, "drafted": 359, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12587564496789128, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 359, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.725831168159562, "done": 975281.719058082, "finish_reason": "length", "first": 975271.806823596, "full_response_s": 10.037662228918634, "last": 975281.719039778, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975271.806823596, 2], [975271.99101874, 7], [975272.143243934, 4], [975272.357973082, 63], [975272.589520318, 10], [975272.772250974, 31], [975272.952603392, 29], [975273.144753998, 22], [975273.330655516, 14], [975273.512877816, 24], [975273.694049485, 4], [975273.839091668, 13], [975274.027776448, 21], [975274.214174692, 2], [975274.396281053, 18], [975274.576738757, 29], [975274.814222857, 27], [975275.056811316, 24], [975275.206966178, 4], [975275.355429474, 16], [975275.535675995, 10], [975275.719778896, 31], [975275.868576166, 8], [975276.056499232, 11], [975276.239977077, 16], [975276.423769486, 12], [975276.60426831, 39], [975276.778672295, 18], [975276.96181984, 11], [975277.151042065, 16], [975277.333809706, 16], [975277.482928942, 11], [975277.666525143, 6], [975277.850402311, 9], [975278.036560774, 29], [975278.222137292, 22], [975278.405161203, 8], [975278.552873188, 18], [975278.73363053, 18], [975278.919181838, 34], [975279.111216164, 10], [975279.294072331, 14], [975279.477812143, 13], [975279.661902006, 2], [975279.843960444, 36], [975280.031613459, 42], [975280.217923437, 26], [975280.370873987, 17], [975280.550187881, 34], [975280.732270885, 12], [975280.91974332, 36], [975281.210174689, 50], [975281.397714357, 2], [975281.719039778, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-4a39b9c9d913e9b99476d332bd1647b2", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.034154184, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.912767808, "time_to_first_token": 0.123860315, "token_sha": "2b28aa2108de", "tokens_per_second": 25.724399576292384}, "seed": 1234, "sent": 975271.681395853, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12542774295434356, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.72036723518126, "done": 975281.723317743, "finish_reason": "length", "first": 975271.807651084, "full_response_s": 10.04230745905079, "last": 975281.721972978, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975271.807651084, 2], [975271.990805212, 7], [975272.144542492, 4], [975272.357766482, 63], [975272.589825922, 10], [975272.771049644, 31], [975272.953468719, 29], [975273.144693296, 22], [975273.328503919, 14], [975273.509957609, 24], [975273.69349597, 4], [975273.838969689, 13], [975274.028051461, 21], [975274.213349987, 2], [975274.397960812, 18], [975274.577499912, 29], [975274.813027783, 27], [975275.05715887, 24], [975275.207937933, 4], [975275.354268239, 16], [975275.53663447, 10], [975275.718095729, 31], [975275.866999874, 8], [975276.055863336, 11], [975276.241966937, 16], [975276.424250988, 12], [975276.605858264, 39], [975276.778586443, 18], [975276.960981488, 11], [975277.150402714, 16], [975277.334738006, 16], [975277.481842856, 11], [975277.667677499, 6], [975277.849632917, 9], [975278.038138794, 29], [975278.221103044, 22], [975278.40388834, 8], [975278.552778904, 18], [975278.733353501, 18], [975278.918162789, 34], [975279.111943577, 10], [975279.29439099, 14], [975279.476124383, 13], [975279.660026669, 2], [975279.844490792, 36], [975280.030536204, 42], [975280.217380818, 26], [975280.370692394, 17], [975280.550064718, 34], [975280.731923779, 12], [975280.918632675, 36], [975281.212259474, 50], [975281.396119714, 2], [975281.721972978, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-2ce9365d19f660c4ad4994ec16cbafd2", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.03398307, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.913165154, "time_to_first_token": 0.124353273, "token_sha": "2b28aa2108de", "tokens_per_second": 25.72336847400414}, "seed": 1234, "sent": 975271.681010284, "speculative": {"acceptance_rate": 0.5576923076923077, "accepted": 203, "drafted": 364, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12664080003742129, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 364, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.727386013755908, "done": 975281.720277891, "finish_reason": "length", "first": 975271.807224989, "full_response_s": 10.038583361078054, "last": 975281.718842122, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975271.807224989, 2], [975271.99097367, 7], [975272.143870966, 4], [975272.356892932, 63], [975272.587980873, 10], [975272.772167521, 31], [975272.952687325, 29], [975273.144626674, 22], [975273.329490153, 14], [975273.510710284, 24], [975273.69304242, 4], [975273.839458486, 13], [975274.028418791, 21], [975274.213119788, 2], [975274.395959721, 18], [975274.576597435, 29], [975274.813699917, 27], [975275.057234627, 24], [975275.206889109, 4], [975275.354678447, 16], [975275.536301139, 10], [975275.71743289, 31], [975275.868281809, 8], [975276.056291512, 11], [975276.240537087, 16], [975276.426019208, 12], [975276.606384244, 39], [975276.778996715, 18], [975276.961940684, 11], [975277.150696782, 16], [975277.334098607, 16], [975277.482563948, 11], [975277.665989852, 6], [975277.848592717, 9], [975278.036891114, 29], [975278.223489192, 22], [975278.405413146, 8], [975278.550094815, 18], [975278.73274882, 18], [975278.920259525, 34], [975279.107344473, 10], [975279.296106893, 14], [975279.476755335, 13], [975279.659840485, 2], [975279.841664132, 36], [975280.031446217, 42], [975280.218354989, 26], [975280.36892123, 17], [975280.550541772, 34], [975280.732650583, 12], [975280.918795404, 36], [975281.209970665, 50], [975281.395723713, 2], [975281.718842122, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-f9faebf3fc07e5d87a4da9327e2c3558", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.034230373, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.912628406, "time_to_first_token": 0.123773567, "token_sha": "2b28aa2108de", "tokens_per_second": 25.724761340357663}, "seed": 1234, "sent": 975271.68169453, "speculative": {"acceptance_rate": 0.5638888888888889, "accepted": 203, "drafted": 360, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1255304591031745, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 360, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.405761058819326, "done": 975281.722030112, "finish_reason": "length", "first": 975271.684913253, "full_response_s": 10.040951542090625, "last": 975281.722006785, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975271.684913253, 2], [975271.773188337, 7], [975271.991867363, 4], [975272.143403544, 72], [975272.356955154, 1], [975272.587452446, 27], [975272.770980591, 30], [975272.953539132, 15], [975273.144819739, 14], [975273.330607758, 20], [975273.510138066, 14], [975273.691894048, 4], [975273.838519658, 13], [975274.028821032, 21], [975274.21281916, 2], [975274.397815793, 18], [975274.580032342, 29], [975274.814356164, 27], [975275.056117214, 24], [975275.205762737, 4], [975275.353913261, 16], [975275.534759103, 10], [975275.717318479, 31], [975275.867554253, 8], [975276.055801131, 11], [975276.242439334, 16], [975276.421972531, 12], [975276.604552043, 39], [975276.77804416, 18], [975276.960854501, 11], [975277.150290046, 16], [975277.335113976, 16], [975277.482882928, 11], [975277.665603275, 6], [975277.85033841, 9], [975278.036017771, 29], [975278.221767466, 22], [975278.40758871, 8], [975278.550775765, 18], [975278.733573941, 18], [975278.918641186, 34], [975279.112351561, 10], [975279.296220952, 14], [975279.478047654, 13], [975279.663584213, 2], [975279.843407649, 36], [975280.030621417, 42], [975280.21811271, 26], [975280.368436945, 17], [975280.550638216, 34], [975280.732898093, 12], [975280.920635254, 36], [975281.210487798, 50], [975281.397899534, 2], [975281.722006785, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-3b1e2a6570a60b5a950fd08b1192ec69", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.00233471, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.03405496, "time_to_first_token": 0.002618203, "token_sha": "2b28aa2108de", "tokens_per_second": 25.41345458207456}, "seed": 1234, "sent": 975271.68107857, "speculative": {"acceptance_rate": 0.5489130434782609, "accepted": 202, "drafted": 368, "rounds": 54, "tokens_per_round": 4.7407407407407405}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.003834682982414961, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 202, "drafted": 368, "rounds": 54}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.723919324738837, "done": 975281.720488123, "finish_reason": "length", "first": 975271.80751349, "full_response_s": 10.038707021041773, "last": 975281.720466364, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975271.80751349, 2], [975271.991468067, 7], [975272.145898119, 4], [975272.358029272, 63], [975272.587600328, 10], [975272.77261088, 31], [975272.953860208, 29], [975273.145081873, 22], [975273.328880912, 14], [975273.511053022, 24], [975273.694520347, 4], [975273.838762929, 13], [975274.029144571, 21], [975274.213226648, 2], [975274.396993137, 18], [975274.579054268, 29], [975274.81482381, 27], [975275.057899066, 24], [975275.205956937, 4], [975275.355113151, 16], [975275.535594111, 10], [975275.719606023, 31], [975275.867261432, 8], [975276.05592335, 11], [975276.2433377, 16], [975276.425948682, 12], [975276.604723044, 39], [975276.779545686, 18], [975276.96238889, 11], [975277.151193355, 16], [975277.335357823, 16], [975277.482808051, 11], [975277.665073567, 6], [975277.851619337, 9], [975278.037910483, 29], [975278.220732898, 22], [975278.404289621, 8], [975278.552118289, 18], [975278.732940237, 18], [975278.91845553, 34], [975279.111511225, 10], [975279.295185632, 14], [975279.477052012, 13], [975279.663529687, 2], [975279.842942467, 36], [975280.03084648, 42], [975280.218687168, 26], [975280.367754763, 17], [975280.550323444, 34], [975280.732998361, 12], [975280.920391471, 36], [975281.21109875, 50], [975281.396023862, 2], [975281.720466364, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-5b9ac049841348f38a513264881431d6", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.034373807, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.912696964, "time_to_first_token": 0.122929424, "token_sha": "2b28aa2108de", "tokens_per_second": 25.724583423268662}, "seed": 1234, "sent": 975271.681781102, "speculative": {"acceptance_rate": 0.5654596100278552, "accepted": 203, "drafted": 359, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12573238799814135, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 359, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.723788252820075, "done": 975281.720022685, "finish_reason": "length", "first": 975271.806966055, "full_response_s": 10.038886758033186, "last": 975281.719969439, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975271.806966055, 2], [975271.9907148, 7], [975272.145476104, 4], [975272.357440463, 63], [975272.589211738, 10], [975272.77203807, 31], [975272.954149365, 29], [975273.145251338, 22], [975273.32993084, 14], [975273.511203321, 24], [975273.692585269, 4], [975273.839125971, 13], [975274.027957049, 21], [975274.214311966, 2], [975274.396576609, 18], [975274.577907032, 29], [975274.816043043, 27], [975275.056701976, 24], [975275.205679604, 4], [975275.355219514, 16], [975275.536759266, 10], [975275.718635388, 31], [975275.867981069, 8], [975276.057999718, 11], [975276.243588106, 16], [975276.42417483, 12], [975276.60633103, 39], [975276.779727855, 18], [975276.961333683, 11], [975277.15158766, 16], [975277.334621195, 16], [975277.482135869, 11], [975277.667296986, 6], [975277.85006442, 9], [975278.037763736, 29], [975278.221263357, 22], [975278.404125371, 8], [975278.55068116, 18], [975278.732897183, 18], [975278.919457555, 34], [975279.113202328, 10], [975279.295448966, 14], [975279.478483045, 13], [975279.662565356, 2], [975279.843551964, 36], [975280.030452015, 42], [975280.217549915, 26], [975280.370808838, 17], [975280.554387065, 34], [975280.731851653, 12], [975280.919177342, 36], [975281.211163324, 50], [975281.396618287, 2], [975281.719969439, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-391ad5fad249656673944cbd52301aaa", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.034465915, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.912528282, "time_to_first_token": 0.123284913, "token_sha": "2b28aa2108de", "tokens_per_second": 25.725021179818512}, "seed": 1234, "sent": 975271.681135927, "speculative": {"acceptance_rate": 0.5670391061452514, "accepted": 203, "drafted": 358, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1258301279740408, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 358, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.723866638789254, "done": 975281.719731704, "finish_reason": "length", "first": 975271.806724512, "full_response_s": 10.038564529968426, "last": 975281.719697689, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975271.806724512, 2], [975271.991410069, 7], [975272.142845005, 4], [975272.356342489, 63], [975272.589486783, 10], [975272.771644357, 31], [975272.954080647, 29], [975273.145429668, 22], [975273.328809699, 14], [975273.511871023, 24], [975273.692099768, 4], [975273.838921563, 13], [975274.028188432, 21], [975274.21343152, 2], [975274.396869526, 18], [975274.57869017, 29], [975274.814065359, 27], [975275.056422547, 24], [975275.206140242, 4], [975275.353335011, 16], [975275.537439575, 10], [975275.717615203, 31], [975275.866936085, 8], [975276.057373582, 11], [975276.243089309, 16], [975276.424429109, 12], [975276.605209569, 39], [975276.778967564, 18], [975276.962651904, 11], [975277.15273616, 16], [975277.335958536, 16], [975277.481543267, 11], [975277.667083586, 6], [975277.850114466, 9], [975278.036179013, 29], [975278.222944413, 22], [975278.404875998, 8], [975278.551553751, 18], [975278.733526918, 18], [975278.918306271, 34], [975279.111282642, 10], [975279.296472895, 14], [975279.476443075, 13], [975279.662390531, 2], [975279.8418635, 36], [975280.031760413, 42], [975280.218075703, 26], [975280.366745441, 17], [975280.554122979, 34], [975280.732749171, 12], [975280.91922798, 36], [975281.210840616, 50], [975281.396367817, 2], [975281.719697689, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-deee3ef2b530333f3f53db46763b92c8", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.034338848, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.91254257, "time_to_first_token": 0.12348297, "token_sha": "2b28aa2108de", "tokens_per_second": 25.724984099614314}, "seed": 1234, "sent": 975271.681167174, "speculative": {"acceptance_rate": 0.5654596100278552, "accepted": 203, "drafted": 359, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12555733800400048, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 359, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.726582153991128, "done": 975281.71899514, "finish_reason": "length", "first": 975271.807029124, "full_response_s": 10.037446957081556, "last": 975281.718955958, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975271.807029124, 2], [975271.991744088, 7], [975272.144958156, 4], [975272.356475332, 63], [975272.588058678, 10], [975272.771602071, 31], [975272.9537409, 29], [975273.145333159, 22], [975273.328171404, 14], [975273.510381864, 24], [975273.693759352, 4], [975273.839388905, 13], [975274.028875766, 21], [975274.213743572, 2], [975274.394929105, 18], [975274.57808213, 29], [975274.814626634, 27], [975275.057976199, 24], [975275.206765802, 4], [975275.354763644, 16], [975275.53805328, 10], [975275.717504615, 31], [975275.866152595, 8], [975276.056870978, 11], [975276.243732709, 16], [975276.423212099, 12], [975276.604183001, 39], [975276.778516973, 18], [975276.962556228, 11], [975277.151512799, 16], [975277.334234906, 16], [975277.481454759, 11], [975277.665770116, 6], [975277.850982465, 9], [975278.036722112, 29], [975278.220972761, 22], [975278.405501798, 8], [975278.552414742, 18], [975278.732678807, 18], [975278.919131472, 34], [975279.112974737, 10], [975279.296850672, 14], [975279.479500094, 13], [975279.661028487, 2], [975279.842119458, 36], [975280.03133627, 42], [975280.217491102, 26], [975280.367541443, 17], [975280.549832023, 34], [975280.732214567, 12], [975280.91959723, 36], [975281.210737276, 50], [975281.396691068, 2], [975281.718955958, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-269bc1e2b7dab1f797c92dce7d9df770", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.034266803, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.912615575, "time_to_first_token": 0.12353356, "token_sha": "2b28aa2108de", "tokens_per_second": 25.724794638775244}, "seed": 1234, "sent": 975271.681548183, "speculative": {"acceptance_rate": 0.5654596100278552, "accepted": 203, "drafted": 359, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12548094103112817, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 359, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.720150903946518, "done": 975281.721218335, "finish_reason": "length", "first": 975271.806775134, "full_response_s": 10.040019370033406, "last": 975281.721180417, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975271.806775134, 2], [975271.990857306, 7], [975272.142691267, 4], [975272.355686979, 63], [975272.588508469, 10], [975272.771454557, 31], [975272.953179242, 29], [975273.144554213, 22], [975273.327584434, 14], [975273.510446438, 24], [975273.693715194, 4], [975273.839256686, 13], [975274.02849458, 21], [975274.213830305, 2], [975274.395558489, 18], [975274.577061193, 29], [975274.815638771, 27], [975275.056844162, 24], [975275.207794627, 4], [975275.353542667, 16], [975275.536487004, 10], [975275.717146389, 31], [975275.86778306, 8], [975276.056026946, 11], [975276.242060373, 16], [975276.422129581, 12], [975276.604630904, 39], [975276.778158747, 18], [975276.961665494, 11], [975277.152548759, 16], [975277.333474295, 16], [975277.483220019, 11], [975277.666825308, 6], [975277.849124936, 9], [975278.03646945, 29], [975278.22234138, 22], [975278.405118917, 8], [975278.551613173, 18], [975278.732405601, 18], [975278.919373142, 34], [975279.112601839, 10], [975279.29533753, 14], [975279.480104503, 13], [975279.662881296, 2], [975279.842800232, 36], [975280.031052328, 42], [975280.217292789, 26], [975280.368024272, 17], [975280.553457884, 34], [975280.733639425, 12], [975280.921366842, 36], [975281.211235305, 50], [975281.395829677, 2], [975281.721180417, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-eda67054dd29fb522ed27758e2f2f162", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.034117177, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.91267682, "time_to_first_token": 0.12378907, "token_sha": "2b28aa2108de", "tokens_per_second": 25.724635699360974}, "seed": 1234, "sent": 975271.681198965, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12557616911362857, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.7240127390452, "done": 975281.720736946, "finish_reason": "length", "first": 975271.807794407, "full_response_s": 10.039141179993749, "last": 975281.720711283, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975271.807794407, 2], [975271.99178063, 7], [975272.145077095, 4], [975272.358470231, 63], [975272.588409465, 10], [975272.770894418, 31], [975272.953577867, 29], [975273.144427722, 22], [975273.330428325, 14], [975273.512105574, 24], [975273.693322249, 4], [975273.838634278, 13], [975274.027683523, 21], [975274.213040223, 2], [975274.396187648, 18], [975274.577184772, 29], [975274.814893791, 27], [975275.057507657, 24], [975275.207872256, 4], [975275.354584611, 16], [975275.537570354, 10], [975275.72000004, 31], [975275.868195124, 8], [975276.055693311, 11], [975276.241609526, 16], [975276.42527778, 12], [975276.604811377, 39], [975276.7791781, 18], [975276.961724532, 11], [975277.152167862, 16], [975277.333599426, 16], [975277.481344587, 11], [975277.664392665, 6], [975277.84930021, 9], [975278.036660195, 29], [975278.220561912, 22], [975278.404717012, 8], [975278.551759903, 18], [975278.733686816, 18], [975278.919523713, 34], [975279.113415312, 10], [975279.296158411, 14], [975279.476669755, 13], [975279.660857294, 2], [975279.843884367, 36], [975280.031104406, 42], [975280.217686262, 26], [975280.369512727, 17], [975280.549479908, 34], [975280.732165545, 12], [975280.921567443, 36], [975281.211890688, 50], [975281.396961554, 2], [975281.720711283, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-1ef45151f225b8a24821ac9dbbf71e2b", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.034043628, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.912752017, "time_to_first_token": 0.124127057, "token_sha": "2b28aa2108de", "tokens_per_second": 25.724440555224675}, "seed": 1234, "sent": 975271.681595766, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12619864102452993, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.726413558163948, "done": 975281.719406132, "finish_reason": "length", "first": 975271.807401702, "full_response_s": 10.038176159956492, "last": 975281.719393493, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975271.807401702, 2], [975271.991583726, 7], [975272.144878447, 4], [975272.35766719, 63], [975272.587708004, 10], [975272.771542345, 31], [975272.953388354, 29], [975273.145168846, 22], [975273.330092914, 14], [975273.512611458, 24], [975273.693672539, 4], [975273.83929366, 13], [975274.028340458, 21], [975274.212926404, 2], [975274.397686166, 18], [975274.579413022, 29], [975274.813185729, 27], [975275.05633591, 24], [975275.207384706, 4], [975275.35498266, 16], [975275.537210576, 10], [975275.718373334, 31], [975275.866558883, 8], [975276.057587462, 11], [975276.24380413, 16], [975276.423857851, 12], [975276.605278319, 39], [975276.778354036, 18], [975276.961069085, 11], [975277.151716919, 16], [975277.334357109, 16], [975277.482471456, 11], [975277.667485618, 6], [975277.851371266, 9], [975278.037023813, 29], [975278.222627033, 22], [975278.406422643, 8], [975278.552045012, 18], [975278.733025306, 18], [975278.918580629, 34], [975279.113842032, 10], [975279.297768445, 14], [975279.475825931, 13], [975279.663773342, 2], [975279.842398136, 36], [975280.030308645, 42], [975280.217993755, 26], [975280.369837915, 17], [975280.550940621, 34], [975280.733120181, 12], [975280.920149145, 36], [975281.211414338, 50], [975281.39716321, 2], [975281.719393493, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-ab61d92c0ea75dbc9fadb5db5e0cfc15", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.034080619, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.912874268, "time_to_first_token": 0.123932761, "token_sha": "2b28aa2108de", "tokens_per_second": 25.72412330732086}, "seed": 1234, "sent": 975271.681229972, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12617172999307513, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.725643812567107, "done": 975281.719375366, "finish_reason": "length", "first": 975271.807073747, "full_response_s": 10.037741458043456, "last": 975281.719362118, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975271.807073747, 2], [975271.9915272, 7], [975272.146517104, 4], [975272.357136651, 63], [975272.587544522, 10], [975272.772321755, 31], [975272.953785699, 29], [975273.145209164, 22], [975273.329078441, 14], [975273.511401681, 24], [975273.694240645, 4], [975273.839029271, 13], [975274.028549074, 21], [975274.214754237, 2], [975274.397069614, 18], [975274.57967346, 29], [975274.814123773, 27], [975275.056871841, 24], [975275.20511185, 4], [975275.354019337, 16], [975275.535322169, 10], [975275.718932385, 31], [975275.866496997, 8], [975276.056435394, 11], [975276.24113868, 16], [975276.423985878, 12], [975276.605726814, 39], [975276.779667985, 18], [975276.96113593, 11], [975277.152298321, 16], [975277.336282075, 16], [975277.483015563, 11], [975277.665708871, 6], [975277.851540204, 9], [975278.037843973, 29], [975278.221858103, 22], [975278.407323136, 8], [975278.553197848, 18], [975278.732243128, 18], [975278.91933044, 34], [975279.113596489, 10], [975279.296927229, 14], [975279.476920753, 13], [975279.662629082, 2], [975279.843491198, 36], [975280.030175226, 42], [975280.217871695, 26], [975280.367151378, 17], [975280.552491521, 34], [975280.732688293, 12], [975280.91990741, 36], [975281.211644825, 50], [975281.396223934, 2], [975281.719362118, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-92d5c968c8ad78934cea4abb693335e9", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.034302578, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.91272117, "time_to_first_token": 0.123562631, "token_sha": "2b28aa2108de", "tokens_per_second": 25.724520606080965}, "seed": 1234, "sent": 975271.681633908, "speculative": {"acceptance_rate": 0.5654596100278552, "accepted": 203, "drafted": 359, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12543983908835799, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 359, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.728215669052517, "done": 975281.720355328, "finish_reason": "length", "first": 975271.807471091, "full_response_s": 10.039535084040835, "last": 975281.718768605, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975271.807471091, 2], [975271.990927447, 7], [975272.144770723, 4], [975272.356072548, 63], [975272.588799897, 10], [975272.771397983, 31], [975272.95286927, 29], [975273.145471922, 22], [975273.32791375, 14], [975273.511149803, 24], [975273.692788845, 4], [975273.839188416, 13], [975274.027858765, 21], [975274.214846426, 2], [975274.395485435, 18], [975274.578244939, 29], [975274.813921621, 27], [975275.057816285, 24], [975275.205360256, 4], [975275.35383264, 16], [975275.534654835, 10], [975275.719192599, 31], [975275.866858344, 8], [975276.056126318, 11], [975276.243190458, 16], [975276.425725267, 12], [975276.605050775, 39], [975276.778429665, 18], [975276.961409008, 11], [975277.152923017, 16], [975277.335552743, 16], [975277.483636819, 11], [975277.666283793, 6], [975277.849554088, 9], [975278.03724542, 29], [975278.223417995, 22], [975278.407038187, 8], [975278.550276296, 18], [975278.732469039, 18], [975278.92031741, 34], [975279.112171088, 10], [975279.294799775, 14], [975279.477421534, 13], [975279.662208362, 2], [975279.843292469, 36], [975280.031943894, 42], [975280.217805282, 26], [975280.367910533, 17], [975280.551339245, 34], [975280.732827856, 12], [975280.921111076, 36], [975281.212031498, 50], [975281.39775618, 2], [975281.718768605, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8cb3782b2ac0344c5f82e403cd32828c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.034192278, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.912610423, "time_to_first_token": 0.123934937, "token_sha": "2b28aa2108de", "tokens_per_second": 25.72480800903155}, "seed": 1234, "sent": 975271.680820244, "speculative": {"acceptance_rate": 0.5638888888888889, "accepted": 203, "drafted": 360, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12665084702894092, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 360, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.677215806095052, "done": 975291.799240784, "finish_reason": "length", "first": 975281.868228914, "full_response_s": 10.059010119060986, "last": 975291.799212161, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975281.868228914, 2], [975282.055410716, 7], [975282.203983799, 4], [975282.418325061, 63], [975282.649709496, 10], [975282.833764859, 31], [975283.022300938, 29], [975283.208822149, 22], [975283.392690086, 14], [975283.573502907, 24], [975283.75851248, 4], [975283.905855893, 13], [975284.09588866, 21], [975284.276583766, 2], [975284.458785806, 18], [975284.639990845, 29], [975284.877967485, 27], [975285.122671382, 24], [975285.269548645, 4], [975285.418883848, 16], [975285.599683326, 10], [975285.780760569, 31], [975285.93096072, 8], [975286.120844373, 11], [975286.302621518, 16], [975286.486960518, 12], [975286.666970706, 39], [975286.843057557, 18], [975287.031144871, 11], [975287.214928108, 16], [975287.399708187, 16], [975287.546915532, 11], [975287.728990114, 6], [975287.913902033, 9], [975288.106488657, 29], [975288.289774145, 22], [975288.473561598, 8], [975288.620290167, 18], [975288.805710599, 18], [975288.991782566, 34], [975289.179877848, 10], [975289.36253556, 14], [975289.546573364, 13], [975289.728115295, 2], [975289.912227052, 36], [975290.105943699, 42], [975290.29001167, 26], [975290.439845399, 17], [975290.622811876, 34], [975290.810903135, 12], [975290.995429737, 36], [975291.285815159, 50], [975291.47221145, 2], [975291.799212161, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-2b3e8556019493ff883dbf0d63a44775", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033252411, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.933110702, "time_to_first_token": 0.123468022, "token_sha": "2b28aa2108de", "tokens_per_second": 25.67171630823127}, "seed": 1234, "sent": 975281.740230665, "speculative": {"acceptance_rate": 0.5638888888888889, "accepted": 203, "drafted": 360, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12799824902322143, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 360, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.675100115939134, "done": 975291.798494221, "finish_reason": "length", "first": 975281.866472549, "full_response_s": 10.05820854997728, "last": 975291.798274133, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975281.866472549, 2], [975282.054570332, 7], [975282.202632587, 4], [975282.416506106, 63], [975282.649585165, 10], [975282.835123703, 31], [975283.021891321, 29], [975283.208607693, 22], [975283.393269488, 14], [975283.573022189, 24], [975283.757984004, 4], [975283.905981153, 13], [975284.097279263, 21], [975284.278220647, 2], [975284.459990112, 18], [975284.641494915, 29], [975284.878698578, 27], [975285.12122974, 24], [975285.269681488, 4], [975285.418130404, 16], [975285.600091422, 10], [975285.781558603, 31], [975285.929113126, 8], [975286.122337981, 11], [975286.302407927, 16], [975286.486106807, 12], [975286.666100723, 39], [975286.844371267, 18], [975287.030107278, 11], [975287.214448382, 16], [975287.399555233, 16], [975287.548310183, 11], [975287.731251644, 6], [975287.914974184, 9], [975288.107158039, 29], [975288.287925063, 22], [975288.474244356, 8], [975288.619193665, 18], [975288.807039717, 18], [975288.990707102, 34], [975289.178682853, 10], [975289.362239028, 14], [975289.54647476, 13], [975289.728428675, 2], [975289.911989029, 36], [975290.106477519, 42], [975290.290269068, 26], [975290.439790681, 17], [975290.623561799, 34], [975290.811896953, 12], [975290.996909937, 36], [975291.285929538, 50], [975291.471489013, 2], [975291.798274133, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-a21c8333c8d32c8256adb4e39312e384", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033177694, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.933218346, "time_to_first_token": 0.123695469, "token_sha": "2b28aa2108de", "tokens_per_second": 25.671438109752792}, "seed": 1234, "sent": 975281.740285671, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12618687807116657, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.671150903046563, "done": 975291.800331623, "finish_reason": "length", "first": 975281.866978802, "full_response_s": 10.059242574963719, "last": 975291.80030828, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975281.866978802, 2], [975282.055181957, 7], [975282.204773865, 4], [975282.41719256, 63], [975282.650111177, 10], [975282.836393814, 31], [975283.022718474, 29], [975283.211322582, 22], [975283.393123109, 14], [975283.574329548, 24], [975283.757779708, 4], [975283.905382199, 13], [975284.096758563, 21], [975284.276781022, 2], [975284.459887332, 18], [975284.641779897, 29], [975284.878840044, 27], [975285.122313219, 24], [975285.272032343, 4], [975285.418209681, 16], [975285.600148076, 10], [975285.780659133, 31], [975285.929536006, 8], [975286.121684981, 11], [975286.301573606, 16], [975286.486321503, 12], [975286.667479247, 39], [975286.844067999, 18], [975287.031101465, 11], [975287.215862377, 16], [975287.399131873, 16], [975287.547245311, 11], [975287.728851959, 6], [975287.915051093, 9], [975288.106825108, 29], [975288.289979545, 22], [975288.471577257, 8], [975288.620963278, 18], [975288.807585152, 18], [975288.991220107, 34], [975289.179182275, 10], [975289.361806276, 14], [975289.547364518, 13], [975289.729424269, 2], [975289.912864244, 36], [975290.104608581, 42], [975290.291414625, 26], [975290.437918432, 17], [975290.623943049, 34], [975290.810236488, 12], [975290.996193484, 36], [975291.285288778, 50], [975291.476925272, 2], [975291.80030828, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-5cd310d1512b943bcdd28d75a921eefb", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033570223, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.933558205, "time_to_first_token": 0.122304834, "token_sha": "2b28aa2108de", "tokens_per_second": 25.670559807224684}, "seed": 1234, "sent": 975281.741089048, "speculative": {"acceptance_rate": 0.5670391061452514, "accepted": 203, "drafted": 358, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1258897540392354, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 358, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.673715145016125, "done": 975291.79814449, "finish_reason": "length", "first": 975281.865626389, "full_response_s": 10.05779608595185, "last": 975291.797963745, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975281.865626389, 2], [975282.054745829, 7], [975282.203558583, 4], [975282.417040854, 63], [975282.649662138, 10], [975282.83592572, 31], [975283.021797101, 29], [975283.21026707, 22], [975283.39122027, 14], [975283.573945242, 24], [975283.756161226, 4], [975283.905622702, 13], [975284.100520148, 21], [975284.276540567, 2], [975284.459142609, 18], [975284.641075987, 29], [975284.879132545, 27], [975285.122951531, 24], [975285.270619773, 4], [975285.418787211, 16], [975285.600334917, 10], [975285.780854326, 31], [975285.93174853, 8], [975286.120247548, 11], [975286.302896116, 16], [975286.486848458, 12], [975286.666516836, 39], [975286.843463766, 18], [975287.031429996, 11], [975287.214236422, 16], [975287.399180191, 16], [975287.547912582, 11], [975287.730703345, 6], [975287.913511792, 9], [975288.106091248, 29], [975288.287412746, 22], [975288.475043702, 8], [975288.62052875, 18], [975288.806204996, 18], [975288.990892759, 34], [975289.177765496, 10], [975289.362013356, 14], [975289.546133397, 13], [975289.729982632, 2], [975289.91467256, 36], [975290.107517975, 42], [975290.29085519, 26], [975290.43776775, 17], [975290.623749392, 34], [975290.810853505, 12], [975290.996414292, 36], [975291.284907561, 50], [975291.472672665, 2], [975291.797963745, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-fca7632d6b551b8f971ed3de726995f5", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033103009, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.933053264, "time_to_first_token": 0.123240894, "token_sha": "2b28aa2108de", "tokens_per_second": 25.671864755239675}, "seed": 1234, "sent": 975281.740348404, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12527798500377685, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.362631644773103, "done": 975291.798048317, "finish_reason": "length", "first": 975281.743864398, "full_response_s": 10.05734112591017, "last": 975291.79802611, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975281.743864398, 2], [975281.832567843, 7], [975282.054642745, 4], [975282.202492768, 72], [975282.415582685, 1], [975282.64929412, 27], [975282.833627088, 30], [975283.021525863, 15], [975283.208299369, 14], [975283.389565517, 20], [975283.574136531, 14], [975283.75595405, 4], [975283.906760163, 13], [975284.095732506, 21], [975284.276487737, 2], [975284.458660643, 18], [975284.640904042, 29], [975284.878948456, 27], [975285.121833286, 24], [975285.269412299, 4], [975285.416825814, 16], [975285.598347169, 10], [975285.780427126, 31], [975285.928522813, 8], [975286.119352174, 11], [975286.30273369, 16], [975286.484637982, 12], [975286.667180331, 39], [975286.842838621, 18], [975287.029559027, 11], [975287.216523104, 16], [975287.399086307, 16], [975287.546318627, 11], [975287.730822396, 6], [975287.914247732, 9], [975288.104854671, 29], [975288.288850996, 22], [975288.473900881, 8], [975288.619840121, 18], [975288.804433943, 18], [975288.990271391, 34], [975289.178236006, 10], [975289.361616411, 14], [975289.545478542, 13], [975289.728740663, 2], [975289.912110321, 36], [975290.104830717, 42], [975290.289733697, 26], [975290.439546514, 17], [975290.622566365, 34], [975290.809057365, 12], [975290.996974398, 36], [975291.285231261, 50], [975291.471172737, 2], [975291.79802611, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-ae5aa01aa3c20be4a2a8a58b8bd231c3", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.002336519, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.053835612, "time_to_first_token": 0.002644043, "token_sha": "2b28aa2108de", "tokens_per_second": 25.363454291577888}, "seed": 1234, "sent": 975281.740707191, "speculative": {"acceptance_rate": 0.5489130434782609, "accepted": 202, "drafted": 368, "rounds": 54, "tokens_per_round": 4.7407407407407405}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.0031572069274261594, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 202, "drafted": 368, "rounds": 54}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.678333437418505, "done": 975291.798913901, "finish_reason": "length", "first": 975281.868352509, "full_response_s": 10.058160423999652, "last": 975291.798903517, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975281.868352509, 2], [975282.055784254, 7], [975282.204415623, 4], [975282.41634232, 63], [975282.650637797, 10], [975282.834867009, 31], [975283.023385264, 29], [975283.209943658, 22], [975283.392600489, 14], [975283.574284509, 24], [975283.758704233, 4], [975283.907439945, 13], [975284.097635185, 21], [975284.278018607, 2], [975284.460672822, 18], [975284.6413786, 29], [975284.878611733, 27], [975285.123167155, 24], [975285.271670661, 4], [975285.417302996, 16], [975285.600575804, 10], [975285.783144847, 31], [975285.931666709, 8], [975286.12014136, 11], [975286.301131255, 16], [975286.485221544, 12], [975286.667097102, 39], [975286.843272669, 18], [975287.030865778, 11], [975287.216164813, 16], [975287.399465685, 16], [975287.546777761, 11], [975287.72950851, 6], [975287.914461916, 9], [975288.108451862, 29], [975288.288623837, 22], [975288.475247902, 8], [975288.621591846, 18], [975288.80384475, 18], [975288.989394736, 34], [975289.179700175, 10], [975289.36233376, 14], [975289.54627776, 13], [975289.728304792, 2], [975289.913077308, 36], [975290.105413191, 42], [975290.290681677, 26], [975290.438225684, 17], [975290.622941055, 34], [975290.811291168, 12], [975290.995642353, 36], [975291.286543323, 50], [975291.472554269, 2], [975291.798903517, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-0a103cdbbc0460ad65c87d3879f1b15d", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033493522, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.933054896, "time_to_first_token": 0.122517162, "token_sha": "2b28aa2108de", "tokens_per_second": 25.67186053735467}, "seed": 1234, "sent": 975281.740753477, "speculative": {"acceptance_rate": 0.5654596100278552, "accepted": 203, "drafted": 359, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12759903201367706, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 359, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.678996552232938, "done": 975291.798436399, "finish_reason": "length", "first": 975281.868107399, "full_response_s": 10.057990989997052, "last": 975291.798401968, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975281.868107399, 2], [975282.054493823, 7], [975282.205348419, 4], [975282.416592423, 63], [975282.650534617, 10], [975282.836103442, 31], [975283.022107169, 29], [975283.210928309, 22], [975283.389673705, 14], [975283.573910316, 24], [975283.756572042, 4], [975283.906380305, 13], [975284.099614342, 21], [975284.277430565, 2], [975284.459488515, 18], [975284.639897744, 29], [975284.879390119, 27], [975285.121461444, 24], [975285.271534666, 4], [975285.41803676, 16], [975285.599027655, 10], [975285.782447961, 31], [975285.929211075, 8], [975286.121971963, 11], [975286.301821645, 16], [975286.486274528, 12], [975286.666221023, 39], [975286.844311941, 18], [975287.02932518, 11], [975287.214543755, 16], [975287.39857223, 16], [975287.547146611, 11], [975287.728911941, 6], [975287.913784693, 9], [975288.106630107, 29], [975288.288469059, 22], [975288.472659968, 8], [975288.619976083, 18], [975288.804074501, 18], [975288.989917036, 34], [975289.17792517, 10], [975289.362151511, 14], [975289.546966853, 13], [975289.728657354, 2], [975289.914272895, 36], [975290.10629327, 42], [975290.291663256, 26], [975290.43875168, 17], [975290.623361359, 34], [975290.81055134, 12], [975290.99667049, 36], [975291.285442837, 50], [975291.472925919, 2], [975291.798401968, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-5e51ca7b400a7b0c615e762e19f51d4d", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033214605, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.933113342, "time_to_first_token": 0.12336273, "token_sha": "2b28aa2108de", "tokens_per_second": 25.671709485261605}, "seed": 1234, "sent": 975281.740445409, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12766199000179768, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.67452405621632, "done": 975291.799609794, "finish_reason": "length", "first": 975281.867561995, "full_response_s": 10.058470348012634, "last": 975291.799586419, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975281.867561995, 2], [975282.054388739, 7], [975282.205481486, 4], [975282.417645055, 63], [975282.650964728, 10], [975282.834253368, 31], [975283.023453822, 29], [975283.208192797, 22], [975283.390593446, 14], [975283.573807152, 24], [975283.756687382, 4], [975283.90669503, 13], [975284.099448028, 21], [975284.278085997, 2], [975284.460607929, 18], [975284.64099743, 29], [975284.878905178, 27], [975285.121055539, 24], [975285.271022589, 4], [975285.419742119, 16], [975285.599085781, 10], [975285.782827627, 31], [975285.931175048, 8], [975286.122478711, 11], [975286.301710209, 16], [975286.487320073, 12], [975286.666789657, 39], [975286.843624992, 18], [975287.030325766, 11], [975287.215017337, 16], [975287.399653565, 16], [975287.548371573, 11], [975287.732515292, 6], [975287.913356806, 9], [975288.108091252, 29], [975288.287703263, 22], [975288.475356554, 8], [975288.622102035, 18], [975288.808212552, 18], [975288.99151752, 34], [975289.179109093, 10], [975289.363535522, 14], [975289.546531926, 13], [975289.729038508, 2], [975289.914903671, 36], [975290.106943917, 42], [975290.290970546, 26], [975290.439382664, 17], [975290.625408754, 34], [975290.810620266, 12], [975290.995797467, 36], [975291.287115653, 50], [975291.475581195, 2], [975291.799586419, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-1977b68cd28026299863d3a1cced65c8", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.0334381, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.933119966, "time_to_first_token": 0.122608279, "token_sha": "2b28aa2108de", "tokens_per_second": 25.671692365826402}, "seed": 1234, "sent": 975281.741139446, "speculative": {"acceptance_rate": 0.5654596100278552, "accepted": 203, "drafted": 359, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12642254901584238, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 359, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.67250330014781, "done": 975291.799667776, "finish_reason": "length", "first": 975281.866834839, "full_response_s": 10.05902335094288, "last": 975291.799641041, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975281.866834839, 2], [975282.054865073, 7], [975282.203409853, 4], [975282.417712204, 63], [975282.651685533, 10], [975282.83493107, 31], [975283.02245554, 29], [975283.208700634, 22], [975283.39211702, 14], [975283.573287075, 24], [975283.758258202, 4], [975283.905283147, 13], [975284.098462322, 21], [975284.276711617, 2], [975284.460123883, 18], [975284.641245597, 29], [975284.878449947, 27], [975285.122361361, 24], [975285.270348951, 4], [975285.416989824, 16], [975285.598532122, 10], [975285.783074273, 31], [975285.930862484, 8], [975286.12226232, 11], [975286.303418944, 16], [975286.486451514, 12], [975286.667035264, 39], [975286.842252772, 18], [975287.029654047, 11], [975287.214829856, 16], [975287.3984367, 16], [975287.548134526, 11], [975287.731917251, 6], [975287.913127166, 9], [975288.107559192, 29], [975288.289832975, 22], [975288.47120308, 8], [975288.619537604, 18], [975288.805589259, 18], [975288.990050135, 34], [975289.178823488, 10], [975289.362860236, 14], [975289.547280026, 13], [975289.730135554, 2], [975289.912361735, 36], [975290.104932057, 42], [975290.290438278, 26], [975290.439728475, 17], [975290.623626165, 34], [975290.809318507, 12], [975290.995551668, 36], [975291.285353224, 50], [975291.476148101, 2], [975291.799641041, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-5ae45d9431f5a0912c08a4fac7361002", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033400901, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.933132142, "time_to_first_token": 0.122956249, "token_sha": "2b28aa2108de", "tokens_per_second": 25.67166089755217}, "seed": 1234, "sent": 975281.740644425, "speculative": {"acceptance_rate": 0.5654596100278552, "accepted": 203, "drafted": 359, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12619041395373642, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 359, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.670491131386747, "done": 975291.799536677, "finish_reason": "length", "first": 975281.86591569, "full_response_s": 10.058988551958464, "last": 975291.79950047, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975281.86591569, 2], [975282.05589217, 7], [975282.204806264, 4], [975282.417987794, 63], [975282.650736145, 10], [975282.834434273, 31], [975283.022982832, 29], [975283.211719063, 22], [975283.392378642, 14], [975283.574487942, 24], [975283.757931207, 4], [975283.907229969, 13], [975284.096487453, 21], [975284.27772649, 2], [975284.459347737, 18], [975284.640665539, 29], [975284.878525912, 27], [975285.121876804, 24], [975285.270091393, 4], [975285.420124601, 16], [975285.599908597, 10], [975285.781377074, 31], [975285.931407455, 8], [975286.120665932, 11], [975286.302086643, 16], [975286.48481836, 12], [975286.66665427, 39], [975286.842369519, 18], [975287.030497599, 11], [975287.215746173, 16], [975287.39863178, 16], [975287.546949003, 11], [975287.73156472, 6], [975287.913438818, 9], [975288.107511402, 29], [975288.288054514, 22], [975288.471858383, 8], [975288.619275998, 18], [975288.805370212, 18], [975288.989669766, 34], [975289.179035672, 10], [975289.362811582, 14], [975289.546615667, 13], [975289.728827764, 2], [975289.915166973, 36], [975290.105314779, 42], [975290.29197558, 26], [975290.438308113, 17], [975290.623881595, 34], [975290.809567409, 12], [975290.995968932, 36], [975291.286723476, 50], [975291.474721387, 2], [975291.79950047, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-2a645bd025d956a8628effab0877ecf3", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033364631, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.933138669, "time_to_first_token": 0.123037798, "token_sha": "2b28aa2108de", "tokens_per_second": 25.671644028872866}, "seed": 1234, "sent": 975281.740548125, "speculative": {"acceptance_rate": 0.5654596100278552, "accepted": 203, "drafted": 359, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12536756496410817, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 359, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.67332896718844, "done": 975291.799443529, "finish_reason": "length", "first": 975281.866920084, "full_response_s": 10.059033510973677, "last": 975291.799406842, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975281.866920084, 2], [975282.055309248, 7], [975282.203137239, 4], [975282.416695043, 63], [975282.6508679, 10], [975282.835877162, 31], [975283.023155177, 29], [975283.211606123, 22], [975283.391919779, 14], [975283.573647766, 24], [975283.75725336, 4], [975283.906584634, 13], [975284.100653758, 21], [975284.27761619, 2], [975284.459433446, 18], [975284.641188287, 29], [975284.878980807, 27], [975285.121323593, 24], [975285.270559183, 4], [975285.417768802, 16], [975285.59872805, 10], [975285.783570095, 31], [975285.930313577, 8], [975286.119959735, 11], [975286.301915257, 16], [975286.486565653, 12], [975286.667387587, 39], [975286.842510026, 18], [975287.030812356, 11], [975287.215356828, 16], [975287.399770809, 16], [975287.547203393, 11], [975287.7287179, 6], [975287.914759472, 9], [975288.109238377, 29], [975288.288931825, 22], [975288.471952587, 8], [975288.61979553, 18], [975288.804858871, 18], [975288.990370555, 34], [975289.17754712, 10], [975289.363075956, 14], [975289.547439012, 13], [975289.729124073, 2], [975289.911806316, 36], [975290.107302896, 42], [975290.290592688, 26], [975290.438983272, 17], [975290.623790863, 34], [975290.812297482, 12], [975290.997146648, 36], [975291.285037236, 50], [975291.473138215, 2], [975291.799406842, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-ca15624ac4cbc326a58b2c0cbac901fa", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033532064, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.933651162, "time_to_first_token": 0.122468636, "token_sha": "2b28aa2108de", "tokens_per_second": 25.670319587572408}, "seed": 1234, "sent": 975281.740410018, "speculative": {"acceptance_rate": 0.5670391061452514, "accepted": 203, "drafted": 358, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1265100659802556, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 358, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.676079161466916, "done": 975291.798080444, "finish_reason": "length", "first": 975281.866571009, "full_response_s": 10.057116847019643, "last": 975291.797993887, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975281.866571009, 2], [975282.056282843, 7], [975282.2052178, 4], [975282.416200822, 63], [975282.65080347, 10], [975282.835327199, 31], [975283.021674193, 29], [975283.207846314, 22], [975283.390203237, 14], [975283.573161096, 24], [975283.757061192, 4], [975283.906976507, 13], [975284.097406058, 21], [975284.277022485, 2], [975284.458919913, 18], [975284.641994, 29], [975284.87909845, 27], [975285.12222919, 24], [975285.271449597, 4], [975285.420427133, 16], [975285.599738044, 10], [975285.781814689, 31], [975285.930536304, 8], [975286.121526539, 11], [975286.302551329, 16], [975286.486367901, 12], [975286.666400456, 39], [975286.843531603, 18], [975287.030767077, 11], [975287.215459784, 16], [975287.399842966, 16], [975287.547606354, 11], [975287.729883696, 6], [975287.913875458, 9], [975288.10566248, 29], [975288.288694906, 22], [975288.472962709, 8], [975288.620049297, 18], [975288.807816471, 18], [975288.989524827, 34], [975289.180156702, 10], [975289.363356985, 14], [975289.546887592, 13], [975289.729377039, 2], [975289.91335429, 36], [975290.105475813, 42], [975290.290131666, 26], [975290.439310635, 17], [975290.624249773, 34], [975290.810477887, 12], [975290.997209718, 36], [975291.286851887, 50], [975291.473499033, 2], [975291.797993887, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-756bcb263c1fd04593db44fd1c20cec6", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033140096, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.933080015, "time_to_first_token": 0.123718924, "token_sha": "2b28aa2108de", "tokens_per_second": 25.6717956177664}, "seed": 1234, "sent": 975281.740963597, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12560741207562387, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.66953363908944, "done": 975291.80100347, "finish_reason": "length", "first": 975281.865837261, "full_response_s": 10.05974833201617, "last": 975291.799792571, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975281.865837261, 2], [975282.056404214, 7], [975282.204502675, 4], [975282.415801829, 63], [975282.651239918, 10], [975282.835682834, 31], [975283.022234092, 29], [975283.210542516, 22], [975283.390759839, 14], [975283.574783514, 24], [975283.757473096, 4], [975283.906922685, 13], [975284.097694207, 21], [975284.27663378, 2], [975284.459841686, 18], [975284.64052788, 29], [975284.879167792, 27], [975285.121544433, 24], [975285.270759367, 4], [975285.419333831, 16], [975285.599150386, 10], [975285.783499361, 31], [975285.930712106, 8], [975286.119621444, 11], [975286.303278518, 16], [975286.486524999, 12], [975286.667552508, 39], [975286.844009009, 18], [975287.031061306, 11], [975287.215095286, 16], [975287.399253757, 16], [975287.547013512, 11], [975287.729092894, 6], [975287.915755483, 9], [975288.109600187, 29], [975288.289680885, 22], [975288.472301854, 8], [975288.619743724, 18], [975288.807334169, 18], [975288.989971722, 34], [975289.178541563, 10], [975289.36259767, 14], [975289.54678622, 13], [975289.729539577, 2], [975289.912583695, 36], [975290.10523651, 42], [975290.290903236, 26], [975290.438385982, 17], [975290.623698018, 34], [975290.810069902, 12], [975290.996085424, 36], [975291.285862885, 50], [975291.473287889, 2], [975291.799792571, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8cbf14aa04657ff7cc9deb501ba6e99b", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033602206, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.933697544, "time_to_first_token": 0.122078939, "token_sha": "2b28aa2108de", "tokens_per_second": 25.67019972880302}, "seed": 1234, "sent": 975281.741255138, "speculative": {"acceptance_rate": 0.5670391061452514, "accepted": 203, "drafted": 358, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12458212301135063, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 358, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.66911823369825, "done": 975291.7998806, "finish_reason": "length", "first": 975281.865728833, "full_response_s": 10.059271005913615, "last": 975291.799844905, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975281.865728833, 2], [975282.056027988, 7], [975282.203268594, 4], [975282.416019581, 63], [975282.649424099, 10], [975282.834729846, 31], [975283.023589528, 29], [975283.207332702, 22], [975283.391753466, 14], [975283.57422016, 24], [975283.757150004, 4], [975283.906082701, 13], [975284.098978078, 21], [975284.276437707, 2], [975284.460176281, 18], [975284.641918499, 29], [975284.878227651, 27], [975285.122427023, 24], [975285.271069164, 4], [975285.420691331, 16], [975285.599488901, 10], [975285.782134069, 31], [975285.929989173, 8], [975286.121192664, 11], [975286.301014523, 16], [975286.485022752, 12], [975286.666892005, 39], [975286.842970104, 18], [975287.029474022, 11], [975287.21539665, 16], [975287.398351951, 16], [975287.546682789, 11], [975287.729162299, 6], [975287.913717112, 9], [975288.105219937, 29], [975288.287616339, 22], [975288.473096416, 8], [975288.619615185, 18], [975288.805084047, 18], [975288.989162297, 34], [975289.178421631, 10], [975289.363129986, 14], [975289.54573394, 13], [975289.7289372, 2], [975289.912306521, 36], [975290.106146779, 42], [975290.291041503, 26], [975290.438842125, 17], [975290.623276994, 34], [975290.809761626, 12], [975290.995086614, 36], [975291.284705264, 50], [975291.471898598, 2], [975291.799844905, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-0679754dcfe6953616594f77a59ed4f1", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033042627, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.933294199, "time_to_first_token": 0.123348554, "token_sha": "2b28aa2108de", "tokens_per_second": 25.671242076538036}, "seed": 1234, "sent": 975281.740609594, "speculative": {"acceptance_rate": 0.5576923076923077, "accepted": 203, "drafted": 364, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12511923897545785, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 364, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.6766394031185, "done": 975291.798527355, "finish_reason": "length", "first": 975281.867307749, "full_response_s": 10.057651915005408, "last": 975291.798513932, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975281.867307749, 2], [975282.055035594, 7], [975282.204056596, 4], [975282.41571268, 63], [975282.649964622, 10], [975282.836303434, 31], [975283.022405094, 29], [975283.209622439, 22], [975283.393015402, 14], [975283.573583256, 24], [975283.756939532, 4], [975283.905170831, 13], [975284.099964777, 21], [975284.277505171, 2], [975284.460079917, 18], [975284.641130033, 29], [975284.879050804, 27], [975285.121956609, 24], [975285.271581496, 4], [975285.417088972, 16], [975285.599233311, 10], [975285.780551889, 31], [975285.928663031, 8], [975286.122050952, 11], [975286.302319946, 16], [975286.485417729, 12], [975286.66781669, 39], [975286.844581323, 18], [975287.029879031, 11], [975287.215277663, 16], [975287.398715857, 16], [975287.547643136, 11], [975287.72993971, 6], [975287.913657642, 9], [975288.10888407, 29], [975288.287822347, 22], [975288.473966063, 8], [975288.61907095, 18], [975288.805518574, 18], [975288.99141546, 34], [975289.180276105, 10], [975289.362731921, 14], [975289.545870239, 13], [975289.729203606, 2], [975289.914444025, 36], [975290.106672711, 42], [975290.289849612, 26], [975290.438709922, 17], [975290.622706648, 34], [975290.812105249, 12], [975290.995220865, 36], [975291.284828524, 50], [975291.476534871, 2], [975291.798513932, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-ed086c3f6f3fa9fe05c5fae926130e95", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033290106, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.933126877, "time_to_first_token": 0.123050678, "token_sha": "2b28aa2108de", "tokens_per_second": 25.671674504676723}, "seed": 1234, "sent": 975281.74087544, "speculative": {"acceptance_rate": 0.5638888888888889, "accepted": 203, "drafted": 360, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1264323090435937, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 360, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.676225960026166, "done": 975291.798883166, "finish_reason": "length", "first": 975281.867482494, "full_response_s": 10.058738306048326, "last": 975291.798848591, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975281.867482494, 2], [975282.054977708, 7], [975282.205591114, 4], [975282.415956655, 63], [975282.649761862, 10], [975282.834179371, 31], [975283.022644156, 29], [975283.207682017, 22], [975283.393394507, 14], [975283.573871501, 24], [975283.758065169, 4], [975283.904941736, 13], [975284.097896247, 21], [975284.278291813, 2], [975284.459292011, 18], [975284.641312618, 29], [975284.878769135, 27], [975285.121633581, 24], [975285.270015428, 4], [975285.417381441, 16], [975285.599559283, 10], [975285.783402805, 31], [975285.930644396, 8], [975286.120362456, 11], [975286.302031173, 16], [975286.485648616, 12], [975286.667141148, 39], [975286.844530141, 18], [975287.031341423, 11], [975287.215779068, 16], [975287.400093341, 16], [975287.54739993, 11], [975287.729703703, 6], [975287.915416248, 9], [975288.106778358, 29], [975288.288791174, 22], [975288.471494045, 8], [975288.620815076, 18], [975288.806117096, 18], [975288.989850175, 34], [975289.180357334, 10], [975289.362642708, 14], [975289.546693424, 13], [975289.730443575, 2], [975289.913123915, 36], [975290.105726139, 42], [975290.290384472, 26], [975290.437837571, 17], [975290.625201865, 34], [975290.810802979, 12], [975290.997062235, 36], [975291.285485235, 50], [975291.474496468, 2], [975291.798848591, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-655dcd794061a7da6bd4277d543c0e83", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033326136, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.932989235, "time_to_first_token": 0.122991864, "token_sha": "2b28aa2108de", "tokens_per_second": 25.67203023853876}, "seed": 1234, "sent": 975281.74014486, "speculative": {"acceptance_rate": 0.5654596100278552, "accepted": 203, "drafted": 359, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12733763398136944, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 359, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "candidate", "burst": null, "phase": "uncached_first_use", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 49.288785308053065, "done": 975297.152023853, "finish_reason": "length", "first": 975291.978362494, "full_response_s": 5.3334763729944825, "last": 975297.151953168, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975291.978362494, 3], [975292.071591714, 26], [975292.155129733, 15], [975292.235143003, 34], [975292.317833774, 21], [975292.398268661, 25], [975292.478650638, 14], [975292.560596748, 14], [975292.641387926, 18], [975292.721495641, 26], [975292.805938729, 13], [975292.886713911, 13], [975292.966690323, 13], [975293.055505362, 23], [975293.139797627, 32], [975293.219913026, 7], [975293.301293401, 23], [975293.382176067, 9], [975293.462694362, 13], [975293.54379174, 15], [975293.62441144, 19], [975293.705991903, 12], [975293.787609565, 5], [975293.868212148, 23], [975293.949252332, 9], [975294.035423378, 17], [975294.120675115, 3], [975294.20125682, 21], [975294.282835735, 10], [975294.364222433, 24], [975294.445011474, 19], [975294.525653833, 14], [975294.606765934, 13], [975294.687340823, 5], [975294.770828402, 22], [975294.851757615, 13], [975294.932530469, 51], [975295.018203666, 15], [975295.104106886, 6], [975295.18543495, 8], [975295.265951237, 9], [975295.347744036, 16], [975295.428763823, 16], [975295.509724669, 9], [975295.590757817, 32], [975295.671756213, 18], [975295.753133428, 13], [975295.834689485, 11], [975295.915928244, 15], [975295.997906879, 8], [975296.086213357, 18], [975296.1624648, 25], [975296.242958515, 19], [975296.324684776, 8], [975296.406607797, 40], [975296.487761215, 16], [975296.568459611, 64], [975296.649865468, 6], [975296.730920202, 6], [975296.814732321, 11], [975296.895919437, 15], [975296.976999134, 17], [975297.065496425, 21], [975297.151953168, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-f7511a08325eb3d335115655bab0921c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.158782717, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 5.173740445, "time_to_first_token": 0.15917555, "token_sha": "8a91591c94a3", "tokens_per_second": 49.28735848092975}, "seed": 1234, "sent": 975291.81854748, "speculative": {"acceptance_rate": 0.2052910052910053, "accepted": 194, "drafted": 945, "rounds": 63, "tokens_per_round": 4.063492063492063}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1598150139907375, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 194, "drafted": 945, "rounds": 63}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 49.39649641546799, "done": 975302.333218798, "finish_reason": "length", "first": 975297.170866443, "full_response_s": 5.172245168010704, "last": 975302.333175888, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975297.170866443, 3], [975297.259669226, 26], [975297.340709916, 15], [975297.42171456, 34], [975297.502573417, 21], [975297.583308375, 25], [975297.664347945, 14], [975297.744965547, 14], [975297.826205462, 18], [975297.907030452, 26], [975297.988438476, 13], [975298.076626294, 13], [975298.159178323, 13], [975298.239928036, 23], [975298.32135198, 32], [975298.402293701, 7], [975298.482958041, 23], [975298.564844255, 9], [975298.646236791, 13], [975298.726484347, 15], [975298.809913367, 19], [975298.891377889, 12], [975298.971787858, 5], [975299.060495292, 23], [975299.143861823, 9], [975299.22443041, 17], [975299.30582351, 3], [975299.386395617, 21], [975299.46743865, 10], [975299.548317337, 24], [975299.628780248, 19], [975299.710144645, 14], [975299.790897545, 13], [975299.872456434, 5], [975299.953276871, 22], [975300.040350051, 13], [975300.124880829, 51], [975300.206066677, 15], [975300.288181913, 6], [975300.368753032, 8], [975300.449959678, 9], [975300.530618922, 16], [975300.611572186, 16], [975300.693769835, 9], [975300.776427788, 32], [975300.857844285, 18], [975300.938838783, 13], [975301.024481732, 11], [975301.111054742, 15], [975301.192064935, 8], [975301.273916825, 18], [975301.348483467, 25], [975301.428723162, 19], [975301.510426321, 8], [975301.591358806, 40], [975301.67192188, 16], [975301.753767242, 64], [975301.834861402, 6], [975301.915797346, 6], [975301.997633, 11], [975302.087241421, 15], [975302.169458629, 17], [975302.250714241, 21], [975302.333175888, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-381066b5821eeec377b5f3f064a6d7da", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.007851162, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 5.162394978, "time_to_first_token": 0.008853508, "token_sha": "8a91591c94a3", "tokens_per_second": 49.39567799184388}, "seed": 1234, "sent": 975297.16097363, "speculative": {"acceptance_rate": 0.2052910052910053, "accepted": 194, "drafted": 945, "rounds": 63, "tokens_per_round": 4.063492063492063}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.009892812930047512, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 194, "drafted": 945, "rounds": 63}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 49.46127542017963, "done": 975307.510930977, "finish_reason": "length", "first": 975302.355343574, "full_response_s": 5.159113991889171, "last": 975307.510891987, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975302.355343574, 3], [975302.443473457, 26], [975302.525008963, 15], [975302.605761474, 34], [975302.685990996, 21], [975302.768416644, 25], [975302.85056904, 14], [975302.931358257, 14], [975303.015957492, 18], [975303.102631594, 26], [975303.183701376, 13], [975303.26429908, 13], [975303.345331152, 13], [975303.426836678, 23], [975303.50685498, 32], [975303.587736433, 7], [975303.668342505, 23], [975303.749291604, 9], [975303.830503958, 13], [975303.911414422, 15], [975303.99235898, 19], [975304.080620643, 12], [975304.1633144, 5], [975304.243903276, 23], [975304.325251404, 9], [975304.405743131, 17], [975304.486747224, 3], [975304.566900884, 21], [975304.647589132, 10], [975304.727925121, 24], [975304.81234491, 19], [975304.893303152, 14], [975304.973239095, 13], [975305.061822686, 5], [975305.145227221, 22], [975305.225820404, 13], [975305.306793845, 51], [975305.387994525, 15], [975305.468399523, 6], [975305.548809161, 8], [975305.629662783, 9], [975305.710659615, 16], [975305.792580333, 16], [975305.873240348, 9], [975305.954022456, 32], [975306.041236501, 18], [975306.125793668, 13], [975306.207035215, 11], [975306.288236091, 15], [975306.368872748, 8], [975306.449687831, 18], [975306.524152365, 25], [975306.604619156, 19], [975306.685608536, 8], [975306.767128216, 40], [975306.850634033, 16], [975306.9314108, 64], [975307.015932532, 6], [975307.102914974, 6], [975307.184942239, 11], [975307.266568479, 15], [975307.348526722, 17], [975307.428819843, 21], [975307.510891987, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-3b0ea7d46d39ccfbc6dc352d8447fcaf", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.002263979, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 5.155340565, "time_to_first_token": 0.002807735, "token_sha": "8a91591c94a3", "tokens_per_second": 49.4632695522027}, "seed": 1234, "sent": 975302.351816985, "speculative": {"acceptance_rate": 0.2052910052910053, "accepted": 194, "drafted": 945, "rounds": 63, "tokens_per_round": 4.063492063492063}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.0035265889018774033, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 194, "drafted": 945, "rounds": 63}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 49.46227423239256, "done": 975312.688290614, "finish_reason": "length", "first": 975307.532794023, "full_response_s": 5.159235956030898, "last": 975312.688238328, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975307.532794023, 3], [975307.621792726, 26], [975307.703098946, 15], [975307.784547592, 34], [975307.866031744, 21], [975307.946908863, 25], [975308.032968094, 14], [975308.118804438, 14], [975308.200156243, 18], [975308.280784171, 26], [975308.362116458, 13], [975308.442375712, 13], [975308.523370522, 13], [975308.603451879, 23], [975308.684753926, 32], [975308.76658669, 7], [975308.849961718, 23], [975308.930776683, 9], [975309.013988583, 13], [975309.101514036, 15], [975309.182584688, 19], [975309.263402069, 12], [975309.344785716, 5], [975309.424697035, 23], [975309.505717608, 9], [975309.586380786, 17], [975309.667478301, 3], [975309.748442764, 21], [975309.82903225, 10], [975309.910574248, 24], [975309.991448494, 19], [975310.079263748, 14], [975310.162672316, 13], [975310.242942841, 5], [975310.324248319, 22], [975310.404605256, 13], [975310.485062414, 51], [975310.566456721, 15], [975310.64681665, 6], [975310.727390939, 8], [975310.810893344, 9], [975310.892508063, 16], [975310.972482889, 16], [975311.06071474, 9], [975311.144845621, 32], [975311.225486856, 18], [975311.307404219, 13], [975311.387624556, 11], [975311.468543108, 15], [975311.549166999, 8], [975311.629681534, 18], [975311.704275743, 25], [975311.785890574, 19], [975311.866022693, 8], [975311.947620856, 40], [975312.033526907, 16], [975312.11946579, 64], [975312.200700398, 6], [975312.282283553, 6], [975312.362803707, 11], [975312.444244019, 15], [975312.52534036, 17], [975312.605726999, 21], [975312.688238328, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-f22f10b0613019d7fdcbdaf6dab079ba", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.002714508, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 5.155131404, "time_to_first_token": 0.003182362, "token_sha": "8a91591c94a3", "tokens_per_second": 49.46527644322294}, "seed": 1234, "sent": 975307.529054658, "speculative": {"acceptance_rate": 0.2052910052910053, "accepted": 194, "drafted": 945, "rounds": 63, "tokens_per_round": 4.063492063492063}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.0037393650272861123, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 194, "drafted": 945, "rounds": 63}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.95632762095187, "done": 975326.365781676, "finish_reason": "length", "first": 975312.913777321, "full_response_s": 13.652475888025947, "last": 975326.365749934, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975312.913777321, 3], [975313.066995076, 11], [975313.250430711, 30], [975313.433902057, 19], [975313.617137203, 21], [975313.797345085, 15], [975313.949455399, 19], [975314.102664185, 17], [975314.283926643, 12], [975314.466857825, 5], [975314.611898095, 5], [975314.796449377, 27], [975314.978989876, 12], [975315.172094708, 13], [975315.353414917, 5], [975315.501435371, 16], [975315.68247879, 5], [975315.865554504, 14], [975316.05267566, 9], [975316.203825526, 22], [975316.350321963, 10], [975316.53046395, 7], [975316.711335303, 23], [975316.864063098, 5], [975317.013329343, 9], [975317.201076276, 14], [975317.349024762, 20], [975317.499024405, 8], [975317.645491969, 12], [975317.794840708, 5], [975317.942541672, 14], [975318.134505467, 14], [975318.28177, 8], [975318.4643802, 13], [975318.635415128, 3], [975318.818485728, 10], [975318.966162892, 11], [975319.157196568, 9], [975319.342168978, 10], [975319.523709833, 20], [975319.672235207, 14], [975319.851555104, 14], [975320.089063685, 13], [975320.27240637, 5], [975320.456066787, 22], [975320.685206297, 3], [975320.921217401, 32], [975321.113107366, 33], [975321.297374425, 11], [975321.48096826, 6], [975321.629203881, 8], [975321.776067407, 9], [975321.927868071, 13], [975322.08257967, 8], [975322.232723371, 20], [975322.385378709, 17], [975322.569654255, 20], [975322.71847314, 13], [975322.894227913, 6], [975323.085649559, 13], [975323.234803766, 9], [975323.384151439, 11], [975323.533121269, 8], [975323.718367636, 15], [975323.899197735, 16], [975324.120209947, 27], [975324.354312018, 4], [975324.504833894, 8], [975324.688970085, 25], [975324.840014056, 18], [975324.990097154, 13], [975325.180495269, 55], [975325.330629246, 11], [975325.515952873, 10], [975325.700672843, 11], [975325.848566598, 15], [975325.99683116, 17], [975326.155313896, 14], [975326.365749934, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4247173aee7b8cb129c8e2f2c51977fd", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.105685007, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.452170157, "time_to_first_token": 0.190076715, "token_sha": "8a91591c94a3", "tokens_per_second": 18.956049248849833}, "seed": 1234, "sent": 975312.713305788, "speculative": {"acceptance_rate": 0.4254807692307692, "accepted": 177, "drafted": 416, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.20047153299674392, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 416, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.9571904341002, "done": 975326.36452425, "finish_reason": "length", "first": 975312.913144816, "full_response_s": 13.648064770037308, "last": 975326.364505179, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975312.913144816, 3], [975313.067515472, 11], [975313.253578387, 30], [975313.434025636, 19], [975313.617769564, 21], [975313.800398301, 15], [975313.946846663, 19], [975314.101467557, 17], [975314.285804974, 12], [975314.468852488, 5], [975314.613961219, 5], [975314.798729533, 27], [975314.981192051, 12], [975315.172813994, 13], [975315.355224914, 5], [975315.499972177, 16], [975315.682934437, 5], [975315.865089961, 14], [975316.051182083, 9], [975316.204737285, 22], [975316.348524861, 10], [975316.532130817, 7], [975316.7125143, 23], [975316.863536029, 5], [975317.011931331, 9], [975317.200728561, 14], [975317.348650936, 20], [975317.501844909, 8], [975317.646495948, 12], [975317.796340621, 5], [975317.943123667, 14], [975318.134712355, 14], [975318.28334975, 8], [975318.463281712, 13], [975318.636439074, 3], [975318.817316826, 10], [975318.967615847, 11], [975319.159041525, 9], [975319.342888888, 10], [975319.523375845, 20], [975319.671462659, 14], [975319.850867514, 14], [975320.089511188, 13], [975320.272690183, 5], [975320.455687841, 22], [975320.685150091, 3], [975320.920380167, 32], [975321.113311166, 33], [975321.298836243, 11], [975321.481816181, 6], [975321.631282525, 8], [975321.776398803, 9], [975321.928369156, 13], [975322.083090147, 8], [975322.233699703, 20], [975322.383875579, 17], [975322.568134694, 20], [975322.717667026, 13], [975322.895187446, 6], [975323.084184636, 13], [975323.232691299, 9], [975323.383173154, 11], [975323.535083678, 8], [975323.716335342, 15], [975323.898601501, 16], [975324.117748772, 27], [975324.354506123, 4], [975324.50297585, 8], [975324.688576196, 25], [975324.840204177, 18], [975324.989144836, 13], [975325.183633283, 55], [975325.331503198, 11], [975325.519498489, 10], [975325.696818055, 11], [975325.847055261, 15], [975325.996699229, 17], [975326.157770831, 14], [975326.364505179, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-298ab3ed57d72c911f2c2ff1a3d8e238", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.105566196, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.451987555, "time_to_first_token": 0.190049228, "token_sha": "8a91591c94a3", "tokens_per_second": 18.956306564914897}, "seed": 1234, "sent": 975312.71645948, "speculative": {"acceptance_rate": 0.4254807692307692, "accepted": 177, "drafted": 416, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.19668533594813198, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 416, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.953096386164525, "done": 975326.366071794, "finish_reason": "length", "first": 975312.911768963, "full_response_s": 13.652971965959296, "last": 975326.366034947, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975312.911768963, 3], [975313.067220683, 11], [975313.25160406, 30], [975313.43434652, 19], [975313.618038274, 21], [975313.798726778, 15], [975313.94714726, 19], [975314.10104818, 17], [975314.285164678, 12], [975314.465961426, 5], [975314.612610277, 5], [975314.79816901, 27], [975314.979738521, 12], [975315.170373539, 13], [975315.354243462, 5], [975315.50092907, 16], [975315.683158781, 5], [975315.865954858, 14], [975316.052049731, 9], [975316.20387738, 22], [975316.349453099, 10], [975316.53096134, 7], [975316.713346381, 23], [975316.863713398, 5], [975317.011640061, 9], [975317.202960559, 14], [975317.348915358, 20], [975317.500370611, 8], [975317.646082235, 12], [975317.794240186, 5], [975317.943534676, 14], [975318.137168009, 14], [975318.281298769, 8], [975318.465348709, 13], [975318.635996307, 3], [975318.81952041, 10], [975318.966478672, 11], [975319.157077197, 9], [975319.340017633, 10], [975319.524306275, 20], [975319.672453343, 14], [975319.851384903, 14], [975320.089017158, 13], [975320.274725997, 5], [975320.456892341, 22], [975320.685010176, 3], [975320.922424749, 32], [975321.114104289, 33], [975321.299485564, 11], [975321.479115, 6], [975321.631104836, 8], [975321.777688244, 9], [975321.926316607, 13], [975322.083516707, 8], [975322.234677732, 20], [975322.384033877, 17], [975322.570043537, 20], [975322.718049412, 13], [975322.895248179, 6], [975323.086047336, 13], [975323.232942346, 9], [975323.383953078, 11], [975323.533211458, 8], [975323.718138348, 15], [975323.900058488, 16], [975324.121186487, 27], [975324.35393752, 4], [975324.503632818, 8], [975324.688156659, 25], [975324.840978069, 18], [975324.989497176, 13], [975325.181996447, 55], [975325.333075285, 11], [975325.516701134, 10], [975325.698137655, 11], [975325.847916238, 15], [975325.996273117, 17], [975326.156712134, 14], [975326.366034947, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-c16bd123c7736ad1bab1b06efc8624c0", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.105316813, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.452659835, "time_to_first_token": 0.194356653, "token_sha": "8a91591c94a3", "tokens_per_second": 18.95535924699162}, "seed": 1234, "sent": 975312.713099828, "speculative": {"acceptance_rate": 0.42042755344418054, "accepted": 177, "drafted": 421, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.19866913498844951, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 421, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.957016589828974, "done": 975326.364260963, "finish_reason": "length", "first": 975312.91275563, "full_response_s": 13.648361270083115, "last": 975326.364239348, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975312.91275563, 3], [975313.0667695, 11], [975313.25087287, 30], [975313.433816044, 19], [975313.617291358, 21], [975313.798596159, 15], [975313.945713456, 19], [975314.102751189, 17], [975314.284321461, 12], [975314.468926469, 5], [975314.613594705, 5], [975314.799078432, 27], [975314.979082433, 12], [975315.171048746, 13], [975315.352868905, 5], [975315.501221779, 16], [975315.682745196, 5], [975315.864056079, 14], [975316.052884148, 9], [975316.205487625, 22], [975316.349725441, 10], [975316.531075208, 7], [975316.712424543, 23], [975316.864159926, 5], [975317.013789599, 9], [975317.20473691, 14], [975317.352102745, 20], [975317.499330186, 8], [975317.645655995, 12], [975317.793877943, 5], [975317.942403741, 14], [975318.13779285, 14], [975318.282923846, 8], [975318.464660702, 13], [975318.63613043, 3], [975318.818403619, 10], [975318.965455366, 11], [975319.15681951, 9], [975319.342679567, 10], [975319.524810961, 20], [975319.672171145, 14], [975319.851273355, 14], [975320.089297484, 13], [975320.271972162, 5], [975320.455641203, 22], [975320.684841942, 3], [975320.921304965, 32], [975321.112480445, 33], [975321.297731084, 11], [975321.481583934, 6], [975321.626825887, 8], [975321.778335837, 9], [975321.927202095, 13], [975322.083763802, 8], [975322.233582811, 20], [975322.384559666, 17], [975322.568610453, 20], [975322.717974999, 13], [975322.894069342, 6], [975323.084771191, 13], [975323.233045238, 9], [975323.387929605, 11], [975323.535633674, 8], [975323.716784429, 15], [975323.900893082, 16], [975324.117900974, 27], [975324.35558042, 4], [975324.505829746, 8], [975324.688776252, 25], [975324.840800811, 18], [975324.988062844, 13], [975325.182691254, 55], [975325.329865721, 11], [975325.512885337, 10], [975325.700290457, 11], [975325.847400272, 15], [975325.99688815, 17], [975326.155881716, 14], [975326.364239348, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-9cf6e9ea66c524a8a9106d954f197f40", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.105489271, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.452066192, "time_to_first_token": 0.191875673, "token_sha": "8a91591c94a3", "tokens_per_second": 18.95619575167193}, "seed": 1234, "sent": 975312.715899693, "speculative": {"acceptance_rate": 0.4254807692307692, "accepted": 177, "drafted": 416, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1968559370143339, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 416, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.956270783094936, "done": 975326.364034988, "finish_reason": "length", "first": 975312.911934364, "full_response_s": 13.648244010983035, "last": 975326.363947311, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975312.911934364, 3], [975313.066612546, 11], [975313.251153292, 30], [975313.434447749, 19], [975313.616778784, 21], [975313.798111073, 15], [975313.947906304, 19], [975314.100928552, 17], [975314.283664877, 12], [975314.467770639, 5], [975314.613422903, 5], [975314.797613942, 27], [975314.981063368, 12], [975315.172484982, 13], [975315.355034489, 5], [975315.500224456, 16], [975315.682112067, 5], [975315.86577216, 14], [975316.051461368, 9], [975316.20130461, 22], [975316.350763019, 10], [975316.531977703, 7], [975316.714879861, 23], [975316.864456011, 5], [975317.013534552, 9], [975317.201936692, 14], [975317.351466192, 20], [975317.497490845, 8], [975317.646450254, 12], [975317.793687486, 5], [975317.943693678, 14], [975318.137528748, 14], [975318.281561047, 8], [975318.464189071, 13], [975318.634675347, 3], [975318.820102213, 10], [975318.966716248, 11], [975319.159392104, 9], [975319.3405819, 10], [975319.525131173, 20], [975319.672361234, 14], [975319.853487082, 14], [975320.089768971, 13], [975320.274584706, 5], [975320.456367432, 22], [975320.684578096, 3], [975320.921764869, 32], [975321.112295827, 33], [975321.297055524, 11], [975321.482058909, 6], [975321.627266143, 8], [975321.77682498, 9], [975321.927693021, 13], [975322.082838844, 8], [975322.232199278, 20], [975322.38287784, 17], [975322.566894227, 20], [975322.716983323, 13], [975322.894750374, 6], [975323.083913718, 13], [975323.234162766, 9], [975323.384963969, 11], [975323.535370467, 8], [975323.715691397, 15], [975323.899856031, 16], [975324.119331946, 27], [975324.353556622, 4], [975324.503883209, 8], [975324.688918983, 25], [975324.839864877, 18], [975324.987939184, 13], [975325.182956844, 55], [975325.331228808, 11], [975325.513858677, 10], [975325.698598566, 11], [975325.848527543, 15], [975325.997789078, 17], [975326.156423632, 14], [975326.363947311, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-0d655d943681d58081721e2170c5bb2e", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.105426537, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.452129822, "time_to_first_token": 0.191756525, "token_sha": "8a91591c94a3", "tokens_per_second": 18.956106086856646}, "seed": 1234, "sent": 975312.715790977, "speculative": {"acceptance_rate": 0.4254807692307692, "accepted": 177, "drafted": 416, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.19614338700193912, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 416, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.952888222690326, "done": 975326.368131799, "finish_reason": "length", "first": 975312.912225682, "full_response_s": 13.647194276098162, "last": 975326.366639437, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975312.912225682, 3], [975313.066879416, 11], [975313.250626, 30], [975313.434406518, 19], [975313.617880584, 21], [975313.797760062, 15], [975313.94543585, 19], [975314.100530439, 17], [975314.283517218, 12], [975314.465910244, 5], [975314.613219758, 5], [975314.797516522, 18], [975314.979210556, 21], [975315.169515187, 9], [975315.352153187, 9], [975315.499488355, 16], [975315.681484186, 5], [975315.865306529, 14], [975316.051982213, 9], [975316.201702212, 22], [975316.350485189, 10], [975316.532486804, 7], [975316.712700997, 23], [975316.864744097, 5], [975317.012739701, 9], [975317.201691933, 14], [975317.352498635, 20], [975317.500623962, 8], [975317.647182051, 12], [975317.793943076, 5], [975317.941764533, 14], [975318.13425138, 14], [975318.280951566, 8], [975318.465297607, 13], [975318.634758816, 3], [975318.817585617, 10], [975318.966959711, 11], [975319.158108615, 9], [975319.340823539, 10], [975319.523792934, 20], [975319.67324701, 14], [975319.852625977, 14], [975320.088568535, 13], [975320.274245519, 5], [975320.458112777, 22], [975320.684620382, 3], [975320.920527186, 32], [975321.113858762, 33], [975321.299595336, 11], [975321.478958622, 6], [975321.628619326, 8], [975321.776995053, 9], [975321.92678355, 13], [975322.082786062, 8], [975322.233764725, 20], [975322.384186976, 17], [975322.568104983, 20], [975322.71809645, 13], [975322.894654921, 6], [975323.084613373, 13], [975323.235269861, 9], [975323.383854186, 11], [975323.534585152, 8], [975323.717075971, 15], [975323.89907278, 16], [975324.12181992, 27], [975324.354936172, 4], [975324.50467958, 8], [975324.688851674, 25], [975324.840734446, 18], [975324.988706708, 13], [975325.182234566, 55], [975325.332527113, 11], [975325.518804162, 10], [975325.697544844, 11], [975325.848925545, 15], [975325.996542739, 17], [975326.155684971, 14], [975326.366639437, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-e329965d4e63c880f906fef46d0d78ee", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.105803275, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.454678786, "time_to_first_token": 0.189407171, "token_sha": "8a91591c94a3", "tokens_per_second": 18.95251488763412}, "seed": 1234, "sent": 975312.720937523, "speculative": {"acceptance_rate": 0.42961165048543687, "accepted": 177, "drafted": 412, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.191288159112446, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 412, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.955267697747583, "done": 975326.366494691, "finish_reason": "length", "first": 975312.911867935, "full_response_s": 13.651082228054293, "last": 975326.364592743, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975312.911867935, 3], [975313.067971408, 11], [975313.254130767, 30], [975313.43327952, 19], [975313.618364006, 21], [975313.798055507, 15], [975313.946530242, 19], [975314.101953411, 17], [975314.284162283, 12], [975314.465380199, 5], [975314.612849852, 5], [975314.797287618, 27], [975314.979326536, 12], [975315.169068403, 13], [975315.351714771, 5], [975315.499270859, 16], [975315.680985213, 5], [975315.864892465, 14], [975316.05153199, 9], [975316.203956785, 22], [975316.348921134, 10], [975316.531487369, 7], [975316.711532416, 23], [975316.861325022, 5], [975317.012624393, 9], [975317.201466534, 14], [975317.350790409, 20], [975317.501604806, 8], [975317.6475849, 12], [975317.794911857, 5], [975317.943828569, 14], [975318.13316542, 14], [975318.283993118, 8], [975318.465053247, 13], [975318.635643471, 3], [975318.819277603, 10], [975318.965854615, 11], [975319.158429339, 9], [975319.340710967, 10], [975319.522514517, 20], [975319.672907902, 14], [975319.853114856, 14], [975320.088936281, 13], [975320.272250983, 5], [975320.45583742, 22], [975320.683648946, 3], [975320.919961654, 32], [975321.112616872, 33], [975321.295931501, 11], [975321.480872936, 6], [975321.629958157, 8], [975321.776328294, 9], [975321.927759675, 13], [975322.08266669, 8], [975322.232425574, 20], [975322.383305536, 17], [975322.568192052, 20], [975322.717897497, 13], [975322.894704263, 6], [975323.084570926, 13], [975323.23603001, 9], [975323.383624162, 11], [975323.534231885, 8], [975323.716140773, 15], [975323.900578373, 16], [975324.119614752, 27], [975324.355323374, 4], [975324.503144692, 8], [975324.688316349, 25], [975324.840417417, 18], [975324.989227633, 13], [975325.182148121, 55], [975325.332250451, 11], [975325.516356523, 10], [975325.697257927, 11], [975325.847986907, 15], [975325.997148861, 17], [975326.157242947, 14], [975326.364592743, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-096dfa2f0aff97af440b162027c24ecf", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.10538817, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.45229652, "time_to_first_token": 0.192451204, "token_sha": "8a91591c94a3", "tokens_per_second": 18.955871186817994}, "seed": 1234, "sent": 975312.715412463, "speculative": {"acceptance_rate": 0.423444976076555, "accepted": 177, "drafted": 418, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.19645547203253955, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 418, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.955608969166942, "done": 975326.364331457, "finish_reason": "length", "first": 975312.911824257, "full_response_s": 13.651919699972495, "last": 975326.364306866, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975312.911824257, 3], [975313.067860068, 11], [975313.251410867, 30], [975313.434166575, 19], [975313.616227653, 21], [975313.799904063, 15], [975313.947440625, 19], [975314.101154496, 17], [975314.284055615, 12], [975314.464899673, 5], [975314.61524218, 5], [975314.797330577, 27], [975314.979154798, 12], [975315.172310844, 13], [975315.352290958, 5], [975315.500280262, 16], [975315.682193488, 5], [975315.865035867, 14], [975316.050738355, 9], [975316.20404819, 22], [975316.34837397, 10], [975316.531702033, 7], [975316.712046957, 23], [975316.861198243, 5], [975317.012090541, 9], [975317.202462273, 14], [975317.34978131, 20], [975317.499792825, 8], [975317.646550282, 12], [975317.795408015, 5], [975317.941564972, 14], [975318.133461361, 14], [975318.280305701, 8], [975318.464785529, 13], [975318.634203012, 3], [975318.816983191, 10], [975318.96473432, 11], [975319.159132338, 9], [975319.34173669, 10], [975319.522591698, 20], [975319.671882019, 14], [975319.854196656, 14], [975320.088237123, 13], [975320.273422045, 5], [975320.457562845, 22], [975320.684220669, 3], [975320.920784744, 32], [975321.112075931, 33], [975321.296492105, 11], [975321.479308497, 6], [975321.630272402, 8], [975321.776238729, 9], [975321.925990795, 13], [975322.082277041, 8], [975322.233867761, 20], [975322.384593777, 17], [975322.567124587, 20], [975322.717526615, 13], [975322.893972994, 6], [975323.084050369, 13], [975323.233826154, 9], [975323.384104913, 11], [975323.533783597, 8], [975323.715456494, 15], [975323.900973447, 16], [975324.12103758, 27], [975324.355371196, 4], [975324.503213953, 8], [975324.688028456, 25], [975324.840681759, 18], [975324.989721568, 13], [975325.181454147, 55], [975325.331103597, 11], [975325.5127871, 10], [975325.69949367, 11], [975325.84795382, 15], [975325.996945604, 17], [975326.156379314, 14], [975326.364306866, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-95fa7c529520e9f6e97baa738b60b14a", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.105277375, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.452288712, "time_to_first_token": 0.195615279, "token_sha": "8a91591c94a3", "tokens_per_second": 18.955882189216577}, "seed": 1234, "sent": 975312.712411757, "speculative": {"acceptance_rate": 0.4194312796208531, "accepted": 177, "drafted": 422, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.19941250002011657, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 422, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.957929119668478, "done": 975326.365669776, "finish_reason": "length", "first": 975312.912862826, "full_response_s": 13.650421274942346, "last": 975326.363699064, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975312.912862826, 3], [975313.065902444, 11], [975313.251245001, 30], [975313.434883173, 19], [975313.615886481, 21], [975313.798150575, 15], [975313.946279227, 19], [975314.101210366, 17], [975314.284910095, 12], [975314.466311221, 5], [975314.612123143, 5], [975314.797905691, 27], [975314.97960507, 12], [975315.170252792, 13], [975315.352988164, 5], [975315.501019962, 16], [975315.682281165, 5], [975315.864433377, 14], [975316.052529105, 9], [975316.205238722, 22], [975316.350853895, 10], [975316.530245638, 7], [975316.714427606, 23], [975316.862399655, 5], [975317.012240951, 9], [975317.203492459, 14], [975317.349424555, 20], [975317.501355759, 8], [975317.647404203, 12], [975317.794730376, 5], [975317.943764316, 14], [975318.135182706, 14], [975318.281262034, 8], [975318.46338878, 13], [975318.634913626, 3], [975318.819052635, 10], [975318.965943188, 11], [975319.158203124, 9], [975319.341372911, 10], [975319.524209495, 20], [975319.671285657, 14], [975319.851626382, 14], [975320.089961764, 13], [975320.273475099, 5], [975320.454933117, 22], [975320.684132832, 3], [975320.920219357, 32], [975321.112983514, 33], [975321.296239122, 11], [975321.478814083, 6], [975321.628978337, 8], [975321.777568009, 9], [975321.927623648, 13], [975322.083199471, 8], [975322.233524958, 20], [975322.385094431, 17], [975322.567737605, 20], [975322.717600388, 13], [975322.894855458, 6], [975323.08589363, 13], [975323.235486669, 9], [975323.386691538, 11], [975323.533469208, 8], [975323.716275072, 15], [975323.900516887, 16], [975324.120429267, 27], [975324.353225418, 4], [975324.506311569, 8], [975324.688507254, 25], [975324.841535456, 18], [975324.989009209, 13], [975325.180007495, 55], [975325.331294534, 11], [975325.513078098, 10], [975325.697365171, 11], [975325.846820117, 15], [975325.997836868, 17], [975326.15649091, 14], [975326.363699064, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b6988f6ed477e7bebb5735fc2dbadb53", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.10560837, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.451968324, "time_to_first_token": 0.189855251, "token_sha": "8a91591c94a3", "tokens_per_second": 18.956333664943887}, "seed": 1234, "sent": 975312.715248501, "speculative": {"acceptance_rate": 0.4254807692307692, "accepted": 177, "drafted": 416, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.19761432497762144, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 416, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.95587592142383, "done": 975326.364753026, "finish_reason": "length", "first": 975312.912421691, "full_response_s": 13.652066863025539, "last": 975326.364714851, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975312.912421691, 3], [975313.067764615, 11], [975313.250228654, 30], [975313.434631774, 19], [975313.615713944, 21], [975313.798801624, 15], [975313.948578919, 19], [975314.102165419, 17], [975314.284405906, 12], [975314.465850006, 5], [975314.615435837, 5], [975314.797693715, 27], [975314.979468563, 12], [975315.171390254, 13], [975315.354561114, 5], [975315.500308181, 16], [975315.680849986, 5], [975315.864841986, 14], [975316.053208328, 9], [975316.203367719, 22], [975316.349604469, 10], [975316.532686589, 7], [975316.714061283, 23], [975316.862312634, 5], [975317.011101393, 9], [975317.204039623, 14], [975317.350468261, 20], [975317.49877947, 8], [975317.647020249, 12], [975317.796096422, 5], [975317.942299505, 14], [975318.137881263, 14], [975318.282552547, 8], [975318.463882234, 13], [975318.636266793, 3], [975318.818660457, 10], [975318.965900806, 11], [975319.157395633, 9], [975319.341604887, 10], [975319.524531563, 20], [975319.671545824, 14], [975319.851905124, 14], [975320.089123491, 13], [975320.275313896, 5], [975320.456941027, 22], [975320.684957458, 3], [975320.922193413, 32], [975321.113432186, 33], [975321.296129446, 11], [975321.480391497, 6], [975321.628820711, 8], [975321.776706072, 9], [975321.926267953, 13], [975322.083318203, 8], [975322.233167691, 20], [975322.385683769, 17], [975322.567694678, 20], [975322.717825372, 13], [975322.894158539, 6], [975323.085774882, 13], [975323.232828782, 9], [975323.38819422, 11], [975323.534083858, 8], [975323.715775794, 15], [975323.899394928, 16], [975324.120342182, 27], [975324.354673541, 4], [975324.505386242, 8], [975324.688667296, 25], [975324.840487638, 18], [975324.988877518, 13], [975325.182487949, 55], [975325.329928071, 11], [975325.517713561, 10], [975325.701615129, 11], [975325.849254445, 15], [975325.996639119, 17], [975326.158039734, 14], [975326.364714851, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-3f534f98a18118e08d075e61eb725ca6", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.105528277, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.452431379, "time_to_first_token": 0.190891389, "token_sha": "8a91591c94a3", "tokens_per_second": 18.955681156498542}, "seed": 1234, "sent": 975312.712686163, "speculative": {"acceptance_rate": 0.4254807692307692, "accepted": 177, "drafted": 416, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1997355279745534, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 416, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.95646328275437, "done": 975326.364825615, "finish_reason": "length", "first": 975312.912918136, "full_response_s": 13.64857820700854, "last": 975326.36479448, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975312.912918136, 3], [975313.06746317, 11], [975313.250744827, 30], [975313.434938451, 19], [975313.616594631, 21], [975313.79911382, 15], [975313.947340948, 19], [975314.100768222, 17], [975314.285699714, 12], [975314.465161727, 5], [975314.612036346, 5], [975314.796779541, 27], [975314.980114763, 12], [975315.170859265, 13], [975315.353637884, 5], [975315.500604346, 16], [975315.681552536, 5], [975315.86469628, 14], [975316.052232524, 9], [975316.202148499, 22], [975316.350911925, 10], [975316.531903194, 7], [975316.712994906, 23], [975316.863241688, 5], [975317.011319785, 9], [975317.201380761, 14], [975317.349147509, 20], [975317.499697932, 8], [975317.646599432, 12], [975317.795914028, 5], [975317.942616486, 14], [975318.135311597, 14], [975318.280569596, 8], [975318.46552531, 13], [975318.635137314, 3], [975318.818062527, 10], [975318.967427806, 11], [975319.159726524, 9], [975319.343051506, 10], [975319.523497025, 20], [975319.67311943, 14], [975319.851846006, 14], [975320.090537535, 13], [975320.275129854, 5], [975320.45664515, 22], [975320.684286138, 3], [975320.921060606, 32], [975321.112414559, 33], [975321.295640952, 11], [975321.480246927, 6], [975321.627510311, 8], [975321.776895713, 9], [975321.928221594, 13], [975322.081837697, 8], [975322.234158582, 20], [975322.384484133, 17], [975322.569135426, 20], [975322.718394199, 13], [975322.895526969, 6], [975323.086349965, 13], [975323.234451443, 9], [975323.383745726, 11], [975323.532459613, 8], [975323.71780476, 15], [975323.901191439, 16], [975324.120809045, 27], [975324.355842315, 4], [975324.503692192, 8], [975324.689607422, 25], [975324.841725642, 18], [975324.988806161, 13], [975325.181595677, 55], [975325.331953406, 11], [975325.513357031, 10], [975325.697984908, 11], [975325.847454622, 15], [975325.996775162, 17], [975326.154885512, 14], [975326.36479448, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-ffb87eaaefe4e064fd20c8add0a864ba", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.105646497, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.452158157, "time_to_first_token": 0.189963232, "token_sha": "8a91591c94a3", "tokens_per_second": 18.95606615859683}, "seed": 1234, "sent": 975312.716247408, "speculative": {"acceptance_rate": 0.4254807692307692, "accepted": 177, "drafted": 416, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1966707280371338, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 416, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.955785425407726, "done": 975326.365717583, "finish_reason": "length", "first": 975312.91173658, "full_response_s": 13.65342241304461, "last": 975326.364093962, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975312.91173658, 3], [975313.066262175, 11], [975313.253843305, 30], [975313.435441552, 19], [975313.616025932, 21], [975313.799747237, 15], [975313.948241699, 19], [975314.101705004, 17], [975314.285280642, 12], [975314.465053827, 5], [975314.615055339, 5], [975314.796664233, 27], [975314.980364882, 12], [975315.170083166, 13], [975315.354515884, 5], [975315.499620238, 16], [975315.68105729, 5], [975315.864346964, 14], [975316.051295038, 9], [975316.202570484, 22], [975316.349549111, 10], [975316.531184564, 7], [975316.712226214, 23], [975316.863922191, 5], [975317.011826806, 9], [975317.204142868, 14], [975317.350111922, 20], [975317.498659266, 8], [975317.645876195, 12], [975317.794338854, 5], [975317.942736337, 14], [975318.134047915, 14], [975318.282464646, 8], [975318.464021125, 13], [975318.635204864, 3], [975318.818595212, 10], [975318.966308951, 11], [975319.1563242, 9], [975319.342967013, 10], [975319.524700773, 20], [975319.671745032, 14], [975319.851183886, 14], [975320.088798142, 13], [975320.272643817, 5], [975320.457231657, 22], [975320.68401802, 3], [975320.921403698, 32], [975321.114028836, 33], [975321.2957397, 11], [975321.4799786, 6], [975321.629116396, 8], [975321.776189387, 9], [975321.926219939, 13], [975322.082931193, 8], [975322.234753041, 20], [975322.385324519, 17], [975322.567416144, 20], [975322.717156436, 13], [975322.89368358, 6], [975323.086588565, 13], [975323.236108391, 9], [975323.383487079, 11], [975323.535267239, 8], [975323.716918665, 15], [975323.901317738, 16], [975324.121629255, 27], [975324.355135972, 4], [975324.50341985, 8], [975324.687670213, 25], [975324.841290697, 18], [975324.989673473, 13], [975325.180917606, 55], [975325.332745521, 11], [975325.517071729, 10], [975325.69866338, 11], [975325.84734589, 15], [975325.997202139, 17], [975326.157636852, 14], [975326.364093962, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-37aa8773dc1419e25b8cb3939c61922c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.105355612, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.452518224, "time_to_first_token": 0.192350711, "token_sha": "8a91591c94a3", "tokens_per_second": 18.955558784902188}, "seed": 1234, "sent": 975312.71229517, "speculative": {"acceptance_rate": 0.423444976076555, "accepted": 177, "drafted": 418, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.19944141001906246, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 418, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.688226938460293, "done": 975326.365888233, "finish_reason": "length", "first": 975312.720897557, "full_response_s": 13.653679459937848, "last": 975326.365851722, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975312.720897557, 3], [975312.806521635, 26], [975313.066035303, 15], [975313.251975246, 19], [975313.435648648, 21], [975313.617376874, 15], [975313.797852954, 19], [975313.944969596, 17], [975314.10034139, 6], [975314.284731638, 11], [975314.465287531, 5], [975314.615366751, 18], [975314.798057062, 21], [975314.980231607, 5], [975315.169850614, 8], [975315.351495179, 5], [975315.499031635, 16], [975315.680612458, 5], [975315.866175425, 14], [975316.051381339, 9], [975316.203622109, 22], [975316.34981659, 10], [975316.529798983, 7], [975316.71282248, 23], [975316.861672065, 5], [975317.011507362, 9], [975317.199797667, 14], [975317.348447359, 20], [975317.49761476, 8], [975317.647850171, 12], [975317.794791893, 5], [975317.942037675, 14], [975318.135756765, 14], [975318.281122743, 8], [975318.464722636, 13], [975318.634303728, 3], [975318.82001396, 10], [975318.964871547, 11], [975319.158768575, 9], [975319.339809304, 10], [975319.523316088, 20], [975319.671382182, 14], [975319.852032223, 14], [975320.088357695, 13], [975320.273573863, 5], [975320.456461397, 22], [975320.68447106, 3], [975320.921597691, 32], [975321.112225494, 33], [975321.297208303, 11], [975321.482357698, 6], [975321.626950475, 8], [975321.778221041, 9], [975321.926147669, 13], [975322.082196451, 8], [975322.23286639, 20], [975322.384814073, 17], [975322.567206264, 20], [975322.717267248, 13], [975322.894816835, 6], [975323.083763339, 13], [975323.233479639, 9], [975323.383371035, 11], [975323.534861782, 8], [975323.715590201, 15], [975323.898746472, 16], [975324.11902463, 27], [975324.353665274, 4], [975324.505738342, 8], [975324.688542229, 25], [975324.840884536, 18], [975324.988770514, 13], [975325.182605049, 55], [975325.329781437, 11], [975325.518175977, 10], [975325.697624073, 11], [975325.849481909, 15], [975325.996742076, 17], [975326.156635657, 14], [975326.365851722, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b98b967f2184792ccc97bf1ddfd79af2", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.002250494, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.647420617, "time_to_first_token": 0.002886853, "token_sha": "8a91591c94a3", "tokens_per_second": 18.684849478615583}, "seed": 1234, "sent": 975312.712208773, "speculative": {"acceptance_rate": 0.4055299539170507, "accepted": 176, "drafted": 434, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.008688783971592784, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 434, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.958949109649218, "done": 975326.366422069, "finish_reason": "length", "first": 975312.913717243, "full_response_s": 13.653010701062158, "last": 975326.363829827, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975312.913717243, 3], [975313.066521637, 11], [975313.252579, 30], [975313.433397723, 19], [975313.617184993, 21], [975313.798181982, 15], [975313.94816375, 19], [975314.100682753, 17], [975314.285197301, 12], [975314.46714127, 5], [975314.614938815, 5], [975314.797984569, 27], [975314.97926049, 12], [975315.17056078, 13], [975315.354790626, 5], [975315.4998825, 16], [975315.681197461, 5], [975315.866368138, 14], [975316.053151498, 9], [975316.204546012, 22], [975316.350037141, 10], [975316.532612144, 7], [975316.713275104, 23], [975316.863122412, 5], [975317.013718705, 9], [975317.200116471, 14], [975317.351312054, 20], [975317.497959852, 8], [975317.646772002, 12], [975317.794074896, 5], [975317.942994616, 14], [975318.133735303, 14], [975318.282120595, 8], [975318.463708369, 13], [975318.634857948, 3], [975318.817786409, 10], [975318.965050101, 11], [975319.157500589, 9], [975319.342388554, 10], [975319.523647275, 20], [975319.672285541, 14], [975319.852714214, 14], [975320.088887531, 13], [975320.272567612, 5], [975320.455358973, 22], [975320.683799852, 3], [975320.922043786, 32], [975321.113210066, 33], [975321.296412284, 11], [975321.479886284, 6], [975321.629688887, 8], [975321.777625782, 9], [975321.927813833, 13], [975322.082994838, 8], [975322.233822803, 20], [975322.385576349, 17], [975322.568266546, 20], [975322.717400107, 13], [975322.894932927, 6], [975323.083975876, 13], [975323.235758212, 9], [975323.382856206, 11], [975323.531988702, 8], [975323.71654903, 15], [975323.900222322, 16], [975324.11990479, 27], [975324.354083947, 4], [975324.50380526, 8], [975324.68950037, 25], [975324.841781688, 18], [975324.990322874, 13], [975325.180232703, 55], [975325.332640565, 11], [975325.519160245, 10], [975325.696974273, 11], [975325.848353246, 15], [975325.997611788, 17], [975326.156144186, 14], [975326.363829827, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-0fbc612ee1fd3f72ae5a62b06887a723", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.105233008, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.452363878, "time_to_first_token": 0.197410109, "token_sha": "8a91591c94a3", "tokens_per_second": 18.955776271932926}, "seed": 1234, "sent": 975312.713411368, "speculative": {"acceptance_rate": 0.41843971631205673, "accepted": 177, "drafted": 423, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.20030587504152209, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 423, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.95590876797273, "done": 975326.365107397, "finish_reason": "length", "first": 975312.912804956, "full_response_s": 13.651898965006694, "last": 975326.365074806, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975312.912804956, 3], [975313.066369451, 11], [975313.252843006, 30], [975313.433091654, 19], [975313.616394702, 21], [975313.799282374, 15], [975313.94762929, 19], [975314.10045825, 17], [975314.284476319, 12], [975314.468455302, 5], [975314.614537806, 5], [975314.798335292, 18], [975314.980690662, 21], [975315.171917819, 9], [975315.352751341, 9], [975315.501340735, 16], [975315.68172333, 5], [975315.86420065, 14], [975316.050905821, 9], [975316.202969269, 22], [975316.350667326, 10], [975316.530615369, 7], [975316.712927693, 23], [975316.863791972, 5], [975317.01282309, 9], [975317.200498729, 14], [975317.352812639, 20], [975317.500979389, 8], [975317.6474842, 12], [975317.795510123, 5], [975317.942913211, 14], [975318.136501345, 14], [975318.283609692, 8], [975318.463966503, 13], [975318.635484661, 3], [975318.819724018, 10], [975318.96721079, 11], [975319.160258472, 9], [975319.340508191, 10], [975319.524641543, 20], [975319.672820609, 14], [975319.851707179, 14], [975320.090261289, 13], [975320.273161926, 5], [975320.455139685, 22], [975320.683929303, 3], [975320.922878444, 32], [975321.113927688, 33], [975321.299115385, 11], [975321.482824897, 6], [975321.630573911, 8], [975321.776774278, 9], [975321.926728544, 13], [975322.081885871, 8], [975322.23308507, 20], [975322.382998187, 17], [975322.567319316, 20], [975322.718762714, 13], [975322.89386983, 6], [975323.083839385, 13], [975323.235126075, 9], [975323.384520529, 11], [975323.533998725, 8], [975323.716488328, 15], [975323.899936604, 16], [975324.11912701, 27], [975324.354839439, 4], [975324.504271963, 8], [975324.689972161, 25], [975324.840280862, 18], [975324.990154784, 13], [975325.181111087, 55], [975325.330538833, 11], [975325.513696459, 10], [975325.701977067, 11], [975325.848623508, 15], [975325.996150465, 17], [975326.155797559, 14], [975326.365074806, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-fda8d54512021a4ff4180e3483e26cb0", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.105763596, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.452069585, "time_to_first_token": 0.189830884, "token_sha": "8a91591c94a3", "tokens_per_second": 18.956190970372532}, "seed": 1234, "sent": 975312.713208432, "speculative": {"acceptance_rate": 0.42961165048543687, "accepted": 177, "drafted": 412, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.19959652400575578, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 412, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.956442969222152, "done": 975326.365499863, "finish_reason": "length", "first": 975312.912485304, "full_response_s": 13.653389471000992, "last": 975326.364376063, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975312.912485304, 3], [975313.066943397, 11], [975313.253055974, 30], [975313.435155851, 19], [975313.616713747, 21], [975313.800163669, 15], [975313.949171393, 19], [975314.102548589, 17], [975314.285568855, 12], [975314.465720171, 5], [975314.612990599, 5], [975314.796898352, 18], [975314.980430959, 21], [975315.170970685, 13], [975315.353990463, 5], [975315.499814855, 16], [975315.682046502, 5], [975315.866896407, 14], [975316.05164381, 9], [975316.204485662, 22], [975316.350225983, 10], [975316.52966022, 7], [975316.71234317, 23], [975316.862546961, 5], [975317.011568368, 9], [975317.201829448, 14], [975317.35120081, 20], [975317.500060959, 8], [975317.647792477, 12], [975317.79417374, 5], [975317.942465787, 14], [975318.136904659, 14], [975318.28120282, 8], [975318.463495768, 13], [975318.634821502, 3], [975318.818184635, 10], [975318.965375225, 11], [975319.157668423, 9], [975319.342041255, 10], [975319.524755283, 20], [975319.672014191, 14], [975319.851070482, 14], [975320.088666499, 13], [975320.275221627, 5], [975320.456252524, 22], [975320.684905124, 3], [975320.922650596, 32], [975321.113616147, 33], [975321.298508671, 11], [975321.479356111, 6], [975321.628939266, 8], [975321.777216917, 9], [975321.927962163, 13], [975322.081749028, 8], [975322.233645609, 20], [975322.383375437, 17], [975322.56781133, 20], [975322.718572097, 13], [975322.893805448, 6], [975323.085198311, 13], [975323.234719273, 9], [975323.387054005, 11], [975323.531900209, 8], [975323.71864801, 15], [975323.899292724, 16], [975324.121433182, 27], [975324.353871378, 4], [975324.506381966, 8], [975324.688254879, 25], [975324.841021699, 18], [975324.990270412, 13], [975325.183311407, 55], [975325.330431221, 11], [975325.513145087, 10], [975325.698234803, 11], [975325.847132762, 15], [975325.99622987, 17], [975326.155999952, 14], [975326.364376063, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-81145b1b100b731cb51855eeee63656a", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.105726446, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.45218646, "time_to_first_token": 0.189741304, "token_sha": "8a91591c94a3", "tokens_per_second": 18.95602627559773}, "seed": 1234, "sent": 975312.712110392, "speculative": {"acceptance_rate": 0.42650602409638555, "accepted": 177, "drafted": 415, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.20037491200491786, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 415, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.953151021546258, "done": 975339.974580682, "finish_reason": "length", "first": 975326.520303308, "full_response_s": 13.581061098957434, "last": 975339.974530508, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975326.520303308, 3], [975326.669786802, 11], [975326.853404805, 30], [975327.040552286, 19], [975327.226645245, 21], [975327.409030531, 15], [975327.557902709, 19], [975327.704005756, 17], [975327.850857577, 6], [975327.999899276, 8], [975328.189571633, 3], [975328.359549055, 5], [975328.543932996, 27], [975328.727384266, 12], [975328.911741156, 13], [975329.102753281, 5], [975329.273174053, 16], [975329.455901822, 5], [975329.638837566, 14], [975329.82223571, 9], [975330.005581128, 27], [975330.158956746, 11], [975330.346083915, 8], [975330.490135102, 16], [975330.639656748, 5], [975330.78773619, 9], [975330.96417567, 14], [975331.116482214, 20], [975331.267712476, 8], [975331.41745212, 12], [975331.568645744, 5], [975331.716708712, 14], [975331.864503388, 11], [975332.013677107, 3], [975332.204831762, 8], [975332.374232785, 13], [975332.556017233, 3], [975332.739973924, 11], [975332.926221625, 10], [975333.115102386, 9], [975333.303640263, 10], [975333.485740628, 20], [975333.66773946, 14], [975333.813525755, 14], [975333.995829064, 13], [975334.186818237, 5], [975334.37166571, 14], [975334.554651027, 11], [975334.739349162, 59], [975334.929303417, 6], [975335.084232627, 11], [975335.271512677, 6], [975335.42258673, 8], [975335.569397031, 9], [975335.718610847, 13], [975335.868353462, 8], [975336.017341323, 20], [975336.176784906, 17], [975336.363233345, 29], [975336.510778635, 6], [975336.695787894, 16], [975336.846225529, 6], [975336.996618114, 15], [975337.152944903, 8], [975337.338968213, 15], [975337.523621956, 16], [975337.737393329, 27], [975337.973504454, 4], [975338.133494878, 8], [975338.31665921, 25], [975338.468220192, 18], [975338.618133009, 13], [975338.804164342, 64], [975338.952080324, 2], [975339.147879604, 10], [975339.317620263, 11], [975339.470503107, 15], [975339.617957074, 17], [975339.793939542, 14], [975339.974530508, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-6e7398c275a368e1df271b207984142b", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034711845, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.455726217, "time_to_first_token": 0.12393042, "token_sha": "8a91591c94a3", "tokens_per_second": 18.95103957137834}, "seed": 1234, "sent": 975326.393519583, "speculative": {"acceptance_rate": 0.44221105527638194, "accepted": 176, "drafted": 398, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12678372499067336, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 398, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.95304840433428, "done": 975339.975982248, "finish_reason": "length", "first": 975326.520491589, "full_response_s": 13.583138335961848, "last": 975339.974791634, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975326.520491589, 3], [975326.669741188, 11], [975326.853623981, 30], [975327.040185435, 19], [975327.226465668, 21], [975327.409960225, 15], [975327.556947208, 19], [975327.705571027, 17], [975327.851344856, 6], [975327.999699747, 8], [975328.189849207, 3], [975328.360974027, 5], [975328.542812716, 27], [975328.724955682, 12], [975328.91169543, 13], [975329.102170262, 5], [975329.271282618, 16], [975329.453859895, 5], [975329.638559304, 14], [975329.822736684, 9], [975330.005206821, 27], [975330.159306254, 11], [975330.343334735, 8], [975330.489947509, 16], [975330.639431396, 5], [975330.788850517, 9], [975330.960915532, 14], [975331.117991456, 20], [975331.270644483, 8], [975331.418054962, 12], [975331.567508265, 5], [975331.714064967, 14], [975331.862765067, 11], [975332.013637204, 7], [975332.205500202, 17], [975332.37320223, 3], [975332.556265112, 10], [975332.739535428, 11], [975332.925708715, 10], [975333.1139279, 20], [975333.301207806, 23], [975333.485217479, 14], [975333.665494293, 13], [975333.813158568, 5], [975333.994808332, 14], [975334.187272012, 11], [975334.3707232, 43], [975334.553917117, 22], [975334.739155953, 11], [975334.930137163, 6], [975335.083942926, 8], [975335.270268962, 9], [975335.42263892, 13], [975335.570834388, 8], [975335.719080126, 20], [975335.868781654, 17], [975336.017389209, 20], [975336.175977623, 13], [975336.361188555, 6], [975336.509663891, 12], [975336.69450306, 6], [975336.845709499, 9], [975336.994701303, 6], [975337.154225321, 8], [975337.338133891, 15], [975337.524624065, 16], [975337.737670504, 27], [975337.971744581, 4], [975338.131774236, 8], [975338.319344442, 25], [975338.465413604, 18], [975338.618189455, 13], [975338.803985276, 64], [975338.952249358, 2], [975339.147268378, 10], [975339.317441965, 11], [975339.46751579, 15], [975339.61864081, 17], [975339.793502133, 14], [975339.974791634, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-94c6611e788075ff683d05bae577d19c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034603033, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.455637069, "time_to_first_token": 0.124430674, "token_sha": "8a91591c94a3", "tokens_per_second": 18.951165128218726}, "seed": 1234, "sent": 975326.392843912, "speculative": {"acceptance_rate": 0.4467005076142132, "accepted": 176, "drafted": 394, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1276476769708097, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 394, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.953087350706596, "done": 975339.975111047, "finish_reason": "length", "first": 975326.520796682, "full_response_s": 13.582709070993587, "last": 975339.97506908, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975326.520796682, 3], [975326.671364825, 11], [975326.854170634, 30], [975327.040705881, 19], [975327.227251975, 21], [975327.40925865, 15], [975327.556750879, 19], [975327.704113448, 17], [975327.850580707, 6], [975327.99973557, 8], [975328.191241877, 3], [975328.359963408, 5], [975328.543112737, 27], [975328.724437173, 12], [975328.910778999, 13], [975329.102299505, 5], [975329.272336596, 16], [975329.457104834, 5], [975329.640580943, 14], [975329.82375732, 9], [975330.004427969, 27], [975330.158757154, 11], [975330.345554366, 8], [975330.491154618, 16], [975330.640702422, 5], [975330.788540657, 9], [975330.961511718, 14], [975331.117142606, 20], [975331.266942104, 8], [975331.418602207, 12], [975331.567274945, 5], [975331.715800841, 14], [975331.863753911, 11], [975332.014059733, 7], [975332.204730598, 17], [975332.376623403, 3], [975332.555910901, 10], [975332.740254746, 11], [975332.928191522, 10], [975333.114118309, 20], [975333.300801197, 23], [975333.486273345, 14], [975333.664621316, 13], [975333.813015597, 5], [975333.996346885, 14], [975334.186562278, 11], [975334.372048064, 43], [975334.554929929, 22], [975334.74024305, 11], [975334.93055958, 6], [975335.084536472, 8], [975335.270755152, 9], [975335.420753244, 13], [975335.570489216, 8], [975335.722047732, 20], [975335.867916133, 17], [975336.016983048, 20], [975336.177083151, 13], [975336.361778342, 6], [975336.512459375, 12], [975336.693819564, 6], [975336.844500998, 9], [975336.994991308, 6], [975337.152053591, 8], [975337.341820335, 15], [975337.524111459, 16], [975337.739027431, 27], [975337.972512857, 4], [975338.132758152, 8], [975338.318323775, 25], [975338.466409313, 18], [975338.617418506, 13], [975338.801494645, 64], [975338.951196355, 2], [975339.147748185, 10], [975339.317267347, 11], [975339.467720807, 15], [975339.61942203, 17], [975339.79303687, 14], [975339.97506908, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-cb2517a8d1291928284abec5149003ef", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034640072, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.455627069, "time_to_first_token": 0.124073375, "token_sha": "8a91591c94a3", "tokens_per_second": 18.951179212411926}, "seed": 1234, "sent": 975326.392401976, "speculative": {"acceptance_rate": 0.45012787723785164, "accepted": 176, "drafted": 391, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1283947059419006, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 391, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.95489113967487, "done": 975339.973923345, "finish_reason": "length", "first": 975326.520877719, "full_response_s": 13.581472603022121, "last": 975339.973869779, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975326.520877719, 3], [975326.671729836, 11], [975326.85471183, 30], [975327.040041505, 19], [975327.22713382, 21], [975327.409628269, 15], [975327.558955887, 19], [975327.705476215, 17], [975327.850911895, 6], [975328.000084069, 8], [975328.191696613, 3], [975328.361428123, 5], [975328.54498539, 29], [975328.724876917, 10], [975328.912576262, 13], [975329.102216772, 5], [975329.272808931, 16], [975329.45550774, 5], [975329.637550989, 16], [975329.821286257, 7], [975330.004830163, 27], [975330.159396971, 11], [975330.344148625, 8], [975330.489902119, 16], [975330.641913707, 5], [975330.78933066, 9], [975330.964080954, 14], [975331.117237019, 20], [975331.267804457, 12], [975331.416659861, 8], [975331.565509985, 5], [975331.714821564, 14], [975331.863832724, 14], [975332.013166229, 8], [975332.20524074, 13], [975332.377158183, 3], [975332.557117274, 10], [975332.738936841, 11], [975332.927898236, 10], [975333.114274719, 20], [975333.299868159, 23], [975333.484206907, 14], [975333.664702737, 13], [975333.813460861, 5], [975333.995953987, 14], [975334.187833016, 11], [975334.370051208, 43], [975334.553408127, 22], [975334.740348582, 11], [975334.930749717, 6], [975335.085154642, 8], [975335.270098152, 9], [975335.420826361, 13], [975335.570065295, 8], [975335.720696324, 20], [975335.867809497, 21], [975336.018044146, 16], [975336.175278032, 13], [975336.360893237, 6], [975336.510985059, 12], [975336.694198911, 6], [975336.845205261, 9], [975336.994282726, 6], [975337.152145892, 8], [975337.342271535, 15], [975337.522502973, 16], [975337.738826302, 27], [975337.974126464, 4], [975338.131682959, 8], [975338.317302995, 25], [975338.465251626, 18], [975338.617704384, 13], [975338.803290245, 64], [975338.952986067, 2], [975339.145328271, 10], [975339.318227729, 11], [975339.46729175, 15], [975339.619653941, 17], [975339.792173413, 14], [975339.973869779, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b94583a30dc9cf661a234fbd60c98a39", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034397025, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.455343079, "time_to_first_token": 0.123998338, "token_sha": "8a91591c94a3", "tokens_per_second": 18.951579198153865}, "seed": 1234, "sent": 975326.392450742, "speculative": {"acceptance_rate": 0.42105263157894735, "accepted": 176, "drafted": 418, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1284269770840183, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 418, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.954404184574845, "done": 975339.974139306, "finish_reason": "length", "first": 975326.52075742, "full_response_s": 13.581625286024064, "last": 975339.974095099, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975326.52075742, 3], [975326.669664535, 11], [975326.853516401, 30], [975327.041150361, 19], [975327.227550173, 21], [975327.408751485, 15], [975327.555864511, 19], [975327.703399666, 17], [975327.850960614, 6], [975328.000209553, 8], [975328.190747879, 3], [975328.361537351, 5], [975328.54364171, 27], [975328.725193481, 12], [975328.910512544, 13], [975329.10104931, 5], [975329.271651324, 16], [975329.454470209, 5], [975329.638119624, 14], [975329.822943445, 9], [975330.004372835, 27], [975330.159506631, 11], [975330.345338342, 8], [975330.489265918, 16], [975330.642287853, 5], [975330.788612718, 9], [975330.964596647, 14], [975331.11680545, 20], [975331.26849208, 8], [975331.418967538, 12], [975331.569207963, 5], [975331.713910189, 14], [975331.864787074, 11], [975332.012558267, 7], [975332.204671816, 17], [975332.374761918, 3], [975332.556201883, 10], [975332.740498241, 11], [975332.927115464, 10], [975333.11448948, 20], [975333.299558762, 23], [975333.48567655, 14], [975333.666512384, 13], [975333.81276207, 5], [975333.99508093, 14], [975334.185371153, 11], [975334.369390224, 43], [975334.553799761, 22], [975334.739944308, 11], [975334.929730297, 6], [975335.085252847, 8], [975335.272012035, 9], [975335.421133822, 13], [975335.570389716, 8], [975335.722149936, 20], [975335.867266717, 21], [975336.016924618, 16], [975336.176272732, 13], [975336.360554961, 6], [975336.512704806, 12], [975336.694881654, 6], [975336.845277595, 9], [975336.99650175, 6], [975337.153569089, 8], [975337.343065635, 15], [975337.52451658, 16], [975337.737724774, 27], [975337.974848678, 4], [975338.133050078, 8], [975338.3187216, 25], [975338.468606626, 18], [975338.615764325, 13], [975338.803869168, 64], [975338.952725421, 2], [975339.146785739, 10], [975339.318259968, 11], [975339.470223661, 15], [975339.618518814, 17], [975339.792051177, 14], [975339.974095099, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b77628a20046802dc77e74a1876860f1", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034492174, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.455289896, "time_to_first_token": 0.123715052, "token_sha": "8a91591c94a3", "tokens_per_second": 18.951654105632212}, "seed": 1234, "sent": 975326.39251402, "speculative": {"acceptance_rate": 0.44, "accepted": 176, "drafted": 400, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12824340001679957, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 400, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.95128989935497, "done": 975339.97551788, "finish_reason": "length", "first": 975326.519921098, "full_response_s": 13.582934823003598, "last": 975339.975469578, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975326.519921098, 3], [975326.670846684, 11], [975326.853724058, 30], [975327.041242325, 19], [975327.228540953, 21], [975327.410199224, 15], [975327.556487608, 19], [975327.705214592, 17], [975327.851051202, 6], [975327.999779952, 8], [975328.189970931, 3], [975328.358732237, 5], [975328.545520394, 27], [975328.725281014, 12], [975328.911639464, 13], [975329.101503918, 5], [975329.271409989, 16], [975329.457373832, 5], [975329.64077684, 14], [975329.824246566, 9], [975330.004521918, 27], [975330.159030936, 11], [975330.343838556, 8], [975330.489822074, 16], [975330.639527441, 5], [975330.788090593, 9], [975330.963377347, 14], [975331.117498769, 20], [975331.269036796, 8], [975331.417339052, 12], [975331.565812518, 5], [975331.713837488, 14], [975331.863966416, 11], [975332.012774963, 7], [975332.20228003, 17], [975332.375281211, 3], [975332.555825832, 10], [975332.739817337, 11], [975332.92512448, 10], [975333.114914024, 20], [975333.302289767, 23], [975333.483249485, 14], [975333.667493389, 13], [975333.812938576, 5], [975333.99616518, 14], [975334.187922117, 11], [975334.370241121, 43], [975334.55421525, 22], [975334.740102991, 11], [975334.928647872, 6], [975335.083171193, 8], [975335.270564791, 9], [975335.422000015, 13], [975335.57043037, 8], [975335.721122613, 20], [975335.867548882, 17], [975336.017040662, 20], [975336.178141018, 13], [975336.364446406, 6], [975336.511091327, 12], [975336.696340626, 6], [975336.845559393, 9], [975336.995634501, 6], [975337.152842667, 8], [975337.340465056, 15], [975337.524340379, 16], [975337.738020811, 27], [975337.974940946, 4], [975338.133409953, 8], [975338.316854819, 25], [975338.46694011, 18], [975338.616144504, 13], [975338.801617265, 64], [975338.952305596, 2], [975339.146600098, 10], [975339.317929996, 11], [975339.470790681, 15], [975339.618894016, 17], [975339.79313517, 14], [975339.975469578, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-a529d01acfaf1164267c1659ed2ef724", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034529964, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.455650156, "time_to_first_token": 0.123381768, "token_sha": "8a91591c94a3", "tokens_per_second": 18.951146696266704}, "seed": 1234, "sent": 975326.392583057, "speculative": {"acceptance_rate": 0.44221105527638194, "accepted": 176, "drafted": 398, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12733804096933454, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 398, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.95283379741941, "done": 975339.973467346, "finish_reason": "length", "first": 975326.51897086, "full_response_s": 13.58053231809754, "last": 975339.973423251, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975326.51897086, 3], [975326.668955664, 11], [975326.855347871, 30], [975327.040350038, 19], [975327.22525296, 21], [975327.409867076, 15], [975327.555358961, 19], [975327.702669484, 17], [975327.851110096, 6], [975327.999482715, 8], [975328.189735995, 3], [975328.358781979, 5], [975328.542522759, 29], [975328.724059234, 10], [975328.910621004, 13], [975329.103033287, 5], [975329.270590355, 16], [975329.4564874, 5], [975329.63921576, 16], [975329.82014977, 7], [975330.004591691, 29], [975330.158875709, 10], [975330.343279073, 23], [975330.4907534, 5], [975330.642351627, 9], [975330.788488131, 14], [975330.963024976, 20], [975331.116732541, 12], [975331.269523371, 8], [975331.417388394, 5], [975331.564833305, 12], [975331.713096762, 11], [975331.863900706, 5], [975332.014303164, 8], [975332.202451192, 13], [975332.374099797, 3], [975332.554822828, 10], [975332.740831637, 11], [975332.928471192, 10], [975333.114743199, 20], [975333.301799913, 23], [975333.482972375, 14], [975333.668042329, 13], [975333.812175771, 5], [975333.994760558, 14], [975334.188059408, 11], [975334.369150073, 43], [975334.553691285, 22], [975334.739598369, 11], [975334.929021267, 6], [975335.083009135, 8], [975335.271230735, 9], [975335.42157251, 13], [975335.569790649, 8], [975335.721860506, 20], [975335.869124906, 21], [975336.017901559, 16], [975336.175103046, 13], [975336.363956712, 6], [975336.511598125, 12], [975336.696441454, 6], [975336.846787253, 9], [975336.994859073, 6], [975337.153774009, 8], [975337.342782605, 15], [975337.52306596, 16], [975337.737832546, 27], [975337.972148182, 4], [975338.132341879, 8], [975338.31891097, 25], [975338.465170893, 18], [975338.616381519, 13], [975338.800954505, 64], [975338.951526312, 2], [975339.147707946, 10], [975339.317806736, 11], [975339.468071306, 15], [975339.618229656, 17], [975339.791871456, 14], [975339.973423251, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-843ae6c1dbef5819b49f7d24f169a0fe", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034321588, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.454993923, "time_to_first_token": 0.124284296, "token_sha": "8a91591c94a3", "tokens_per_second": 18.952070990095535}, "seed": 1234, "sent": 975326.392935028, "speculative": {"acceptance_rate": 0.41411764705882353, "accepted": 176, "drafted": 425, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12603583210147917, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 425, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.950511848964698, "done": 975339.974893167, "finish_reason": "length", "first": 975326.518774147, "full_response_s": 13.581927019986324, "last": 975339.974875071, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975326.518774147, 3], [975326.669236054, 11], [975326.854074541, 30], [975327.040753703, 19], [975327.225579412, 21], [975327.40782867, 15], [975327.556345566, 19], [975327.704945578, 17], [975327.851749385, 6], [975327.999333313, 8], [975328.189284268, 3], [975328.360516972, 5], [975328.543750202, 27], [975328.724632462, 12], [975328.910961024, 13], [975329.103651904, 5], [975329.273968393, 16], [975329.453171056, 5], [975329.639818075, 14], [975329.821772767, 9], [975330.004051311, 27], [975330.158692612, 11], [975330.34580135, 8], [975330.489985012, 16], [975330.639815014, 5], [975330.787854121, 9], [975330.963296278, 14], [975331.117549263, 20], [975331.270748527, 8], [975331.41707119, 12], [975331.566261286, 5], [975331.716771382, 14], [975331.863390836, 11], [975332.01241296, 7], [975332.203938882, 17], [975332.375043315, 3], [975332.55821997, 10], [975332.739446327, 11], [975332.925310633, 10], [975333.115528514, 20], [975333.300310191, 23], [975333.485384849, 14], [975333.665064612, 13], [975333.8119341, 5], [975333.994393547, 14], [975334.186980999, 11], [975334.37128118, 43], [975334.555821097, 22], [975334.740186796, 11], [975334.930497134, 6], [975335.084157414, 8], [975335.271412729, 9], [975335.422174009, 13], [975335.570787013, 8], [975335.71773163, 20], [975335.867713436, 17], [975336.018297385, 20], [975336.177425395, 13], [975336.361450193, 6], [975336.510103267, 12], [975336.696672598, 6], [975336.845945011, 9], [975336.994335316, 6], [975337.155148728, 8], [975337.338692799, 15], [975337.522923502, 16], [975337.737059197, 27], [975337.971911567, 4], [975338.132691707, 8], [975338.317208454, 25], [975338.466822146, 18], [975338.615300726, 13], [975338.804724354, 64], [975338.951384317, 2], [975339.145755504, 10], [975339.317682068, 11], [975339.470735339, 15], [975339.618049935, 17], [975339.792302688, 14], [975339.974875071, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-ae8ddfdb3931d0e82f0effd738359d79", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034566987, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.455619341, "time_to_first_token": 0.123687261, "token_sha": "8a91591c94a3", "tokens_per_second": 18.95119009669077}, "seed": 1234, "sent": 975326.392966147, "speculative": {"acceptance_rate": 0.44556962025316454, "accepted": 176, "drafted": 395, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1258079999824986, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 395, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.952676101355117, "done": 975339.97350776, "finish_reason": "length", "first": 975326.518817426, "full_response_s": 13.580859664944, "last": 975339.973381765, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975326.518817426, 3], [975326.669472974, 11], [975326.854475039, 30], [975327.041090459, 19], [975327.224916396, 21], [975327.407656676, 15], [975327.558011953, 19], [975327.702754169, 17], [975327.849882733, 6], [975327.99996593, 8], [975328.19045205, 3], [975328.36012057, 5], [975328.542687489, 29], [975328.724338136, 10], [975328.911458574, 13], [975329.101643241, 5], [975329.271470627, 16], [975329.457576209, 5], [975329.637198265, 16], [975329.821636084, 7], [975330.004757733, 29], [975330.159346748, 10], [975330.342148393, 23], [975330.490044578, 5], [975330.639013699, 9], [975330.788137679, 14], [975330.963544925, 20], [975331.118172441, 12], [975331.267026325, 8], [975331.418183054, 5], [975331.568936101, 12], [975331.713763746, 11], [975331.863143229, 5], [975332.01285752, 8], [975332.204980301, 13], [975332.374935671, 3], [975332.555442726, 10], [975332.738999111, 11], [975332.924099509, 10], [975333.113858174, 20], [975333.300667394, 23], [975333.483831432, 14], [975333.665922917, 13], [975333.812438434, 5], [975333.994447801, 14], [975334.186043384, 11], [975334.370601764, 43], [975334.553840144, 22], [975334.740425923, 11], [975334.930078285, 6], [975335.083361058, 8], [975335.26986208, 9], [975335.422331731, 13], [975335.570749959, 8], [975335.720331009, 20], [975335.868600733, 21], [975336.017446727, 16], [975336.178371313, 13], [975336.362083051, 6], [975336.509750816, 12], [975336.695492624, 6], [975336.847968746, 9], [975336.994214168, 6], [975337.153044292, 8], [975337.340718855, 15], [975337.523230675, 16], [975337.737930014, 27], [975337.97355954, 4], [975338.132013331, 8], [975338.317980715, 25], [975338.465760216, 18], [975338.614961138, 13], [975338.800590486, 64], [975338.952173232, 2], [975339.148189177, 10], [975339.31798761, 11], [975339.468624486, 15], [975339.617774152, 17], [975339.794115679, 14], [975339.973381765, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-17d9c8e92b6a38ce6036f7a007f8b8b5", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034361122, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.455284505, "time_to_first_token": 0.124260281, "token_sha": "8a91591c94a3", "tokens_per_second": 18.95166169880999}, "seed": 1234, "sent": 975326.392648095, "speculative": {"acceptance_rate": 0.4200477326968974, "accepted": 176, "drafted": 419, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12616933102253824, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 419, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.950613221696017, "done": 975339.97586974, "finish_reason": "length", "first": 975326.519807086, "full_response_s": 13.582807388040237, "last": 975339.975836029, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975326.519807086, 3], [975326.670427211, 11], [975326.853773128, 30], [975327.040259417, 19], [975327.227648425, 21], [975327.410384914, 15], [975327.556562806, 19], [975327.704629717, 17], [975327.850408602, 6], [975328.000763197, 8], [975328.190219338, 3], [975328.361607013, 5], [975328.542594932, 27], [975328.726248275, 12], [975328.91246537, 13], [975329.103859801, 5], [975329.273577623, 16], [975329.456765966, 5], [975329.637085565, 14], [975329.820733349, 9], [975330.005017244, 27], [975330.15863087, 11], [975330.34518286, 8], [975330.489500981, 16], [975330.639162862, 5], [975330.787940822, 9], [975330.964331233, 14], [975331.118295253, 20], [975331.268765862, 12], [975331.416424029, 8], [975331.566919214, 5], [975331.71460034, 14], [975331.865086455, 11], [975332.012655048, 7], [975332.204583403, 17], [975332.373513531, 3], [975332.556574557, 10], [975332.740730057, 11], [975332.924878265, 10], [975333.114211746, 20], [975333.301259421, 23], [975333.485822049, 14], [975333.665352346, 13], [975333.813085898, 5], [975333.995444501, 14], [975334.187072083, 11], [975334.371454422, 43], [975334.555547602, 22], [975334.740014562, 11], [975334.930273622, 6], [975335.084287681, 8], [975335.271543316, 9], [975335.420373081, 13], [975335.570238873, 8], [975335.718203565, 20], [975335.869039453, 21], [975336.01725547, 16], [975336.179089064, 13], [975336.362902141, 6], [975336.509934425, 12], [975336.695175404, 6], [975336.846934095, 9], [975336.996896248, 6], [975337.154024289, 8], [975337.341043787, 15], [975337.523805614, 16], [975337.737288085, 27], [975337.973427305, 4], [975338.132228539, 8], [975338.318068552, 25], [975338.467409005, 18], [975338.615179354, 13], [975338.803394433, 64], [975338.952128226, 2], [975339.145162613, 10], [975339.318187298, 11], [975339.46834552, 15], [975339.618969214, 17], [975339.792416588, 14], [975339.975836029, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4e09289b7f02af616c7c26c75872ddf1", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034434448, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.455342822, "time_to_first_token": 0.124114845, "token_sha": "8a91591c94a3", "tokens_per_second": 18.951579560133187}, "seed": 1234, "sent": 975326.393062352, "speculative": {"acceptance_rate": 0.43564356435643564, "accepted": 176, "drafted": 404, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12674473400693387, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 404, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.595213017643434, "done": 975340.233305374, "finish_reason": "length", "first": 975326.51985646, "full_response_s": 13.839957672986202, "last": 975340.233063174, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975326.51985646, 3], [975326.670966279, 11], [975326.853356087, 30], [975327.040471649, 19], [975327.226828663, 21], [975327.408328444, 15], [975327.556858955, 19], [975327.704359503, 17], [975327.850144003, 6], [975327.99983299, 8], [975328.190622651, 3], [975328.359259738, 5], [975328.54299159, 27], [975328.725157931, 12], [975328.911107707, 9], [975329.102360783, 9], [975329.270818122, 16], [975329.453080787, 5], [975329.637815987, 14], [975329.820872352, 9], [975330.003899524, 27], [975330.159245408, 11], [975330.342450958, 8], [975330.488945449, 16], [975330.640303413, 5], [975330.78940053, 9], [975330.961191346, 14], [975331.117390069, 20], [975331.266387132, 8], [975331.418928243, 12], [975331.570087292, 5], [975331.716515471, 12], [975331.863695449, 11], [975332.013352399, 5], [975332.204507694, 8], [975332.374461176, 13], [975332.556071071, 3], [975332.739487541, 11], [975332.925891636, 10], [975333.114356508, 9], [975333.305045396, 10], [975333.486208627, 20], [975333.665673342, 6], [975333.812673049, 8], [975333.995198046, 14], [975334.186683617, 13], [975334.371021749, 5], [975334.556114126, 14], [975334.738848668, 11], [975334.929414373, 59], [975335.083879904, 6], [975335.271325548, 11], [975335.422896591, 6], [975335.571452782, 8], [975335.718796408, 9], [975335.867985027, 13], [975336.017686927, 8], [975336.178688854, 20], [975336.360826344, 32], [975336.510664095, 14], [975336.693372572, 6], [975336.844682736, 16], [975336.994810483, 6], [975337.15542395, 15], [975337.340823459, 5], [975337.524264397, 7], [975337.737452767, 14], [975337.973356795, 13], [975338.131471239, 31], [975338.317686389, 8], [975338.467793855, 25], [975338.618011765, 18], [975338.802707658, 8], [975338.952513076, 13], [975339.144834321, 56], [975339.317866334, 2], [975339.469113253, 4], [975339.619615927, 6], [975339.793311996, 11], [975339.974652903, 15], [975340.061820962, 17], [975340.149087481, 21], [975340.233063174, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-d98d7e9b290edba0b0f63fd677be41e1", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 1, "prefill_raised": [], "prefill_seconds": 0.034845729, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.714343265, "time_to_first_token": 0.12161324, "token_sha": "8a91591c94a3", "tokens_per_second": 18.59367197339872}, "seed": 1234, "sent": 975326.393347701, "speculative": {"acceptance_rate": 0.41766109785202865, "accepted": 175, "drafted": 419, "rounds": 82, "tokens_per_round": 3.1219512195121952}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12650875898543745, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 175, "drafted": 419, "rounds": 82}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.95228010332247, "done": 975339.974395248, "finish_reason": "length", "first": 975326.51952564, "full_response_s": 13.581703506992199, "last": 975339.974371105, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975326.51952564, 3], [975326.669856224, 11], [975326.853260778, 30], [975327.040633995, 19], [975327.226251868, 21], [975327.410666327, 15], [975327.555939356, 19], [975327.703714247, 17], [975327.851642365, 6], [975327.99962247, 8], [975328.191563097, 3], [975328.35906704, 5], [975328.543535378, 27], [975328.726726018, 12], [975328.911987691, 13], [975329.101988508, 5], [975329.271969857, 16], [975329.453235134, 5], [975329.639559956, 14], [975329.821868684, 9], [975330.004118621, 27], [975330.159543109, 11], [975330.344808393, 8], [975330.492016666, 16], [975330.638874712, 5], [975330.788570176, 9], [975330.962556753, 14], [975331.116375514, 20], [975331.26688329, 8], [975331.417763533, 12], [975331.566011855, 5], [975331.71615598, 14], [975331.864062892, 11], [975332.013851453, 3], [975332.20433522, 8], [975332.3746952, 13], [975332.558141061, 3], [975332.739392633, 11], [975332.924705631, 10], [975333.113673781, 9], [975333.304683505, 10], [975333.483725884, 20], [975333.668415964, 14], [975333.812362548, 14], [975333.996562973, 13], [975334.186158948, 5], [975334.372259353, 14], [975334.554694689, 11], [975334.739816265, 59], [975334.928503925, 6], [975335.083683143, 11], [975335.271154066, 6], [975335.421460658, 8], [975335.570699385, 9], [975335.718930979, 13], [975335.868410963, 8], [975336.01748615, 20], [975336.17890115, 17], [975336.362540362, 29], [975336.5134279, 6], [975336.693583381, 16], [975336.846725687, 6], [975336.995581895, 15], [975337.152734207, 8], [975337.339709739, 14], [975337.522766067, 12], [975337.740291978, 13], [975337.974477171, 23], [975338.130911179, 8], [975338.318173588, 25], [975338.468145283, 18], [975338.616993945, 13], [975338.803024175, 64], [975338.953063649, 2], [975339.147971169, 10], [975339.31836958, 11], [975339.470846903, 15], [975339.617878821, 17], [975339.79319664, 14], [975339.974371105, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-1416a3005f50727b23e38d6d444d77a5", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034753781, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.455541679, "time_to_first_token": 0.122491545, "token_sha": "8a91591c94a3", "tokens_per_second": 18.95129947819026}, "seed": 1234, "sent": 975326.392691741, "speculative": {"acceptance_rate": 0.45714285714285713, "accepted": 176, "drafted": 385, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12683389894664288, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 385, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.953495935819834, "done": 975339.975933578, "finish_reason": "length", "first": 975326.520215039, "full_response_s": 13.58248059998732, "last": 975339.9741974, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975326.520215039, 3], [975326.670586453, 11], [975326.855574455, 30], [975327.041186119, 19], [975327.226016692, 21], [975327.410313924, 15], [975327.557077827, 19], [975327.703039679, 17], [975327.851582415, 6], [975327.999553625, 8], [975328.189056516, 3], [975328.358626688, 5], [975328.544400323, 27], [975328.724192701, 12], [975328.910092303, 13], [975329.103950742, 5], [975329.272048686, 16], [975329.45482474, 5], [975329.63738853, 14], [975329.823349126, 9], [975330.005479019, 27], [975330.159435865, 11], [975330.34511267, 8], [975330.492277713, 16], [975330.641669171, 5], [975330.788794999, 9], [975330.962306746, 14], [975331.117651804, 20], [975331.267279612, 8], [975331.418311193, 12], [975331.565741016, 5], [975331.714150484, 14], [975331.863228282, 11], [975332.014113091, 3], [975332.20567162, 8], [975332.374824379, 13], [975332.557936092, 3], [975332.740559599, 11], [975332.925579248, 10], [975333.115674317, 9], [975333.303323074, 10], [975333.485044477, 20], [975333.66606248, 14], [975333.813208166, 14], [975333.994850347, 13], [975334.185905709, 5], [975334.371101314, 14], [975334.554547126, 11], [975334.739744715, 59], [975334.92882449, 6], [975335.083431552, 11], [975335.271803307, 6], [975335.422075884, 8], [975335.569133313, 9], [975335.717991685, 13], [975335.868842628, 8], [975336.018349031, 20], [975336.177886275, 17], [975336.360692189, 29], [975336.512939901, 6], [975336.694093762, 16], [975336.845654941, 6], [975336.995977881, 15], [975337.155023549, 8], [975337.341464156, 15], [975337.524669295, 16], [975337.738743329, 27], [975337.97306103, 4], [975338.132634493, 8], [975338.319429607, 25], [975338.465317896, 18], [975338.616608231, 13], [975338.804346767, 64], [975338.953153901, 2], [975339.146081396, 10], [975339.317521674, 11], [975339.470615919, 15], [975339.61931133, 17], [975339.793644976, 14], [975339.9741974, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-aadac3fd6660e9ac0a76cbe647967177", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034748212, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.455704874, "time_to_first_token": 0.12299983, "token_sha": "8a91591c94a3", "tokens_per_second": 18.95106963089892}, "seed": 1234, "sent": 975326.393452978, "speculative": {"acceptance_rate": 0.4433249370277078, "accepted": 176, "drafted": 397, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12676206103060395, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 397, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 19.03683942719038, "done": 975339.793728573, "finish_reason": "length", "first": 975326.396915572, "full_response_s": 13.40096971404273, "last": 975339.791996251, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975326.396915572, 3], [975326.484962237, 26], [975326.669392993, 15], [975326.853982096, 19], [975327.040895874, 21], [975327.225075158, 15], [975327.408186705, 19], [975327.555482941, 17], [975327.703637209, 6], [975327.851174286, 11], [975328.000132116, 5], [975328.189375977, 18], [975328.361135094, 21], [975328.544896113, 9], [975328.724768601, 9], [975328.911171448, 16], [975329.101325828, 5], [975329.272942462, 10], [975329.453964724, 13], [975329.63760897, 27], [975329.820271301, 11], [975330.005061786, 8], [975330.158491899, 16], [975330.346284596, 9], [975330.492553351, 5], [975330.637883644, 14], [975330.788261563, 20], [975330.961720943, 8], [975331.116567715, 12], [975331.267450774, 5], [975331.416900204, 14], [975331.568015542, 14], [975331.715450229, 8], [975331.863620156, 13], [975332.013294673, 3], [975332.203532385, 10], [975332.375881365, 11], [975332.558493064, 10], [975332.740106863, 24], [975332.927479131, 19], [975333.113792609, 14], [975333.300534071, 13], [975333.483928245, 5], [975333.664793806, 14], [975333.813296547, 11], [975333.99454087, 59], [975334.188128926, 6], [975334.370909305, 11], [975334.555906886, 4], [975334.740634315, 10], [975334.929905555, 9], [975335.08286122, 9], [975335.270367518, 12], [975335.42063072, 20], [975335.57111537, 21], [975335.719566268, 16], [975335.86706834, 13], [975336.018249643, 6], [975336.1756225, 12], [975336.362245637, 6], [975336.513278977, 15], [975336.696989691, 8], [975336.847548905, 14], [975336.994938894, 12], [975337.154505263, 26], [975337.3393318, 10], [975337.523713025, 8], [975337.739848634, 16], [975337.973705423, 24], [975338.130716961, 11], [975338.316536046, 13], [975338.465900291, 56], [975338.616856222, 2], [975338.804250707, 4], [975338.951765887, 6], [975339.144692838, 11], [975339.318302046, 15], [975339.468837567, 17], [975339.618135132, 14], [975339.791996251, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-9ae4d65b142a2dbfca92ebe19add7825", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 1, "prefill_raised": [], "prefill_seconds": 0.002304829, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.395231073, "time_to_first_token": 0.002965172, "token_sha": "8a91591c94a3", "tokens_per_second": 19.03662569240697}, "seed": 1234, "sent": 975326.392758859, "speculative": {"acceptance_rate": 0.4389027431421446, "accepted": 176, "drafted": 401, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.004156713024713099, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 401, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.950934181371547, "done": 975339.975304112, "finish_reason": "length", "first": 975326.519454331, "full_response_s": 13.582053783000447, "last": 975339.975255378, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975326.519454331, 3], [975326.669077852, 11], [975326.853125199, 30], [975327.040988334, 19], [975327.225863674, 21], [975327.409474195, 15], [975327.555740196, 19], [975327.702925763, 17], [975327.849718275, 6], [975328.000502518, 8], [975328.189449878, 3], [975328.359821173, 5], [975328.543587264, 27], [975328.723800828, 12], [975328.910390197, 9], [975329.101760789, 9], [975329.271034563, 16], [975329.45412323, 5], [975329.640161614, 14], [975329.822566226, 9], [975330.004703175, 27], [975330.158566648, 11], [975330.346479261, 8], [975330.490448147, 16], [975330.641413901, 5], [975330.78888906, 9], [975330.964891549, 14], [975331.117742648, 20], [975331.267867895, 8], [975331.417275038, 12], [975331.565093936, 5], [975331.714958343, 12], [975331.86299997, 11], [975332.01297694, 5], [975332.203014084, 8], [975332.374322861, 13], [975332.555217438, 3], [975332.740791974, 11], [975332.923965274, 10], [975333.114568197, 9], [975333.303950588, 10], [975333.486147685, 20], [975333.665890647, 14], [975333.813421934, 14], [975333.995040052, 13], [975334.187537203, 5], [975334.369779058, 14], [975334.55311713, 11], [975334.739020965, 59], [975334.928753388, 6], [975335.084760704, 11], [975335.270939434, 6], [975335.421879075, 8], [975335.56994586, 9], [975335.719822451, 13], [975335.868166988, 8], [975336.017138482, 20], [975336.1764985, 17], [975336.363635347, 23], [975336.511914578, 12], [975336.696742675, 16], [975336.845076802, 6], [975336.995539833, 15], [975337.153122177, 8], [975337.337795135, 14], [975337.524576498, 12], [975337.740062482, 13], [975337.972843997, 23], [975338.131022471, 8], [975338.318415851, 25], [975338.467061769, 18], [975338.616808048, 13], [975338.801405401, 55], [975338.952576674, 11], [975339.147621709, 10], [975339.317367104, 11], [975339.46875637, 15], [975339.619250196, 17], [975339.792683779, 14], [975339.975255378, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-cd7024d6b7e0b6b53642ddf59591a5df", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034790819, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.455578991, "time_to_first_token": 0.122150821, "token_sha": "8a91591c94a3", "tokens_per_second": 18.95124692668827}, "seed": 1234, "sent": 975326.393250329, "speculative": {"acceptance_rate": 0.46684350132625996, "accepted": 176, "drafted": 377, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12620400206651539, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 377, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.953567860558334, "done": 975339.977262058, "finish_reason": "length", "first": 975326.520392905, "full_response_s": 13.58495980699081, "last": 975339.974324211, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975326.520392905, 3], [975326.671055812, 11], [975326.853880836, 30], [975327.04082842, 19], [975327.228183958, 21], [975327.408538836, 15], [975327.558456673, 19], [975327.703484223, 17], [975327.849804223, 6], [975328.000255727, 8], [975328.190108014, 3], [975328.360377601, 5], [975328.543697804, 27], [975328.725358467, 12], [975328.910292536, 13], [975329.100938498, 5], [975329.272623545, 16], [975329.455205095, 5], [975329.64023206, 14], [975329.820790851, 9], [975330.004649017, 27], [975330.15963853, 11], [975330.342934653, 8], [975330.491075228, 16], [975330.638360875, 5], [975330.789068158, 9], [975330.960625366, 14], [975331.117912354, 20], [975331.266563334, 8], [975331.418509746, 12], [975331.565598669, 5], [975331.714381276, 14], [975331.864400096, 11], [975332.013409213, 3], [975332.202575731, 8], [975332.37375405, 13], [975332.557377616, 3], [975332.73880347, 11], [975332.924965926, 10], [975333.115315194, 9], [975333.299156136, 10], [975333.484702969, 20], [975333.666961904, 14], [975333.812832772, 14], [975333.995355753, 13], [975334.185040141, 5], [975334.370475785, 14], [975334.555202479, 11], [975334.740477633, 59], [975334.930214808, 6], [975335.085089348, 11], [975335.27108298, 6], [975335.420976116, 8], [975335.570338438, 9], [975335.719311894, 13], [975335.868084543, 8], [975336.01860883, 20], [975336.179344638, 17], [975336.3637268, 29], [975336.5111827, 6], [975336.694686797, 16], [975336.847180263, 6], [975336.99607263, 15], [975337.153686349, 8], [975337.340059294, 15], [975337.523344606, 16], [975337.737176633, 27], [975337.972754177, 4], [975338.133700615, 8], [975338.318822013, 25], [975338.465957521, 18], [975338.617550965, 13], [975338.800469994, 64], [975338.95201871, 2], [975339.146277805, 10], [975339.317756562, 11], [975339.469865514, 15], [975339.618721207, 17], [975339.792839853, 14], [975339.974324211, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-eece96aaac45fe3f7da81dc3a6b97487", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034676007, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.45568097, "time_to_first_token": 0.124431906, "token_sha": "8a91591c94a3", "tokens_per_second": 18.951103297449837}, "seed": 1234, "sent": 975326.392302251, "speculative": {"acceptance_rate": 0.43672456575682383, "accepted": 176, "drafted": 403, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12809065403416753, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 403, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 19.02260407097073, "done": 975353.680805322, "finish_reason": "length", "first": 975340.274987935, "full_response_s": 13.410866215010174, "last": 975353.680092675, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975340.274987935, 3], [975340.363095656, 26], [975340.548953699, 15], [975340.729256196, 19], [975340.916199772, 21], [975341.100976245, 15], [975341.283703719, 19], [975341.43281303, 17], [975341.578586477, 6], [975341.729300835, 11], [975341.874805429, 5], [975342.060951925, 18], [975342.235991056, 21], [975342.421651152, 9], [975342.606312085, 9], [975342.785384736, 16], [975342.97237252, 5], [975343.150025597, 10], [975343.329507857, 13], [975343.515085836, 27], [975343.698608544, 11], [975343.881326116, 8], [975344.028954458, 16], [975344.222046882, 9], [975344.368066209, 5], [975344.51613412, 14], [975344.664996018, 20], [975344.841542967, 8], [975344.988718435, 12], [975345.144219784, 5], [975345.29595013, 14], [975345.442133842, 14], [975345.590698012, 8], [975345.740164503, 13], [975345.889409389, 3], [975346.07984933, 10], [975346.252742981, 11], [975346.436245232, 10], [975346.622175861, 24], [975346.807872115, 19], [975346.990794666, 14], [975347.183969686, 13], [975347.367074182, 5], [975347.549555853, 14], [975347.697613317, 11], [975347.881809922, 59], [975348.071134622, 6], [975348.256700367, 11], [975348.444999519, 4], [975348.630290681, 10], [975348.816231869, 9], [975348.964286706, 9], [975349.156342709, 12], [975349.3053302, 20], [975349.455352983, 21], [975349.605835958, 16], [975349.756823315, 13], [975349.904952601, 6], [975350.05788244, 12], [975350.247212642, 6], [975350.399290463, 15], [975350.581104755, 8], [975350.733163568, 14], [975350.887297767, 12], [975351.035256939, 26], [975351.226616262, 10], [975351.411368825, 8], [975351.625517761, 16], [975351.858986339, 24], [975352.008388041, 11], [975352.203213122, 13], [975352.35121801, 56], [975352.503661062, 2], [975352.685200034, 4], [975352.842265564, 6], [975353.025258956, 11], [975353.206339807, 15], [975353.357741606, 17], [975353.508681388, 14], [975353.680092675, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-7b85615ae7221f4fd74881c921cc3d0f", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 1, "prefill_raised": [], "prefill_seconds": 0.002438393, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.405226304, "time_to_first_token": 0.003045171, "token_sha": "8a91591c94a3", "tokens_per_second": 19.022431566404087}, "seed": 1234, "sent": 975340.269939107, "speculative": {"acceptance_rate": 0.4389027431421446, "accepted": 176, "drafted": 401, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.005048827966675162, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 401, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.9362614761408, "done": 975353.863875722, "finish_reason": "length", "first": 975340.397615465, "full_response_s": 13.595527598052286, "last": 975353.863842699, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975340.397615465, 3], [975340.549430194, 11], [975340.731331162, 30], [975340.914028921, 19], [975341.102508654, 21], [975341.282882404, 15], [975341.434784688, 19], [975341.579478525, 17], [975341.726933255, 6], [975341.876189588, 8], [975342.060781051, 3], [975342.236187545, 5], [975342.420506857, 27], [975342.605999296, 12], [975342.787310027, 13], [975342.970500843, 5], [975343.146286658, 16], [975343.330842705, 5], [975343.516922267, 14], [975343.697021081, 9], [975343.880354551, 27], [975344.0292332, 11], [975344.219405536, 8], [975344.368160158, 16], [975344.515455616, 5], [975344.66460368, 9], [975344.839830307, 14], [975344.987633545, 20], [975345.145319985, 8], [975345.29674847, 12], [975345.441479497, 5], [975345.592760403, 14], [975345.740953355, 11], [975345.890188689, 7], [975346.079924944, 17], [975346.251673515, 3], [975346.435510106, 10], [975346.621206904, 11], [975346.80569008, 10], [975346.989898201, 20], [975347.18418203, 23], [975347.369015138, 14], [975347.547584386, 13], [975347.698824395, 5], [975347.882738593, 14], [975348.070965796, 11], [975348.256550916, 43], [975348.441623254, 22], [975348.62948303, 11], [975348.816129169, 6], [975348.965546357, 8], [975349.156571101, 9], [975349.307786434, 13], [975349.455181405, 8], [975349.60492671, 20], [975349.75675351, 17], [975349.905425129, 20], [975350.058420981, 13], [975350.24851794, 6], [975350.397409281, 12], [975350.582698875, 6], [975350.735669496, 9], [975350.886099201, 6], [975351.036321158, 8], [975351.226788496, 15], [975351.414304514, 16], [975351.624783387, 27], [975351.858561826, 4], [975352.006533003, 8], [975352.200179885, 25], [975352.352821313, 18], [975352.505270397, 13], [975352.687049377, 64], [975352.840724722, 2], [975353.025668478, 10], [975353.206953226, 11], [975353.356675419, 15], [975353.506824446, 17], [975353.680029542, 14], [975353.863842699, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-a984d0f37ef6dd37189a04e1d845674e", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034767096, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.466373293, "time_to_first_token": 0.123080809, "token_sha": "8a91591c94a3", "tokens_per_second": 18.93605608961935}, "seed": 1234, "sent": 975340.268348124, "speculative": {"acceptance_rate": 0.45012787723785164, "accepted": 176, "drafted": 391, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12926734099164605, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 391, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.937863412881647, "done": 975353.864229485, "finish_reason": "length", "first": 975340.398372542, "full_response_s": 13.594576096045785, "last": 975353.86346068, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975340.398372542, 3], [975340.548503619, 11], [975340.730189506, 30], [975340.913771475, 19], [975341.10179452, 21], [975341.283393362, 15], [975341.433934398, 19], [975341.580492281, 17], [975341.727705004, 6], [975341.877150818, 8], [975342.061594606, 3], [975342.23630634, 5], [975342.422993633, 27], [975342.602998699, 12], [975342.786603269, 13], [975342.970680132, 5], [975343.148395399, 16], [975343.32963126, 5], [975343.517681328, 14], [975343.697083734, 9], [975343.881033998, 27], [975344.029430329, 11], [975344.222359127, 8], [975344.369141723, 16], [975344.516657173, 5], [975344.665653995, 9], [975344.839704856, 14], [975344.990567665, 20], [975345.144066701, 8], [975345.295797464, 12], [975345.442192783, 5], [975345.592436591, 14], [975345.743919474, 11], [975345.890682592, 3], [975346.080978746, 8], [975346.252393106, 13], [975346.436295775, 3], [975346.62222722, 11], [975346.80703448, 10], [975346.990975715, 9], [975347.184297082, 10], [975347.367673761, 20], [975347.550725091, 14], [975347.697903323, 14], [975347.882542248, 13], [975348.07266428, 5], [975348.257588943, 14], [975348.442019672, 11], [975348.628926858, 59], [975348.817833845, 6], [975348.966019093, 11], [975349.159748316, 6], [975349.306532526, 8], [975349.455950178, 9], [975349.607827136, 13], [975349.755941123, 8], [975349.908107514, 20], [975350.05849269, 17], [975350.249399173, 29], [975350.397345012, 6], [975350.582241771, 16], [975350.732458473, 6], [975350.885973094, 15], [975351.036531054, 8], [975351.227400106, 15], [975351.415297183, 16], [975351.625782952, 27], [975351.860258086, 4], [975352.007708737, 8], [975352.200289849, 25], [975352.352638552, 18], [975352.505148033, 13], [975352.688346867, 64], [975352.84034344, 2], [975353.025573089, 10], [975353.208130912, 11], [975353.35649373, 15], [975353.507570899, 17], [975353.67946097, 14], [975353.86346068, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-cb9d5d8b61ea0ecbcdfd75bdb29454c3", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034875652, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.466177092, "time_to_first_token": 0.123078698, "token_sha": "8a91591c94a3", "tokens_per_second": 18.936331986268815}, "seed": 1234, "sent": 975340.269653389, "speculative": {"acceptance_rate": 0.4433249370277078, "accepted": 176, "drafted": 397, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12871915299911052, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 397, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.935720672573602, "done": 975353.865113758, "finish_reason": "length", "first": 975340.398476138, "full_response_s": 13.593769069062546, "last": 975353.865087967, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975340.398476138, 3], [975340.549248232, 11], [975340.7294699, 30], [975340.913929501, 19], [975341.101146431, 21], [975341.284239316, 15], [975341.433216344, 19], [975341.578703432, 17], [975341.727641742, 6], [975341.877823242, 8], [975342.061168253, 3], [975342.233938601, 5], [975342.422416085, 27], [975342.605843445, 12], [975342.787411416, 13], [975342.971709184, 5], [975343.147479911, 16], [975343.33005195, 5], [975343.516606502, 14], [975343.698855623, 9], [975343.88110958, 27], [975344.030624831, 11], [975344.221703774, 8], [975344.369490159, 16], [975344.516955787, 5], [975344.664303979, 9], [975344.841069351, 14], [975344.989103077, 20], [975345.144368098, 8], [975345.294498566, 12], [975345.44216816, 5], [975345.59256609, 14], [975345.743617389, 11], [975345.891841287, 3], [975346.081902778, 8], [975346.252080397, 13], [975346.435823711, 3], [975346.621620521, 11], [975346.806979858, 10], [975346.989470248, 9], [975347.183294942, 10], [975347.368660622, 20], [975347.549751686, 14], [975347.696750004, 14], [975347.88374123, 13], [975348.072597162, 5], [975348.258323557, 14], [975348.443617568, 11], [975348.628829069, 59], [975348.817773159, 6], [975348.964584119, 11], [975349.157698469, 6], [975349.306120493, 8], [975349.454954885, 9], [975349.605630718, 13], [975349.756397666, 8], [975349.906394646, 20], [975350.059942911, 17], [975350.248150049, 29], [975350.397828515, 6], [975350.584151592, 16], [975350.732801261, 6], [975350.88603618, 15], [975351.035858774, 8], [975351.22905384, 15], [975351.415486008, 16], [975351.625465123, 27], [975351.861638325, 4], [975352.008491974, 8], [975352.201614538, 25], [975352.352998203, 18], [975352.501773928, 13], [975352.686075395, 64], [975352.842996754, 2], [975353.024488327, 10], [975353.208409271, 11], [975353.359398715, 15], [975353.507879689, 17], [975353.681313769, 14], [975353.865087967, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-56609dd071fc0e71d7472b459e156b67", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.03483951, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.466073607, "time_to_first_token": 0.122512351, "token_sha": "8a91591c94a3", "tokens_per_second": 18.93647750948314}, "seed": 1234, "sent": 975340.271344689, "speculative": {"acceptance_rate": 0.44221105527638194, "accepted": 176, "drafted": 398, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12713144905865192, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 398, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.935626836736528, "done": 975353.864692781, "finish_reason": "length", "first": 975340.397990235, "full_response_s": 13.595350821036845, "last": 975353.864668798, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975340.397990235, 3], [975340.548694204, 11], [975340.728559293, 30], [975340.915179008, 19], [975341.102366083, 21], [975341.284374111, 15], [975341.433335956, 19], [975341.578965263, 17], [975341.727957075, 6], [975341.876135686, 8], [975342.062702311, 3], [975342.23626271, 5], [975342.422298969, 27], [975342.606074525, 12], [975342.785787618, 13], [975342.970332337, 5], [975343.149134829, 16], [975343.330354755, 5], [975343.516228099, 14], [975343.69753839, 9], [975343.883041815, 27], [975344.029973958, 11], [975344.224092985, 8], [975344.368436724, 16], [975344.517312446, 5], [975344.665548127, 9], [975344.840859503, 14], [975344.987994029, 20], [975345.145380638, 8], [975345.297088906, 12], [975345.441553254, 5], [975345.591948768, 14], [975345.741454969, 11], [975345.891082306, 3], [975346.080940044, 8], [975346.253292162, 13], [975346.436100165, 3], [975346.620477234, 11], [975346.807170892, 10], [975346.991501569, 9], [975347.185258232, 10], [975347.366593943, 20], [975347.550113097, 14], [975347.697478954, 14], [975347.882079513, 13], [975348.073099193, 5], [975348.256965141, 14], [975348.443708861, 11], [975348.62909914, 59], [975348.819685987, 6], [975348.966268492, 11], [975349.160513921, 6], [975349.306623035, 8], [975349.456126268, 9], [975349.606549629, 13], [975349.75668148, 8], [975349.909255969, 20], [975350.057713774, 17], [975350.248951605, 29], [975350.398314418, 6], [975350.58323228, 16], [975350.735398961, 6], [975350.88437163, 15], [975351.036917008, 8], [975351.226022107, 15], [975351.415392924, 16], [975351.625712907, 27], [975351.860694615, 4], [975352.007120486, 8], [975352.202167975, 25], [975352.354366571, 18], [975352.504875451, 13], [975352.688673719, 64], [975352.839348611, 2], [975353.025459189, 10], [975353.208959683, 11], [975353.358133272, 15], [975353.507377898, 17], [975353.680338827, 14], [975353.864668798, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-f1238cd73039f2f83566cad2b630300d", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034803447, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.466485673, "time_to_first_token": 0.123052267, "token_sha": "8a91591c94a3", "tokens_per_second": 18.935898065169983}, "seed": 1234, "sent": 975340.26934196, "speculative": {"acceptance_rate": 0.43672456575682383, "accepted": 176, "drafted": 403, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12864827504381537, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 403, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.935536781457397, "done": 975353.867322081, "finish_reason": "length", "first": 975340.398418332, "full_response_s": 13.59227901196573, "last": 975353.865160941, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975340.398418332, 3], [975340.548179054, 11], [975340.728871857, 30], [975340.913296755, 19], [975341.102070974, 21], [975341.284963482, 15], [975341.434158358, 19], [975341.579247477, 17], [975341.728294855, 6], [975341.87670685, 8], [975342.062420321, 3], [975342.235045345, 5], [975342.422635549, 27], [975342.602890095, 12], [975342.787619168, 9], [975342.96982709, 9], [975343.148141808, 16], [975343.331245123, 5], [975343.51733894, 14], [975343.697824012, 9], [975343.879897143, 27], [975344.029338029, 11], [975344.22036883, 8], [975344.370035163, 16], [975344.519266969, 5], [975344.665696105, 9], [975344.841999847, 14], [975344.988250643, 20], [975345.146105861, 8], [975345.296353636, 12], [975345.441873627, 5], [975345.590400087, 12], [975345.744449439, 11], [975345.889927419, 5], [975346.081056504, 8], [975346.252692983, 13], [975346.435689428, 3], [975346.621351043, 11], [975346.80711211, 10], [975346.991265241, 9], [975347.185580109, 10], [975347.368017845, 20], [975347.547773724, 14], [975347.697835838, 14], [975347.882825886, 13], [975348.072234679, 5], [975348.25678726, 14], [975348.444415268, 11], [975348.629798827, 59], [975348.818689254, 6], [975348.964020907, 11], [975349.157526699, 6], [975349.305878197, 8], [975349.456017568, 9], [975349.605500754, 13], [975349.75584311, 8], [975349.906974402, 20], [975350.059519086, 17], [975350.247015225, 23], [975350.397650809, 12], [975350.583619866, 16], [975350.731647702, 6], [975350.886457861, 15], [975351.035797336, 8], [975351.226281106, 14], [975351.413550812, 12], [975351.627155432, 13], [975351.858181087, 23], [975352.007755792, 8], [975352.204267181, 25], [975352.353308736, 18], [975352.503102905, 13], [975352.687891619, 55], [975352.839472894, 11], [975353.025332873, 10], [975353.206624533, 11], [975353.357811267, 15], [975353.508207517, 17], [975353.681570512, 14], [975353.865160941, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-df44d6da9cec739a06d6371e764084c0", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.03494869, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.467173472, "time_to_first_token": 0.1213542, "token_sha": "8a91591c94a3", "tokens_per_second": 18.934930966039612}, "seed": 1234, "sent": 975340.275043069, "speculative": {"acceptance_rate": 0.46684350132625996, "accepted": 176, "drafted": 377, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1233752629486844, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 377, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.9339439208054, "done": 975353.866231511, "finish_reason": "length", "first": 975340.398313792, "full_response_s": 13.596344241988845, "last": 975353.866189321, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975340.398313792, 3], [975340.548064835, 11], [975340.728782421, 30], [975340.915583506, 19], [975341.102312229, 21], [975341.283548092, 15], [975341.43440243, 19], [975341.579222822, 17], [975341.726596707, 6], [975341.87760973, 8], [975342.061465251, 3], [975342.236509469, 5], [975342.421797179, 27], [975342.604893223, 12], [975342.7859339, 13], [975342.971012824, 5], [975343.147892857, 16], [975343.332054662, 5], [975343.515882688, 14], [975343.699268249, 9], [975343.882442444, 27], [975344.030060275, 11], [975344.223256295, 8], [975344.368800663, 16], [975344.518922917, 5], [975344.666037933, 9], [975344.842793466, 14], [975344.989992982, 20], [975345.144586619, 8], [975345.295665484, 12], [975345.440955035, 5], [975345.591892498, 14], [975345.74133107, 11], [975345.889162998, 7], [975346.080871774, 17], [975346.252644633, 3], [975346.43556644, 10], [975346.62102827, 11], [975346.806466053, 10], [975346.990453542, 20], [975347.184611119, 23], [975347.369386404, 14], [975347.54844842, 13], [975347.697951977, 5], [975347.884168879, 14], [975348.07211086, 11], [975348.259281428, 43], [975348.443353273, 22], [975348.628200979, 11], [975348.818635544, 6], [975348.964623046, 8], [975349.159227631, 9], [975349.307351041, 13], [975349.454800203, 8], [975349.605144975, 20], [975349.756441425, 17], [975349.905943174, 20], [975350.059130636, 13], [975350.247134229, 6], [975350.397587003, 12], [975350.581802714, 6], [975350.73486266, 9], [975350.885213313, 6], [975351.035074017, 8], [975351.225756612, 15], [975351.411519076, 16], [975351.625405605, 27], [975351.859483889, 4], [975352.008564851, 8], [975352.202271667, 25], [975352.353790303, 18], [975352.502084573, 13], [975352.687331479, 64], [975352.84260624, 2], [975353.024762541, 10], [975353.207138803, 11], [975353.359781102, 15], [975353.510134937, 17], [975353.681770248, 14], [975353.866189321, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-388c44c842427e9b52f006a1bd682edc", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034633501, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.466635828, "time_to_first_token": 0.125018997, "token_sha": "8a91591c94a3", "tokens_per_second": 18.935686927079498}, "seed": 1234, "sent": 975340.269887269, "speculative": {"acceptance_rate": 0.44221105527638194, "accepted": 176, "drafted": 398, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12842652294784784, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 398, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.58067677101562, "done": 975354.121963205, "finish_reason": "length", "first": 975340.39792547, "full_response_s": 13.84834442101419, "last": 975354.121860456, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975340.39792547, 3], [975340.549035904, 11], [975340.730039992, 30], [975340.914615845, 19], [975341.101745881, 21], [975341.286291578, 15], [975341.433671624, 19], [975341.58040422, 17], [975341.727150735, 6], [975341.875974956, 8], [975342.062830242, 3], [975342.234548659, 5], [975342.419033214, 27], [975342.604315148, 12], [975342.787109059, 9], [975342.97265755, 9], [975343.146704387, 16], [975343.329775687, 5], [975343.514080768, 14], [975343.69787449, 9], [975343.881854625, 27], [975344.030383447, 11], [975344.2192801, 8], [975344.369831459, 16], [975344.517038552, 5], [975344.663854427, 9], [975344.842488021, 14], [975344.986827814, 20], [975345.146204337, 8], [975345.295577359, 12], [975345.441696081, 5], [975345.590617967, 12], [975345.742058468, 11], [975345.892348261, 5], [975346.079763925, 8], [975346.251243802, 13], [975346.436167427, 3], [975346.620206171, 11], [975346.806802665, 10], [975346.990844472, 9], [975347.182986217, 10], [975347.367347229, 20], [975347.546950185, 6], [975347.697558119, 8], [975347.882268642, 14], [975348.071533552, 13], [975348.257906692, 5], [975348.441304226, 14], [975348.627478173, 11], [975348.819236243, 59], [975348.964389774, 6], [975349.156040031, 11], [975349.306729863, 6], [975349.455685212, 8], [975349.607349857, 9], [975349.754890056, 13], [975349.909558167, 8], [975350.057822042, 20], [975350.250585436, 32], [975350.398971754, 14], [975350.583785156, 6], [975350.732570325, 16], [975350.886884822, 6], [975351.035122784, 15], [975351.228302138, 5], [975351.412065809, 7], [975351.627405423, 14], [975351.859517808, 13], [975352.007060424, 31], [975352.201725542, 8], [975352.353703858, 25], [975352.504032537, 18], [975352.685266943, 8], [975352.840588983, 13], [975353.024613763, 56], [975353.207053734, 2], [975353.359909465, 4], [975353.50749455, 6], [975353.680398649, 11], [975353.866131723, 15], [975353.946983764, 17], [975354.030090846, 21], [975354.121860456, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4036d7a5e4921793f50f2bb2fb5ffb0e", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 1, "prefill_raised": [], "prefill_seconds": 0.03498616, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.724361675, "time_to_first_token": 0.12268316, "token_sha": "8a91591c94a3", "tokens_per_second": 18.58009909958162}, "seed": 1234, "sent": 975340.273618784, "speculative": {"acceptance_rate": 0.41766109785202865, "accepted": 175, "drafted": 419, "rounds": 82, "tokens_per_round": 3.1219512195121952}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12430668598972261, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 175, "drafted": 419, "rounds": 82}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.93680287311754, "done": 975353.863543413, "finish_reason": "length", "first": 975340.397675959, "full_response_s": 13.594008243991993, "last": 975353.863518198, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975340.397675959, 3], [975340.549071311, 11], [975340.729701684, 30], [975340.915635152, 19], [975341.101575248, 21], [975341.286033956, 15], [975341.433453823, 19], [975341.57965439, 17], [975341.726100325, 6], [975341.875051373, 8], [975342.060711101, 3], [975342.234836745, 5], [975342.421273022, 29], [975342.604055957, 10], [975342.785610472, 13], [975342.970398734, 5], [975343.149510559, 16], [975343.331713122, 5], [975343.515729381, 16], [975343.696484076, 7], [975343.882208261, 27], [975344.029580084, 11], [975344.22288754, 8], [975344.36749519, 16], [975344.517097286, 5], [975344.664239501, 9], [975344.839255688, 14], [975344.987164426, 20], [975345.144475103, 12], [975345.294892488, 8], [975345.441920633, 5], [975345.591231241, 14], [975345.740844223, 14], [975345.890528293, 8], [975346.079974942, 13], [975346.252147754, 3], [975346.435998041, 10], [975346.620772935, 11], [975346.805847914, 10], [975346.990399928, 20], [975347.183843354, 23], [975347.365898384, 14], [975347.547850297, 13], [975347.697691123, 5], [975347.882784752, 14], [975348.071632348, 11], [975348.260248401, 43], [975348.442853995, 22], [975348.630166942, 11], [975348.817137421, 6], [975348.965657281, 8], [975349.156806868, 9], [975349.305405318, 13], [975349.456345284, 8], [975349.606827235, 20], [975349.756053823, 21], [975349.906357544, 16], [975350.05861179, 13], [975350.250947631, 6], [975350.397050542, 12], [975350.582404981, 6], [975350.732238913, 9], [975350.885882729, 6], [975351.036824644, 8], [975351.225883136, 15], [975351.41497393, 16], [975351.625830294, 27], [975351.860579675, 4], [975352.006736388, 8], [975352.204122962, 25], [975352.352101195, 18], [975352.50597962, 13], [975352.685326717, 64], [975352.84187697, 2], [975353.024240576, 10], [975353.209036673, 11], [975353.358941196, 15], [975353.507254463, 17], [975353.680273293, 14], [975353.863518198, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-36fc45e58c29ac9e106cf786b2f8687f", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034525264, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.466039433, "time_to_first_token": 0.12554469, "token_sha": "8a91591c94a3", "tokens_per_second": 18.936525566314224}, "seed": 1234, "sent": 975340.269535169, "speculative": {"acceptance_rate": 0.42105263157894735, "accepted": 176, "drafted": 418, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12814079003874213, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 418, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.937202027025123, "done": 975353.864382008, "finish_reason": "length", "first": 975340.397848961, "full_response_s": 13.595317317987792, "last": 975353.86340737, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975340.397848961, 3], [975340.548868758, 11], [975340.729401774, 30], [975340.914891355, 19], [975341.103076586, 21], [975341.283115996, 15], [975341.432998784, 19], [975341.578847491, 17], [975341.725820143, 6], [975341.875564858, 8], [975342.061675147, 3], [975342.234077236, 5], [975342.420804367, 27], [975342.603426251, 12], [975342.786524807, 13], [975342.96995091, 5], [975343.146486923, 16], [975343.329244538, 5], [975343.515225271, 14], [975343.696601032, 9], [975343.88018974, 27], [975344.029669793, 11], [975344.219728644, 8], [975344.366845405, 16], [975344.515311701, 5], [975344.66416696, 9], [975344.84070298, 14], [975344.987464639, 20], [975345.14585787, 12], [975345.295916883, 8], [975345.441126901, 5], [975345.591161644, 14], [975345.740540042, 11], [975345.891604719, 7], [975346.082084115, 17], [975346.251444211, 3], [975346.435957819, 10], [975346.620886147, 11], [975346.807628251, 10], [975346.989764814, 20], [975347.18403058, 23], [975347.369097327, 14], [975347.547689567, 13], [975347.698184113, 5], [975347.883490423, 14], [975348.073633286, 11], [975348.259868351, 43], [975348.443031636, 22], [975348.628023114, 11], [975348.81597367, 6], [975348.963607242, 8], [975349.15861802, 9], [975349.308943705, 13], [975349.456574476, 8], [975349.605898052, 20], [975349.755540049, 21], [975349.90758798, 16], [975350.059663033, 13], [975350.246598968, 6], [975350.398637414, 12], [975350.582874677, 6], [975350.73560953, 9], [975350.887796774, 6], [975351.035367959, 8], [975351.228718044, 15], [975351.411264685, 16], [975351.625303673, 27], [975351.858762554, 4], [975352.00661812, 8], [975352.202718451, 25], [975352.351666666, 18], [975352.50263449, 13], [975352.687479233, 64], [975352.838666155, 2], [975353.024436217, 10], [975353.208739659, 11], [975353.357124811, 15], [975353.507439528, 17], [975353.679782846, 14], [975353.86340737, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-9f64fdc67c279dd55cd49fb0c2e5696f", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034561327, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.466032936, "time_to_first_token": 0.125238349, "token_sha": "8a91591c94a3", "tokens_per_second": 18.93653470268031}, "seed": 1234, "sent": 975340.26906469, "speculative": {"acceptance_rate": 0.43564356435643564, "accepted": 176, "drafted": 404, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1287842709571123, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 404, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.93553125000761, "done": 975353.863794397, "finish_reason": "length", "first": 975340.39702723, "full_response_s": 13.593754749977961, "last": 975353.863773773, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975340.39702723, 3], [975340.549498351, 11], [975340.728378211, 30], [975340.914283584, 19], [975341.102255591, 21], [975341.283255287, 15], [975341.435124948, 19], [975341.579181495, 17], [975341.727412566, 6], [975341.876034154, 8], [975342.061029986, 3], [975342.23424907, 5], [975342.421128707, 29], [975342.605021091, 10], [975342.786087863, 13], [975342.970085609, 5], [975343.149804197, 16], [975343.330103212, 5], [975343.515431856, 16], [975343.698150704, 7], [975343.880470706, 29], [975344.029148467, 10], [975344.220863644, 23], [975344.36770547, 5], [975344.51602574, 9], [975344.667469434, 14], [975344.840152744, 20], [975344.987347619, 12], [975345.145446028, 8], [975345.29510712, 5], [975345.440863167, 12], [975345.590534322, 11], [975345.741508872, 5], [975345.889494394, 8], [975346.080032364, 13], [975346.251352807, 3], [975346.436204434, 10], [975346.620311687, 11], [975346.805771549, 10], [975346.990868215, 20], [975347.184358248, 23], [975347.367239536, 14], [975347.549664761, 13], [975347.699654781, 5], [975347.882183557, 14], [975348.072388194, 11], [975348.259594888, 43], [975348.444163101, 22], [975348.629020518, 11], [975348.816799129, 6], [975348.963835506, 8], [975349.157915229, 9], [975349.306895409, 13], [975349.455857926, 8], [975349.606357716, 20], [975349.755739738, 21], [975349.906603503, 16], [975350.059375651, 13], [975350.248995316, 6], [975350.398099769, 12], [975350.581710798, 6], [975350.733762763, 9], [975350.884666708, 6], [975351.034638369, 8], [975351.227577748, 15], [975351.413913984, 16], [975351.626785349, 27], [975351.86132272, 4], [975352.006989499, 8], [975352.203541462, 25], [975352.351801029, 18], [975352.503472604, 13], [975352.687935665, 64], [975352.839949885, 2], [975353.023934059, 10], [975353.20781294, 11], [975353.358424014, 15], [975353.509572829, 17], [975353.681667932, 14], [975353.863773773, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-ed757556bea7de33f86e9bb663019a19", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.03448709, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.466130517, "time_to_first_token": 0.125459957, "token_sha": "8a91591c94a3", "tokens_per_second": 18.93639748093049}, "seed": 1234, "sent": 975340.270039647, "speculative": {"acceptance_rate": 0.4200477326968974, "accepted": 176, "drafted": 419, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1269875830039382, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 419, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.935881866209073, "done": 975353.864263532, "finish_reason": "length", "first": 975340.39775314, "full_response_s": 13.595447313040495, "last": 975353.864250333, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975340.39775314, 3], [975340.548283851, 11], [975340.730999014, 30], [975340.912909249, 19], [975341.10255822, 21], [975341.283890976, 15], [975341.434214932, 19], [975341.579888158, 17], [975341.72864017, 6], [975341.875310835, 8], [975342.060830473, 3], [975342.23576964, 5], [975342.41940568, 27], [975342.601867571, 12], [975342.785657926, 13], [975342.971541254, 5], [975343.146997609, 16], [975343.33066668, 5], [975343.5146459, 14], [975343.696236213, 9], [975343.881066797, 27], [975344.029515686, 11], [975344.221319708, 8], [975344.370219477, 16], [975344.517581924, 5], [975344.665145053, 9], [975344.839996318, 14], [975344.987941806, 20], [975345.144660376, 8], [975345.296950543, 12], [975345.442086995, 5], [975345.591498016, 14], [975345.741855419, 11], [975345.889678004, 7], [975346.081745759, 17], [975346.251594286, 3], [975346.435629638, 10], [975346.620043633, 11], [975346.806093282, 10], [975346.990719836, 20], [975347.182136407, 23], [975347.366238532, 14], [975347.547150562, 13], [975347.696825441, 5], [975347.884671741, 14], [975348.072855505, 11], [975348.260087767, 43], [975348.444762407, 22], [975348.629228927, 11], [975348.818123178, 6], [975348.965500375, 8], [975349.157402655, 9], [975349.308076151, 13], [975349.456627866, 8], [975349.606453697, 20], [975349.7552291, 17], [975349.908890158, 20], [975350.060153528, 13], [975350.246195126, 6], [975350.397871649, 12], [975350.582937554, 6], [975350.735874097, 9], [975350.885395834, 6], [975351.034387242, 8], [975351.226914235, 15], [975351.412697563, 16], [975351.624892967, 27], [975351.860135466, 4], [975352.006352833, 8], [975352.201138379, 25], [975352.354613922, 18], [975352.504416203, 13], [975352.686516515, 64], [975352.838881011, 2], [975353.024533046, 10], [975353.207368731, 11], [975353.357224104, 15], [975353.508584352, 17], [975353.680868616, 14], [975353.864250333, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b14613b3e7adadc8c2f8af70d693105c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034670508, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.465909517, "time_to_first_token": 0.124124773, "token_sha": "8a91591c94a3", "tokens_per_second": 18.936708261560494}, "seed": 1234, "sent": 975340.268816219, "speculative": {"acceptance_rate": 0.44556962025316454, "accepted": 176, "drafted": 395, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12893692101351917, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 395, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.934963177567525, "done": 975353.864909461, "finish_reason": "length", "first": 975340.397715429, "full_response_s": 13.59516316303052, "last": 975353.864865991, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975340.397715429, 3], [975340.547813163, 11], [975340.729798688, 30], [975340.915960517, 19], [975341.102757749, 21], [975341.283053662, 15], [975341.432148286, 19], [975341.580638259, 17], [975341.729382512, 6], [975341.875638248, 8], [975342.062902495, 3], [975342.235364246, 5], [975342.421931862, 27], [975342.605414709, 12], [975342.786466857, 13], [975342.970920668, 5], [975343.147081622, 16], [975343.331018763, 5], [975343.515806242, 14], [975343.697774494, 9], [975343.882981369, 27], [975344.02979406, 11], [975344.218949248, 8], [975344.36714477, 16], [975344.518020133, 5], [975344.664092322, 9], [975344.838949123, 14], [975344.987235959, 20], [975345.145103272, 8], [975345.295022787, 12], [975345.441630003, 5], [975345.592823313, 14], [975345.74138614, 11], [975345.889576679, 7], [975346.080397999, 17], [975346.252239735, 3], [975346.435386383, 10], [975346.621889408, 11], [975346.805946759, 10], [975346.990025381, 20], [975347.182511081, 23], [975347.367739583, 14], [975347.548274026, 13], [975347.698872153, 5], [975347.883267487, 14], [975348.073303233, 11], [975348.25728945, 43], [975348.443794922, 22], [975348.627760739, 11], [975348.818405264, 6], [975348.964142423, 8], [975349.161141691, 9], [975349.309036646, 13], [975349.456443057, 8], [975349.605989105, 20], [975349.756104397, 17], [975349.905561652, 20], [975350.059191466, 13], [975350.247568582, 6], [975350.396626861, 12], [975350.58142228, 6], [975350.734154557, 9], [975350.88493937, 6], [975351.035192525, 8], [975351.228915733, 15], [975351.413145659, 16], [975351.627472061, 27], [975351.859402196, 4], [975352.00688187, 8], [975352.200886388, 25], [975352.352280692, 18], [975352.505876536, 13], [975352.685911929, 64], [975352.841161427, 2], [975353.024925592, 10], [975353.206464555, 11], [975353.356971041, 15], [975353.50698028, 17], [975353.680221007, 14], [975353.864865991, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-10f038f4d4bfe53f7c1a8efbff8198ef", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034706602, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.466324415, "time_to_first_token": 0.123657702, "token_sha": "8a91591c94a3", "tokens_per_second": 18.93612482081288}, "seed": 1234, "sent": 975340.269746298, "speculative": {"acceptance_rate": 0.4467005076142132, "accepted": 176, "drafted": 394, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12796913099009544, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 394, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.936811153235706, "done": 975353.863241344, "finish_reason": "length", "first": 975340.397368114, "full_response_s": 13.59406485001091, "last": 975353.863204465, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975340.397368114, 3], [975340.548793385, 11], [975340.730399099, 30], [975340.915701934, 19], [975341.101992897, 21], [975341.286451829, 15], [975341.432431972, 19], [975341.578415091, 17], [975341.72706581, 6], [975341.877291133, 8], [975342.062149146, 3], [975342.233714161, 5], [975342.419812722, 29], [975342.601770502, 10], [975342.785510428, 13], [975342.970545401, 5], [975343.150220742, 16], [975343.330264694, 5], [975343.515623065, 16], [975343.697586981, 7], [975343.880286377, 29], [975344.03054845, 10], [975344.224425758, 23], [975344.367858825, 5], [975344.515703255, 9], [975344.66521913, 14], [975344.840778626, 20], [975344.989719919, 12], [975345.144743797, 8], [975345.29416453, 5], [975345.442373881, 12], [975345.590242492, 11], [975345.742515268, 5], [975345.888971549, 8], [975346.081524551, 13], [975346.253111864, 3], [975346.435899069, 10], [975346.620405348, 11], [975346.805591332, 10], [975346.990920869, 20], [975347.183505558, 23], [975347.366370367, 14], [975347.551065255, 13], [975347.697155638, 5], [975347.882623717, 14], [975348.073556904, 11], [975348.256051654, 43], [975348.442390187, 22], [975348.627641895, 11], [975348.817572862, 6], [975348.965207297, 8], [975349.158209539, 9], [975349.305174302, 13], [975349.45606203, 8], [975349.606909712, 20], [975349.755315017, 21], [975349.905063573, 16], [975350.058987841, 13], [975350.248817114, 6], [975350.399087206, 12], [975350.581981604, 6], [975350.73136152, 9], [975350.884118295, 6], [975351.034514517, 8], [975351.228111889, 15], [975351.415725728, 16], [975351.624673471, 27], [975351.858904885, 4], [975352.007319983, 8], [975352.200043937, 25], [975352.352028557, 18], [975352.500664303, 13], [975352.688749365, 64], [975352.839145706, 2], [975353.023993865, 10], [975353.207270975, 11], [975353.356792967, 15], [975353.506664755, 17], [975353.679895306, 14], [975353.863204465, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-527f53bb893e0e24210769c66c9fe3ab", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034445475, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.466121142, "time_to_first_token": 0.125509524, "token_sha": "8a91591c94a3", "tokens_per_second": 18.936410664290754}, "seed": 1234, "sent": 975340.269176494, "speculative": {"acceptance_rate": 0.41411764705882353, "accepted": 176, "drafted": 425, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12819161999505013, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 425, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.935756691942743, "done": 975353.864779898, "finish_reason": "length", "first": 975340.398155462, "full_response_s": 13.595343685010448, "last": 975353.864741675, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975340.398155462, 3], [975340.548609279, 11], [975340.729604247, 30], [975340.915378137, 19], [975341.102948239, 21], [975341.284586839, 15], [975341.431901223, 19], [975341.579410223, 17], [975341.726698192, 6], [975341.876846189, 8], [975342.062047646, 3], [975342.235484258, 5], [975342.422689723, 27], [975342.602585257, 12], [975342.785967179, 13], [975342.971639106, 5], [975343.148667053, 16], [975343.330773556, 5], [975343.517752429, 14], [975343.697132165, 9], [975343.882723058, 27], [975344.029726687, 11], [975344.223667033, 8], [975344.367948261, 16], [975344.517639186, 5], [975344.666977468, 9], [975344.841634275, 14], [975344.988158503, 20], [975345.145583063, 8], [975345.296176218, 12], [975345.441043704, 5], [975345.592115258, 14], [975345.740740803, 11], [975345.890014056, 3], [975346.081335214, 8], [975346.251503777, 13], [975346.435754754, 3], [975346.620951601, 11], [975346.80722537, 10], [975346.991006178, 9], [975347.185018577, 10], [975347.366520394, 20], [975347.549302438, 14], [975347.70020961, 14], [975347.883060934, 13], [975348.072175241, 5], [975348.258012976, 14], [975348.443931093, 11], [975348.629561571, 59], [975348.81769329, 6], [975348.965015992, 11], [975349.157098042, 6], [975349.308552167, 8], [975349.456297846, 9], [975349.606971342, 13], [975349.755627166, 8], [975349.905826506, 20], [975350.058049154, 17], [975350.251218741, 29], [975350.399953128, 6], [975350.583013888, 16], [975350.733932453, 6], [975350.883926494, 15], [975351.035920964, 8], [975351.227812396, 14], [975351.41176182, 12], [975351.626049455, 13], [975351.85837908, 23], [975352.008143314, 8], [975352.201275286, 25], [975352.350993058, 18], [975352.500909222, 13], [975352.684973962, 64], [975352.839015822, 2], [975353.026340998, 10], [975353.206121943, 11], [975353.357670088, 15], [975353.510644151, 17], [975353.681722698, 14], [975353.864741675, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-7e575ab9eb4f0187d4e9029f0a2edfe4", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034912531, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.466443962, "time_to_first_token": 0.123040236, "token_sha": "8a91591c94a3", "tokens_per_second": 18.935956717271935}, "seed": 1234, "sent": 975340.269436213, "speculative": {"acceptance_rate": 0.45714285714285713, "accepted": 176, "drafted": 385, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12871924904175103, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 385, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.934895872246734, "done": 975353.865428835, "finish_reason": "length", "first": 975340.398204804, "full_response_s": 13.597182195982896, "last": 975353.865403236, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975340.398204804, 3], [975340.549543822, 11], [975340.730230129, 30], [975340.915270989, 19], [975341.101249931, 21], [975341.286391959, 15], [975341.431728029, 19], [975341.579143449, 17], [975341.727543633, 6], [975341.87539856, 8], [975342.060885831, 3], [975342.234728685, 5], [975342.420171573, 27], [975342.602308755, 12], [975342.785717572, 13], [975342.97198583, 5], [975343.147384619, 16], [975343.33060225, 5], [975343.514958401, 14], [975343.696782817, 9], [975343.879589026, 27], [975344.029613283, 11], [975344.220035865, 8], [975344.367585938, 16], [975344.518484116, 5], [975344.665080511, 9], [975344.84172072, 14], [975344.988605367, 20], [975345.145043002, 8], [975345.296506846, 12], [975345.44143041, 5], [975345.591019057, 14], [975345.740665925, 11], [975345.889060586, 7], [975346.080784113, 17], [975346.252804851, 3], [975346.436062151, 10], [975346.622120439, 11], [975346.807398068, 10], [975346.989289135, 20], [975347.183759949, 23], [975347.366046267, 14], [975347.548353975, 13], [975347.698545156, 5], [975347.884963571, 14], [975348.071999103, 11], [975348.258957519, 43], [975348.445109547, 22], [975348.630093776, 11], [975348.816505683, 6], [975348.964945242, 8], [975349.160210636, 9], [975349.307285811, 13], [975349.455051122, 8], [975349.606035583, 20], [975349.75636274, 21], [975349.905340092, 16], [975350.057954805, 13], [975350.251804625, 6], [975350.39687226, 12], [975350.584091482, 6], [975350.734439379, 9], [975350.887704297, 6], [975351.036100429, 8], [975351.227285806, 15], [975351.412232491, 16], [975351.626503151, 27], [975351.858066419, 4], [975352.006932525, 8], [975352.200753032, 25], [975352.351409203, 18], [975352.501692123, 13], [975352.688095676, 64], [975352.841494439, 2], [975353.02412506, 10], [975353.208661678, 11], [975353.359986199, 15], [975353.507930631, 17], [975353.68068987, 14], [975353.865403236, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b923c80d6c2ab3e732c4e2e65f1bf885", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 2, "prefill_raised": [], "prefill_seconds": 0.034595502, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.466568597, "time_to_first_token": 0.12493604, "token_sha": "8a91591c94a3", "tokens_per_second": 18.935781462310104}, "seed": 1234, "sent": 975340.268246639, "speculative": {"acceptance_rate": 0.44, "accepted": 176, "drafted": 400, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12995816499460489, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 400, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} diff --git a/validation/pr608-three-way/requests-reverse.jsonl b/validation/pr608-three-way/requests-reverse.jsonl new file mode 100644 index 000000000..a1002aa3b --- /dev/null +++ b/validation/pr608-three-way/requests-reverse.jsonl @@ -0,0 +1,312 @@ +{"arm": "stock", "burst": null, "phase": "uncached_first_use", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 69.24770626013763, "done": 975615.955530193, "finish_reason": "length", "first": 975612.273034137, "full_response_s": 3.831081417039968, "last": 975615.955466578, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975612.273034137, 2], [975612.356670892, 7], [975612.437882865, 4], [975612.518853517, 73], [975612.598820852, 51], [975612.679502807, 21], [975612.759111048, 14], [975612.839571794, 20], [975612.923359779, 16], [975613.004383055, 15], [975613.085940956, 23], [975613.166515957, 23], [975613.250711163, 25], [975613.337297664, 36], [975613.418604212, 14], [975613.499735534, 6], [975613.580341877, 18], [975613.660636389, 18], [975613.742538201, 19], [975613.82360954, 8], [975613.905211106, 11], [975613.985592834, 18], [975614.067089475, 15], [975614.147425747, 39], [975614.229258636, 30], [975614.316244664, 14], [975614.400345331, 15], [975614.481052713, 8], [975614.561791631, 6], [975614.64231729, 15], [975614.722952931, 23], [975614.80356366, 22], [975614.887254244, 26], [975614.968578027, 35], [975615.050152188, 31], [975615.131282361, 12], [975615.212038417, 13], [975615.299461043, 38], [975615.384055411, 47], [975615.464682461, 25], [975615.545970902, 11], [975615.626623888, 34], [975615.707460789, 12], [975615.788263003, 36], [975615.868720315, 60], [975615.955466578, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-466580eea337ab9b2c6ff1cd7ce9648d", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.133865121, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 3.682509047, "time_to_first_token": 0.134200119, "token_sha": "2b28aa2108de", "tokens_per_second": 69.2462657241097}, "seed": 1234, "sent": 975612.124448776, "speculative": {"acceptance_rate": 0.31555555555555553, "accepted": 213, "drafted": 675, "rounds": 45, "tokens_per_round": 5.688888888888889}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.14858536096289754, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 213, "drafted": 675, "rounds": 45}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 69.174004623681, "done": 975619.771795235, "finish_reason": "length", "first": 975616.08538641, "full_response_s": 3.8151158089749515, "last": 975619.771742309, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975616.08538641, 2], [975616.166295119, 7], [975616.251038205, 4], [975616.337099558, 73], [975616.419785291, 51], [975616.500092304, 21], [975616.580760924, 14], [975616.661470918, 20], [975616.742233183, 16], [975616.82260373, 15], [975616.906328573, 23], [975616.987221669, 23], [975617.068227513, 25], [975617.149084849, 36], [975617.230524649, 14], [975617.317538139, 6], [975617.401868486, 18], [975617.482311673, 18], [975617.562664143, 19], [975617.643369659, 8], [975617.723593061, 11], [975617.804591849, 18], [975617.886281884, 15], [975617.966624068, 39], [975618.047822005, 30], [975618.128839291, 14], [975618.209287184, 15], [975618.296826598, 8], [975618.380153982, 6], [975618.46167399, 15], [975618.542148506, 23], [975618.623032772, 22], [975618.703757649, 26], [975618.784604348, 35], [975618.86667231, 31], [975618.949043514, 12], [975619.029759817, 13], [975619.111111224, 38], [975619.191806904, 47], [975619.277900551, 25], [975619.362731784, 11], [975619.443850061, 34], [975619.524565133, 12], [975619.605201743, 36], [975619.685651494, 60], [975619.771742309, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8d14591b837e6954f245473140a56d8c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.127332158, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 3.686661538, "time_to_first_token": 0.127749203, "token_sha": "2b28aa2108de", "tokens_per_second": 69.16826982124769}, "seed": 1234, "sent": 975615.956679426, "speculative": {"acceptance_rate": 0.31555555555555553, "accepted": 213, "drafted": 675, "rounds": 45, "tokens_per_round": 5.688888888888889}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12870698398910463, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 213, "drafted": 675, "rounds": 45}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 69.1720748582593, "done": 975623.596225875, "finish_reason": "length", "first": 975619.909715807, "full_response_s": 3.8141463570063934, "last": 975623.596174548, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975619.909715807, 2], [975619.991230476, 7], [975620.073319864, 4], [975620.153548983, 73], [975620.235031188, 51], [975620.323063153, 21], [975620.406223841, 14], [975620.486326355, 20], [975620.567523912, 16], [975620.648095053, 15], [975620.728468568, 23], [975620.808970592, 23], [975620.892621236, 25], [975620.972892468, 36], [975621.054156345, 14], [975621.134810046, 6], [975621.215320103, 18], [975621.302603034, 18], [975621.386143842, 19], [975621.466878229, 8], [975621.547227874, 11], [975621.627757147, 18], [975621.708119352, 15], [975621.788663056, 39], [975621.869257352, 30], [975621.950621804, 14], [975622.03298111, 15], [975622.114529605, 8], [975622.194915443, 6], [975622.281074326, 15], [975622.365691987, 23], [975622.446749119, 22], [975622.527327912, 26], [975622.608215993, 35], [975622.688886944, 31], [975622.769645396, 12], [975622.850953211, 13], [975622.933918406, 38], [975623.014546863, 47], [975623.095914549, 25], [975623.176579102, 11], [975623.261836027, 34], [975623.347621882, 12], [975623.429815466, 36], [975623.510227242, 60], [975623.596174548, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-3fb4276af5e8f03e4dc9fb6ebf6423fb", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.126483344, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 3.686742222, "time_to_first_token": 0.126867206, "token_sha": "2b28aa2108de", "tokens_per_second": 69.16675608029533}, "seed": 1234, "sent": 975619.782079518, "speculative": {"acceptance_rate": 0.31555555555555553, "accepted": 213, "drafted": 675, "rounds": 45, "tokens_per_round": 5.688888888888889}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12763628899119794, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 213, "drafted": 675, "rounds": 45}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 67.1514293427637, "done": 975627.533547512, "finish_reason": "length", "first": 975623.736119893, "full_response_s": 3.9266571230255067, "last": 975627.533507417, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975623.736119893, 2], [975623.817909807, 7], [975623.899662157, 4], [975623.980336199, 73], [975624.062132947, 51], [975624.142854476, 21], [975624.228134955, 14], [975624.320914544, 20], [975624.410726229, 16], [975624.494672056, 15], [975624.574823936, 23], [975624.655393902, 23], [975624.73555943, 25], [975624.816240928, 36], [975624.899934187, 14], [975624.983253025, 6], [975625.077076476, 18], [975625.161665359, 18], [975625.243871731, 19], [975625.330640027, 8], [975625.413534236, 11], [975625.49408126, 18], [975625.574417521, 15], [975625.65499664, 39], [975625.746053542, 30], [975625.834709468, 14], [975625.920417876, 15], [975626.013733167, 8], [975626.096308618, 6], [975626.176886203, 15], [975626.261891605, 23], [975626.347684522, 22], [975626.429181298, 26], [975626.509542952, 35], [975626.590565229, 31], [975626.6816541, 12], [975626.770945835, 13], [975626.85193077, 38], [975626.935156878, 47], [975627.015780463, 25], [975627.097480051, 11], [975627.177809885, 34], [975627.263611267, 12], [975627.348987621, 36], [975627.438943997, 60], [975627.533507417, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-89e611a8f8204d1324ffa7763699f665", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.127896132, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 3.797738795, "time_to_first_token": 0.128323208, "token_sha": "2b28aa2108de", "tokens_per_second": 67.14521818502266}, "seed": 1234, "sent": 975623.606890389, "speculative": {"acceptance_rate": 0.31555555555555553, "accepted": 213, "drafted": 675, "rounds": 45, "tokens_per_round": 5.688888888888889}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12922950403299183, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 213, "drafted": 675, "rounds": 45}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.88295575509609, "done": 975638.456768855, "finish_reason": "length", "first": 975628.208767906, "full_response_s": 10.909467246965505, "last": 975638.456746583, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975628.208767906, 2], [975628.341369431, 7], [975628.507770211, 4], [975628.720629189, 63], [975628.964998863, 10], [975629.155154549, 31], [975629.347161673, 29], [975629.545471748, 22], [975629.729858516, 14], [975629.911994066, 24], [975630.093923399, 4], [975630.249691112, 13], [975630.447908938, 21], [975630.631296649, 2], [975630.812999732, 18], [975630.998043659, 29], [975631.23418067, 27], [975631.477055485, 24], [975631.626752611, 4], [975631.772635647, 16], [975632.007623077, 10], [975632.191670666, 31], [975632.347117866, 8], [975632.532649816, 11], [975632.716807402, 16], [975632.901450802, 12], [975633.085444957, 39], [975633.274290535, 18], [975633.462659821, 11], [975633.644539712, 16], [975633.830723026, 16], [975633.977342659, 11], [975634.162842138, 6], [975634.351737431, 9], [975634.538697623, 29], [975634.723262999, 22], [975634.910429636, 8], [975635.058481572, 18], [975635.244573055, 18], [975635.4381301, 34], [975635.63571171, 10], [975635.82006836, 14], [975636.021151866, 13], [975636.204165947, 2], [975636.396163582, 36], [975636.590138941, 42], [975636.794163264, 26], [975636.945820582, 17], [975637.130519439, 34], [975637.388164679, 12], [975637.57431881, 36], [975637.875499904, 50], [975638.062478481, 2], [975638.456746583, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-7ef46d071c0eea6647afca757d0665e2", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.451085644, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.246142854, "time_to_first_token": 0.658537001, "token_sha": "2b28aa2108de", "tokens_per_second": 24.887414086799534}, "seed": 1234, "sent": 975627.547301608, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6614662979263812, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.88444373314356, "done": 975638.456547229, "finish_reason": "length", "first": 975628.209132952, "full_response_s": 10.908429050934501, "last": 975638.456498846, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975628.209132952, 2], [975628.34275165, 7], [975628.507838306, 4], [975628.721527789, 63], [975628.96386251, 10], [975629.156030605, 31], [975629.347915765, 29], [975629.545759277, 22], [975629.729474814, 14], [975629.912451318, 24], [975630.094406603, 4], [975630.248702194, 13], [975630.448751092, 21], [975630.632056436, 2], [975630.814354544, 18], [975630.998086842, 29], [975631.234798878, 27], [975631.478362955, 24], [975631.626379565, 4], [975631.773054963, 16], [975632.007046116, 10], [975632.19130778, 31], [975632.348287131, 8], [975632.532252323, 11], [975632.717355548, 16], [975632.90138786, 12], [975633.085360607, 39], [975633.276540859, 18], [975633.462728603, 11], [975633.646682135, 16], [975633.830225679, 16], [975633.978151998, 11], [975634.162900905, 6], [975634.35259304, 9], [975634.53936791, 29], [975634.724073986, 22], [975634.910936279, 8], [975635.058908104, 18], [975635.244953477, 18], [975635.436933876, 34], [975635.634558685, 10], [975635.819941628, 14], [975636.019612899, 13], [975636.204939815, 2], [975636.396663777, 36], [975636.591078484, 42], [975636.793690845, 26], [975636.945507198, 17], [975637.130180568, 34], [975637.388356466, 12], [975637.574982056, 36], [975637.875857319, 50], [975638.062032461, 2], [975638.456498846, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8b87d0221d2d0548427531f1ffb9b962", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.451093308, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.246307649, "time_to_first_token": 0.65849745, "token_sha": "2b28aa2108de", "tokens_per_second": 24.8870138136919}, "seed": 1234, "sent": 975627.548118178, "speculative": {"acceptance_rate": 0.5546448087431693, "accepted": 203, "drafted": 366, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6610147739993408, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 366, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.880908693980196, "done": 975638.457564578, "finish_reason": "length", "first": 975628.208655061, "full_response_s": 10.908984733046964, "last": 975638.457476884, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975628.208655061, 2], [975628.341208475, 7], [975628.506192974, 4], [975628.720521928, 63], [975628.966197423, 10], [975629.155641464, 31], [975629.346735812, 29], [975629.545985686, 22], [975629.728358844, 14], [975629.913059669, 24], [975630.094049444, 4], [975630.249091832, 13], [975630.448143668, 21], [975630.631699806, 2], [975630.8131688, 18], [975630.99761639, 29], [975631.23434105, 27], [975631.476900962, 24], [975631.625582114, 4], [975631.772277384, 16], [975632.005976993, 10], [975632.191882597, 31], [975632.34894441, 8], [975632.532428174, 11], [975632.716547537, 16], [975632.900587689, 12], [975633.084611811, 39], [975633.276467581, 18], [975633.462205145, 11], [975633.644778314, 16], [975633.830784336, 16], [975633.978681456, 11], [975634.162636976, 6], [975634.352679054, 9], [975634.538929633, 29], [975634.725341712, 22], [975634.909787318, 8], [975635.058582865, 18], [975635.244678748, 18], [975635.437968984, 34], [975635.634241589, 10], [975635.819611652, 14], [975636.021823496, 13], [975636.204365894, 2], [975636.395681803, 36], [975636.589918195, 42], [975636.793544896, 26], [975636.945598284, 17], [975637.129533577, 34], [975637.388061418, 12], [975637.575057526, 36], [975637.876133503, 50], [975638.061713013, 2], [975638.457476884, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8d5351d0d0317a7019d2564cdca5aa3c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.45113897, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.249023369, "time_to_first_token": 0.655158787, "token_sha": "2b28aa2108de", "tokens_per_second": 24.880419413550467}, "seed": 1234, "sent": 975627.548579845, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6600752159720287, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.88454906422382, "done": 975638.456426864, "finish_reason": "length", "first": 975628.209071962, "full_response_s": 10.906759271980263, "last": 975638.456394481, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975628.209071962, 2], [975628.34221264, 7], [975628.508051548, 4], [975628.72081912, 63], [975628.965630751, 10], [975629.156102284, 31], [975629.348145391, 29], [975629.545667103, 22], [975629.729783638, 14], [975629.911911348, 24], [975630.094095491, 4], [975630.248898029, 13], [975630.449770696, 21], [975630.631758284, 2], [975630.813866093, 18], [975630.997506377, 29], [975631.234876092, 27], [975631.477330678, 24], [975631.626034134, 4], [975631.772705229, 16], [975632.00714365, 10], [975632.192937225, 31], [975632.347036236, 8], [975632.532162933, 11], [975632.714816, 16], [975632.900773508, 12], [975633.08509911, 39], [975633.276168309, 18], [975633.462526401, 11], [975633.646178773, 16], [975633.830835599, 16], [975633.97793202, 11], [975634.162117534, 6], [975634.352366358, 9], [975634.539172395, 29], [975634.724490855, 22], [975634.910359558, 8], [975635.059913437, 18], [975635.246196132, 18], [975635.437828748, 34], [975635.635013009, 10], [975635.820714551, 14], [975636.020391262, 13], [975636.204992389, 2], [975636.396266844, 36], [975636.588901806, 42], [975636.794993978, 26], [975636.945713529, 17], [975637.130332996, 34], [975637.388846469, 12], [975637.574651777, 36], [975637.876380201, 50], [975638.062283526, 2], [975638.456394481, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-10fb5f85ea384f99e2a3d0bea9647c3b", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.451092091, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.246932801, "time_to_first_token": 0.656209863, "token_sha": "2b28aa2108de", "tokens_per_second": 24.885495489451685}, "seed": 1234, "sent": 975627.549667592, "speculative": {"acceptance_rate": 0.5576923076923077, "accepted": 203, "drafted": 364, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6594043700024486, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 364, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.88709670188864, "done": 975638.455243695, "finish_reason": "length", "first": 975628.208924702, "full_response_s": 10.905383835895918, "last": 975638.455198225, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975628.208924702, 2], [975628.34147738, 7], [975628.506397496, 4], [975628.720886718, 63], [975628.96453638, 10], [975629.155732149, 31], [975629.34777932, 29], [975629.546603942, 22], [975629.729383361, 14], [975629.912078288, 24], [975630.094295997, 4], [975630.248851614, 13], [975630.449151689, 21], [975630.631442773, 2], [975630.813042867, 18], [975630.997216433, 29], [975631.234835565, 27], [975631.478097154, 24], [975631.625746606, 4], [975631.77250765, 16], [975632.006634255, 10], [975632.191163928, 31], [975632.348441479, 8], [975632.532707127, 11], [975632.715961745, 16], [975632.90039251, 12], [975633.085158469, 39], [975633.275045715, 18], [975633.46151486, 11], [975633.644837, 16], [975633.829417812, 16], [975633.976764755, 11], [975634.161409409, 6], [975634.353132258, 9], [975634.539420884, 29], [975634.725116182, 22], [975634.910734156, 8], [975635.059718211, 18], [975635.245913099, 18], [975635.43730137, 34], [975635.635239835, 10], [975635.820935905, 14], [975636.021515456, 13], [975636.204849241, 2], [975636.397494987, 36], [975636.59055165, 42], [975636.793923014, 26], [975636.946145869, 17], [975637.130042507, 34], [975637.387969709, 12], [975637.574257419, 36], [975637.87664197, 50], [975638.0619072, 2], [975638.455198225, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-e6a680b60453447c59368608ac89dc14", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.451093676, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.246323649, "time_to_first_token": 0.656990338, "token_sha": "2b28aa2108de", "tokens_per_second": 24.88697495173178}, "seed": 1234, "sent": 975627.549859859, "speculative": {"acceptance_rate": 0.5546448087431693, "accepted": 203, "drafted": 366, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6590648429701105, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 366, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.88103372754404, "done": 975638.457659343, "finish_reason": "length", "first": 975628.208827809, "full_response_s": 10.909973010071553, "last": 975638.457598129, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975628.208827809, 2], [975628.341793196, 7], [975628.506872779, 4], [975628.720029317, 63], [975628.965365542, 10], [975629.155475292, 31], [975629.347285334, 29], [975629.546047861, 22], [975629.728299006, 14], [975629.911472912, 24], [975630.093986038, 4], [975630.248025044, 13], [975630.448227474, 21], [975630.6314717, 2], [975630.813094274, 18], [975630.997691284, 29], [975631.234746767, 27], [975631.478027428, 24], [975631.625688016, 4], [975631.772403157, 16], [975632.007201936, 10], [975632.193128692, 31], [975632.347184232, 8], [975632.532076551, 11], [975632.715505229, 16], [975632.899979353, 12], [975633.084470743, 39], [975633.274399076, 18], [975633.461616137, 11], [975633.645200927, 16], [975633.829355782, 16], [975633.976578664, 11], [975634.163412667, 6], [975634.3530417, 9], [975634.53967035, 29], [975634.722817747, 22], [975634.909936322, 8], [975635.059472345, 18], [975635.245348362, 18], [975635.437576499, 34], [975635.634640747, 10], [975635.819548838, 14], [975636.020233186, 13], [975636.204898632, 2], [975636.396719807, 36], [975636.589035386, 42], [975636.793408164, 26], [975636.944853279, 17], [975637.131185325, 34], [975637.387658101, 12], [975637.573899973, 36], [975637.87543101, 50], [975638.061544682, 2], [975638.457598129, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-2602a080589153e02d7a4f0f5f9f3032", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.451140778, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.249010906, "time_to_first_token": 0.654349769, "token_sha": "2b28aa2108de", "tokens_per_second": 24.880449668632636}, "seed": 1234, "sent": 975627.547686333, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.661141476011835, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.886349771692153, "done": 975638.455133026, "finish_reason": "length", "first": 975628.208502537, "full_response_s": 10.906365090049803, "last": 975638.455083588, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975628.208502537, 2], [975628.341864938, 7], [975628.506121984, 4], [975628.719881993, 63], [975628.964423583, 10], [975629.155413934, 31], [975629.347011053, 29], [975629.545511987, 22], [975629.728238831, 14], [975629.911421601, 24], [975630.093816538, 4], [975630.248630964, 13], [975630.449213463, 21], [975630.632458186, 2], [975630.813237102, 18], [975630.997362957, 29], [975631.234648066, 27], [975631.476849699, 24], [975631.625970184, 4], [975631.772458179, 16], [975632.007675444, 10], [975632.190729636, 31], [975632.346955455, 8], [975632.532334128, 11], [975632.714706066, 16], [975632.900830115, 12], [975633.085039656, 39], [975633.275640851, 18], [975633.46306829, 11], [975633.645611236, 16], [975633.830530359, 16], [975633.977105274, 11], [975634.161496878, 6], [975634.352883945, 9], [975634.539308007, 29], [975634.722597705, 22], [975634.910094285, 8], [975635.059287582, 18], [975635.245054626, 18], [975635.437161982, 34], [975635.635318345, 10], [975635.820775126, 14], [975636.019680305, 13], [975636.204575313, 2], [975636.396986888, 36], [975636.587791835, 42], [975636.793070285, 26], [975636.945060122, 17], [975637.129684693, 34], [975637.389187836, 12], [975637.574722975, 36], [975637.875938884, 50], [975638.061771156, 2], [975638.455083588, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-4fa7721b09d05d1d3e5535235e001ed8", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.45109038, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.246123238, "time_to_first_token": 0.658493722, "token_sha": "2b28aa2108de", "tokens_per_second": 24.887461733260878}, "seed": 1234, "sent": 975627.548767936, "speculative": {"acceptance_rate": 0.5546448087431693, "accepted": 203, "drafted": 366, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6597346010385081, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 366, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.887296722477004, "done": 975638.455667284, "finish_reason": "length", "first": 975628.209448768, "full_response_s": 10.90789666492492, "last": 975638.455639941, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975628.209448768, 2], [975628.341133261, 7], [975628.506272252, 4], [975628.72104585, 63], [975628.965083613, 10], [975629.155259922, 31], [975629.346845089, 29], [975629.546742226, 22], [975629.729273124, 14], [975629.91274803, 24], [975630.093871913, 4], [975630.247942166, 13], [975630.448627399, 21], [975630.631396166, 2], [975630.813146512, 18], [975630.997294655, 29], [975631.234275836, 27], [975631.476945584, 24], [975631.625925945, 4], [975631.772339287, 16], [975632.007450282, 10], [975632.191227174, 31], [975632.347242295, 8], [975632.533056525, 11], [975632.71645802, 16], [975632.900962223, 12], [975633.084412648, 39], [975633.274696892, 18], [975633.462581023, 11], [975633.644715372, 16], [975633.829182011, 16], [975633.977588973, 11], [975634.1621795, 6], [975634.352159612, 9], [975634.538767894, 29], [975634.723938981, 22], [975634.911542503, 8], [975635.058639263, 18], [975635.244728475, 18], [975635.437642449, 34], [975635.634429856, 10], [975635.821403157, 14], [975636.019766431, 13], [975636.204654766, 2], [975636.395768313, 36], [975636.591313133, 42], [975636.794784672, 26], [975636.945278084, 17], [975637.130590637, 34], [975637.387745411, 12], [975637.573825543, 36], [975637.875331813, 50], [975638.062766505, 2], [975638.455639941, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-b0bfd5712e26323cc38a28c3c69411ae", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.451093195, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.247033151, "time_to_first_token": 0.655662934, "token_sha": "2b28aa2108de", "tokens_per_second": 24.88525178384094}, "seed": 1234, "sent": 975627.547770619, "speculative": {"acceptance_rate": 0.559228650137741, "accepted": 203, "drafted": 363, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6616781488992274, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 363, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 23.660934163517776, "done": 975638.454651295, "finish_reason": "length", "first": 975627.677347726, "full_response_s": 10.90788293699734, "last": 975638.454606064, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975627.677347726, 2], [975627.758131611, 7], [975628.341958439, 4], [975628.508532079, 72], [975628.721472975, 1], [975628.966309404, 27], [975629.155088679, 30], [975629.346919103, 15], [975629.546308238, 14], [975629.730064958, 20], [975629.911516895, 14], [975630.094223887, 4], [975630.249283426, 13], [975630.448692021, 21], [975630.631520451, 2], [975630.812966821, 18], [975630.997822401, 29], [975631.234597075, 27], [975631.477812921, 24], [975631.626536681, 4], [975631.77222177, 16], [975632.007860447, 10], [975632.190519465, 31], [975632.347842247, 8], [975632.532596569, 11], [975632.715432847, 16], [975632.900195251, 12], [975633.085749125, 39], [975633.276012233, 18], [975633.461686311, 11], [975633.644600031, 16], [975633.831039193, 16], [975633.977976707, 11], [975634.162954887, 6], [975634.352955975, 9], [975634.539614751, 29], [975634.723456578, 22], [975634.911220943, 8], [975635.058699694, 18], [975635.244883991, 18], [975635.438025975, 34], [975635.634335347, 10], [975635.81941537, 14], [975636.02047022, 13], [975636.204400853, 2], [975636.397686662, 36], [975636.587671918, 42], [975636.792870706, 26], [975636.944944269, 17], [975637.130406674, 34], [975637.388551597, 12], [975637.574465206, 36], [975637.875393923, 50], [975638.061438492, 2], [975638.454606064, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-b2a28d143077b0a39f6f85808d5906fa", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.128699754, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.777499644, "time_to_first_token": 0.129173949, "token_sha": "2b28aa2108de", "tokens_per_second": 23.660404400195215}, "seed": 1234, "sent": 975627.546768358, "speculative": {"acceptance_rate": 0.5444743935309974, "accepted": 202, "drafted": 371, "rounds": 54, "tokens_per_round": 4.7407407407407405}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.13057936797849834, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 202, "drafted": 371, "rounds": 54}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.88558594707381, "done": 975638.456070601, "finish_reason": "length", "first": 975628.208605335, "full_response_s": 10.9092281650519, "last": 975638.455500889, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975628.208605335, 2], [975628.343078121, 7], [975628.506705984, 4], [975628.72016605, 63], [975628.963665523, 10], [975629.155301905, 31], [975629.347540143, 29], [975629.545437029, 22], [975629.729539116, 14], [975629.912371864, 24], [975630.093776555, 4], [975630.249599898, 13], [975630.4494912, 21], [975630.631345527, 2], [975630.813434585, 18], [975630.998158856, 29], [975631.234378089, 27], [975631.476807476, 24], [975631.625534564, 4], [975631.772172811, 16], [975632.007791521, 10], [975632.19251906, 31], [975632.346880913, 8], [975632.533213049, 11], [975632.715804389, 16], [975632.900256738, 12], [975633.086044813, 39], [975633.275361754, 18], [975633.462039758, 11], [975633.644676701, 16], [975633.829256857, 16], [975633.976710884, 11], [975634.163120195, 6], [975634.352081806, 9], [975634.538383104, 29], [975634.722521227, 22], [975634.911922157, 8], [975635.060598171, 18], [975635.244801209, 18], [975635.438306208, 34], [975635.635499284, 10], [975635.82014087, 14], [975636.020542266, 13], [975636.20451261, 2], [975636.396348281, 36], [975636.588404571, 42], [975636.793985237, 26], [975636.946039904, 17], [975637.130776856, 34], [975637.388780167, 12], [975637.574171358, 36], [975637.877046983, 50], [975638.061589288, 2], [975638.455500889, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-cdf5d44ce73a33f5c7bab4c761304da4", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.451131722, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.247032255, "time_to_first_token": 0.655610264, "token_sha": "2b28aa2108de", "tokens_per_second": 24.88525395980614}, "seed": 1234, "sent": 975627.546842436, "speculative": {"acceptance_rate": 0.559228650137741, "accepted": 203, "drafted": 363, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6617628990206867, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 363, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.882376034337398, "done": 975638.456954386, "finish_reason": "length", "first": 975628.2087017, "full_response_s": 10.906823605997488, "last": 975638.456919139, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975628.2087017, 2], [975628.342676756, 7], [975628.506546436, 4], [975628.720948877, 63], [975628.963148737, 10], [975629.155585145, 31], [975629.347087035, 29], [975629.546196545, 22], [975629.729108392, 14], [975629.911621084, 24], [975630.094142162, 4], [975630.249328689, 13], [975630.44902358, 21], [975630.632341933, 2], [975630.813552773, 18], [975630.99777653, 29], [975631.235017032, 27], [975631.478151344, 24], [975631.62649817, 4], [975631.772765755, 16], [975632.006234634, 10], [975632.192377864, 31], [975632.349149476, 8], [975632.533430259, 11], [975632.717610965, 16], [975632.900321216, 12], [975633.085793716, 39], [975633.276228243, 18], [975633.461762613, 11], [975633.646619481, 16], [975633.829664286, 16], [975633.977492175, 11], [975634.162275562, 6], [975634.352438165, 9], [975634.538261635, 29], [975634.723606846, 22], [975634.91171813, 8], [975635.059531128, 18], [975635.246365087, 18], [975635.437514949, 34], [975635.635078223, 10], [975635.821061566, 14], [975636.020855858, 13], [975636.205401147, 2], [975636.397271873, 36], [975636.58963553, 42], [975636.793468802, 26], [975636.946085919, 17], [975637.130981283, 34], [975637.389246523, 12], [975637.574785261, 36], [975637.87729984, 50], [975638.063042434, 2], [975638.456919139, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8c4a37c26e3e036cc7e5ce9f0161b1bd", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.451134602, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.248405834, "time_to_first_token": 0.65573994, "token_sha": "2b28aa2108de", "tokens_per_second": 24.88191862523777}, "seed": 1234, "sent": 975627.55013078, "speculative": {"acceptance_rate": 0.559228650137741, "accepted": 203, "drafted": 363, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6585709200007841, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 363, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.88439128250622, "done": 975638.457179852, "finish_reason": "length", "first": 975628.209717305, "full_response_s": 10.908892590901814, "last": 975638.457104798, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975628.209717305, 2], [975628.342845807, 7], [975628.50791496, 4], [975628.721290339, 63], [975628.964655737, 10], [975629.156394548, 31], [975629.34771809, 29], [975629.546489929, 22], [975629.72933373, 14], [975629.912315433, 24], [975630.094532679, 4], [975630.249405551, 13], [975630.449557582, 21], [975630.631831978, 2], [975630.814213828, 18], [975630.998218566, 29], [975631.234954937, 27], [975631.47757592, 24], [975631.626119828, 4], [975631.772811674, 16], [975632.006697966, 10], [975632.191798631, 31], [975632.348513509, 8], [975632.532887554, 11], [975632.716895432, 16], [975632.89987678, 12], [975633.084515222, 39], [975633.274793993, 18], [975633.46330166, 11], [975633.645152464, 16], [975633.830285021, 16], [975633.976617623, 11], [975634.16135981, 6], [975634.351604075, 9], [975634.538847763, 29], [975634.723113403, 22], [975634.909568859, 8], [975635.059569319, 18], [975635.245747088, 18], [975635.437785165, 34], [975635.634700921, 10], [975635.819357691, 14], [975636.020622712, 13], [975636.20421585, 2], [975636.395559326, 36], [975636.588032757, 42], [975636.793208809, 26], [975636.94564489, 17], [975637.129464139, 34], [975637.388255781, 12], [975637.574935657, 36], [975637.876029074, 50], [975638.061649639, 2], [975638.457104798, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-bdfd8546bb8b95a83804c23096bf30e3", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.45113649, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.248630596, "time_to_first_token": 0.656322132, "token_sha": "2b28aa2108de", "tokens_per_second": 24.881372941622608}, "seed": 1234, "sent": 975627.548287261, "speculative": {"acceptance_rate": 0.559228650137741, "accepted": 203, "drafted": 363, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6614300439832732, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 363, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.878513814658522, "done": 975638.458702548, "finish_reason": "length", "first": 975628.208549704, "full_response_s": 10.909524239017628, "last": 975638.458358109, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975628.208549704, 2], [975628.342551175, 7], [975628.507304368, 4], [975628.719961975, 63], [975628.964298978, 10], [975629.155353072, 31], [975629.347611165, 29], [975629.546089332, 22], [975629.729137927, 14], [975629.91176012, 24], [975630.094469641, 4], [975630.248188016, 13], [975630.448570792, 21], [975630.632395627, 2], [975630.813936443, 18], [975630.997981244, 29], [975631.234423048, 27], [975631.478184687, 24], [975631.626571928, 4], [975631.772968918, 16], [975632.00677846, 10], [975632.192263947, 31], [975632.347370355, 8], [975632.531876109, 11], [975632.716056942, 16], [975632.901184393, 12], [975633.08562852, 39], [975633.276081079, 18], [975633.463424265, 11], [975633.646390943, 16], [975633.830044068, 16], [975633.977181608, 11], [975634.161320835, 6], [975634.351970321, 9], [975634.538184101, 29], [975634.722415214, 22], [975634.911489576, 8], [975635.058838714, 18], [975635.24521131, 18], [975635.437716831, 34], [975635.63450139, 10], [975635.819303213, 14], [975636.019193246, 13], [975636.2044529, 2], [975636.395633404, 36], [975636.590609392, 42], [975636.79460466, 26], [975636.945771239, 17], [975637.131066544, 34], [975637.388918227, 12], [975637.575114165, 36], [975637.875793224, 50], [975638.063133807, 2], [975638.458358109, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-d5c19df6cc21213e73e74306894f0f1d", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.451142778, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.249864035, "time_to_first_token": 0.654500309, "token_sha": "2b28aa2108de", "tokens_per_second": 24.878378789148496}, "seed": 1234, "sent": 975627.549178309, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6593713950132951, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.883339891404187, "done": 975638.457423654, "finish_reason": "length", "first": 975628.20952355, "full_response_s": 10.910471940995194, "last": 975638.457344024, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975628.20952355, 2], [975628.341655327, 7], [975628.506635986, 4], [975628.720247039, 63], [975628.963290813, 10], [975629.156324294, 31], [975629.348300554, 29], [975629.546427419, 22], [975629.728733506, 14], [975629.912243531, 24], [975630.094671011, 4], [975630.248269293, 13], [975630.448061958, 21], [975630.631653967, 2], [975630.813818894, 18], [975630.997151011, 29], [975631.235059463, 27], [975631.477285527, 24], [975631.625635841, 4], [975631.772835065, 16], [975632.006909416, 10], [975632.193055926, 31], [975632.347537199, 8], [975632.531999625, 11], [975632.71560953, 16], [975632.900084422, 12], [975633.084979721, 39], [975633.275173551, 18], [975633.461567642, 11], [975633.644932006, 16], [975633.829307287, 16], [975633.977401058, 11], [975634.162058079, 6], [975634.351534301, 9], [975634.538479469, 29], [975634.722988767, 22], [975634.909693896, 8], [975635.0587715, 18], [975635.245277212, 18], [975635.438086405, 34], [975635.634814902, 10], [975635.821615023, 14], [975636.020708374, 13], [975636.204297512, 2], [975636.398164313, 36], [975636.589219317, 42], [975636.794546662, 26], [975636.945192262, 17], [975637.129608183, 34], [975637.388423121, 12], [975637.574400072, 36], [975637.876419032, 50], [975638.061495547, 2], [975638.457344024, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-b63ac892b5862a61aa88a60e514c7b02", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.451137834, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.248877805, "time_to_first_token": 0.655307184, "token_sha": "2b28aa2108de", "tokens_per_second": 24.880772788177467}, "seed": 1234, "sent": 975627.546951713, "speculative": {"acceptance_rate": 0.559228650137741, "accepted": 203, "drafted": 363, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6625718369614333, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 363, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.885364737737635, "done": 975638.455823488, "finish_reason": "length", "first": 975628.208809505, "full_response_s": 10.906740007922053, "last": 975638.455796145, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975628.208809505, 2], [975628.341422614, 7], [975628.507379342, 4], [975628.721349698, 63], [975628.964235748, 10], [975629.155686711, 31], [975629.347233879, 29], [975629.54562904, 22], [975629.72917183, 14], [975629.912876442, 24], [975630.094595701, 4], [975630.248772576, 13], [975630.449249286, 21], [975630.632100003, 2], [975630.813497559, 18], [975630.997577127, 29], [975631.234697312, 27], [975631.477219193, 24], [975631.626173027, 4], [975631.772945574, 16], [975632.006044319, 10], [975632.190647094, 31], [975632.348353897, 8], [975632.532787796, 11], [975632.716692862, 16], [975632.900916208, 12], [975633.084941434, 39], [975633.274880519, 18], [975633.462934886, 11], [975633.645965114, 16], [975633.829786906, 16], [975633.976674965, 11], [975634.161717224, 6], [975634.351809733, 9], [975634.539252537, 29], [975634.722664871, 22], [975634.910030927, 8], [975635.060168631, 18], [975635.246439869, 18], [975635.437241676, 34], [975635.634765719, 10], [975635.820336273, 14], [975636.019533349, 13], [975636.204759036, 2], [975636.397070934, 36], [975636.589757063, 42], [975636.794346811, 26], [975636.94514556, 17], [975637.130102122, 34], [975637.387883743, 12], [975637.574862827, 36], [975637.875604557, 50], [975638.061966862, 2], [975638.455796145, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-66bf61b60d1b3253fc8e934238462a11", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.451094795, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.246276851, "time_to_first_token": 0.6569045, "token_sha": "2b28aa2108de", "tokens_per_second": 24.887088618449045}, "seed": 1234, "sent": 975627.54908348, "speculative": {"acceptance_rate": 0.5576923076923077, "accepted": 203, "drafted": 364, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6597260249545798, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 364, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.885194861494032, "done": 975638.455941965, "finish_reason": "length", "first": 975628.20885648, "full_response_s": 10.909265717025846, "last": 975638.45591307, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975628.20885648, 2], [975628.341300089, 7], [975628.508308453, 4], [975628.720567687, 63], [975628.963739697, 10], [975629.155532187, 31], [975629.347819127, 29], [975629.545558738, 22], [975629.729232133, 14], [975629.912804188, 24], [975630.094331693, 4], [975630.248095858, 13], [975630.448420492, 21], [975630.631576737, 2], [975630.813622532, 18], [975630.997443531, 29], [975631.23450191, 27], [975631.477153195, 24], [975631.626455867, 4], [975631.772542305, 16], [975632.007934317, 10], [975632.19107265, 31], [975632.347422914, 8], [975632.532505884, 11], [975632.717525783, 16], [975632.901025613, 12], [975633.085846674, 39], [975633.274621406, 18], [975633.462119036, 11], [975633.645705633, 16], [975633.829538273, 16], [975633.978412247, 11], [975634.162716158, 6], [975634.351889891, 9], [975634.539096237, 29], [975634.724683474, 22], [975634.911652804, 8], [975635.060451679, 18], [975635.245586068, 18], [975635.43745175, 34], [975635.634160312, 10], [975635.820218276, 14], [975636.021967492, 13], [975636.205063956, 2], [975636.397884673, 36], [975636.590062495, 42], [975636.794091362, 26], [975636.946115038, 17], [975637.131276971, 34], [975637.38850259, 12], [975637.573984371, 36], [975637.876353049, 50], [975638.063099008, 2], [975638.45591307, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-087227a62209732920e352bf8572db2d", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.45109238, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.2461917, "time_to_first_token": 0.65866807, "token_sha": "2b28aa2108de", "tokens_per_second": 24.887295442657}, "seed": 1234, "sent": 975627.546676248, "speculative": {"acceptance_rate": 0.5546448087431693, "accepted": 203, "drafted": 366, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6621802320005372, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 366, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.735789253069107, "done": 975649.497440161, "finish_reason": "length", "first": 975639.188129449, "full_response_s": 11.023776633897796, "last": 975649.497078858, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975639.188129449, 2], [975639.365189621, 7], [975639.514272838, 4], [975639.743664231, 63], [975639.981456126, 10], [975640.182243785, 31], [975640.371334314, 29], [975640.555703993, 22], [975640.738713483, 14], [975640.923331125, 24], [975641.106987786, 4], [975641.257467165, 13], [975641.446399287, 21], [975641.628046545, 2], [975641.811549739, 18], [975641.997116466, 29], [975642.231979474, 27], [975642.476514962, 24], [975642.626438119, 4], [975642.774033817, 16], [975643.007355814, 10], [975643.192522492, 31], [975643.348310905, 8], [975643.534144893, 11], [975643.719863588, 16], [975643.902321508, 12], [975644.085679325, 39], [975644.275112486, 18], [975644.460838545, 11], [975644.645447482, 16], [975644.829067581, 16], [975644.979111945, 11], [975645.162635586, 6], [975645.355652497, 9], [975645.544069785, 29], [975645.740488798, 22], [975645.927306627, 8], [975646.090718514, 18], [975646.280647719, 18], [975646.477181133, 34], [975646.682725671, 10], [975646.868872944, 14], [975647.055541199, 13], [975647.255680747, 2], [975647.447929638, 36], [975647.631599988, 42], [975647.817010724, 26], [975647.981972529, 17], [975648.166623641, 34], [975648.426308172, 12], [975648.609853185, 36], [975648.915358768, 50], [975649.102543498, 2], [975649.497078858, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-ee46dacd5ff8b0242014816dc92f2d31", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.496866014, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.310324428, "time_to_first_token": 0.711806201, "token_sha": "2b28aa2108de", "tokens_per_second": 24.732490406169013}, "seed": 1234, "sent": 975638.473663527, "speculative": {"acceptance_rate": 0.5471698113207547, "accepted": 203, "drafted": 371, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.7144659219775349, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 371, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.732004678718766, "done": 975649.49882334, "finish_reason": "length", "first": 975639.187952926, "full_response_s": 11.024863981059752, "last": 975649.498479845, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975639.187952926, 2], [975639.365444206, 7], [975639.514241063, 4], [975639.743267058, 63], [975639.981161573, 10], [975640.180358299, 31], [975640.371223469, 29], [975640.555459215, 22], [975640.737562745, 14], [975640.923834472, 24], [975641.106813487, 4], [975641.258354326, 13], [975641.445266085, 21], [975641.627995267, 2], [975641.812178346, 18], [975641.99625292, 29], [975642.232392519, 27], [975642.47595976, 24], [975642.626095936, 4], [975642.773219151, 16], [975643.008013573, 10], [975643.192835972, 31], [975643.348237131, 8], [975643.534480596, 11], [975643.719662714, 16], [975643.903485381, 12], [975644.085987429, 39], [975644.274314843, 18], [975644.461075995, 11], [975644.645573526, 16], [975644.829713356, 16], [975644.979562269, 11], [975645.162773966, 6], [975645.355557651, 9], [975645.545156796, 29], [975645.740737464, 22], [975645.925742732, 8], [975646.092672159, 18], [975646.281824104, 18], [975646.476885445, 34], [975646.68343834, 10], [975646.870256124, 14], [975647.056586035, 13], [975647.257197123, 2], [975647.447060669, 36], [975647.631407897, 42], [975647.816682588, 26], [975647.982291321, 17], [975648.168276686, 34], [975648.426493799, 12], [975648.610262438, 36], [975648.916290376, 50], [975649.102619448, 2], [975649.498479845, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8cdc6b04796e7b87f757100beb1f8e6e", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.496869486, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.311822245, "time_to_first_token": 0.711390628, "token_sha": "2b28aa2108de", "tokens_per_second": 24.72889795241035}, "seed": 1234, "sent": 975638.473959359, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.7139935670420527, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.73401252918798, "done": 975649.499272497, "finish_reason": "length", "first": 975639.189469494, "full_response_s": 11.025661721010692, "last": 975649.499159428, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975639.189469494, 2], [975639.366294184, 7], [975639.515376361, 4], [975639.744294151, 63], [975639.982175035, 10], [975640.180098866, 31], [975640.371765679, 29], [975640.556321752, 22], [975640.738270951, 14], [975640.924252589, 24], [975641.107832068, 4], [975641.258867368, 13], [975641.447050182, 21], [975641.628118672, 2], [975641.814193941, 18], [975641.994231758, 29], [975642.233102612, 27], [975642.475739222, 24], [975642.62489024, 4], [975642.773547318, 16], [975643.008188688, 10], [975643.193571744, 31], [975643.349843681, 8], [975643.534910409, 11], [975643.718672148, 16], [975643.902783495, 12], [975644.085252248, 39], [975644.275477629, 18], [975644.461039212, 11], [975644.645284238, 16], [975644.829450547, 16], [975644.980202124, 11], [975645.163051015, 6], [975645.355213596, 9], [975645.545272857, 29], [975645.739701731, 22], [975645.926047348, 8], [975646.091965201, 18], [975646.280160564, 18], [975646.478290912, 34], [975646.68220874, 10], [975646.87047383, 14], [975647.056372569, 13], [975647.255612716, 2], [975647.447685309, 36], [975647.631673058, 42], [975647.816901015, 26], [975647.981768615, 17], [975648.165846638, 34], [975648.425661053, 12], [975648.610298949, 36], [975648.915262595, 50], [975649.101847228, 2], [975649.499159428, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-de9b1150f4df6fd54fcbbbe3c310877c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.496874478, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.312467444, "time_to_first_token": 0.711621806, "token_sha": "2b28aa2108de", "tokens_per_second": 24.72735079017041}, "seed": 1234, "sent": 975638.473610776, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.715858718031086, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 23.404429214467203, "done": 975649.496892047, "finish_reason": "length", "first": 975638.601426394, "full_response_s": 11.022458252962679, "last": 975649.496799986, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975638.601426394, 2], [975638.690582269, 7], [975639.365837652, 4], [975639.514621725, 72], [975639.743537355, 1], [975639.982119852, 27], [975640.179442835, 30], [975640.370578718, 15], [975640.555836021, 14], [975640.739167967, 20], [975640.923545167, 14], [975641.107036473, 4], [975641.257310818, 13], [975641.445627852, 21], [975641.627615741, 2], [975641.811212164, 18], [975641.994581909, 29], [975642.23210995, 27], [975642.476273384, 24], [975642.627059526, 4], [975642.773508631, 16], [975643.007185739, 10], [975643.191902972, 31], [975643.347708601, 8], [975643.533469263, 11], [975643.719030026, 16], [975643.901934366, 12], [975644.084959104, 39], [975644.274841405, 18], [975644.460444396, 11], [975644.644252521, 16], [975644.828292369, 16], [975644.977885497, 11], [975645.162138495, 6], [975645.353755939, 9], [975645.546643813, 29], [975645.739217424, 22], [975645.92589004, 8], [975646.092246858, 18], [975646.281144762, 18], [975646.476086378, 34], [975646.681448792, 10], [975646.874391407, 14], [975647.054358014, 13], [975647.256044497, 2], [975647.447342422, 36], [975647.631273772, 42], [975647.815913761, 26], [975647.981038186, 17], [975648.165943451, 34], [975648.426261453, 12], [975648.609996653, 36], [975648.916034414, 50], [975649.101422743, 2], [975649.496799986, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-2997b1107b0c7ff7a4a76292264d03ab", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.125457248, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.895798428, "time_to_first_token": 0.126043441, "token_sha": "2b28aa2108de", "tokens_per_second": 23.40351665690708}, "seed": 1234, "sent": 975638.474433794, "speculative": {"acceptance_rate": 0.5358090185676393, "accepted": 202, "drafted": 377, "rounds": 54, "tokens_per_round": 4.7407407407407405}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12699259992223233, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 202, "drafted": 377, "rounds": 54}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.734222265313758, "done": 975649.499084374, "finish_reason": "length", "first": 975639.189271307, "full_response_s": 11.024488392053172, "last": 975649.498873819, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975639.189271307, 2], [975639.365759846, 7], [975639.514190425, 4], [975639.744141515, 63], [975639.981655704, 10], [975640.179694237, 31], [975640.371678289, 29], [975640.55623961, 22], [975640.738917717, 14], [975640.925061255, 24], [975641.107403695, 4], [975641.258809146, 13], [975641.445178103, 21], [975641.629062663, 2], [975641.813956667, 18], [975641.996594623, 29], [975642.232794748, 27], [975642.476196266, 24], [975642.625963619, 4], [975642.773929244, 16], [975643.008242319, 10], [975643.193766235, 31], [975643.348558851, 8], [975643.53366489, 11], [975643.719398865, 16], [975643.90322174, 12], [975644.08517729, 39], [975644.275379743, 18], [975644.461396626, 11], [975644.645037125, 16], [975644.829358741, 16], [975644.980076415, 11], [975645.163829794, 6], [975645.354627196, 9], [975645.544316114, 29], [975645.74010172, 22], [975645.926291214, 8], [975646.092448933, 18], [975646.280723253, 18], [975646.476525615, 34], [975646.682918321, 10], [975646.869582173, 14], [975647.055859062, 13], [975647.25493395, 2], [975647.44696912, 36], [975647.630428163, 42], [975647.817539238, 26], [975647.981242517, 17], [975648.16735287, 34], [975648.425715963, 12], [975648.609816929, 36], [975648.914399833, 50], [975649.101664961, 2], [975649.498873819, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-01a373a3a23f454e42ba3ef5546cba0e", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.496879197, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.31218406, "time_to_first_token": 0.711219513, "token_sha": "2b28aa2108de", "tokens_per_second": 24.728030310195997}, "seed": 1234, "sent": 975638.474595982, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.7146753249689937, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.734187182850384, "done": 975649.498211516, "finish_reason": "length", "first": 975639.188563086, "full_response_s": 11.02447253500577, "last": 975649.498180221, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975639.188563086, 2], [975639.365294642, 7], [975639.51453024, 4], [975639.742848445, 63], [975639.981724582, 10], [975640.180730289, 31], [975640.37233888, 29], [975640.555508942, 22], [975640.737857746, 14], [975640.924334699, 24], [975641.107781957, 4], [975641.257233668, 13], [975641.444913054, 21], [975641.628332234, 2], [975641.813833278, 18], [975641.997267246, 29], [975642.232584465, 27], [975642.476328791, 24], [975642.626277003, 4], [975642.773623332, 16], [975643.008146193, 10], [975643.193996517, 31], [975643.349231233, 8], [975643.53479838, 11], [975643.719724248, 16], [975643.902541038, 12], [975644.085621039, 39], [975644.274991225, 18], [975644.462032674, 11], [975644.645489193, 16], [975644.829625326, 16], [975644.979375858, 11], [975645.163154324, 6], [975645.355330377, 9], [975645.544515549, 29], [975645.739649428, 22], [975645.926664212, 8], [975646.091026314, 18], [975646.281327861, 18], [975646.477844972, 34], [975646.682685912, 10], [975646.86901926, 14], [975647.055768569, 13], [975647.256586211, 2], [975647.44786708, 36], [975647.630899718, 42], [975647.816300374, 26], [975647.981927251, 17], [975648.167878264, 34], [975648.425450194, 12], [975648.610172504, 36], [975648.915680136, 50], [975649.10244454, 2], [975649.498180221, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-b1be3e3fa2c2c5baac7e3d316e2d6b09", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.49686771, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.310601717, "time_to_first_token": 0.711801993, "token_sha": "2b28aa2108de", "tokens_per_second": 24.73182526094078}, "seed": 1234, "sent": 975638.473738981, "speculative": {"acceptance_rate": 0.5471698113207547, "accepted": 203, "drafted": 371, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.714824105030857, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 371, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.730283908313574, "done": 975649.49982373, "finish_reason": "length", "first": 975639.188482624, "full_response_s": 11.025339168962091, "last": 975649.499726965, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975639.188482624, 2], [975639.366151212, 7], [975639.515521909, 4], [975639.743787284, 63], [975639.981859859, 10], [975640.182292504, 31], [975640.372278705, 29], [975640.557342717, 22], [975640.739380169, 14], [975640.924732352, 24], [975641.107662473, 4], [975641.258674525, 13], [975641.445320772, 21], [975641.628770446, 2], [975641.812824585, 18], [975641.997041252, 29], [975642.232862106, 27], [975642.475221508, 24], [975642.626639313, 4], [975642.774247236, 16], [975643.008523927, 10], [975643.193061966, 31], [975643.349766307, 8], [975643.533549933, 11], [975643.718830128, 16], [975643.902240326, 12], [975644.085106652, 39], [975644.276735515, 18], [975644.460969406, 11], [975644.64436775, 16], [975644.828900785, 16], [975644.979048842, 11], [975645.162340218, 6], [975645.355452886, 9], [975645.545691614, 29], [975645.739871806, 22], [975645.925163372, 8], [975646.090531095, 18], [975646.280471963, 18], [975646.477778302, 34], [975646.681564981, 10], [975646.874303425, 14], [975647.054324703, 13], [975647.257136356, 2], [975647.447782762, 36], [975647.630544496, 42], [975647.817205407, 26], [975647.981500862, 17], [975648.166552635, 34], [975648.425859175, 12], [975648.60970258, 36], [975648.914707425, 50], [975649.101754318, 2], [975649.499726965, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-f06bb8c5655a165dff01b70423c50df5", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.496875614, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.313064884, "time_to_first_token": 0.711348421, "token_sha": "2b28aa2108de", "tokens_per_second": 24.72591832478575}, "seed": 1234, "sent": 975638.474484561, "speculative": {"acceptance_rate": 0.553133514986376, "accepted": 203, "drafted": 367, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.7139980630017817, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 367, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.734386211863637, "done": 975649.498750318, "finish_reason": "length", "first": 975639.189176654, "full_response_s": 11.024421336944215, "last": 975649.498710831, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975639.189176654, 2], [975639.366203738, 7], [975639.514349588, 4], [975639.743046504, 63], [975639.981231076, 10], [975640.181790661, 31], [975640.37218434, 29], [975640.555421088, 22], [975640.737507739, 14], [975640.92268087, 24], [975641.107106279, 4], [975641.257364928, 13], [975641.446035601, 21], [975641.629324432, 2], [975641.813498823, 18], [975641.99543363, 29], [975642.232711534, 27], [975642.476761371, 24], [975642.627340015, 4], [975642.773401642, 16], [975643.00758384, 10], [975643.192976416, 31], [975643.348085039, 8], [975643.534215195, 11], [975643.719238997, 16], [975643.902584973, 12], [975644.085322726, 39], [975644.276464739, 18], [975644.462218669, 11], [975644.645695091, 16], [975644.829533184, 16], [975644.980568162, 11], [975645.163410493, 6], [975645.355902682, 9], [975645.546358029, 29], [975645.74019367, 22], [975645.926991467, 8], [975646.0935462, 18], [975646.280298896, 18], [975646.47804935, 34], [975646.683162331, 10], [975646.8685726, 14], [975647.055468704, 13], [975647.254874224, 2], [975647.446798356, 36], [975647.630294134, 42], [975647.816439987, 26], [975647.98087659, 17], [975648.165666642, 34], [975648.426550853, 12], [975648.609775923, 36], [975648.91576383, 50], [975649.102496827, 2], [975649.498710831, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-1056afd33ad06b5ddc3459948685d9bf", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.49687035, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.311918371, "time_to_first_token": 0.711183113, "token_sha": "2b28aa2108de", "tokens_per_second": 24.728667433707713}, "seed": 1234, "sent": 975638.474328981, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.7148476729635149, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.732529089279986, "done": 975649.498603602, "finish_reason": "length", "first": 975639.188202599, "full_response_s": 11.024811631068587, "last": 975649.498510901, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975639.188202599, 2], [975639.36562985, 7], [975639.514468033, 4], [975639.743600185, 63], [975639.981767957, 10], [975640.181332369, 31], [975640.37158978, 29], [975640.556397766, 22], [975640.738868727, 14], [975640.924835485, 24], [975641.107712871, 4], [975641.257902978, 13], [975641.444814817, 21], [975641.627789288, 2], [975641.813088226, 18], [975641.994646035, 29], [975642.231910307, 27], [975642.475391023, 24], [975642.625042844, 4], [975642.772845225, 16], [975643.007422244, 10], [975643.192026441, 31], [975643.347823574, 8], [975643.533379234, 11], [975643.718499352, 16], [975643.901754067, 12], [975644.084778277, 39], [975644.27443052, 18], [975644.461776824, 11], [975644.644626799, 16], [975644.828519227, 16], [975644.978475241, 11], [975645.163358623, 6], [975645.35598068, 9], [975645.544913891, 29], [975645.740363921, 22], [975645.927461983, 8], [975646.093854368, 18], [975646.280584808, 18], [975646.47723198, 34], [975646.683223497, 10], [975646.869775512, 14], [975647.056262572, 13], [975647.255482032, 2], [975647.448169872, 36], [975647.631031299, 42], [975647.817298028, 26], [975647.981179174, 17], [975648.16538289, 34], [975648.426199726, 12], [975648.609393133, 36], [975648.914815326, 50], [975649.102094981, 2], [975649.498510901, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-29b59c39fd13d13e9a578e9f03139db6", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.496869294, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.31183714, "time_to_first_token": 0.711200505, "token_sha": "2b28aa2108de", "tokens_per_second": 24.728862232593407}, "seed": 1234, "sent": 975638.473791971, "speculative": {"acceptance_rate": 0.5501355013550135, "accepted": 203, "drafted": 369, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.7144106279592961, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 369, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.730471400553416, "done": 975649.499881217, "finish_reason": "length", "first": 975639.188617484, "full_response_s": 11.025763318059035, "last": 975649.499783651, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975639.188617484, 2], [975639.366042751, 7], [975639.515298987, 4], [975639.743201844, 63], [975639.982342806, 10], [975640.181261923, 31], [975640.37066582, 29], [975640.555887268, 22], [975640.738018317, 14], [975640.92420355, 24], [975641.106873005, 4], [975641.257629321, 13], [975641.445114681, 21], [975641.628388776, 2], [975641.812429811, 18], [975641.996507154, 29], [975642.231579676, 27], [975642.475810932, 24], [975642.625460993, 4], [975642.773059315, 16], [975643.008070851, 10], [975643.192324769, 31], [975643.348845371, 8], [975643.534679119, 11], [975643.719924099, 16], [975643.902979666, 12], [975644.085913511, 39], [975644.274906556, 18], [975644.460529321, 11], [975644.644315304, 16], [975644.828966383, 16], [975644.978348797, 11], [975645.162267995, 6], [975645.354158648, 9], [975645.545829962, 29], [975645.740145271, 22], [975645.925352023, 8], [975646.091674505, 18], [975646.280234722, 18], [975646.476962083, 34], [975646.681872621, 10], [975646.874255474, 14], [975647.054559976, 13], [975647.256110255, 2], [975647.447188874, 36], [975647.632129606, 42], [975647.816335845, 26], [975647.981864804, 17], [975648.166824068, 34], [975648.425153834, 12], [975648.609302063, 36], [975648.914630163, 50], [975649.102142676, 2], [975649.499783651, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-9e0a18920307fb362683b692fa2c1c36", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.496878078, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.313066292, "time_to_first_token": 0.710646648, "token_sha": "2b28aa2108de", "tokens_per_second": 24.72591494905907}, "seed": 1234, "sent": 975638.474117899, "speculative": {"acceptance_rate": 0.553133514986376, "accepted": 203, "drafted": 367, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.7144995849812403, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 367, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.730485563332948, "done": 975649.498441174, "finish_reason": "length", "first": 975639.187177603, "full_response_s": 11.024160959990695, "last": 975649.498337865, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975639.187177603, 2], [975639.36649853, 7], [975639.514397107, 4], [975639.743962847, 63], [975639.981405951, 10], [975640.180921468, 31], [975640.371119616, 29], [975640.556119422, 22], [975640.738322629, 14], [975640.923248375, 24], [975641.107273923, 4], [975641.258941046, 13], [975641.446901402, 21], [975641.627681259, 2], [975641.812340534, 18], [975641.995615145, 29], [975642.233154914, 27], [975642.476954662, 24], [975642.625808407, 4], [975642.772980085, 16], [975643.007509522, 10], [975643.191839726, 31], [975643.348622961, 8], [975643.534626097, 11], [975643.719179158, 16], [975643.902020619, 12], [975644.084993951, 39], [975644.2750366, 18], [975644.460633927, 11], [975644.645140834, 16], [975644.829493569, 16], [975644.977996998, 11], [975645.163939183, 6], [975645.353851872, 9], [975645.543663188, 29], [975645.740796006, 22], [975645.925244697, 8], [975646.090215007, 18], [975646.280038775, 18], [975646.476427761, 34], [975646.682469645, 10], [975646.869264006, 14], [975647.056071761, 13], [975647.254825185, 2], [975647.446888914, 36], [975647.630234472, 42], [975647.817462088, 26], [975647.98179711, 17], [975648.165461592, 34], [975648.425343045, 12], [975648.609542409, 36], [975648.914296956, 50], [975649.101487493, 2], [975649.498337865, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-947c12aa6cf07f361623bf94728b12e8", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.496868526, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.311654793, "time_to_first_token": 0.711588751, "token_sha": "2b28aa2108de", "tokens_per_second": 24.72929952747304}, "seed": 1234, "sent": 975638.474280214, "speculative": {"acceptance_rate": 0.5501355013550135, "accepted": 203, "drafted": 369, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.7128973889630288, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 369, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.73043924509544, "done": 975649.499240817, "finish_reason": "length", "first": 975639.188023804, "full_response_s": 11.02538823906798, "last": 975649.499203378, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975639.188023804, 2], [975639.365560331, 7], [975639.514714059, 4], [975639.743901345, 63], [975639.981917713, 10], [975640.179970885, 31], [975640.372704678, 29], [975640.557270127, 22], [975640.738393651, 14], [975640.923754586, 24], [975641.107591978, 4], [975641.258145211, 13], [975641.445542542, 21], [975641.62884134, 2], [975641.811826979, 18], [975641.995034201, 29], [975642.232046112, 27], [975642.477150017, 24], [975642.626514485, 4], [975642.773836958, 16], [975643.007026415, 10], [975643.191985194, 31], [975643.347912948, 8], [975643.533919539, 11], [975643.71874581, 16], [975643.901706884, 12], [975644.084916129, 39], [975644.275995391, 18], [975644.461976019, 11], [975644.645767649, 16], [975644.828436333, 16], [975644.978878191, 11], [975645.162198173, 6], [975645.353974077, 9], [975645.545950919, 29], [975645.739322781, 22], [975645.92581201, 8], [975646.090141441, 18], [975646.281266071, 18], [975646.477577715, 34], [975646.682282226, 10], [975646.874571418, 14], [975647.054265216, 13], [975647.256681648, 2], [975647.448108434, 36], [975647.631866989, 42], [975647.815846498, 26], [975647.980940029, 17], [975648.167467091, 34], [975648.425264039, 12], [975648.609610887, 36], [975648.914546118, 50], [975649.10220645, 2], [975649.499203378, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-9175a21c7c33fc5db55d6227511affdf", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.49687195, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.312288073, "time_to_first_token": 0.710709622, "token_sha": "2b28aa2108de", "tokens_per_second": 24.727780895459087}, "seed": 1234, "sent": 975638.473852578, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.7141712260199711, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.733979251264188, "done": 975649.498145598, "finish_reason": "length", "first": 975639.188408258, "full_response_s": 11.024227165966295, "last": 975649.498112063, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975639.188408258, 2], [975639.365368592, 7], [975639.514317125, 4], [975639.742954522, 63], [975639.981374144, 10], [975640.180835198, 31], [975640.372946272, 29], [975640.556852346, 22], [975640.737752996, 14], [975640.922620888, 24], [975641.107320722, 4], [975641.257571547, 13], [975641.446099615, 21], [975641.628705904, 2], [975641.811959072, 18], [975641.997202511, 29], [975642.231398673, 27], [975642.475460317, 24], [975642.627133828, 4], [975642.773329356, 16], [975643.007255929, 10], [975643.192130038, 31], [975643.350102634, 8], [975643.534738446, 11], [975643.720129421, 16], [975643.901900847, 12], [975644.085438579, 39], [975644.274547509, 18], [975644.461592349, 11], [975644.645087715, 16], [975644.828608857, 16], [975644.979707929, 11], [975645.163771508, 6], [975645.354304004, 9], [975645.543748641, 29], [975645.740425808, 22], [975645.926739394, 8], [975646.089863193, 18], [975646.281598942, 18], [975646.476320052, 34], [975646.682572555, 10], [975646.86999245, 14], [975647.054617399, 13], [975647.255114409, 2], [975647.447436035, 36], [975647.631493847, 42], [975647.816756746, 26], [975647.981563196, 17], [975648.165560549, 34], [975648.425794201, 12], [975648.610132121, 36], [975648.915447166, 50], [975649.102041687, 2], [975649.498112063, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-2e840c5f88610d812ecb85f841a4c7bc", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.496864702, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.310311037, "time_to_first_token": 0.712089457, "token_sha": "2b28aa2108de", "tokens_per_second": 24.73252252865085}, "seed": 1234, "sent": 975638.473918432, "speculative": {"acceptance_rate": 0.5471698113207547, "accepted": 203, "drafted": 371, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.7144898260012269, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 371, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.733637288786024, "done": 975649.49794034, "finish_reason": "length", "first": 975639.188073819, "full_response_s": 11.023732139961794, "last": 975649.497920164, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975639.188073819, 2], [975639.366105485, 7], [975639.514914757, 4], [975639.743445949, 63], [975639.981516908, 10], [975640.181974848, 31], [975640.372821395, 29], [975640.557195889, 22], [975640.737620136, 14], [975640.922757076, 24], [975641.107185845, 4], [975641.258431732, 13], [975641.44470602, 21], [975641.628523301, 2], [975641.811605161, 18], [975641.996032782, 29], [975642.232167213, 27], [975642.47530565, 24], [975642.626947161, 4], [975642.773143185, 16], [975643.008476137, 10], [975643.192780757, 31], [975643.34964215, 8], [975643.534551491, 11], [975643.71896526, 16], [975643.902092458, 12], [975644.085725388, 39], [975644.274648658, 18], [975644.460772227, 11], [975644.645221264, 16], [975644.828698118, 16], [975644.97897606, 11], [975645.162964121, 6], [975645.354216007, 9], [975645.544208693, 29], [975645.739479593, 22], [975645.9263731, 8], [975646.091381505, 18], [975646.282522709, 18], [975646.477132447, 34], [975646.683513906, 10], [975646.868686069, 14], [975647.054668246, 13], [975647.255542158, 2], [975647.447296583, 36], [975647.630863175, 42], [975647.81708973, 26], [975647.982030624, 17], [975648.165137184, 34], [975648.426445464, 12], [975648.610205367, 36], [975648.915940865, 50], [975649.10198684, 2], [975649.497920164, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-eb2e091516970540892d5c0953858a1f", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.496859838, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.310314493, "time_to_first_token": 0.711825336, "token_sha": "2b28aa2108de", "tokens_per_second": 24.73251423835108}, "seed": 1234, "sent": 975638.4742082, "speculative": {"acceptance_rate": 0.5442359249329759, "accepted": 203, "drafted": 373, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.713865619036369, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 373, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.72777068993786, "done": 975649.501270876, "finish_reason": "length", "first": 975639.187641782, "full_response_s": 11.026482115034014, "last": 975649.499934111, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975639.187641782, 2], [975639.365088904, 7], [975639.514773833, 4], [975639.743130918, 63], [975639.981313073, 10], [975640.180556598, 31], [975640.370745962, 29], [975640.555611307, 22], [975640.73767495, 14], [975640.923182713, 24], [975641.106925292, 4], [975641.259121762, 13], [975641.445845254, 21], [975641.629260945, 2], [975641.812928518, 18], [975641.996142667, 29], [975642.232909897, 27], [975642.477204223, 24], [975642.626163806, 4], [975642.773733041, 16], [975643.007827386, 10], [975643.192585466, 31], [975643.348174077, 8], [975643.533984754, 11], [975643.718590886, 16], [975643.901817937, 12], [975644.084854051, 39], [975644.275297153, 18], [975644.461347412, 11], [975644.644405925, 16], [975644.828789828, 16], [975644.979491215, 11], [975645.162701344, 6], [975645.355076224, 9], [975645.544439919, 29], [975645.739584086, 22], [975645.926806528, 8], [975646.093090996, 18], [975646.282255292, 18], [975646.476658363, 34], [975646.683104493, 10], [975646.869355859, 14], [975647.056172654, 13], [975647.25502542, 2], [975647.448371307, 36], [975647.6303653, 42], [975647.816150842, 26], [975647.981106648, 17], [975648.168042596, 34], [975648.425923318, 12], [975648.609466107, 36], [975648.914466744, 50], [975649.101563011, 2], [975649.499934111, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-13fd84b84b9a9a6c2cde20cd497ae6b2", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.496879886, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.313182097, "time_to_first_token": 0.710779316, "token_sha": "2b28aa2108de", "tokens_per_second": 24.725637305888053}, "seed": 1234, "sent": 975638.474788761, "speculative": {"acceptance_rate": 0.553133514986376, "accepted": 203, "drafted": 367, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.7128530209884048, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 367, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 24.73380847984506, "done": 975649.497346259, "finish_reason": "length", "first": 975639.187257504, "full_response_s": 11.023803784977645, "last": 975649.497032491, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975639.187257504, 2], [975639.366235001, 7], [975639.515091633, 4], [975639.743370271, 63], [975639.98158937, 10], [975640.179861368, 31], [975640.371467255, 29], [975640.556177388, 22], [975640.737961359, 14], [975640.923428931, 24], [975641.107871091, 4], [975641.257723847, 13], [975641.446628753, 21], [975641.627904069, 2], [975641.812556112, 18], [975641.994722193, 29], [975642.231486543, 27], [975642.475531388, 24], [975642.625883285, 4], [975642.773271885, 16], [975643.007112701, 10], [975643.192446766, 31], [975643.349176899, 8], [975643.534078959, 11], [975643.719806406, 16], [975643.901987164, 12], [975644.085067981, 39], [975644.275246915, 18], [975644.460693845, 11], [975644.644927959, 16], [975644.828837843, 16], [975644.980654976, 11], [975645.163013928, 6], [975645.354069898, 9], [975645.545882841, 29], [975645.739795856, 22], [975645.925949623, 8], [975646.093929214, 18], [975646.280379086, 18], [975646.477384584, 34], [975646.683040126, 10], [975646.870343321, 14], [975647.0550367, 13], [975647.256172798, 2], [975647.447240537, 36], [975647.630811769, 42], [975647.815747157, 26], [975647.980826719, 17], [975648.166106423, 34], [975648.426375146, 12], [975648.609923503, 36], [975648.915411071, 50], [975649.10193041, 2], [975649.497032491, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-66ab084a80232584609090bf11f5430a", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.496866926, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.310368971, "time_to_first_token": 0.712165984, "token_sha": "2b28aa2108de", "tokens_per_second": 24.7323835565186}, "seed": 1234, "sent": 975638.473542474, "speculative": {"acceptance_rate": 0.5471698113207547, "accepted": 203, "drafted": 371, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.7137150299968198, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 371, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.184021730768986, "done": 975660.34289299, "finish_reason": "length", "first": 975650.217400643, "full_response_s": 10.824277626001276, "last": 975660.342868399, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975650.217400643, 2], [975650.383487771, 7], [975650.532663582, 4], [975650.762597289, 63], [975651.002254057, 10], [975651.185288439, 31], [975651.378252689, 29], [975651.560651233, 22], [975651.743216091, 14], [975651.924752788, 24], [975652.110633852, 4], [975652.25918319, 13], [975652.447544077, 21], [975652.628319835, 2], [975652.809461023, 18], [975652.993851042, 29], [975653.228755594, 27], [975653.474895308, 24], [975653.623931516, 4], [975653.773591501, 16], [975654.001862215, 10], [975654.183645762, 31], [975654.33614846, 8], [975654.52292626, 11], [975654.706221832, 16], [975654.892038459, 12], [975655.076169901, 39], [975655.265786736, 18], [975655.451489912, 11], [975655.633613423, 16], [975655.818181829, 16], [975655.968436704, 11], [975656.151604799, 6], [975656.341395745, 9], [975656.527424438, 29], [975656.711751318, 22], [975656.896326803, 8], [975657.04721952, 18], [975657.232611097, 18], [975657.425630427, 34], [975657.607070363, 10], [975657.792239898, 14], [975657.978966004, 13], [975658.160559812, 2], [975658.351990276, 36], [975658.536711026, 42], [975658.718504621, 26], [975658.869445598, 17], [975659.057093668, 34], [975659.299480856, 12], [975659.4873414, 36], [975659.773750113, 50], [975659.957721738, 2], [975660.342868399, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-6cbe534def70712b4b552759241b70e0", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.488343721, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.125700709, "time_to_first_token": 0.696236833, "token_sha": "2b28aa2108de", "tokens_per_second": 25.183442344227004}, "seed": 1234, "sent": 975649.518615364, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6987852790625766, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.186066398926858, "done": 975660.342162241, "finish_reason": "length", "first": 975650.217494497, "full_response_s": 10.823491774033755, "last": 975660.342140242, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975650.217494497, 2], [975650.385170686, 7], [975650.53251037, 4], [975650.762220131, 63], [975651.003971244, 10], [975651.185081997, 31], [975651.376698714, 29], [975651.559414321, 22], [975651.744860208, 14], [975651.925912437, 24], [975652.110351059, 4], [975652.259971585, 13], [975652.446391803, 21], [975652.630910263, 2], [975652.810534627, 18], [975652.994244839, 29], [975653.230167221, 27], [975653.475214755, 24], [975653.623198816, 4], [975653.769863503, 16], [975654.00122532, 10], [975654.184479884, 31], [975654.337023509, 8], [975654.522462608, 11], [975654.7068174, 16], [975654.891618278, 12], [975655.076610642, 39], [975655.264937702, 18], [975655.452875348, 11], [975655.635246468, 16], [975655.818982273, 16], [975655.967149186, 11], [975656.152458265, 6], [975656.342357864, 9], [975656.529039804, 29], [975656.71168764, 22], [975656.897731774, 8], [975657.047149922, 18], [975657.232333984, 18], [975657.426924921, 34], [975657.608202734, 10], [975657.79193421, 14], [975657.976189532, 13], [975658.163901613, 2], [975658.353597978, 36], [975658.537327234, 42], [975658.72144848, 26], [975658.870295095, 17], [975659.057739171, 34], [975659.298607727, 12], [975659.485398539, 36], [975659.773823775, 50], [975659.957062956, 2], [975660.342140242, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-af8b86bd59378373d7d39238c1b8dafd", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.488338072, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.124086256, "time_to_first_token": 0.696687749, "token_sha": "2b28aa2108de", "tokens_per_second": 25.187458260628237}, "seed": 1234, "sent": 975649.518670467, "speculative": {"acceptance_rate": 0.5486486486486486, "accepted": 203, "drafted": 370, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6988240299979225, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 370, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.189623241122646, "done": 975660.342096915, "finish_reason": "length", "first": 975650.218856381, "full_response_s": 10.82327640405856, "last": 975660.342072499, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975650.218856381, 2], [975650.384314069, 7], [975650.533105234, 4], [975650.76239339, 63], [975651.003307069, 10], [975651.18672821, 31], [975651.378750916, 29], [975651.562057116, 22], [975651.743673359, 14], [975651.924871537, 24], [975652.110553358, 4], [975652.258185728, 13], [975652.446810688, 21], [975652.629169076, 2], [975652.809309875, 18], [975652.994510048, 29], [975653.228613341, 27], [975653.476356469, 24], [975653.622836361, 4], [975653.770898276, 16], [975654.000876801, 10], [975654.182933749, 31], [975654.337126162, 8], [975654.524306448, 11], [975654.707088065, 16], [975654.890437493, 12], [975655.075826342, 39], [975655.26552959, 18], [975655.451534487, 11], [975655.634352444, 16], [975655.818366993, 16], [975655.967581927, 11], [975656.152851775, 6], [975656.341502047, 9], [975656.526975937, 29], [975656.712203307, 22], [975656.89749378, 8], [975657.048184503, 18], [975657.232148021, 18], [975657.427311855, 34], [975657.60619709, 10], [975657.792097438, 14], [975657.977911823, 13], [975658.160970777, 2], [975658.350905648, 36], [975658.537432047, 42], [975658.718745127, 26], [975658.871116834, 17], [975659.056202651, 34], [975659.29894303, 12], [975659.488152467, 36], [975659.774794246, 50], [975659.956401757, 2], [975660.342072499, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-720396b6d17c5a96a0592f531c7455ab", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.488341241, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.124153806, "time_to_first_token": 0.696448333, "token_sha": "2b28aa2108de", "tokens_per_second": 25.187290205812186}, "seed": 1234, "sent": 975649.518820511, "speculative": {"acceptance_rate": 0.5486486486486486, "accepted": 203, "drafted": 370, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.7000358700752258, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 370, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.185834243399185, "done": 975660.343380081, "finish_reason": "length", "first": 975650.218537941, "full_response_s": 10.824224955053069, "last": 975660.343277012, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975650.218537941, 2], [975650.384568526, 7], [975650.533345884, 4], [975650.761639314, 63], [975651.003393355, 10], [975651.187104856, 31], [975651.378537466, 29], [975651.561262801, 22], [975651.743018481, 14], [975651.925086651, 24], [975652.111261899, 4], [975652.259331618, 13], [975652.446933085, 21], [975652.62996176, 2], [975652.809678633, 18], [975652.994315973, 29], [975653.228938437, 27], [975653.474214429, 24], [975653.621527179, 4], [975653.770596523, 16], [975653.999102015, 10], [975654.184056424, 31], [975654.336661886, 8], [975654.524477548, 11], [975654.705863841, 16], [975654.891675285, 12], [975655.077118373, 39], [975655.264630126, 18], [975655.451252991, 11], [975655.634975803, 16], [975655.819040895, 16], [975655.967441834, 11], [975656.151363206, 6], [975656.341760776, 9], [975656.527950328, 29], [975656.710695522, 22], [975656.896767847, 8], [975657.04846736, 18], [975657.231731568, 18], [975657.425363442, 34], [975657.609055383, 10], [975657.791188454, 14], [975657.978841607, 13], [975658.16178882, 2], [975658.35282803, 36], [975658.536139425, 42], [975658.720347981, 26], [975658.870781915, 17], [975659.055148695, 34], [975659.299030211, 12], [975659.488888624, 36], [975659.772945526, 50], [975659.957122858, 2], [975660.343277012, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-6c54cb64fc49ac028fda4b4cda7481d7", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.488346841, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.126208136, "time_to_first_token": 0.695859964, "token_sha": "2b28aa2108de", "tokens_per_second": 25.182180395190723}, "seed": 1234, "sent": 975649.519155126, "speculative": {"acceptance_rate": 0.553133514986376, "accepted": 203, "drafted": 367, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6993828150443733, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 367, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.18136786385443, "done": 975660.343752216, "finish_reason": "length", "first": 975650.217178953, "full_response_s": 10.82441685500089, "last": 975660.343713833, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975650.217178953, 2], [975650.38320565, 7], [975650.533980843, 4], [975650.761671745, 63], [975651.004215478, 10], [975651.186923597, 31], [975651.377629266, 29], [975651.560790333, 22], [975651.743765725, 14], [975651.926191342, 24], [975652.111126095, 4], [975652.259406992, 13], [975652.446559831, 21], [975652.631642547, 2], [975652.810133037, 18], [975652.994955557, 29], [975653.228797769, 27], [975653.476271351, 24], [975653.622367605, 4], [975653.774384088, 16], [975653.999635745, 10], [975654.182843623, 31], [975654.336252105, 8], [975654.525252951, 11], [975654.708016137, 16], [975654.891420252, 12], [975655.07797331, 39], [975655.264409252, 18], [975655.452038906, 11], [975655.634273854, 16], [975655.818888003, 16], [975655.966943367, 11], [975656.151514066, 6], [975656.343531402, 9], [975656.528646198, 29], [975656.712491747, 22], [975656.896453519, 8], [975657.048046427, 18], [975657.232686391, 18], [975657.425943891, 34], [975657.607350484, 10], [975657.792302744, 14], [975657.978597101, 13], [975658.160932634, 2], [975658.355403674, 36], [975658.538212603, 42], [975658.720513528, 26], [975658.869347792, 17], [975659.057797218, 34], [975659.29833431, 12], [975659.487637025, 36], [975659.773976795, 50], [975659.956171075, 2], [975660.343713833, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-7e6643283e76c8cf558b4665a0c7ece6", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.488355848, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.126522592, "time_to_first_token": 0.695443847, "token_sha": "2b28aa2108de", "tokens_per_second": 25.181398420169543}, "seed": 1234, "sent": 975649.519335361, "speculative": {"acceptance_rate": 0.553133514986376, "accepted": 203, "drafted": 367, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6978435920318589, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 367, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 23.84794207170917, "done": 975660.34118561, "finish_reason": "length", "first": 975649.648249414, "full_response_s": 10.821894791093655, "last": 975660.340995951, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975649.648249414, 2], [975649.729476959, 7], [975650.383292496, 4], [975650.532553777, 72], [975650.762175108, 1], [975651.002023807, 27], [975651.184960784, 30], [975651.37524488, 15], [975651.559201431, 14], [975651.741504408, 20], [975651.926313467, 14], [975652.108730301, 4], [975652.258070323, 13], [975652.445859593, 21], [975652.630607263, 2], [975652.809389409, 18], [975652.996013897, 29], [975653.228826936, 27], [975653.473977748, 24], [975653.62141307, 4], [975653.770444623, 16], [975654.0015188, 10], [975654.183732, 31], [975654.336026879, 8], [975654.522626428, 11], [975654.706621998, 16], [975654.890300393, 12], [975655.078033517, 39], [975655.263842483, 18], [975655.450151244, 11], [975655.634511511, 16], [975655.818325074, 16], [975655.96707386, 11], [975656.151735516, 6], [975656.343421052, 9], [975656.528775618, 29], [975656.710954891, 22], [975656.897224155, 8], [975657.048849078, 18], [975657.231373385, 18], [975657.426548275, 34], [975657.609301217, 10], [975657.792161388, 14], [975657.977621831, 13], [975658.160466502, 2], [975658.351244295, 36], [975658.53717223, 42], [975658.721106073, 26], [975658.869224979, 17], [975659.056788108, 34], [975659.299216047, 12], [975659.487153565, 36], [975659.772708204, 50], [975659.956458123, 2], [975660.340995951, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-dcece021da592108e09093e294f953e7", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.127176466, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.693142351, "time_to_first_token": 0.127639702, "token_sha": "2b28aa2108de", "tokens_per_second": 23.84705932360032}, "seed": 1234, "sent": 975649.519290819, "speculative": {"acceptance_rate": 0.5372340425531915, "accepted": 202, "drafted": 376, "rounds": 54, "tokens_per_round": 4.7407407407407405}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12895859510172158, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 202, "drafted": 376, "rounds": 54}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.18076679759589, "done": 975660.344684015, "finish_reason": "length", "first": 975650.217727963, "full_response_s": 10.82438127102796, "last": 975660.344504564, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975650.217727963, 2], [975650.383623911, 7], [975650.532876808, 4], [975650.761265948, 63], [975651.002963686, 10], [975651.185386533, 31], [975651.376425361, 29], [975651.56256523, 22], [975651.74172917, 14], [975651.925540303, 24], [975652.111013378, 4], [975652.259837797, 13], [975652.448165469, 21], [975652.631280781, 2], [975652.809259588, 18], [975652.994046556, 29], [975653.229221118, 27], [975653.474998009, 24], [975653.623672243, 4], [975653.772064837, 16], [975653.998393298, 10], [975654.183532133, 31], [975654.337082371, 8], [975654.524758388, 11], [975654.706482753, 16], [975654.890924121, 12], [975655.07752145, 39], [975655.264572639, 18], [975655.449928033, 11], [975655.633802314, 16], [975655.818515869, 16], [975655.967023317, 11], [975656.151834153, 6], [975656.342072928, 9], [975656.528375853, 29], [975656.711429215, 22], [975656.897544835, 8], [975657.046703214, 18], [975657.231591732, 18], [975657.423696494, 34], [975657.606415836, 10], [975657.791705288, 14], [975657.975467359, 13], [975658.162149114, 2], [975658.351102443, 36], [975658.535578623, 42], [975658.719322696, 26], [975658.871043844, 17], [975659.05577735, 34], [975659.29815401, 12], [975659.490075729, 36], [975659.773138081, 50], [975659.956245137, 2], [975660.344504564, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8886eef21fed9c4be97d57b3d8ce34db", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.488359336, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.127428281, "time_to_first_token": 0.695261403, "token_sha": "2b28aa2108de", "tokens_per_second": 25.179146464893144}, "seed": 1234, "sent": 975649.520302744, "speculative": {"acceptance_rate": 0.5546448087431693, "accepted": 203, "drafted": 366, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6974252189975232, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 366, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.17819857692893, "done": 975660.345158883, "finish_reason": "length", "first": 975650.217264231, "full_response_s": 10.82619248807896, "last": 975660.345073781, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975650.217264231, 2], [975650.384897557, 7], [975650.532993733, 4], [975650.76284645, 63], [975651.002745484, 10], [975651.185635742, 31], [975651.375545864, 29], [975651.560580946, 22], [975651.744594327, 14], [975651.925021261, 24], [975652.110708506, 4], [975652.26003616, 13], [975652.447331618, 21], [975652.629911937, 2], [975652.81019094, 18], [975652.993587384, 29], [975653.229612851, 27], [975653.475839411, 24], [975653.623554502, 4], [975653.772650438, 16], [975654.000422109, 10], [975654.183939659, 31], [975654.337487209, 8], [975654.524409037, 11], [975654.705342415, 16], [975654.890593281, 12], [975655.077326319, 39], [975655.264879335, 18], [975655.450773339, 11], [975655.634068371, 16], [975655.819614992, 16], [975655.970162163, 11], [975656.151917095, 6], [975656.343086981, 9], [975656.528314542, 29], [975656.712669422, 22], [975656.897786349, 8], [975657.048107305, 18], [975657.232857427, 18], [975657.425137032, 34], [975657.609524539, 10], [975657.791396496, 14], [975657.97910128, 13], [975658.161551322, 2], [975658.351408243, 36], [975658.537912195, 42], [975658.720115139, 26], [975658.870604063, 17], [975659.05539952, 34], [975659.298803673, 12], [975659.486053882, 36], [975659.772435299, 50], [975659.957611229, 2], [975660.345073781, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-aa66c0649ea0f5b0042d8983f28822a8", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.488363272, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.127960731, "time_to_first_token": 0.694137017, "token_sha": "2b28aa2108de", "tokens_per_second": 25.177822739723656}, "seed": 1234, "sent": 975649.518966395, "speculative": {"acceptance_rate": 0.5546448087431693, "accepted": 203, "drafted": 366, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6982978360028937, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 366, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.189876883865118, "done": 975660.341122588, "finish_reason": "length", "first": 975650.217958756, "full_response_s": 10.822374619077891, "last": 975660.341072941, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975650.217958756, 2], [975650.385215181, 7], [975650.53227756, 4], [975650.761362569, 63], [975651.004149063, 10], [975651.187173654, 31], [975651.377960297, 29], [975651.560366824, 22], [975651.743133741, 14], [975651.926893852, 24], [975652.110277861, 4], [975652.259562588, 13], [975652.44774836, 21], [975652.629463053, 2], [975652.811194817, 18], [975652.99492055, 29], [975653.228571151, 27], [975653.475897905, 24], [975653.623496552, 4], [975653.774070224, 16], [975653.998489199, 10], [975654.181637127, 31], [975654.336841258, 8], [975654.524996606, 11], [975654.707634547, 16], [975654.89195171, 12], [975655.076969384, 39], [975655.263729382, 18], [975655.451788289, 11], [975655.633722268, 16], [975655.818251572, 16], [975655.969240219, 11], [975656.152299933, 6], [975656.34168769, 9], [975656.529141129, 29], [975656.711109511, 22], [975656.897011473, 8], [975657.047694996, 18], [975657.232787445, 18], [975657.425278516, 34], [975657.606990413, 10], [975657.792985431, 14], [975657.977069413, 13], [975658.16186341, 2], [975658.351688971, 36], [975658.534985599, 42], [975658.719853818, 26], [975658.869760485, 17], [975659.057340845, 34], [975659.298237448, 12], [975659.489302773, 36], [975659.773302077, 50], [975659.955846811, 2], [975660.341072941, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-e040ac8abaff4dfb6e96ac1e99e07d92", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.488331528, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.123940276, "time_to_first_token": 0.696880561, "token_sha": "2b28aa2108de", "tokens_per_second": 25.187821445816674}, "seed": 1234, "sent": 975649.518747969, "speculative": {"acceptance_rate": 0.5456989247311828, "accepted": 203, "drafted": 372, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6992107870755717, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 372, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.18789429306215, "done": 975660.341364406, "finish_reason": "length", "first": 975650.217317941, "full_response_s": 10.82246706506703, "last": 975660.341228937, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975650.217317941, 2], [975650.383569224, 7], [975650.532607775, 4], [975650.76171112, 63], [975651.003489593, 10], [975651.186133729, 31], [975651.376165656, 29], [975651.559674842, 22], [975651.74206353, 14], [975651.92543333, 24], [975652.11016836, 4], [975652.258690419, 13], [975652.447175383, 21], [975652.630233752, 2], [975652.810081678, 18], [975652.99560514, 29], [975653.229834413, 27], [975653.47662123, 24], [975653.621798148, 4], [975653.769986411, 16], [975653.998806871, 10], [975654.185069325, 31], [975654.336719277, 8], [975654.52485101, 11], [975654.708328689, 16], [975654.891193026, 12], [975655.076490805, 39], [975655.265133313, 18], [975655.453149741, 11], [975655.635278339, 16], [975655.819959527, 16], [975655.970359198, 11], [975656.152779441, 6], [975656.343027319, 9], [975656.527685199, 29], [975656.712034975, 22], [975656.89796692, 8], [975657.049702895, 18], [975657.231968058, 18], [975657.424641989, 34], [975657.606548009, 10], [975657.792789932, 14], [975657.97511572, 13], [975658.162993956, 2], [975658.351927125, 36], [975658.536423977, 42], [975658.721695338, 26], [975658.870009615, 17], [975659.059152494, 34], [975659.299394874, 12], [975659.487459253, 36], [975659.773480184, 50], [975659.956720357, 2], [975660.341228937, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-1c6f23e0c2f41b599fac9520c1cd8527", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.488340345, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.12414907, "time_to_first_token": 0.696244162, "token_sha": "2b28aa2108de", "tokens_per_second": 25.187301988235145}, "seed": 1234, "sent": 975649.518897341, "speculative": {"acceptance_rate": 0.5486486486486486, "accepted": 203, "drafted": 370, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6984206000342965, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 370, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.182589901179593, "done": 975660.344268714, "finish_reason": "length", "first": 975650.218190926, "full_response_s": 10.824836426996626, "last": 975660.344234395, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975650.218190926, 2], [975650.383388685, 7], [975650.533221711, 4], [975650.761418408, 63], [975651.001878947, 10], [975651.186425402, 31], [975651.378883809, 29], [975651.562436226, 22], [975651.744042966, 14], [975651.926269884, 24], [975652.109355981, 4], [975652.259760055, 13], [975652.446865855, 21], [975652.628934378, 2], [975652.810670111, 18], [975652.994753978, 29], [975653.229027347, 27], [975653.476787418, 24], [975653.622242761, 4], [975653.770271076, 16], [975653.998659243, 10], [975654.18258139, 31], [975654.337524808, 8], [975654.523185437, 11], [975654.706124107, 16], [975654.890882554, 12], [975655.076677696, 39], [975655.265384138, 18], [975655.450632511, 11], [975655.635063705, 16], [975655.818754887, 16], [975655.968043307, 11], [975656.152926941, 6], [975656.34183335, 9], [975656.529412306, 29], [975656.712562433, 22], [975656.896386561, 8], [975657.049375848, 18], [975657.231926267, 18], [975657.424404043, 34], [975657.606615575, 10], [975657.79057415, 14], [975657.977763091, 13], [975658.16238754, 2], [975658.35527859, 36], [975658.535450019, 42], [975658.720814337, 26], [975658.87010406, 17], [975659.055908883, 34], [975659.298033022, 12], [975659.48704848, 36], [975659.774216405, 50], [975659.955945993, 2], [975660.344234395, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-accd55bcff95b89f35203f472694ad17", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.488357128, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.127048659, "time_to_first_token": 0.69517171, "token_sha": "2b28aa2108de", "tokens_per_second": 25.180090329019915}, "seed": 1234, "sent": 975649.519432287, "speculative": {"acceptance_rate": 0.553133514986376, "accepted": 203, "drafted": 367, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.698758639045991, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 367, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.179902881566115, "done": 975660.34467144, "finish_reason": "length", "first": 975650.217444866, "full_response_s": 10.825207281974144, "last": 975660.344568914, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975650.217444866, 2], [975650.383030535, 7], [975650.533441817, 4], [975650.763153722, 63], [975651.001719991, 10], [975651.185486466, 31], [975651.376266741, 29], [975651.561019303, 22], [975651.742578396, 14], [975651.92495475, 24], [975652.110439265, 4], [975652.259486702, 13], [975652.447286148, 21], [975652.62863773, 2], [975652.809605419, 18], [975652.994129242, 29], [975653.229531813, 27], [975653.47564412, 24], [975653.623614965, 4], [975653.770698649, 16], [975653.999491893, 10], [975654.182327205, 31], [975654.336786795, 8], [975654.523770126, 11], [975654.708241715, 16], [975654.891372349, 12], [975655.077938479, 39], [975655.264110444, 18], [975655.451398683, 11], [975655.634666723, 16], [975655.818421999, 16], [975655.968347027, 11], [975656.15249788, 6], [975656.341991218, 9], [975656.526663578, 29], [975656.711951585, 22], [975656.896240725, 8], [975657.04790387, 18], [975657.231872412, 18], [975657.426234587, 34], [975657.606876192, 10], [975657.791652601, 14], [975657.976565698, 13], [975658.162644669, 2], [975658.352383753, 36], [975658.535649822, 42], [975658.719133516, 26], [975658.870547905, 17], [975659.055867476, 34], [975659.298559712, 12], [975659.486286596, 36], [975659.774451087, 50], [975659.956333007, 2], [975660.344568914, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-39bc8cc14654d5b3a00f3b883fb0b81f", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.488361064, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.127504391, "time_to_first_token": 0.694188984, "token_sha": "2b28aa2108de", "tokens_per_second": 25.178957239121083}, "seed": 1234, "sent": 975649.519464158, "speculative": {"acceptance_rate": 0.5546448087431693, "accepted": 203, "drafted": 366, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6979807079769671, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 366, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.19004210644251, "done": 975660.341793451, "finish_reason": "length", "first": 975650.218706113, "full_response_s": 10.822740194038488, "last": 975660.3417539, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975650.218706113, 2], [975650.383807138, 7], [975650.533934269, 4], [975650.761818941, 63], [975651.002147756, 10], [975651.186524599, 31], [975651.378646775, 29], [975651.560503844, 22], [975651.743565538, 14], [975651.926684929, 24], [975652.109511017, 4], [975652.258801584, 13], [975652.447841365, 21], [975652.628539749, 2], [975652.810775052, 18], [975652.995923803, 29], [975653.229412264, 27], [975653.476717068, 24], [975653.623148353, 4], [975653.770978065, 16], [975654.001603102, 10], [975654.181997949, 31], [975654.337313181, 8], [975654.524926864, 11], [975654.707353418, 16], [975654.891277823, 12], [975655.077266689, 39], [975655.264994468, 18], [975655.452591276, 11], [975655.635499166, 16], [975655.819308152, 16], [975655.967494649, 11], [975656.152560806, 6], [975656.342546787, 9], [975656.528250736, 29], [975656.711625498, 22], [975656.896860389, 8], [975657.047527992, 18], [975657.232271538, 18], [975657.424160385, 34], [975657.606709413, 10], [975657.790796496, 14], [975657.975743944, 13], [975658.162320294, 2], [975658.35275192, 36], [975658.535841417, 42], [975658.71837704, 26], [975658.869890546, 17], [975659.058856646, 34], [975659.298876839, 12], [975659.485112083, 36], [975659.774703704, 50], [975659.957168537, 2], [975660.3417539, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-ed161289323cceee19ab460b0f380a86", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.488339528, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.124097359, "time_to_first_token": 0.696801219, "token_sha": "2b28aa2108de", "tokens_per_second": 25.187430637785514}, "seed": 1234, "sent": 975649.519053257, "speculative": {"acceptance_rate": 0.5486486486486486, "accepted": 203, "drafted": 370, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6996528560994193, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 370, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.186769934235535, "done": 975660.342412987, "finish_reason": "length", "first": 975650.218026963, "full_response_s": 10.822727731079794, "last": 975660.342389899, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975650.218026963, 2], [975650.3846427, 7], [975650.533672899, 4], [975650.76210383, 63], [975651.002866329, 10], [975651.185548737, 31], [975651.375648342, 29], [975651.55932042, 22], [975651.744332894, 14], [975651.92536482, 24], [975652.111200317, 4], [975652.260223579, 13], [975652.447590124, 21], [975652.630034046, 2], [975652.810584993, 18], [975652.994872679, 29], [975653.229906268, 27], [975653.475429806, 24], [975653.622758299, 4], [975653.77082447, 16], [975653.999755646, 10], [975654.181802323, 31], [975654.337628997, 8], [975654.524128085, 11], [975654.706720891, 16], [975654.890806684, 12], [975655.077184995, 39], [975655.265444377, 18], [975655.450242329, 11], [975655.635318722, 16], [975655.820349837, 16], [975655.966844938, 11], [975656.151107372, 6], [975656.343630663, 9], [975656.526894852, 29], [975656.71138864, 22], [975656.896162359, 8], [975657.046828042, 18], [975657.23211063, 18], [975657.425904132, 34], [975657.608932011, 10], [975657.790369515, 14], [975657.978447953, 13], [975658.161972463, 2], [975658.353260978, 36], [975658.536508103, 42], [975658.718581675, 26], [975658.871402891, 17], [975659.055592635, 34], [975659.297837987, 12], [975659.486635179, 36], [975659.774510125, 50], [975659.956127908, 2], [975660.342389899, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-aea97f98a99b48bfd562ad5989d1b0ca", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.488342537, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.12497268, "time_to_first_token": 0.696108646, "token_sha": "2b28aa2108de", "tokens_per_second": 25.185253141838597}, "seed": 1234, "sent": 975649.519685256, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6983417070005089, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.184832085062524, "done": 975660.343538701, "finish_reason": "length", "first": 975650.21836905, "full_response_s": 10.82444494892843, "last": 975660.343511006, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975650.21836905, 2], [975650.384707386, 7], [975650.532155339, 4], [975650.762908305, 63], [975651.002618991, 10], [975651.186598741, 31], [975651.377296682, 29], [975651.559972562, 22], [975651.742238053, 14], [975651.926082769, 24], [975652.109817761, 4], [975652.258600165, 13], [975652.447714328, 21], [975652.629308737, 2], [975652.810631328, 18], [975652.996260866, 29], [975653.228510576, 27], [975653.474570116, 24], [975653.623785792, 4], [975653.771888362, 16], [975653.99992729, 10], [975654.18320395, 31], [975654.336580912, 8], [975654.52306912, 11], [975654.707023875, 16], [975654.891032246, 12], [975655.077881233, 39], [975655.265901037, 18], [975655.450317207, 11], [975655.634918429, 16], [975655.820060068, 16], [975655.969387959, 11], [975656.152393627, 6], [975656.34291193, 9], [975656.529092698, 29], [975656.712279881, 22], [975656.897294105, 8], [975657.04889466, 18], [975657.231466999, 18], [975657.424345197, 34], [975657.609812804, 10], [975657.792869338, 14], [975657.975371266, 13], [975658.163506679, 2], [975658.353939089, 36], [975658.535119707, 42], [975658.719948359, 26], [975658.870065213, 17], [975659.056102766, 34], [975659.299709314, 12], [975659.489689643, 36], [975659.773608005, 50], [975659.956028807, 2], [975660.343511006, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-64efcd219eec82d3240c7ef863236c00", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.488356585, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.12644061, "time_to_first_token": 0.695514565, "token_sha": "2b28aa2108de", "tokens_per_second": 25.181602284635332}, "seed": 1234, "sent": 975649.519093752, "speculative": {"acceptance_rate": 0.553133514986376, "accepted": 203, "drafted": 367, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6992752979276702, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 367, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 25.185999535156927, "done": 975660.343026971, "finish_reason": "length", "first": 975650.218334955, "full_response_s": 10.824478884926066, "last": 975660.343007579, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975650.218334955, 2], [975650.382889018, 7], [975650.532221386, 4], [975650.762736821, 63], [975651.002675598, 10], [975651.185837913, 31], [975651.375863872, 29], [975651.559593948, 22], [975651.744114676, 14], [975651.92597906, 24], [975652.108896681, 4], [975652.258403466, 13], [975652.446696467, 21], [975652.630341526, 2], [975652.811268079, 18], [975652.994596798, 29], [975653.228964964, 27], [975653.476226377, 24], [975653.622115868, 4], [975653.76944289, 16], [975653.999816317, 10], [975654.182657372, 31], [975654.337580374, 8], [975654.523291563, 11], [975654.707698065, 16], [975654.890517235, 12], [975655.077701301, 39], [975655.264812009, 18], [975655.450548225, 11], [975655.633959398, 16], [975655.818849124, 16], [975655.968232374, 11], [975656.151459267, 6], [975656.341255221, 9], [975656.527521171, 29], [975656.710789248, 22], [975656.896938227, 8], [975657.048675178, 18], [975657.231774879, 18], [975657.424972588, 34], [975657.607855383, 10], [975657.790729649, 14], [975657.979402248, 13], [975658.16085862, 2], [975658.354324359, 36], [975658.536990555, 42], [975658.719642351, 26], [975658.869952592, 17], [975659.056528883, 34], [975659.29794096, 12], [975659.488258689, 36], [975659.772542225, 50], [975659.957471761, 2], [975660.343007579, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-f498cd062faf890270842299785ba361", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.488345225, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.125930111, "time_to_first_token": 0.696060871, "token_sha": "2b28aa2108de", "tokens_per_second": 25.182871815695073}, "seed": 1234, "sent": 975649.518548086, "speculative": {"acceptance_rate": 0.553133514986376, "accepted": 203, "drafted": 367, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.6997868689941242, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 367, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "stock", "burst": null, "phase": "uncached_first_use", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 49.44005471772643, "done": 975665.652503166, "finish_reason": "length", "first": 975660.494698349, "full_response_s": 5.289737061946653, "last": 975665.652459631, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975660.494698349, 3], [975660.574722458, 26], [975660.656663524, 15], [975660.73755105, 34], [975660.818951891, 21], [975660.902204397, 25], [975660.983289184, 14], [975661.066045623, 14], [975661.146713477, 18], [975661.227452752, 26], [975661.313333494, 13], [975661.39722592, 13], [975661.47899656, 13], [975661.559911975, 23], [975661.64070133, 32], [975661.72162996, 7], [975661.802791929, 23], [975661.88314976, 9], [975661.964310962, 13], [975662.046374349, 15], [975662.127267143, 19], [975662.207903191, 12], [975662.293283611, 5], [975662.378922345, 23], [975662.460807993, 9], [975662.54138609, 17], [975662.622086681, 3], [975662.702685834, 21], [975662.783772126, 10], [975662.864959489, 24], [975662.949112583, 19], [975663.028881904, 14], [975663.111084121, 13], [975663.191871927, 5], [975663.274131038, 22], [975663.360548602, 13], [975663.443912981, 51], [975663.524814992, 15], [975663.605456129, 6], [975663.686109522, 8], [975663.767134298, 9], [975663.847860186, 16], [975663.929616065, 16], [975664.010310355, 9], [975664.093132862, 32], [975664.173524199, 18], [975664.254139291, 13], [975664.341564127, 11], [975664.426010831, 15], [975664.506775392, 8], [975664.587786217, 18], [975664.662120992, 25], [975664.742968078, 19], [975664.823710079, 8], [975664.907631119, 40], [975664.989054, 16], [975665.070812392, 64], [975665.151951649, 6], [975665.232888526, 6], [975665.319751042, 11], [975665.405884856, 15], [975665.486701881, 17], [975665.56779461, 21], [975665.652459631, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-bae5613c55ec9c9d6a6854ec93cff991", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.130068406, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 5.158723048, "time_to_first_token": 0.130912623, "token_sha": "8a91591c94a3", "tokens_per_second": 49.43083736562708}, "seed": 1234, "sent": 975660.362766104, "speculative": {"acceptance_rate": 0.2052910052910053, "accepted": 194, "drafted": 945, "rounds": 63, "tokens_per_round": 4.063492063492063}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.13193224498536438, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 194, "drafted": 945, "rounds": 63}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 49.44678810339943, "done": 975670.947209228, "finish_reason": "length", "first": 975665.790107166, "full_response_s": 5.286568304989487, "last": 975670.947166093, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975665.790107166, 3], [975665.871181593, 26], [975665.953202972, 15], [975666.033602041, 34], [975666.115626684, 21], [975666.195942636, 25], [975666.278500945, 14], [975666.365665439, 14], [975666.448240499, 18], [975666.528560242, 26], [975666.609537537, 13], [975666.689999468, 13], [975666.770837822, 13], [975666.851360952, 23], [975666.935712865, 32], [975667.016517733, 7], [975667.097623746, 23], [975667.179023879, 9], [975667.259385174, 13], [975667.346967435, 15], [975667.430909246, 19], [975667.511611637, 12], [975667.592449993, 5], [975667.672999492, 23], [975667.753970548, 9], [975667.834250086, 17], [975667.91623563, 3], [975667.996935127, 21], [975668.078473802, 10], [975668.159692901, 24], [975668.240516362, 19], [975668.327478449, 14], [975668.411897434, 13], [975668.493054839, 5], [975668.573626083, 22], [975668.654376234, 13], [975668.73520752, 51], [975668.81632275, 15], [975668.898669534, 6], [975668.980791475, 8], [975669.061981873, 9], [975669.142316133, 16], [975669.224016406, 16], [975669.310563049, 9], [975669.395118112, 32], [975669.477173047, 18], [975669.558175642, 13], [975669.639027232, 11], [975669.719647261, 15], [975669.800607649, 8], [975669.881812608, 18], [975669.956939724, 25], [975670.037655415, 19], [975670.119230829, 8], [975670.200528666, 40], [975670.283705078, 16], [975670.370589651, 64], [975670.454183956, 6], [975670.535017933, 6], [975670.616093807, 11], [975670.697124723, 15], [975670.778761799, 17], [975670.859067966, 21], [975670.947166093, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-2d2e0e71e7e22715bdeaf70cb57e5cf6", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.127134319, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 5.157752941, "time_to_first_token": 0.128208611, "token_sha": "8a91591c94a3", "tokens_per_second": 49.44013467045978}, "seed": 1234, "sent": 975665.660640923, "speculative": {"acceptance_rate": 0.2052910052910053, "accepted": 194, "drafted": 945, "rounds": 63, "tokens_per_round": 4.063492063492063}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1294662430882454, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 194, "drafted": 945, "rounds": 63}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 49.38695027655718, "done": 975676.260758154, "finish_reason": "length", "first": 975671.097368554, "full_response_s": 5.294021509937011, "last": 975676.260675836, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975671.097368554, 3], [975671.178497021, 26], [975671.260110211, 15], [975671.348447084, 34], [975671.432752589, 21], [975671.513347549, 25], [975671.593957774, 14], [975671.674828679, 14], [975671.755777294, 18], [975671.836406927, 26], [975671.917596402, 13], [975671.998317873, 13], [975672.079761357, 13], [975672.160647672, 23], [975672.241892618, 32], [975672.328097515, 7], [975672.413942342, 23], [975672.494885472, 9], [975672.575787786, 13], [975672.656085156, 15], [975672.736800339, 19], [975672.816943489, 12], [975672.900265247, 5], [975672.98230051, 23], [975673.063905, 9], [975673.144898674, 17], [975673.225235196, 3], [975673.31214715, 21], [975673.396265831, 10], [975673.479303308, 24], [975673.559966558, 19], [975673.640765949, 14], [975673.721551932, 13], [975673.802258125, 5], [975673.883789419, 22], [975673.965153581, 13], [975674.046424625, 51], [975674.127619511, 15], [975674.208456871, 6], [975674.292965288, 8], [975674.379275514, 9], [975674.46250798, 16], [975674.543923501, 16], [975674.62516741, 9], [975674.705774343, 32], [975674.786900047, 18], [975674.868263506, 13], [975674.951522549, 11], [975675.032467892, 15], [975675.113742346, 8], [975675.194783749, 18], [975675.269220939, 25], [975675.356722529, 19], [975675.441731735, 8], [975675.522813794, 40], [975675.604315682, 16], [975675.68526768, 64], [975675.76677856, 6], [975675.848716566, 6], [975675.932087255, 11], [975676.013185268, 15], [975676.095105035, 17], [975676.176115257, 21], [975676.260675836, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-9e4580e3d9bba9793379907040f91b44", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.128596442, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 5.164313224, "time_to_first_token": 0.129493875, "token_sha": "8a91591c94a3", "tokens_per_second": 49.37733033212317}, "seed": 1234, "sent": 975670.966736644, "speculative": {"acceptance_rate": 0.2052910052910053, "accepted": 194, "drafted": 945, "rounds": 63, "tokens_per_round": 4.063492063492063}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.13063190993852913, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 194, "drafted": 945, "rounds": 63}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 49.44914789523035, "done": 975681.575913294, "finish_reason": "length", "first": 975676.419056167, "full_response_s": 5.297236543963663, "last": 975681.575868991, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975676.419056167, 3], [975676.500125892, 26], [975676.58136542, 15], [975676.662063715, 34], [975676.742585534, 21], [975676.823977698, 25], [975676.908024197, 14], [975676.990207143, 14], [975677.071736842, 18], [975677.152359076, 26], [975677.233116394, 13], [975677.318892832, 13], [975677.403705631, 13], [975677.485691382, 23], [975677.56638523, 32], [975677.647272369, 7], [975677.727815645, 23], [975677.808747471, 9], [975677.889415242, 13], [975677.971021149, 15], [975678.052215226, 19], [975678.133076495, 12], [975678.213847479, 5], [975678.298612121, 23], [975678.384961394, 9], [975678.467019353, 17], [975678.547808576, 3], [975678.62835563, 21], [975678.709156389, 10], [975678.790138904, 24], [975678.873053978, 19], [975678.954778635, 14], [975679.035304987, 13], [975679.116723108, 5], [975679.197381856, 22], [975679.279364651, 13], [975679.366294999, 51], [975679.449770587, 15], [975679.530338666, 6], [975679.611196177, 8], [975679.691750225, 9], [975679.772734565, 16], [975679.85363062, 16], [975679.935359727, 9], [975680.016138618, 32], [975680.097726033, 18], [975680.178772821, 13], [975680.259431283, 11], [975680.346958289, 15], [975680.431423118, 8], [975680.512220265, 18], [975680.586710901, 25], [975680.667263494, 19], [975680.748191421, 8], [975680.829334463, 40], [975680.913294939, 16], [975680.994130278, 64], [975681.075972584, 6], [975681.15678034, 6], [975681.237818042, 11], [975681.324292709, 15], [975681.410324619, 17], [975681.491366914, 21], [975681.575868991, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-3e890eaefcd80803f24c3de86c04a0cb", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.139041243, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 5.157187695, "time_to_first_token": 0.139547359, "token_sha": "8a91591c94a3", "tokens_per_second": 49.445553483971075}, "seed": 1234, "sent": 975676.27867675, "speculative": {"acceptance_rate": 0.2052910052910053, "accepted": 194, "drafted": 945, "rounds": 63, "tokens_per_round": 4.063492063492063}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.14037941698916256, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 194, "drafted": 945, "rounds": 63}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.80188240376872, "done": 975695.998957843, "finish_reason": "length", "first": 975682.435728664, "full_response_s": 14.402545506018214, "last": 975695.99820047, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975682.435728664, 3], [975682.562381793, 11], [975682.74255629, 30], [975682.929278062, 19], [975683.110265278, 21], [975683.294486715, 15], [975683.44695026, 19], [975683.596595029, 17], [975683.776971684, 12], [975683.960757792, 5], [975684.107374897, 5], [975684.291231387, 27], [975684.480878562, 12], [975684.663602073, 13], [975684.844048955, 5], [975684.994378721, 16], [975685.178734098, 5], [975685.365726513, 14], [975685.549559711, 9], [975685.731064154, 27], [975685.877585282, 11], [975686.062533672, 8], [975686.210458413, 16], [975686.362322815, 5], [975686.514563287, 9], [975686.696024982, 14], [975686.843386539, 20], [975686.995262191, 8], [975687.143570798, 12], [975687.293806044, 5], [975687.451492588, 14], [975687.632949471, 14], [975687.780668061, 8], [975687.962030005, 13], [975688.137161581, 3], [975688.322157914, 10], [975688.473870517, 11], [975688.657239467, 9], [975688.841347455, 10], [975689.028146369, 20], [975689.212032878, 14], [975689.401673576, 14], [975689.635647707, 13], [975689.818434276, 5], [975690.002271222, 22], [975690.23046272, 3], [975690.47452204, 32], [975690.659566795, 33], [975690.843012775, 11], [975691.029049877, 6], [975691.177835108, 8], [975691.328422037, 9], [975691.481179983, 13], [975691.630468738, 8], [975691.778180364, 20], [975691.928955243, 17], [975692.113315879, 20], [975692.263068048, 13], [975692.445369089, 6], [975692.627272107, 13], [975692.777562407, 9], [975692.928650065, 11], [975693.078625016, 8], [975693.261335137, 15], [975693.457357609, 16], [975693.668401332, 27], [975693.904981418, 4], [975694.057800172, 8], [975694.241542895, 25], [975694.432113429, 18], [975694.582864284, 13], [975694.765974015, 55], [975694.915924476, 11], [975695.10142479, 10], [975695.285904634, 11], [975695.442279269, 15], [975695.593277832, 17], [975695.743499775, 14], [975695.99820047, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-1286cc0c8e1ac762172545a658e08277", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.625530101, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.562039481, "time_to_first_token": 0.834608591, "token_sha": "8a91591c94a3", "tokens_per_second": 18.802481762219255}, "seed": 1234, "sent": 975681.596412337, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8393163270084187, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.8055875440775, "done": 975695.99731166, "finish_reason": "length", "first": 975682.437275792, "full_response_s": 14.396247681928799, "last": 975695.997075474, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975682.437275792, 3], [975682.564032039, 11], [975682.743447707, 30], [975682.927175332, 19], [975683.110359148, 21], [975683.296291645, 15], [975683.447055185, 19], [975683.59507342, 17], [975683.777107633, 12], [975683.95947488, 5], [975684.108405687, 5], [975684.291527732, 27], [975684.480609625, 12], [975684.66261517, 13], [975684.844094042, 5], [975684.996669606, 16], [975685.177443123, 5], [975685.365150895, 14], [975685.548758996, 9], [975685.732465718, 27], [975685.878275312, 11], [975686.060622344, 8], [975686.210863491, 16], [975686.363274103, 5], [975686.515103129, 9], [975686.697405171, 14], [975686.844715129, 20], [975686.995614246, 8], [975687.144392169, 12], [975687.294482619, 5], [975687.450814285, 14], [975687.634136385, 14], [975687.781123602, 8], [975687.964591108, 13], [975688.139570144, 3], [975688.322830777, 10], [975688.475834691, 11], [975688.659965942, 9], [975688.842802554, 10], [975689.030773855, 20], [975689.214229654, 14], [975689.403885424, 14], [975689.639988349, 13], [975689.819182177, 5], [975690.00115813, 22], [975690.230758793, 3], [975690.473453011, 32], [975690.65896817, 33], [975690.845137361, 11], [975691.028461859, 6], [975691.177751446, 8], [975691.327701271, 9], [975691.482797014, 13], [975691.628848987, 8], [975691.779609912, 20], [975691.928666018, 17], [975692.114831856, 20], [975692.261400235, 13], [975692.44429774, 6], [975692.629352038, 13], [975692.779526149, 9], [975692.928690368, 11], [975693.080599494, 8], [975693.261763526, 15], [975693.458936561, 16], [975693.668894184, 27], [975693.905661673, 4], [975694.058477627, 8], [975694.24253463, 25], [975694.433030238, 18], [975694.582754687, 13], [975694.76482614, 55], [975694.915569988, 11], [975695.10117982, 10], [975695.28675826, 11], [975695.441847744, 15], [975695.59302323, 17], [975695.74180969, 14], [975695.997075474, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-ff1742927950a7f541d96590ecb2b9c3", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.625534597, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.562204885, "time_to_first_token": 0.832867931, "token_sha": "8a91591c94a3", "tokens_per_second": 18.802252448053913}, "seed": 1234, "sent": 975681.601063978, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8362118139630184, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.806680337864897, "done": 975695.999422839, "finish_reason": "length", "first": 975682.440380033, "full_response_s": 14.402382245985791, "last": 975695.9993918, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975682.440380033, 3], [975682.56366232, 11], [975682.742933305, 30], [975682.926253243, 19], [975683.111169255, 21], [975683.29570662, 15], [975683.446190727, 19], [975683.596316828, 17], [975683.776237367, 12], [975683.959282517, 5], [975684.109513338, 5], [975684.293599327, 27], [975684.479563763, 12], [975684.66311895, 13], [975684.84479932, 5], [975684.995704463, 16], [975685.17711126, 5], [975685.365874205, 14], [975685.548484795, 9], [975685.730519239, 27], [975685.877388951, 11], [975686.062475561, 8], [975686.208580253, 16], [975686.361990087, 5], [975686.515766312, 9], [975686.697481217, 14], [975686.843612901, 20], [975686.996463504, 8], [975687.144982874, 12], [975687.294263712, 5], [975687.451759141, 14], [975687.632798179, 14], [975687.781380363, 8], [975687.963136969, 13], [975688.13539297, 3], [975688.324798982, 10], [975688.475151413, 11], [975688.658040423, 9], [975688.843870655, 10], [975689.028509432, 20], [975689.21369506, 14], [975689.404812248, 14], [975689.636225917, 13], [975689.820142105, 5], [975690.001744083, 22], [975690.231202685, 3], [975690.47388332, 32], [975690.659875571, 33], [975690.842882042, 11], [975691.028955831, 6], [975691.174986284, 8], [975691.327769142, 9], [975691.482229413, 13], [975691.630739259, 8], [975691.77863784, 20], [975691.929216724, 17], [975692.11382257, 20], [975692.262824663, 13], [975692.443203095, 6], [975692.627112943, 13], [975692.778395569, 9], [975692.930323414, 11], [975693.07774483, 8], [975693.261041289, 15], [975693.456463984, 16], [975693.668767659, 27], [975693.906752877, 4], [975694.056440367, 8], [975694.240839697, 25], [975694.434485945, 18], [975694.581677658, 13], [975694.765804035, 55], [975694.917663631, 11], [975695.101109214, 10], [975695.286108165, 11], [975695.442966483, 15], [975695.593173483, 17], [975695.742098242, 14], [975695.9993918, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-45844581218030ef8e4ab4f2f2eb4a54", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.625533781, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.5620838, "time_to_first_token": 0.833460652, "token_sha": "8a91591c94a3", "tokens_per_second": 18.80242031832896}, "seed": 1234, "sent": 975681.597040593, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8433394399471581, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.802965118536825, "done": 975696.002238112, "finish_reason": "length", "first": 975682.436641328, "full_response_s": 14.403892560047098, "last": 975695.998332178, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975682.436641328, 3], [975682.563958521, 11], [975682.742717774, 30], [975682.926760654, 19], [975683.110817712, 21], [975683.296552967, 15], [975683.446283701, 19], [975683.595523216, 17], [975683.777044002, 12], [975683.958851536, 5], [975684.106513015, 5], [975684.292907297, 18], [975684.479348681, 21], [975684.663223363, 9], [975684.844843815, 9], [975684.993691282, 16], [975685.177696957, 5], [975685.364541583, 14], [975685.54820613, 9], [975685.732084512, 27], [975685.877473556, 11], [975686.061554033, 8], [975686.207960701, 16], [975686.363332933, 5], [975686.514233519, 9], [975686.695028703, 14], [975686.844096297, 20], [975686.995403899, 8], [975687.144051474, 12], [975687.292959489, 5], [975687.452839674, 14], [975687.63205999, 14], [975687.779884177, 8], [975687.963684267, 13], [975688.136459471, 3], [975688.324366929, 10], [975688.47499716, 11], [975688.657482405, 9], [975688.844759208, 10], [975689.028090867, 20], [975689.213360956, 14], [975689.402733005, 14], [975689.634229567, 13], [975689.819890815, 5], [975690.001879151, 22], [975690.23086103, 3], [975690.473531377, 32], [975690.659018377, 33], [975690.842820732, 11], [975691.02797928, 6], [975691.176454023, 8], [975691.328194203, 9], [975691.480703435, 13], [975691.627951458, 8], [975691.7783506, 20], [975691.928789087, 17], [975692.11279458, 20], [975692.26299909, 13], [975692.445098023, 6], [975692.626816774, 13], [975692.777467817, 9], [975692.928539043, 11], [975693.078183811, 8], [975693.262895738, 15], [975693.460113683, 16], [975693.667748997, 27], [975693.90548371, 4], [975694.057669056, 8], [975694.240350477, 25], [975694.433809274, 18], [975694.583407534, 13], [975694.766397908, 55], [975694.914868854, 11], [975695.101724574, 10], [975695.284545244, 11], [975695.442026059, 15], [975695.59438086, 17], [975695.742575974, 14], [975695.998332178, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-47a0fb9d58c322818cf2878ff579b31e", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.625549461, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.562261059, "time_to_first_token": 0.83183319, "token_sha": "8a91591c94a3", "tokens_per_second": 18.80217457035163}, "seed": 1234, "sent": 975681.598345552, "speculative": {"acceptance_rate": 0.42142857142857143, "accepted": 177, "drafted": 420, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8382957760477439, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 420, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.80921824980913, "done": 975695.997399162, "finish_reason": "length", "first": 975682.44018335, "full_response_s": 14.400281115085818, "last": 975695.997365611, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975682.44018335, 3], [975682.563069072, 11], [975682.744044684, 30], [975682.927713862, 19], [975683.109627886, 21], [975683.296231247, 15], [975683.445804369, 19], [975683.5939442, 17], [975683.776099867, 12], [975683.958900863, 5], [975684.10661242, 5], [975684.293378692, 27], [975684.480067191, 12], [975684.662042129, 13], [975684.843659445, 5], [975684.993849054, 16], [975685.176532778, 5], [975685.365242173, 14], [975685.548880625, 9], [975685.731475359, 27], [975685.878436188, 11], [975686.060082774, 8], [975686.208840903, 16], [975686.362393389, 5], [975686.513249144, 9], [975686.696737524, 14], [975686.843680163, 20], [975686.99388573, 8], [975687.145134806, 12], [975687.293030784, 5], [975687.453371596, 14], [975687.631807836, 14], [975687.779170467, 8], [975687.962947822, 13], [975688.135676499, 3], [975688.321802323, 10], [975688.474008946, 11], [975688.659888488, 9], [975688.845176142, 10], [975689.027677053, 20], [975689.213318093, 14], [975689.401205284, 14], [975689.635289732, 13], [975689.819578695, 5], [975690.000415573, 22], [975690.231575076, 3], [975690.472475116, 32], [975690.65777052, 33], [975690.843344495, 11], [975691.028875481, 6], [975691.174886142, 8], [975691.328124765, 9], [975691.481888893, 13], [975691.628379367, 8], [975691.777896547, 20], [975691.92787287, 17], [975692.11257065, 20], [975692.261953965, 13], [975692.444165375, 6], [975692.628622792, 13], [975692.779175374, 9], [975692.926769328, 11], [975693.077469093, 8], [975693.260553173, 15], [975693.45787054, 16], [975693.669559911, 27], [975693.907758756, 4], [975694.05552479, 8], [975694.241971589, 25], [975694.432560858, 18], [975694.583104406, 13], [975694.766636894, 55], [975694.917383767, 11], [975695.100223764, 10], [975695.284645434, 11], [975695.441654037, 15], [975695.59430603, 17], [975695.7437794, 14], [975695.997365611, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-011f2e5450e2ab4e71a685e5b32c4b91", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.625531141, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.561892797, "time_to_first_token": 0.834275976, "token_sha": "8a91591c94a3", "tokens_per_second": 18.802685127875957}, "seed": 1234, "sent": 975681.597118047, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8430653030518442, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.804621805767756, "done": 975695.998799607, "finish_reason": "length", "first": 975682.438277318, "full_response_s": 14.402254057000391, "last": 975695.998773383, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975682.438277318, 3], [975682.561042067, 11], [975682.742635712, 30], [975682.927059591, 19], [975683.109493778, 21], [975683.296176064, 15], [975683.445712708, 19], [975683.595724619, 17], [975683.776900902, 12], [975683.959379235, 5], [975684.105733387, 5], [975684.291115998, 27], [975684.481036286, 12], [975684.662324394, 13], [975684.843933934, 5], [975684.996579513, 16], [975685.177211801, 5], [975685.365661218, 14], [975685.549390292, 9], [975685.732120543, 27], [975685.878324543, 11], [975686.062150817, 8], [975686.208174984, 16], [975686.362091349, 5], [975686.512723654, 9], [975686.698043106, 14], [975686.842945766, 20], [975686.996309156, 8], [975687.143299877, 12], [975687.293194315, 5], [975687.449976531, 14], [975687.635200758, 14], [975687.779024439, 8], [975687.963640988, 13], [975688.13547556, 3], [975688.323568774, 10], [975688.474675041, 11], [975688.659548112, 9], [975688.845378696, 10], [975689.028960349, 20], [975689.214951156, 14], [975689.402023439, 14], [975689.637392847, 13], [975689.818963671, 5], [975690.000482611, 22], [975690.230802184, 3], [975690.4742232, 32], [975690.657887062, 33], [975690.843927888, 11], [975691.0287719, 6], [975691.175121961, 8], [975691.327874275, 9], [975691.482313923, 13], [975691.628784732, 8], [975691.779328367, 20], [975691.928019043, 17], [975692.113028814, 20], [975692.262392386, 13], [975692.444356138, 6], [975692.629487938, 13], [975692.778034987, 9], [975692.930219913, 11], [975693.077176028, 8], [975693.260817614, 15], [975693.45544729, 16], [975693.669609382, 27], [975693.905923955, 4], [975694.058077653, 8], [975694.240645622, 25], [975694.431874811, 18], [975694.581700665, 13], [975694.765588712, 55], [975694.916418511, 11], [975695.101299401, 10], [975695.286582953, 11], [975695.443536325, 15], [975695.593231433, 17], [975695.741509777, 14], [975695.998773383, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-11359d2ea7b3c68a89d862f00affd779", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.625528069, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.562017802, "time_to_first_token": 0.83493927, "token_sha": "8a91591c94a3", "tokens_per_second": 18.802511818145156}, "seed": 1234, "sent": 975681.59654555, "speculative": {"acceptance_rate": 0.4154929577464789, "accepted": 177, "drafted": 426, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8417317679850385, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 426, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.803526344880428, "done": 975695.999199101, "finish_reason": "length", "first": 975682.437880433, "full_response_s": 14.399090265971608, "last": 975695.999166509, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975682.437880433, 3], [975682.562768583, 11], [975682.743814242, 30], [975682.927955136, 19], [975683.110866255, 21], [975683.294950239, 15], [975683.445601974, 19], [975683.595460626, 17], [975683.776314949, 12], [975683.958534104, 5], [975684.10733277, 5], [975684.290499662, 18], [975684.478791415, 21], [975684.661649851, 13], [975684.844492608, 5], [975684.994264916, 16], [975685.177639518, 5], [975685.365073409, 14], [975685.549065868, 9], [975685.733975999, 27], [975685.877983399, 11], [975686.060683223, 8], [975686.208909621, 16], [975686.362909056, 5], [975686.51240571, 9], [975686.697032972, 14], [975686.843319884, 20], [975686.996228582, 8], [975687.143159128, 12], [975687.293602705, 5], [975687.449245301, 14], [975687.633877671, 14], [975687.779569881, 8], [975687.962753011, 13], [975688.13671924, 3], [975688.32348684, 10], [975688.472552999, 11], [975688.659081964, 9], [975688.843253374, 10], [975689.027790458, 20], [975689.212761515, 14], [975689.402630128, 14], [975689.637821284, 13], [975689.817925889, 5], [975690.000710253, 22], [975690.232747302, 3], [975690.473616975, 32], [975690.658777295, 33], [975690.842000049, 11], [975691.026387864, 6], [975691.179101396, 8], [975691.326727664, 9], [975691.482517629, 13], [975691.629406429, 8], [975691.779061878, 20], [975691.929347489, 17], [975692.113634879, 20], [975692.263137919, 13], [975692.444771152, 6], [975692.629062509, 13], [975692.77710917, 9], [975692.928132254, 11], [975693.07956448, 8], [975693.261666793, 15], [975693.459579185, 16], [975693.66848797, 27], [975693.904559573, 4], [975694.055109409, 8], [975694.242308108, 25], [975694.432456909, 18], [975694.58223902, 13], [975694.764978072, 55], [975694.915493254, 11], [975695.100392192, 10], [975695.28509827, 11], [975695.441506072, 15], [975695.592904017, 17], [975695.741101084, 14], [975695.999166509, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-cdc2902ec0a8c85cf264cc5f88f9e0c4", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.625546581, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.56196345, "time_to_first_token": 0.832147374, "token_sha": "8a91591c94a3", "tokens_per_second": 18.8025871725823}, "seed": 1234, "sent": 975681.600108835, "speculative": {"acceptance_rate": 0.41843971631205673, "accepted": 177, "drafted": 423, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8377715980168432, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 423, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.801737121497194, "done": 975695.997853087, "finish_reason": "length", "first": 975682.435240084, "full_response_s": 14.401273650000803, "last": 975695.997816688, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975682.435240084, 3], [975682.562666442, 11], [975682.742162652, 30], [975682.929662628, 19], [975683.109355477, 21], [975683.29436803, 15], [975683.447997961, 19], [975683.595948373, 17], [975683.777172783, 12], [975683.959662684, 5], [975684.107181846, 5], [975684.29228712, 27], [975684.479722687, 12], [975684.663399118, 13], [975684.844172456, 5], [975684.996110693, 16], [975685.178181072, 5], [975685.364312677, 14], [975685.549702124, 9], [975685.731611132, 27], [975685.877673855, 11], [975686.060225475, 8], [975686.210150997, 16], [975686.363719835, 5], [975686.513925719, 9], [975686.696190034, 14], [975686.844370849, 20], [975686.995064724, 8], [975687.14433577, 12], [975687.293475684, 5], [975687.448520216, 14], [975687.634378347, 14], [975687.780891015, 8], [975687.963516048, 13], [975688.136369313, 3], [975688.322258103, 10], [975688.475777861, 11], [975688.658500299, 9], [975688.842729356, 10], [975689.029991746, 20], [975689.213069428, 14], [975689.40174871, 14], [975689.640312997, 13], [975689.818332055, 5], [975690.001271615, 22], [975690.232350544, 3], [975690.472579545, 32], [975690.658625651, 33], [975690.84170564, 11], [975691.027254722, 6], [975691.178343623, 8], [975691.327923746, 9], [975691.483678992, 13], [975691.628272729, 8], [975691.780016637, 20], [975691.928582468, 17], [975692.113236457, 20], [975692.261291422, 13], [975692.445749623, 6], [975692.628661671, 13], [975692.777917694, 9], [975692.927054841, 11], [975693.078263457, 8], [975693.263299967, 15], [975693.45470558, 16], [975693.669306701, 27], [975693.907248273, 4], [975694.058159027, 8], [975694.242798944, 25], [975694.433126236, 18], [975694.581820838, 13], [975694.765096021, 55], [975694.915978922, 11], [975695.101758285, 10], [975695.285745774, 11], [975695.442678219, 15], [975695.592785876, 17], [975695.742378651, 14], [975695.997816688, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-3e0b43c5e0cfff1694dac3a802740939", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.625527477, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.562036745, "time_to_first_token": 0.835647556, "token_sha": "8a91591c94a3", "tokens_per_second": 18.80248555542459}, "seed": 1234, "sent": 975681.596579437, "speculative": {"acceptance_rate": 0.4116279069767442, "accepted": 177, "drafted": 430, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8386606469284743, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 430, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.806798066545852, "done": 975695.998161511, "finish_reason": "length", "first": 975682.439196351, "full_response_s": 14.400002146023326, "last": 975695.99812324, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975682.439196351, 3], [975682.563411143, 11], [975682.742989271, 30], [975682.927411118, 19], [975683.110325132, 21], [975683.295143819, 15], [975683.445252559, 19], [975683.596005428, 17], [975683.776367732, 12], [975683.959222439, 5], [975684.106690754, 5], [975684.292213938, 27], [975684.479480342, 12], [975684.661871893, 13], [975684.844406994, 5], [975684.994989569, 16], [975685.179493615, 5], [975685.36482188, 14], [975685.549125898, 9], [975685.731147655, 27], [975685.877150333, 11], [975686.060332896, 8], [975686.207519176, 16], [975686.363916086, 5], [975686.514378123, 9], [975686.69828478, 14], [975686.844796519, 20], [975686.994456707, 8], [975687.145341217, 12], [975687.294357102, 5], [975687.452095325, 14], [975687.634887758, 14], [975687.779736213, 8], [975687.962349693, 13], [975688.139106476, 3], [975688.322957829, 10], [975688.473341619, 11], [975688.65824309, 9], [975688.842690445, 10], [975689.029432737, 20], [975689.211870914, 14], [975689.404272854, 14], [975689.637747718, 13], [975689.818586208, 5], [975690.001806017, 22], [975690.230330612, 3], [975690.47318169, 32], [975690.658323962, 33], [975690.841218789, 11], [975691.027749574, 6], [975691.176780622, 8], [975691.327045448, 9], [975691.480835144, 13], [975691.629041862, 8], [975691.778779997, 20], [975691.929295202, 17], [975692.11462127, 20], [975692.261525736, 13], [975692.443424802, 6], [975692.627567507, 13], [975692.778560957, 9], [975692.927789159, 11], [975693.077374823, 8], [975693.263217521, 15], [975693.454100764, 16], [975693.669135202, 27], [975693.904662578, 4], [975694.057183532, 8], [975694.242048099, 25], [975694.431656641, 18], [975694.581418944, 13], [975694.766296039, 55], [975694.916713528, 11], [975695.101974232, 10], [975695.285149389, 11], [975695.441933902, 15], [975695.592573722, 17], [975695.743180487, 14], [975695.99812324, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-c4c9ec9c34e886604730cfea14013e3d", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.625530453, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.561902813, "time_to_first_token": 0.835915053, "token_sha": "8a91591c94a3", "tokens_per_second": 18.802671241351565}, "seed": 1234, "sent": 975681.598159365, "speculative": {"acceptance_rate": 0.4125874125874126, "accepted": 177, "drafted": 429, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8410369859775528, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 429, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.803844361733994, "done": 975695.998551405, "finish_reason": "length", "first": 975682.437466123, "full_response_s": 14.402081325068139, "last": 975695.998522846, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975682.437466123, 3], [975682.563149726, 11], [975682.74437474, 30], [975682.928739196, 19], [975683.111130584, 21], [975683.294197363, 15], [975683.445044229, 19], [975683.59590511, 17], [975683.776627949, 12], [975683.958614678, 5], [975684.108306617, 5], [975684.292033975, 27], [975684.480932001, 12], [975684.661279044, 13], [975684.843999613, 5], [975684.996189459, 16], [975685.178329997, 5], [975685.365295676, 14], [975685.547987528, 9], [975685.730241951, 27], [975685.878716565, 11], [975686.060434445, 8], [975686.210558267, 16], [975686.363090075, 5], [975686.516088624, 9], [975686.695247386, 14], [975686.843981659, 20], [975686.994039166, 8], [975687.143055051, 12], [975687.293740862, 5], [975687.450396696, 14], [975687.63127345, 14], [975687.782190758, 8], [975687.962171042, 13], [975688.137417271, 3], [975688.323681907, 10], [975688.472667092, 11], [975688.659253992, 9], [975688.840797293, 10], [975689.0283459, 20], [975689.211259314, 14], [975689.403119507, 14], [975689.636839677, 13], [975689.818215881, 5], [975690.000342567, 22], [975690.230663387, 3], [975690.472690198, 32], [975690.658542837, 33], [975690.842656752, 11], [975691.027091558, 6], [975691.175858054, 8], [975691.327535724, 9], [975691.482092344, 13], [975691.628920889, 8], [975691.778984728, 20], [975691.928411897, 17], [975692.112720742, 20], [975692.262086697, 13], [975692.444945627, 6], [975692.628096582, 13], [975692.777257358, 9], [975692.9283594, 11], [975693.078095781, 8], [975693.262723982, 15], [975693.453795923, 16], [975693.669078643, 27], [975693.907875729, 4], [975694.056150134, 8], [975694.241324309, 25], [975694.433530721, 18], [975694.581232437, 13], [975694.766795034, 55], [975694.914749833, 11], [975695.101679359, 10], [975695.285683791, 11], [975695.441758082, 15], [975695.592110054, 17], [975695.74266786, 14], [975695.998522846, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-597a4cb235d00e52a2f1736f9a5da7ce", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.625529237, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.561896557, "time_to_first_token": 0.83465843, "token_sha": "8a91591c94a3", "tokens_per_second": 18.80267991488117}, "seed": 1234, "sent": 975681.59647008, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8409960430581123, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.8030981295837, "done": 975696.000179556, "finish_reason": "length", "first": 975682.435414096, "full_response_s": 14.40352970501408, "last": 975695.997009012, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975682.435414096, 3], [975682.560842905, 11], [975682.742298377, 30], [975682.926865452, 19], [975683.111543277, 21], [975683.295987061, 15], [975683.446061723, 19], [975683.596979275, 17], [975683.776857735, 12], [975683.958976205, 5], [975684.109927984, 5], [975684.290587372, 27], [975684.479198877, 12], [975684.66160806, 13], [975684.844982852, 5], [975684.994831477, 16], [975685.179168967, 5], [975685.366668985, 14], [975685.549321861, 9], [975685.732877515, 27], [975685.876868052, 11], [975686.060966944, 8], [975686.210769878, 16], [975686.363663629, 5], [975686.512007256, 9], [975686.696390684, 14], [975686.84355575, 20], [975686.994606143, 8], [975687.144204862, 12], [975687.295202808, 5], [975687.450660545, 14], [975687.634606037, 14], [975687.781899966, 8], [975687.964821694, 13], [975688.1368945, 3], [975688.323881198, 10], [975688.475348208, 11], [975688.656993681, 9], [975688.840968201, 10], [975689.029231894, 20], [975689.211347839, 14], [975689.405041779, 14], [975689.637445182, 13], [975689.819644469, 5], [975690.000783483, 22], [975690.231812558, 3], [975690.474146497, 32], [975690.658904508, 33], [975690.841894452, 11], [975691.026509413, 6], [975691.175252421, 8], [975691.326818926, 9], [975691.482430432, 13], [975691.631136129, 8], [975691.779231089, 20], [975691.928870477, 17], [975692.113126428, 20], [975692.261689539, 13], [975692.443769129, 6], [975692.628021592, 13], [975692.776023726, 9], [975692.927405936, 11], [975693.080134465, 8], [975693.26295532, 15], [975693.453930352, 16], [975693.667568553, 27], [975693.905424335, 4], [975694.056585307, 8], [975694.240446843, 25], [975694.433078621, 18], [975694.580985259, 13], [975694.764711359, 55], [975694.917459221, 11], [975695.100538812, 10], [975695.286251537, 11], [975695.443070001, 15], [975695.593347286, 17], [975695.741745643, 14], [975695.997009012, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-3f9bb08e2fb9d21f133ef9986fb2e663", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.625521846, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.561912284, "time_to_first_token": 0.835615557, "token_sha": "8a91591c94a3", "tokens_per_second": 18.802658110452647}, "seed": 1234, "sent": 975681.596649851, "speculative": {"acceptance_rate": 0.41067285382830626, "accepted": 177, "drafted": 431, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8387642450397834, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 431, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.806298581111296, "done": 975695.997937212, "finish_reason": "length", "first": 975682.438613582, "full_response_s": 14.39871747395955, "last": 975695.997900589, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975682.438613582, 3], [975682.563866875, 11], [975682.743380621, 30], [975682.927122325, 19], [975683.110031716, 21], [975683.296615669, 15], [975683.446605629, 19], [975683.597085928, 17], [975683.776708891, 12], [975683.959943236, 5], [975684.107073608, 5], [975684.291403959, 27], [975684.48041587, 12], [975684.662645858, 13], [975684.844946932, 5], [975684.995251051, 16], [975685.177823242, 5], [975685.364892646, 14], [975685.548952223, 9], [975685.732032545, 27], [975685.877748045, 11], [975686.061511602, 8], [975686.208628108, 16], [975686.363593662, 5], [975686.514143153, 9], [975686.696229888, 14], [975686.843131857, 20], [975686.996099481, 8], [975687.144680658, 12], [975687.29468255, 5], [975687.448795777, 14], [975687.631925417, 14], [975687.779992078, 8], [975687.964650707, 13], [975688.137816188, 3], [975688.322370612, 10], [975688.474621026, 11], [975688.658364734, 9], [975688.844290404, 10], [975689.029904677, 20], [975689.212433924, 14], [975689.401928722, 14], [975689.638911832, 13], [975689.819368092, 5], [975690.002017388, 22], [975690.233208683, 3], [975690.4734017, 32], [975690.658129247, 33], [975690.843778244, 11], [975691.028395525, 6], [975691.177203508, 8], [975691.328666319, 9], [975691.481476312, 13], [975691.63164474, 8], [975691.78022516, 20], [975691.928230397, 17], [975692.11547448, 20], [975692.263411912, 13], [975692.443046139, 6], [975692.628378351, 13], [975692.776637118, 9], [975692.929170243, 11], [975693.077047312, 8], [975693.261995984, 15], [975693.459282952, 16], [975693.668836041, 27], [975693.904368442, 4], [975694.057912698, 8], [975694.24142445, 25], [975694.434579047, 18], [975694.581619627, 13], [975694.765493435, 55], [975694.916357633, 11], [975695.101347864, 10], [975695.28476607, 11], [975695.443827918, 15], [975695.594478042, 17], [975695.741644398, 14], [975695.997900589, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b7bb3d2ad005369064b328f9abea3289", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.625531989, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.562229892, "time_to_first_token": 0.834053917, "token_sha": "8a91591c94a3", "tokens_per_second": 18.802217779129208}, "seed": 1234, "sent": 975681.599219738, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8393938440131024, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.80324403027466, "done": 975695.996920934, "finish_reason": "length", "first": 975682.435365457, "full_response_s": 14.399307298939675, "last": 975695.996855144, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975682.435365457, 3], [975682.564110053, 11], [975682.744934421, 30], [975682.930425137, 19], [975683.109733756, 21], [975683.295612687, 15], [975683.444868377, 19], [975683.597284563, 17], [975683.776797337, 12], [975683.960030738, 5], [975684.105851864, 5], [975684.29102768, 27], [975684.47889514, 12], [975684.662419719, 13], [975684.843535704, 5], [975684.994761367, 16], [975685.177351798, 5], [975685.366412943, 14], [975685.549629966, 9], [975685.733350207, 27], [975685.877937209, 11], [975686.060514139, 8], [975686.208260469, 16], [975686.362967598, 5], [975686.513549425, 9], [975686.69858698, 14], [975686.842698684, 20], [975686.995888511, 8], [975687.145392527, 12], [975687.295106139, 5], [975687.453770322, 14], [975687.63250977, 14], [975687.780123675, 8], [975687.964018067, 13], [975688.135974027, 3], [975688.324582124, 10], [975688.473016203, 11], [975688.657747326, 9], [975688.842244232, 10], [975689.031037208, 20], [975689.211122565, 14], [975689.401532236, 14], [975689.636908299, 13], [975689.81913533, 5], [975690.000214522, 22], [975690.232019241, 3], [975690.472332704, 32], [975690.658827838, 33], [975690.842581826, 11], [975691.026452838, 6], [975691.177304481, 8], [975691.327128518, 9], [975691.483342024, 13], [975691.628984135, 8], [975691.779930656, 20], [975691.928502742, 17], [975692.114383324, 20], [975692.262316787, 13], [975692.444479847, 6], [975692.628329664, 13], [975692.779256748, 9], [975692.92844527, 11], [975693.078308768, 8], [975693.262848267, 15], [975693.456727321, 16], [975693.667389646, 27], [975693.904456008, 4], [975694.055692338, 8], [975694.24120092, 25], [975694.43281514, 18], [975694.581540093, 13], [975694.766867512, 55], [975694.915079169, 11], [975695.101875258, 10], [975695.286667062, 11], [975695.444054104, 15], [975695.593390389, 17], [975695.742928429, 14], [975695.996855144, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-afb7919c6656bce7cbfdb47f0f885b64", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.625532693, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.561955355, "time_to_first_token": 0.833892769, "token_sha": "8a91591c94a3", "tokens_per_second": 18.802598395664752}, "seed": 1234, "sent": 975681.597613635, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8377518219640478, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.803008996353206, "done": 975695.9976505, "finish_reason": "length", "first": 975682.435969969, "full_response_s": 14.401144453091547, "last": 975695.997629172, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975682.435969969, 3], [975682.561994795, 11], [975682.745183007, 30], [975682.930341747, 19], [975683.110601045, 21], [975683.295353717, 15], [975683.445438363, 19], [975683.594267136, 17], [975683.775788978, 12], [975683.958743987, 5], [975684.106815167, 5], [975684.290395249, 18], [975684.478947427, 21], [975684.661390978, 9], [975684.844345924, 9], [975684.994043353, 16], [975685.177554448, 5], [975685.366741079, 14], [975685.549253655, 9], [975685.731310019, 27], [975685.879097211, 11], [975686.062042644, 8], [975686.20778197, 16], [975686.362562377, 5], [975686.514036516, 9], [975686.697766825, 14], [975686.845067568, 20], [975686.995154609, 8], [975687.145598634, 12], [975687.295447906, 5], [975687.45241946, 14], [975687.63265735, 14], [975687.780299734, 8], [975687.964398937, 13], [975688.135168704, 3], [975688.324098056, 10], [975688.47429337, 11], [975688.660307757, 9], [975688.842360261, 10], [975689.028793553, 20], [975689.21212214, 14], [975689.402334743, 14], [975689.634632197, 13], [975689.81872958, 5], [975690.001223488, 22], [975690.231612515, 3], [975690.472977423, 32], [975690.658223389, 33], [975690.840881549, 11], [975691.028680702, 6], [975691.176148382, 8], [975691.327813237, 9], [975691.48169165, 13], [975691.631397114, 8], [975691.778278506, 20], [975691.929408752, 17], [975692.114665957, 20], [975692.262025259, 13], [975692.442818673, 6], [975692.627785662, 13], [975692.776513777, 9], [975692.930411124, 11], [975693.078976719, 8], [975693.262788348, 15], [975693.455855887, 16], [975693.669478137, 27], [975693.906215483, 4], [975694.056658729, 8], [975694.23994804, 25], [975694.432236818, 18], [975694.582477318, 13], [975694.766544672, 55], [975694.91652998, 11], [975695.100692248, 10], [975695.285585474, 11], [975695.44255163, 15], [975695.593846538, 17], [975695.740909088, 14], [975695.997629172, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-c7de149686ebfeb49748e8fefe9f3dff", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.625548389, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.561979098, "time_to_first_token": 0.832033057, "token_sha": "8a91591c94a3", "tokens_per_second": 18.802565477895858}, "seed": 1234, "sent": 975681.596506047, "speculative": {"acceptance_rate": 0.42142857142857143, "accepted": 177, "drafted": 420, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8394639220787212, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 420, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.80382133440128, "done": 975695.998475151, "finish_reason": "length", "first": 975682.437372606, "full_response_s": 14.401221795007586, "last": 975695.998445936, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975682.437372606, 3], [975682.561644884, 11], [975682.741933778, 30], [975682.926601858, 19], [975683.110105362, 21], [975683.29428648, 15], [975683.447357498, 19], [975683.594675558, 17], [975683.776578718, 12], [975683.96018435, 5], [975684.10802208, 5], [975684.29261612, 27], [975684.478676058, 12], [975684.662787358, 13], [975684.844558926, 5], [975684.994168918, 16], [975685.178268366, 5], [975685.364271846, 14], [975685.548611832, 9], [975685.733649624, 27], [975685.87867191, 11], [975686.061463091, 8], [975686.209877164, 16], [975686.362452044, 5], [975686.514824656, 9], [975686.695448388, 14], [975686.844235109, 20], [975686.995979613, 8], [975687.144483543, 12], [975687.293134685, 5], [975687.449684154, 14], [975687.631428198, 14], [975687.779405853, 8], [975687.962656534, 13], [975688.136240245, 3], [975688.322760586, 10], [975688.475601609, 11], [975688.658584089, 9], [975688.842551776, 10], [975689.029568733, 20], [975689.211937456, 14], [975689.403541065, 14], [975689.636722912, 13], [975689.819937134, 5], [975690.001340781, 22], [975690.230192679, 3], [975690.4731151, 32], [975690.659248227, 33], [975690.844596639, 11], [975691.026940106, 6], [975691.176262348, 8], [975691.327319601, 9], [975691.483061792, 13], [975691.631495736, 8], [975691.779413149, 20], [975691.928917132, 17], [975692.114887583, 20], [975692.262533134, 13], [975692.443934421, 6], [975692.629695373, 13], [975692.775889937, 9], [975692.930106268, 11], [975693.077984856, 8], [975693.262249882, 15], [975693.45401523, 16], [975693.668124747, 27], [975693.904864013, 4], [975694.055630723, 8], [975694.240875296, 25], [975694.433176714, 18], [975694.583565386, 13], [975694.766106843, 55], [975694.914956676, 11], [975695.101242586, 10], [975695.284707096, 11], [975695.442921445, 15], [975695.592417038, 17], [975695.741060349, 14], [975695.998445936, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-6079f879b933bb5deba70731dd2b75f5", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.625526133, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.561901405, "time_to_first_token": 0.835210464, "token_sha": "8a91591c94a3", "tokens_per_second": 18.802673193449603}, "seed": 1234, "sent": 975681.597253356, "speculative": {"acceptance_rate": 0.4154929577464789, "accepted": 177, "drafted": 426, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8401192500023171, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 426, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "stock", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 17.869867798571413, "done": 975695.999549204, "finish_reason": "length", "first": 975681.729697471, "full_response_s": 14.40321128105279, "last": 975695.999528836, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975681.729697471, 3], [975681.81083653, 26], [975682.56187171, 15], [975682.743486394, 19], [975682.930015739, 21], [975683.109212457, 15], [975683.295058493, 19], [975683.44476646, 17], [975683.595358404, 6], [975683.775963134, 11], [975683.960477223, 5], [975684.106327356, 18], [975684.291284442, 21], [975684.480526075, 5], [975684.662854172, 8], [975684.844902358, 5], [975684.994468975, 16], [975685.177940967, 5], [975685.366293618, 14], [975685.549488177, 9], [975685.731415377, 27], [975685.878397821, 11], [975686.062114578, 8], [975686.208514351, 16], [975686.362191042, 5], [975686.51364379, 9], [975686.695200507, 14], [975686.844605212, 20], [975686.994537905, 8], [975687.14443076, 12], [975687.293986807, 5], [975687.450978649, 14], [975687.631702927, 14], [975687.778876875, 8], [975687.964092049, 13], [975688.137059008, 3], [975688.321599064, 10], [975688.473486495, 11], [975688.660383275, 9], [975688.842626062, 10], [975689.027897192, 20], [975689.212555825, 14], [975689.402999606, 14], [975689.639684901, 13], [975689.81889228, 5], [975690.00239845, 22], [975690.230933652, 3], [975690.474281486, 32], [975690.659944529, 33], [975690.843070662, 11], [975691.027649944, 6], [975691.175790376, 8], [975691.326912491, 9], [975691.481792448, 13], [975691.628090702, 8], [975691.779156035, 20], [975691.929713896, 17], [975692.113892376, 20], [975692.261086979, 13], [975692.445659657, 6], [975692.628236322, 13], [975692.776741739, 9], [975692.929280049, 11], [975693.081075066, 8], [975693.262373559, 15], [975693.45519864, 16], [975693.66819457, 27], [975693.904151343, 4], [975694.056393088, 8], [975694.240146371, 25], [975694.434101251, 18], [975694.582302538, 13], [975694.766998677, 55], [975694.91517435, 11], [975695.100991809, 10], [975695.28581326, 11], [975695.442201527, 15], [975695.593784011, 17], [975695.743583405, 14], [975695.999528836, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-84f052a3a24ba2d27c7226df800a93f5", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.130006321, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 14.26821755, "time_to_first_token": 0.131417709, "token_sha": "8a91591c94a3", "tokens_per_second": 17.871888980274203}, "seed": 1234, "sent": 975681.596337923, "speculative": {"acceptance_rate": 0.39819004524886875, "accepted": 176, "drafted": 442, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1333595480537042, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 442, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.74231593980371, "done": 975710.486557589, "finish_reason": "length", "first": 975696.880931353, "full_response_s": 14.460527791059576, "last": 975710.486507143, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975696.880931353, 3], [975697.008351382, 11], [975697.192184434, 30], [975697.385028218, 19], [975697.563337457, 21], [975697.747973977, 15], [975697.895472748, 19], [975698.043903321, 17], [975698.226783825, 12], [975698.418707716, 5], [975698.564496116, 5], [975698.751679407, 27], [975698.938112207, 12], [975699.124349878, 13], [975699.306915113, 5], [975699.460883726, 16], [975699.645170965, 5], [975699.829168181, 14], [975700.010037574, 9], [975700.197612959, 27], [975700.350024238, 11], [975700.533960274, 8], [975700.684845415, 16], [975700.833041665, 5], [975700.983529091, 9], [975701.169938765, 14], [975701.318830439, 20], [975701.472942078, 8], [975701.622926333, 12], [975701.76764928, 5], [975701.919087181, 14], [975702.104559874, 14], [975702.253477855, 8], [975702.442152803, 13], [975702.614861833, 3], [975702.798243731, 10], [975702.949089506, 11], [975703.133802318, 9], [975703.3184163, 10], [975703.507598727, 20], [975703.691357691, 14], [975703.873092051, 14], [975704.105502212, 13], [975704.28804761, 5], [975704.4798162, 22], [975704.712641471, 3], [975704.948067111, 32], [975705.133589638, 33], [975705.31953449, 11], [975705.510372339, 6], [975705.657282939, 8], [975705.804590073, 9], [975705.954467098, 13], [975706.104662018, 8], [975706.254484836, 20], [975706.410777076, 17], [975706.595679126, 20], [975706.745234719, 13], [975706.921907105, 6], [975707.107858109, 13], [975707.259861627, 9], [975707.412228512, 11], [975707.563098171, 8], [975707.748243226, 15], [975707.935099585, 16], [975708.150759017, 27], [975708.389586731, 4], [975708.540865135, 8], [975708.726892604, 25], [975708.915886033, 18], [975709.065931622, 13], [975709.24878183, 55], [975709.405417687, 11], [975709.590334291, 10], [975709.777018484, 11], [975709.925188842, 15], [975710.075781765, 17], [975710.227110877, 14], [975710.486507143, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-7563d8319870576bdf647d12ee02d6d1", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.641840429, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.605614925, "time_to_first_token": 0.853724545, "token_sha": "8a91591c94a3", "tokens_per_second": 18.742262029733286}, "seed": 1234, "sent": 975696.026029798, "speculative": {"acceptance_rate": 0.41067285382830626, "accepted": 177, "drafted": 431, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8549015549942851, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 431, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.74245516808879, "done": 975710.486647731, "finish_reason": "length", "first": 975696.881146499, "full_response_s": 14.46121195005253, "last": 975710.48662122, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975696.881146499, 3], [975697.011956283, 11], [975697.192275855, 30], [975697.383717675, 19], [975697.565073269, 21], [975697.746999361, 15], [975697.896206842, 19], [975698.044142323, 17], [975698.227588092, 12], [975698.417674942, 5], [975698.565498235, 5], [975698.750597738, 27], [975698.939529211, 12], [975699.124890216, 13], [975699.307141651, 5], [975699.460965643, 16], [975699.645262867, 5], [975699.826415626, 14], [975700.011294311, 9], [975700.196825811, 27], [975700.350449555, 11], [975700.534139421, 8], [975700.685594372, 16], [975700.833691216, 5], [975700.985429971, 9], [975701.169143664, 14], [975701.318713802, 20], [975701.474674322, 8], [975701.622013972, 12], [975701.77011925, 5], [975701.919606048, 14], [975702.103289426, 14], [975702.251095915, 8], [975702.444127793, 13], [975702.616530815, 3], [975702.797322138, 10], [975702.951498101, 11], [975703.137592174, 9], [975703.319182873, 10], [975703.506764044, 20], [975703.690914438, 14], [975703.874088938, 14], [975704.105151165, 13], [975704.288307379, 5], [975704.479894134, 22], [975704.711426621, 3], [975704.949148652, 32], [975705.13382264, 33], [975705.320918519, 11], [975705.510669308, 6], [975705.656840198, 8], [975705.804833091, 9], [975705.954658501, 13], [975706.104239693, 8], [975706.253966033, 20], [975706.411999589, 17], [975706.595413613, 20], [975706.745502616, 13], [975706.922124716, 6], [975707.110913408, 13], [975707.257989098, 9], [975707.413287126, 11], [975707.564055219, 8], [975707.748934553, 15], [975707.933605207, 16], [975708.147436108, 27], [975708.391327616, 4], [975708.540290909, 8], [975708.7257882, 25], [975708.915015943, 18], [975709.063682398, 13], [975709.249216316, 55], [975709.406265842, 11], [975709.594409837, 10], [975709.777863583, 11], [975709.925462995, 15], [975710.074519188, 17], [975710.225521092, 14], [975710.48662122, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-5401c34263887772bb6eadb12a6d817f", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.641849517, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.605720282, "time_to_first_token": 0.853672449, "token_sha": "8a91591c94a3", "tokens_per_second": 18.742116897505095}, "seed": 1234, "sent": 975696.025435781, "speculative": {"acceptance_rate": 0.4154929577464789, "accepted": 177, "drafted": 426, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8557107179658487, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 426, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.74264846619719, "done": 975710.487260292, "finish_reason": "length", "first": 975696.881877825, "full_response_s": 14.461899645044468, "last": 975710.487212229, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975696.881877825, 3], [975697.013227019, 11], [975697.191859546, 30], [975697.382124403, 19], [975697.564446741, 21], [975697.746076777, 15], [975697.895920689, 19], [975698.044901792, 17], [975698.22752363, 12], [975698.418622646, 5], [975698.564793564, 5], [975698.751233866, 27], [975698.940248105, 12], [975699.124193578, 13], [975699.307428348, 5], [975699.461333042, 16], [975699.641939223, 5], [975699.827714569, 14], [975700.010238481, 9], [975700.194810901, 27], [975700.351388715, 11], [975700.534316281, 8], [975700.685479207, 16], [975700.833808509, 5], [975700.987502047, 9], [975701.169866926, 14], [975701.319436008, 20], [975701.473572558, 8], [975701.622155536, 12], [975701.76855049, 5], [975701.918475068, 14], [975702.102227229, 14], [975702.252734417, 8], [975702.44449164, 13], [975702.616131641, 3], [975702.799482308, 10], [975702.949226078, 11], [975703.134393263, 9], [975703.318832369, 10], [975703.510628251, 20], [975703.692973362, 14], [975703.874267317, 14], [975704.104381728, 13], [975704.289033345, 5], [975704.479284293, 22], [975704.710102319, 3], [975704.948287921, 32], [975705.132324453, 33], [975705.319070758, 11], [975705.508403493, 6], [975705.656442816, 8], [975705.804520059, 9], [975705.955304645, 13], [975706.104071809, 8], [975706.255114613, 20], [975706.410957615, 17], [975706.595479659, 20], [975706.744199465, 13], [975706.920821677, 6], [975707.110292064, 13], [975707.255593286, 9], [975707.41285456, 11], [975707.562939663, 8], [975707.748392471, 15], [975707.935842783, 16], [975708.14790144, 27], [975708.391037847, 4], [975708.543084711, 8], [975708.725106585, 25], [975708.913828564, 18], [975709.063283128, 13], [975709.247614516, 55], [975709.404021914, 11], [975709.591262284, 10], [975709.776659005, 11], [975709.924779396, 15], [975710.074921898, 17], [975710.225669857, 14], [975710.487212229, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-59ed01d2b78b560ced1ceea3bf456e44", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.641850461, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.605759689, "time_to_first_token": 0.85342908, "token_sha": "8a91591c94a3", "tokens_per_second": 18.74206261383278}, "seed": 1234, "sent": 975696.025360647, "speculative": {"acceptance_rate": 0.4154929577464789, "accepted": 177, "drafted": 426, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8565171780064702, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 426, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.73827382526456, "done": 975710.490721133, "finish_reason": "length", "first": 975696.882166826, "full_response_s": 14.465426019974984, "last": 975710.490677534, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975696.882166826, 3], [975697.008044558, 11], [975697.191068718, 30], [975697.382468874, 19], [975697.564944761, 21], [975697.746917763, 15], [975697.894983832, 19], [975698.04506582, 17], [975698.227802967, 12], [975698.417988342, 5], [975698.564661664, 5], [975698.750850244, 18], [975698.940639919, 21], [975699.12472958, 9], [975699.30782781, 9], [975699.461029386, 16], [975699.644393641, 5], [975699.826956492, 14], [975700.0107457, 9], [975700.197840089, 27], [975700.350139083, 11], [975700.536649262, 8], [975700.685361258, 16], [975700.832446879, 5], [975700.985161002, 9], [975701.169981387, 14], [975701.319608115, 20], [975701.472673509, 8], [975701.621403603, 12], [975701.767827356, 5], [975701.92126863, 14], [975702.102467207, 14], [975702.250616823, 8], [975702.442739172, 13], [975702.616276902, 3], [975702.797245436, 10], [975702.950229653, 11], [975703.133095151, 9], [975703.320818576, 10], [975703.508682332, 20], [975703.69164226, 14], [975703.87321816, 14], [975704.10445507, 13], [975704.286559119, 5], [975704.480517318, 22], [975704.711186419, 3], [975704.949255129, 32], [975705.132451842, 33], [975705.320194873, 11], [975705.508817322, 6], [975705.656659195, 8], [975705.80497032, 9], [975705.954564343, 13], [975706.105061688, 8], [975706.254879146, 20], [975706.40935484, 17], [975706.595037478, 20], [975706.745185552, 13], [975706.921517115, 6], [975707.106765288, 13], [975707.255212559, 9], [975707.412429499, 11], [975707.564698147, 8], [975707.748988872, 15], [975707.933294687, 16], [975708.147841938, 27], [975708.389186821, 4], [975708.542084784, 8], [975708.725951091, 25], [975708.913157173, 18], [975709.065391588, 13], [975709.248133815, 55], [975709.405940746, 11], [975709.590761065, 10], [975709.778165351, 11], [975709.925962727, 15], [975710.076487827, 17], [975710.225403095, 14], [975710.490677534, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-007b9d420b23b4901c4253e981bba730", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.641862589, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.609774485, "time_to_first_token": 0.852716074, "token_sha": "8a91591c94a3", "tokens_per_second": 18.73653382582114}, "seed": 1234, "sent": 975696.025295113, "speculative": {"acceptance_rate": 0.42142857142857143, "accepted": 177, "drafted": 420, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8568717130692676, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 420, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.73823419109382, "done": 975710.490965079, "finish_reason": "length", "first": 975696.882224568, "full_response_s": 14.465384548995644, "last": 975710.49076406, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975696.882224568, 3], [975697.011560725, 11], [975697.192880512, 30], [975697.384478296, 19], [975697.564253274, 21], [975697.747115918, 15], [975697.895182515, 19], [975698.045474498, 17], [975698.227442528, 12], [975698.418768674, 5], [975698.564886794, 5], [975698.749843005, 18], [975698.939106902, 21], [975699.121519885, 9], [975699.308432115, 9], [975699.462281322, 16], [975699.644636147, 5], [975699.826084594, 14], [975700.009889242, 9], [975700.196293792, 27], [975700.351144449, 11], [975700.536014078, 8], [975700.683870976, 16], [975700.835562337, 5], [975700.987176919, 9], [975701.169617013, 14], [975701.319390297, 20], [975701.472769858, 8], [975701.621118043, 12], [975701.769091804, 5], [975701.918738102, 14], [975702.102605139, 14], [975702.25031883, 8], [975702.441863562, 13], [975702.615537784, 3], [975702.797902219, 10], [975702.951216124, 11], [975703.132723609, 9], [975703.318522809, 10], [975703.507956318, 20], [975703.692560333, 14], [975703.873450138, 14], [975704.105291801, 13], [975704.286720779, 5], [975704.481135047, 22], [975704.711337568, 3], [975704.94986889, 32], [975705.132170585, 33], [975705.320550352, 11], [975705.509277359, 6], [975705.655887198, 8], [975705.803786094, 9], [975705.956075346, 13], [975706.103973876, 8], [975706.254046303, 20], [975706.409225259, 17], [975706.594729902, 20], [975706.745080578, 13], [975706.922343174, 6], [975707.106861462, 13], [975707.257145295, 9], [975707.41365686, 11], [975707.564391626, 8], [975707.747596219, 15], [975707.93317733, 16], [975708.148326741, 27], [975708.39067352, 4], [975708.541498991, 8], [975708.725869334, 25], [975708.915181107, 18], [975709.064309807, 13], [975709.248481214, 55], [975709.404082152, 11], [975709.591769791, 10], [975709.77572882, 11], [975709.926040261, 15], [975710.077128531, 17], [975710.226137653, 14], [975710.49076406, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-63dba5fb40156155afc0703cade77158", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.641863661, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.609909185, "time_to_first_token": 0.852640412, "token_sha": "8a91591c94a3", "tokens_per_second": 18.73634838658918}, "seed": 1234, "sent": 975696.02558053, "speculative": {"acceptance_rate": 0.42142857142857143, "accepted": 177, "drafted": 420, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8566440379945561, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 420, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.738761641152706, "done": 975710.489627401, "finish_reason": "length", "first": 975696.881436492, "full_response_s": 14.46311497502029, "last": 975710.489592937, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975696.881436492, 3], [975697.009917502, 11], [975697.191793484, 30], [975697.382927215, 19], [975697.56512962, 21], [975697.746541005, 15], [975697.894750974, 19], [975698.043965848, 17], [975698.227383058, 12], [975698.419404738, 5], [975698.564725982, 5], [975698.751390502, 27], [975698.939962977, 12], [975699.124775883, 13], [975699.308753467, 5], [975699.46040057, 16], [975699.645529196, 5], [975699.827442688, 14], [975700.011336101, 9], [975700.198242031, 27], [975700.350688557, 11], [975700.536259016, 8], [975700.685031218, 16], [975700.83329713, 5], [975700.986084386, 9], [975701.169335852, 14], [975701.320740519, 20], [975701.473629341, 8], [975701.621624254, 12], [975701.768371246, 5], [975701.919510946, 14], [975702.103117014, 14], [975702.251812457, 8], [975702.443769482, 13], [975702.61633522, 3], [975702.798938817, 10], [975702.949815728, 11], [975703.137216568, 9], [975703.318953118, 10], [975703.506505795, 20], [975703.690784713, 14], [975703.873559447, 14], [975704.10542647, 13], [975704.287256814, 5], [975704.481197557, 22], [975704.710410295, 3], [975704.950271952, 32], [975705.1336485, 33], [975705.319358302, 11], [975705.509021045, 6], [975705.656984611, 8], [975705.805087741, 9], [975705.956341275, 13], [975706.104286924, 8], [975706.254540771, 20], [975706.409909322, 17], [975706.594474644, 20], [975706.744809977, 13], [975706.922202154, 6], [975707.107506614, 13], [975707.256898917, 9], [975707.411936663, 11], [975707.563712363, 8], [975707.749825427, 15], [975707.934082059, 16], [975708.146861066, 27], [975708.391456876, 4], [975708.540605605, 8], [975708.726132367, 25], [975708.913024441, 18], [975709.063763036, 13], [975709.248969586, 55], [975709.404836725, 11], [975709.59085223, 10], [975709.776813417, 11], [975709.924263969, 15], [975710.076719725, 17], [975710.227593425, 14], [975710.489592937, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-40010076ce7056b967212b9a381beaa8", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.641851486, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.608811468, "time_to_first_token": 0.853010403, "token_sha": "8a91591c94a3", "tokens_per_second": 18.73785970212105}, "seed": 1234, "sent": 975696.026512426, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8549240659922361, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.7377109356688, "done": 975710.49045466, "finish_reason": "length", "first": 975696.881409997, "full_response_s": 14.464208259014413, "last": 975710.490329511, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975696.881409997, 3], [975697.011334651, 11], [975697.191646047, 30], [975697.380183444, 19], [975697.563675161, 21], [975697.746378369, 15], [975697.894844828, 19], [975698.043708718, 17], [975698.227098809, 12], [975698.418441979, 5], [975698.564580594, 5], [975698.751785068, 18], [975698.938680401, 21], [975699.12392528, 13], [975699.307988078, 5], [975699.460179295, 16], [975699.645824389, 5], [975699.828021234, 14], [975700.01099627, 9], [975700.19510371, 27], [975700.351012517, 11], [975700.535706694, 8], [975700.685246765, 16], [975700.832064825, 5], [975700.98649292, 9], [975701.169748865, 14], [975701.319796111, 20], [975701.472178273, 8], [975701.620626279, 12], [975701.768427901, 5], [975701.918186276, 14], [975702.102715248, 14], [975702.252848142, 8], [975702.443442115, 13], [975702.615674517, 3], [975702.798072471, 10], [975702.949906461, 11], [975703.13539015, 9], [975703.320047027, 10], [975703.511865196, 20], [975703.692112488, 14], [975703.874772521, 14], [975704.104531964, 13], [975704.286463602, 5], [975704.480689234, 22], [975704.710311881, 3], [975704.950497242, 32], [975705.13190624, 33], [975705.320307478, 11], [975705.510525311, 6], [975705.657917659, 8], [975705.80503059, 9], [975705.953899832, 13], [975706.104727953, 8], [975706.254837068, 20], [975706.411178122, 17], [975706.594796444, 20], [975706.745696627, 13], [975706.922952935, 6], [975707.106952691, 13], [975707.259744702, 9], [975707.411741116, 11], [975707.563379572, 8], [975707.74736048, 15], [975707.934839464, 16], [975708.147128211, 27], [975708.389705304, 4], [975708.542371753, 8], [975708.726330634, 25], [975708.912877452, 18], [975709.064226081, 13], [975709.247920188, 55], [975709.405527268, 11], [975709.593967048, 10], [975709.776247287, 11], [975709.925875481, 15], [975710.074644497, 17], [975710.227188667, 14], [975710.490329511, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-ee91c31f34012340911f75b2fcb937ee", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.641861773, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.60956625, "time_to_first_token": 0.852625645, "token_sha": "8a91591c94a3", "tokens_per_second": 18.736820506678526}, "seed": 1234, "sent": 975696.026246401, "speculative": {"acceptance_rate": 0.41843971631205673, "accepted": 177, "drafted": 423, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8551635959884152, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 423, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.741024297944552, "done": 975710.487856085, "finish_reason": "length", "first": 975696.881296496, "full_response_s": 14.462035288917832, "last": 975710.48780999, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975696.881296496, 3], [975697.011734384, 11], [975697.191985975, 30], [975697.383532832, 19], [975697.56450954, 21], [975697.747461462, 15], [975697.895119509, 19], [975698.044790563, 17], [975698.228067696, 12], [975698.417147067, 5], [975698.564199627, 5], [975698.750025257, 27], [975698.938897371, 12], [975699.123828099, 13], [975699.307579592, 5], [975699.461614843, 16], [975699.64483787, 5], [975699.829378575, 14], [975700.0109236, 9], [975700.195980664, 27], [975700.349081189, 11], [975700.536417844, 8], [975700.684332276, 16], [975700.833178909, 5], [975700.983754029, 9], [975701.169020676, 14], [975701.320287426, 20], [975701.473931333, 8], [975701.622870366, 12], [975701.767991752, 5], [975701.919463123, 14], [975702.103788421, 14], [975702.250873968, 8], [975702.442616295, 13], [975702.615434011, 3], [975702.798338496, 10], [975702.948276246, 11], [975703.13237749, 9], [975703.31912761, 10], [975703.509076194, 20], [975703.691745761, 14], [975703.875734657, 14], [975704.105842828, 13], [975704.28715384, 5], [975704.480797775, 22], [975704.710730639, 3], [975704.949031727, 32], [975705.13390275, 33], [975705.319224898, 11], [975705.510027468, 6], [975705.657718464, 8], [975705.80386174, 9], [975705.955853895, 13], [975706.105016058, 8], [975706.255553946, 20], [975706.409488964, 17], [975706.595084933, 20], [975706.74534718, 13], [975706.923294303, 6], [975707.10731793, 13], [975707.256263765, 9], [975707.411859465, 11], [975707.564436233, 8], [975707.748547955, 15], [975707.934420258, 16], [975708.149571254, 27], [975708.39181106, 4], [975708.541245093, 8], [975708.727980673, 25], [975708.913921954, 18], [975709.064807314, 13], [975709.248556732, 55], [975709.404454159, 11], [975709.590199799, 10], [975709.775376701, 11], [975709.924730198, 15], [975710.075163492, 17], [975710.223598133, 14], [975710.48780999, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-109b26ef083bac8ab72ec5823740365f", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.641846654, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.605844279, "time_to_first_token": 0.85337073, "token_sha": "8a91591c94a3", "tokens_per_second": 18.741946091032432}, "seed": 1234, "sent": 975696.025820796, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8554756999947131, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.743079884131188, "done": 975710.487050297, "finish_reason": "length", "first": 975696.88199419, "full_response_s": 14.460906005930156, "last": 975710.487015434, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975696.88199419, 3], [975697.009630598, 11], [975697.192359693, 30], [975697.380882627, 19], [975697.565922928, 21], [975697.747349048, 15], [975697.896488354, 19], [975698.044739812, 17], [975698.228020386, 12], [975698.419336868, 5], [975698.565092949, 5], [975698.751617168, 27], [975698.937768856, 12], [975699.123385086, 13], [975699.307635575, 5], [975699.461917427, 16], [975699.645711768, 5], [975699.826880334, 14], [975700.011381284, 9], [975700.195653712, 27], [975700.349713557, 11], [975700.534950617, 8], [975700.68478828, 16], [975700.832913796, 5], [975700.984950735, 9], [975701.168933478, 14], [975701.320496797, 20], [975701.473052667, 8], [975701.62090904, 12], [975701.76916177, 5], [975701.920817921, 14], [975702.10352454, 14], [975702.251225959, 8], [975702.44330543, 13], [975702.61465643, 3], [975702.79873879, 10], [975702.950062121, 11], [975703.133453126, 9], [975703.318642662, 10], [975703.508285542, 20], [975703.69123451, 14], [975703.874444625, 14], [975704.105600242, 13], [975704.286637885, 5], [975704.481561852, 22], [975704.711368063, 3], [975704.949463652, 32], [975705.133515144, 33], [975705.319172899, 11], [975705.510103002, 6], [975705.658093815, 8], [975705.80408615, 9], [975705.955718474, 13], [975706.104888461, 8], [975706.25465856, 20], [975706.410309008, 17], [975706.595758516, 20], [975706.745133233, 13], [975706.921218755, 6], [975707.107951978, 13], [975707.258609258, 9], [975707.413743978, 11], [975707.564494648, 8], [975707.748154845, 15], [975707.934314277, 16], [975708.148431731, 27], [975708.39162452, 4], [975708.541383138, 8], [975708.725986835, 25], [975708.913648697, 18], [975709.064886448, 13], [975709.248898372, 55], [975709.404886676, 11], [975709.591859357, 10], [975709.77606334, 11], [975709.926212865, 15], [975710.075530539, 17], [975710.226780645, 14], [975710.487015434, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-f6cb45158a24ac34cbfc96c4bbd148e0", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.641845757, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.605633404, "time_to_first_token": 0.85344404, "token_sha": "8a91591c94a3", "tokens_per_second": 18.742236574228954}, "seed": 1234, "sent": 975696.026144291, "speculative": {"acceptance_rate": 0.4116279069767442, "accepted": 177, "drafted": 430, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8558498990023509, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 430, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.740169317828858, "done": 975710.488136814, "finish_reason": "length", "first": 975696.880978024, "full_response_s": 14.462462558993138, "last": 975710.488112286, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975696.880978024, 3], [975697.012401824, 11], [975697.192080804, 30], [975697.380560571, 19], [975697.56543934, 21], [975697.747841596, 15], [975697.894650129, 19], [975698.045344565, 17], [975698.227899237, 12], [975698.418532776, 5], [975698.565205666, 5], [975698.749706849, 27], [975698.940801803, 12], [975699.12107156, 13], [975699.307299695, 5], [975699.460034531, 16], [975699.644898172, 5], [975699.826632629, 14], [975700.010297664, 9], [975700.195397287, 27], [975700.349476091, 11], [975700.534825596, 8], [975700.683606054, 16], [975700.834579146, 5], [975700.98404335, 9], [975701.170711401, 14], [975701.319673234, 20], [975701.471476963, 8], [975701.621226632, 12], [975701.768609688, 5], [975701.920469658, 14], [975702.102657682, 14], [975702.251175801, 8], [975702.442417548, 13], [975702.615388604, 3], [975702.796485103, 10], [975702.947557848, 11], [975703.136933391, 9], [975703.319020557, 10], [975703.508961381, 20], [975703.691418313, 14], [975703.87295519, 14], [975704.105093902, 13], [975704.28710869, 5], [975704.479625789, 22], [975704.711758117, 3], [975704.948671608, 32], [975705.132932406, 33], [975705.319291328, 11], [975705.510965412, 6], [975705.657474358, 8], [975705.803711663, 9], [975705.955059147, 13], [975706.10484019, 8], [975706.254102398, 20], [975706.409593058, 17], [975706.595299776, 20], [975706.745278446, 13], [975706.922398853, 6], [975707.107241692, 13], [975707.257343706, 9], [975707.411973798, 11], [975707.563621134, 8], [975707.750097916, 15], [975707.934036428, 16], [975708.148784778, 27], [975708.39189221, 4], [975708.5413101, 8], [975708.726737776, 25], [975708.915435948, 18], [975709.06496059, 13], [975709.249633649, 55], [975709.404530045, 11], [975709.591387993, 10], [975709.777793808, 11], [975709.925522786, 15], [975710.075320688, 17], [975710.224796871, 14], [975710.488112286, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-c06ceb50caf0ed40924e2d8915b3f993", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.641847869, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.605680443, "time_to_first_token": 0.853709136, "token_sha": "8a91591c94a3", "tokens_per_second": 18.74217177658286}, "seed": 1234, "sent": 975696.025674255, "speculative": {"acceptance_rate": 0.4125874125874126, "accepted": 177, "drafted": 429, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8553037689998746, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 429, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.73886602850278, "done": 975710.489924705, "finish_reason": "length", "first": 975696.881792947, "full_response_s": 14.46385081205517, "last": 975710.489873586, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975696.881792947, 3], [975697.010828375, 11], [975697.19215389, 30], [975697.384783488, 19], [975697.566263687, 21], [975697.747911946, 15], [975697.895699558, 19], [975698.045420579, 17], [975698.227707129, 12], [975698.418847008, 5], [975698.564322888, 5], [975698.751892585, 27], [975698.941843521, 12], [975699.123768164, 13], [975699.308180697, 5], [975699.460286685, 16], [975699.644087681, 5], [975699.828557476, 14], [975700.01107966, 9], [975700.195225179, 27], [975700.349552409, 11], [975700.535092277, 8], [975700.68553319, 16], [975700.833742687, 5], [975700.987106793, 9], [975701.170408657, 14], [975701.32067596, 20], [975701.474330107, 8], [975701.620477931, 12], [975701.768796372, 5], [975701.920194177, 14], [975702.102143327, 14], [975702.250528361, 8], [975702.441963336, 13], [975702.614404709, 3], [975702.797959466, 10], [975702.94788192, 11], [975703.13465228, 9], [975703.320584005, 10], [975703.506232986, 20], [975703.692273348, 14], [975703.873349996, 14], [975704.105464805, 13], [975704.288512158, 5], [975704.480950812, 22], [975704.71114834, 3], [975704.947934874, 32], [975705.132253751, 33], [975705.319893889, 11], [975705.509891951, 6], [975705.656124376, 8], [975705.804160532, 9], [975705.954156658, 13], [975706.104953691, 8], [975706.25434756, 20], [975706.411714812, 17], [975706.594630736, 20], [975706.745468953, 13], [975706.922083197, 6], [975707.106346355, 13], [975707.258318514, 9], [975707.412980701, 11], [975707.564641012, 8], [975707.749660487, 15], [975707.934652125, 16], [975708.148821209, 27], [975708.389475518, 4], [975708.541712601, 8], [975708.725621756, 25], [975708.915741029, 18], [975709.063133932, 13], [975709.248727672, 55], [975709.403874749, 11], [975709.59069681, 10], [975709.775540777, 11], [975709.924517035, 15], [975710.074370232, 17], [975710.227676143, 14], [975710.489873586, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-a05de6a616e02f79528bb66ee746192c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.641852733, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.608981177, "time_to_first_token": 0.852879734, "token_sha": "8a91591c94a3", "tokens_per_second": 18.73762603411969}, "seed": 1234, "sent": 975696.026073893, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8557190540013835, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.739612438620412, "done": 975710.48885702, "finish_reason": "length", "first": 975696.881205554, "full_response_s": 14.462927362998016, "last": 975710.488744175, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975696.881205554, 3], [975697.012832309, 11], [975697.192938687, 30], [975697.381347671, 19], [975697.56344291, 21], [975697.74624194, 15], [975697.894910938, 19], [975698.044034486, 17], [975698.227660651, 12], [975698.417404053, 5], [975698.565159203, 5], [975698.750660233, 27], [975698.941463259, 12], [975699.12281566, 13], [975699.307074133, 5], [975699.461085144, 16], [975699.642090867, 5], [975699.827023867, 14], [975700.010550153, 9], [975700.198154209, 27], [975700.348907258, 11], [975700.535370078, 8], [975700.684534031, 16], [975700.834056967, 5], [975700.984139187, 9], [975701.169476552, 14], [975701.320824181, 20], [975701.473335172, 8], [975701.622114433, 12], [975701.769416612, 5], [975701.920233856, 14], [975702.101821559, 14], [975702.252921709, 8], [975702.443197337, 13], [975702.614993734, 3], [975702.796929108, 10], [975702.950569277, 11], [975703.136050917, 9], [975703.319347781, 10], [975703.507120563, 20], [975703.691177248, 14], [975703.87662233, 14], [975704.104300642, 13], [975704.287697955, 5], [975704.480084929, 22], [975704.711281809, 3], [975704.948798789, 32], [975705.13164799, 33], [975705.319758308, 11], [975705.509096083, 6], [975705.657114848, 8], [975705.804020568, 9], [975705.956930828, 13], [975706.103828759, 8], [975706.255265457, 20], [975706.411643694, 17], [975706.594926649, 20], [975706.746500607, 13], [975706.922251129, 6], [975707.108740199, 13], [975707.255890606, 9], [975707.41264263, 11], [975707.56558038, 8], [975707.747908755, 15], [975707.933521977, 16], [975708.147607479, 27], [975708.390019232, 4], [975708.541782952, 8], [975708.727800037, 25], [975708.914103342, 18], [975709.06514825, 13], [975709.249872731, 55], [975709.404967474, 11], [975709.590599501, 10], [975709.776759834, 11], [975709.926736019, 15], [975710.074839756, 17], [975710.223985915, 14], [975710.488744175, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-13dfb1f44c5bf91ba83cbb06e1ecdb94", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.64184891, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.607974673, "time_to_first_token": 0.853468567, "token_sha": "8a91591c94a3", "tokens_per_second": 18.739011949070814}, "seed": 1234, "sent": 975696.025929657, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8552758969599381, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.74145059400714, "done": 975710.487357361, "finish_reason": "length", "first": 975696.88110986, "full_response_s": 14.46093030902557, "last": 975710.487313858, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975696.88110986, 3], [975697.011457015, 11], [975697.191324135, 30], [975697.383777705, 19], [975697.565586008, 21], [975697.747533636, 15], [975697.89523125, 19], [975698.04483029, 17], [975698.227844678, 12], [975698.418134082, 5], [975698.564955192, 5], [975698.750169749, 27], [975698.938381608, 12], [975699.122226075, 13], [975699.30736371, 5], [975699.462598562, 16], [975699.644741856, 5], [975699.828866764, 14], [975700.011428291, 9], [975700.197207945, 27], [975700.349267617, 11], [975700.534515092, 8], [975700.684450305, 16], [975700.835347398, 5], [975700.984422188, 9], [975701.169197455, 14], [975701.320075384, 20], [975701.471757964, 8], [975701.621336229, 12], [975701.769491058, 5], [975701.919164027, 14], [975702.104342727, 14], [975702.25081853, 8], [975702.443513713, 13], [975702.615489433, 3], [975702.797504037, 10], [975702.949442169, 11], [975703.136591784, 9], [975703.320331516, 10], [975703.510122472, 20], [975703.692034298, 14], [975703.87709235, 14], [975704.104863316, 13], [975704.287861199, 5], [975704.480410297, 22], [975704.712288616, 3], [975704.950708421, 32], [975705.134146888, 33], [975705.319611544, 11], [975705.507990671, 6], [975705.657061249, 8], [975705.804460029, 9], [975705.955628045, 13], [975706.104559333, 8], [975706.255848802, 20], [975706.411914312, 17], [975706.594978824, 20], [975706.74685751, 13], [975706.921750821, 6], [975707.106655835, 13], [975707.256723594, 9], [975707.414146336, 11], [975707.565241205, 8], [975707.748040767, 15], [975707.935697251, 16], [975708.148973397, 27], [975708.390159709, 4], [975708.542747024, 8], [975708.726635282, 25], [975708.91536259, 18], [975709.065181225, 13], [975709.24823618, 55], [975709.403665651, 11], [975709.593559459, 10], [975709.775817474, 11], [975709.92495008, 15], [975710.074753774, 17], [975710.224376561, 14], [975710.487313858, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-30d08d8e7d1f24b57e6e360021568797", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.641844974, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.605813656, "time_to_first_token": 0.853247692, "token_sha": "8a91591c94a3", "tokens_per_second": 18.741988274074888}, "seed": 1234, "sent": 975696.026427052, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8546828080434352, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.74048409337811, "done": 975710.489075958, "finish_reason": "length", "first": 975696.88208174, "full_response_s": 14.46355222701095, "last": 975710.488987449, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975696.88208174, 3], [975697.008446036, 11], [975697.192688085, 30], [975697.381217258, 19], [975697.56392229, 21], [975697.746673737, 15], [975697.895807956, 19], [975698.044536505, 17], [975698.227196102, 12], [975698.417858201, 5], [975698.565035254, 5], [975698.751325368, 27], [975698.940374294, 12], [975699.12260429, 13], [975699.306844683, 5], [975699.460593653, 16], [975699.642807633, 5], [975699.827242517, 14], [975700.011125067, 9], [975700.195928937, 27], [975700.350193481, 11], [975700.534714015, 8], [975700.686026025, 16], [975700.8327626, 5], [975700.984759364, 9], [975701.168329813, 14], [975701.318974083, 20], [975701.47474728, 8], [975701.622610837, 12], [975701.769668734, 5], [975701.92160411, 14], [975702.102966074, 14], [975702.250695957, 8], [975702.443886887, 13], [975702.614773611, 3], [975702.799201435, 10], [975702.950172263, 11], [975703.134142005, 9], [975703.319607886, 10], [975703.509621044, 20], [975703.691455273, 14], [975703.875166623, 14], [975704.104705992, 13], [975704.288800935, 5], [975704.479713819, 22], [975704.71139667, 3], [975704.950066933, 32], [975705.134727049, 33], [975705.320648734, 11], [975705.509507609, 6], [975705.657673713, 8], [975705.805272824, 9], [975705.956654403, 13], [975706.10509588, 8], [975706.254420422, 20], [975706.410021895, 17], [975706.595829218, 20], [975706.744915607, 13], [975706.921339168, 6], [975707.110180274, 13], [975707.256598989, 9], [975707.41230563, 11], [975707.565149607, 8], [975707.750489842, 15], [975707.934360676, 16], [975708.149276878, 27], [975708.38933061, 4], [975708.542677921, 8], [975708.726800798, 25], [975708.913738231, 18], [975709.063544626, 13], [975709.248409472, 55], [975709.405604274, 11], [975709.591815006, 10], [975709.776372052, 11], [975709.924641016, 15], [975710.074104639, 17], [975710.22370829, 14], [975710.488987449, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-1d02922cfdc30ccd3344c96cb39726e1", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.641849918, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.608195468, "time_to_first_token": 0.852874822, "token_sha": "8a91591c94a3", "tokens_per_second": 18.738707905808575}, "seed": 1234, "sent": 975696.025523731, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8565580089343712, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 17.796564957716946, "done": 975710.48748267, "finish_reason": "length", "first": 975696.158829721, "full_response_s": 14.461736608995125, "last": 975710.487437551, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975696.158829721, 3], [975696.239671533, 26], [975697.009809937, 15], [975697.193324245, 19], [975697.380326465, 21], [975697.563835781, 15], [975697.747238459, 19], [975697.894526788, 17], [975698.044084869, 6], [975698.22809784, 11], [975698.418898511, 5], [975698.565254177, 18], [975698.750718135, 21], [975698.938493734, 5], [975699.122989608, 8], [975699.306736702, 5], [975699.461548141, 16], [975699.645227268, 5], [975699.828390376, 14], [975700.01037923, 9], [975700.195553491, 27], [975700.349011351, 11], [975700.535642695, 8], [975700.684591725, 16], [975700.835093357, 5], [975700.983095902, 9], [975701.168070411, 14], [975701.31974568, 20], [975701.473243318, 8], [975701.622644836, 12], [975701.769230585, 5], [975701.919803723, 14], [975702.101932708, 14], [975702.251716683, 8], [975702.441724846, 13], [975702.615287135, 3], [975702.796352322, 10], [975702.948507569, 11], [975703.132149239, 9], [975703.320758321, 10], [975703.511381416, 20], [975703.691927773, 14], [975703.877615985, 14], [975704.104923795, 13], [975704.288714601, 5], [975704.479508992, 22], [975704.710496613, 3], [975704.948468957, 32], [975705.132675581, 33], [975705.3204061, 11], [975705.508936599, 6], [975705.656945908, 8], [975705.803943674, 9], [975705.954699732, 13], [975706.10477824, 8], [975706.254299769, 20], [975706.410893665, 17], [975706.595363566, 20], [975706.746411841, 13], [975706.92285657, 6], [975707.10932492, 13], [975707.258946626, 9], [975707.414236382, 11], [975707.564776721, 8], [975707.747977841, 15], [975707.934724779, 16], [975708.150128648, 27], [975708.390894747, 4], [975708.54041657, 8], [975708.724739938, 25], [975708.913364416, 18], [975709.064445739, 13], [975709.24943815, 55], [975709.403779056, 11], [975709.592646282, 10], [975709.775466587, 11], [975709.92488053, 15], [975710.075057255, 17], [975710.224095608, 14], [975710.487437551, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-7ead862eba439faf2c6a31d66db2c911", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.13074159, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 14.328121107, "time_to_first_token": 0.131343239, "token_sha": "8a91591c94a3", "tokens_per_second": 17.797169502944794}, "seed": 1234, "sent": 975696.025746061, "speculative": {"acceptance_rate": 0.39819004524886875, "accepted": 176, "drafted": 442, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.13308366003911942, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 442, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "stock", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.739791884100008, "done": 975710.488702608, "finish_reason": "length", "first": 975696.881051078, "full_response_s": 14.463480164995417, "last": 975710.488459398, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975696.881051078, 3], [975697.01205076, 11], [975697.191558594, 30], [975697.38281957, 19], [975697.564347016, 21], [975697.748308784, 15], [975697.896566816, 19], [975698.043795404, 17], [975698.227957347, 12], [975698.418219472, 5], [975698.565426092, 5], [975698.750530748, 27], [975698.942292518, 12], [975699.123176995, 13], [975699.308655245, 5], [975699.460799504, 16], [975699.64546931, 5], [975699.828334666, 14], [975700.010438316, 9], [975700.196040774, 27], [975700.350401364, 11], [975700.535150932, 8], [975700.685727457, 16], [975700.834291697, 5], [975700.985573327, 9], [975701.169691827, 14], [975701.319312139, 20], [975701.472390812, 8], [975701.622428937, 12], [975701.769879816, 5], [975701.91974814, 14], [975702.103061672, 14], [975702.250199713, 8], [975702.443973813, 13], [975702.616179704, 3], [975702.797626514, 10], [975702.949289581, 11], [975703.134999472, 9], [975703.31874698, 10], [975703.509505079, 20], [975703.690629853, 14], [975703.874689483, 14], [975704.106293168, 13], [975704.287377739, 5], [975704.481275795, 22], [975704.71084886, 3], [975704.949344423, 32], [975705.134455232, 33], [975705.319409085, 11], [975705.509384876, 6], [975705.658021769, 8], [975705.804226755, 9], [975705.954366172, 13], [975706.104173327, 8], [975706.253815333, 20], [975706.411386309, 17], [975706.594864218, 20], [975706.744441043, 13], [975706.921429549, 6], [975707.107428935, 13], [975707.257671538, 9], [975707.413430194, 11], [975707.563964533, 8], [975707.749227026, 15], [975707.933838401, 16], [975708.1480663, 27], [975708.391736453, 4], [975708.543471869, 8], [975708.728273993, 25], [975708.914666175, 18], [975709.063594913, 13], [975709.249268938, 55], [975709.403833134, 11], [975709.592957234, 10], [975709.778576621, 11], [975709.926470602, 15], [975710.075960352, 17], [975710.227744189, 14], [975710.488459398, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-5854035d14e094d026d7bbe6bac2472d", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.641848158, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.606131023, "time_to_first_token": 0.853449623, "token_sha": "8a91591c94a3", "tokens_per_second": 18.74155111169695}, "seed": 1234, "sent": 975696.025222443, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8558286349289119, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.669789239810427, "done": 975725.003997902, "finish_reason": "length", "first": 975711.345542169, "full_response_s": 14.478247949038632, "last": 975725.003971663, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975711.345542169, 3], [975711.47623612, 11], [975711.6590664, 30], [975711.843066187, 19], [975712.026810688, 21], [975712.209277861, 15], [975712.362222378, 19], [975712.513850209, 17], [975712.694965815, 12], [975712.879062533, 5], [975713.02934376, 5], [975713.214075887, 27], [975713.403282816, 12], [975713.587366703, 13], [975713.77020987, 5], [975713.918464974, 16], [975714.103367949, 5], [975714.284805491, 14], [975714.475743083, 9], [975714.659011395, 27], [975714.808804573, 11], [975714.994664232, 8], [975715.143538156, 16], [975715.29007073, 5], [975715.448886951, 9], [975715.633470913, 14], [975715.781306959, 20], [975715.930743592, 8], [975716.080829216, 12], [975716.229359632, 5], [975716.384341007, 14], [975716.568847887, 14], [975716.716634833, 8], [975716.902256823, 13], [975717.079396066, 3], [975717.260773059, 10], [975717.413995633, 11], [975717.599973856, 9], [975717.783114454, 10], [975717.968071169, 20], [975718.153121755, 14], [975718.339397174, 14], [975718.576226329, 13], [975718.760101504, 5], [975718.946341695, 22], [975719.178438652, 3], [975719.424327555, 32], [975719.609281267, 33], [975719.793937034, 11], [975719.979036201, 6], [975720.127537893, 8], [975720.275637099, 9], [975720.434106767, 13], [975720.584494876, 8], [975720.732915418, 20], [975720.880969826, 17], [975721.06749741, 20], [975721.217315376, 13], [975721.399509515, 6], [975721.586562686, 13], [975721.733549986, 9], [975721.920505001, 11], [975722.068240061, 8], [975722.255094233, 15], [975722.450149689, 16], [975722.661983273, 27], [975722.904180524, 4], [975723.053897618, 8], [975723.239379235, 25], [975723.432403161, 18], [975723.582560324, 13], [975723.765269609, 55], [975723.917029967, 11], [975724.101569723, 10], [975724.288831603, 11], [975724.44712956, 15], [975724.59640502, 17], [975724.746110709, 14], [975725.003971663, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-9fa2b2f114dba7c2a520cd5197052a91", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.607900586, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.65986461, "time_to_first_token": 0.812304323, "token_sha": "8a91591c94a3", "tokens_per_second": 18.66782777724764}, "seed": 1234, "sent": 975710.525749953, "speculative": {"acceptance_rate": 0.4135514018691589, "accepted": 177, "drafted": 428, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8197922159451991, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 428, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.667735089458855, "done": 975725.005145746, "finish_reason": "length", "first": 975711.345177042, "full_response_s": 14.477038060082123, "last": 975725.005109475, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975711.345177042, 3], [975711.475900304, 11], [975711.660185556, 30], [975711.843540719, 19], [975712.025083227, 21], [975712.212520484, 15], [975712.362512899, 19], [975712.512320391, 17], [975712.695956079, 12], [975712.880243719, 5], [975713.030356311, 5], [975713.214323065, 27], [975713.404207048, 12], [975713.588113549, 13], [975713.772728879, 5], [975713.918665401, 16], [975714.104143418, 5], [975714.285165146, 14], [975714.47745488, 9], [975714.661662897, 27], [975714.808117006, 11], [975714.993962378, 8], [975715.142587444, 16], [975715.290141049, 5], [975715.44981536, 9], [975715.634951805, 14], [975715.783259183, 20], [975715.932209123, 8], [975716.080940782, 12], [975716.229674472, 5], [975716.382877219, 14], [975716.569514446, 14], [975716.71931451, 8], [975716.902207736, 13], [975717.078829552, 3], [975717.2604231, 10], [975717.41461525, 11], [975717.599417262, 9], [975717.783799461, 10], [975717.969277315, 20], [975718.15170427, 14], [975718.340962735, 14], [975718.576491763, 13], [975718.758864623, 5], [975718.947422436, 22], [975719.178507627, 3], [975719.425697521, 32], [975719.609204597, 33], [975719.794815892, 11], [975719.980713776, 6], [975720.128298098, 8], [975720.275504638, 9], [975720.433790887, 13], [975720.584843683, 8], [975720.73412126, 20], [975720.882015464, 17], [975721.06788812, 20], [975721.217627576, 13], [975721.400257256, 6], [975721.58622375, 13], [975721.73458372, 9], [975721.918884689, 11], [975722.069908468, 8], [975722.256359113, 15], [975722.450051435, 16], [975722.662179909, 27], [975722.905260241, 4], [975723.052535539, 8], [975723.239241062, 25], [975723.433029081, 18], [975723.581656762, 13], [975723.768847969, 55], [975723.916933377, 11], [975724.102617697, 10], [975724.290140803, 11], [975724.448132223, 15], [975724.596313358, 17], [975724.745935482, 14], [975725.005109475, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-49c3e2320d6334846e30eddb6569e66b", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.607898554, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.659817635, "time_to_first_token": 0.813677377, "token_sha": "8a91591c94a3", "tokens_per_second": 18.667891974386524}, "seed": 1234, "sent": 975710.528107686, "speculative": {"acceptance_rate": 0.4116279069767442, "accepted": 177, "drafted": 430, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8170693559804931, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 430, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.66754829835742, "done": 975725.004191738, "finish_reason": "length", "first": 975711.344076062, "full_response_s": 14.476955389953218, "last": 975725.004145179, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975711.344076062, 3], [975711.477108962, 11], [975711.658148167, 30], [975711.842586759, 19], [975712.024595703, 21], [975712.211664393, 15], [975712.360667345, 19], [975712.513049925, 17], [975712.696045292, 12], [975712.878554609, 5], [975713.029944593, 5], [975713.213301427, 27], [975713.404522593, 12], [975713.589566313, 13], [975713.771785671, 5], [975713.918080568, 16], [975714.103214673, 5], [975714.286578582, 14], [975714.476513592, 9], [975714.662541531, 27], [975714.809525915, 11], [975714.99441611, 8], [975715.144164925, 16], [975715.290862295, 5], [975715.449916253, 9], [975715.634860191, 14], [975715.782047053, 20], [975715.932640968, 8], [975716.081344068, 12], [975716.229581866, 5], [975716.3834705, 14], [975716.571863012, 14], [975716.717304768, 8], [975716.902153737, 13], [975717.077257239, 3], [975717.259660319, 10], [975717.414082319, 11], [975717.598746847, 9], [975717.78293649, 10], [975717.967989907, 20], [975718.152680726, 14], [975718.340106581, 14], [975718.575132533, 13], [975718.759233814, 5], [975718.945947673, 22], [975719.179366933, 3], [975719.42508504, 32], [975719.610050416, 33], [975719.794310529, 11], [975719.981586106, 6], [975720.128550764, 8], [975720.274755937, 9], [975720.434585107, 13], [975720.582685177, 8], [975720.731826005, 20], [975720.88194817, 17], [975721.068079075, 20], [975721.217685398, 13], [975721.398295049, 6], [975721.58495463, 13], [975721.733477715, 9], [975721.918827011, 11], [975722.068433481, 8], [975722.255494287, 15], [975722.449714724, 16], [975722.663290137, 27], [975722.902349945, 4], [975723.055289727, 8], [975723.238843344, 25], [975723.432586532, 18], [975723.582185805, 13], [975723.764669464, 55], [975723.914467086, 11], [975724.102075534, 10], [975724.289327527, 11], [975724.447691098, 15], [975724.596035765, 17], [975724.746028375, 14], [975725.004145179, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-9dcce8fbd8abcb33f1c0692ed972dc03", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.607899978, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.659755381, "time_to_first_token": 0.813538101, "token_sha": "8a91591c94a3", "tokens_per_second": 18.66797705284617}, "seed": 1234, "sent": 975710.527236348, "speculative": {"acceptance_rate": 0.4116279069767442, "accepted": 177, "drafted": 430, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8168397139525041, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 430, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.667749826964407, "done": 975725.005245792, "finish_reason": "length", "first": 975711.345285232, "full_response_s": 14.478957579936832, "last": 975725.005206881, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975711.345285232, 3], [975711.47697055, 11], [975711.65963109, 30], [975711.84237974, 19], [975712.025930342, 21], [975712.21016883, 15], [975712.362655168, 19], [975712.512078749, 17], [975712.695162642, 12], [975712.878725181, 5], [975713.030262073, 5], [975713.214929178, 27], [975713.40399427, 12], [975713.588647887, 13], [975713.770591941, 5], [975713.917801535, 16], [975714.103888016, 5], [975714.284307439, 14], [975714.477696634, 9], [975714.660800662, 27], [975714.809034103, 11], [975714.995998167, 8], [975715.143917203, 16], [975715.289420043, 5], [975715.450695002, 9], [975715.633298198, 14], [975715.782621247, 20], [975715.935434451, 8], [975716.081688491, 12], [975716.228902379, 5], [975716.382948817, 14], [975716.570816734, 14], [975716.715739799, 8], [975716.903056227, 13], [975717.0796447, 3], [975717.26059084, 10], [975717.413785686, 11], [975717.59827865, 9], [975717.783706887, 10], [975717.969069433, 20], [975718.15294024, 14], [975718.340034566, 14], [975718.574719215, 13], [975718.758636773, 5], [975718.946447069, 22], [975719.178284432, 3], [975719.425299611, 32], [975719.609599147, 33], [975719.793419415, 11], [975719.978933036, 6], [975720.129791037, 8], [975720.274488679, 9], [975720.434217244, 13], [975720.586643783, 8], [975720.732435205, 20], [975720.882645544, 17], [975721.068222608, 20], [975721.218315287, 13], [975721.400044301, 6], [975721.584694604, 13], [975721.733861754, 9], [975721.917833579, 11], [975722.068695186, 8], [975722.256471415, 15], [975722.449785762, 16], [975722.6615645, 27], [975722.903861203, 4], [975723.052457605, 8], [975723.238589126, 25], [975723.432648131, 18], [975723.580875246, 13], [975723.765816812, 55], [975723.915983017, 11], [975724.102928137, 10], [975724.28886749, 11], [975724.44779036, 15], [975724.594996783, 17], [975724.746645896, 14], [975725.005206881, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-0b4bc22c2d6206f127a7f41cc1198971", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.607892651, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.659676902, "time_to_first_token": 0.816394653, "token_sha": "8a91591c94a3", "tokens_per_second": 18.668084306054403}, "seed": 1234, "sent": 975710.526288212, "speculative": {"acceptance_rate": 0.4068965517241379, "accepted": 177, "drafted": 435, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8189970199018717, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 435, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.66616117305506, "done": 975725.005870224, "finish_reason": "length", "first": 975711.344765437, "full_response_s": 14.477695339010097, "last": 975725.005849665, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975711.344765437, 3], [975711.47702506, 11], [975711.65697202, 30], [975711.841814891, 19], [975712.025419955, 21], [975712.212030528, 15], [975712.362446373, 19], [975712.51350001, 17], [975712.695753588, 12], [975712.880145802, 5], [975713.031155555, 5], [975713.215064999, 27], [975713.403873249, 12], [975713.588755805, 13], [975713.772838669, 5], [975713.918826677, 16], [975714.101236802, 5], [975714.285291798, 14], [975714.476794801, 9], [975714.659969659, 27], [975714.808411703, 11], [975714.994545467, 8], [975715.143026473, 16], [975715.290189447, 5], [975715.449685379, 9], [975715.634389099, 14], [975715.782494018, 20], [975715.93304907, 8], [975716.082925452, 12], [975716.228624098, 5], [975716.384411837, 14], [975716.570396456, 14], [975716.716979512, 8], [975716.901657862, 13], [975717.077710396, 3], [975717.260824018, 10], [975717.415039623, 11], [975717.600425685, 9], [975717.784926185, 10], [975717.9694112, 20], [975718.153768155, 14], [975718.340710662, 14], [975718.577367037, 13], [975718.759930373, 5], [975718.946097605, 22], [975719.179951287, 3], [975719.42487391, 32], [975719.610253563, 33], [975719.795320424, 11], [975719.980026977, 6], [975720.128621706, 8], [975720.276503237, 9], [975720.434898923, 13], [975720.5846406, 8], [975720.733496363, 20], [975720.882189028, 17], [975721.068334989, 20], [975721.218821162, 13], [975721.39914714, 6], [975721.585995292, 13], [975721.733978343, 9], [975721.919297111, 11], [975722.068859758, 8], [975722.256061153, 15], [975722.449161649, 16], [975722.6620502, 27], [975722.904292841, 4], [975723.054971543, 8], [975723.238268286, 25], [975723.432491927, 18], [975723.581191702, 13], [975723.768547912, 55], [975723.916200308, 11], [975724.101692904, 10], [975724.288153572, 11], [975724.446358779, 15], [975724.596353197, 17], [975724.745566227, 14], [975725.005849665, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-146ecb923a3e2ef9bbeeb00e423b132c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.607906202, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.659953183, "time_to_first_token": 0.810989956, "token_sha": "8a91591c94a3", "tokens_per_second": 18.667706732505568}, "seed": 1234, "sent": 975710.528174885, "speculative": {"acceptance_rate": 0.4135514018691589, "accepted": 177, "drafted": 428, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8165905519854277, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 428, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.667093304593546, "done": 975725.005050868, "finish_reason": "length", "first": 975711.343984624, "full_response_s": 14.47775002499111, "last": 975725.004386693, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975711.343984624, 3], [975711.478922757, 11], [975711.659322666, 30], [975711.843334389, 19], [975712.024357117, 21], [975712.208603638, 15], [975712.361339376, 19], [975712.515711842, 17], [975712.696401204, 12], [975712.87867299, 5], [975713.029627865, 5], [975713.214209196, 27], [975713.402712894, 12], [975713.589134099, 13], [975713.771592348, 5], [975713.917250348, 16], [975714.102882569, 5], [975714.286361084, 14], [975714.476253854, 9], [975714.660489198, 27], [975714.808763566, 11], [975714.993459174, 8], [975715.142347034, 16], [975715.289549175, 5], [975715.44828735, 9], [975715.632990237, 14], [975715.782580576, 20], [975715.930601627, 8], [975716.079816906, 12], [975716.228527109, 5], [975716.382769238, 14], [975716.571946978, 14], [975716.72028087, 8], [975716.90238346, 13], [975717.078541895, 3], [975717.260930927, 10], [975717.415744182, 11], [975717.599644936, 9], [975717.782629506, 10], [975717.969705961, 20], [975718.151989767, 14], [975718.339521939, 14], [975718.575346911, 13], [975718.759813512, 5], [975718.947262936, 22], [975719.179892664, 3], [975719.425803343, 32], [975719.610122446, 33], [975719.795412805, 11], [975719.979602891, 6], [975720.129883067, 8], [975720.274795968, 9], [975720.434523221, 13], [975720.583179805, 8], [975720.732646096, 20], [975720.881155101, 17], [975721.068152961, 20], [975721.21745398, 13], [975721.399688022, 6], [975721.585051747, 13], [975721.734375293, 9], [975721.917980584, 11], [975722.068545222, 8], [975722.254902253, 15], [975722.449951262, 16], [975722.661769455, 27], [975722.90360569, 4], [975723.055100644, 8], [975723.239451713, 25], [975723.431551198, 18], [975723.582618995, 13], [975723.768130227, 55], [975723.916448365, 11], [975724.102142013, 10], [975724.289930632, 11], [975724.445999236, 15], [975724.597188472, 17], [975724.747052462, 14], [975725.004386693, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-fdf436aaea4482166e1b59d9ebbc1ce6", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.607894442, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.659732981, "time_to_first_token": 0.812774472, "token_sha": "8a91591c94a3", "tokens_per_second": 18.668007665647064}, "seed": 1234, "sent": 975710.527300843, "speculative": {"acceptance_rate": 0.4135514018691589, "accepted": 177, "drafted": 428, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8166837809840217, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 428, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.66789000513816, "done": 975725.005716068, "finish_reason": "length", "first": 975711.345871121, "full_response_s": 14.479779638932087, "last": 975725.005690197, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975711.345871121, 3], [975711.477728083, 11], [975711.657639124, 30], [975711.841405381, 19], [975712.026226799, 21], [975712.20940477, 15], [975712.36150142, 19], [975712.513592135, 17], [975712.694873242, 12], [975712.880068172, 5], [975713.029749814, 5], [975713.213681401, 27], [975713.402600609, 12], [975713.587794789, 13], [975713.769928773, 5], [975713.917442808, 16], [975714.102382726, 5], [975714.28378926, 14], [975714.476846592, 9], [975714.660174582, 27], [975714.808164669, 11], [975714.994616649, 8], [975715.143497117, 16], [975715.290309332, 5], [975715.449222814, 9], [975715.633920742, 14], [975715.7838612, 20], [975715.93312238, 8], [975716.080342508, 12], [975716.230161564, 5], [975716.383519267, 14], [975716.571252515, 14], [975716.717513787, 8], [975716.902039788, 13], [975717.076686789, 3], [975717.261341301, 10], [975717.415483484, 11], [975717.598035648, 9], [975717.782431095, 10], [975717.97012987, 20], [975718.152321967, 14], [975718.340352367, 14], [975718.577458747, 13], [975718.760328491, 5], [975718.946612296, 22], [975719.17918169, 3], [975719.425388649, 32], [975719.610420855, 33], [975719.795104557, 11], [975719.979188022, 6], [975720.127256156, 8], [975720.27534941, 9], [975720.433608395, 13], [975720.585489411, 8], [975720.732518643, 20], [975720.881329993, 17], [975721.068520104, 20], [975721.218082444, 13], [975721.399963216, 6], [975721.585401994, 13], [975721.733091149, 9], [975721.919923655, 11], [975722.069235253, 8], [975722.254050595, 15], [975722.448846841, 16], [975722.662230323, 27], [975722.902193869, 4], [975723.052115966, 8], [975723.237838985, 25], [975723.432073393, 18], [975723.581766632, 13], [975723.767509122, 55], [975723.914645002, 11], [975724.10191589, 10], [975724.288921489, 11], [975724.44617416, 15], [975724.595247384, 17], [975724.745674352, 14], [975725.005690197, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-1e4cd92f8b8869708f3179109c137e6e", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.607896458, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.65971975, "time_to_first_token": 0.816815474, "token_sha": "8a91591c94a3", "tokens_per_second": 18.6680257477464}, "seed": 1234, "sent": 975710.525936429, "speculative": {"acceptance_rate": 0.4078341013824885, "accepted": 177, "drafted": 434, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8199346920009702, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 434, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.668417111896538, "done": 975725.004276488, "finish_reason": "length", "first": 975711.344806636, "full_response_s": 14.476705683977343, "last": 975725.004240024, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975711.344806636, 3], [975711.475569321, 11], [975711.658055881, 30], [975711.842432971, 19], [975712.025263191, 21], [975712.208507112, 15], [975712.36079131, 19], [975712.51197, 17], [975712.695369565, 12], [975712.878601328, 5], [975713.030851514, 5], [975713.215142629, 27], [975713.403664838, 12], [975713.588321192, 13], [975713.771704553, 5], [975713.91824322, 16], [975714.103539401, 5], [975714.285433939, 14], [975714.476956621, 9], [975714.66175907, 27], [975714.807868756, 11], [975714.993861196, 8], [975715.142449527, 16], [975715.290919285, 5], [975715.448351972, 9], [975715.633634957, 14], [975715.781703605, 20], [975715.932475789, 8], [975716.082461624, 12], [975716.229634937, 5], [975716.383885386, 14], [975716.570683793, 14], [975716.719540057, 8], [975716.903101298, 13], [975717.077805145, 3], [975717.261491921, 10], [975717.41469976, 11], [975717.600363142, 9], [975717.78215595, 10], [975717.967338084, 20], [975718.152615304, 14], [975718.34045174, 14], [975718.574869563, 13], [975718.758750802, 5], [975718.946772613, 22], [975719.17983449, 3], [975719.425153551, 32], [975719.610792829, 33], [975719.794015864, 11], [975719.981278994, 6], [975720.128983185, 8], [975720.27467821, 9], [975720.43311188, 13], [975720.586055813, 8], [975720.73355873, 20], [975720.880856389, 17], [975721.068561735, 20], [975721.218542737, 13], [975721.399035431, 6], [975721.584852552, 13], [975721.735389652, 9], [975721.920757219, 11], [975722.068911469, 8], [975722.255979155, 15], [975722.449505625, 16], [975722.662127158, 27], [975722.902089679, 4], [975723.052214539, 8], [975723.23802474, 25], [975723.431892197, 18], [975723.581365522, 13], [975723.768451835, 55], [975723.915309834, 11], [975724.103102949, 10], [975724.289202586, 11], [975724.448267596, 15], [975724.596217793, 17], [975724.745752478, 14], [975725.004240024, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-9d5837537eaf1cd675ee388c775faf56", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.607898026, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.659722549, "time_to_first_token": 0.812065418, "token_sha": "8a91591c94a3", "tokens_per_second": 18.66802192250003}, "seed": 1234, "sent": 975710.527570804, "speculative": {"acceptance_rate": 0.4135514018691589, "accepted": 177, "drafted": 428, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8172358319861814, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 428, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.667069734908452, "done": 975725.005309742, "finish_reason": "length", "first": 975711.344867738, "full_response_s": 14.477486880961806, "last": 975725.005287055, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975711.344867738, 3], [975711.478267093, 11], [975711.66001324, 30], [975711.841229833, 19], [975712.025783322, 21], [975712.209866838, 15], [975712.361880931, 19], [975712.512222746, 17], [975712.695070725, 12], [975712.878499747, 5], [975713.029214259, 5], [975713.213038249, 27], [975713.403613703, 12], [975713.588422453, 13], [975713.770418425, 5], [975713.917658082, 16], [975714.101929233, 5], [975714.283978263, 14], [975714.475466578, 9], [975714.659846702, 27], [975714.80862989, 11], [975714.995826779, 8], [975715.14290198, 16], [975715.291250029, 5], [975715.448443682, 9], [975715.634152896, 14], [975715.782366469, 20], [975715.931478517, 8], [975716.082054658, 12], [975716.229059367, 5], [975716.383835163, 14], [975716.570773855, 14], [975716.718751724, 8], [975716.901504538, 13], [975717.079121033, 3], [975717.260540857, 10], [975717.414759902, 11], [975717.598905131, 9], [975717.7828495, 10], [975717.96637014, 20], [975718.153559152, 14], [975718.33980534, 14], [975718.575670087, 13], [975718.760784879, 5], [975718.946936768, 22], [975719.178785476, 3], [975719.426416639, 32], [975719.610084191, 33], [975719.793718367, 11], [975719.979389153, 6], [975720.128171941, 8], [975720.276028641, 9], [975720.434845805, 13], [975720.584073526, 8], [975720.73256997, 20], [975720.882595721, 17], [975721.067842777, 20], [975721.21890108, 13], [975721.399920993, 6], [975721.585777009, 13], [975721.734797507, 9], [975721.919519089, 11], [975722.069352338, 8], [975722.254587141, 15], [975722.448567824, 16], [975722.663566162, 27], [975722.903136309, 4], [975723.05467803, 8], [975723.238786577, 25], [975723.432881517, 18], [975723.58249711, 13], [975723.76636259, 55], [975723.917269369, 11], [975724.103501099, 10], [975724.290070005, 11], [975724.446265629, 15], [975724.595380005, 17], [975724.745430646, 14], [975725.005287055, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-2b332c42289a21bf21a0205dffe90fdf", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.60789729, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.659819603, "time_to_first_token": 0.813364441, "token_sha": "8a91591c94a3", "tokens_per_second": 18.667889284862614}, "seed": 1234, "sent": 975710.527822861, "speculative": {"acceptance_rate": 0.40877598152424943, "accepted": 177, "drafted": 433, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8170448769815266, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 433, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.66904431266241, "done": 975725.00433647, "finish_reason": "length", "first": 975711.345341774, "full_response_s": 14.474359006038867, "last": 975725.004316263, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975711.345341774, 3], [975711.477378907, 11], [975711.657189103, 30], [975711.843164041, 19], [975712.026308845, 21], [975712.208311181, 15], [975712.362023711, 19], [975712.51628242, 17], [975712.696599999, 12], [975712.879508473, 5], [975713.031221025, 5], [975713.212808527, 27], [975713.404575727, 12], [975713.588570289, 13], [975713.772127454, 5], [975713.917373449, 16], [975714.101600345, 5], [975714.286409163, 14], [975714.47561779, 9], [975714.6607458, 27], [975714.80806096, 11], [975714.992950803, 8], [975715.144048079, 16], [975715.291180959, 5], [975715.450181095, 9], [975715.633697308, 14], [975715.782940823, 20], [975715.934184082, 8], [975716.080083843, 12], [975716.228985785, 5], [975716.383670415, 14], [975716.570141983, 14], [975716.718453604, 8], [975716.901922383, 13], [975717.078421402, 3], [975717.259773772, 10], [975717.414818733, 11], [975717.600717966, 9], [975717.786097196, 10], [975717.968627364, 20], [975718.152752996, 14], [975718.340402029, 14], [975718.57602643, 13], [975718.759572814, 5], [975718.94622989, 22], [975719.179471699, 3], [975719.426088231, 32], [975719.608920188, 33], [975719.79452038, 11], [975719.981070567, 6], [975720.127825358, 8], [975720.274973163, 9], [975720.433516926, 13], [975720.584269921, 8], [975720.732245738, 20], [975720.882391215, 17], [975721.067413572, 20], [975721.217967071, 13], [975721.399810931, 6], [975721.585243294, 13], [975721.735214056, 9], [975721.919690525, 11], [975722.069419696, 8], [975722.25543992, 15], [975722.449430891, 16], [975722.663040607, 27], [975722.903046472, 4], [975723.05379218, 8], [975723.238987372, 25], [975723.432953499, 18], [975723.581065929, 13], [975723.7669292, 55], [975723.917430581, 11], [975724.103290416, 10], [975724.290369757, 11], [975724.447579885, 15], [975724.596966862, 17], [975724.74690453, 14], [975725.004316263, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-7b9d6e0746bcf405619e8deac58d5071", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.607902858, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.659873522, "time_to_first_token": 0.810991988, "token_sha": "8a91591c94a3", "tokens_per_second": 18.667815597948845}, "seed": 1234, "sent": 975710.529977464, "speculative": {"acceptance_rate": 0.4135514018691589, "accepted": 177, "drafted": 428, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8153643100522459, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 428, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.670308622502933, "done": 975725.004626335, "finish_reason": "length", "first": 975711.345751236, "full_response_s": 14.475659613963217, "last": 975725.003800771, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975711.345751236, 3], [975711.475235969, 11], [975711.659887035, 30], [975711.841332247, 19], [975712.025695836, 21], [975712.209059098, 15], [975712.36288905, 19], [975712.514154937, 17], [975712.695894288, 12], [975712.879955038, 5], [975713.03079814, 5], [975713.214396216, 27], [975713.403461131, 12], [975713.587557691, 13], [975713.772290234, 5], [975713.918323202, 16], [975714.104327253, 5], [975714.284399069, 14], [975714.475265415, 9], [975714.661167005, 27], [975714.809099686, 11], [975714.994469693, 8], [975715.142969594, 16], [975715.290411234, 5], [975715.450230197, 9], [975715.633155465, 14], [975715.782527697, 20], [975715.933859482, 8], [975716.08253247, 12], [975716.228083552, 5], [975716.382305825, 14], [975716.570734224, 14], [975716.720555407, 8], [975716.902684876, 13], [975717.077015069, 3], [975717.261022765, 10], [975717.415299713, 11], [975717.600066942, 9], [975717.785631255, 10], [975717.967495696, 20], [975718.154197408, 14], [975718.339913098, 14], [975718.575760917, 13], [975718.75941213, 5], [975718.947693678, 22], [975719.179089916, 3], [975719.424987891, 32], [975719.610706192, 33], [975719.794071559, 11], [975719.980335977, 6], [975720.12910523, 8], [975720.275709161, 9], [975720.433945651, 13], [975720.585153756, 8], [975720.734798523, 20], [975720.881486725, 17], [975721.068609254, 20], [975721.218133435, 13], [975721.400540225, 6], [975721.585943613, 13], [975721.734993582, 9], [975721.920209584, 11], [975722.069716697, 8], [975722.255037258, 15], [975722.449336221, 16], [975722.662475389, 27], [975722.90490649, 4], [975723.052797101, 8], [975723.238922606, 25], [975723.432794895, 18], [975723.5822419, 13], [975723.767126588, 55], [975723.917490628, 11], [975724.103240753, 10], [975724.289567105, 11], [975724.447053946, 15], [975724.596147122, 17], [975724.74711998, 14], [975725.003800771, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4198cc3c6caab8aa6b59447aa2fab5e5", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.607904362, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.659816547, "time_to_first_token": 0.810634301, "token_sha": "8a91591c94a3", "tokens_per_second": 18.667893461278123}, "seed": 1234, "sent": 975710.528966721, "speculative": {"acceptance_rate": 0.4135514018691589, "accepted": 177, "drafted": 428, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8167845149291679, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 428, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.667390633423498, "done": 975725.004471379, "finish_reason": "length", "first": 975711.344263081, "full_response_s": 14.473624864942394, "last": 975725.004447571, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975711.344263081, 3], [975711.476688349, 11], [975711.658775207, 30], [975711.84191028, 19], [975712.026077426, 21], [975712.210464327, 15], [975712.362399446, 19], [975712.515917757, 17], [975712.695460027, 12], [975712.880337221, 5], [975713.029855971, 5], [975713.21347515, 18], [975713.403744132, 21], [975713.587234531, 13], [975713.772676225, 5], [975713.919060479, 16], [975714.100967513, 5], [975714.286524296, 14], [975714.476138017, 9], [975714.662855683, 27], [975714.808347369, 11], [975714.995164796, 8], [975715.14369764, 16], [975715.291117216, 5], [975715.44898698, 9], [975715.63434902, 14], [975715.782662925, 20], [975715.933369974, 8], [975716.082698594, 12], [975716.228831549, 5], [975716.384260193, 14], [975716.571506189, 14], [975716.717737061, 8], [975716.903327516, 13], [975717.078482825, 3], [975717.26170582, 10], [975717.415587113, 11], [975717.598843692, 9], [975717.783416542, 10], [975717.968468039, 20], [975718.153463763, 14], [975718.341179066, 14], [975718.575922497, 13], [975718.759747449, 5], [975718.946510155, 22], [975719.179757964, 3], [975719.42574008, 32], [975719.610626322, 33], [975719.795490563, 11], [975719.978808111, 6], [975720.12821922, 8], [975720.27485515, 9], [975720.433240197, 13], [975720.583824525, 8], [975720.73364076, 20], [975720.881400407, 17], [975721.067813482, 20], [975721.21860264, 13], [975721.398432341, 6], [975721.585312877, 13], [975721.733388262, 9], [975721.918682166, 11], [975722.068153296, 8], [975722.255857862, 15], [975722.44896943, 16], [975722.662592234, 27], [975722.904570418, 4], [975723.053512811, 8], [975723.238346156, 25], [975723.433291075, 18], [975723.580691218, 13], [975723.764782758, 55], [975723.917356583, 11], [975724.101760598, 10], [975724.288784804, 11], [975724.446778353, 15], [975724.596634022, 17], [975724.74526745, 14], [975725.004447571, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-cab5458fe6f65a584a8c7e73372606d3", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.60791521, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.660048877, "time_to_first_token": 0.810557055, "token_sha": "8a91591c94a3", "tokens_per_second": 18.667575957898237}, "seed": 1234, "sent": 975710.530846514, "speculative": {"acceptance_rate": 0.41451990632318503, "accepted": 177, "drafted": 427, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8134165669325739, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 427, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.668482559501065, "done": 975725.003552617, "finish_reason": "length", "first": 975711.344128317, "full_response_s": 14.475008686073124, "last": 975725.003513818, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975711.344128317, 3], [975711.477999484, 11], [975711.658420336, 30], [975711.84280381, 19], [975712.024757875, 21], [975712.211442303, 15], [975712.361933778, 19], [975712.515519751, 17], [975712.695798563, 12], [975712.879557224, 5], [975713.02951286, 5], [975713.213528173, 27], [975713.402839435, 12], [975713.589962655, 13], [975713.770962428, 5], [975713.919208459, 16], [975714.102145276, 5], [975714.283928712, 14], [975714.477192055, 9], [975714.660574076, 27], [975714.807961746, 11], [975714.993142926, 8], [975715.142812462, 16], [975715.290520015, 5], [975715.449478472, 9], [975715.634540919, 14], [975715.782126859, 20], [975715.935137562, 8], [975716.08196082, 12], [975716.227879973, 5], [975716.383428486, 14], [975716.570606995, 14], [975716.716311641, 8], [975716.903264686, 13], [975717.077889127, 3], [975717.260361134, 10], [975717.41523421, 11], [975717.599499564, 9], [975717.783877203, 10], [975717.966815937, 20], [975718.15405042, 14], [975718.339706623, 14], [975718.575849219, 13], [975718.759449681, 5], [975718.947079373, 22], [975719.179552577, 3], [975719.425463639, 32], [975719.609087784, 33], [975719.793601618, 11], [975719.979327826, 6], [975720.127962395, 8], [975720.275548781, 9], [975720.433680314, 13], [975720.582468686, 8], [975720.731719399, 20], [975720.882546331, 17], [975721.068272926, 20], [975721.218644031, 13], [975721.399869506, 6], [975721.58572757, 13], [975721.734130483, 9], [975721.918550345, 11], [975722.068327531, 8], [975722.255178039, 15], [975722.449875984, 16], [975722.661440599, 27], [975722.902490597, 4], [975723.055395837, 8], [975723.239328276, 25], [975723.432717201, 18], [975723.58094926, 13], [975723.768783555, 55], [975723.915848636, 11], [975724.101973521, 10], [975724.288468844, 11], [975724.447860566, 15], [975724.59655868, 17], [975724.746488716, 14], [975725.003513818, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-1eba5f7609176dc20a560874ade747de", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.607897306, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.659617272, "time_to_first_token": 0.812294644, "token_sha": "8a91591c94a3", "tokens_per_second": 18.668165800128868}, "seed": 1234, "sent": 975710.528543931, "speculative": {"acceptance_rate": 0.4135514018691589, "accepted": 177, "drafted": 428, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8155843860004097, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 428, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 17.772885502608133, "done": 975725.003766116, "finish_reason": "length", "first": 975710.656048679, "full_response_s": 14.477904469007626, "last": 975725.003747029, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975710.656048679, 3], [975710.737095277, 26], [975711.478655499, 15], [975711.657297916, 19], [975711.842046997, 21], [975712.02585668, 15], [975712.208143553, 19], [975712.361048376, 17], [975712.512759964, 6], [975712.695535241, 11], [975712.878405765, 5], [975713.030511155, 18], [975713.213610155, 21], [975713.404858744, 5], [975713.588832027, 8], [975713.772216108, 5], [975713.917584388, 16], [975714.10398267, 5], [975714.2858662, 14], [975714.475861336, 9], [975714.658843767, 27], [975714.807604747, 11], [975714.993062512, 8], [975715.142859309, 16], [975715.2898444, 5], [975715.450420001, 9], [975715.634677027, 14], [975715.781888801, 20], [975715.932800708, 8], [975716.081262278, 12], [975716.230726606, 5], [975716.382715591, 14], [975716.56921399, 14], [975716.716130957, 8], [975716.900790107, 13], [975717.078146849, 3], [975717.259279241, 10], [975717.414193356, 11], [975717.600662239, 9], [975717.78525888, 10], [975717.966181648, 20], [975718.153708188, 14], [975718.339304697, 14], [975718.576819051, 13], [975718.759037051, 5], [975718.946566874, 22], [975719.180066324, 3], [975719.424100681, 32], [975719.609817702, 33], [975719.794616393, 11], [975719.98053938, 6], [975720.12943511, 8], [975720.275675194, 9], [975720.434051648, 13], [975720.586310223, 8], [975720.73272347, 20], [975720.882464701, 17], [975721.067580416, 20], [975721.21849013, 13], [975721.399600233, 6], [975721.586638908, 13], [975721.734629047, 9], [975721.917546594, 11], [975722.070011169, 8], [975722.254240206, 15], [975722.448290695, 16], [975722.66188654, 27], [975722.90198093, 4], [975723.052855595, 8], [975723.239547198, 25], [975723.431809783, 18], [975723.580784592, 13], [975723.765169276, 55], [975723.914538861, 11], [975724.103662263, 10], [975724.288535979, 11], [975724.448372281, 15], [975724.595650639, 17], [975724.746603593, 14], [975725.003747029, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-fdd82898c499134677ad59d2b3e9e8a9", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.127293729, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 14.348013621, "time_to_first_token": 0.128089869, "token_sha": "8a91591c94a3", "tokens_per_second": 17.772494976362275}, "seed": 1234, "sent": 975710.525861647, "speculative": {"acceptance_rate": 0.39461883408071746, "accepted": 176, "drafted": 446, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1301870320457965, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 446, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.66576677867467, "done": 975725.006010317, "finish_reason": "length", "first": 975711.344618, "full_response_s": 14.474744213977829, "last": 975725.005990877, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975711.344618, 3], [975711.476860616, 11], [975711.657947228, 30], [975711.843590334, 19], [975712.027163639, 21], [975712.212451478, 15], [975712.361804805, 19], [975712.515295117, 17], [975712.696347893, 12], [975712.880527072, 5], [975713.03060048, 5], [975713.213400048, 18], [975713.404154058, 21], [975713.587885746, 9], [975713.771111736, 9], [975713.918117879, 16], [975714.102632623, 5], [975714.286243855, 14], [975714.476404027, 9], [975714.66009156, 27], [975714.809336096, 11], [975714.995519603, 8], [975715.143283682, 16], [975715.29104781, 5], [975715.449078386, 9], [975715.634108306, 14], [975715.781627063, 20], [975715.931376296, 8], [975716.082194238, 12], [975716.228200349, 5], [975716.382834404, 14], [975716.568609301, 14], [975716.717874994, 8], [975716.900930536, 13], [975717.077532736, 3], [975717.261163338, 10], [975717.415834499, 11], [975717.599319472, 9], [975717.784571394, 10], [975717.966723123, 20], [975718.153629646, 14], [975718.339960808, 14], [975718.574982056, 13], [975718.759122873, 5], [975718.947461363, 22], [975719.178638216, 3], [975719.424772536, 32], [975719.609778423, 33], [975719.793269483, 11], [975719.97990378, 6], [975720.128089703, 8], [975720.274575877, 9], [975720.435100566, 13], [975720.584151844, 8], [975720.732977976, 20], [975720.881686688, 17], [975721.067753995, 20], [975721.21842714, 13], [975721.398737902, 6], [975721.586183063, 13], [975721.733273096, 9], [975721.918604984, 11], [975722.068590357, 8], [975722.255571357, 15], [975722.450101626, 16], [975722.662274722, 27], [975722.902573843, 4], [975723.054381686, 8], [975723.239502128, 25], [975723.431294132, 18], [975723.581611691, 13], [975723.767394309, 55], [975723.916701559, 11], [975724.102504692, 10], [975724.289794235, 11], [975724.446650756, 15], [975724.596272031, 17], [975724.747715278, 14], [975725.005990877, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-3d11eb53a57043f8748b13a8ef21fb3d", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.607916986, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.66199867, "time_to_first_token": 0.810492304, "token_sha": "8a91591c94a3", "tokens_per_second": 18.664911786292834}, "seed": 1234, "sent": 975710.531266103, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8133518969407305, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "stock", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 18.66265853299366, "done": 975725.00854187, "finish_reason": "length", "first": 975711.344692799, "full_response_s": 14.483156324014999, "last": 975725.008340963, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975711.344692799, 3], [975711.476410756, 11], [975711.657690386, 30], [975711.843379124, 19], [975712.025527504, 21], [975712.209919077, 15], [975712.361626857, 19], [975712.512506275, 17], [975712.695293279, 12], [975712.87917957, 5], [975713.030428197, 5], [975713.213756407, 18], [975713.40436754, 21], [975713.589220817, 9], [975713.771349826, 9], [975713.919297801, 16], [975714.102067294, 5], [975714.286144369, 14], [975714.476697123, 9], [975714.659419833, 27], [975714.808706208, 11], [975714.995246682, 8], [975715.142705681, 16], [975715.289777458, 5], [975715.448108954, 9], [975715.634447113, 14], [975715.783517736, 20], [975715.932039479, 8], [975716.08106745, 12], [975716.228741535, 5], [975716.383622145, 14], [975716.56959774, 14], [975716.715972081, 8], [975716.903399722, 13], [975717.078794897, 3], [975717.259933224, 10], [975717.413636314, 11], [975717.598957769, 9], [975717.784301016, 10], [975717.968677282, 20], [975718.153400868, 14], [975718.339189132, 14], [975718.575566538, 13], [975718.759869174, 5], [975718.947152155, 22], [975719.179426724, 3], [975719.426029865, 32], [975719.609712984, 33], [975719.794782165, 11], [975719.980100703, 6], [975720.129338632, 8], [975720.27558958, 9], [975720.434258875, 13], [975720.583979353, 8], [975720.733737285, 20], [975720.881616562, 17], [975721.067677181, 20], [975721.217832771, 13], [975721.398499284, 6], [975721.586805448, 13], [975721.733915785, 9], [975721.918978191, 11], [975722.069295603, 8], [975722.254478392, 15], [975722.449075843, 16], [975722.662412175, 27], [975722.903675384, 4], [975723.052329784, 8], [975723.238120994, 25], [975723.431983987, 18], [975723.581406609, 13], [975723.767861513, 55], [975723.914833445, 11], [975724.102545299, 10], [975724.288060646, 11], [975724.446901486, 15], [975724.596460267, 17], [975724.746439101, 14], [975725.008340963, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-742d4ee7c5856e21978f3eb7f51d8cab", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.607919001, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.664438929, "time_to_first_token": 0.810328021, "token_sha": "8a91591c94a3", "tokens_per_second": 18.661578519613727}, "seed": 1234, "sent": 975710.525385546, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.8193072529975325, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "python", "burst": null, "phase": "uncached_first_use", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 66.69242710043252, "done": 975751.328936755, "finish_reason": "length", "first": 975747.504351463, "full_response_s": 4.028868215973489, "last": 975751.327874029, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975747.504351463, 2], [975747.655872004, 7], [975747.740129492, 4], [975747.821802356, 73], [975747.902798533, 51], [975747.984987305, 21], [975748.065960954, 14], [975748.146797935, 20], [975748.226925669, 16], [975748.307633677, 15], [975748.394420529, 23], [975748.478840191, 23], [975748.560032876, 25], [975748.640378572, 36], [975748.721623127, 14], [975748.801890666, 6], [975748.883133878, 18], [975748.965453129, 18], [975749.046568472, 19], [975749.127101926, 8], [975749.207279596, 11], [975749.28763123, 18], [975749.373644343, 15], [975749.459773373, 39], [975749.540469543, 30], [975749.62078721, 14], [975749.701075581, 15], [975749.78180279, 8], [975749.862030716, 6], [975749.94236456, 12], [975750.023063579, 26], [975750.104658545, 22], [975750.185515336, 18], [975750.26568592, 38], [975750.347832312, 22], [975750.434280584, 10], [975750.516636875, 14], [975750.596893313, 15], [975750.677127431, 38], [975750.757771812, 47], [975750.838549069, 25], [975750.921408646, 11], [975751.002638597, 34], [975751.084178062, 12], [975751.164415206, 36], [975751.247894399, 60], [975751.327874029, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-6bd7c20f259e4a02a50fb35e", "runtime": {"accepted": 209, "cached": 0, "decode_s": 3.8292, "drafted": 690, "drafts": true, "min_rows": 16, "prefill_s": 0.1775, "rounds": 46, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975747.300068539, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.20428292406722903, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 209, "drafted": 690, "rounds": 46}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 67.80201579807485, "done": 975755.21305793, "finish_reason": "length", "first": 975751.451509881, "full_response_s": 3.8830671519972384, "last": 975755.212460009, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975751.451509881, 2], [975751.537310042, 7], [975751.619440404, 4], [975751.699194296, 73], [975751.779993522, 51], [975751.860201483, 21], [975751.940675791, 14], [975752.021705013, 20], [975752.102969493, 16], [975752.183605669, 15], [975752.263643219, 23], [975752.344463006, 23], [975752.431716733, 25], [975752.515720923, 36], [975752.596938813, 14], [975752.677604396, 6], [975752.75919562, 18], [975752.840146285, 18], [975752.923317169, 19], [975753.005407694, 8], [975753.086505156, 11], [975753.16668752, 18], [975753.247251539, 15], [975753.327598811, 39], [975753.415928802, 30], [975753.49957393, 14], [975753.580707711, 15], [975753.661025336, 8], [975753.741672937, 6], [975753.821843413, 12], [975753.902303324, 26], [975753.984991357, 22], [975754.068057141, 18], [975754.149524003, 38], [975754.229952555, 22], [975754.310617453, 10], [975754.396914374, 14], [975754.481885552, 15], [975754.563595704, 38], [975754.644360136, 47], [975754.724785903, 25], [975754.805652636, 11], [975754.886834387, 34], [975754.969884237, 12], [975755.050363045, 36], [975755.131716423, 60], [975755.212460009, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-264aa678b3f04386855985eb", "runtime": {"accepted": 209, "cached": 13, "decode_s": 3.7601, "drafted": 690, "drafts": true, "min_rows": 16, "prefill_s": 0.1177, "rounds": 46, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975751.329990778, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12151910294778645, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 209, "drafted": 690, "rounds": 46}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 67.90787877889488, "done": 975759.090500065, "finish_reason": "length", "first": 975755.334652977, "full_response_s": 3.867010178975761, "last": 975759.089740083, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975755.334652977, 2], [975755.422173198, 7], [975755.50671994, 4], [975755.58766432, 73], [975755.667524775, 51], [975755.748670239, 21], [975755.828968779, 14], [975755.908615848, 20], [975755.989249438, 16], [975756.070869915, 15], [975756.151365444, 23], [975756.23165981, 23], [975756.3117493, 25], [975756.398832478, 36], [975756.484213217, 14], [975756.565114592, 6], [975756.645681431, 18], [975756.725233223, 18], [975756.806202516, 19], [975756.886104301, 8], [975756.970123794, 11], [975757.050037898, 18], [975757.13114991, 15], [975757.211658527, 39], [975757.292338709, 30], [975757.376299356, 14], [975757.462280802, 15], [975757.543958112, 8], [975757.62469562, 6], [975757.705153343, 12], [975757.785976897, 26], [975757.86625045, 22], [975757.947079062, 18], [975758.028410093, 38], [975758.1096006, 22], [975758.189932776, 10], [975758.270559472, 14], [975758.352442331, 15], [975758.438499776, 38], [975758.521379442, 47], [975758.602601197, 25], [975758.683061897, 11], [975758.763572708, 34], [975758.84418371, 12], [975758.926731146, 36], [975759.007701659, 60], [975759.089740083, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-62c1057c763249789216a948", "runtime": {"accepted": 209, "cached": 13, "decode_s": 3.7545, "drafted": 690, "drafts": true, "min_rows": 16, "prefill_s": 0.1086, "rounds": 46, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975755.223489886, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.11116309091448784, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 209, "drafted": 690, "rounds": 46}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 67.99735530122675, "done": 975762.964936524, "finish_reason": "length", "first": 975759.213114248, "full_response_s": 3.863340678042732, "last": 975762.963260101, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975759.213114248, 2], [975759.294086297, 7], [975759.378918446, 4], [975759.464373812, 73], [975759.545183625, 51], [975759.626408853, 21], [975759.706138916, 14], [975759.786707856, 20], [975759.866702394, 16], [975759.947617438, 15], [975760.027696103, 23], [975760.109418056, 23], [975760.189695692, 25], [975760.26986517, 36], [975760.351857133, 14], [975760.43831014, 6], [975760.520941063, 18], [975760.601771678, 18], [975760.681898373, 19], [975760.762120138, 8], [975760.842651432, 11], [975760.925077066, 18], [975761.006324296, 15], [975761.087713074, 39], [975761.167494404, 30], [975761.24905033, 14], [975761.32854405, 15], [975761.415474679, 8], [975761.49892464, 6], [975761.578977131, 12], [975761.659815523, 26], [975761.740376081, 22], [975761.820909729, 18], [975761.901238358, 38], [975761.982496341, 22], [975762.064361878, 10], [975762.144595725, 14], [975762.22526713, 15], [975762.305611232, 38], [975762.39189351, 47], [975762.476450678, 25], [975762.557722756, 11], [975762.637508103, 34], [975762.718253714, 12], [975762.798837858, 36], [975762.879205831, 60], [975762.963260101, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-0aa23dd1ac054fd6b441e451", "runtime": {"accepted": 209, "cached": 13, "decode_s": 3.7499, "drafted": 690, "drafts": true, "min_rows": 16, "prefill_s": 0.1087, "rounds": 46, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975759.101595846, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1115184020018205, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 209, "drafted": 690, "rounds": 46}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.482749445714443, "done": 975773.71148275, "finish_reason": "length", "first": 975763.277614439, "full_response_s": 10.732935592066497, "last": 975773.6931113, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975763.277614439, 2], [975763.451231086, 7], [975763.600345825, 4], [975763.835869865, 63], [975764.119425796, 10], [975764.303995079, 31], [975764.504266561, 29], [975764.652434509, 13], [975764.842295265, 13], [975764.999972828, 20], [975765.179035894, 14], [975765.36534333, 4], [975765.523068236, 13], [975765.704153782, 21], [975765.886043581, 2], [975766.068914671, 18], [975766.25609417, 29], [975766.499913815, 27], [975766.684611853, 15], [975766.838251068, 11], [975767.012982164, 18], [975767.199403365, 10], [975767.388222699, 31], [975767.54364117, 8], [975767.691483982, 8], [975767.841619315, 8], [975767.993992293, 18], [975768.178825615, 24], [975768.364839436, 25], [975768.52463702, 13], [975768.708286594, 11], [975768.860518856, 16], [975769.062428877, 13], [975769.232542201, 8], [975769.389641341, 12], [975769.577931015, 9], [975769.755469922, 29], [975769.942300401, 22], [975770.129580455, 8], [975770.275744755, 18], [975770.476797743, 18], [975770.654669173, 34], [975770.83995881, 10], [975771.024406167, 14], [975771.210110917, 13], [975771.403821988, 2], [975771.593935785, 36], [975771.776268536, 42], [975771.960632121, 26], [975772.116153083, 17], [975772.295637665, 34], [975772.496141953, 12], [975772.675982366, 36], [975772.976104969, 50], [975773.155243018, 2], [975773.452313024, 54], [975773.6931113, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-d6f30031ea5d43ed8cabf5b3", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.4167, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2618, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975762.978547158, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.29906728107016534, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.478704607409032, "done": 975773.71374004, "finish_reason": "length", "first": 975763.277192129, "full_response_s": 10.730317160021514, "last": 975773.694410037, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975763.277192129, 2], [975763.451615077, 7], [975763.600676185, 4], [975763.837274695, 63], [975764.1197483, 10], [975764.302314719, 31], [975764.504901297, 29], [975764.655353767, 13], [975764.841771646, 13], [975764.998917269, 20], [975765.177254865, 14], [975765.366572021, 4], [975765.523818394, 13], [975765.704423423, 21], [975765.885456299, 2], [975766.068520313, 18], [975766.254436866, 29], [975766.500471354, 27], [975766.686425394, 15], [975766.838479175, 11], [975767.013598086, 18], [975767.201126699, 10], [975767.38936472, 31], [975767.54372568, 8], [975767.692475222, 8], [975767.842845734, 8], [975767.991800714, 18], [975768.175981715, 24], [975768.36466008, 25], [975768.524125177, 13], [975768.708170277, 11], [975768.857941222, 16], [975769.062579865, 13], [975769.232459323, 8], [975769.392712308, 12], [975769.577578704, 9], [975769.756732388, 29], [975769.94143871, 22], [975770.12759479, 8], [975770.276695004, 18], [975770.4727364, 18], [975770.655744715, 34], [975770.841357017, 10], [975771.026160973, 14], [975771.209452373, 13], [975771.405068839, 2], [975771.589507795, 36], [975771.779307408, 42], [975771.958778453, 26], [975772.116993495, 17], [975772.29867868, 34], [975772.494780641, 12], [975772.677933008, 36], [975772.977487016, 50], [975773.15585486, 2], [975773.450408462, 54], [975773.694410037, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-e0608407305c4cb7816c14b2", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.4168, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2618, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975762.98342288, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.29376924911048263, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.478582082946648, "done": 975773.712236588, "finish_reason": "length", "first": 975763.276410036, "full_response_s": 10.729765236959793, "last": 975773.693680086, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975763.276410036, 2], [975763.451191039, 7], [975763.59995097, 4], [975763.835598991, 63], [975764.118475211, 10], [975764.302930544, 31], [975764.50504939, 29], [975764.653307256, 13], [975764.841642817, 13], [975764.998801992, 20], [975765.176618736, 14], [975765.365272484, 4], [975765.522548217, 13], [975765.707590419, 21], [975765.884958135, 2], [975766.068039812, 18], [975766.25550468, 29], [975766.496682757, 27], [975766.687984669, 15], [975766.836963947, 11], [975767.014982085, 18], [975767.198767204, 10], [975767.391027128, 31], [975767.54763805, 8], [975767.693415183, 8], [975767.842534669, 8], [975767.992016613, 18], [975768.1762831, 24], [975768.365792789, 25], [975768.523962221, 13], [975768.708087783, 11], [975768.858029524, 16], [975769.063814684, 13], [975769.234331647, 8], [975769.392832385, 12], [975769.57813133, 9], [975769.755678749, 29], [975769.943080751, 22], [975770.127215423, 8], [975770.276089882, 18], [975770.472666162, 18], [975770.656765923, 34], [975770.840905476, 10], [975771.025806181, 14], [975771.20939111, 13], [975771.403686583, 2], [975771.591780509, 36], [975771.776859866, 42], [975771.958937681, 26], [975772.117798371, 17], [975772.297031983, 34], [975772.495921862, 12], [975772.678332438, 36], [975772.976760378, 50], [975773.15578331, 2], [975773.452744886, 54], [975773.693680086, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-0c0655d83ec047e587eed316", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.4168, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2618, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975762.982471351, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2939386849757284, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.473110040286063, "done": 975773.71414531, "finish_reason": "length", "first": 975763.276456339, "full_response_s": 10.733499258989468, "last": 975773.696055629, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975763.276456339, 2], [975763.450200279, 7], [975763.600477454, 4], [975763.835516641, 63], [975764.11983697, 10], [975764.302021526, 31], [975764.504108565, 29], [975764.6546494, 13], [975764.841252202, 13], [975764.997835439, 20], [975765.177120628, 14], [975765.365796984, 4], [975765.525335046, 13], [975765.70506952, 21], [975765.885579464, 2], [975766.068328157, 18], [975766.253948061, 29], [975766.499407203, 27], [975766.684721787, 15], [975766.837420304, 11], [975767.013220575, 18], [975767.199137723, 10], [975767.389114742, 31], [975767.543338953, 8], [975767.691794454, 8], [975767.843496438, 8], [975767.991174825, 18], [975768.176075793, 24], [975768.366093294, 25], [975768.523872447, 13], [975768.708682169, 11], [975768.858068723, 16], [975769.062672599, 13], [975769.231924632, 8], [975769.391022204, 12], [975769.576820786, 9], [975769.755878648, 29], [975769.943181932, 22], [975770.128129977, 8], [975770.276040139, 18], [975770.475317922, 18], [975770.654412187, 34], [975770.838583403, 10], [975771.02426177, 14], [975771.211619681, 13], [975771.404298073, 2], [975771.597567747, 36], [975771.775838354, 42], [975771.957884363, 26], [975772.116561185, 17], [975772.296715319, 34], [975772.494251102, 12], [975772.675879345, 36], [975772.977139105, 50], [975773.158383072, 2], [975773.449799964, 54], [975773.696055629, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-e428908431904654b2339753", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.4167, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2618, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975762.980646051, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2958102880511433, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.483409011051382, "done": 975773.712935675, "finish_reason": "length", "first": 975763.278727597, "full_response_s": 10.733853778103366, "last": 975773.693943872, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975763.278727597, 2], [975763.451806896, 7], [975763.600259427, 4], [975763.83542426, 63], [975764.119335126, 10], [975764.302622984, 31], [975764.505436325, 29], [975764.652816196, 13], [975764.84293229, 13], [975765.000318804, 20], [975765.177387614, 14], [975765.364246781, 4], [975765.523401716, 13], [975765.704700841, 21], [975765.886682094, 2], [975766.069021629, 18], [975766.258196711, 29], [975766.49662351, 27], [975766.685527495, 15], [975766.838789808, 11], [975767.012568526, 18], [975767.200863634, 10], [975767.388743903, 31], [975767.544020937, 8], [975767.691555644, 8], [975767.841329978, 8], [975767.993472306, 18], [975768.179796296, 24], [975768.364258026, 25], [975768.529705731, 13], [975768.708508157, 11], [975768.858868464, 16], [975769.06231128, 13], [975769.234419612, 8], [975769.389311893, 12], [975769.577813178, 9], [975769.757887496, 29], [975769.941933002, 22], [975770.129508312, 8], [975770.275961613, 18], [975770.474404968, 18], [975770.657076828, 34], [975770.838727256, 10], [975771.026224139, 14], [975771.21240323, 13], [975771.403755078, 2], [975771.597363335, 36], [975771.777863858, 42], [975771.961384775, 26], [975772.116813291, 17], [975772.296309809, 34], [975772.497162745, 12], [975772.677225217, 36], [975772.976266933, 50], [975773.158228243, 2], [975773.451412902, 54], [975773.693943872, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-c2cf975e23a84778b2b84678", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.4167, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2618, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975762.979081897, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.29964570002630353, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.482527557404556, "done": 975773.712098975, "finish_reason": "length", "first": 975763.277399788, "full_response_s": 10.73151740198955, "last": 975773.692991046, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975763.277399788, 2], [975763.450592717, 7], [975763.602699912, 4], [975763.836752756, 63], [975764.119503042, 10], [975764.302725477, 31], [975764.505134284, 29], [975764.653876682, 13], [975764.84393849, 13], [975765.001166655, 20], [975765.179076981, 14], [975765.365702506, 4], [975765.523972871, 13], [975765.704018009, 21], [975765.887392173, 2], [975766.068976734, 18], [975766.255696691, 29], [975766.500708132, 27], [975766.684971557, 15], [975766.83803789, 11], [975767.014474065, 18], [975767.200948528, 10], [975767.388807693, 31], [975767.544349281, 8], [975767.691651274, 8], [975767.842157238, 8], [975767.995986406, 18], [975768.177364146, 24], [975768.365302801, 25], [975768.524364563, 13], [975768.707764559, 11], [975768.858577255, 16], [975769.062365678, 13], [975769.232375917, 8], [975769.389165768, 12], [975769.576920015, 9], [975769.755201625, 29], [975769.942992257, 22], [975770.128350452, 8], [975770.276958501, 18], [975770.472451799, 18], [975770.655244647, 34], [975770.838796038, 10], [975771.023920034, 14], [975771.210719815, 13], [975771.405489804, 2], [975771.59062228, 36], [975771.776523458, 42], [975771.957416646, 26], [975772.114680894, 17], [975772.295771181, 34], [975772.494164032, 12], [975772.677822115, 36], [975772.977829264, 50], [975773.155315833, 2], [975773.449657424, 54], [975773.692991046, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-fd47d9b09e4d4e34afb3b6e2", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.4167, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2618, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975762.980581573, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2968182150507346, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.480194796577432, "done": 975773.713358209, "finish_reason": "length", "first": 975763.276255992, "full_response_s": 10.73471004597377, "last": 975773.69283977, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975763.276255992, 2], [975763.451732626, 7], [975763.602075319, 4], [975763.835659566, 63], [975764.119703597, 10], [975764.301929192, 31], [975764.505785676, 29], [975764.653395894, 13], [975764.843199676, 13], [975764.997693267, 20], [975765.177198034, 14], [975765.365141847, 4], [975765.522886961, 13], [975765.705931243, 21], [975765.886388629, 2], [975766.070578375, 18], [975766.254698827, 29], [975766.496158033, 27], [975766.685487192, 15], [975766.837632059, 11], [975767.01367258, 18], [975767.200796675, 10], [975767.388469029, 31], [975767.548857381, 8], [975767.691397152, 8], [975767.841430088, 8], [975767.992176097, 18], [975768.179216981, 24], [975768.36474363, 25], [975768.523412154, 13], [975768.70821306, 11], [975768.858500841, 16], [975769.063721374, 13], [975769.232270224, 8], [975769.390668805, 12], [975769.578421707, 9], [975769.756560168, 29], [975769.94116198, 22], [975770.129034564, 8], [975770.275853264, 18], [975770.471849045, 18], [975770.654186353, 34], [975770.840330178, 10], [975771.026086543, 14], [975771.211734558, 13], [975771.403443245, 2], [975771.590805476, 36], [975771.776389397, 42], [975771.959290233, 26], [975772.115883697, 17], [975772.296967953, 34], [975772.49683768, 12], [975772.678194858, 36], [975772.97589715, 50], [975773.159131966, 2], [975773.449569346, 54], [975773.69283977, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-deb1ddcc2ad44ebd802ed191", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.4167, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2618, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975762.978648163, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.29760782897938043, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.4798692885631, "done": 975773.713962979, "finish_reason": "length", "first": 975763.276704957, "full_response_s": 10.733026519068517, "last": 975773.693427244, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975763.276704957, 2], [975763.452027931, 7], [975763.600558492, 4], [975763.836915168, 63], [975764.121217369, 10], [975764.303073133, 31], [975764.505511603, 29], [975764.653241722, 13], [975764.841131949, 13], [975764.998664556, 20], [975765.176952056, 14], [975765.36504961, 4], [975765.524273343, 13], [975765.704236836, 21], [975765.885791715, 2], [975766.070650998, 18], [975766.254029067, 29], [975766.496884608, 27], [975766.684859208, 15], [975766.837340306, 11], [975767.014583598, 18], [975767.198903777, 10], [975767.38921122, 31], [975767.543428295, 8], [975767.691719464, 8], [975767.84268209, 8], [975767.991484865, 18], [975768.178624612, 24], [975768.365577418, 25], [975768.524974996, 13], [975768.70953274, 11], [975768.858635141, 16], [975769.063231818, 13], [975769.23328108, 8], [975769.390101122, 12], [975769.578913136, 9], [975769.757375253, 29], [975769.941057999, 22], [975770.127468825, 8], [975770.27625271, 18], [975770.472088079, 18], [975770.65563459, 34], [975770.838481646, 10], [975771.024051567, 14], [975771.2086314, 13], [975771.404040143, 2], [975771.589671423, 36], [975771.778331719, 42], [975771.958205283, 26], [975772.116432756, 17], [975772.297644481, 34], [975772.494319564, 12], [975772.675407916, 36], [975772.977243806, 50], [975773.155599954, 2], [975773.450848755, 54], [975773.693427244, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-eec16e66dbb74dc3a9c94ba4", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.4168, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2618, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975762.98093646, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2957684970460832, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.47630968916291, "done": 975773.713920916, "finish_reason": "length", "first": 975763.276358677, "full_response_s": 10.733430029009469, "last": 975773.694595872, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975763.276358677, 2], [975763.451429129, 7], [975763.600114502, 4], [975763.835746284, 63], [975764.118782132, 10], [975764.303382918, 31], [975764.505342599, 29], [975764.653182075, 13], [975764.84119806, 13], [975764.998496544, 20], [975765.179293696, 14], [975765.364432696, 4], [975765.522699845, 13], [975765.70670676, 21], [975765.885132083, 2], [975766.071602559, 18], [975766.255161968, 29], [975766.496515193, 27], [975766.684794537, 15], [975766.841761912, 11], [975767.012339444, 18], [975767.199638335, 10], [975767.390901675, 31], [975767.543930923, 8], [975767.694239868, 8], [975767.843757312, 8], [975767.991061627, 18], [975768.176195854, 24], [975768.367301857, 25], [975768.523794241, 13], [975768.708450622, 11], [975768.859903815, 16], [975769.063679583, 13], [975769.23310678, 8], [975769.392419419, 12], [975769.576683077, 9], [975769.756168945, 29], [975769.944500429, 22], [975770.127300541, 8], [975770.275905775, 18], [975770.472011521, 18], [975770.654084131, 34], [975770.838657018, 10], [975771.02587682, 14], [975771.208568714, 13], [975771.406178524, 2], [975771.589399206, 36], [975771.778065693, 42], [975771.957629505, 26], [975772.117421628, 17], [975772.295527043, 34], [975772.494041667, 12], [975772.676455107, 36], [975772.976680251, 50], [975773.155480053, 2], [975773.449466196, 54], [975773.694595872, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-724d0dc940b847cdbd05a917", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.4167, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2618, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975762.980490887, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.29586779000237584, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.483468849205078, "done": 975773.710997305, "finish_reason": "length", "first": 975763.277871281, "full_response_s": 10.731186641962267, "last": 975773.693062101, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975763.277871281, 2], [975763.451380762, 7], [975763.60087202, 4], [975763.836203393, 63], [975764.120372893, 10], [975764.304322831, 31], [975764.50495472, 29], [975764.65346098, 13], [975764.842870755, 13], [975764.998360899, 20], [975765.178160603, 14], [975765.365483087, 4], [975765.522992014, 13], [975765.704978018, 21], [975765.886929896, 2], [975766.069899096, 18], [975766.254940581, 29], [975766.499620846, 27], [975766.686928166, 15], [975766.838748976, 11], [975767.01390371, 18], [975767.198982607, 10], [975767.389765926, 31], [975767.545056096, 8], [975767.692965466, 8], [975767.844518798, 8], [975767.991561199, 18], [975768.176420776, 24], [975768.365388735, 25], [975768.523518935, 13], [975768.708727064, 11], [975768.858315581, 16], [975769.062618024, 13], [975769.233025758, 8], [975769.391260998, 12], [975769.576987566, 9], [975769.755527505, 29], [975769.942849924, 22], [975770.128615854, 8], [975770.277469705, 18], [975770.471927315, 18], [975770.655165321, 34], [975770.839483974, 10], [975771.025731111, 14], [975771.20874439, 13], [975771.404421366, 2], [975771.591971464, 36], [975771.777242529, 42], [975771.958484076, 26], [975772.115635703, 17], [975772.297452293, 34], [975772.496707188, 12], [975772.675669766, 36], [975772.977411882, 50], [975773.156480125, 2], [975773.449717518, 54], [975773.693062101, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-4dbc67f8f6554a3494b23598", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.4168, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2618, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975762.979810663, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2980606179917231, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.478902856954395, "done": 975773.712728816, "finish_reason": "length", "first": 975763.276209257, "full_response_s": 10.734262184007093, "last": 975773.693342798, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975763.276209257, 2], [975763.45198406, 7], [975763.601149421, 4], [975763.835955751, 63], [975764.120054437, 10], [975764.303640431, 31], [975764.506772837, 29], [975764.652737766, 13], [975764.840959409, 13], [975764.999170223, 20], [975765.178661935, 14], [975765.367391985, 4], [975765.524103219, 13], [975765.705269563, 21], [975765.88552073, 2], [975766.068664453, 18], [975766.255111265, 29], [975766.497284886, 27], [975766.685804001, 15], [975766.837122583, 11], [975767.01350788, 18], [975767.200218673, 10], [975767.390481877, 31], [975767.544100327, 8], [975767.69231969, 8], [975767.843837982, 8], [975767.994257823, 18], [975768.176961739, 24], [975768.364398326, 25], [975768.5259775, 13], [975768.707993897, 11], [975768.859587487, 16], [975769.062267041, 13], [975769.235668751, 8], [975769.389262694, 12], [975769.576505513, 9], [975769.756386972, 29], [975769.941312809, 22], [975770.127652821, 8], [975770.277108546, 18], [975770.47279683, 18], [975770.654323261, 34], [975770.838147942, 10], [975771.0245345, 14], [975771.208875779, 13], [975771.404133901, 2], [975771.589759245, 36], [975771.776742349, 42], [975771.957318824, 26], [975772.114810603, 17], [975772.295161612, 34], [975772.494629925, 12], [975772.676560161, 36], [975772.97885532, 50], [975773.155731087, 2], [975773.45242419, 54], [975773.693342798, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-d9fe64d879aa4f81be500998", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.4167, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2618, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975762.978466632, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2977426249999553, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.48405367714817, "done": 975773.712174141, "finish_reason": "length", "first": 975763.278650574, "full_response_s": 10.734245912986808, "last": 975773.693592616, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975763.278650574, 2], [975763.45148596, 7], [975763.601213532, 4], [975763.836307966, 63], [975764.119789163, 10], [975764.302220865, 31], [975764.504344223, 29], [975764.652323792, 13], [975764.840815109, 13], [975765.00266214, 20], [975765.179144036, 14], [975765.365196694, 4], [975765.522309582, 13], [975765.705358793, 21], [975765.885651767, 2], [975766.068431867, 18], [975766.253535095, 29], [975766.495826601, 27], [975766.686493424, 15], [975766.839384097, 11], [975767.01306893, 18], [975767.199287815, 10], [975767.389709928, 31], [975767.542959346, 8], [975767.691282195, 8], [975767.841216781, 8], [975767.99161755, 18], [975768.178880525, 24], [975768.366414454, 25], [975768.526716235, 13], [975768.707854172, 11], [975768.858713956, 16], [975769.062821219, 13], [975769.232623335, 8], [975769.38991839, 12], [975769.577721708, 9], [975769.75530839, 29], [975769.940981665, 22], [975770.128939206, 8], [975770.27703314, 18], [975770.473537229, 18], [975770.656618246, 34], [975770.841286267, 10], [975771.025206244, 14], [975771.209184683, 13], [975771.404554115, 2], [975771.591209274, 36], [975771.777548618, 42], [975771.961309865, 26], [975772.1152792, 17], [975772.297741198, 34], [975772.494471449, 12], [975772.676751932, 36], [975772.978806617, 50], [975773.155374903, 2], [975773.450061494, 54], [975773.693592616, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-86a81995da684263adc7c910", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.4166, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2618, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975762.977928228, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.3007223460590467, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.476518009844735, "done": 975773.713085191, "finish_reason": "length", "first": 975763.277234336, "full_response_s": 10.73379190696869, "last": 975773.695382861, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975763.277234336, 2], [975763.451568774, 7], [975763.601809854, 4], [975763.835808362, 63], [975764.118749492, 10], [975764.30421045, 31], [975764.504477804, 29], [975764.653121357, 13], [975764.841327176, 13], [975765.00274617, 20], [975765.177314783, 14], [975765.365580285, 4], [975765.524385485, 13], [975765.704828037, 21], [975765.887096996, 2], [975766.070204208, 18], [975766.26077113, 29], [975766.500623222, 27], [975766.688208807, 15], [975766.838871582, 11], [975767.014898615, 18], [975767.199884569, 10], [975767.390382088, 31], [975767.545458598, 8], [975767.691597915, 8], [975767.845237277, 8], [975767.99235606, 18], [975768.1757634, 24], [975768.366632033, 25], [975768.524233094, 13], [975768.707922955, 11], [975768.860242159, 16], [975769.062722598, 13], [975769.232915088, 8], [975769.391097578, 12], [975769.578575784, 9], [975769.75725068, 29], [975769.942542652, 22], [975770.127540503, 8], [975770.27725283, 18], [975770.476377673, 18], [975770.655508913, 34], [975770.840050264, 10], [975771.024350888, 14], [975771.208959809, 13], [975771.404214843, 2], [975771.58989785, 36], [975771.775713733, 42], [975771.9588441, 26], [975772.114888089, 17], [975772.296133205, 34], [975772.49551392, 12], [975772.677059061, 36], [975772.97683356, 50], [975773.157086175, 2], [975773.4506498, 54], [975773.695382861, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-553791ef0a514c67acc471d6", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.4167, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2618, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975762.979293284, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.29794105200562626, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.474450262736074, "done": 975773.712784383, "finish_reason": "length", "first": 975763.277346478, "full_response_s": 10.729544201982208, "last": 975773.69637519, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975763.277346478, 2], [975763.451687331, 7], [975763.600752855, 4], [975763.835241512, 63], [975764.120656023, 10], [975764.30237667, 31], [975764.507281816, 29], [975764.653514195, 13], [975764.842382031, 13], [975765.00046952, 20], [975765.178771885, 14], [975765.36670853, 4], [975765.523552209, 13], [975765.705525509, 21], [975765.886797227, 2], [975766.070072067, 18], [975766.253859743, 29], [975766.499681373, 27], [975766.688252502, 15], [975766.839294323, 11], [975767.013970461, 18], [975767.200292511, 10], [975767.388360792, 31], [975767.543497397, 8], [975767.692599107, 8], [975767.843917116, 8], [975767.992438491, 18], [975768.178023986, 24], [975768.364519108, 25], [975768.524817704, 13], [975768.709321161, 11], [975768.85837118, 16], [975769.062763829, 13], [975769.233805227, 8], [975769.390215775, 12], [975769.577503553, 9], [975769.755753307, 29], [975769.941233819, 22], [975770.128280006, 8], [975770.276186888, 18], [975770.47398749, 18], [975770.6553897, 34], [975770.840592107, 10], [975771.02469216, 14], [975771.210559338, 13], [975771.406726479, 2], [975771.592132948, 36], [975771.775926304, 42], [975771.961141389, 26], [975772.118597728, 17], [975772.296192595, 34], [975772.493691083, 12], [975772.679396253, 36], [975772.977191743, 50], [975773.155667776, 2], [975773.45030976, 54], [975773.69637519, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-ace460b6893e4967abcfe6be", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.4168, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2618, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975762.983240181, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2941062969621271, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.477334560620854, "done": 975773.711300114, "finish_reason": "length", "first": 975763.277289519, "full_response_s": 10.72629364009481, "last": 975773.6950905, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975763.277289519, 2], [975763.451303996, 7], [975763.600939986, 4], [975763.839503794, 63], [975764.120295183, 10], [975764.304390429, 31], [975764.505188891, 29], [975764.654526811, 13], [975764.843153357, 13], [975764.998055562, 20], [975765.176752893, 14], [975765.365418481, 4], [975765.523486578, 13], [975765.704635194, 21], [975765.887239697, 2], [975766.069546496, 18], [975766.257838208, 29], [975766.497965366, 27], [975766.686849848, 15], [975766.840740049, 11], [975767.014418258, 18], [975767.201341334, 10], [975767.389430718, 31], [975767.543841293, 8], [975767.692115775, 8], [975767.843674674, 8], [975767.99312265, 18], [975768.17744016, 24], [975768.365653592, 25], [975768.524491216, 13], [975768.708996113, 11], [975768.859106234, 16], [975769.062911937, 13], [975769.232172226, 8], [975769.392966638, 12], [975769.577662797, 9], [975769.755594751, 29], [975769.941373143, 22], [975770.12944897, 8], [975770.27854728, 18], [975770.474526741, 18], [975770.655996581, 34], [975770.838979154, 10], [975771.02461413, 14], [975771.210053127, 13], [975771.404349624, 2], [975771.589586209, 36], [975771.777158019, 42], [975771.959425126, 26], [975772.11441962, 17], [975772.295451285, 34], [975772.493879719, 12], [975772.676305607, 36], [975772.976200711, 50], [975773.157419767, 2], [975773.449754989, 54], [975773.6950905, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-10ed56e0a9104e4185c05309", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.4168, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2618, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975762.985006474, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.29228304501157254, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.482926247985223, "done": 975773.709258883, "finish_reason": "length", "first": 975763.277802419, "full_response_s": 10.731684230035171, "last": 975773.693224065, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975763.277802419, 2], [975763.450777721, 7], [975763.60019938, 4], [975763.835367925, 63], [975764.118681974, 10], [975764.303726349, 31], [975764.504830099, 29], [975764.652544522, 13], [975764.840901667, 13], [975764.997350875, 20], [975765.178597457, 14], [975765.366350314, 4], [975765.522797539, 13], [975765.70381267, 21], [975765.884850314, 2], [975766.06786772, 18], [975766.253436138, 29], [975766.495944358, 27], [975766.686771898, 15], [975766.837806983, 11], [975767.014063723, 18], [975767.198562793, 10], [975767.388665457, 31], [975767.54581947, 8], [975767.693691657, 8], [975767.843203981, 8], [975767.991309942, 18], [975768.177062153, 24], [975768.365036439, 25], [975768.525061746, 13], [975768.708572459, 11], [975768.858438778, 16], [975769.063122652, 13], [975769.23319017, 8], [975769.391361268, 12], [975769.579417732, 9], [975769.755390532, 29], [975769.940843924, 22], [975770.127356108, 8], [975770.275605558, 18], [975770.471688921, 18], [975770.653908503, 34], [975770.838025241, 10], [975771.024127246, 14], [975771.208441997, 13], [975771.403595546, 2], [975771.590361759, 36], [975771.775990175, 42], [975771.959806237, 26], [975772.114125803, 17], [975772.295692863, 34], [975772.493455905, 12], [975772.6750969, 36], [975772.976024075, 50], [975773.155138701, 2], [975773.44932356, 54], [975773.693224065, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-83fd5481fce14165a9292696", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.4166, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2618, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975762.977574653, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.3002277660416439, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.680662471318797, "done": 975784.290199526, "finish_reason": "length", "first": 975773.939650736, "full_response_s": 10.568692503031343, "last": 975784.271626237, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975773.939650736, 2], [975774.07399632, 7], [975774.221489558, 4], [975774.459950773, 63], [975774.730178576, 10], [975774.91995572, 31], [975775.103352283, 29], [975775.253214267, 13], [975775.446373685, 13], [975775.592453807, 20], [975775.774667582, 14], [975775.959197655, 4], [975776.117872601, 13], [975776.301819057, 21], [975776.494511417, 2], [975776.677432842, 18], [975776.85846804, 29], [975777.097954091, 27], [975777.282979933, 15], [975777.445657458, 11], [975777.619690281, 18], [975777.80658171, 10], [975777.990569996, 31], [975778.144744606, 8], [975778.290160575, 8], [975778.450073257, 8], [975778.598977432, 18], [975778.783565735, 24], [975778.971631287, 25], [975779.122816322, 13], [975779.304280143, 11], [975779.46651074, 16], [975779.616803236, 13], [975779.797368278, 8], [975779.952631668, 12], [975780.136052533, 9], [975780.321184174, 29], [975780.517683849, 22], [975780.699955493, 8], [975780.848499891, 18], [975781.037548994, 18], [975781.221109763, 34], [975781.415935817, 10], [975781.602402294, 14], [975781.790230834, 13], [975781.9768759, 2], [975782.16031322, 36], [975782.345098283, 42], [975782.541521295, 26], [975782.692248989, 17], [975782.875796498, 34], [975783.070177626, 12], [975783.250986946, 36], [975783.549503321, 50], [975783.737519863, 2], [975784.026082653, 54], [975784.271626237, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-a4a1bcf0d950424fb7d3cb30", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3328, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1905, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975773.721507023, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2181437130784616, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.682845907271844, "done": 975784.290864102, "finish_reason": "length", "first": 975773.939290249, "full_response_s": 10.569419429986738, "last": 975784.270351787, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975773.939290249, 2], [975774.073389614, 7], [975774.221203325, 4], [975774.458986828, 63], [975774.729579502, 10], [975774.916230513, 31], [975775.100816935, 29], [975775.25122241, 13], [975775.445715428, 13], [975775.592118231, 20], [975775.776449763, 14], [975775.958690515, 4], [975776.118076404, 13], [975776.301619078, 21], [975776.494359901, 2], [975776.672620012, 18], [975776.85752387, 29], [975777.097377993, 27], [975777.282751474, 15], [975777.444627946, 11], [975777.621918196, 18], [975777.80391947, 10], [975777.99098749, 31], [975778.142092109, 8], [975778.289804744, 8], [975778.452038858, 8], [975778.597262913, 18], [975778.779800049, 24], [975778.971477386, 25], [975779.121269815, 13], [975779.305086012, 11], [975779.468286986, 16], [975779.614857683, 13], [975779.797430133, 8], [975779.952283228, 12], [975780.135136779, 9], [975780.318405056, 29], [975780.516807854, 22], [975780.699081882, 8], [975780.848037214, 18], [975781.035805755, 18], [975781.221899088, 34], [975781.415423125, 10], [975781.599032533, 14], [975781.787836154, 13], [975781.975311313, 2], [975782.159778192, 36], [975782.344578135, 42], [975782.541038602, 26], [975782.690970843, 17], [975782.875034516, 34], [975783.070578432, 12], [975783.253252813, 36], [975783.549322845, 50], [975783.736651243, 2], [975784.027464076, 54], [975784.270351787, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-1ad28d626a7a49d99328ea84", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3327, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1905, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975773.721444672, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21784557704813778, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.668242433001694, "done": 975784.290545598, "finish_reason": "length", "first": 975773.938477164, "full_response_s": 10.568149253027514, "last": 975784.275654638, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975773.938477164, 2], [975774.073734774, 7], [975774.221753328, 4], [975774.459219815, 63], [975774.730336012, 10], [975774.916719621, 31], [975775.102913813, 29], [975775.253708463, 13], [975775.447988878, 13], [975775.595875614, 20], [975775.775701717, 14], [975775.960129185, 4], [975776.117747308, 13], [975776.299927326, 21], [975776.494570664, 2], [975776.672513039, 18], [975776.857429985, 29], [975777.101903053, 27], [975777.284429386, 15], [975777.444949859, 11], [975777.621248676, 18], [975777.803641044, 10], [975777.989435015, 31], [975778.143160195, 8], [975778.289892438, 8], [975778.452101289, 8], [975778.598189595, 18], [975778.780946469, 24], [975778.970686109, 25], [975779.122463642, 13], [975779.306185601, 11], [975779.466768446, 16], [975779.616166836, 13], [975779.797847019, 8], [975779.953181207, 12], [975780.136243248, 9], [975780.319800111, 29], [975780.5187084, 22], [975780.700711747, 8], [975780.84927752, 18], [975781.036869682, 18], [975781.225279712, 34], [975781.417053551, 10], [975781.599833122, 14], [975781.78971043, 13], [975781.976810446, 2], [975782.161860879, 36], [975782.345763899, 42], [975782.541339123, 26], [975782.692021906, 17], [975782.87616377, 34], [975783.071122355, 12], [975783.249936715, 36], [975783.550878456, 50], [975783.741103778, 2], [975784.025766532, 54], [975784.275654638, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-fdb3708e9bc74f8e80189064", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3327, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1905, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975773.722396345, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21608081902377307, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.67780785677556, "done": 975784.289459928, "finish_reason": "length", "first": 975773.938584186, "full_response_s": 10.56785218801815, "last": 975784.271754842, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975773.938584186, 2], [975774.07422489, 7], [975774.222466159, 4], [975774.459476641, 63], [975774.731431346, 10], [975774.917804444, 31], [975775.101573397, 29], [975775.25235432, 13], [975775.447698533, 13], [975775.59436797, 20], [975775.775589624, 14], [975775.959834376, 4], [975776.117164106, 13], [975776.29741209, 21], [975776.497722317, 2], [975776.673577461, 18], [975776.857622764, 29], [975777.09759498, 27], [975777.282050947, 15], [975777.447480551, 11], [975777.620283723, 18], [975777.809040356, 10], [975777.990105719, 31], [975778.142448148, 8], [975778.29334898, 8], [975778.449921773, 8], [975778.600101997, 18], [975778.780337156, 24], [975778.971274767, 25], [975779.125127835, 13], [975779.304382764, 11], [975779.466714911, 16], [975779.617278313, 13], [975779.797913002, 8], [975779.952934108, 12], [975780.1359202, 9], [975780.318718248, 29], [975780.518860029, 22], [975780.699253302, 8], [975780.851512187, 18], [975781.036587417, 18], [975781.22560612, 34], [975781.416893698, 10], [975781.599936912, 14], [975781.789240729, 13], [975781.976572756, 2], [975782.160848679, 36], [975782.344347277, 42], [975782.542929741, 26], [975782.692676179, 17], [975782.874913127, 34], [975783.0717649, 12], [975783.251183006, 36], [975783.549628294, 50], [975783.737589877, 2], [975784.029804181, 54], [975784.271754842, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-663b609f2f4a4a8bb15dd87e", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3327, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1905, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975773.72160774, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.216976445983164, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.673851294654604, "done": 975784.289628852, "finish_reason": "length", "first": 975773.9391407, "full_response_s": 10.567943433998153, "last": 975784.273968326, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975773.9391407, 2], [975774.075031399, 7], [975774.222320466, 4], [975774.459407378, 63], [975774.730388427, 10], [975774.916589881, 31], [975775.101198254, 29], [975775.252637849, 13], [975775.447176034, 13], [975775.59368773, 20], [975775.775127859, 14], [975775.959084842, 4], [975776.116962766, 13], [975776.299492296, 21], [975776.496645446, 2], [975776.67472337, 18], [975776.861690171, 29], [975777.098509534, 27], [975777.283898695, 15], [975777.447843374, 11], [975777.621340402, 18], [975777.805107665, 10], [975777.992445007, 31], [975778.143476988, 8], [975778.293718779, 8], [975778.452501327, 8], [975778.598480932, 18], [975778.781883999, 24], [975778.972739964, 25], [975779.12137322, 13], [975779.305839066, 11], [975779.466885451, 16], [975779.617653568, 13], [975779.797771293, 8], [975779.954392826, 12], [975780.13820141, 9], [975780.319469046, 29], [975780.519039257, 22], [975780.701444082, 8], [975780.848292376, 18], [975781.036193314, 18], [975781.225325535, 34], [975781.416151428, 10], [975781.599707429, 14], [975781.788580233, 13], [975781.978625811, 2], [975782.1604748, 36], [975782.345398164, 42], [975782.540936364, 26], [975782.692082593, 17], [975782.878964295, 34], [975783.07025028, 12], [975783.250051864, 36], [975783.55105258, 50], [975783.738467648, 2], [975784.026577873, 54], [975784.273968326, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-efc527cbe33e4be5b194e291", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3327, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1905, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975773.721685418, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2174552819924429, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.67813398580856, "done": 975784.289713234, "finish_reason": "length", "first": 975773.939015487, "full_response_s": 10.567526099970564, "last": 975784.272049587, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975773.939015487, 2], [975774.074410838, 7], [975774.221262219, 4], [975774.460823504, 63], [975774.730028851, 10], [975774.91712102, 31], [975775.104101817, 29], [975775.252207907, 13], [975775.446213449, 13], [975775.592356658, 20], [975775.775350493, 14], [975775.960491673, 4], [975776.116857313, 13], [975776.298162648, 21], [975776.494724404, 2], [975776.67658043, 18], [975776.858054738, 29], [975777.098334994, 27], [975777.285147481, 15], [975777.444702841, 11], [975777.620517957, 18], [975777.806275686, 10], [975777.989942795, 31], [975778.142733261, 8], [975778.291697339, 8], [975778.450923525, 8], [975778.597617752, 18], [975778.780501104, 24], [975778.971548313, 25], [975779.122131762, 13], [975779.304960223, 11], [975779.468588739, 16], [975779.616957249, 13], [975779.800628921, 8], [975779.954888238, 12], [975780.137575793, 9], [975780.320566316, 29], [975780.520828942, 22], [975780.699668348, 8], [975780.849185458, 18], [975781.038731238, 18], [975781.22223732, 34], [975781.416963409, 10], [975781.600665087, 14], [975781.789025982, 13], [975781.976744864, 2], [975782.160038154, 36], [975782.344816722, 42], [975782.54119847, 26], [975782.691572333, 17], [975782.875973646, 34], [975783.074804844, 12], [975783.252128039, 36], [975783.549725668, 50], [975783.737673059, 2], [975784.02596192, 54], [975784.272049587, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-5d321b13b4d84f44b5ecf867", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3328, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1905, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975773.722187134, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21682835300453007, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.678740875933936, "done": 975784.288984355, "finish_reason": "length", "first": 975773.938096597, "full_response_s": 10.566893842071295, "last": 975784.270876591, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975773.938096597, 2], [975774.074280633, 7], [975774.221423656, 4], [975774.461599886, 63], [975774.732676596, 10], [975774.917199898, 31], [975775.101658819, 29], [975775.251897418, 13], [975775.445886032, 13], [975775.592787159, 20], [975775.778965431, 14], [975775.961626078, 4], [975776.118199105, 13], [975776.297234622, 21], [975776.495467122, 2], [975776.673654804, 18], [975776.860160928, 29], [975777.098908677, 27], [975777.282863632, 15], [975777.446603435, 11], [975777.621836246, 18], [975777.805379243, 10], [975777.990804246, 31], [975778.14464032, 8], [975778.290224094, 8], [975778.450180726, 8], [975778.597542522, 18], [975778.779921742, 24], [975778.97335659, 25], [975779.122049828, 13], [975779.304891792, 11], [975779.467073159, 16], [975779.616035911, 13], [975779.797703887, 8], [975779.954277997, 12], [975780.136110468, 9], [975780.319012033, 29], [975780.519395312, 22], [975780.698829072, 8], [975780.848719549, 18], [975781.038178931, 18], [975781.221243824, 34], [975781.416552235, 10], [975781.602702446, 14], [975781.788923616, 13], [975781.975926931, 2], [975782.160198662, 36], [975782.345229368, 42], [975782.542602117, 26], [975782.693029786, 17], [975782.875465402, 34], [975783.071021862, 12], [975783.251525894, 36], [975783.549588775, 50], [975783.740998917, 2], [975784.027068133, 54], [975784.270876591, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-14f73a1588bf4bf88e5bf549", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3328, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1905, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975773.722090513, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21600608399603516, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.681138045243593, "done": 975784.286388368, "finish_reason": "length", "first": 975773.939049919, "full_response_s": 10.564097475958988, "last": 975784.270826336, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975773.939049919, 2], [975774.075582762, 7], [975774.220954947, 4], [975774.459596334, 63], [975774.730555943, 10], [975774.917285464, 31], [975775.101464808, 29], [975775.252283969, 13], [975775.447439291, 13], [975775.592643595, 20], [975775.780308327, 14], [975775.960355484, 4], [975776.115837833, 13], [975776.297649156, 21], [975776.49488224, 2], [975776.672901126, 18], [975776.859278501, 29], [975777.102175111, 27], [975777.284741443, 15], [975777.446862661, 11], [975777.623969811, 18], [975777.810081179, 10], [975777.98981995, 31], [975778.142561202, 8], [975778.292375483, 8], [975778.449357242, 8], [975778.59805219, 18], [975778.780827464, 24], [975778.975155587, 25], [975779.123951175, 13], [975779.306938016, 11], [975779.466823356, 16], [975779.617131949, 13], [975779.799199611, 8], [975779.956757554, 12], [975780.13651401, 9], [975780.319603763, 29], [975780.519205029, 22], [975780.699355412, 8], [975780.849388046, 18], [975781.037723246, 18], [975781.222287351, 34], [975781.416449117, 10], [975781.600369158, 14], [975781.788475211, 13], [975781.976528213, 2], [975782.160610877, 36], [975782.344495641, 42], [975782.543887847, 26], [975782.693304884, 17], [975782.876280151, 34], [975783.07136859, 12], [975783.250140934, 36], [975783.549418571, 50], [975783.736753737, 2], [975784.026153787, 54], [975784.270826336, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-db558be469604916839badf9", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3328, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1905, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975773.722290892, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2167590269818902, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.68001379021214, "done": 975784.291322619, "finish_reason": "length", "first": 975773.940377279, "full_response_s": 10.5688241799362, "last": 975784.272624342, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975773.940377279, 2], [975774.074606369, 7], [975774.221542853, 4], [975774.460208447, 63], [975774.729701995, 10], [975774.917413301, 31], [975775.101296828, 29], [975775.253611826, 13], [975775.44546625, 13], [975775.593114416, 20], [975775.77564383, 14], [975775.961752299, 4], [975776.120515578, 13], [975776.29834794, 21], [975776.494796994, 2], [975776.672986068, 18], [975776.85873581, 29], [975777.098434368, 27], [975777.283324421, 15], [975777.44597281, 11], [975777.622732193, 18], [975777.804834712, 10], [975777.992067896, 31], [975778.142906521, 8], [975778.291171255, 8], [975778.448913508, 8], [975778.598806348, 18], [975778.781675812, 24], [975778.971700741, 25], [975779.125810795, 13], [975779.305690797, 11], [975779.468200972, 16], [975779.614726998, 13], [975779.79805327, 8], [975779.953995891, 12], [975780.136367517, 9], [975780.323086321, 29], [975780.517083223, 22], [975780.700339852, 8], [975780.849460332, 18], [975781.037795036, 18], [975781.222486146, 34], [975781.417183068, 10], [975781.600067053, 14], [975781.789474515, 13], [975781.977263459, 2], [975782.162770025, 36], [975782.344998269, 42], [975782.540669187, 26], [975782.692446296, 17], [975782.877138627, 34], [975783.07031799, 12], [975783.250790391, 36], [975783.55012369, 50], [975783.737265293, 2], [975784.029270113, 54], [975784.272624342, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-93d2a0d726e1453690217c76", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3328, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1905, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975773.722498439, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2178788399323821, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.676018052140883, "done": 975784.288521278, "finish_reason": "length", "first": 975773.93940679, "full_response_s": 10.565893961931579, "last": 975784.273326933, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975773.93940679, 2], [975774.07549006, 7], [975774.220683033, 4], [975774.460566423, 63], [975774.7323535, 10], [975774.91705443, 31], [975775.103726674, 29], [975775.251483684, 13], [975775.446787387, 13], [975775.592298131, 20], [975775.774555184, 14], [975775.962978445, 4], [975776.120072292, 13], [975776.297707859, 21], [975776.494427835, 2], [975776.672843751, 18], [975776.858196318, 29], [975777.099588708, 27], [975777.284121138, 15], [975777.445566676, 11], [975777.621105607, 18], [975777.804608157, 10], [975777.990325666, 31], [975778.142026702, 8], [975778.291648188, 8], [975778.450252869, 8], [975778.599060342, 18], [975778.78118784, 24], [975778.973459515, 25], [975779.122189025, 13], [975779.305615711, 11], [975779.469862516, 16], [975779.61707411, 13], [975779.798480588, 8], [975779.955942405, 12], [975780.137853498, 9], [975780.321478167, 29], [975780.518315034, 22], [975780.698603989, 8], [975780.848813163, 18], [975781.037915113, 18], [975781.221177089, 34], [975781.417461589, 10], [975781.600131323, 14], [975781.789067101, 13], [975781.976997658, 2], [975782.161153504, 36], [975782.345852281, 42], [975782.541270213, 26], [975782.69285059, 17], [975782.875188609, 34], [975783.070666014, 12], [975783.251127903, 36], [975783.550564288, 50], [975783.738094137, 2], [975784.025577257, 54], [975784.273326933, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-d0b560453f3f4322a29f8397", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3328, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1905, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975773.722627316, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21677947393618524, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.68185722669381, "done": 975784.288387681, "finish_reason": "length", "first": 975773.939799933, "full_response_s": 10.566629303968512, "last": 975784.271275302, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975773.939799933, 2], [975774.074335688, 7], [975774.221339002, 4], [975774.460299325, 63], [975774.730433114, 10], [975774.916074229, 31], [975775.101780928, 29], [975775.251677856, 13], [975775.445817298, 13], [975775.592393777, 20], [975775.776343254, 14], [975775.960035667, 4], [975776.116082851, 13], [975776.297903502, 21], [975776.493759227, 2], [975776.672767993, 18], [975776.857725946, 29], [975777.101473208, 27], [975777.282443402, 15], [975777.447366697, 11], [975777.619999346, 18], [975777.803472424, 10], [975777.989253867, 31], [975778.141699062, 8], [975778.290025923, 8], [975778.45001057, 8], [975778.598135516, 18], [975778.781288829, 24], [975778.973023126, 25], [975779.123279127, 13], [975779.30549725, 11], [975779.467627897, 16], [975779.616491804, 13], [975779.797498851, 8], [975779.952428856, 12], [975780.135502418, 9], [975780.319324218, 29], [975780.519761543, 22], [975780.701835065, 8], [975780.848418181, 18], [975781.037661103, 18], [975781.221426555, 34], [975781.418312129, 10], [975781.599141219, 14], [975781.788841586, 13], [975781.975719736, 2], [975782.160236117, 36], [975782.34423192, 42], [975782.540407865, 26], [975782.691339106, 17], [975782.875125794, 34], [975783.069910336, 12], [975783.2505671, 36], [975783.551541833, 50], [975783.736949748, 2], [975784.025485659, 54], [975784.271275302, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-966490a102cb414a880e43df", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3327, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1905, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975773.721758377, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21804155595600605, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.683249772573138, "done": 975784.29013844, "finish_reason": "length", "first": 975773.940432126, "full_response_s": 10.568006407935172, "last": 975784.271324628, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975773.940432126, 2], [975774.0741539, 7], [975774.220339329, 4], [975774.459366403, 63], [975774.729866807, 10], [975774.915804683, 31], [975775.103996939, 29], [975775.251416134, 13], [975775.446714141, 13], [975775.592180726, 20], [975775.775926304, 14], [975775.959510528, 4], [975776.120619831, 13], [975776.297517079, 21], [975776.494209216, 2], [975776.67372093, 18], [975776.857801384, 29], [975777.097491366, 27], [975777.286109811, 15], [975777.444481758, 11], [975777.620614515, 18], [975777.80618092, 10], [975777.995501335, 31], [975778.144535187, 8], [975778.29087891, 8], [975778.449493223, 8], [975778.5991445, 18], [975778.780994084, 24], [975778.972615983, 25], [975779.121742572, 13], [975779.304835777, 11], [975779.469271826, 16], [975779.616101493, 13], [975779.798287489, 8], [975779.952559253, 12], [975780.135362357, 9], [975780.31863865, 29], [975780.520509366, 22], [975780.700130993, 8], [975780.851119717, 18], [975781.036474379, 18], [975781.221843474, 34], [975781.416365775, 10], [975781.599627367, 14], [975781.788033334, 13], [975781.975841669, 2], [975782.160659467, 36], [975782.346537337, 42], [975782.542344795, 26], [975782.691950836, 17], [975782.876393844, 34], [975783.072270824, 12], [975783.250642602, 36], [975783.550272663, 50], [975783.73670401, 2], [975784.028436485, 54], [975784.271324628, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-13778d20c4cb4e5b88192b9a", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3327, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1905, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975773.722132032, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21830009401310235, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.686101019384147, "done": 975784.291266669, "finish_reason": "length", "first": 975773.940752086, "full_response_s": 10.569434854085557, "last": 975784.270451369, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975773.940752086, 2], [975774.074796157, 7], [975774.22181659, 4], [975774.461399059, 63], [975774.733341972, 10], [975774.915956664, 31], [975775.103156767, 29], [975775.251346231, 13], [975775.445618183, 13], [975775.591961739, 20], [975775.774953415, 14], [975775.958759074, 4], [975776.120193665, 13], [975776.29857019, 21], [975776.494645606, 2], [975776.673136112, 18], [975776.859584605, 29], [975777.099341642, 27], [975777.284556487, 15], [975777.446308226, 11], [975777.619583868, 18], [975777.804193527, 10], [975777.991544997, 31], [975778.146081838, 8], [975778.291273221, 8], [975778.449852174, 8], [975778.597683799, 18], [975778.780452433, 24], [975778.971026645, 25], [975779.121950535, 13], [975779.304679157, 11], [975779.466647921, 16], [975779.615322392, 13], [975779.79712846, 8], [975779.953097289, 12], [975780.135622271, 9], [975780.318812998, 29], [975780.520276123, 22], [975780.699431362, 8], [975780.848778492, 18], [975781.036054501, 18], [975781.22241498, 34], [975781.416294913, 10], [975781.599537081, 14], [975781.78836979, 13], [975781.976641586, 2], [975782.160398514, 36], [975782.34614221, 42], [975782.542134608, 26], [975782.693379618, 17], [975782.875673637, 34], [975783.07168159, 12], [975783.250312722, 36], [975783.550499521, 50], [975783.736555118, 2], [975784.025638375, 54], [975784.270451369, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-f715ba4899db458b99add999", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3327, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1905, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975773.721831815, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21892027102876455, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.68144197844962, "done": 975784.287656978, "finish_reason": "length", "first": 975773.939102541, "full_response_s": 10.565672414959408, "last": 975784.27075173, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975773.939102541, 2], [975774.073831508, 7], [975774.220869749, 4], [975774.459724475, 63], [975774.730665428, 10], [975774.917663983, 31], [975775.101391913, 29], [975775.254744935, 13], [975775.446297527, 13], [975775.594431072, 20], [975775.778705021, 14], [975775.959028123, 4], [975776.119061196, 13], [975776.297581494, 21], [975776.494100611, 2], [975776.673064866, 18], [975776.858931581, 29], [975777.098562685, 27], [975777.283419411, 15], [975777.444854261, 11], [975777.62250815, 18], [975777.804915126, 10], [975777.99065793, 31], [975778.142230457, 8], [975778.290389962, 8], [975778.451946556, 8], [975778.598542546, 18], [975778.780897943, 24], [975778.971405772, 25], [975779.126122372, 13], [975779.305979526, 11], [975779.467137957, 16], [975779.615194283, 13], [975779.797646224, 8], [975779.955098185, 12], [975780.136809427, 9], [975780.319734, 29], [975780.520036129, 22], [975780.699572719, 8], [975780.850329463, 18], [975781.038390414, 18], [975781.222012845, 34], [975781.418945938, 10], [975781.599244384, 14], [975781.788642551, 13], [975781.975582683, 2], [975782.159929165, 36], [975782.345505265, 42], [975782.540071073, 26], [975782.69218187, 17], [975782.876719373, 34], [975783.069606007, 12], [975783.250870597, 36], [975783.552595792, 50], [975783.737126528, 2], [975784.025354254, 54], [975784.27075173, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-518e9fbf372641d0ad7357c1", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3328, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1905, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975773.721984563, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2171179779106751, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.67783108713726, "done": 975784.288773096, "finish_reason": "length", "first": 975773.938386942, "full_response_s": 10.566889698035084, "last": 975784.271547871, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975773.938386942, 2], [975774.07390229, 7], [975774.221617731, 4], [975774.45915444, 63], [975774.729790505, 10], [975774.916160787, 31], [975775.10111104, 29], [975775.251625361, 13], [975775.447557305, 13], [975775.592244548, 20], [975775.775075572, 14], [975775.959346212, 4], [975776.115679613, 13], [975776.297113489, 21], [975776.493957286, 2], [975776.673306588, 18], [975776.858625156, 29], [975777.097742688, 27], [975777.283971717, 15], [975777.446527357, 11], [975777.619800022, 18], [975777.803776273, 10], [975777.989577091, 31], [975778.142651663, 8], [975778.290100257, 8], [975778.449131151, 8], [975778.597428013, 18], [975778.782715979, 24], [975778.972358917, 25], [975779.12157104, 13], [975779.304591639, 11], [975779.466929722, 16], [975779.615537954, 13], [975779.797564674, 8], [975779.954072673, 12], [975780.140530139, 9], [975780.323382554, 29], [975780.518591443, 22], [975780.698900398, 8], [975780.84902127, 18], [975781.038311056, 18], [975781.222373669, 34], [975781.415675439, 10], [975781.599981727, 14], [975781.788088356, 13], [975781.981298548, 2], [975782.162223894, 36], [975782.346738228, 42], [975782.541124472, 26], [975782.692138351, 17], [975782.877963375, 34], [975783.070942728, 12], [975783.251984619, 36], [975783.550619438, 50], [975783.737438985, 2], [975784.025698774, 54], [975784.271547871, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-ca688eb498ab48fbb7695c31", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3328, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1905, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975773.721883398, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2165035440120846, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.67866353280003, "done": 975784.290922037, "finish_reason": "length", "first": 975773.939459253, "full_response_s": 10.569543682970107, "last": 975784.27227163, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975773.939459253, 2], [975774.076874011, 7], [975774.221698513, 4], [975774.459289205, 63], [975774.733438802, 10], [975774.916663095, 31], [975775.101899165, 29], [975775.254879347, 13], [975775.445980462, 13], [975775.593953004, 20], [975775.780215386, 14], [975775.96024315, 4], [975776.115997621, 13], [975776.30251864, 21], [975776.496728804, 2], [975776.673765809, 18], [975776.85788423, 29], [975777.099421688, 27], [975777.284622694, 15], [975777.447933708, 11], [975777.622094336, 18], [975777.808794634, 10], [975777.99124766, 31], [975778.141876578, 8], [975778.291581902, 8], [975778.449580741, 8], [975778.598622864, 18], [975778.780676828, 24], [975778.970828474, 25], [975779.124643287, 13], [975779.3054041, 11], [975779.467762534, 16], [975779.61596508, 13], [975779.797260361, 8], [975779.954624196, 12], [975780.140259793, 9], [975780.320455215, 29], [975780.517242803, 22], [975780.701684508, 8], [975780.848656399, 18], [975781.036283792, 18], [975781.222330246, 34], [975781.417611874, 10], [975781.600188426, 14], [975781.788257568, 13], [975781.97603568, 2], [975782.161251118, 36], [975782.344927439, 42], [975782.540802768, 26], [975782.691481023, 17], [975782.877321982, 34], [975783.070398996, 12], [975783.250366769, 36], [975783.549158497, 50], [975783.73705733, 2], [975784.028874491, 54], [975784.27227163, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-b0d92031c01645149c7e1b2f", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3327, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.1905, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975773.721378354, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.21808089897967875, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.61621881352761, "done": 975794.907064235, "finish_reason": "length", "first": 975784.534637377, "full_response_s": 10.598570261965506, "last": 975794.893661317, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975784.534637377, 2], [975784.672835564, 7], [975784.821147961, 4], [975785.0579395, 63], [975785.328552833, 10], [975785.521985941, 31], [975785.706379439, 29], [975785.854337735, 13], [975786.036459689, 13], [975786.18867763, 20], [975786.374416172, 14], [975786.565035302, 4], [975786.713422853, 13], [975786.895778388, 21], [975787.085845823, 2], [975787.266061361, 18], [975787.460946522, 29], [975787.697719926, 27], [975787.884601229, 15], [975788.036924213, 11], [975788.217417892, 18], [975788.407678557, 10], [975788.596013603, 31], [975788.747381346, 8], [975788.897411617, 8], [975789.051823498, 8], [975789.197822329, 18], [975789.383584463, 24], [975789.576305601, 25], [975789.724720888, 13], [975789.91040229, 11], [975790.061948001, 16], [975790.210907053, 13], [975790.407989003, 8], [975790.562314137, 12], [975790.742826094, 9], [975790.933777791, 29], [975791.122377865, 22], [975791.30836288, 8], [975791.468070306, 18], [975791.654306419, 18], [975791.836344008, 34], [975792.024949428, 10], [975792.216549851, 14], [975792.406351051, 13], [975792.597771926, 2], [975792.776527002, 36], [975792.964420314, 42], [975793.151864293, 26], [975793.302309878, 17], [975793.496142027, 34], [975793.682044346, 12], [975793.874676844, 36], [975794.162754864, 50], [975794.352807681, 2], [975794.646772953, 54], [975794.893661317, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-e74578173c104222913083eb", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3595, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2021, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975784.308493973, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.22614340402651578, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.613537172437763, "done": 975794.910484666, "finish_reason": "length", "first": 975784.535218387, "full_response_s": 10.60238409100566, "last": 975794.895370941, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975784.535218387, 2], [975784.671835684, 7], [975784.821743003, 4], [975785.060331236, 63], [975785.330463683, 10], [975785.524918416, 31], [975785.706906962, 29], [975785.855225458, 13], [975786.037712876, 13], [975786.187316831, 20], [975786.374620951, 14], [975786.564823435, 4], [975786.714869475, 13], [975786.895716358, 21], [975787.084582732, 2], [975787.267054938, 18], [975787.45849818, 29], [975787.698787069, 27], [975787.885019875, 15], [975788.038157351, 11], [975788.216880001, 18], [975788.411349398, 10], [975788.595632908, 31], [975788.746762016, 8], [975788.896783088, 8], [975789.051642798, 8], [975789.198251199, 18], [975789.381468225, 24], [975789.577760927, 25], [975789.725709072, 13], [975789.910162311, 11], [975790.060387221, 16], [975790.212464744, 13], [975790.40831554, 8], [975790.561046903, 12], [975790.744269836, 9], [975790.934363713, 29], [975791.12378548, 22], [975791.30821026, 8], [975791.466716994, 18], [975791.652076919, 18], [975791.837672408, 34], [975792.022996818, 10], [975792.214816563, 14], [975792.408225119, 13], [975792.594956904, 2], [975792.777597777, 36], [975792.963738042, 42], [975793.153206374, 26], [975793.303353565, 17], [975793.498277192, 34], [975793.68263366, 12], [975793.873019171, 36], [975794.16263381, 50], [975794.353959814, 2], [975794.646444353, 54], [975794.895370941, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-27eff70f321a4786aeef3862", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3596, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2021, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975784.308100575, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.22711781202815473, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.612725192314652, "done": 975794.911300519, "finish_reason": "length", "first": 975784.533855171, "full_response_s": 10.603277142974548, "last": 975794.894349509, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975784.533855171, 2], [975784.672718095, 7], [975784.820490264, 4], [975785.057225773, 63], [975785.328236072, 10], [975785.523874744, 31], [975785.704765541, 29], [975785.854982151, 13], [975786.037660189, 13], [975786.188089228, 20], [975786.374276959, 14], [975786.563826466, 4], [975786.712975024, 13], [975786.896909002, 21], [975787.084275652, 2], [975787.265594636, 18], [975787.458201435, 29], [975787.698554722, 27], [975787.884076361, 15], [975788.036623212, 11], [975788.216248655, 18], [975788.409866889, 10], [975788.593547485, 31], [975788.746141183, 8], [975788.897080969, 8], [975789.050372444, 8], [975789.19717676, 18], [975789.382335709, 24], [975789.575092318, 25], [975789.724362528, 13], [975789.909617508, 11], [975790.06163404, 16], [975790.212690819, 13], [975790.406791128, 8], [975790.561681256, 12], [975790.742600675, 9], [975790.933443847, 29], [975791.122472631, 22], [975791.306700951, 8], [975791.467521519, 18], [975791.65095749, 18], [975791.835342655, 34], [975792.02181091, 10], [975792.215553634, 14], [975792.407258758, 13], [975792.594832171, 2], [975792.776572137, 36], [975792.966263775, 42], [975793.15027753, 26], [975793.300542879, 17], [975793.495219744, 34], [975793.680988131, 12], [975793.871772593, 36], [975794.16351139, 50], [975794.352174783, 2], [975794.648501345, 54], [975794.894349509, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-cbbb727da9274cc19c4a1989", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3594, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2021, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975784.308023376, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.22583179490175098, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.616624607704374, "done": 975794.909372628, "finish_reason": "length", "first": 975784.535735879, "full_response_s": 10.600680819014087, "last": 975794.894589055, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975784.535735879, 2], [975784.672953929, 7], [975784.821682972, 4], [975785.057339594, 63], [975785.328694573, 10], [975785.522917887, 31], [975785.705143436, 29], [975785.855170483, 13], [975786.037201784, 13], [975786.188487507, 20], [975786.373737084, 14], [975786.564346646, 4], [975786.713539987, 13], [975786.895325215, 21], [975787.085630468, 2], [975787.265698202, 18], [975787.459345888, 29], [975787.697626152, 27], [975787.885389322, 15], [975788.038735402, 11], [975788.218084708, 18], [975788.408651958, 10], [975788.595552846, 31], [975788.745119543, 8], [975788.898401049, 8], [975789.052272767, 8], [975789.198758771, 18], [975789.381353956, 24], [975789.576250051, 25], [975789.724969458, 13], [975789.913217567, 11], [975790.061081061, 16], [975790.212807168, 13], [975790.408146136, 8], [975790.561424286, 12], [975790.744577237, 9], [975790.935551734, 29], [975791.124148847, 22], [975791.310132919, 8], [975791.46651735, 18], [975791.651828637, 18], [975791.83606067, 34], [975792.022462415, 10], [975792.214939568, 14], [975792.406259805, 13], [975792.594033757, 2], [975792.775465971, 36], [975792.962775649, 42], [975793.152961883, 26], [975793.301240079, 17], [975793.496852938, 34], [975793.681310763, 12], [975793.872219206, 36], [975794.165221878, 50], [975794.352519591, 2], [975794.647045043, 54], [975794.894589055, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-afb72c40a626480a8ab79451", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3596, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2021, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975784.308691809, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.227044070023112, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.612133099340188, "done": 975794.910985743, "finish_reason": "length", "first": 975784.53550518, "full_response_s": 10.601805242011324, "last": 975794.89624876, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975784.53550518, 2], [975784.672893563, 7], [975784.82098934, 4], [975785.058834871, 63], [975785.331283584, 10], [975785.522854016, 31], [975785.706196291, 29], [975785.854117356, 13], [975786.03752072, 13], [975786.188577793, 20], [975786.373837129, 14], [975786.564500819, 4], [975786.713361527, 13], [975786.896846443, 21], [975787.084404257, 2], [975787.266559798, 18], [975787.458574626, 29], [975787.69790589, 27], [975787.885278205, 15], [975788.038515311, 11], [975788.216798851, 18], [975788.409990406, 10], [975788.595796328, 31], [975788.749217894, 8], [975788.899290932, 8], [975789.052537881, 8], [975789.197304917, 18], [975789.382995501, 24], [975789.575714895, 25], [975789.725196701, 13], [975789.911305516, 11], [975790.062690063, 16], [975790.212544262, 13], [975790.407702242, 8], [975790.561774998, 12], [975790.744923309, 9], [975790.934657867, 29], [975791.123499663, 22], [975791.309018257, 8], [975791.466458216, 18], [975791.651108062, 18], [975791.835763381, 34], [975792.023490519, 10], [975792.216497196, 14], [975792.406564454, 13], [975792.595033014, 2], [975792.777657935, 36], [975792.964123329, 42], [975793.153702762, 26], [975793.30214353, 17], [975793.496716477, 34], [975793.683350299, 12], [975793.873451145, 36], [975794.162902828, 50], [975794.352306268, 2], [975794.649062708, 54], [975794.89624876, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-0f0ddb6ed92647b4849f5bea", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3597, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2021, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975784.309180501, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.22632467898074538, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.61331301859499, "done": 975794.908484041, "finish_reason": "length", "first": 975784.534442085, "full_response_s": 10.59995430894196, "last": 975794.894688989, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975784.534442085, 2], [975784.673015544, 7], [975784.821444482, 4], [975785.057415161, 63], [975785.328057372, 10], [975785.522696228, 31], [975785.705351399, 29], [975785.855041446, 13], [975786.037847433, 13], [975786.186352917, 20], [975786.373947335, 14], [975786.564422324, 4], [975786.713160684, 13], [975786.896193338, 21], [975787.087328412, 2], [975787.267224886, 18], [975787.460886555, 29], [975787.696989095, 27], [975787.885337708, 15], [975788.037771377, 11], [975788.218892865, 18], [975788.408486634, 10], [975788.595029355, 31], [975788.747450976, 8], [975788.897146023, 8], [975789.0523839, 8], [975789.196859504, 18], [975789.381593134, 24], [975789.576496861, 25], [975789.725797502, 13], [975789.913029188, 11], [975790.060458916, 16], [975790.211947988, 13], [975790.407850607, 8], [975790.560263497, 12], [975790.74359014, 9], [975790.933949035, 29], [975791.122107823, 22], [975791.306973665, 8], [975791.468680515, 18], [975791.65190054, 18], [975791.835543338, 34], [975792.021926347, 10], [975792.215643072, 14], [975792.406021027, 13], [975792.596063614, 2], [975792.776009958, 36], [975792.964276141, 42], [975793.15164545, 26], [975793.301059107, 17], [975793.495868065, 34], [975793.681469992, 12], [975793.872757129, 36], [975794.164540454, 50], [975794.353153576, 2], [975794.648901927, 54], [975794.894688989, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-603a0d052fe8405b9e0bb306", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3596, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2021, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975784.308529732, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.22591235290747136, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.61090540747008, "done": 975794.909867753, "finish_reason": "length", "first": 975784.534580642, "full_response_s": 10.601671021082439, "last": 975794.895841058, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975784.534580642, 2], [975784.673272242, 7], [975784.821616158, 4], [975785.058181638, 63], [975785.327896992, 10], [975785.52347125, 31], [975785.707037023, 29], [975785.857240434, 13], [975786.03701582, 13], [975786.187949856, 20], [975786.375842266, 14], [975786.56367207, 4], [975786.712883506, 13], [975786.895464812, 21], [975787.084995075, 2], [975787.266730786, 18], [975787.458146316, 29], [975787.698354519, 27], [975787.884406081, 15], [975788.037872798, 11], [975788.216505433, 18], [975788.409922424, 10], [975788.593657195, 31], [975788.746850814, 8], [975788.896458503, 8], [975789.05061703, 8], [975789.197043499, 18], [975789.383469026, 24], [975789.575486117, 25], [975789.724049592, 13], [975789.911879535, 11], [975790.061491323, 16], [975790.21069837, 13], [975790.406556509, 8], [975790.560392438, 12], [975790.743994803, 9], [975790.933582228, 29], [975791.122230908, 22], [975791.30708891, 8], [975791.466307147, 18], [975791.650516812, 18], [975791.835654568, 34], [975792.023055713, 10], [975792.216068358, 14], [975792.40588391, 13], [975792.593916928, 2], [975792.775387013, 36], [975792.962455112, 42], [975793.15062317, 26], [975793.301119858, 17], [975793.498993352, 34], [975793.680604268, 12], [975793.872861335, 36], [975794.162555412, 50], [975794.352583702, 2], [975794.646546287, 54], [975794.895841058, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-f6628c7f7ca7410ea022d056", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3595, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2021, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975784.308196732, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.22638391004875302, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.616537045164964, "done": 975794.91170523, "finish_reason": "length", "first": 975784.534895915, "full_response_s": 10.60345259506721, "last": 975794.893785938, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975784.534895915, 2], [975784.672526916, 7], [975784.821891335, 4], [975785.05695434, 63], [975785.328375829, 10], [975785.524361373, 31], [975785.70496216, 29], [975785.854682975, 13], [975786.036660373, 13], [975786.18817193, 20], [975786.373623951, 14], [975786.564681374, 4], [975786.713282585, 13], [975786.895027734, 21], [975787.086236981, 2], [975787.267327555, 18], [975787.458283353, 29], [975787.697364862, 27], [975787.884963876, 15], [975788.037010451, 11], [975788.216572792, 18], [975788.409050317, 10], [975788.594092513, 31], [975788.744703521, 8], [975788.896826911, 8], [975789.05316097, 8], [975789.199440131, 18], [975789.382928255, 24], [975789.575290569, 25], [975789.725677617, 13], [975789.911954653, 11], [975790.0601115, 16], [975790.212110512, 13], [975790.40642384, 8], [975790.561841508, 12], [975790.74299617, 9], [975790.934031705, 29], [975791.12342248, 22], [975791.307274442, 8], [975791.467199286, 18], [975791.6527498, 18], [975791.836111101, 34], [975792.022527437, 10], [975792.214650215, 14], [975792.407400994, 13], [975792.594207481, 2], [975792.775887737, 36], [975792.962595861, 42], [975793.150853677, 26], [975793.301706196, 17], [975793.496208953, 34], [975793.683497896, 12], [975793.873628053, 36], [975794.164276572, 50], [975794.354342701, 2], [975794.646841976, 54], [975794.893785938, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-5783612507064dde96864e7a", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3595, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2021, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975784.308252635, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2266432800097391, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.62229758558516, "done": 975794.910361709, "finish_reason": "length", "first": 975784.537057192, "full_response_s": 10.601278629968874, "last": 975794.893523688, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975784.537057192, 2], [975784.673213123, 7], [975784.821502784, 4], [975785.060397618, 63], [975785.329413532, 10], [975785.52337162, 31], [975785.704465692, 29], [975785.855579497, 13], [975786.03849137, 13], [975786.186475986, 20], [975786.374763476, 14], [975786.568556243, 4], [975786.713484372, 13], [975786.895595913, 21], [975787.08595982, 2], [975787.266288796, 18], [975787.458069662, 29], [975787.69804787, 27], [975787.88465078, 15], [975788.037520807, 11], [975788.217692813, 18], [975788.408957599, 10], [975788.596613445, 31], [975788.74626358, 8], [975788.897234837, 8], [975789.052049092, 8], [975789.197937686, 18], [975789.382403787, 24], [975789.577314522, 25], [975789.726561628, 13], [975789.912068074, 11], [975790.061425293, 16], [975790.210484407, 13], [975790.405979643, 8], [975790.560140636, 12], [975790.743396433, 9], [975790.933871789, 29], [975791.123224053, 22], [975791.307851548, 8], [975791.468886175, 18], [975791.651204188, 18], [975791.837989793, 34], [975792.02538801, 10], [975792.215478308, 14], [975792.407332228, 13], [975792.595419917, 2], [975792.777065197, 36], [975792.963100057, 42], [975793.152702561, 26], [975793.304914536, 17], [975793.495696165, 34], [975793.680367425, 12], [975793.874381779, 36], [975794.164078976, 50], [975794.355171881, 2], [975794.648666733, 54], [975794.893523688, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-f9c3b5b5797c464ca0b93eee", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3597, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2021, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975784.309083079, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.22797411296050996, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.615599252344115, "done": 975794.910427788, "finish_reason": "length", "first": 975784.535159636, "full_response_s": 10.602516505052336, "last": 975794.894444307, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975784.535159636, 2], [975784.673075991, 7], [975784.821072858, 4], [975785.057874174, 63], [975785.328484866, 10], [975785.525645102, 31], [975785.705409798, 29], [975785.854780364, 13], [975786.038574264, 13], [975786.186279671, 20], [975786.375636191, 14], [975786.564123019, 4], [975786.714118005, 13], [975786.896252633, 21], [975787.086420433, 2], [975787.265748185, 18], [975787.459928802, 29], [975787.699177396, 27], [975787.886173288, 15], [975788.036803383, 11], [975788.216680597, 18], [975788.409221465, 10], [975788.593847878, 31], [975788.743997697, 8], [975788.896578916, 8], [975789.05086272, 8], [975789.20034419, 18], [975789.381670188, 24], [975789.575201195, 25], [975789.724156021, 13], [975789.911530359, 11], [975790.060237865, 16], [975790.212880734, 13], [975790.406489135, 8], [975790.560965881, 12], [975790.744645859, 9], [975790.933698577, 29], [975791.122725761, 22], [975791.307372951, 8], [975791.46569345, 18], [975791.652243636, 18], [975791.835955889, 34], [975792.022417504, 10], [975792.214277728, 14], [975792.406800145, 13], [975792.594499859, 2], [975792.775838426, 36], [975792.962334427, 42], [975793.151182885, 26], [975793.303431803, 17], [975793.496420164, 34], [975793.680923844, 12], [975793.871511671, 36], [975794.163953603, 50], [975794.353651389, 2], [975794.647198431, 54], [975794.894444307, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-afa692c3cf6e4524b2f19821", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3595, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2021, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975784.307911283, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.22724835306871682, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.612240432835016, "done": 975794.910848466, "finish_reason": "length", "first": 975784.534089198, "full_response_s": 10.602484458009712, "last": 975794.894787595, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975784.534089198, 2], [975784.672776894, 7], [975784.821828441, 4], [975785.057562501, 63], [975785.328834794, 10], [975785.526814531, 31], [975785.705597489, 29], [975785.85452141, 13], [975786.036717331, 13], [975786.188762972, 20], [975786.37390156, 14], [975786.564047293, 4], [975786.713864059, 13], [975786.895885554, 21], [975787.086950564, 2], [975787.266211406, 18], [975787.459086742, 29], [975787.699389791, 27], [975787.885554294, 15], [975788.037151183, 11], [975788.218358126, 18], [975788.409548689, 10], [975788.593756408, 31], [975788.74591874, 8], [975788.898332235, 8], [975789.051189609, 8], [975789.197488753, 18], [975789.384195985, 24], [975789.575545075, 25], [975789.723903979, 13], [975789.909476711, 11], [975790.06054037, 16], [975790.212951517, 13], [975790.406912885, 8], [975790.562047039, 12], [975790.743486511, 9], [975790.934129607, 29], [975791.122955515, 22], [975791.307208347, 8], [975791.466124496, 18], [975791.65172032, 18], [975791.836442693, 34], [975792.02323926, 10], [975792.215136332, 14], [975792.407146824, 13], [975792.597057734, 2], [975792.775708413, 36], [975792.962701218, 42], [975793.151998738, 26], [975793.302606655, 17], [975793.498371174, 34], [975793.68237117, 12], [975793.872304388, 36], [975794.163335186, 50], [975794.354839441, 2], [975794.650799867, 54], [975794.894787595, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-e630f20793b14d49b81c9856", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3597, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2021, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975784.308364008, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.22572519001550972, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.614816447067366, "done": 975794.907389251, "finish_reason": "length", "first": 975784.533643992, "full_response_s": 10.598578245029785, "last": 975794.893258111, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975784.533643992, 2], [975784.673140693, 7], [975784.820415098, 4], [975785.057816223, 63], [975785.33117605, 10], [975785.524202048, 31], [975785.70525041, 29], [975785.854631248, 13], [975786.037448658, 13], [975786.186791227, 20], [975786.374498986, 14], [975786.568408038, 4], [975786.716066791, 13], [975786.896313448, 21], [975787.088194903, 2], [975787.267643596, 18], [975787.461236115, 29], [975787.69889321, 27], [975787.885959709, 15], [975788.037416937, 11], [975788.221200363, 18], [975788.412063525, 10], [975788.59515012, 31], [975788.747589661, 8], [975788.899359075, 8], [975789.05113065, 8], [975789.19854492, 18], [975789.382236399, 24], [975789.577153645, 25], [975789.725256491, 13], [975789.910531311, 11], [975790.060781292, 16], [975790.212028834, 13], [975790.406697866, 8], [975790.560592082, 12], [975790.74591095, 9], [975790.935923709, 29], [975791.122657586, 22], [975791.308891108, 8], [975791.466938684, 18], [975791.652813862, 18], [975791.83570847, 34], [975792.024105544, 10], [975792.214490155, 14], [975792.406863935, 13], [975792.596635584, 2], [975792.776472939, 36], [975792.963451377, 42], [975793.150701792, 26], [975793.302063324, 17], [975793.497395645, 34], [975793.680862774, 12], [975793.873562919, 36], [975794.165320083, 50], [975794.352726594, 2], [975794.647438538, 54], [975794.893258111, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-1133a894ecef403480013a21", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3596, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2021, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975784.308811006, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.22483298601582646, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.61063467363278, "done": 975794.90148147, "finish_reason": "length", "first": 975784.533687319, "full_response_s": 10.59316242102068, "last": 975794.895061716, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975784.533687319, 2], [975784.672465125, 7], [975784.820904494, 4], [975785.05676972, 63], [975785.328297095, 10], [975785.522494569, 31], [975785.705874523, 29], [975785.856490324, 13], [975786.036587974, 13], [975786.187787859, 20], [975786.373540481, 14], [975786.564281144, 4], [975786.714039895, 13], [975786.89605331, 21], [975787.085557269, 2], [975787.266528198, 18], [975787.457953873, 29], [975787.697960416, 27], [975787.88454619, 15], [975788.036499119, 11], [975788.216971518, 18], [975788.407827225, 10], [975788.594483495, 31], [975788.746944876, 8], [975788.897601724, 8], [975789.051366117, 8], [975789.197638957, 18], [975789.381067739, 24], [975789.575990201, 25], [975789.726090775, 13], [975789.91006441, 11], [975790.060740733, 16], [975790.211201926, 13], [975790.406264836, 8], [975790.560901066, 12], [975790.74332621, 9], [975790.934269492, 29], [975791.122598532, 22], [975791.307715583, 8], [975791.467262197, 18], [975791.651355624, 18], [975791.83691081, 34], [975792.023710401, 10], [975792.213970103, 14], [975792.40706721, 13], [975792.59553057, 2], [975792.775243512, 36], [975792.96324159, 42], [975793.150982522, 26], [975793.301506281, 17], [975793.498176443, 34], [975793.68025482, 12], [975793.872523199, 36], [975794.163435072, 50], [975794.354444378, 2], [975794.647559959, 54], [975794.895061716, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-83398afa154b420992c88c09", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3595, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2021, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975784.308319049, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2253682700684294, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.611616741631355, "done": 975794.911665855, "finish_reason": "length", "first": 975784.535818021, "full_response_s": 10.60294516698923, "last": 975794.896778972, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975784.535818021, 2], [975784.672161964, 7], [975784.821569359, 4], [975785.060109577, 63], [975785.328649214, 10], [975785.521890359, 31], [975785.704828499, 29], [975785.854559937, 13], [975786.038184001, 13], [975786.186995702, 20], [975786.375285959, 14], [975786.564191258, 4], [975786.713746942, 13], [975786.895534042, 21], [975787.084919428, 2], [975787.266481719, 18], [975787.45874243, 29], [975787.697526107, 27], [975787.88471473, 15], [975788.037360426, 11], [975788.217516354, 18], [975788.410439852, 10], [975788.594602341, 31], [975788.747526126, 8], [975788.898875278, 8], [975789.050757459, 8], [975789.199174409, 18], [975789.381181688, 24], [975789.57749047, 25], [975789.72860166, 13], [975789.910834295, 11], [975790.063424254, 16], [975790.211608076, 13], [975790.407116032, 8], [975790.561323872, 12], [975790.745074393, 9], [975790.935845103, 29], [975791.123572589, 22], [975791.307907115, 8], [975791.465962259, 18], [975791.652164261, 18], [975791.836290297, 34], [975792.02223498, 10], [975792.216709863, 14], [975792.406484104, 13], [975792.595719862, 2], [975792.778522155, 36], [975792.963590301, 42], [975793.152277643, 26], [975793.305547162, 17], [975793.495502922, 34], [975793.680763144, 12], [975793.871683731, 36], [975794.165737882, 50], [975794.352963677, 2], [975794.647118769, 54], [975794.896778972, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-012edd7f504641ec94222ebf", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3596, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2021, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975784.308720688, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2270973330596462, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.607679780592733, "done": 975794.910134466, "finish_reason": "length", "first": 975784.534034351, "full_response_s": 10.601565310033038, "last": 975794.896652943, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975784.534034351, 2], [975784.672383591, 7], [975784.820255102, 4], [975785.057151615, 63], [975785.330111388, 10], [975785.521737899, 31], [975785.704896866, 29], [975785.857292977, 13], [975786.03727719, 13], [975786.187229505, 20], [975786.373461042, 14], [975786.563917392, 4], [975786.713963257, 13], [975786.895663239, 21], [975787.085713426, 2], [975787.266921997, 18], [975787.460173436, 29], [975787.698473028, 27], [975787.883931229, 15], [975788.038688139, 11], [975788.21733527, 18], [975788.408388572, 10], [975788.594662355, 31], [975788.747016778, 8], [975788.898660195, 8], [975789.052125555, 8], [975789.200444059, 18], [975789.384258975, 24], [975789.575388583, 25], [975789.724787926, 13], [975789.909731089, 11], [975790.060338263, 16], [975790.210619956, 13], [975790.40719275, 8], [975790.561503388, 12], [975790.743859686, 9], [975790.934429728, 29], [975791.123042457, 22], [975791.309610307, 8], [975791.466390425, 18], [975791.650837493, 18], [975791.83656381, 34], [975792.023609396, 10], [975792.216277729, 14], [975792.406950973, 13], [975792.595257713, 2], [975792.775784731, 36], [975792.962635892, 42], [975793.154413881, 26], [975793.302505745, 17], [975793.495951663, 34], [975793.681656307, 12], [975793.872024699, 36], [975794.166293548, 50], [975794.354769011, 2], [975794.647268894, 54], [975794.896652943, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-caa89f61e7e5480d841aa053", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3596, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2021, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975784.308569156, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.22546519502066076, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 13, "case_id": null, "complete": true, "decode_tps": 24.613235251432, "done": 975794.911976695, "finish_reason": "length", "first": 975784.533591274, "full_response_s": 10.604149265913293, "last": 975794.893870912, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975784.533591274, 2], [975784.672078094, 7], [975784.820081106, 4], [975785.057084832, 63], [975785.328150426, 10], [975785.522103986, 31], [975785.704548906, 29], [975785.855292672, 13], [975786.036817361, 13], [975786.186114043, 20], [975786.375467299, 14], [975786.565768677, 4], [975786.713075134, 13], [975786.896123932, 21], [975787.085074625, 2], [975787.265804887, 18], [975787.459432478, 29], [975787.697107397, 27], [975787.884470576, 15], [975788.037232797, 11], [975788.216417211, 18], [975788.408300846, 10], [975788.594927613, 31], [975788.744141518, 8], [975788.896646515, 8], [975789.051035116, 8], [975789.201084828, 18], [975789.381886215, 24], [975789.579032833, 25], [975789.72555506, 13], [975789.911155328, 11], [975790.064320777, 16], [975790.211291012, 13], [975790.408385842, 8], [975790.561585226, 12], [975790.744127104, 9], [975790.93529398, 29], [975791.123720105, 22], [975791.307799581, 8], [975791.467108536, 18], [975791.652675177, 18], [975791.836975209, 34], [975792.023173342, 10], [975792.216385326, 14], [975792.407491168, 13], [975792.594144491, 2], [975792.776642839, 36], [975792.963944437, 42], [975793.150521589, 26], [975793.304023357, 17], [975793.496295207, 34], [975793.681832751, 12], [975793.873907694, 36], [975794.165617916, 50], [975794.352878447, 2], [975794.647628981, 54], [975794.893870912, 2]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-e1ecf8ef873843e3a024e09f", "runtime": {"accepted": 199, "cached": 13, "decode_s": 10.3595, "drafted": 352, "drafts": true, "min_rows": 4, "prefill_s": 0.2021, "rounds": 56, "token_sha": "2b28aa2108de"}, "seed": 1234, "sent": 975784.307827429, "speculative": {}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.22576384502463043, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 13}, "total_tokens": 270}, "work": {"accepted": 199, "drafted": 352, "rounds": 56}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "python", "burst": null, "phase": "uncached_first_use", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 50.11002847610702, "done": 975800.140730909, "finish_reason": "length", "first": 975795.051502621, "full_response_s": 5.211056388914585, "last": 975800.140304359, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975795.051502621, 3], [975795.133487945, 26], [975795.216290706, 15], [975795.297651869, 34], [975795.379685384, 21], [975795.466514114, 25], [975795.55131694, 14], [975795.632118484, 14], [975795.712639123, 18], [975795.794028093, 26], [975795.875012817, 13], [975795.955338278, 13], [975796.037072681, 13], [975796.118978137, 23], [975796.200441154, 32], [975796.281205628, 7], [975796.360985166, 23], [975796.449288087, 9], [975796.53318068, 13], [975796.613924258, 15], [975796.69428535, 19], [975796.775277131, 17], [975796.855828251, 23], [975796.93865063, 9], [975797.020654788, 17], [975797.102070368, 3], [975797.182996088, 21], [975797.264292439, 10], [975797.344867367, 24], [975797.431578311, 19], [975797.515930222, 14], [975797.596959971, 13], [975797.678047047, 5], [975797.758270575, 22], [975797.838888511, 13], [975797.920425929, 51], [975798.00214448, 15], [975798.084070114, 6], [975798.164880909, 8], [975798.24609016, 9], [975798.328307354, 16], [975798.414147712, 16], [975798.500543577, 9], [975798.582278431, 32], [975798.663910456, 18], [975798.74554504, 13], [975798.827966582, 11], [975798.912018887, 15], [975798.996121832, 8], [975799.078457873, 18], [975799.160980406, 25], [975799.233840429, 19], [975799.316059625, 8], [975799.400196712, 40], [975799.488289467, 16], [975799.570573589, 64], [975799.651963349, 6], [975799.732922094, 6], [975799.814095731, 11], [975799.895206842, 15], [975799.977265884, 17], [975800.058894743, 21], [975800.140304359, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-c2d9e25738e9453580d206a5", "runtime": {"accepted": 193, "cached": 0, "decode_s": 5.088, "drafted": 930, "drafts": true, "min_rows": 16, "prefill_s": 0.1144, "rounds": 62, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975794.92967452, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.121828100993298, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 193, "drafted": 930, "rounds": 62}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 50.32740826046728, "done": 975805.328054698, "finish_reason": "length", "first": 975800.259777741, "full_response_s": 5.179258568910882, "last": 975805.326599356, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975800.259777741, 3], [975800.341816383, 26], [975800.429025352, 15], [975800.513752251, 34], [975800.594354094, 21], [975800.675074126, 25], [975800.755527525, 14], [975800.836097673, 14], [975800.918978409, 18], [975801.00015864, 26], [975801.081867818, 13], [975801.162139959, 13], [975801.242900712, 13], [975801.323549851, 23], [975801.408581256, 32], [975801.49485732, 7], [975801.575142692, 23], [975801.656128272, 9], [975801.736723124, 13], [975801.81790926, 15], [975801.897179009, 19], [975801.978706257, 17], [975802.059893865, 23], [975802.140645132, 9], [975802.221597977, 17], [975802.301969605, 3], [975802.383491685, 21], [975802.470270267, 10], [975802.553028702, 24], [975802.633909118, 19], [975802.714486932, 14], [975802.796093026, 13], [975802.877262588, 5], [975802.961732969, 22], [975803.043062367, 13], [975803.125369167, 51], [975803.206595287, 15], [975803.286903846, 6], [975803.367791926, 8], [975803.455436233, 9], [975803.539027738, 16], [975803.619787918, 16], [975803.700399317, 9], [975803.781097994, 32], [975803.862332931, 18], [975803.943254932, 13], [975804.024626667, 11], [975804.10587554, 15], [975804.186751382, 8], [975804.267090117, 18], [975804.348176034, 25], [975804.427671045, 19], [975804.513580849, 8], [975804.594579921, 40], [975804.676013302, 16], [975804.756831625, 64], [975804.838232928, 6], [975804.920782076, 6], [975805.002473389, 11], [975805.084442951, 15], [975805.165576164, 17], [975805.24610608, 21], [975805.326599356, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-36bf6b6714574d2a876c1e87", "runtime": {"accepted": 193, "cached": 30, "decode_s": 5.0663, "drafted": 930, "drafts": true, "min_rows": 16, "prefill_s": 0.1083, "rounds": 62, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975800.148796129, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1109816120006144, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 193, "drafted": 930, "rounds": 62}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 50.03491411725481, "done": 975810.563138984, "finish_reason": "length", "first": 975805.465657156, "full_response_s": 5.217459577019326, "last": 975810.562098401, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975805.465657156, 3], [975805.576256403, 26], [975805.657605243, 15], [975805.738429696, 34], [975805.819619164, 21], [975805.899967325, 25], [975805.981435236, 14], [975806.062675552, 14], [975806.143315947, 18], [975806.223851879, 26], [975806.304647854, 13], [975806.385970408, 13], [975806.472752388, 13], [975806.556643266, 23], [975806.637269181, 32], [975806.717671629, 7], [975806.798021358, 23], [975806.878873508, 9], [975806.961747052, 13], [975807.043032536, 15], [975807.12373597, 19], [975807.204523435, 17], [975807.28484723, 23], [975807.365658773, 9], [975807.452986085, 17], [975807.53708904, 3], [975807.617138506, 21], [975807.697733622, 10], [975807.778589693, 24], [975807.859245401, 19], [975807.939998499, 14], [975808.021877059, 13], [975808.103137746, 5], [975808.183480197, 22], [975808.264331005, 13], [975808.344882044, 51], [975808.432164191, 15], [975808.516658274, 6], [975808.59776386, 8], [975808.678209797, 9], [975808.759224682, 16], [975808.840224975, 16], [975808.922749233, 9], [975809.004270427, 32], [975809.087454526, 18], [975809.168356166, 13], [975809.249259854, 11], [975809.329670834, 15], [975809.415247613, 8], [975809.502279335, 18], [975809.585327293, 25], [975809.658745347, 19], [975809.739512271, 8], [975809.820560067, 40], [975809.901043111, 16], [975809.983583626, 64], [975810.065525979, 6], [975810.146344839, 6], [975810.227371533, 11], [975810.308378532, 15], [975810.389423082, 17], [975810.478312506, 21], [975810.562098401, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-2fa75c6ec5a9489395eca06c", "runtime": {"accepted": 193, "cached": 30, "decode_s": 5.096, "drafted": 930, "drafts": true, "min_rows": 16, "prefill_s": 0.1172, "rounds": 62, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975805.345679407, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.119977748952806, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 193, "drafted": 930, "rounds": 62}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 50.36282013579986, "done": 975815.758473144, "finish_reason": "length", "first": 975810.693820318, "full_response_s": 5.177115399041213, "last": 975815.757079272, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975810.693820318, 3], [975810.775177197, 26], [975810.856973458, 15], [975810.939284812, 34], [975811.021462185, 21], [975811.102567231, 25], [975811.183538649, 14], [975811.263939919, 14], [975811.344432179, 18], [975811.430901453, 26], [975811.5160957, 13], [975811.596665286, 13], [975811.677059405, 13], [975811.757754652, 23], [975811.838980032, 32], [975811.919606802, 7], [975812.000423552, 23], [975812.081912895, 9], [975812.162369221, 13], [975812.242826332, 15], [975812.323227555, 19], [975812.406779474, 17], [975812.494184807, 23], [975812.577716342, 9], [975812.658280154, 17], [975812.738582452, 3], [975812.819108345, 21], [975812.900165683, 10], [975812.98320283, 24], [975813.064567025, 19], [975813.145345697, 14], [975813.225655148, 13], [975813.306053269, 5], [975813.387648691, 22], [975813.47388842, 13], [975813.55786489, 51], [975813.638693705, 15], [975813.719328397, 6], [975813.79998536, 8], [975813.880867327, 9], [975813.961338087, 16], [975814.043259102, 16], [975814.124233723, 9], [975814.204704356, 32], [975814.285678401, 18], [975814.366414403, 13], [975814.453414933, 11], [975814.537844082, 15], [975814.618311338, 8], [975814.699481875, 18], [975814.780422689, 25], [975814.854047529, 19], [975814.936584339, 8], [975815.018521547, 40], [975815.100277431, 16], [975815.18062162, 64], [975815.261556451, 6], [975815.342532561, 6], [975815.428825684, 11], [975815.514178285, 15], [975815.595507747, 17], [975815.676399443, 21], [975815.757079272, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-aef3c8ad91924b9690544128", "runtime": {"accepted": 193, "cached": 30, "decode_s": 5.0629, "drafted": 930, "drafts": true, "min_rows": 16, "prefill_s": 0.1094, "rounds": 62, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975810.581357745, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.11246257298626006, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 193, "drafted": 930, "rounds": 62}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.120002760642688, "done": 975829.352757576, "finish_reason": "length", "first": 975815.998467578, "full_response_s": 13.570609124028124, "last": 975829.335285736, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975815.998467578, 3], [975816.135443642, 11], [975816.318220056, 30], [975816.503966017, 19], [975816.6531034, 21], [975816.838369916, 15], [975816.987035281, 19], [975817.139935108, 17], [975817.286280974, 6], [975817.446207598, 11], [975817.595486261, 5], [975817.777927325, 27], [975817.960847804, 12], [975818.144468044, 13], [975818.294282025, 5], [975818.450502113, 16], [975818.640482798, 5], [975818.822332407, 16], [975819.010340036, 7], [975819.161907979, 22], [975819.311429488, 10], [975819.504897248, 7], [975819.690059919, 23], [975819.844354535, 5], [975819.988341647, 9], [975820.164677116, 14], [975820.313646289, 20], [975820.474512852, 8], [975820.624135177, 12], [975820.775917613, 5], [975820.930863818, 14], [975821.081131011, 11], [975821.225452453, 7], [975821.37746055, 9], [975821.534523427, 8], [975821.708152338, 3], [975821.89130239, 10], [975822.039947095, 11], [975822.22756191, 9], [975822.419352246, 10], [975822.60729283, 20], [975822.753400985, 14], [975822.938351864, 14], [975823.170293374, 13], [975823.320481934, 5], [975823.50411454, 14], [975823.731213954, 11], [975823.964645624, 32], [975824.152536839, 33], [975824.304220519, 11], [975824.497642055, 6], [975824.645661931, 8], [975824.795478325, 9], [975824.948163696, 13], [975825.099051189, 8], [975825.253024162, 20], [975825.4057483, 17], [975825.561859224, 20], [975825.708849654, 13], [975825.859831273, 2], [975826.015731661, 16], [975826.197213141, 6], [975826.348455684, 15], [975826.509582943, 8], [975826.694156624, 15], [975826.877924069, 16], [975827.117034293, 22], [975827.400391054, 9], [975827.56015982, 8], [975827.707507494, 25], [975827.861190656, 18], [975828.011089362, 13], [975828.194905386, 55], [975828.347669754, 11], [975828.548015752, 10], [975828.69476173, 11], [975828.848038039, 15], [975829.000601231, 17], [975829.150849243, 14], [975829.335285736, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4fc6a5e0cebc4b18a457c5c6", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3359, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1917, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975815.782148452, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.216319125960581, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.122475373364246, "done": 975829.351283753, "finish_reason": "length", "first": 975815.99930567, "full_response_s": 13.565761299105361, "last": 975829.334399324, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975815.99930567, 3], [975816.134964645, 11], [975816.318769835, 30], [975816.506357961, 19], [975816.652090831, 21], [975816.837346836, 15], [975816.986628218, 19], [975817.139874597, 17], [975817.286837489, 6], [975817.447286469, 11], [975817.595719087, 5], [975817.777661075, 27], [975817.961764071, 12], [975818.145905739, 13], [975818.296528245, 5], [975818.452475236, 16], [975818.643720195, 5], [975818.821674134, 16], [975819.010030348, 7], [975819.163494038, 22], [975819.309674745, 10], [975819.504293262, 7], [975819.689578602, 23], [975819.839581397, 5], [975819.991279339, 9], [975820.164095834, 14], [975820.31497893, 20], [975820.47517442, 8], [975820.624682125, 12], [975820.776348995, 5], [975820.929239695, 14], [975821.078979477, 11], [975821.224715078, 7], [975821.378291827, 9], [975821.535086518, 8], [975821.706684083, 3], [975821.89234435, 10], [975822.040613496, 11], [975822.227758354, 9], [975822.419295175, 10], [975822.604059112, 20], [975822.753857055, 14], [975822.937863427, 14], [975823.168998732, 13], [975823.318994432, 5], [975823.505633065, 14], [975823.732387175, 11], [975823.967744241, 32], [975824.153907784, 33], [975824.304673293, 11], [975824.498540658, 6], [975824.646706723, 8], [975824.795625346, 9], [975824.947533647, 13], [975825.100938969, 8], [975825.249925257, 20], [975825.404177632, 17], [975825.562108963, 20], [975825.708640443, 13], [975825.860368429, 2], [975826.015986279, 16], [975826.197372273, 6], [975826.347856354, 15], [975826.508643205, 8], [975826.692668195, 15], [975826.878496152, 16], [975827.11728656, 22], [975827.403529766, 9], [975827.55894108, 8], [975827.706565388, 25], [975827.861815793, 18], [975828.011581862, 13], [975828.19515818, 55], [975828.346961675, 11], [975828.547903706, 10], [975828.695917543, 11], [975828.848340416, 15], [975829.001491594, 17], [975829.150281352, 14], [975829.334399324, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-c3570204f7ce48f59d24162e", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.336, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1917, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975815.785522454, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21378321608062834, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.123232696908858, "done": 975829.351597506, "finish_reason": "length", "first": 975815.999195305, "full_response_s": 13.564785994007252, "last": 975829.333760859, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975815.999195305, 3], [975816.137535178, 11], [975816.318476514, 30], [975816.50296996, 19], [975816.653378498, 21], [975816.838696213, 15], [975816.987108591, 19], [975817.140864094, 17], [975817.287729052, 6], [975817.446784417, 11], [975817.597583956, 5], [975817.777810592, 27], [975817.962309547, 12], [975818.148339091, 13], [975818.297148215, 5], [975818.451524714, 16], [975818.642033194, 5], [975818.820929047, 16], [975819.01027695, 7], [975819.162473822, 22], [975819.311493711, 10], [975819.505697118, 7], [975819.689779686, 23], [975819.83841624, 5], [975819.991488822, 9], [975820.168104701, 14], [975820.313583667, 20], [975820.476256283, 8], [975820.625495322, 12], [975820.775606276, 5], [975820.930785468, 14], [975821.07907437, 11], [975821.22591641, 7], [975821.376997633, 9], [975821.534674223, 8], [975821.70640825, 3], [975821.890905599, 10], [975822.041243993, 11], [975822.225439463, 9], [975822.419767148, 10], [975822.604766216, 20], [975822.753991371, 14], [975822.938475717, 14], [975823.168328123, 13], [975823.31953266, 5], [975823.504037438, 14], [975823.731690599, 11], [975823.968611037, 32], [975824.155365878, 33], [975824.30519864, 11], [975824.497511114, 6], [975824.64665802, 8], [975824.797433288, 9], [975824.947360403, 13], [975825.098857225, 8], [975825.250808165, 20], [975825.403380755, 17], [975825.56134306, 20], [975825.709030898, 13], [975825.860522442, 2], [975826.014870529, 16], [975826.19701625, 6], [975826.347898561, 15], [975826.508709907, 8], [975826.692772288, 15], [975826.880222928, 16], [975827.114363955, 22], [975827.400652168, 9], [975827.558310294, 8], [975827.707299819, 25], [975827.861744403, 18], [975828.012386068, 13], [975828.196697969, 55], [975828.348669076, 11], [975828.547137548, 10], [975828.696360493, 11], [975828.848973314, 15], [975829.001260943, 17], [975829.151472285, 14], [975829.333760859, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-785dc294bb254f64a46fe9ec", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.336, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1917, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975815.786811512, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2123837930848822, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.120975863604013, "done": 975829.351933418, "finish_reason": "length", "first": 975815.999007213, "full_response_s": 13.566042171907611, "last": 975829.335146635, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975815.999007213, 3], [975816.136771788, 11], [975816.322011152, 30], [975816.503394622, 19], [975816.655853832, 21], [975816.838769827, 15], [975816.986444271, 19], [975817.140307099, 17], [975817.286661013, 6], [975817.446122032, 11], [975817.595964666, 5], [975817.778169447, 27], [975817.960108525, 12], [975818.146146149, 13], [975818.295851684, 5], [975818.451900961, 16], [975818.639559667, 5], [975818.822100204, 16], [975819.01095039, 7], [975819.161461557, 22], [975819.31233686, 10], [975819.50454604, 7], [975819.689501564, 23], [975819.838829607, 5], [975819.989638561, 9], [975820.164312245, 14], [975820.314464862, 20], [975820.475260498, 8], [975820.625635303, 12], [975820.775673763, 5], [975820.931685063, 14], [975821.080638238, 11], [975821.228055497, 7], [975821.377675217, 9], [975821.536841629, 8], [975821.707357764, 3], [975821.889619453, 10], [975822.040676774, 11], [975822.22525806, 9], [975822.419713774, 10], [975822.602832133, 20], [975822.753336075, 14], [975822.938547075, 14], [975823.168611301, 13], [975823.319123293, 5], [975823.503161362, 14], [975823.733936419, 11], [975823.96829386, 32], [975824.152884863, 33], [975824.303826288, 11], [975824.500322505, 6], [975824.645953604, 8], [975824.797927037, 9], [975824.950427356, 13], [975825.100894522, 8], [975825.250296433, 20], [975825.403667628, 17], [975825.562187681, 20], [975825.709804369, 13], [975825.860585112, 2], [975826.015555089, 16], [975826.197568285, 6], [975826.3489518, 15], [975826.509516817, 8], [975826.694083666, 15], [975826.879246327, 16], [975827.114752394, 22], [975827.401445094, 9], [975827.561849621, 8], [975827.706967186, 25], [975827.863658231, 18], [975828.010691019, 13], [975828.196145054, 55], [975828.347892421, 11], [975828.547602417, 10], [975828.695334773, 11], [975828.848740023, 15], [975829.000512081, 17], [975829.150919337, 14], [975829.335146635, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4ef379fbaf3f45728079d28c", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.336, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1917, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975815.785891246, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2131159669952467, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.121329578580486, "done": 975829.353883422, "finish_reason": "length", "first": 975815.99897427, "full_response_s": 13.570865805959329, "last": 975829.334866994, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975815.99897427, 3], [975816.136175689, 11], [975816.319282111, 30], [975816.504157388, 19], [975816.658178339, 21], [975816.837897111, 15], [975816.989585958, 19], [975817.141083881, 17], [975817.287050332, 6], [975817.445955876, 11], [975817.59602892, 5], [975817.778407794, 27], [975817.96060477, 12], [975818.147540181, 13], [975818.29536752, 5], [975818.451184833, 16], [975818.639473429, 5], [975818.821607784, 16], [975819.012536754, 7], [975819.162630618, 22], [975819.310584276, 10], [975819.505342134, 7], [975819.69011955, 23], [975819.837768607, 5], [975819.988206818, 9], [975820.163759234, 14], [975820.317975053, 20], [975820.47648759, 8], [975820.624624158, 12], [975820.776070681, 5], [975820.929857281, 14], [975821.080777963, 11], [975821.229705859, 7], [975821.377066927, 9], [975821.535679096, 8], [975821.707040875, 3], [975821.892138755, 10], [975822.040176306, 11], [975822.226624284, 9], [975822.418701333, 10], [975822.603707216, 20], [975822.752753016, 14], [975822.939352801, 14], [975823.169169544, 13], [975823.318414478, 5], [975823.505753414, 14], [975823.731865395, 11], [975823.965809038, 32], [975824.153545248, 33], [975824.304293941, 11], [975824.499364735, 6], [975824.646943917, 8], [975824.798840312, 9], [975824.94775337, 13], [975825.102335497, 8], [975825.249347782, 20], [975825.402761345, 17], [975825.563714206, 20], [975825.710569407, 13], [975825.859910472, 2], [975826.014654086, 16], [975826.19864066, 6], [975826.349344543, 15], [975826.509974118, 8], [975826.693121112, 15], [975826.879448114, 16], [975827.115272462, 22], [975827.400192579, 9], [975827.558145146, 8], [975827.707230204, 25], [975827.860389138, 18], [975828.010575214, 13], [975828.195908067, 55], [975828.349023451, 11], [975828.548907059, 10], [975828.697230361, 11], [975828.849573844, 15], [975829.002980776, 17], [975829.151528524, 14], [975829.334866994, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-05456928327e436b9a0b86da", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3359, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1917, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975815.783017616, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21595665393397212, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.12271933366298, "done": 975829.348058531, "finish_reason": "length", "first": 975815.999066588, "full_response_s": 13.564319939934649, "last": 975829.333990118, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975815.999066588, 3], [975816.134709131, 11], [975816.319193521, 30], [975816.504041807, 19], [975816.656142034, 21], [975816.837474417, 15], [975816.987366041, 19], [975817.139376561, 17], [975817.287321286, 6], [975817.445727657, 11], [975817.595882076, 5], [975817.779288125, 27], [975817.961476046, 12], [975818.146700441, 13], [975818.295654745, 5], [975818.451724629, 16], [975818.64090618, 5], [975818.822481444, 16], [975819.010801466, 7], [975819.161996745, 22], [975819.309774903, 10], [975819.50463319, 7], [975819.690599331, 23], [975819.838043881, 5], [975819.991601924, 9], [975820.169990786, 14], [975820.31345223, 20], [975820.474768494, 8], [975820.625771875, 12], [975820.774418048, 5], [975820.928858792, 14], [975821.078864327, 11], [975821.224832163, 7], [975821.378417216, 9], [975821.534247769, 8], [975821.706025522, 3], [975821.888953932, 10], [975822.039855769, 11], [975822.225839486, 9], [975822.418802947, 10], [975822.602602074, 20], [975822.755296525, 14], [975822.937736102, 14], [975823.168556886, 13], [975823.31754285, 5], [975823.503045205, 14], [975823.731767173, 11], [975823.965651169, 32], [975824.154626247, 33], [975824.305542745, 11], [975824.502065633, 6], [975824.651353976, 8], [975824.795994586, 9], [975824.948904143, 13], [975825.100071581, 8], [975825.250466749, 20], [975825.403128568, 17], [975825.561940295, 20], [975825.708941156, 13], [975825.860452011, 2], [975826.015494034, 16], [975826.197651867, 6], [975826.348193146, 15], [975826.508105969, 8], [975826.693832408, 15], [975826.879064955, 16], [975827.115205823, 22], [975827.400309248, 9], [975827.558449203, 8], [975827.705429718, 25], [975827.860213846, 18], [975828.010275572, 13], [975828.195059766, 55], [975828.347476927, 11], [975828.546670102, 10], [975828.695404979, 11], [975828.84774899, 15], [975829.000401219, 17], [975829.149949392, 14], [975829.333990118, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-68d59cc0250b4e73b88da3d1", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3359, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1917, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975815.783738591, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2153279969934374, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.116963225216093, "done": 975829.352120934, "finish_reason": "length", "first": 975815.99872642, "full_response_s": 13.56826741702389, "last": 975829.337665089, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975815.99872642, 3], [975816.135377964, 11], [975816.318637134, 30], [975816.504356408, 19], [975816.654049986, 21], [975816.838159665, 15], [975816.988951045, 19], [975817.140070609, 17], [975817.288308575, 6], [975817.446352603, 11], [975817.595634881, 5], [975817.77729606, 27], [975817.960922619, 12], [975818.144121748, 13], [975818.294793069, 5], [975818.451668182, 16], [975818.639794078, 5], [975818.820729756, 16], [975819.010748507, 7], [975819.161289897, 22], [975819.309168965, 10], [975819.504111394, 7], [975819.69167729, 23], [975819.840056746, 5], [975819.989233546, 9], [975820.164994469, 14], [975820.3144004, 20], [975820.473890818, 8], [975820.624869224, 12], [975820.775468039, 5], [975820.930480803, 14], [975821.079331516, 11], [975821.226026376, 7], [975821.377504101, 9], [975821.536205532, 8], [975821.706613701, 3], [975821.889411138, 10], [975822.040026629, 11], [975822.225740528, 9], [975822.419578465, 10], [975822.604624315, 20], [975822.753806464, 14], [975822.937531835, 14], [975823.169752027, 13], [975823.317640591, 5], [975823.502621438, 14], [975823.731448364, 11], [975823.965009936, 32], [975824.152795089, 33], [975824.307186275, 11], [975824.498071805, 6], [975824.647824441, 8], [975824.797984268, 9], [975824.948543975, 13], [975825.099740357, 8], [975825.249444196, 20], [975825.40330826, 17], [975825.561795402, 20], [975825.710398723, 13], [975825.864087256, 2], [975826.015602704, 16], [975826.197991667, 6], [975826.347818722, 15], [975826.508761762, 8], [975826.693507727, 15], [975826.879664541, 16], [975827.119782774, 22], [975827.401118814, 9], [975827.563306163, 8], [975827.705961001, 25], [975827.860870407, 18], [975828.011946206, 13], [975828.195795046, 55], [975828.348047554, 11], [975828.548262242, 10], [975828.696470107, 11], [975828.849464407, 15], [975829.001292175, 17], [975829.150557746, 14], [975829.337665089, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-6d36af7883624c01aa8350bb", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.336, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1917, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975815.783853517, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21487290295772254, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.1222093248159, "done": 975829.351225915, "finish_reason": "length", "first": 975815.999526289, "full_response_s": 13.562021082034335, "last": 975829.334805475, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975815.999526289, 3], [975816.135493241, 11], [975816.318844345, 30], [975816.503527307, 19], [975816.653706378, 21], [975816.836219838, 15], [975816.988379826, 19], [975817.139985715, 17], [975817.286933023, 6], [975817.446891791, 11], [975817.596241267, 5], [975817.778496896, 27], [975817.960769582, 12], [975818.144944785, 13], [975818.294355239, 5], [975818.452390566, 16], [975818.639723008, 5], [975818.820988774, 16], [975819.013626217, 7], [975819.162992418, 22], [975819.311064025, 10], [975819.504457082, 7], [975819.690925355, 23], [975819.840540751, 5], [975819.988260865, 9], [975820.164182952, 14], [975820.31570013, 20], [975820.474710271, 8], [975820.625242208, 12], [975820.774998418, 5], [975820.929120178, 14], [975821.078653516, 11], [975821.225695552, 7], [975821.378896485, 9], [975821.534803916, 8], [975821.708368877, 3], [975821.889901958, 10], [975822.040880066, 11], [975822.226245285, 9], [975822.418459466, 10], [975822.605413193, 20], [975822.754070442, 14], [975822.938217899, 14], [975823.168781969, 13], [975823.318929474, 5], [975823.502961735, 14], [975823.731603305, 11], [975823.966290082, 32], [975824.153068299, 33], [975824.303741746, 11], [975824.501215717, 6], [975824.647638557, 8], [975824.796460191, 9], [975824.948682436, 13], [975825.099838722, 8], [975825.249841611, 20], [975825.404335805, 17], [975825.562427227, 20], [975825.709195823, 13], [975825.862023271, 2], [975826.015673838, 16], [975826.199026299, 6], [975826.349024183, 15], [975826.510120403, 8], [975826.693184391, 15], [975826.878621669, 16], [975827.114831032, 22], [975827.402435935, 9], [975827.559615544, 8], [975827.70629693, 25], [975827.863541242, 18], [975828.012189576, 13], [975828.1976191, 55], [975828.348772657, 11], [975828.548600954, 10], [975828.696302111, 11], [975828.849739088, 15], [975829.002086509, 17], [975829.151057078, 14], [975829.334805475, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-935661ec6dbf4e3fb20e5f73", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.336, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1917, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975815.789204833, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2103214559610933, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.122351548558175, "done": 975829.353458823, "finish_reason": "length", "first": 975815.99976422, "full_response_s": 13.565365180023946, "last": 975829.334944224, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975815.99976422, 3], [975816.135186864, 11], [975816.319744229, 30], [975816.502629584, 19], [975816.656726436, 21], [975816.836737298, 15], [975816.987610404, 19], [975817.13948787, 17], [975817.286775042, 6], [975817.4471598, 11], [975817.596818886, 5], [975817.778878359, 27], [975817.960532196, 12], [975818.14501192, 13], [975818.294049438, 5], [975818.451798755, 16], [975818.639905499, 5], [975818.821501162, 16], [975819.013144164, 7], [975819.161653665, 22], [975819.309509597, 10], [975819.504702148, 7], [975819.689834804, 23], [975819.837660882, 5], [975819.98887733, 9], [975820.166368341, 14], [975820.316691931, 20], [975820.474237626, 8], [975820.625121746, 12], [975820.776953141, 5], [975820.93161548, 14], [975821.079691428, 11], [975821.225286937, 7], [975821.377331785, 9], [975821.534872555, 8], [975821.708094995, 3], [975821.889171431, 10], [975822.040738933, 11], [975822.225325914, 9], [975822.419062093, 10], [975822.603285802, 20], [975822.754159032, 14], [975822.938076958, 14], [975823.169252806, 13], [975823.318485692, 5], [975823.5037537, 14], [975823.732221835, 11], [975823.966394928, 32], [975824.153299494, 33], [975824.3048838, 11], [975824.500194076, 6], [975824.646782817, 8], [975824.797051985, 9], [975824.94981257, 13], [975825.099965136, 8], [975825.25094373, 20], [975825.404800994, 17], [975825.562040484, 20], [975825.709679555, 13], [975825.861494707, 2], [975826.014924368, 16], [975826.197269684, 6], [975826.347378508, 15], [975826.508242494, 8], [975826.693248053, 15], [975826.880426572, 16], [975827.117354622, 22], [975827.400713399, 9], [975827.559068133, 8], [975827.708299332, 25], [975827.860582446, 18], [975828.011455593, 13], [975828.196214876, 55], [975828.353183484, 11], [975828.551225758, 10], [975828.696584792, 11], [975828.849043312, 15], [975829.001549321, 17], [975829.150450244, 14], [975829.334944224, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-8c6a736adabc41b0816f45c4", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.336, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1917, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975815.788093643, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21167057694401592, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.12314775342416, "done": 975829.349845434, "finish_reason": "length", "first": 975815.99948229, "full_response_s": 13.56258876400534, "last": 975829.334107075, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975815.99948229, 3], [975816.134776186, 11], [975816.321549531, 30], [975816.502889737, 19], [975816.655037547, 21], [975816.836544022, 15], [975816.986919844, 19], [975817.139814087, 17], [975817.287117291, 6], [975817.446671492, 11], [975817.596342913, 5], [975817.77693546, 27], [975817.960408039, 12], [975818.145631281, 13], [975818.296258555, 5], [975818.45219921, 16], [975818.640196053, 5], [975818.823287025, 16], [975819.01105106, 7], [975819.161712159, 22], [975819.309896612, 10], [975819.507114349, 7], [975819.689734951, 23], [975819.841509753, 5], [975819.988566554, 9], [975820.16766164, 14], [975820.31551871, 20], [975820.475020216, 8], [975820.624756059, 12], [975820.775535462, 5], [975820.929342141, 14], [975821.081259904, 11], [975821.225866268, 7], [975821.376730439, 9], [975821.536656626, 8], [975821.706739458, 3], [975821.890362156, 10], [975822.040384445, 11], [975822.225535381, 9], [975822.41988105, 10], [975822.602675416, 20], [975822.754235542, 14], [975822.93780642, 14], [975823.168859023, 13], [975823.318783253, 5], [975823.50245797, 14], [975823.732465381, 11], [975823.965242139, 32], [975824.152709507, 33], [975824.303922558, 11], [975824.501152406, 6], [975824.645832567, 8], [975824.798125304, 9], [975824.950216961, 13], [975825.099113699, 8], [975825.24952525, 20], [975825.404947615, 17], [975825.562371933, 20], [975825.709085409, 13], [975825.860145714, 2], [975826.016211666, 16], [975826.197713418, 6], [975826.348063293, 15], [975826.509134186, 8], [975826.693552494, 15], [975826.879905288, 16], [975827.114446945, 22], [975827.40136068, 9], [975827.559544586, 8], [975827.709519256, 25], [975827.861284414, 18], [975828.012500385, 13], [975828.199052443, 55], [975828.348537031, 11], [975828.549400008, 10], [975828.696422476, 11], [975828.849143678, 15], [975829.000671997, 17], [975829.150048877, 14], [975829.334107075, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4ccb8c8ae1f147c6a33c6ccc", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.336, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1917, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975815.78725667, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21222562005277723, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.121468578833554, "done": 975829.349071932, "finish_reason": "length", "first": 975815.998260815, "full_response_s": 13.565123873064294, "last": 975829.334056596, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975815.998260815, 3], [975816.13440501, 11], [975816.318305814, 30], [975816.502758365, 19], [975816.652434135, 21], [975816.83595834, 15], [975816.987417272, 19], [975817.139620779, 17], [975817.287490498, 6], [975817.445611548, 11], [975817.596083863, 5], [975817.777509079, 27], [975817.960999785, 12], [975818.146069367, 13], [975818.295430718, 5], [975818.450755995, 16], [975818.639357192, 5], [975818.820841481, 16], [975819.010156905, 7], [975819.161118509, 22], [975819.310297355, 10], [975819.505269223, 7], [975819.689208387, 23], [975819.837570532, 5], [975819.988416125, 9], [975820.163528663, 14], [975820.316328723, 20], [975820.474183915, 8], [975820.62392963, 12], [975820.777394075, 5], [975820.930541201, 14], [975821.080845465, 11], [975821.227382441, 7], [975821.376926066, 9], [975821.535535531, 8], [975821.706486152, 3], [975821.889277541, 10], [975822.039760027, 11], [975822.225678914, 9], [975822.418297726, 10], [975822.602415166, 20], [975822.75285767, 14], [975822.937417165, 14], [975823.168687731, 13], [975823.318319136, 5], [975823.503832387, 14], [975823.731378878, 11], [975823.965341912, 32], [975824.15242329, 33], [975824.304149273, 11], [975824.497738789, 6], [975824.646545494, 8], [975824.797624468, 9], [975824.948306109, 13], [975825.100353607, 8], [975825.250727335, 20], [975825.402895182, 17], [975825.561480001, 20], [975825.708785624, 13], [975825.860880273, 2], [975826.015797084, 16], [975826.197130071, 6], [975826.348529554, 15], [975826.508986413, 8], [975826.694215951, 15], [975826.878036962, 16], [975827.114533391, 22], [975827.401799166, 9], [975827.560301256, 8], [975827.705309736, 25], [975827.860689307, 18], [975828.012458386, 13], [975828.195237522, 55], [975828.347171382, 11], [975828.547452116, 10], [975828.69624296, 11], [975828.847964073, 15], [975829.000955622, 17], [975829.149691286, 14], [975829.334056596, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4a2fa389bf3442c69b7aaeb0", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3359, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1917, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975815.783948059, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21431275608483702, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.12201947509967, "done": 975829.353726305, "finish_reason": "length", "first": 975815.999105259, "full_response_s": 13.570377927972004, "last": 975829.334516842, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975815.999105259, 3], [975816.135829121, 11], [975816.319685222, 30], [975816.503618793, 19], [975816.653032682, 21], [975816.837405027, 15], [975816.989737522, 19], [975817.139563932, 17], [975817.286720692, 6], [975817.44589543, 11], [975817.59725838, 5], [975817.778253637, 27], [975817.961710104, 12], [975818.149261149, 13], [975818.296191421, 5], [975818.453028167, 16], [975818.642288084, 5], [975818.822428821, 16], [975819.010577999, 7], [975819.161810717, 22], [975819.309387072, 10], [975819.505029421, 7], [975819.689651801, 23], [975819.838344818, 5], [975819.990439662, 9], [975820.16615969, 14], [975820.313805389, 20], [975820.474111917, 8], [975820.624220007, 12], [975820.775243997, 5], [975820.929495049, 14], [975821.079152321, 11], [975821.224973312, 7], [975821.377593459, 9], [975821.534355879, 8], [975821.707996149, 3], [975821.889770809, 10], [975822.040928928, 11], [975822.225893917, 9], [975822.420011511, 10], [975822.603654914, 20], [975822.755193728, 14], [975822.937120564, 14], [975823.172772229, 13], [975823.31872367, 5], [975823.50331651, 14], [975823.73434617, 11], [975823.966955523, 32], [975824.15295843, 33], [975824.306106044, 11], [975824.500865965, 6], [975824.648492106, 8], [975824.798203287, 9], [975824.94799778, 13], [975825.098948679, 8], [975825.250874835, 20], [975825.40442977, 17], [975825.56274466, 20], [975825.709578118, 13], [975825.860784052, 2], [975826.015866346, 16], [975826.197787976, 6], [975826.348403653, 15], [975826.508807873, 8], [975826.693948149, 15], [975826.880274671, 16], [975827.115904703, 22], [975827.402734473, 9], [975827.561501277, 8], [975827.707815983, 25], [975827.86188768, 18], [975828.011522632, 13], [975828.196471142, 55], [975828.347570285, 11], [975828.549326714, 10], [975828.695979238, 11], [975828.847630129, 15], [975829.000063515, 17], [975829.150978408, 14], [975829.334516842, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-d73c493187eb439084393321", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3359, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1917, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975815.783348377, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2157568819820881, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.12134832161518, "done": 975829.351800589, "finish_reason": "length", "first": 975815.999142154, "full_response_s": 13.565439817961305, "last": 975829.335021806, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975815.999142154, 3], [975816.134584958, 11], [975816.31890068, 30], [975816.503872243, 19], [975816.656518681, 21], [975816.837292213, 15], [975816.986774935, 19], [975817.138849501, 17], [975817.287528721, 6], [975817.447519648, 11], [975817.598087369, 5], [975817.777994107, 27], [975817.960687632, 12], [975818.149543015, 13], [975818.295716168, 5], [975818.452867771, 16], [975818.642941909, 5], [975818.82203891, 16], [975819.012236985, 7], [975819.16341692, 22], [975819.31016507, 10], [975819.506235425, 7], [975819.689292513, 23], [975819.844543619, 5], [975819.989708703, 9], [975820.166283223, 14], [975820.317439642, 20], [975820.475557579, 8], [975820.625025701, 12], [975820.776234038, 5], [975820.930375045, 14], [975821.079456618, 11], [975821.225037199, 7], [975821.377748032, 9], [975821.5353268, 8], [975821.707492529, 3], [975821.891193497, 10], [975822.040234384, 11], [975822.224919635, 9], [975822.419135131, 10], [975822.603425863, 20], [975822.75310752, 14], [975822.937931746, 14], [975823.169978949, 13], [975823.32056022, 5], [975823.505428798, 14], [975823.731085269, 11], [975823.966014569, 32], [975824.155088861, 33], [975824.306354998, 11], [975824.499907171, 6], [975824.646331755, 8], [975824.797535302, 9], [975824.949962647, 13], [975825.100282776, 8], [975825.250649785, 20], [975825.40322719, 17], [975825.56153888, 20], [975825.711043764, 13], [975825.860728805, 2], [975826.016026806, 16], [975826.197424688, 6], [975826.347606727, 15], [975826.508920254, 8], [975826.694792962, 15], [975826.880838898, 16], [975827.119355008, 22], [975827.400584906, 9], [975827.559378302, 8], [975827.705822477, 25], [975827.860984804, 18], [975828.012022844, 13], [975828.195295265, 55], [975828.347968884, 11], [975828.548422974, 10], [975828.695526976, 11], [975828.851176319, 15], [975829.003268594, 17], [975829.151399598, 14], [975829.335021806, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-a52d02e25e1d429f88bd5d75", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.336, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1917, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975815.786360771, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2127813829574734, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.12061135684188, "done": 975829.352874597, "finish_reason": "length", "first": 975815.998350972, "full_response_s": 13.567979983985424, "last": 975829.334744628, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975815.998350972, 3], [975816.138957081, 11], [975816.319547145, 30], [975816.504281161, 19], [975816.652591956, 21], [975816.836368763, 15], [975816.98870353, 19], [975817.1401156, 17], [975817.28611949, 6], [975817.446989212, 11], [975817.595807085, 5], [975817.778809833, 27], [975817.959841988, 12], [975818.147714929, 13], [975818.294167099, 5], [975818.450341477, 16], [975818.64005628, 5], [975818.822216506, 16], [975819.011813298, 7], [975819.163077328, 22], [975819.312724339, 10], [975819.504796978, 7], [975819.691086583, 23], [975819.838471951, 5], [975819.988997856, 9], [975820.163932062, 14], [975820.318666701, 20], [975820.477456384, 8], [975820.624297093, 12], [975820.775359514, 5], [975820.931034918, 14], [975821.079236815, 11], [975821.225375943, 7], [975821.378028025, 9], [975821.534953001, 8], [975821.706811968, 3], [975821.889222502, 10], [975822.04052249, 11], [975822.226049289, 9], [975822.419824827, 10], [975822.603823486, 20], [975822.752977475, 14], [975822.939033912, 14], [975823.170061332, 13], [975823.318869475, 5], [975823.503942032, 14], [975823.733812518, 11], [975823.965578755, 32], [975824.154052836, 33], [975824.304497697, 11], [975824.497369837, 6], [975824.646877679, 8], [975824.797693026, 9], [975824.948246894, 13], [975825.100668783, 8], [975825.251155165, 20], [975825.404270846, 17], [975825.562483914, 20], [975825.709148992, 13], [975825.861689855, 2], [975826.01593996, 16], [975826.199325509, 6], [975826.347963791, 15], [975826.508533559, 8], [975826.693311524, 15], [975826.878815441, 16], [975827.117692982, 22], [975827.400814037, 9], [975827.560896347, 8], [975827.707175661, 25], [975827.861666117, 18], [975828.010769993, 13], [975828.196421719, 55], [975828.347281555, 11], [975828.54833944, 10], [975828.695472066, 11], [975828.84843427, 15], [975829.001030949, 17], [975829.150673999, 14], [975829.334744628, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-a3c89297e1d24af9bb28f299", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3359, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1917, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975815.784894613, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21345635899342597, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.121872967565736, "done": 975829.351500116, "finish_reason": "length", "first": 975815.998948895, "full_response_s": 13.568602145067416, "last": 975829.334462651, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975815.998948895, 3], [975816.135064739, 11], [975816.318543872, 30], [975816.503145492, 19], [975816.656238735, 21], [975816.837839496, 15], [975816.988241013, 19], [975817.139690201, 17], [975817.287434483, 6], [975817.446055122, 11], [975817.596162805, 5], [975817.777592581, 27], [975817.961096199, 12], [975818.144674295, 13], [975818.295305809, 5], [975818.450713116, 16], [975818.641527494, 5], [975818.821559913, 16], [975819.011203921, 7], [975819.164385154, 22], [975819.311155287, 10], [975819.505383605, 7], [975819.692586741, 23], [975819.838936964, 5], [975819.989507348, 9], [975820.1674691, 14], [975820.315818271, 20], [975820.474444517, 8], [975820.626212937, 12], [975820.774775895, 5], [975820.931320351, 14], [975821.078767433, 11], [975821.229100289, 7], [975821.376528156, 9], [975821.53474195, 8], [975821.706150176, 3], [975821.88903801, 10], [975822.042460861, 11], [975822.225107647, 9], [975822.418615911, 10], [975822.607945599, 20], [975822.755638934, 14], [975822.940111935, 14], [975823.169116121, 13], [975823.31866788, 5], [975823.506134878, 14], [975823.732760382, 11], [975823.967298283, 32], [975824.153007324, 33], [975824.304359556, 11], [975824.497897457, 6], [975824.650576874, 8], [975824.796921956, 9], [975824.948091234, 13], [975825.099400877, 8], [975825.253883582, 20], [975825.403846552, 17], [975825.563828523, 20], [975825.710766394, 13], [975825.860017141, 2], [975826.015144618, 16], [975826.197504334, 6], [975826.348594049, 15], [975826.509764795, 8], [975826.692979227, 15], [975826.879568815, 16], [975827.118168251, 22], [975827.400053174, 9], [975827.558522257, 8], [975827.706669145, 25], [975827.860778905, 18], [975828.011145904, 13], [975828.195617098, 55], [975828.348112704, 11], [975828.550412449, 10], [975828.695634542, 11], [975828.847868219, 15], [975829.000801354, 17], [975829.151952242, 14], [975829.334462651, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-a6dac4a204b746ddbd774cdc", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3359, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1917, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975815.782897971, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2160509240347892, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "python", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.121623591802656, "done": 975829.353301451, "finish_reason": "length", "first": 975815.998607879, "full_response_s": 13.571515262010507, "last": 975829.334295551, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975815.998607879, 3], [975816.135328973, 11], [975816.318365108, 30], [975816.50234519, 19], [975816.652937292, 21], [975816.836142688, 15], [975816.987281931, 19], [975817.140458216, 17], [975817.287377685, 6], [975817.446440649, 11], [975817.596689929, 5], [975817.777076737, 27], [975817.959509083, 12], [975818.144235954, 13], [975818.294708943, 5], [975818.453354799, 16], [975818.640735976, 5], [975818.821760116, 16], [975819.010659549, 7], [975819.161381991, 22], [975819.309264178, 10], [975819.505986647, 7], [975819.68941595, 23], [975819.83876388, 5], [975819.988084149, 9], [975820.163857215, 14], [975820.313326856, 20], [975820.47494513, 8], [975820.624950694, 12], [975820.775819663, 5], [975820.930618575, 14], [975821.079807649, 11], [975821.225566386, 7], [975821.376829653, 9], [975821.535949378, 8], [975821.706541607, 3], [975821.890183712, 10], [975822.041714446, 11], [975822.225613315, 9], [975822.4189216, 10], [975822.604434448, 20], [975822.753223757, 14], [975822.937662168, 14], [975823.170222928, 13], [975823.319055311, 5], [975823.503711237, 14], [975823.73214038, 11], [975823.965083086, 32], [975824.15345453, 33], [975824.304761355, 11], [975824.498396997, 6], [975824.646440185, 8], [975824.797183774, 9], [975824.948812433, 13], [975825.099901521, 8], [975825.250177059, 20], [975825.40358115, 17], [975825.563616672, 20], [975825.709483672, 13], [975825.860192081, 2], [975826.014763827, 16], [975826.197324387, 6], [975826.347484474, 15], [975826.507896262, 8], [975826.692854542, 15], [975826.878352651, 16], [975827.117221713, 22], [975827.400520699, 9], [975827.560071566, 8], [975827.706489453, 25], [975827.863360318, 18], [975828.011302813, 13], [975828.196946491, 55], [975828.347805335, 11], [975828.550315891, 10], [975828.696508746, 11], [975828.84828173, 15], [975829.001370717, 17], [975829.150760685, 14], [975829.334295551, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-725098f587e245a5aa79d19c", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.336, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1917, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975815.781786189, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.21682169009000063, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.036261060892738, "done": 975843.035602822, "finish_reason": "length", "first": 975829.622085899, "full_response_s": 13.657081244979054, "last": 975843.017573552, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975829.622085899, 3], [975829.759425807, 11], [975829.937406034, 30], [975830.116186595, 19], [975830.26478348, 21], [975830.458739406, 15], [975830.607607276, 19], [975830.756097603, 17], [975830.902195282, 6], [975831.056345018, 11], [975831.205043359, 5], [975831.388613509, 27], [975831.630341369, 12], [975831.798218838, 13], [975831.957542234, 5], [975832.103779465, 16], [975832.285910147, 5], [975832.477669521, 16], [975832.668216299, 7], [975832.816528379, 22], [975832.974161752, 10], [975833.153235675, 7], [975833.33403831, 23], [975833.493380092, 5], [975833.646886455, 9], [975833.816710558, 14], [975833.970246603, 20], [975834.118990965, 8], [975834.268420608, 12], [975834.426132622, 5], [975834.580410298, 14], [975834.730114062, 11], [975834.87929656, 7], [975835.034695621, 9], [975835.182217837, 8], [975835.354934151, 3], [975835.547621144, 10], [975835.696024397, 11], [975835.880043078, 9], [975836.070798198, 10], [975836.258450542, 20], [975836.412984665, 14], [975836.60415296, 14], [975836.831526126, 13], [975836.985897855, 5], [975837.160820411, 14], [975837.389481087, 11], [975837.634841158, 32], [975837.820872229, 33], [975837.976894883, 11], [975838.160444382, 6], [975838.309983503, 8], [975838.470209885, 9], [975838.62302442, 13], [975838.772664275, 8], [975838.927954276, 20], [975839.080298792, 17], [975839.229217849, 20], [975839.37986146, 13], [975839.54421719, 2], [975839.691753464, 16], [975839.877559667, 6], [975840.030590778, 15], [975840.183394965, 8], [975840.366908054, 15], [975840.56657596, 16], [975840.795303557, 22], [975841.080155016, 9], [975841.232069259, 8], [975841.383810113, 25], [975841.544686552, 18], [975841.696877204, 13], [975841.880762688, 55], [975842.032060163, 11], [975842.216666513, 10], [975842.367308898, 11], [975842.531341187, 15], [975842.677395469, 17], [975842.8295687, 14], [975843.017573552, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-e718fcebc6714d57b9ac91c0", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3962, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1955, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975829.378521577, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.24356432200875133, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.032948742285758, "done": 975843.036881545, "finish_reason": "length", "first": 975829.620892134, "full_response_s": 13.656752852955833, "last": 975843.018711014, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975829.620892134, 3], [975829.757512955, 11], [975829.937562222, 30], [975830.114822898, 19], [975830.269695111, 21], [975830.455492312, 15], [975830.608306412, 19], [975830.755232535, 17], [975830.90385574, 6], [975831.059135802, 11], [975831.20419101, 5], [975831.388388922, 27], [975831.630254891, 12], [975831.799205952, 13], [975831.954620749, 5], [975832.103604493, 16], [975832.285698568, 5], [975832.482540866, 16], [975832.670491991, 7], [975832.815985703, 22], [975832.973114832, 10], [975833.153446342, 7], [975833.334383918, 23], [975833.492130985, 5], [975833.643104542, 9], [975833.8162806, 14], [975833.967995854, 20], [975834.121641689, 8], [975834.268476063, 12], [975834.425196403, 5], [975834.580705731, 14], [975834.729889491, 11], [975834.880454133, 7], [975835.035173114, 9], [975835.182074368, 8], [975835.354500641, 3], [975835.548904283, 10], [975835.69668051, 11], [975835.882494814, 9], [975836.070872933, 10], [975836.258687304, 20], [975836.411626696, 14], [975836.603283012, 14], [975836.833455458, 13], [975836.986061131, 5], [975837.159746068, 14], [975837.387267761, 11], [975837.63571653, 32], [975837.824126171, 33], [975837.974642694, 11], [975838.15998804, 6], [975838.310108028, 8], [975838.472124034, 9], [975838.62426228, 13], [975838.77201061, 8], [975838.925073957, 20], [975839.081804709, 17], [975839.229412133, 20], [975839.381084376, 13], [975839.542957011, 2], [975839.692037089, 16], [975839.87760109, 6], [975840.028599975, 15], [975840.183841899, 8], [975840.367721076, 15], [975840.565361492, 16], [975840.796981134, 22], [975841.083922787, 9], [975841.234524691, 8], [975841.382669819, 25], [975841.546729401, 18], [975841.700128378, 13], [975841.880019057, 55], [975842.031683035, 11], [975842.218464008, 10], [975842.367566748, 11], [975842.528603554, 15], [975842.678554195, 17], [975842.83379726, 14], [975843.018711014, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-9e16447287ae4037b6a49bee", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3962, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1955, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975829.380128692, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2407634420087561, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.030573303121457, "done": 975843.036361749, "finish_reason": "length", "first": 975829.621190111, "full_response_s": 13.657716223038733, "last": 975843.020681337, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975829.621190111, 3], [975829.758334088, 11], [975829.937787209, 30], [975830.115382902, 19], [975830.263358936, 21], [975830.457480346, 15], [975830.610869713, 19], [975830.758107365, 17], [975830.903275866, 6], [975831.055628667, 11], [975831.204100004, 5], [975831.388123121, 27], [975831.630576835, 12], [975831.796955987, 13], [975831.952926532, 5], [975832.106855171, 16], [975832.287173014, 5], [975832.479446569, 16], [975832.666184074, 7], [975832.814773139, 22], [975832.971487221, 10], [975833.153715904, 7], [975833.335666817, 23], [975833.492350628, 5], [975833.642950161, 9], [975833.817063414, 14], [975833.970496309, 20], [975834.118338244, 8], [975834.266932306, 12], [975834.425605818, 5], [975834.581664205, 14], [975834.729294737, 11], [975834.878662222, 7], [975835.036913202, 9], [975835.182957756, 8], [975835.353607317, 3], [975835.55007584, 10], [975835.697998144, 11], [975835.881542595, 9], [975836.071565461, 10], [975836.259626739, 20], [975836.411206849, 14], [975836.603857271, 14], [975836.831604924, 13], [975836.985369195, 5], [975837.15938598, 14], [975837.387370527, 11], [975837.634501309, 32], [975837.820786759, 33], [975837.977346793, 11], [975838.163856928, 6], [975838.309888081, 8], [975838.47326988, 9], [975838.623275438, 13], [975838.773404146, 8], [975838.926548628, 20], [975839.081618121, 17], [975839.229607681, 20], [975839.381219429, 13], [975839.544268837, 2], [975839.693529583, 16], [975839.877504884, 6], [975840.030156931, 15], [975840.182930352, 8], [975840.370254218, 15], [975840.56586492, 16], [975840.795973061, 22], [975841.08237855, 9], [975841.230282163, 8], [975841.382057289, 25], [975841.544211122, 18], [975841.694530681, 13], [975841.87953038, 55], [975842.033745613, 11], [975842.216749455, 10], [975842.367036536, 11], [975842.52869344, 15], [975842.678502596, 17], [975842.833715918, 14], [975843.020681337, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b648bfd068b1471cab8cbb91", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3962, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1955, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975829.378645526, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.24254458502400666, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.034346161682603, "done": 975843.033823887, "finish_reason": "length", "first": 975829.621044451, "full_response_s": 13.65450707997661, "last": 975843.017879721, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975829.621044451, 3], [975829.758021919, 11], [975829.939259031, 30], [975830.115300887, 19], [975830.265626405, 21], [975830.456624654, 15], [975830.605740823, 19], [975830.755581519, 17], [975830.902896002, 6], [975831.056927325, 11], [975831.2046626, 5], [975831.388075282, 27], [975831.630297162, 12], [975831.798582286, 13], [975831.953622548, 5], [975832.106563337, 16], [975832.285992753, 5], [975832.480582751, 16], [975832.67140909, 7], [975832.817234507, 22], [975832.972439679, 10], [975833.153488725, 7], [975833.338322692, 23], [975833.492273717, 5], [975833.645165343, 9], [975833.816753629, 14], [975833.967717349, 20], [975834.117754929, 8], [975834.268285331, 12], [975834.425932322, 5], [975834.58047012, 14], [975834.729222371, 11], [975834.879337759, 7], [975835.032778176, 9], [975835.181564476, 8], [975835.353832848, 3], [975835.553357765, 10], [975835.696421956, 11], [975835.882353073, 9], [975836.070684073, 10], [975836.262443379, 20], [975836.412832028, 14], [975836.601532668, 14], [975836.832017202, 13], [975836.986193448, 5], [975837.159578264, 14], [975837.387628153, 11], [975837.636009531, 32], [975837.821861663, 33], [975837.974837538, 11], [975838.160832853, 6], [975838.310174075, 8], [975838.472409915, 9], [975838.622801273, 13], [975838.771490222, 8], [975838.925451405, 20], [975839.082343081, 17], [975839.229782765, 20], [975839.382551911, 13], [975839.543199054, 2], [975839.694657126, 16], [975839.877033599, 6], [975840.030977281, 15], [975840.186418865, 8], [975840.368190921, 15], [975840.568107973, 16], [975840.797665263, 22], [975841.081381757, 9], [975841.233469771, 8], [975841.382602348, 25], [975841.54360312, 18], [975841.694675462, 13], [975841.879920371, 55], [975842.033423156, 11], [975842.217818502, 10], [975842.369382579, 11], [975842.528877563, 15], [975842.678423382, 17], [975842.830342075, 14], [975843.017879721, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-7b2b322d851d476497f9d76b", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3962, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1955, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975829.379316807, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2417276439955458, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.0330262930977, "done": 975843.033293403, "finish_reason": "length", "first": 975829.621622341, "full_response_s": 13.654140335973352, "last": 975843.019386631, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975829.621622341, 3], [975829.758117501, 11], [975829.940634072, 30], [975830.114256143, 19], [975830.263509365, 21], [975830.454729721, 15], [975830.606546596, 19], [975830.756161506, 17], [975830.904168357, 6], [975831.057306692, 11], [975831.204036422, 5], [975831.388692356, 27], [975831.629703047, 12], [975831.797281564, 13], [975831.952490926, 5], [975832.105027693, 16], [975832.285843525, 5], [975832.479012275, 16], [975832.667760293, 7], [975832.815761932, 22], [975832.970093429, 10], [975833.152881027, 7], [975833.333983319, 23], [975833.495240882, 5], [975833.643410391, 9], [975833.816361846, 14], [975833.96853805, 20], [975834.117799328, 8], [975834.268346146, 12], [975834.425493292, 5], [975834.5827509, 14], [975834.731227493, 11], [975834.879419453, 7], [975835.034370572, 9], [975835.182158942, 8], [975835.354998293, 3], [975835.547350783, 10], [975835.696481298, 11], [975835.880728454, 9], [975836.068838243, 10], [975836.26003273, 20], [975836.411384413, 14], [975836.602035584, 14], [975836.83231206, 13], [975836.985964349, 5], [975837.159510873, 14], [975837.387017543, 11], [975837.635127823, 32], [975837.820375505, 33], [975837.975535906, 11], [975838.161998778, 6], [975838.309495402, 8], [975838.470597076, 9], [975838.6219851, 13], [975838.771153446, 8], [975838.928736834, 20], [975839.081069958, 17], [975839.232125559, 20], [975839.380276842, 13], [975839.544543935, 2], [975839.691395552, 16], [975839.879649139, 6], [975840.029576321, 15], [975840.183152747, 8], [975840.366985029, 15], [975840.564802272, 16], [975840.795470113, 22], [975841.084625123, 9], [975841.231454425, 8], [975841.382119319, 25], [975841.544474844, 18], [975841.695960408, 13], [975841.879376288, 55], [975842.032294461, 11], [975842.219874232, 10], [975842.367620011, 11], [975842.529855877, 15], [975842.678886619, 17], [975842.831040459, 14], [975843.019386631, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-5ecac76380a7450887536019", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3963, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1955, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975829.379153067, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.24246927397325635, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.03589179659306, "done": 975843.037273617, "finish_reason": "length", "first": 975829.621300381, "full_response_s": 13.658547805040143, "last": 975843.017047884, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975829.621300381, 3], [975829.757636248, 11], [975829.937311684, 30], [975830.114413916, 19], [975830.263239371, 21], [975830.455201759, 15], [975830.60753267, 19], [975830.755029835, 17], [975830.902969153, 6], [975831.056216669, 11], [975831.203709277, 5], [975831.388474297, 27], [975831.629310432, 12], [975831.796545805, 13], [975831.952027896, 5], [975832.103697963, 16], [975832.284546323, 5], [975832.479371354, 16], [975832.666613648, 7], [975832.815518946, 22], [975832.969726637, 10], [975833.1523132, 7], [975833.338425138, 23], [975833.491966972, 5], [975833.642722439, 9], [975833.815693285, 14], [975833.969265793, 20], [975834.117126256, 8], [975834.26712267, 12], [975834.42498404, 5], [975834.579521454, 14], [975834.7288111, 11], [975834.878561424, 7], [975835.032516838, 9], [975835.181226452, 8], [975835.354870328, 3], [975835.546469507, 10], [975835.6957281, 11], [975835.879800075, 9], [975836.068392989, 10], [975836.258736295, 20], [975836.411036053, 14], [975836.601820453, 14], [975836.835564482, 13], [975836.985028627, 5], [975837.159324701, 14], [975837.387528763, 11], [975837.634361873, 32], [975837.82023338, 33], [975837.974550584, 11], [975838.159834188, 6], [975838.314022787, 8], [975838.469892516, 9], [975838.621719346, 13], [975838.771226372, 8], [975838.925146932, 20], [975839.081456397, 17], [975839.229160011, 20], [975839.379938482, 13], [975839.54351663, 2], [975839.691650874, 16], [975839.877133101, 6], [975840.028917424, 15], [975840.181702796, 8], [975840.367624758, 15], [975840.5667481, 16], [975840.795548815, 22], [975841.086013811, 9], [975841.23095266, 8], [975841.381853981, 25], [975841.5430687, 18], [975841.694311774, 13], [975841.878793661, 55], [975842.032806194, 11], [975842.216511492, 10], [975842.370652934, 11], [975842.528749342, 15], [975842.677163123, 17], [975842.829647546, 14], [975843.017047884, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-000ffa0ed82d4fbaad84ba21", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3961, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1955, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975829.378725812, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.24257456907071173, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.034320655269138, "done": 975843.036043277, "finish_reason": "length", "first": 975829.622225208, "full_response_s": 13.656497978954576, "last": 975843.01907843, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975829.622225208, 3], [975829.75772127, 11], [975829.938044419, 30], [975830.114765028, 19], [975830.265045346, 21], [975830.454944164, 15], [975830.607950932, 19], [975830.754538503, 17], [975830.904728712, 6], [975831.055230116, 11], [975831.204454236, 5], [975831.387630284, 27], [975831.629556715, 12], [975831.798410562, 13], [975831.952850533, 5], [975832.104264046, 16], [975832.286714593, 5], [975832.477573172, 16], [975832.667870195, 7], [975832.816835124, 22], [975832.971710304, 10], [975833.15657707, 7], [975833.335303817, 23], [975833.493106626, 5], [975833.643357704, 9], [975833.818484069, 14], [975833.971111127, 20], [975834.120484099, 8], [975834.267677265, 12], [975834.426787439, 5], [975834.580961597, 14], [975834.730060751, 11], [975834.878801163, 7], [975835.03505694, 9], [975835.183070698, 8], [975835.354786474, 3], [975835.553063708, 10], [975835.696564321, 11], [975835.880573129, 9], [975836.071820911, 10], [975836.262242871, 20], [975836.412239258, 14], [975836.602210988, 14], [975836.83222611, 13], [975836.985620053, 5], [975837.159626902, 14], [975837.387119349, 11], [975837.635203133, 32], [975837.824055661, 33], [975837.974225728, 11], [975838.165427772, 6], [975838.311121381, 8], [975838.471519887, 9], [975838.621875358, 13], [975838.771875253, 8], [975838.925645336, 20], [975839.083795832, 17], [975839.230815765, 20], [975839.380335241, 13], [975839.544073882, 2], [975839.691826422, 16], [975839.877860716, 6], [975840.028778659, 15], [975840.182456267, 8], [975840.366831544, 15], [975840.566379181, 16], [975840.796669974, 22], [975841.084494214, 9], [975841.231367659, 8], [975841.38368306, 25], [975841.543811547, 18], [975841.695832011, 13], [975841.88059522, 55], [975842.032906384, 11], [975842.217167829, 10], [975842.367710457, 11], [975842.52945203, 15], [975842.679800103, 17], [975842.830687411, 14], [975843.01907843, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-c830e999bb724a78ad1ecbe6", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3961, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1955, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975829.379545298, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2426799099193886, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.033941032174617, "done": 975843.024312391, "finish_reason": "length", "first": 975829.621238878, "full_response_s": 13.645516787888482, "last": 975843.018359294, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975829.621238878, 3], [975829.75713738, 11], [975829.937487408, 30], [975830.114172401, 19], [975830.266777706, 21], [975830.455873007, 15], [975830.605149412, 19], [975830.755977254, 17], [975830.903937259, 6], [975831.056399081, 11], [975831.204811156, 5], [975831.387367954, 27], [975831.630094926, 12], [975831.796679241, 13], [975831.952614347, 5], [975832.103870167, 16], [975832.285050151, 5], [975832.478715017, 16], [975832.666668382, 7], [975832.81568835, 22], [975832.970698775, 10], [975833.153775518, 7], [975833.334951441, 23], [975833.49399435, 5], [975833.644411344, 9], [975833.816938905, 14], [975833.969145588, 20], [975834.117605941, 8], [975834.267624674, 12], [975834.425326544, 5], [975834.580244925, 14], [975834.728740782, 11], [975834.879159635, 7], [975835.035367733, 9], [975835.181891573, 8], [975835.354407459, 3], [975835.551731067, 10], [975835.697076709, 11], [975835.880821844, 9], [975836.069799197, 10], [975836.259232012, 20], [975836.411131523, 14], [975836.604457209, 14], [975836.831809751, 13], [975836.985765554, 5], [975837.159167233, 14], [975837.38689153, 11], [975837.636513872, 32], [975837.820114342, 33], [975837.975434388, 11], [975838.160965074, 6], [975838.314404346, 8], [975838.470322363, 9], [975838.624065724, 13], [975838.772513991, 8], [975838.928631124, 20], [975839.083037945, 17], [975839.231279786, 20], [975839.381933797, 13], [975839.544437553, 2], [975839.693769882, 16], [975839.880250486, 6], [975840.030285152, 15], [975840.181512128, 8], [975840.366158471, 15], [975840.564984156, 16], [975840.795063066, 22], [975841.080075258, 9], [975841.230430336, 8], [975841.383880063, 25], [975841.544606905, 18], [975841.696201283, 13], [975841.882904895, 55], [975842.032131377, 11], [975842.217520589, 10], [975842.368198782, 11], [975842.528954954, 15], [975842.678304585, 17], [975842.83108617, 14], [975843.018359294, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-ac24b470348c431fa9e097f1", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3962, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1955, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975829.378795603, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.24244327493943274, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.034211018183107, "done": 975843.03730152, "finish_reason": "length", "first": 975829.621515208, "full_response_s": 13.65825923497323, "last": 975843.018445596, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975829.621515208, 3], [975829.757944097, 11], [975829.937987477, 30], [975830.117969866, 19], [975830.266196632, 21], [975830.45444488, 15], [975830.60418505, 19], [975830.755439554, 17], [975830.902773509, 6], [975831.055329298, 11], [975831.203961784, 5], [975831.387204054, 27], [975831.630711968, 12], [975831.797557093, 13], [975831.953162318, 5], [975832.104499897, 16], [975832.290443836, 5], [975832.479833856, 16], [975832.669023449, 7], [975832.816680471, 22], [975832.971545716, 10], [975833.153380295, 7], [975833.337674483, 23], [975833.493296686, 5], [975833.642894723, 9], [975833.816459396, 14], [975833.968088732, 20], [975834.118104298, 8], [975834.267515093, 12], [975834.427478623, 5], [975834.580783233, 14], [975834.729381519, 11], [975834.878839594, 7], [975835.032610388, 9], [975835.182707586, 8], [975835.356143179, 3], [975835.550718994, 10], [975835.6962554, 11], [975835.880237041, 9], [975836.071881309, 10], [975836.261731139, 20], [975836.411797268, 14], [975836.604073058, 14], [975836.832569942, 13], [975836.985708355, 5], [975837.160033885, 14], [975837.389789288, 11], [975837.635621876, 32], [975837.821518982, 33], [975837.97439838, 11], [975838.161555636, 6], [975838.310445781, 8], [975838.47097686, 9], [975838.622926966, 13], [975838.772099824, 8], [975838.926812798, 20], [975839.081222962, 17], [975839.230319904, 20], [975839.380026256, 13], [975839.543007186, 2], [975839.691954019, 16], [975839.877219611, 6], [975840.029120395, 15], [975840.183467412, 8], [975840.367509353, 15], [975840.564431097, 16], [975840.795873448, 22], [975841.080709852, 9], [975841.232402131, 8], [975841.383261678, 25], [975841.547542391, 18], [975841.696564539, 13], [975841.880719969, 55], [975842.031804281, 11], [975842.216794302, 10], [975842.369803241, 11], [975842.529783527, 15], [975842.677627304, 17], [975842.82982695, 14], [975843.018445596, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-abbbd78170d44a63968fb100", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3962, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1955, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975829.379042285, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.24247292301151901, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.035892478498916, "done": 975843.03211151, "finish_reason": "length", "first": 975829.621435322, "full_response_s": 13.653176662046462, "last": 975843.017182345, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975829.621435322, 3], [975829.758174236, 11], [975829.938560583, 30], [975830.116453197, 19], [975830.265865919, 21], [975830.455103825, 15], [975830.610103107, 19], [975830.754681987, 17], [975830.903070478, 6], [975831.055713881, 11], [975831.204696855, 5], [975831.388961613, 27], [975831.630018576, 12], [975831.798338148, 13], [975831.952726072, 5], [975832.106187298, 16], [975832.284856971, 5], [975832.478546557, 16], [975832.667519963, 7], [975832.816230882, 22], [975832.972077159, 10], [975833.153308185, 7], [975833.334446893, 23], [975833.492450593, 5], [975833.644748552, 9], [975833.816410101, 14], [975833.970420359, 20], [975834.119514057, 8], [975834.267956475, 12], [975834.425665368, 5], [975834.580572374, 14], [975834.729958098, 11], [975834.88053002, 7], [975835.035480899, 9], [975835.182767841, 8], [975835.357243586, 3], [975835.548282089, 10], [975835.695912111, 11], [975835.880642344, 9], [975836.068712982, 10], [975836.259287691, 20], [975836.412589394, 14], [975836.603171526, 14], [975836.833701132, 13], [975836.986407251, 5], [975837.163278723, 14], [975837.387082885, 11], [975837.635952444, 32], [975837.821117696, 33], [975837.974739188, 11], [975838.162791384, 6], [975838.30974946, 8], [975838.470500599, 9], [975838.622866296, 13], [975838.772234941, 8], [975838.925548682, 20], [975839.080829275, 17], [975839.235213009, 20], [975839.380213532, 13], [975839.543095024, 2], [975839.693329668, 16], [975839.877803245, 6], [975840.03242464, 15], [975840.18284397, 8], [975840.367309821, 15], [975840.566830322, 16], [975840.797053117, 22], [975841.081903633, 9], [975841.231135008, 8], [975841.382506911, 25], [975841.545730464, 18], [975841.694463146, 13], [975841.880823839, 55], [975842.031882071, 11], [975842.217404688, 10], [975842.367877845, 11], [975842.530491927, 15], [975842.677463516, 17], [975842.829445327, 14], [975843.017182345, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-177887806d534b6e9d16bae5", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3962, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1955, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975829.378934848, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2425004739779979, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.0335321467081, "done": 975843.035909904, "finish_reason": "length", "first": 975829.621715667, "full_response_s": 13.656446397071704, "last": 975843.019123885, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975829.621715667, 3], [975829.757586009, 11], [975829.937852344, 30], [975830.114681446, 19], [975830.264310179, 21], [975830.455413866, 15], [975830.605825925, 19], [975830.755645725, 17], [975830.903766063, 6], [975831.055062536, 11], [975831.20474935, 5], [975831.387948757, 27], [975831.629747542, 12], [975831.798507776, 13], [975831.952555948, 5], [975832.104940591, 16], [975832.287510687, 5], [975832.4778847, 16], [975832.666011214, 7], [975832.817077214, 22], [975832.973010034, 10], [975833.152591993, 7], [975833.335033775, 23], [975833.491786656, 5], [975833.643987306, 9], [975833.816189338, 14], [975833.967512217, 20], [975834.117844767, 8], [975834.268045113, 12], [975834.42819803, 5], [975834.580636021, 14], [975834.729803269, 11], [975834.881517117, 7], [975835.033974517, 9], [975835.182011026, 8], [975835.353934989, 3], [975835.54922258, 10], [975835.697422717, 11], [975835.880384686, 9], [975836.07039128, 10], [975836.261041779, 20], [975836.413722312, 14], [975836.603035737, 14], [975836.831729561, 13], [975836.985825696, 5], [975837.159450874, 14], [975837.388376072, 11], [975837.63606057, 32], [975837.823676165, 33], [975837.974465114, 11], [975838.161082511, 6], [975838.310252553, 8], [975838.470892094, 9], [975838.623122354, 13], [975838.77103436, 8], [975838.926741551, 20], [975839.081728263, 17], [975839.233240574, 20], [975839.381281236, 13], [975839.542876645, 2], [975839.695493715, 16], [975839.878346705, 6], [975840.0306658, 15], [975840.182081747, 8], [975840.369589737, 15], [975840.565586575, 16], [975840.795820281, 22], [975841.08167399, 9], [975841.230672411, 8], [975841.382938053, 25], [975841.542945455, 18], [975841.694592392, 13], [975841.879135221, 55], [975842.032423259, 11], [975842.216955562, 10], [975842.367660954, 11], [975842.528459573, 15], [975842.677334175, 17], [975842.831795594, 14], [975843.019123885, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-6d02d3e8802e4a2ca88c9fb3", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3961, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1955, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975829.379463507, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.24225215998012573, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.035970826531628, "done": 975843.037507259, "finish_reason": "length", "first": 975829.621585478, "full_response_s": 13.65784657211043, "last": 975843.017277367, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975829.621585478, 3], [975829.758924379, 11], [975829.940518235, 30], [975830.115425973, 19], [975830.26371776, 21], [975830.457178865, 15], [975830.604982168, 19], [975830.75516396, 17], [975830.902835588, 6], [975831.055569932, 11], [975831.205279385, 5], [975831.388211759, 27], [975831.630411079, 12], [975831.797912317, 13], [975831.953216477, 5], [975832.104606822, 16], [975832.286103247, 5], [975832.4789541, 16], [975832.667290736, 7], [975832.816281169, 22], [975832.972644426, 10], [975833.154756648, 7], [975833.334508283, 23], [975833.493174225, 5], [975833.646427586, 9], [975833.816327191, 14], [975833.968708574, 20], [975834.11923512, 8], [975834.268223317, 12], [975834.426028688, 5], [975834.581063979, 14], [975834.729190611, 11], [975834.879381854, 7], [975835.036835316, 9], [975835.182640723, 8], [975835.354682076, 3], [975835.549323137, 10], [975835.698190731, 11], [975835.884415794, 9], [975836.070277586, 10], [975836.260965572, 20], [975836.412719151, 14], [975836.605227463, 14], [975836.832870335, 13], [975836.989879476, 5], [975837.162978138, 14], [975837.386479843, 11], [975837.636816969, 32], [975837.821381978, 33], [975837.976313136, 11], [975838.161343817, 6], [975838.309812499, 8], [975838.471604589, 9], [975838.623192592, 13], [975838.77192042, 8], [975838.926658881, 20], [975839.083637308, 17], [975839.229842779, 20], [975839.3803882, 13], [975839.543841999, 2], [975839.692935501, 16], [975839.878699465, 6], [975840.029657359, 15], [975840.182222176, 8], [975840.366684347, 15], [975840.565441826, 16], [975840.796147953, 22], [975841.080341204, 9], [975841.230890182, 8], [975841.381974219, 25], [975841.544124964, 18], [975841.696102805, 13], [975841.879637418, 55], [975842.031942309, 11], [975842.217605147, 10], [975842.370266047, 11], [975842.530198429, 15], [975842.681388835, 17], [975842.833381318, 14], [975843.017277367, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-04263add7dd841099e39a1fe", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3962, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1955, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975829.379660687, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.24192479101475328, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.031903489048315, "done": 975843.037721846, "finish_reason": "length", "first": 975829.620975684, "full_response_s": 13.657963769044727, "last": 975843.019530387, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975829.620975684, 3], [975829.758990521, 11], [975829.937700299, 30], [975830.114889025, 19], [975830.269383774, 21], [975830.456109626, 15], [975830.604326423, 19], [975830.755529584, 17], [975830.904945748, 6], [975831.05627998, 11], [975831.204400414, 5], [975831.388015683, 27], [975831.630148221, 12], [975831.797388089, 13], [975831.952768887, 5], [975832.104175584, 16], [975832.28447338, 5], [975832.478185894, 16], [975832.666347334, 7], [975832.815605424, 22], [975832.969942712, 10], [975833.153038927, 7], [975833.333897113, 23], [975833.493858321, 5], [975833.643030576, 9], [975833.816230745, 14], [975833.967909936, 20], [975834.118555455, 8], [975834.2678887, 12], [975834.424672799, 5], [975834.58012224, 14], [975834.730405336, 11], [975834.878948744, 7], [975835.0336875, 9], [975835.183129064, 8], [975835.353993868, 3], [975835.547731958, 10], [975835.696739181, 11], [975835.881129261, 9], [975836.069905083, 10], [975836.25896461, 20], [975836.411922177, 14], [975836.602454039, 14], [975836.832117392, 13], [975836.9865528, 5], [975837.161023975, 14], [975837.387436509, 11], [975837.636429506, 32], [975837.821709138, 33], [975837.975102972, 11], [975838.163026259, 6], [975838.310388022, 8], [975838.471077897, 9], [975838.622640637, 13], [975838.771826982, 8], [975838.925899378, 20], [975839.080646032, 17], [975839.229301144, 20], [975839.380771903, 13], [975839.543362154, 2], [975839.691521453, 16], [975839.880561983, 6], [975840.031574547, 15], [975840.187484936, 8], [975840.367837553, 15], [975840.56614189, 16], [975840.795613102, 22], [975841.08148681, 9], [975841.230841383, 8], [975841.381919852, 25], [975841.544251601, 18], [975841.694971919, 13], [975841.879582875, 55], [975842.032504105, 11], [975842.216421526, 10], [975842.367918692, 11], [975842.52902236, 15], [975842.677758613, 17], [975842.830808336, 14], [975843.019530387, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-0485689da0074599a35f85d7", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3963, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1955, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975829.379758077, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2412176070502028, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.033725903501892, "done": 975843.035329085, "finish_reason": "length", "first": 975829.622025596, "full_response_s": 13.65535152493976, "last": 975843.019297433, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975829.622025596, 3], [975829.758081214, 11], [975829.938448298, 30], [975830.115958488, 19], [975830.266860312, 21], [975830.455026675, 15], [975830.606766703, 19], [975830.757994488, 17], [975830.902532667, 6], [975831.05835054, 11], [975831.203828827, 5], [975831.3872885, 27], [975831.629496748, 12], [975831.796825014, 13], [975831.952138374, 5], [975832.106138195, 16], [975832.286182013, 5], [975832.478261764, 16], [975832.669894885, 7], [975832.814873217, 22], [975832.971320761, 10], [975833.152465436, 7], [975833.334253985, 23], [975833.49187819, 5], [975833.64281602, 9], [975833.815398444, 14], [975833.967381948, 20], [975834.117267389, 8], [975834.268149862, 12], [975834.425122053, 5], [975834.580302572, 14], [975834.729463725, 11], [975834.88173164, 7], [975835.032401129, 9], [975835.181434783, 8], [975835.353766145, 3], [975835.546348277, 10], [975835.695653077, 11], [975835.880434557, 9], [975836.068951824, 10], [975836.258601018, 20], [975836.411515946, 14], [975836.602937052, 14], [975836.831398305, 13], [975836.985514855, 5], [975837.159041012, 14], [975837.386202458, 11], [975837.63492202, 32], [975837.82347641, 33], [975837.975021534, 11], [975838.162165719, 6], [975838.309106515, 8], [975838.470428888, 9], [975838.622077818, 13], [975838.772803584, 8], [975838.924978039, 20], [975839.080411685, 17], [975839.229042781, 20], [975839.381464543, 13], [975839.542707753, 2], [975839.695360454, 16], [975839.878274115, 6], [975840.032816231, 15], [975840.181893991, 8], [975840.366426689, 15], [975840.564895166, 16], [975840.795154536, 22], [975841.079991132, 9], [975841.230521918, 8], [975841.381777455, 25], [975841.545347769, 18], [975841.695445188, 13], [975841.878886651, 55], [975842.031987716, 11], [975842.216574099, 10], [975842.367124438, 11], [975842.528816781, 15], [975842.677296272, 17], [975842.829366833, 14], [975843.019297433, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4c999bcc6dc14f97ade9eb1e", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3961, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1955, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975829.37997756, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.24204803595785052, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.034344820422028, "done": 975843.028338363, "finish_reason": "length", "first": 975829.620669195, "full_response_s": 13.649468586081639, "last": 975843.017505409, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975829.620669195, 3], [975829.758384807, 11], [975829.937925654, 30], [975830.114506474, 19], [975830.264837911, 21], [975830.456390451, 15], [975830.605639369, 19], [975830.755486545, 17], [975830.903578995, 6], [975831.05616619, 11], [975831.204526283, 5], [975831.387700922, 27], [975831.630197596, 12], [975831.797737409, 13], [975831.95299413, 5], [975832.10399282, 16], [975832.287430737, 5], [975832.480824713, 16], [975832.666553649, 7], [975832.816606409, 22], [975832.97180275, 10], [975833.152793189, 7], [975833.334183635, 23], [975833.492055642, 5], [975833.645242477, 9], [975833.815776595, 14], [975833.96763167, 20], [975834.117689683, 8], [975834.268092008, 12], [975834.424911898, 5], [975834.58128559, 14], [975834.73046415, 11], [975834.879111428, 7], [975835.035803083, 9], [975835.183347715, 8], [975835.356925721, 3], [975835.548740687, 10], [975835.696615791, 11], [975835.880148115, 9], [975836.069652192, 10], [975836.259412104, 20], [975836.413874772, 14], [975836.603409169, 14], [975836.831912213, 13], [975836.987090004, 5], [975837.159684277, 14], [975837.386741981, 11], [975837.63554567, 32], [975837.82030469, 33], [975837.978201909, 11], [975838.161915756, 6], [975838.314752179, 8], [975838.470751409, 9], [975838.623686741, 13], [975838.773040283, 8], [975838.926956314, 20], [975839.081168788, 17], [975839.230084678, 20], [975839.380433271, 13], [975839.543612708, 2], [975839.692576213, 16], [975839.878884629, 6], [975840.03040155, 15], [975840.18303043, 8], [975840.366561438, 15], [975840.567550978, 16], [975840.796478138, 22], [975841.080821481, 9], [975841.230793976, 8], [975841.382276036, 25], [975841.544765286, 18], [975841.694909472, 13], [975841.880177597, 55], [975842.03262095, 11], [975842.218373242, 10], [975842.368851359, 11], [975842.531106729, 15], [975842.679637434, 17], [975842.832547913, 14], [975843.017505409, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-670fcbec4737456ea91a4bba", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3961, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1955, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975829.378869777, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.24179941799957305, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "python", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 19.034119340649514, "done": 975843.033693922, "finish_reason": "length", "first": 975829.62081556, "full_response_s": 13.65524725499563, "last": 975843.017810474, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975829.62081556, 3], [975829.757264545, 11], [975829.939396516, 30], [975830.114622487, 19], [975830.263443303, 21], [975830.454610716, 15], [975830.607375217, 19], [975830.754253805, 17], [975830.902690391, 6], [975831.054729423, 11], [975831.203567089, 5], [975831.389051275, 27], [975831.630377976, 12], [975831.798629517, 13], [975831.9530964, 5], [975832.105708077, 16], [975832.284774669, 5], [975832.479941773, 16], [975832.666930073, 7], [975832.816768981, 22], [975832.971897052, 10], [975833.153110382, 7], [975833.3341257, 23], [975833.492800473, 5], [975833.643172764, 9], [975833.81529635, 14], [975833.968165322, 20], [975834.117491559, 8], [975834.267756767, 12], [975834.425815333, 5], [975834.579997395, 14], [975834.728631392, 11], [975834.87998504, 7], [975835.034517241, 9], [975835.182828159, 8], [975835.355627319, 3], [975835.546985959, 10], [975835.696357365, 11], [975835.8803064, 9], [975836.070041591, 10], [975836.260373442, 20], [975836.410805546, 14], [975836.603524366, 14], [975836.833406307, 13], [975836.986445042, 5], [975837.160367622, 14], [975837.388260219, 11], [975837.634615787, 32], [975837.82048667, 33], [975837.97493672, 11], [975838.160568699, 6], [975838.311384831, 8], [975838.472952719, 9], [975838.622724587, 13], [975838.772589205, 8], [975838.925208002, 20], [975839.080743853, 17], [975839.229539522, 20], [975839.379709815, 13], [975839.54371397, 2], [975839.691886933, 16], [975839.87743199, 6], [975840.030096293, 15], [975840.181828089, 8], [975840.367422923, 15], [975840.565282197, 16], [975840.795719963, 22], [975841.081784563, 9], [975841.232471154, 8], [975841.383080658, 25], [975841.543382453, 18], [975841.694804899, 13], [975841.880366649, 55], [975842.032243807, 11], [975842.217750712, 10], [975842.367397488, 11], [975842.528097229, 15], [975842.680164814, 17], [975842.82994706, 14], [975843.017810474, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4c2c9111fce6492d907e0be9", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.3961, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1955, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975829.378446667, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.24236889299936593, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 18.9688282946252, "done": 975856.746619008, "finish_reason": "length", "first": 975843.28887088, "full_response_s": 13.679704976035282, "last": 975856.73197849, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975843.28887088, 3], [975843.424960894, 11], [975843.613086799, 30], [975843.78746132, 19], [975843.941968198, 21], [975844.133713496, 15], [975844.277375228, 19], [975844.430798195, 17], [975844.587699403, 6], [975844.736145747, 11], [975844.883791422, 5], [975845.073888664, 27], [975845.258217013, 12], [975845.446871535, 13], [975845.600409446, 5], [975845.7486605, 16], [975845.932579276, 5], [975846.120898401, 16], [975846.30780143, 7], [975846.468811958, 22], [975846.617721496, 10], [975846.800978447, 7], [975846.989331318, 23], [975847.14233627, 5], [975847.293460064, 9], [975847.477400635, 14], [975847.627381334, 20], [975847.776967675, 8], [975847.925917648, 12], [975848.079714872, 5], [975848.2322447, 14], [975848.380901368, 11], [975848.542907606, 7], [975848.692690265, 9], [975848.839498495, 8], [975849.015872731, 3], [975849.200023319, 10], [975849.349722205, 11], [975849.546304672, 9], [975849.727853142, 10], [975849.913048652, 20], [975850.065056769, 14], [975850.252145261, 14], [975850.496784628, 13], [975850.650236984, 5], [975850.821531689, 14], [975851.056839063, 11], [975851.290993007, 32], [975851.486804473, 33], [975851.643273435, 11], [975851.826258871, 6], [975851.97704854, 8], [975852.131293251, 9], [975852.285740309, 13], [975852.441011365, 8], [975852.597781811, 20], [975852.744303912, 17], [975852.895942043, 20], [975853.053808162, 13], [975853.206285363, 2], [975853.352866585, 16], [975853.553325216, 6], [975853.700217807, 15], [975853.850277303, 8], [975854.036161753, 15], [975854.22202454, 16], [975854.462474113, 22], [975854.741452945, 9], [975854.892953179, 8], [975855.045679355, 25], [975855.197150519, 18], [975855.349532479, 13], [975855.548524909, 55], [975855.699926683, 11], [975855.940472178, 10], [975856.08301273, 11], [975856.233483871, 15], [975856.385827881, 17], [975856.54509972, 14], [975856.73197849, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-05600127d678451baef9ddab", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.4425, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1931, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975843.066914032, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.22195684805046767, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 18.96982910553464, "done": 975856.749346819, "finish_reason": "length", "first": 975843.28948013, "full_response_s": 13.682275239028968, "last": 975856.731878508, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975843.28948013, 3], [975843.426236962, 11], [975843.612698856, 30], [975843.788020219, 19], [975843.942535721, 21], [975844.13151825, 15], [975844.278018558, 19], [975844.42839753, 17], [975844.587969813, 6], [975844.734583783, 11], [975844.883722128, 5], [975845.074926657, 27], [975845.25728345, 12], [975845.4475436, 13], [975845.600939994, 5], [975845.748459817, 16], [975845.933590197, 5], [975846.120624455, 16], [975846.306322184, 7], [975846.467383622, 22], [975846.617362352, 10], [975846.800688902, 7], [975846.989096044, 23], [975847.142537017, 5], [975847.293838743, 9], [975847.475414712, 14], [975847.628555772, 20], [975847.775535244, 8], [975847.926020862, 12], [975848.080330474, 5], [975848.233998309, 14], [975848.379897343, 11], [975848.541018737, 7], [975848.693157583, 9], [975848.838515222, 8], [975849.014243808, 3], [975849.20356303, 10], [975849.349630191, 11], [975849.545882153, 9], [975849.729132201, 10], [975849.912244638, 20], [975850.06517683, 14], [975850.250502642, 14], [975850.496150962, 13], [975850.644809331, 5], [975850.821920993, 14], [975851.057850528, 11], [975851.291412742, 32], [975851.490436311, 33], [975851.641331783, 11], [975851.826798779, 6], [975851.976175552, 8], [975852.130341688, 9], [975852.284672957, 13], [975852.441980911, 8], [975852.596408818, 20], [975852.743940256, 17], [975852.896041752, 20], [975853.053867185, 13], [975853.201647436, 2], [975853.352703725, 16], [975853.551776019, 6], [975853.698990747, 15], [975853.849584039, 8], [975854.036274455, 15], [975854.221933582, 16], [975854.462552047, 22], [975854.741870983, 9], [975854.893592685, 8], [975855.046599206, 25], [975855.197344755, 18], [975855.354267748, 13], [975855.550304757, 55], [975855.699833981, 11], [975855.939829441, 10], [975856.083209365, 11], [975856.233068392, 15], [975856.385930295, 17], [975856.545759433, 14], [975856.731878508, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4e852de58ef54b52ad627daf", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.4426, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1931, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975843.06707158, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.22240854997653514, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 18.97227596973197, "done": 975856.749029258, "finish_reason": "length", "first": 975843.291985258, "full_response_s": 13.680686075007543, "last": 975856.732649963, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975843.291985258, 3], [975843.427038063, 11], [975843.614283508, 30], [975843.786886037, 19], [975843.942182993, 21], [975844.131621047, 15], [975844.278632512, 19], [975844.428774705, 17], [975844.58971027, 6], [975844.73584169, 11], [975844.884391569, 5], [975845.074992719, 27], [975845.257825326, 12], [975845.44824056, 13], [975845.602235404, 5], [975845.749446787, 16], [975845.93285759, 5], [975846.121054958, 16], [975846.306588658, 7], [975846.466186049, 22], [975846.618970475, 10], [975846.802025992, 7], [975846.991317929, 23], [975847.143459988, 5], [975847.293319411, 9], [975847.477474569, 14], [975847.626204561, 20], [975847.775798278, 8], [975847.926197882, 12], [975848.080120687, 5], [975848.233613101, 14], [975848.379848192, 11], [975848.542826168, 7], [975848.692575436, 9], [975848.839357187, 8], [975849.014672182, 3], [975849.200729895, 10], [975849.34935823, 11], [975849.545429044, 9], [975849.727198533, 10], [975849.914047141, 20], [975850.066774842, 14], [975850.252202827, 14], [975850.496273552, 13], [975850.645160731, 5], [975850.82184061, 14], [975851.05992117, 11], [975851.290823203, 32], [975851.488232329, 33], [975851.641540594, 11], [975851.825318972, 6], [975851.976034131, 8], [975852.131770648, 9], [975852.286278169, 13], [975852.438494302, 8], [975852.598063212, 20], [975852.746525414, 17], [975852.896278067, 20], [975853.054911065, 13], [975853.204032182, 2], [975853.352770827, 16], [975853.55271339, 6], [975853.700292733, 15], [975853.851160899, 8], [975854.035706628, 15], [975854.222981175, 16], [975854.462629197, 22], [975854.741809849, 9], [975854.892114846, 8], [975855.045772345, 25], [975855.197242165, 18], [975855.349604173, 13], [975855.547267577, 55], [975855.7002229, 11], [975855.939559015, 10], [975856.085031052, 11], [975856.235364948, 15], [975856.387374727, 17], [975856.547420644, 14], [975856.732649963, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-25421bdfcdfc471099cc7758", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.4426, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1931, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975843.068343183, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.22364207496866584, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 18.9685511990501, "done": 975856.747375743, "finish_reason": "length", "first": 975843.28843665, "full_response_s": 13.68037750502117, "last": 975856.731740639, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975843.28843665, 3], [975843.425061596, 11], [975843.615204575, 30], [975843.786538029, 19], [975843.941770283, 21], [975844.130231367, 15], [975844.277517849, 19], [975844.428270461, 17], [975844.587353475, 6], [975844.734686468, 11], [975844.883500725, 5], [975845.073045339, 27], [975845.256855124, 12], [975845.44702054, 13], [975845.601681481, 5], [975845.747850535, 16], [975845.932315138, 5], [975846.12040558, 16], [975846.306228698, 7], [975846.470043978, 22], [975846.617436814, 10], [975846.800323374, 7], [975846.991673633, 23], [975847.143343095, 5], [975847.291933026, 9], [975847.475822478, 14], [975847.626023125, 20], [975847.775645017, 8], [975847.926371254, 12], [975848.079565979, 5], [975848.231310369, 14], [975848.379152144, 11], [975848.543453066, 7], [975848.692405535, 9], [975848.840042563, 8], [975849.014014549, 3], [975849.200803829, 10], [975849.349462995, 11], [975849.544445034, 9], [975849.72664429, 10], [975849.912063842, 20], [975850.064927348, 14], [975850.250350821, 14], [975850.497661392, 13], [975850.645563938, 5], [975850.820928887, 14], [975851.056725178, 11], [975851.290289407, 32], [975851.486926102, 33], [975851.641058989, 11], [975851.828864252, 6], [975851.975587949, 8], [975852.129972273, 9], [975852.283706147, 13], [975852.437331688, 8], [975852.597842577, 20], [975852.743639975, 17], [975852.898219159, 20], [975853.055457597, 13], [975853.202729363, 2], [975853.352303862, 16], [975853.552816923, 6], [975853.698697281, 15], [975853.849279054, 8], [975854.036811483, 15], [975854.221795025, 16], [975854.461798816, 22], [975854.740863326, 9], [975854.891810325, 8], [975855.045352867, 25], [975855.198447498, 18], [975855.354367922, 13], [975855.547801533, 55], [975855.699637697, 11], [975855.940650734, 10], [975856.082770735, 11], [975856.234437225, 15], [975856.389427928, 17], [975856.549396504, 14], [975856.731740639, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-cf35ffae75c94f34b8754d42", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.4424, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1931, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975843.066998238, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.22143841197248548, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 18.96814089791191, "done": 975856.748062992, "finish_reason": "length", "first": 975843.288706068, "full_response_s": 13.680901717976667, "last": 975856.73230085, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975843.288706068, 3], [975843.425419412, 11], [975843.613309786, 30], [975843.787278444, 19], [975843.943658544, 21], [975844.130658077, 15], [975844.277586919, 19], [975844.429455938, 17], [975844.587048442, 6], [975844.736217506, 11], [975844.884339986, 5], [975845.074544473, 27], [975845.258036761, 12], [975845.447906216, 13], [975845.600625857, 5], [975845.74993772, 16], [975845.935241744, 5], [975846.120693254, 16], [975846.306480276, 7], [975846.466825219, 22], [975846.61788282, 10], [975846.802909012, 7], [975846.98978174, 23], [975847.14327452, 5], [975847.292960619, 9], [975847.476730954, 14], [975847.627049854, 20], [975847.775390031, 8], [975847.928411064, 12], [975848.079646441, 5], [975848.23314132, 14], [975848.379703172, 11], [975848.543072131, 7], [975848.692508589, 9], [975848.840093794, 8], [975849.014513242, 3], [975849.200198691, 10], [975849.350608377, 11], [975849.544827665, 9], [975849.727740505, 10], [975849.912128705, 20], [975850.066714379, 14], [975850.251832644, 14], [975850.496044837, 13], [975850.646606954, 5], [975850.819491159, 14], [975851.056588605, 11], [975851.293050065, 32], [975851.489405262, 33], [975851.643960908, 11], [975851.826653806, 6], [975851.977231816, 8], [975852.131363425, 9], [975852.285260576, 13], [975852.437829661, 8], [975852.596980933, 20], [975852.74570188, 17], [975852.898693613, 20], [975853.05514266, 13], [975853.201993348, 2], [975853.352935576, 16], [975853.553871108, 6], [975853.70398697, 15], [975853.851803029, 8], [975854.035287517, 15], [975854.223208305, 16], [975854.463861649, 22], [975854.741530559, 9], [975854.892497189, 8], [975855.047556961, 25], [975855.198387563, 18], [975855.35063311, 13], [975855.547073294, 55], [975855.70076596, 11], [975855.941235409, 10], [975856.082965787, 11], [975856.234948174, 15], [975856.386807635, 17], [975856.549275658, 14], [975856.73230085, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-e4735ba279704a6782d98e1f", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.4426, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1931, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975843.067161274, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.22154479392338544, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 18.969160487250456, "done": 975856.749827976, "finish_reason": "length", "first": 975843.290677191, "full_response_s": 13.68253230501432, "last": 975856.733549382, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975843.290677191, 3], [975843.425702766, 11], [975843.615942974, 30], [975843.787905694, 19], [975843.942301999, 21], [975844.130742651, 15], [975844.27729491, 19], [975844.428844544, 17], [975844.588848481, 6], [975844.736776213, 11], [975844.886362068, 5], [975845.076203252, 27], [975845.258994611, 12], [975845.448811587, 13], [975845.602759793, 5], [975845.74974798, 16], [975845.933069217, 5], [975846.123027729, 16], [975846.308485127, 7], [975846.467494948, 22], [975846.618579332, 10], [975846.801368758, 7], [975846.990375951, 23], [975847.14267911, 5], [975847.292063327, 9], [975847.477240958, 14], [975847.62669591, 20], [975847.775053079, 8], [975847.926310151, 12], [975848.084971089, 5], [975848.234636198, 14], [975848.382636449, 11], [975848.542045178, 7], [975848.692979251, 9], [975848.840283982, 8], [975849.015482516, 3], [975849.201486549, 10], [975849.350110645, 11], [975849.545182041, 9], [975849.727988467, 10], [975849.915024255, 20], [975850.066013131, 14], [975850.250909273, 14], [975850.498362065, 13], [975850.645619089, 5], [975850.821384637, 14], [975851.057224815, 11], [975851.290765684, 32], [975851.487984382, 33], [975851.643207965, 11], [975851.82620012, 6], [975851.976275325, 8], [975852.132017762, 9], [975852.285456027, 13], [975852.439962492, 8], [975852.596341059, 20], [975852.743732757, 17], [975852.897330891, 20], [975853.054224073, 13], [975853.202099345, 2], [975853.353045893, 16], [975853.55462989, 6], [975853.704296003, 15], [975853.850106331, 8], [975854.035415178, 15], [975854.222545056, 16], [975854.462913287, 22], [975854.742770931, 9], [975854.892317626, 8], [975855.046050515, 25], [975855.199648975, 18], [975855.351783068, 13], [975855.547512212, 55], [975855.699478741, 11], [975855.941995808, 10], [975856.083962564, 11], [975856.232938411, 15], [975856.386363693, 17], [975856.545436241, 14], [975856.733549382, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4c5389996aec49258bdda13f", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.4426, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1931, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975843.067295671, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.22338152001611888, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 18.970158283493664, "done": 975856.748794495, "finish_reason": "length", "first": 975843.290402173, "full_response_s": 13.68100681900978, "last": 975856.732567293, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975843.290402173, 3], [975843.426716407, 11], [975843.612787238, 30], [975843.787961725, 19], [975843.942109347, 21], [975844.131836386, 15], [975844.277460698, 19], [975844.428187774, 17], [975844.587253301, 6], [975844.735515362, 11], [975844.886146889, 5], [975845.076706808, 27], [975845.25744087, 12], [975845.447630126, 13], [975845.602158158, 5], [975845.748873536, 16], [975845.932640651, 5], [975846.121409734, 16], [975846.306384694, 7], [975846.467906362, 22], [975846.617959538, 10], [975846.800858898, 7], [975846.990299344, 23], [975847.14433888, 5], [975847.293040921, 9], [975847.476610684, 14], [975847.627893979, 20], [975847.775480445, 8], [975847.926444404, 12], [975848.079980066, 5], [975848.234541048, 14], [975848.379781698, 11], [975848.543681733, 7], [975848.692742184, 9], [975848.840237007, 8], [975849.015529603, 3], [975849.199876122, 10], [975849.349839851, 11], [975849.545112411, 9], [975849.727461055, 10], [975849.912352284, 20], [975850.065325835, 14], [975850.251474844, 14], [975850.499680243, 13], [975850.645857019, 5], [975850.822696847, 14], [975851.056870167, 11], [975851.29052257, 32], [975851.488040269, 33], [975851.641945113, 11], [975851.826370388, 6], [975851.975855351, 8], [975852.131200101, 9], [975852.284806362, 13], [975852.43986891, 8], [975852.596916166, 20], [975852.743861954, 17], [975852.897651332, 20], [975853.056718304, 13], [975853.201837735, 2], [975853.352587215, 16], [975853.553064422, 6], [975853.699199958, 15], [975853.849781362, 8], [975854.036533777, 15], [975854.225544477, 16], [975854.463215072, 22], [975854.744233554, 9], [975854.891538827, 8], [975855.045847271, 25], [975855.19764822, 18], [975855.350268958, 13], [975855.546705254, 55], [975855.699180507, 11], [975855.942214171, 10], [975856.083283636, 11], [975856.235151193, 15], [975856.389096544, 17], [975856.546262846, 14], [975856.732567293, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-afc83df5b3db4beaa746d31f", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.4427, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1931, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975843.067787676, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.22261449694633484, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 18.97226858455247, "done": 975856.7484214, "finish_reason": "length", "first": 975843.292634635, "full_response_s": 13.680384801933542, "last": 975856.733304572, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975843.292634635, 3], [975843.426627305, 11], [975843.613425608, 30], [975843.788298693, 19], [975843.943414917, 21], [975844.13290833, 15], [975844.281530174, 19], [975844.428117232, 17], [975844.587845, 6], [975844.737448022, 11], [975844.88477444, 5], [975845.072909854, 27], [975845.258302003, 12], [975845.447821018, 13], [975845.601103958, 5], [975845.751740191, 16], [975845.932980755, 5], [975846.122150245, 16], [975846.307238611, 7], [975846.469198877, 22], [975846.617224515, 10], [975846.801246489, 7], [975846.991612691, 23], [975847.143011326, 5], [975847.292390248, 9], [975847.475542709, 14], [975847.626798452, 20], [975847.77488577, 8], [975847.925692661, 12], [975848.081380754, 5], [975848.230351159, 14], [975848.38179538, 11], [975848.542983797, 7], [975848.691981433, 9], [975848.838384041, 8], [975849.015143275, 3], [975849.200638009, 10], [975849.350064934, 11], [975849.545057836, 9], [975849.726813902, 10], [975849.912615126, 20], [975850.065287387, 14], [975850.251892802, 14], [975850.495747372, 13], [975850.644923328, 5], [975850.820220375, 14], [975851.056469264, 11], [975851.291093469, 32], [975851.487072243, 33], [975851.640829106, 11], [975851.825396826, 6], [975851.976112001, 8], [975852.130613458, 9], [975852.284604639, 13], [975852.438596795, 8], [975852.596056409, 20], [975852.745745399, 17], [975852.895637538, 20], [975853.053934271, 13], [975853.201564206, 2], [975853.353256048, 16], [975853.551905456, 6], [975853.70053004, 15], [975853.849995245, 8], [975854.03666403, 15], [975854.221877999, 16], [975854.462036474, 22], [975854.741095801, 9], [975854.892047968, 8], [975855.046321709, 25], [975855.198858561, 18], [975855.351706686, 13], [975855.548418767, 55], [975855.698669847, 11], [975855.93970354, 10], [975856.083463424, 11], [975856.237803598, 15], [975856.386556729, 17], [975856.545638684, 14], [975856.733304572, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-d7fd03d47c474bce98ede6c1", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.4425, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1931, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975843.068036598, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2245980369625613, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 18.9679556528775, "done": 975856.745620199, "finish_reason": "length", "first": 975843.289117723, "full_response_s": 13.677748749032617, "last": 975856.732843798, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975843.289117723, 3], [975843.426378894, 11], [975843.613550101, 30], [975843.789464923, 19], [975843.942919473, 21], [975844.130369844, 15], [975844.278385189, 19], [975844.428038354, 17], [975844.587777258, 6], [975844.734750387, 11], [975844.883937867, 5], [975845.076087446, 27], [975845.257083518, 12], [975845.447453186, 13], [975845.601601979, 5], [975845.748066946, 16], [975845.932210948, 5], [975846.122415935, 16], [975846.308353082, 7], [975846.466721909, 22], [975846.618700449, 10], [975846.801119884, 7], [975846.991013616, 23], [975847.142756868, 5], [975847.292879005, 9], [975847.475624083, 14], [975847.625938583, 20], [975847.776196573, 8], [975847.925849474, 12], [975848.080263004, 5], [975848.233385315, 14], [975848.38030087, 11], [975848.541554373, 7], [975848.693488919, 9], [975848.839428129, 8], [975849.014092947, 3], [975849.200097509, 10], [975849.350314032, 11], [975849.545561761, 9], [975849.72691406, 10], [975849.91328887, 20], [975850.066093705, 14], [975850.251952065, 14], [975850.496209489, 13], [975850.646271122, 5], [975850.82485347, 14], [975851.062029074, 11], [975851.291986697, 32], [975851.488960312, 33], [975851.641641136, 11], [975851.825842432, 6], [975851.976967198, 8], [975852.13257655, 9], [975852.291141147, 13], [975852.438863253, 8], [975852.596771929, 20], [975852.745328481, 17], [975852.895477157, 20], [975853.057542366, 13], [975853.203623567, 2], [975853.354856572, 16], [975853.554129998, 6], [975853.698574404, 15], [975853.849502729, 8], [975854.0351364, 15], [975854.222617119, 16], [975854.464723294, 22], [975854.742124562, 9], [975854.891703447, 8], [975855.044380024, 25], [975855.19936095, 18], [975855.351208521, 13], [975855.549902254, 55], [975855.69859772, 11], [975855.942550148, 10], [975856.086323615, 11], [975856.233938852, 15], [975856.386040149, 17], [975856.548637945, 14], [975856.732843798, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-66d292c208e448f8952d3a27", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.4425, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1931, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975843.06787145, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.22124627302400768, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 18.96684066802695, "done": 975856.749215158, "finish_reason": "length", "first": 975843.288509512, "full_response_s": 13.681728771072812, "last": 975856.73302589, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975843.288509512, 3], [975843.427318025, 11], [975843.612571931, 30], [975843.786756088, 19], [975843.941844937, 21], [975844.131922848, 15], [975844.277172065, 19], [975844.42794834, 17], [975844.587570478, 6], [975844.737176604, 11], [975844.88512008, 5], [975845.072711683, 27], [975845.260148489, 12], [975845.44911678, 13], [975845.602651667, 5], [975845.748318476, 16], [975845.935812787, 5], [975846.121838364, 16], [975846.306028606, 7], [975846.469356377, 22], [975846.618459783, 10], [975846.800537529, 7], [975846.99111859, 23], [975847.142835026, 5], [975847.293914405, 9], [975847.475204316, 14], [975847.628123158, 20], [975847.77586618, 8], [975847.926572513, 12], [975848.081925206, 5], [975848.23173148, 14], [975848.380533697, 11], [975848.542115272, 7], [975848.692099238, 9], [975848.840153057, 8], [975849.013732763, 3], [975849.203649989, 10], [975849.35245408, 11], [975849.545260711, 9], [975849.7267188, 10], [975849.912676612, 20], [975850.065690194, 14], [975850.25208787, 14], [975850.49874932, 13], [975850.645260761, 5], [975850.819267821, 14], [975851.059813188, 11], [975851.290874642, 32], [975851.487571368, 33], [975851.641824492, 11], [975851.826311446, 6], [975851.978063125, 8], [975852.132806897, 9], [975852.285899361, 13], [975852.440927319, 8], [975852.596836488, 20], [975852.746989323, 17], [975852.8980179, 20], [975853.05699233, 13], [975853.202555399, 2], [975853.355412896, 16], [975853.554017296, 6], [975853.700383195, 15], [975853.850689118, 8], [975854.035566087, 15], [975854.222245271, 16], [975854.464066701, 22], [975854.741386802, 9], [975854.8932625, 8], [975855.0451158, 25], [975855.197052234, 18], [975855.350165425, 13], [975855.546946672, 55], [975855.700281811, 11], [975855.941958305, 10], [975856.08363582, 11], [975856.233583628, 15], [975856.387069885, 17], [975856.547669214, 14], [975856.73302589, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-acfcedec659c4834aaf3cdc8", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.4427, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1931, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975843.067486387, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.22102312499191612, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 18.971735563041868, "done": 975856.747909299, "finish_reason": "length", "first": 975843.291890972, "full_response_s": 13.680529149947688, "last": 975856.732938532, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975843.291890972, 3], [975843.424848593, 11], [975843.613707297, 30], [975843.78703029, 19], [975843.942639991, 21], [975844.130445666, 15], [975844.276503744, 19], [975844.431543122, 17], [975844.589982231, 6], [975844.735443139, 11], [975844.883994618, 5], [975845.074815475, 27], [975845.257200268, 12], [975845.447316629, 13], [975845.60209224, 5], [975845.748254286, 16], [975845.932771224, 5], [975846.121325607, 16], [975846.306138764, 7], [975846.467074509, 22], [975846.617521132, 10], [975846.800753044, 7], [975846.988933823, 23], [975847.143087197, 5], [975847.294099233, 9], [975847.47731926, 14], [975847.626918417, 20], [975847.774983272, 8], [975847.92576834, 12], [975848.080511366, 5], [975848.231430239, 14], [975848.379057922, 11], [975848.542338483, 7], [975848.692850789, 9], [975848.840327197, 8], [975849.016353936, 3], [975849.200446765, 10], [975849.351168013, 11], [975849.544696548, 9], [975849.727257588, 10], [975849.912985661, 20], [975850.065808704, 14], [975850.250684286, 14], [975850.495913784, 13], [975850.645094061, 5], [975850.820760283, 14], [975851.058602895, 11], [975851.294334244, 32], [975851.488574001, 33], [975851.641734174, 11], [975851.825216639, 6], [975851.975675963, 8], [975852.130412567, 9], [975852.284750491, 13], [975852.439549798, 8], [975852.598138379, 20], [975852.749398117, 17], [975852.895722048, 20], [975853.055737143, 13], [975853.202898751, 2], [975853.354382183, 16], [975853.552489619, 6], [975853.701300902, 15], [975853.849424426, 8], [975854.036580992, 15], [975854.222692925, 16], [975854.465235762, 22], [975854.7409495, 9], [975854.893152823, 8], [975855.044932748, 25], [975855.199205433, 18], [975855.349686204, 13], [975855.547716847, 55], [975855.698754821, 11], [975855.939684724, 10], [975856.085451971, 11], [975856.234686884, 15], [975856.392391686, 17], [975856.545530255, 14], [975856.732938532, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-5d9e9fc90f0343568ae367eb", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.4425, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1931, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975843.067380149, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.22451082291081548, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 18.968362716172717, "done": 975856.749778089, "finish_reason": "length", "first": 975843.289343077, "full_response_s": 13.681835729046725, "last": 975856.732780648, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975843.289343077, 3], [975843.427404295, 11], [975843.613763456, 30], [975843.787728354, 19], [975843.941625902, 21], [975844.134718097, 15], [975844.278585441, 19], [975844.428706787, 17], [975844.587514447, 6], [975844.736622088, 11], [975844.884703962, 5], [975845.07320204, 27], [975845.257578099, 12], [975845.446645572, 13], [975845.601758695, 5], [975845.748520488, 16], [975845.934700268, 5], [975846.120827779, 16], [975846.309074393, 7], [975846.46756389, 22], [975846.618099263, 10], [975846.801559442, 7], [975846.991769023, 23], [975847.142898305, 5], [975847.293525982, 9], [975847.476375074, 14], [975847.62635427, 20], [975847.777377026, 8], [975847.92707543, 12], [975848.081107288, 5], [975848.23285779, 14], [975848.379953518, 11], [975848.541215533, 7], [975848.693370762, 9], [975848.838628659, 8], [975849.014807075, 3], [975849.200324944, 10], [975849.352671995, 11], [975849.54601055, 9], [975849.727391537, 10], [975849.914204882, 20], [975850.067702757, 14], [975850.251630648, 14], [975850.499429192, 13], [975850.645924554, 5], [975850.823080534, 14], [975851.058508674, 11], [975851.292894372, 32], [975851.487166097, 33], [975851.643795728, 11], [975851.828958586, 6], [975851.97677525, 8], [975852.13272349, 9], [975852.287043944, 13], [975852.437540275, 8], [975852.597217167, 20], [975852.745803846, 17], [975852.900097341, 20], [975853.054103771, 13], [975853.202331244, 2], [975853.354273177, 16], [975853.553916883, 6], [975853.700120177, 15], [975853.852285738, 8], [975854.035978845, 15], [975854.222455106, 16], [975854.463404876, 22], [975854.742206304, 9], [975854.892770415, 8], [975855.044847822, 25], [975855.197718475, 18], [975855.351119483, 13], [975855.548887189, 55], [975855.698850691, 11], [975855.940087659, 10], [975856.08352723, 11], [975856.236060373, 15], [975856.388194596, 17], [975856.545853479, 14], [975856.732780648, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-c2c8ac5a5feb40caa786a71e", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.4426, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1931, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975843.06794236, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2214007170405239, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 18.967804880967222, "done": 975856.748959931, "finish_reason": "length", "first": 975843.289638655, "full_response_s": 13.681391001911834, "last": 975856.733471592, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975843.289638655, 3], [975843.426014391, 11], [975843.614874311, 30], [975843.787787265, 19], [975843.944681609, 21], [975844.133122165, 15], [975844.280855533, 19], [975844.428919326, 17], [975844.587637053, 6], [975844.737903323, 11], [975844.883651842, 5], [975845.07431771, 27], [975845.257357416, 12], [975845.449390582, 13], [975845.602567429, 5], [975845.749339893, 16], [975845.933711043, 5], [975846.121201002, 16], [975846.307994562, 7], [975846.467277353, 22], [975846.617606602, 10], [975846.802296001, 7], [975846.991395607, 23], [975847.144596826, 5], [975847.293654459, 9], [975847.477050546, 14], [975847.626622344, 20], [975847.775926707, 8], [975847.926877578, 12], [975848.081791049, 5], [975848.234232991, 14], [975848.379307757, 11], [975848.544160842, 7], [975848.69302429, 9], [975848.839604045, 8], [975849.016576107, 3], [975849.200928194, 10], [975849.350404894, 11], [975849.544575479, 9], [975849.727655883, 10], [975849.913157897, 20], [975850.066217254, 14], [975850.251194434, 14], [975850.497739839, 13], [975850.648391874, 5], [975850.82230076, 14], [975851.057953694, 11], [975851.293102111, 32], [975851.487350925, 33], [975851.642322609, 11], [975851.827513259, 6], [975851.978015878, 8], [975852.131093815, 9], [975852.286909867, 13], [975852.438713753, 8], [975852.596576622, 20], [975852.744608401, 17], [975852.896498814, 20], [975853.053675253, 13], [975853.201687995, 2], [975853.352466722, 16], [975853.553149076, 6], [975853.701543057, 15], [975853.852698736, 8], [975854.035659989, 15], [975854.223521962, 16], [975854.461642579, 22], [975854.741648412, 9], [975854.892620211, 8], [975855.045415089, 25], [975855.199769868, 18], [975855.350391884, 13], [975855.549472072, 55], [975855.697931224, 11], [975855.942067374, 10], [975856.083722842, 11], [975856.234364795, 15], [975856.38765176, 17], [975856.547934121, 14], [975856.733471592, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-c81fd7612d3b4ddd9e6d8fdb", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.4427, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1931, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975843.067568929, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.22206972597632557, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 18.965999826853015, "done": 975856.747449022, "finish_reason": "length", "first": 975843.288742035, "full_response_s": 13.679468311020173, "last": 975856.733854464, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975843.288742035, 3], [975843.425487011, 11], [975843.614401073, 30], [975843.78807409, 19], [975843.942239392, 21], [975844.130958102, 15], [975844.277804418, 19], [975844.427801415, 17], [975844.58943834, 6], [975844.735907241, 11], [975844.884946868, 5], [975845.073529968, 27], [975845.259259229, 12], [975845.447202168, 13], [975845.603142152, 5], [975845.749661614, 16], [975845.933214734, 5], [975846.120996271, 16], [975846.30674067, 7], [975846.466509274, 22], [975846.618259307, 10], [975846.800619783, 7], [975846.990518187, 23], [975847.144040247, 5], [975847.294170176, 9], [975847.475701601, 14], [975847.62582193, 20], [975847.775715112, 8], [975847.925433211, 12], [975848.080397224, 5], [975848.23322567, 14], [975848.380230776, 11], [975848.541971132, 7], [975848.692792311, 9], [975848.839164839, 8], [975849.0138706, 3], [975849.199633295, 10], [975849.349554769, 11], [975849.54639323, 9], [975849.727551581, 10], [975849.912412714, 20], [975850.065233709, 14], [975850.251767925, 14], [975850.49582497, 13], [975850.64821887, 5], [975850.81982192, 14], [975851.057493225, 11], [975851.291231994, 32], [975851.486989749, 33], [975851.641185002, 11], [975851.8267363, 6], [975851.976358603, 8], [975852.129882243, 9], [975852.283846384, 13], [975852.438332593, 8], [975852.595700401, 20], [975852.743549001, 17], [975852.895350856, 20], [975853.054704526, 13], [975853.202237294, 2], [975853.354035167, 16], [975853.553412238, 6], [975853.699057049, 15], [975853.850328326, 8], [975854.03638762, 15], [975854.221705987, 16], [975854.461542598, 22], [975854.74122823, 9], [975854.891632009, 8], [975855.044562452, 25], [975855.197312452, 18], [975855.349369267, 13], [975855.548094151, 55], [975855.698386141, 11], [975855.940715469, 10], [975856.08333573, 11], [975856.233781928, 15], [975856.387968137, 17], [975856.545931814, 14], [975856.733854464, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-dde0133a76b5454cb9093b85", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.4425, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1931, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975843.067980711, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.22076132404617965, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 18.96452886309616, "done": 975856.746747933, "finish_reason": "length", "first": 975843.288664101, "full_response_s": 13.679129916941747, "last": 975856.734819386, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975843.288664101, 3], [975843.425901369, 11], [975843.61382835, 30], [975843.787850767, 19], [975843.943925114, 21], [975844.13169439, 15], [975844.276716475, 19], [975844.428647188, 17], [975844.587440353, 6], [975844.735263255, 11], [975844.884248612, 5], [975845.073121274, 27], [975845.25752626, 12], [975845.448478667, 13], [975845.600305096, 5], [975845.748395146, 16], [975845.935328814, 5], [975846.121527843, 16], [975846.307429758, 7], [975846.46827213, 22], [975846.617792854, 10], [975846.801042222, 7], [975846.990929154, 23], [975847.144268178, 5], [975847.292798735, 9], [975847.476183654, 14], [975847.627656848, 20], [975847.776330218, 8], [975847.927015575, 12], [975848.081316628, 5], [975848.230574226, 14], [975848.380409764, 11], [975848.543160625, 7], [975848.693759489, 9], [975848.839712955, 8], [975849.015245913, 3], [975849.203441129, 10], [975849.349902265, 11], [975849.544921455, 9], [975849.727505406, 10], [975849.913544081, 20], [975850.067139746, 14], [975850.250748988, 14], [975850.497259817, 13], [975850.646675673, 5], [975850.820507217, 14], [975851.057106785, 11], [975851.292123638, 32], [975851.489103509, 33], [975851.64298773, 11], [975851.825504936, 6], [975851.97836307, 8], [975852.132163119, 9], [975852.28559676, 13], [975852.437735487, 8], [975852.598836971, 20], [975852.746607396, 17], [975852.896406672, 20], [975853.054285655, 13], [975853.202441866, 2], [975853.354921963, 16], [975853.555116328, 6], [975853.6989067, 15], [975853.850221528, 8], [975854.036107003, 15], [975854.222871561, 16], [975854.462988757, 22], [975854.743348806, 9], [975854.892549284, 8], [975855.044497094, 25], [975855.198099954, 18], [975855.351456708, 13], [975855.550863096, 55], [975855.699692768, 11], [975855.941900098, 10], [975856.08594588, 11], [975856.234873807, 15], [975856.387466629, 17], [975856.549865549, 14], [975856.734819386, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-1cc2d9f3737c48329bca039e", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.4427, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1931, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975843.067618016, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.22104608500376344, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "python", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 30, "case_id": null, "complete": true, "decode_tps": 18.966080851996175, "done": 975856.746312439, "finish_reason": "length", "first": 975843.289035308, "full_response_s": 13.67950656497851, "last": 975856.734090298, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975843.289035308, 3], [975843.425359669, 11], [975843.613627875, 30], [975843.790529203, 19], [975843.944081926, 21], [975844.132311064, 15], [975844.280138414, 19], [975844.428348043, 17], [975844.58791367, 6], [975844.734921567, 11], [975844.884456223, 5], [975845.073663613, 27], [975845.258640603, 12], [975845.449184667, 13], [975845.601035848, 5], [975845.748181247, 16], [975845.932462223, 5], [975846.120516618, 16], [975846.308640723, 7], [975846.466986863, 22], [975846.618027345, 10], [975846.800422956, 7], [975846.98959816, 23], [975847.14453446, 5], [975847.293713514, 9], [975847.476526766, 14], [975847.626282943, 20], [975847.776039296, 8], [975847.926132427, 12], [975848.079206243, 5], [975848.232378729, 14], [975848.379504168, 11], [975848.543982894, 7], [975848.693833231, 9], [975848.839549086, 8], [975849.016291681, 3], [975849.201066895, 10], [975849.349775084, 11], [975849.544985534, 9], [975849.727020665, 10], [975849.913661854, 20], [975850.06630914, 14], [975850.250822043, 14], [975850.49598567, 13], [975850.647179117, 5], [975850.821450619, 14], [975851.057392411, 11], [975851.291711887, 32], [975851.48791344, 33], [975851.644051818, 11], [975851.828401911, 6], [975851.977942904, 8], [975852.131882453, 9], [975852.286180635, 13], [975852.438167381, 8], [975852.597724084, 20], [975852.74598069, 17], [975852.899256912, 20], [975853.053995614, 13], [975853.202488073, 2], [975853.353180018, 16], [975853.554323129, 6], [975853.701831499, 15], [975853.850381093, 8], [975854.035760002, 15], [975854.225160405, 16], [975854.465844357, 22], [975854.747624917, 9], [975854.892843694, 8], [975855.044740736, 25], [975855.200254401, 18], [975855.350870449, 13], [975855.547598274, 55], [975855.69904763, 11], [975855.941669143, 10], [975856.082906956, 11], [975856.236659815, 15], [975856.385636622, 17], [975856.54645825, 14], [975856.734090298, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-d234ad01d5c04302aabc5def", "runtime": {"accepted": 176, "cached": 30, "decode_s": 13.4425, "drafted": 369, "drafts": true, "min_rows": 4, "prefill_s": 0.1931, "rounds": 79, "token_sha": "8a91591c94a3"}, "seed": 1234, "sent": 975843.066805874, "speculative": {}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.22222943394444883, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 30}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 369, "rounds": 79}, "work_source": "tensorfold"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "candidate", "burst": null, "phase": "uncached_first_use", "prompt": "code", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 69.68209806744301, "done": 975495.050454404, "finish_reason": "length", "first": 975491.390939126, "full_response_s": 3.8033633729210123, "last": 975495.050415621, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975491.390939126, 2], [975491.477087901, 7], [975491.556897077, 4], [975491.636702413, 73], [975491.716780684, 51], [975491.796775007, 21], [975491.877497805, 14], [975491.957338374, 20], [975492.037226158, 16], [975492.118209109, 15], [975492.204484459, 23], [975492.287773499, 23], [975492.368440044, 25], [975492.448621131, 36], [975492.529679055, 14], [975492.609838543, 6], [975492.690179305, 18], [975492.770136591, 18], [975492.852501613, 19], [975492.9335289, 8], [975493.013456941, 11], [975493.095156257, 18], [975493.18049007, 15], [975493.263962772, 39], [975493.34455724, 30], [975493.425300041, 14], [975493.505767201, 15], [975493.586043024, 8], [975493.666769393, 6], [975493.747155452, 15], [975493.827116357, 23], [975493.908155998, 22], [975493.988216086, 26], [975494.0693615, 35], [975494.15160965, 31], [975494.237952923, 12], [975494.320056484, 13], [975494.400779976, 38], [975494.481698053, 47], [975494.561892393, 25], [975494.642259607, 11], [975494.722502921, 34], [975494.802821336, 12], [975494.886125984, 36], [975494.965882019, 60], [975495.050415621, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-73e9d0950b8b36617226494c96b0626a", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.128536336, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 3.65975196, "time_to_first_token": 0.129361399, "token_sha": "2b28aa2108de", "tokens_per_second": 69.67685318214845}, "seed": 1234, "sent": 975491.247091031, "speculative": {"acceptance_rate": 0.31555555555555553, "accepted": 213, "drafted": 675, "rounds": 45, "tokens_per_round": 5.688888888888889}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.14384809497278184, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 270}, "work": {"accepted": 213, "drafted": 675, "rounds": 45}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 69.60973560490154, "done": 975498.724605786, "finish_reason": "length", "first": 975495.061290061, "full_response_s": 3.6724140100413933, "last": 975498.724570747, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975495.061290061, 2], [975495.149416642, 7], [975495.235877339, 4], [975495.317200846, 73], [975495.398220635, 51], [975495.478295028, 21], [975495.558268497, 14], [975495.638204831, 20], [975495.718258921, 16], [975495.798441071, 15], [975495.87917375, 23], [975495.959878863, 23], [975496.04076197, 25], [975496.120691795, 36], [975496.207020385, 14], [975496.290417833, 6], [975496.371399241, 18], [975496.451309306, 18], [975496.531412661, 19], [975496.611415011, 8], [975496.692189626, 11], [975496.772334451, 18], [975496.854544768, 15], [975496.935250555, 39], [975497.015727293, 30], [975497.096721199, 14], [975497.181947506, 15], [975497.266226433, 8], [975497.346337998, 6], [975497.427404783, 15], [975497.507424335, 23], [975497.588191032, 22], [975497.668498991, 26], [975497.749125005, 35], [975497.82912019, 31], [975497.910109619, 12], [975497.990463595, 13], [975498.071342227, 38], [975498.153371849, 47], [975498.240526516, 25], [975498.321507161, 11], [975498.40242872, 34], [975498.482764953, 12], [975498.563091554, 36], [975498.642860188, 60], [975498.724570747, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-26101eda917797f133722034c6a53748", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.008061628, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 3.663323613, "time_to_first_token": 0.008365235, "token_sha": "2b28aa2108de", "tokens_per_second": 69.6089199149876}, "seed": 1234, "sent": 975495.052191776, "speculative": {"acceptance_rate": 0.31555555555555553, "accepted": 213, "drafted": 675, "rounds": 45, "tokens_per_round": 5.688888888888889}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.009098284994252026, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 213, "drafted": 675, "rounds": 45}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 69.5278153956902, "done": 975502.406446989, "finish_reason": "length", "first": 975498.738814637, "full_response_s": 3.670958764036186, "last": 975502.406411534, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975498.738814637, 2], [975498.826230321, 7], [975498.91049751, 4], [975498.990182372, 73], [975499.071027152, 51], [975499.152075094, 21], [975499.238324446, 14], [975499.319746137, 20], [975499.400358044, 16], [975499.480675415, 15], [975499.560659229, 23], [975499.640611348, 23], [975499.720969662, 25], [975499.80139495, 36], [975499.882767732, 14], [975499.962740173, 6], [975500.044122587, 18], [975500.124208032, 18], [975500.210441804, 19], [975500.29333206, 8], [975500.3742718, 11], [975500.454481865, 18], [975500.534442546, 15], [975500.615097285, 39], [975500.695265, 30], [975500.775751009, 14], [975500.858097955, 15], [975500.939360279, 8], [975501.019365841, 6], [975501.100133236, 15], [975501.185239556, 23], [975501.269311412, 22], [975501.349603813, 26], [975501.430698494, 35], [975501.511086844, 31], [975501.591398717, 12], [975501.671870136, 13], [975501.752094716, 38], [975501.832275937, 47], [975501.913389916, 25], [975501.9937919, 11], [975502.075081505, 34], [975502.156571249, 12], [975502.242545194, 36], [975502.323965995, 60], [975502.406411534, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-a37180ac47e9fd37a7ae6eb67edc52e4", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.002235037, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 3.667455029, "time_to_first_token": 0.002819355, "token_sha": "2b28aa2108de", "tokens_per_second": 69.53050493697}, "seed": 1234, "sent": 975498.735488225, "speculative": {"acceptance_rate": 0.31555555555555553, "accepted": 213, "drafted": 675, "rounds": 45, "tokens_per_round": 5.688888888888889}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.003326411941088736, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 213, "drafted": 675, "rounds": 45}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 69.65385665735059, "done": 975506.081957307, "finish_reason": "length", "first": 975502.420959033, "full_response_s": 3.664290318964049, "last": 975506.081919276, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975502.420959033, 2], [975502.509189918, 7], [975502.58952424, 4], [975502.669503309, 73], [975502.749790497, 51], [975502.830672212, 21], [975502.912802146, 14], [975502.992632678, 20], [975503.073303681, 16], [975503.154429293, 15], [975503.24082774, 23], [975503.322223345, 23], [975503.403716819, 25], [975503.483774624, 36], [975503.564331294, 14], [975503.644752896, 6], [975503.725136147, 18], [975503.805119074, 18], [975503.885902571, 19], [975503.965897564, 8], [975504.046780563, 11], [975504.126824659, 18], [975504.213204628, 15], [975504.296104702, 39], [975504.377113537, 30], [975504.457335436, 14], [975504.537883164, 15], [975504.618427821, 8], [975504.698424558, 6], [975504.778596394, 15], [975504.861812476, 23], [975504.942195316, 22], [975505.022347891, 26], [975505.103696142, 35], [975505.189231627, 31], [975505.273222887, 12], [975505.353800345, 13], [975505.434872028, 38], [975505.516169129, 47], [975505.596762138, 25], [975505.6777504, 11], [975505.758152839, 34], [975505.83847949, 12], [975505.919284591, 36], [975505.999593084, 60], [975506.081919276, 48]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-802b089c86966854a61ea76da9417997", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.002234477, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 3.660978898, "time_to_first_token": 0.002618417, "token_sha": "2b28aa2108de", "tokens_per_second": 69.65350172854232}, "seed": 1234, "sent": 975502.417666988, "speculative": {"acceptance_rate": 0.31555555555555553, "accepted": 213, "drafted": 675, "rounds": 45, "tokens_per_round": 5.688888888888889}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.0032920449739322066, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 213, "drafted": 675, "rounds": 45}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.565471656859945, "done": 975516.343907181, "finish_reason": "length", "first": 975506.369485533, "full_response_s": 10.244359409087338, "last": 975516.343876126, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975506.369485533, 2], [975506.5194753, 7], [975506.664587214, 4], [975506.878926865, 63], [975507.110849242, 10], [975507.300089328, 31], [975507.480343091, 29], [975507.661388878, 22], [975507.843376877, 14], [975508.027608286, 24], [975508.2140719, 4], [975508.360462744, 13], [975508.541059349, 21], [975508.722181683, 2], [975508.9059693, 18], [975509.085841293, 29], [975509.3239323, 27], [975509.558792971, 24], [975509.709007273, 4], [975509.879581545, 16], [975510.117404279, 10], [975510.305146042, 31], [975510.452931524, 8], [975510.632279361, 11], [975510.817234264, 16], [975511.001381195, 12], [975511.185533887, 39], [975511.360705757, 18], [975511.543762225, 11], [975511.723020551, 16], [975511.90752405, 16], [975512.05593725, 11], [975512.245099094, 6], [975512.428755134, 9], [975512.611697258, 29], [975512.791429991, 22], [975512.97768199, 8], [975513.124968076, 18], [975513.318221627, 18], [975513.501216796, 34], [975513.678606275, 10], [975513.862182211, 14], [975514.045670266, 13], [975514.232955745, 2], [975514.41725728, 36], [975514.600681465, 42], [975514.784320331, 26], [975514.934127038, 17], [975515.11991887, 34], [975515.361949066, 12], [975515.544066703, 36], [975515.827769343, 50], [975516.010599556, 2], [975516.343876126, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-9e3c6c3cdb12ca3caf0e3a0d57a95915", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.173211584, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.974249844, "time_to_first_token": 0.262532814, "token_sha": "2b28aa2108de", "tokens_per_second": 25.56583241730154}, "seed": 1234, "sent": 975506.099547772, "speculative": {"acceptance_rate": 0.559228650137741, "accepted": 203, "drafted": 363, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.26993776101153344, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 363, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.566019051837774, "done": 975516.343512313, "finish_reason": "length", "first": 975506.369301699, "full_response_s": 10.245407777023502, "last": 975516.34347873, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975506.369301699, 2], [975506.519258011, 7], [975506.665033136, 4], [975506.878751062, 63], [975507.11167469, 10], [975507.299202811, 31], [975507.480538477, 29], [975507.661887487, 22], [975507.84322381, 14], [975508.025420224, 24], [975508.214339157, 4], [975508.363290195, 13], [975508.542539753, 21], [975508.725947507, 2], [975508.903641754, 18], [975509.086092085, 29], [975509.326507263, 27], [975509.560344893, 24], [975509.708498568, 4], [975509.879686485, 16], [975510.118132289, 10], [975510.305793446, 31], [975510.451717864, 8], [975510.632684917, 11], [975510.81622431, 16], [975511.000257229, 12], [975511.184334514, 39], [975511.360365352, 18], [975511.541339722, 11], [975511.721951846, 16], [975511.904991774, 16], [975512.054258084, 11], [975512.245162468, 6], [975512.427774411, 9], [975512.608800769, 29], [975512.790698428, 22], [975512.976076517, 8], [975513.124402428, 18], [975513.315203909, 18], [975513.498545723, 34], [975513.679093476, 10], [975513.861449721, 14], [975514.045142346, 13], [975514.234188924, 2], [975514.418216003, 36], [975514.598820976, 42], [975514.783211068, 26], [975514.935383081, 17], [975515.116551018, 34], [975515.3610517, 12], [975515.54483172, 36], [975515.828180818, 50], [975516.010540405, 2], [975516.34347873, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-87e48055a4bbb9f93a5cfd8abe8d0b62", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.173051477, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.97424674, "time_to_first_token": 0.264842314, "token_sha": "2b28aa2108de", "tokens_per_second": 25.565840373425534}, "seed": 1234, "sent": 975506.098104536, "speculative": {"acceptance_rate": 0.559228650137741, "accepted": 203, "drafted": 363, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.27119716303423047, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 363, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.56778618687673, "done": 975516.343260208, "finish_reason": "length", "first": 975506.369744086, "full_response_s": 10.242641572025605, "last": 975516.343231745, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975506.369744086, 2], [975506.51722004, 7], [975506.665293528, 4], [975506.879489872, 63], [975507.111415033, 10], [975507.300555442, 31], [975507.481948131, 29], [975507.660828894, 22], [975507.844508379, 14], [975508.024164437, 24], [975508.213979727, 4], [975508.361776337, 13], [975508.540588323, 21], [975508.724027436, 2], [975508.904601437, 18], [975509.085499959, 29], [975509.324871456, 27], [975509.559066627, 24], [975509.71049198, 4], [975509.880712407, 16], [975510.119534567, 10], [975510.304470494, 31], [975510.45199944, 8], [975510.63360657, 11], [975510.817858901, 16], [975511.000612514, 12], [975511.185842517, 39], [975511.36048658, 18], [975511.541511332, 11], [975511.724194084, 16], [975511.905666778, 16], [975512.055272406, 11], [975512.243446439, 6], [975512.42835105, 9], [975512.610457023, 29], [975512.791714126, 22], [975512.978444063, 8], [975513.1246813, 18], [975513.317550767, 18], [975513.500750873, 34], [975513.678490278, 10], [975513.862804017, 14], [975514.045431841, 13], [975514.234048064, 2], [975514.416950153, 36], [975514.600239814, 42], [975514.78402586, 26], [975514.933619933, 17], [975515.117105562, 34], [975515.359711996, 12], [975515.542458798, 36], [975515.827281693, 50], [975516.010501271, 2], [975516.343231745, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-5a7a42e0e58323db5a51fc0b67650f92", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.173168513, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.974177494, "time_to_first_token": 0.263176412, "token_sha": "2b28aa2108de", "tokens_per_second": 25.566017864971435}, "seed": 1234, "sent": 975506.100618636, "speculative": {"acceptance_rate": 0.559228650137741, "accepted": 203, "drafted": 363, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2691254500532523, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 363, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.563854179974836, "done": 975516.343108597, "finish_reason": "length", "first": 975506.368037865, "full_response_s": 10.239822297007777, "last": 975516.343059558, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975506.368037865, 2], [975506.519377335, 7], [975506.666481653, 4], [975506.879120107, 63], [975507.112174419, 10], [975507.299303288, 31], [975507.482041104, 29], [975507.661294816, 22], [975507.842906939, 14], [975508.028168765, 24], [975508.213768166, 4], [975508.360574148, 13], [975508.542304416, 21], [975508.725855605, 2], [975508.904234952, 18], [975509.085301213, 29], [975509.327755354, 27], [975509.559761262, 24], [975509.707462871, 4], [975509.87939123, 16], [975510.119587702, 10], [975510.306330246, 31], [975510.453898631, 8], [975510.632964525, 11], [975510.816579691, 16], [975511.003506172, 12], [975511.183982621, 39], [975511.361981863, 18], [975511.542076276, 11], [975511.723287583, 16], [975511.906591518, 16], [975512.054161447, 11], [975512.243200831, 6], [975512.430709523, 9], [975512.60994739, 29], [975512.792876908, 22], [975512.979239031, 8], [975513.125572666, 18], [975513.316188248, 18], [975513.499017005, 34], [975513.679303582, 10], [975513.862493002, 14], [975514.045863157, 13], [975514.234235243, 2], [975514.417952539, 36], [975514.600029196, 42], [975514.785071909, 26], [975514.933464642, 17], [975515.118885333, 34], [975515.362376797, 12], [975515.541926878, 36], [975515.829114631, 50], [975516.010935834, 2], [975516.343059558, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8e0f8cc6dd3fdece0f3940a91fedf697", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.173262239, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.974153846, "time_to_first_token": 0.261744486, "token_sha": "2b28aa2108de", "tokens_per_second": 25.566078480157422}, "seed": 1234, "sent": 975506.1032863, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2647515650605783, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.56910758563322, "done": 975516.342828813, "finish_reason": "length", "first": 975506.369806436, "full_response_s": 10.244272066978738, "last": 975516.34277867, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975506.369806436, 2], [975506.51975638, 7], [975506.665606639, 4], [975506.878687336, 63], [975507.111218671, 10], [975507.299700908, 31], [975507.480914946, 29], [975507.662573338, 22], [975507.843970523, 14], [975508.026561485, 24], [975508.21335093, 4], [975508.359917208, 13], [975508.541210753, 21], [975508.72476727, 2], [975508.905171644, 18], [975509.085951753, 29], [975509.326765847, 27], [975509.561401277, 24], [975509.709605319, 4], [975509.881506479, 16], [975510.118922201, 10], [975510.307352856, 31], [975510.452683387, 8], [975510.632634455, 11], [975510.815954414, 16], [975511.001876396, 12], [975511.185396147, 39], [975511.361349898, 18], [975511.544836769, 11], [975511.722192079, 16], [975511.907441413, 16], [975512.05344894, 11], [975512.243836348, 6], [975512.428454119, 9], [975512.609682726, 29], [975512.791614737, 22], [975512.978515885, 8], [975513.125406047, 18], [975513.316570076, 18], [975513.499845428, 34], [975513.678962104, 10], [975513.861518535, 14], [975514.045260775, 13], [975514.235893481, 2], [975514.41804316, 36], [975514.600454319, 42], [975514.783771148, 26], [975514.93554306, 17], [975515.118310886, 34], [975515.360414871, 12], [975515.543882436, 36], [975515.827956969, 50], [975516.011748434, 2], [975516.34277867, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-2318eca32cb80f8fb9b70fac0041ad66", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.172810556, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.974145735, "time_to_first_token": 0.267430924, "token_sha": "2b28aa2108de", "tokens_per_second": 25.566099270555725}, "seed": 1234, "sent": 975506.098556746, "speculative": {"acceptance_rate": 0.5546448087431693, "accepted": 203, "drafted": 366, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.27124968997668475, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 366, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.569674373573513, "done": 975516.341903752, "finish_reason": "length", "first": 975506.368854704, "full_response_s": 10.243690131930634, "last": 975516.341605873, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975506.368854704, 2], [975506.518533265, 7], [975506.665862727, 4], [975506.878824708, 63], [975507.11067776, 10], [975507.301635282, 31], [975507.481017855, 29], [975507.661789922, 22], [975507.842550102, 14], [975508.024263234, 24], [975508.214135723, 4], [975508.360877163, 13], [975508.541132707, 21], [975508.722358862, 2], [975508.904796519, 18], [975509.085727808, 29], [975509.327922149, 27], [975509.559195455, 24], [975509.708150002, 4], [975509.881093307, 16], [975510.117506164, 10], [975510.30561606, 31], [975510.45150571, 8], [975510.632753379, 11], [975510.816748982, 16], [975511.001929371, 12], [975511.18486645, 39], [975511.36130366, 18], [975511.540955685, 11], [975511.722492486, 16], [975511.905238326, 16], [975512.054595706, 11], [975512.24350231, 6], [975512.429246895, 9], [975512.609102984, 29], [975512.792436201, 22], [975512.976798688, 8], [975513.123970921, 18], [975513.315022842, 18], [975513.499708968, 34], [975513.678842204, 10], [975513.863134023, 14], [975514.044810788, 13], [975514.235984215, 2], [975514.416761886, 36], [975514.599308945, 42], [975514.784217182, 26], [975514.93325564, 17], [975515.120636161, 34], [975515.359209947, 12], [975515.54179333, 36], [975515.826714206, 50], [975516.011497497, 2], [975516.341605873, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-6e47ea8d36544bd1440cae2469d0008a", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.173013206, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.974336849, "time_to_first_token": 0.265348411, "token_sha": "2b28aa2108de", "tokens_per_second": 25.56560940946822}, "seed": 1234, "sent": 975506.09821362, "speculative": {"acceptance_rate": 0.5576923076923077, "accepted": 203, "drafted": 364, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2706410839455202, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 364, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.561057480897908, "done": 975516.344640151, "finish_reason": "length", "first": 975506.368500555, "full_response_s": 10.246154058957472, "last": 975516.34461364, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975506.368500555, 2], [975506.518242281, 7], [975506.664781384, 4], [975506.880099198, 63], [975507.112065526, 10], [975507.301068627, 31], [975507.481402899, 29], [975507.661468971, 22], [975507.842666706, 14], [975508.025234037, 24], [975508.212246307, 4], [975508.360947561, 13], [975508.542014761, 21], [975508.723661543, 2], [975508.903847955, 18], [975509.085215583, 29], [975509.325840435, 27], [975509.561069575, 24], [975509.707998519, 4], [975509.880880722, 16], [975510.116950628, 10], [975510.305713081, 31], [975510.454163487, 8], [975510.632525562, 11], [975510.816147704, 16], [975511.000847723, 12], [975511.185126619, 39], [975511.361753886, 18], [975511.542488311, 11], [975511.722100386, 16], [975511.907229995, 16], [975512.054717495, 11], [975512.244370268, 6], [975512.428076834, 9], [975512.612101102, 29], [975512.791951031, 22], [975512.97719946, 8], [975513.126079339, 18], [975513.315654567, 18], [975513.500096893, 34], [975513.679724801, 10], [975513.862240546, 14], [975514.044941984, 13], [975514.233457426, 2], [975514.416348555, 36], [975514.600151752, 42], [975514.783109455, 26], [975514.935606994, 17], [975515.118007535, 34], [975515.35882591, 12], [975515.542617658, 36], [975515.8274534, 50], [975516.010736944, 2], [975516.34461364, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-b1df060240b64e8dd93dd24d0bf00b59", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.172897802, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.974284595, "time_to_first_token": 0.265608691, "token_sha": "2b28aa2108de", "tokens_per_second": 25.56574334442279}, "seed": 1234, "sent": 975506.098486092, "speculative": {"acceptance_rate": 0.5546448087431693, "accepted": 203, "drafted": 366, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.27001446299254894, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 366, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.56691220910206, "done": 975516.3425869, "finish_reason": "length", "first": 975506.36874322, "full_response_s": 10.244753587991, "last": 975516.342571812, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975506.36874322, 2], [975506.517820774, 7], [975506.66524657, 4], [975506.879642747, 63], [975507.110611313, 10], [975507.299872151, 31], [975507.480596763, 29], [975507.662150471, 22], [975507.842794895, 14], [975508.024929902, 24], [975508.213089322, 4], [975508.362558217, 13], [975508.54169621, 21], [975508.726450484, 2], [975508.903923777, 18], [975509.085656834, 29], [975509.327159787, 27], [975509.559912074, 24], [975509.708247311, 4], [975509.880627977, 16], [975510.119742673, 10], [975510.306567263, 31], [975510.453589824, 8], [975510.632409229, 11], [975510.817381299, 16], [975511.003608681, 12], [975511.184908481, 39], [975511.362493144, 18], [975511.54456609, 11], [975511.7223099, 16], [975511.906439315, 16], [975512.055027342, 11], [975512.244465145, 6], [975512.429272606, 9], [975512.609278898, 29], [975512.791801068, 22], [975512.978972159, 8], [975513.126174296, 18], [975513.317901717, 18], [975513.500489921, 34], [975513.67877027, 10], [975513.862131621, 14], [975514.046050159, 13], [975514.235030947, 2], [975514.417511432, 36], [975514.600091594, 42], [975514.783161982, 26], [975514.93448394, 17], [975515.117648442, 34], [975515.362227617, 12], [975515.543201432, 36], [975515.827905003, 50], [975516.011105125, 2], [975516.342571812, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-185c22d1a62ad83b8cb8987b5ac9cae4", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.172938777, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.974578875, "time_to_first_token": 0.265873899, "token_sha": "2b28aa2108de", "tokens_per_second": 25.564989078298304}, "seed": 1234, "sent": 975506.097833312, "speculative": {"acceptance_rate": 0.5546448087431693, "accepted": 203, "drafted": 366, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.27090990799479187, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 366, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.56770587767295, "done": 975516.341486325, "finish_reason": "length", "first": 975506.367918012, "full_response_s": 10.243586983066052, "last": 975516.341436998, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975506.367918012, 2], [975506.518467683, 7], [975506.664928259, 4], [975506.879907699, 63], [975507.111019221, 10], [975507.298493552, 31], [975507.479853697, 29], [975507.662668951, 22], [975507.842243391, 14], [975508.027494738, 24], [975508.212609896, 4], [975508.364577181, 13], [975508.540495382, 21], [975508.726553585, 2], [975508.905081375, 18], [975509.08540569, 29], [975509.32430952, 27], [975509.560431562, 24], [975509.708934203, 4], [975509.881446849, 16], [975510.118247485, 10], [975510.30608907, 31], [975510.452400692, 8], [975510.634085755, 11], [975510.817594125, 16], [975511.002984027, 12], [975511.184112441, 39], [975511.361105746, 18], [975511.543361053, 11], [975511.723115812, 16], [975511.905806837, 16], [975512.054946, 11], [975512.244675251, 6], [975512.427445445, 9], [975512.612308232, 29], [975512.792167377, 22], [975512.979149242, 8], [975513.125660199, 18], [975513.315128503, 18], [975513.499950465, 34], [975513.680035512, 10], [975513.862739395, 14], [975514.046287784, 13], [975514.233215273, 2], [975514.418931166, 36], [975514.600751511, 42], [975514.781772231, 26], [975514.93634006, 17], [975515.117032812, 34], [975515.359093263, 12], [975515.542709479, 36], [975515.828226529, 50], [975516.009859578, 2], [975516.341436998, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-27c0e631a2afa4fb9de4445298ab354c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.172756509, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.974206053, "time_to_first_token": 0.267402381, "token_sha": "2b28aa2108de", "tokens_per_second": 25.565944662162075}, "seed": 1234, "sent": 975506.097899342, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2700186700094491, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.567361555494294, "done": 975516.342495559, "finish_reason": "length", "first": 975506.36878925, "full_response_s": 10.243715508026071, "last": 975516.342442552, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975506.36878925, 2], [975506.519669935, 7], [975506.666576994, 4], [975506.878135176, 63], [975507.111620499, 10], [975507.299520433, 31], [975507.480269061, 29], [975507.661826321, 22], [975507.844028378, 14], [975508.026260886, 24], [975508.21233904, 4], [975508.361525112, 13], [975508.541578806, 21], [975508.726145261, 2], [975508.904069181, 18], [975509.085598372, 29], [975509.326710809, 27], [975509.559964936, 24], [975509.710115592, 4], [975509.880175191, 16], [975510.118618674, 10], [975510.30720166, 31], [975510.452222313, 8], [975510.63365668, 11], [975510.817735897, 16], [975511.00113405, 12], [975511.184208598, 39], [975511.361430984, 18], [975511.540801034, 11], [975511.724625991, 16], [975511.905757751, 16], [975512.054778405, 11], [975512.2448943, 6], [975512.429159058, 9], [975512.610085722, 29], [975512.793715443, 22], [975512.978170615, 8], [975513.12515463, 18], [975513.317369204, 18], [975513.499163449, 34], [975513.679481977, 10], [975513.86297486, 14], [975514.045764552, 13], [975514.235427143, 2], [975514.419108969, 36], [975514.599239971, 42], [975514.784517685, 26], [975514.935665089, 17], [975515.11722463, 34], [975515.360534436, 12], [975515.544372806, 36], [975515.829700021, 50], [975516.010169808, 2], [975516.342442552, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-34868624d77bda6a33e6df25c177e615", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.172860507, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.974532523, "time_to_first_token": 0.266543303, "token_sha": "2b28aa2108de", "tokens_per_second": 25.565107879692857}, "seed": 1234, "sent": 975506.098780051, "speculative": {"acceptance_rate": 0.5546448087431693, "accepted": 203, "drafted": 366, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2700091990409419, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 366, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.560692266488132, "done": 975516.345877731, "finish_reason": "length", "first": 975506.368432861, "full_response_s": 10.240540707949549, "last": 975516.344688486, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975506.368432861, 2], [975506.516921745, 7], [975506.665954357, 4], [975506.880281704, 63], [975507.111728128, 10], [975507.301298412, 31], [975507.480963472, 29], [975507.660902796, 22], [975507.84369378, 14], [975508.025121897, 24], [975508.212542186, 4], [975508.361682883, 13], [975508.542110518, 21], [975508.723312513, 2], [975508.904549343, 18], [975509.085902171, 29], [975509.326223399, 27], [975509.560988826, 24], [975509.708824302, 4], [975509.880824019, 16], [975510.117173437, 10], [975510.308337578, 31], [975510.452472674, 8], [975510.632471243, 11], [975510.816657833, 16], [975511.003070073, 12], [975511.184780693, 39], [975511.362393211, 18], [975511.540649422, 11], [975511.724546009, 16], [975511.906543808, 16], [975512.055626604, 11], [975512.243334331, 6], [975512.427228251, 9], [975512.610594651, 29], [975512.791876873, 22], [975512.977963885, 8], [975513.125315041, 18], [975513.317165914, 18], [975513.499780662, 34], [975513.679765328, 10], [975513.863239828, 14], [975514.04609347, 13], [975514.234786858, 2], [975514.417666787, 36], [975514.599664391, 42], [975514.782866262, 26], [975514.936454729, 17], [975515.119174156, 34], [975515.360741598, 12], [975515.543259271, 36], [975515.828490873, 50], [975516.010970425, 2], [975516.344688486, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-fad1ea84af60b4a8798860e5529d8a5b", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.173338524, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.977047249, "time_to_first_token": 0.260574266, "token_sha": "2b28aa2108de", "tokens_per_second": 25.558664165448217}, "seed": 1234, "sent": 975506.105337023, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2630958380177617, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.564459854977663, "done": 975516.344371103, "finish_reason": "length", "first": 975506.369543612, "full_response_s": 10.244346512947232, "last": 975516.344328976, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975506.369543612, 2], [975506.518024176, 7], [975506.665687933, 4], [975506.878387649, 63], [975507.110473222, 10], [975507.301550069, 31], [975507.482847896, 29], [975507.661538057, 22], [975507.842868092, 14], [975508.02482077, 24], [975508.212795171, 4], [975508.361104901, 13], [975508.541465401, 21], [975508.724117049, 2], [975508.90435706, 18], [975509.085566005, 29], [975509.325200454, 27], [975509.559269709, 24], [975509.708305534, 4], [975509.880927392, 16], [975510.117777307, 10], [975510.304819987, 31], [975510.454091633, 8], [975510.633421103, 11], [975510.816042715, 16], [975511.000433847, 12], [975511.184051851, 39], [975511.361221806, 18], [975511.545501758, 11], [975511.724297713, 16], [975511.905157113, 16], [975512.053500443, 11], [975512.2442224, 6], [975512.429213232, 9], [975512.611325461, 29], [975512.793116724, 22], [975512.975632803, 8], [975513.124130612, 18], [975513.316841892, 18], [975513.500550895, 34], [975513.678736271, 10], [975513.862405325, 14], [975514.045030557, 13], [975514.234378934, 2], [975514.419358577, 36], [975514.599144022, 42], [975514.782634781, 26], [975514.93507117, 17], [975515.117419744, 34], [975515.359345399, 12], [975515.543462129, 36], [975515.827524022, 50], [975516.010066771, 2], [975516.344328976, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-9e2d8fb4d3a49fd44b384d69c59b4b82", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.173129219, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.974138231, "time_to_first_token": 0.263642749, "token_sha": "2b28aa2108de", "tokens_per_second": 25.566118505100555}, "seed": 1234, "sent": 975506.10002459, "speculative": {"acceptance_rate": 0.559228650137741, "accepted": 203, "drafted": 363, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.26951902196742594, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 363, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.565054730026613, "done": 975516.343661444, "finish_reason": "length", "first": 975506.369091065, "full_response_s": 10.243129749083892, "last": 975516.343644325, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975506.369091065, 2], [975506.517323797, 7], [975506.666380552, 4], [975506.879294742, 63], [975507.112257664, 10], [975507.298884484, 31], [975507.483734157, 29], [975507.662746789, 22], [975507.843294336, 14], [975508.026914483, 24], [975508.213674904, 4], [975508.362050856, 13], [975508.54063757, 21], [975508.725561598, 2], [975508.905124909, 18], [975509.085796814, 29], [975509.326108235, 27], [975509.559688001, 24], [975509.709543161, 4], [975509.881126826, 16], [975510.119181634, 10], [975510.30773958, 31], [975510.45184114, 8], [975510.633360369, 11], [975510.81716713, 16], [975511.00128435, 12], [975511.18594925, 39], [975511.361907082, 18], [975511.541371193, 11], [975511.723217201, 16], [975511.906811944, 16], [975512.055084684, 11], [975512.244082724, 6], [975512.429625444, 9], [975512.610677897, 29], [975512.792916058, 22], [975512.977459084, 8], [975513.125833762, 18], [975513.316450624, 18], [975513.500277415, 34], [975513.678276652, 10], [975513.862054471, 14], [975514.045723673, 13], [975514.233045198, 2], [975514.41811911, 36], [975514.600808069, 42], [975514.782040703, 26], [975514.934804986, 17], [975515.120314123, 34], [975515.360222237, 12], [975515.54207785, 36], [975515.828779585, 50], [975516.010677825, 2], [975516.343644325, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-8329c5db113da1a6bb69c6504401bf4e", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.173300829, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.974316434, "time_to_first_token": 0.260843137, "token_sha": "2b28aa2108de", "tokens_per_second": 25.56566173605316}, "seed": 1234, "sent": 975506.100531695, "speculative": {"acceptance_rate": 0.5607734806629834, "accepted": 203, "drafted": 362, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.26855937007348984, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 362, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.570744725656393, "done": 975516.341566226, "finish_reason": "length", "first": 975506.369206998, "full_response_s": 10.240707196993753, "last": 975516.341540723, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975506.369206998, 2], [975506.518713019, 7], [975506.665731547, 4], [975506.879553918, 63], [975507.110053378, 10], [975507.300754332, 31], [975507.480148521, 29], [975507.661589944, 22], [975507.843784897, 14], [975508.025971983, 24], [975508.212834801, 4], [975508.364204712, 13], [975508.541946987, 21], [975508.725067693, 2], [975508.904299542, 18], [975509.086166003, 29], [975509.325512045, 27], [975509.560504456, 24], [975509.710192421, 4], [975509.88005697, 16], [975510.116856647, 10], [975510.307280426, 31], [975510.452563647, 8], [975510.63320055, 11], [975510.816512253, 16], [975511.000498133, 12], [975511.184692072, 39], [975511.360274058, 18], [975511.544215252, 11], [975511.72383683, 16], [975511.907067744, 16], [975512.053347935, 11], [975512.245410941, 6], [975512.430390189, 9], [975512.610533933, 29], [975512.790807241, 22], [975512.976381084, 8], [975513.125709158, 18], [975513.316269013, 18], [975513.498765796, 34], [975513.67836185, 10], [975513.861206976, 14], [975514.045614204, 13], [975514.234710925, 2], [975514.419026475, 36], [975514.600851972, 42], [975514.782361413, 26], [975514.933129932, 17], [975515.116382831, 34], [975515.358957523, 12], [975515.544547025, 36], [975515.827808349, 50], [975516.011038535, 2], [975516.341540723, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-ed288411c4c9211767408522ae86a242", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.172976631, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.974210293, "time_to_first_token": 0.265322859, "token_sha": "2b28aa2108de", "tokens_per_second": 25.56593379417331}, "seed": 1234, "sent": 975506.100859029, "speculative": {"acceptance_rate": 0.5576923076923077, "accepted": 203, "drafted": 364, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.26834796904586256, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 364, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.56947025097985, "done": 975516.342875963, "finish_reason": "length", "first": 975506.369448783, "full_response_s": 10.244499659980647, "last": 975516.342279565, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975506.369448783, 2], [975506.518607678, 7], [975506.665362406, 4], [975506.879836054, 63], [975507.112356749, 10], [975507.300285882, 31], [975507.483183774, 29], [975507.660681715, 22], [975507.843508729, 14], [975508.025697383, 24], [975508.212722757, 4], [975508.361828015, 13], [975508.542226386, 21], [975508.723460157, 2], [975508.905222058, 18], [975509.086027687, 29], [975509.327662604, 27], [975509.560097796, 24], [975509.709661077, 4], [975509.881810662, 16], [975510.118459095, 10], [975510.307011026, 31], [975510.453138878, 8], [975510.632192836, 11], [975510.815648615, 16], [975511.001707281, 12], [975511.185778967, 39], [975511.362739537, 18], [975511.542884252, 11], [975511.724886047, 16], [975511.906195402, 16], [975512.055338772, 11], [975512.24430571, 6], [975512.428961399, 9], [975512.610348514, 29], [975512.794101079, 22], [975512.979309301, 8], [975513.123842397, 18], [975513.314822496, 18], [975513.501637375, 34], [975513.67889721, 10], [975513.861312669, 14], [975514.044616906, 13], [975514.235621889, 2], [975514.418604936, 36], [975514.599470333, 42], [975514.782493265, 26], [975514.935931977, 17], [975515.119596912, 34], [975515.361373355, 12], [975515.543920611, 36], [975515.829479292, 50], [975516.011573383, 2], [975516.342279565, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-180edcb6839ae472b1f48ec4d64b3516", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.173089076, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 9.974143783, "time_to_first_token": 0.265322507, "token_sha": "2b28aa2108de", "tokens_per_second": 25.566104273995304}, "seed": 1234, "sent": 975506.098376303, "speculative": {"acceptance_rate": 0.559228650137741, "accepted": 203, "drafted": 363, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.2710724800126627, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 363, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 24.90576935116795, "done": 975516.342357147, "finish_reason": "length", "first": 975506.103729551, "full_response_s": 10.244604345061816, "last": 975516.342321116, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975506.103729551, 2], [975506.195425447, 7], [975506.517549966, 4], [975506.666135919, 72], [975506.878629482, 1], [975507.110225085, 27], [975507.300812811, 30], [975507.481118444, 15], [975507.662086473, 14], [975507.844287106, 20], [975508.025315011, 14], [975508.212918495, 4], [975508.362912671, 13], [975508.541512488, 21], [975508.722930893, 2], [975508.90470409, 18], [975509.08620581, 29], [975509.324493691, 27], [975509.560391772, 24], [975509.709187875, 4], [975509.879805826, 16], [975510.118686224, 10], [975510.305313877, 31], [975510.453485411, 8], [975510.633889857, 11], [975510.81580349, 16], [975510.999996308, 12], [975511.183897455, 39], [975511.360621232, 18], [975511.541082785, 11], [975511.723642564, 16], [975511.907162205, 16], [975512.054097593, 11], [975512.243062515, 6], [975512.428904617, 9], [975512.610999199, 29], [975512.792957705, 22], [975512.978820084, 8], [975513.123756544, 18], [975513.315368, 18], [975513.499407249, 34], [975513.68010255, 10], [975513.86183379, 14], [975514.045812294, 13], [975514.23511992, 2], [975514.419406048, 36], [975514.599938863, 42], [975514.782811336, 26], [975514.93488164, 17], [975515.117159688, 34], [975515.35944946, 12], [975515.543115787, 36], [975515.82738065, 50], [975516.010771919, 2], [975516.342321116, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-f7607cc383a8427c3affa23dbf2dc33d", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.002262604, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.239008336, "time_to_first_token": 0.002583651, "token_sha": "2b28aa2108de", "tokens_per_second": 24.90475558100962}, "seed": 1234, "sent": 975506.097752802, "speculative": {"acceptance_rate": 0.5444743935309974, "accepted": 202, "drafted": 371, "rounds": 54, "tokens_per_round": 4.7407407407407405}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.00597674900200218, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 202, "drafted": 371, "rounds": 54}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.06880361227366, "done": 975526.536095676, "finish_reason": "length", "first": 975516.364061064, "full_response_s": 10.176303541986272, "last": 975526.536066236, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975516.364061064, 2], [975516.45271682, 7], [975516.667110418, 4], [975516.816335771, 72], [975517.030605058, 1], [975517.274945039, 27], [975517.457563792, 30], [975517.639729294, 15], [975517.820592259, 14], [975518.003477345, 20], [975518.191365051, 14], [975518.379847923, 4], [975518.523512954, 13], [975518.704222552, 21], [975518.888535582, 2], [975519.069811425, 18], [975519.255566879, 29], [975519.49030023, 27], [975519.724052394, 24], [975519.872979163, 4], [975520.043875061, 16], [975520.292763713, 10], [975520.47554798, 31], [975520.623515692, 8], [975520.806285656, 11], [975520.988842927, 16], [975521.173999289, 12], [975521.36120404, 39], [975521.533039035, 18], [975521.714977045, 11], [975521.898641246, 16], [975522.082121503, 16], [975522.237562795, 11], [975522.420952479, 6], [975522.604387697, 9], [975522.788506368, 29], [975522.973845471, 22], [975523.157815335, 8], [975523.313889748, 18], [975523.497181856, 18], [975523.680067512, 34], [975523.86179874, 10], [975524.046598585, 14], [975524.236113795, 13], [975524.422501833, 2], [975524.603648233, 36], [975524.786987513, 42], [975524.973632748, 26], [975525.121924055, 17], [975525.312199808, 34], [975525.548528544, 12], [975525.731579342, 36], [975526.018971063, 50], [975526.207449835, 2], [975526.536066236, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-9e2acce233e22663752f7f0f4153d9c0", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.002259309, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.171776843, "time_to_first_token": 0.002623874, "token_sha": "2b28aa2108de", "tokens_per_second": 25.06936633942039}, "seed": 1234, "sent": 975516.359792134, "speculative": {"acceptance_rate": 0.5358090185676393, "accepted": 202, "drafted": 377, "rounds": 54, "tokens_per_round": 4.7407407407407405}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.004268929944373667, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 202, "drafted": 377, "rounds": 54}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.374757282791823, "done": 975526.537723052, "finish_reason": "length", "first": 975516.487061082, "full_response_s": 10.177994019933976, "last": 975526.53641829, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975516.487061082, 2], [975516.666727053, 7], [975516.814762953, 4], [975517.031528567, 63], [975517.280637895, 10], [975517.458380056, 31], [975517.639596178, 29], [975517.820521781, 22], [975518.005337018, 14], [975518.190903385, 24], [975518.377409452, 4], [975518.523777394, 13], [975518.70475196, 21], [975518.888025917, 2], [975519.068616932, 18], [975519.255129676, 29], [975519.490055869, 27], [975519.725374675, 24], [975519.873088408, 4], [975520.045363881, 16], [975520.292640309, 10], [975520.475195735, 31], [975520.62426151, 8], [975520.804452462, 11], [975520.98995243, 16], [975521.174348239, 12], [975521.361864084, 39], [975521.534961714, 18], [975521.717378398, 11], [975521.900719473, 16], [975522.082820459, 16], [975522.235522343, 11], [975522.42029445, 6], [975522.604677449, 9], [975522.787610954, 29], [975522.972835229, 22], [975523.157336549, 8], [975523.314351095, 18], [975523.498359902, 18], [975523.680530331, 34], [975523.862178009, 10], [975524.046104023, 14], [975524.236621748, 13], [975524.420270507, 2], [975524.603720487, 36], [975524.787282353, 42], [975524.972816676, 26], [975525.125024748, 17], [975525.31583143, 34], [975525.549402871, 12], [975525.731937555, 36], [975526.021322306, 50], [975526.207306159, 2], [975526.53641829, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-6274ae005f023aa9db875dfb377c8143", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033719209, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.050899834, "time_to_first_token": 0.123857545, "token_sha": "2b28aa2108de", "tokens_per_second": 25.370862729861326}, "seed": 1234, "sent": 975516.359729032, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12733205000404269, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.370530998850565, "done": 975526.536753032, "finish_reason": "length", "first": 975516.485679939, "full_response_s": 10.176380290999077, "last": 975526.536711193, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975516.485679939, 2], [975516.669605064, 7], [975516.815086112, 4], [975517.032036344, 63], [975517.276388293, 10], [975517.459746767, 31], [975517.638190412, 29], [975517.820460599, 22], [975518.004260202, 14], [975518.19119712, 24], [975518.376752319, 4], [975518.52451638, 13], [975518.705313368, 21], [975518.887328594, 2], [975519.069668773, 18], [975519.254975553, 29], [975519.490695995, 27], [975519.724426335, 24], [975519.872109956, 4], [975520.043790744, 16], [975520.292081957, 10], [975520.474360687, 31], [975520.62323178, 8], [975520.804125495, 11], [975520.990832548, 16], [975521.174285313, 12], [975521.36247789, 39], [975521.534124795, 18], [975521.717645398, 11], [975521.900533414, 16], [975522.082631216, 16], [975522.237144775, 11], [975522.421392594, 6], [975522.603895968, 9], [975522.789126909, 29], [975522.975527758, 22], [975523.157956531, 8], [975523.316758544, 18], [975523.499120359, 18], [975523.681928898, 34], [975523.862489664, 10], [975524.046519787, 14], [975524.237151012, 13], [975524.42315551, 2], [975524.604721626, 36], [975524.787561192, 42], [975524.974632079, 26], [975525.123926524, 17], [975525.314026267, 34], [975525.549994325, 12], [975525.732411893, 36], [975526.019359036, 50], [975526.209761783, 2], [975526.536711193, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-41b0bd5510f38ce5082068c13c042b0f", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033274469, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.051074821, "time_to_first_token": 0.124148528, "token_sha": "2b28aa2108de", "tokens_per_second": 25.370421028726316}, "seed": 1234, "sent": 975516.360372741, "speculative": {"acceptance_rate": 0.5442359249329759, "accepted": 203, "drafted": 373, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12530719803180546, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 373, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.36634459321508, "done": 975526.538512133, "finish_reason": "length", "first": 975516.485786976, "full_response_s": 10.178208093973808, "last": 975526.53847703, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975516.485786976, 2], [975516.6674274, 7], [975516.815169101, 4], [975517.030905721, 63], [975517.27876643, 10], [975517.460111061, 31], [975517.638582752, 29], [975517.822258322, 22], [975518.005098817, 14], [975518.191548502, 24], [975518.379456127, 4], [975518.523026568, 13], [975518.706442822, 21], [975518.888884212, 2], [975519.068875597, 18], [975519.256951046, 29], [975519.491713468, 27], [975519.724726406, 24], [975519.875032126, 4], [975520.043737945, 16], [975520.29203727, 10], [975520.476143659, 31], [975520.622270288, 8], [975520.804607561, 11], [975520.990323363, 16], [975521.174653254, 12], [975521.363119839, 39], [975521.533977919, 18], [975521.715391593, 11], [975521.899950999, 16], [975522.082959046, 16], [975522.236185667, 11], [975522.419042215, 6], [975522.603748148, 9], [975522.787791925, 29], [975522.973620374, 22], [975523.159381353, 8], [975523.313796631, 18], [975523.497331308, 18], [975523.680731189, 34], [975523.862047453, 10], [975524.045949452, 14], [975524.235765565, 13], [975524.421356219, 2], [975524.603880659, 36], [975524.788542075, 42], [975524.974245834, 26], [975525.123533288, 17], [975525.315397522, 34], [975525.550562293, 12], [975525.732853065, 36], [975526.020401038, 50], [975526.207591639, 2], [975526.53847703, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-50d2209910d08159c508b77722c35a47", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033480287, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.051049318, "time_to_first_token": 0.124084386, "token_sha": "2b28aa2108de", "tokens_per_second": 25.37048540228842}, "seed": 1234, "sent": 975516.360304039, "speculative": {"acceptance_rate": 0.5471698113207547, "accepted": 203, "drafted": 371, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1254829369718209, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 371, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.364061222477712, "done": 975526.540659126, "finish_reason": "length", "first": 975516.486947789, "full_response_s": 10.180653669987805, "last": 975526.540542825, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975516.486947789, 2], [975516.667672273, 7], [975516.817114148, 4], [975517.03156991, 63], [975517.278096194, 10], [975517.458502628, 31], [975517.63940876, 29], [975517.822719012, 22], [975518.004577233, 14], [975518.191832541, 24], [975518.376419801, 4], [975518.521870586, 13], [975518.704822054, 21], [975518.888114299, 2], [975519.068791183, 18], [975519.256491684, 29], [975519.491486995, 27], [975519.724636153, 24], [975519.871962633, 4], [975520.044554033, 16], [975520.29103682, 10], [975520.474892672, 31], [975520.623609289, 8], [975520.804509228, 11], [975520.991288935, 16], [975521.175308003, 12], [975521.362916981, 39], [975521.533321379, 18], [975521.716182705, 11], [975521.898837384, 16], [975522.083767839, 16], [975522.235657139, 11], [975522.419972252, 6], [975522.604088938, 9], [975522.790246253, 29], [975522.973979931, 22], [975523.158125118, 8], [975523.315564019, 18], [975523.497754192, 18], [975523.683478676, 34], [975523.863091982, 10], [975524.047482383, 14], [975524.236747024, 13], [975524.420695342, 2], [975524.603041115, 36], [975524.787854768, 42], [975524.974731324, 26], [975525.123288495, 17], [975525.315455441, 34], [975525.548745642, 12], [975525.732812106, 36], [975526.019854718, 50], [975526.209846484, 2], [975526.540542825, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-dfc93dbb80217dbc89efc404b378764a", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033940066, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.054761369, "time_to_first_token": 0.122999715, "token_sha": "2b28aa2108de", "tokens_per_second": 25.361119040198677}, "seed": 1234, "sent": 975516.360005456, "speculative": {"acceptance_rate": 0.553133514986376, "accepted": 203, "drafted": 367, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12694233295042068, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 367, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.369489941721188, "done": 975526.538827243, "finish_reason": "length", "first": 975516.486606824, "full_response_s": 10.178401511977427, "last": 975526.53805053, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975516.486606824, 2], [975516.668329501, 7], [975516.81467214, 4], [975517.031638628, 63], [975517.275912931, 10], [975517.46082248, 31], [975517.638775018, 29], [975517.821552487, 22], [975518.00548967, 14], [975518.190454166, 24], [975518.380214441, 4], [975518.523439596, 13], [975518.704480672, 21], [975518.887753701, 2], [975519.068977386, 18], [975519.254905843, 29], [975519.491952821, 27], [975519.723814113, 24], [975519.874310756, 4], [975520.044092415, 16], [975520.292287023, 10], [975520.475686744, 31], [975520.622843024, 8], [975520.805076795, 11], [975520.990676249, 16], [975521.175435903, 12], [975521.362865639, 39], [975521.535072079, 18], [975521.715754318, 11], [975521.899558851, 16], [975522.083492055, 16], [975522.236649014, 11], [975522.418943738, 6], [975522.604583196, 9], [975522.789434916, 29], [975522.975289989, 22], [975523.157888805, 8], [975523.317882159, 18], [975523.498793633, 18], [975523.682375844, 34], [975523.862241159, 10], [975524.04778351, 14], [975524.236863517, 13], [975524.421289229, 2], [975524.60402915, 36], [975524.787406973, 42], [975524.972993839, 26], [975525.12359079, 17], [975525.31276272, 34], [975525.549199293, 12], [975525.730895522, 36], [975526.020743283, 50], [975526.208099816, 2], [975526.53805053, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-4ce7163089ba125daf365839355fb8a8", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033791319, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.050851355, "time_to_first_token": 0.123806747, "token_sha": "2b28aa2108de", "tokens_per_second": 25.37098510298285}, "seed": 1234, "sent": 975516.360425731, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1261810929281637, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.372550436396153, "done": 975526.537418437, "finish_reason": "length", "first": 975516.487165159, "full_response_s": 10.177555745001882, "last": 975526.537396437, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975516.487165159, 2], [975516.667267805, 7], [975516.816166928, 4], [975517.031378123, 63], [975517.280292177, 10], [975517.458124144, 31], [975517.639376217, 29], [975517.821214929, 22], [975518.005255805, 14], [975518.191658114, 24], [975518.378177477, 4], [975518.523200883, 13], [975518.705087006, 21], [975518.888689706, 2], [975519.068918299, 18], [975519.255032591, 29], [975519.49037994, 27], [975519.723924542, 24], [975519.873948014, 4], [975520.045164975, 16], [975520.291169184, 10], [975520.474810178, 31], [975520.624460192, 8], [975520.804957999, 11], [975520.989059496, 16], [975521.1745858, 12], [975521.36316731, 39], [975521.534602957, 18], [975521.715471782, 11], [975521.90176541, 16], [975522.08393129, 16], [975522.236428028, 11], [975522.420776884, 6], [975522.603800243, 9], [975522.787967568, 29], [975522.975058043, 22], [975523.158445189, 8], [975523.31710583, 18], [975523.498280016, 18], [975523.683111855, 34], [975523.862687946, 10], [975524.045549608, 14], [975524.238140055, 13], [975524.421098834, 2], [975524.604906852, 36], [975524.788031499, 42], [975524.973145387, 26], [975525.124554634, 17], [975525.313622583, 34], [975525.550056004, 12], [975525.734097732, 36], [975526.020837233, 50], [975526.208472781, 2], [975526.537396437, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-3d1298ee8d2c05818cd80065056cd842", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033424689, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.051355149, "time_to_first_token": 0.124158688, "token_sha": "2b28aa2108de", "tokens_per_second": 25.369713458525013}, "seed": 1234, "sent": 975516.359862692, "speculative": {"acceptance_rate": 0.5471698113207547, "accepted": 203, "drafted": 371, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1273024670081213, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 371, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.36614111788197, "done": 975526.540060887, "finish_reason": "length", "first": 975516.487224357, "full_response_s": 10.17989882803522, "last": 975526.539995049, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975516.487224357, 2], [975516.669084823, 7], [975516.816682785, 4], [975517.031834558, 63], [975517.276015904, 10], [975517.460421419, 31], [975517.63985673, 29], [975517.820885994, 22], [975518.003862694, 14], [975518.190750029, 24], [975518.378413086, 4], [975518.523311632, 13], [975518.704899364, 21], [975518.888294549, 2], [975519.0694479, 18], [975519.255702475, 29], [975519.489690632, 27], [975519.726928869, 24], [975519.873308753, 4], [975520.044152557, 16], [975520.293493707, 10], [975520.475057963, 31], [975520.623675927, 8], [975520.805419473, 11], [975520.990087498, 16], [975521.175039643, 12], [975521.362701931, 39], [975521.533261061, 18], [975521.715179967, 11], [975521.901998715, 16], [975522.08372128, 16], [975522.236057303, 11], [975522.420685655, 6], [975522.604319907, 9], [975522.789825129, 29], [975522.975332787, 22], [975523.158854297, 8], [975523.314932054, 18], [975523.49841446, 18], [975523.681542077, 34], [975523.862821094, 10], [975524.046963534, 14], [975524.238212453, 13], [975524.422916605, 2], [975524.604550959, 36], [975524.789267814, 42], [975524.973796344, 26], [975525.122557845, 17], [975525.316220922, 34], [975525.549812107, 12], [975525.733730607, 36], [975526.020906895, 50], [975526.209681321, 2], [975526.539995049, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-0fc82395c4675c853ec1ef298b007907", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033902227, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.054240281, "time_to_first_token": 0.123096048, "token_sha": "2b28aa2108de", "tokens_per_second": 25.362433448292084}, "seed": 1234, "sent": 975516.360162059, "speculative": {"acceptance_rate": 0.553133514986376, "accepted": 203, "drafted": 367, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12706229800824076, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 367, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.375823779224827, "done": 975526.536509311, "finish_reason": "length", "first": 975516.487459486, "full_response_s": 10.175643240916543, "last": 975526.536394339, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975516.487459486, 2], [975516.667890554, 7], [975516.815381255, 4], [975517.032319712, 63], [975517.275642939, 10], [975517.459494263, 31], [975517.638871816, 29], [975517.821450826, 22], [975518.003803223, 14], [975518.191266174, 24], [975518.377112564, 4], [975518.523980844, 13], [975518.704038509, 21], [975518.88909211, 2], [975519.069905486, 18], [975519.255938244, 29], [975519.492270396, 27], [975519.724125336, 24], [975519.873661079, 4], [975520.045272188, 16], [975520.291746655, 10], [975520.47541984, 31], [975520.623352449, 8], [975520.805923394, 11], [975520.990513021, 16], [975521.173793103, 12], [975521.362335062, 39], [975521.533828644, 18], [975521.716678931, 11], [975521.900112611, 16], [975522.083057092, 16], [975522.23691515, 11], [975522.421455504, 6], [975522.604739991, 9], [975522.78950477, 29], [975522.97441515, 22], [975523.157258712, 8], [975523.317456971, 18], [975523.498760978, 18], [975523.681144105, 34], [975523.861660776, 10], [975524.0471662, 14], [975524.23789899, 13], [975524.421916314, 2], [975524.603281636, 36], [975524.788262644, 42], [975524.973074365, 26], [975525.125400849, 17], [975525.312995369, 34], [975525.548820904, 12], [975525.732285945, 36], [975526.020957773, 50], [975526.207864831, 2], [975526.536394339, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-3be607f23884ae4bfd644949a4e41c78", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.03375476, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.050817901, "time_to_first_token": 0.123656751, "token_sha": "2b28aa2108de", "tokens_per_second": 25.37106954993473}, "seed": 1234, "sent": 975516.36086607, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12659341597463936, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.367078338554407, "done": 975526.539570166, "finish_reason": "length", "first": 975516.487129512, "full_response_s": 10.179459977080114, "last": 975526.539528791, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975516.487129512, 2], [975516.667586371, 7], [975516.814503265, 4], [975517.031248431, 63], [975517.275423873, 10], [975517.45939489, 31], [975517.640146994, 29], [975517.820267741, 22], [975518.004631823, 14], [975518.190360953, 24], [975518.378107943, 4], [975518.523118949, 13], [975518.705375334, 21], [975518.888627099, 2], [975519.068951594, 18], [975519.255994275, 29], [975519.492016788, 27], [975519.72615862, 24], [975519.875792248, 4], [975520.044400454, 16], [975520.29163853, 10], [975520.474978461, 31], [975520.623460973, 8], [975520.80558862, 11], [975520.989901695, 16], [975521.174234306, 12], [975521.36395359, 39], [975521.535354951, 18], [975521.716129635, 11], [975521.901920813, 16], [975522.084663556, 16], [975522.235749632, 11], [975522.42065036, 6], [975522.603841329, 9], [975522.790730734, 29], [975522.974154774, 22], [975523.157134411, 8], [975523.314205259, 18], [975523.497942282, 18], [975523.681504446, 34], [975523.862104187, 10], [975524.046039785, 14], [975524.235493077, 13], [975524.421407177, 2], [975524.605675278, 36], [975524.787170244, 42], [975524.972918081, 26], [975525.12229094, 17], [975525.314906481, 34], [975525.550410889, 12], [975525.731504528, 36], [975526.020698085, 50], [975526.209302404, 2], [975526.539528791, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-3d66540f72f6918e9ef105b66a99f39a", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033865396, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.053844804, "time_to_first_token": 0.12343191, "token_sha": "2b28aa2108de", "tokens_per_second": 25.36343110235263}, "seed": 1234, "sent": 975516.360110189, "speculative": {"acceptance_rate": 0.553133514986376, "accepted": 203, "drafted": 367, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1270193230593577, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 367, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.374644973149078, "done": 975526.537257641, "finish_reason": "length", "first": 975516.487832499, "full_response_s": 10.177358613931574, "last": 975526.537234186, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975516.487832499, 2], [975516.668097636, 7], [975516.815666271, 4], [975517.030790349, 63], [975517.278989448, 10], [975517.458587698, 31], [975517.639203614, 29], [975517.820167392, 22], [975518.003942643, 14], [975518.190304282, 24], [975518.380576142, 4], [975518.523937581, 13], [975518.704632748, 21], [975518.887812772, 2], [975519.069720052, 18], [975519.255083198, 29], [975519.490942227, 27], [975519.726497362, 24], [975519.873228547, 4], [975520.044289481, 16], [975520.292694387, 10], [975520.47509153, 31], [975520.623552731, 8], [975520.804813987, 11], [975520.991684811, 16], [975521.175838147, 12], [975521.36138277, 39], [975521.533158936, 18], [975521.717748147, 11], [975521.90115938, 16], [975522.083974681, 16], [975522.236851888, 11], [975522.419109205, 6], [975522.603665703, 9], [975522.789626335, 29], [975522.973397372, 22], [975523.158584944, 8], [975523.315203774, 18], [975523.498824544, 18], [975523.681440432, 34], [975523.862611644, 10], [975524.044646434, 14], [975524.235895193, 13], [975524.420908552, 2], [975524.605373351, 36], [975524.787970156, 42], [975524.974104863, 26], [975525.121977702, 17], [975525.314442671, 34], [975525.548959348, 12], [975525.733642257, 36], [975526.021009372, 50], [975526.207693428, 2], [975526.537234186, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-16853ad4cd93c0a56068fc33c7336cc7", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033337444, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.051414747, "time_to_first_token": 0.123724893, "token_sha": "2b28aa2108de", "tokens_per_second": 25.369563033513135}, "seed": 1234, "sent": 975516.359899027, "speculative": {"acceptance_rate": 0.5471698113207547, "accepted": 203, "drafted": 371, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12793347192928195, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 371, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.37501074858458, "done": 975526.53682783, "finish_reason": "length", "first": 975516.4875499, "full_response_s": 10.176865573041141, "last": 975526.536806727, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975516.4875499, 2], [975516.667855211, 7], [975516.815913799, 4], [975517.031921547, 63], [975517.279489753, 10], [975517.459148129, 31], [975517.638076879, 29], [975517.821395003, 22], [975518.004519346, 14], [975518.190609889, 24], [975518.377235713, 4], [975518.522935675, 13], [975518.704587789, 21], [975518.887504845, 2], [975519.069784722, 18], [975519.256733325, 29], [975519.490615661, 27], [975519.726795097, 24], [975519.873361152, 4], [975520.044016945, 16], [975520.294837076, 10], [975520.475480622, 31], [975520.622111909, 8], [975520.805247318, 11], [975520.990718311, 16], [975521.174815537, 12], [975521.363069809, 39], [975521.536058594, 18], [975521.717043272, 11], [975521.899827931, 16], [975522.083288477, 16], [975522.236501162, 11], [975522.420100664, 6], [975522.604634442, 9], [975522.78815601, 29], [975522.973037287, 22], [975523.158033553, 8], [975523.314464819, 18], [975523.497587397, 18], [975523.681096602, 34], [975523.863611439, 10], [975524.045246305, 14], [975524.237963181, 13], [975524.419923205, 2], [975524.602832129, 36], [975524.788094793, 42], [975524.973328981, 26], [975525.121562562, 17], [975525.316970244, 34], [975525.549139263, 12], [975525.73070132, 36], [975526.019178497, 50], [975526.208814579, 2], [975526.536806727, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-53aa4b4dede5bece58beb25e7b14733c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033682138, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.050996951, "time_to_first_token": 0.123809131, "token_sha": "2b28aa2108de", "tokens_per_second": 25.37061758581365}, "seed": 1234, "sent": 975516.359962257, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1275876429863274, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.37305344757267, "done": 975526.53702856, "finish_reason": "length", "first": 975516.486339231, "full_response_s": 10.176252438919619, "last": 975526.536371267, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975516.486339231, 2], [975516.666991461, 7], [975516.81442018, 4], [975517.031033254, 63], [975517.277474165, 10], [975517.459191136, 31], [975517.637933795, 29], [975517.820828556, 22], [975518.004806618, 14], [975518.191307229, 24], [975518.378047929, 4], [975518.524252004, 13], [975518.70348571, 21], [975518.888490319, 2], [975519.068516487, 18], [975519.254784742, 29], [975519.491435445, 27], [975519.726219642, 24], [975519.872437947, 4], [975520.043827767, 16], [975520.29328125, 10], [975520.475588795, 31], [975520.623845362, 8], [975520.804371712, 11], [975520.989290529, 16], [975521.174169428, 12], [975521.363555426, 39], [975521.534320501, 18], [975521.717173252, 11], [975521.899645312, 16], [975522.085082936, 16], [975522.235606244, 11], [975522.419279584, 6], [975522.604255141, 9], [975522.790600242, 29], [975522.974799235, 22], [975523.157595582, 8], [975523.317200275, 18], [975523.498506457, 18], [975523.680856433, 34], [975523.86336487, 10], [975524.044745151, 14], [975524.236175329, 13], [975524.4206292, 2], [975524.604389012, 36], [975524.787914878, 42], [975524.972541485, 26], [975525.123346973, 17], [975525.312607876, 34], [975525.548646829, 12], [975525.731285847, 36], [975526.020229075, 50], [975526.208909536, 2], [975526.536371267, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-2a04bfc1a07fab29ae7eb1421e38b165", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033587421, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.050979016, "time_to_first_token": 0.12374406, "token_sha": "2b28aa2108de", "tokens_per_second": 25.37066285722708}, "seed": 1234, "sent": 975516.360776121, "speculative": {"acceptance_rate": 0.5501355013550135, "accepted": 203, "drafted": 369, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.125563109992072, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 369, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.372707155222475, "done": 975526.538352729, "finish_reason": "length", "first": 975516.488159961, "full_response_s": 10.177802601014264, "last": 975526.538329162, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975516.488159961, 2], [975516.668813183, 7], [975516.817046774, 4], [975517.030973591, 63], [975517.276211802, 10], [975517.458719502, 31], [975517.639075874, 29], [975517.82064205, 22], [975518.004098383, 14], [975518.191502743, 24], [975518.37787891, 4], [975518.52337011, 13], [975518.703579291, 21], [975518.889776777, 2], [975519.06976109, 18], [975519.255284392, 29], [975519.491012033, 27], [975519.724584603, 24], [975519.873419262, 4], [975520.044178028, 16], [975520.292161427, 10], [975520.47577943, 31], [975520.623884113, 8], [975520.806373349, 11], [975520.99000566, 16], [975521.175705447, 12], [975521.362993779, 39], [975521.534177338, 18], [975521.715280396, 11], [975521.898997859, 16], [975522.083849804, 16], [975522.235300397, 11], [975522.41941878, 6], [975522.604167352, 9], [975522.790828923, 29], [975522.974612392, 22], [975523.158308809, 8], [975523.314074431, 18], [975523.498575063, 18], [975523.681591084, 34], [975523.863281032, 10], [975524.044816397, 14], [975524.235678176, 13], [975524.42173312, 2], [975524.604314342, 36], [975524.788596042, 42], [975524.974179708, 26], [975525.122832989, 17], [975525.314636073, 34], [975525.550467128, 12], [975525.73172377, 36], [975526.019618932, 50], [975526.208253651, 2], [975526.538329162, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-5662947c48be1a0166b41c4a1cd9502c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033544462, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.05112746, "time_to_first_token": 0.12409189, "token_sha": "2b28aa2108de", "tokens_per_second": 25.370288160687597}, "seed": 1234, "sent": 975516.360550128, "speculative": {"acceptance_rate": 0.5471698113207547, "accepted": 203, "drafted": 371, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12760983291082084, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 371, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.374137293480953, "done": 975526.537635358, "finish_reason": "length", "first": 975516.48800803, "full_response_s": 10.177007489022799, "last": 975526.537610783, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975516.48800803, 2], [975516.669022681, 7], [975516.815030834, 4], [975517.031494968, 63], [975517.275224039, 10], [975517.457753482, 31], [975517.640255759, 29], [975517.822628535, 22], [975518.003600957, 14], [975518.191616532, 24], [975518.379090442, 4], [975518.522289566, 13], [975518.70633433, 21], [975518.889274952, 2], [975519.069186531, 18], [975519.256222364, 29], [975519.489552396, 27], [975519.725162777, 24], [975519.872881838, 4], [975520.04492895, 16], [975520.294500142, 10], [975520.474067032, 31], [975520.624060556, 8], [975520.805554909, 11], [975520.989789955, 16], [975521.174742307, 12], [975521.362118429, 39], [975521.536562083, 18], [975521.71628491, 11], [975521.901545048, 16], [975522.082464325, 16], [975522.237745749, 11], [975522.419904494, 6], [975522.604796485, 9], [975522.789320872, 29], [975522.973190434, 22], [975523.159252797, 8], [975523.31633366, 18], [975523.497852877, 18], [975523.680213876, 34], [975523.863186699, 10], [975524.046308017, 14], [975524.237477435, 13], [975524.421864236, 2], [975524.604804935, 36], [975524.788802644, 42], [975524.974042816, 26], [975525.122414393, 17], [975525.313268513, 34], [975525.55051839, 12], [975525.733304011, 36], [975526.020138325, 50], [975526.208700166, 2], [975526.537610783, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-a91b44e04068d9e4c48f0c242d17ca94", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033827446, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.05109898, "time_to_first_token": 0.123440565, "token_sha": "2b28aa2108de", "tokens_per_second": 25.37036004793179}, "seed": 1234, "sent": 975516.360627869, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1273801609640941, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.37044489719, "done": 975526.537184124, "finish_reason": "length", "first": 975516.486093575, "full_response_s": 10.177527665975504, "last": 975526.53715894, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975516.486093575, 2], [975516.66683665, 7], [975516.814320279, 4], [975517.032080903, 63], [975517.277105616, 10], [975517.457891318, 31], [975517.638022081, 29], [975517.822803618, 22], [975518.003722586, 14], [975518.190983862, 24], [975518.377511577, 4], [975518.522450585, 13], [975518.70389869, 21], [975518.889663389, 2], [975519.068722177, 18], [975519.255161755, 29], [975519.491275369, 27], [975519.72448275, 24], [975519.875207801, 4], [975520.043948803, 16], [975520.29305276, 10], [975520.474706789, 31], [975520.622630262, 8], [975520.8042513, 11], [975520.989174837, 16], [975521.175511261, 12], [975521.361724152, 39], [975521.533769558, 18], [975521.718031419, 11], [975521.899699071, 16], [975522.082297402, 16], [975522.235454601, 11], [975522.420835458, 6], [975522.604982672, 9], [975522.788848582, 29], [975522.975122633, 22], [975523.158377783, 8], [975523.315907369, 18], [975523.498029447, 18], [975523.680400895, 34], [975523.867406527, 10], [975524.045906365, 14], [975524.236535799, 13], [975524.421605811, 2], [975524.604262839, 36], [975524.789203928, 42], [975524.973531375, 26], [975525.121818938, 17], [975525.316624526, 34], [975525.549928167, 12], [975525.732505507, 36], [975526.020482043, 50], [975526.208187365, 2], [975526.53715894, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-e77c347cef753c641b4cb861094d2c44", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033624556, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.050972712, "time_to_first_token": 0.124010004, "token_sha": "2b28aa2108de", "tokens_per_second": 25.370678769782337}, "seed": 1234, "sent": 975516.359656458, "speculative": {"acceptance_rate": 0.5501355013550135, "accepted": 203, "drafted": 369, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12643711699638516, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 369, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.288661181756716, "done": 975536.766025499, "finish_reason": "length", "first": 975526.682423828, "full_response_s": 10.208911592024378, "last": 975536.765994412, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975526.682423828, 2], [975526.865512919, 7], [975527.014456791, 4], [975527.235921497, 63], [975527.4747827, 10], [975527.657129576, 31], [975527.837346276, 29], [975528.019978237, 22], [975528.203373776, 14], [975528.390728639, 24], [975528.572572543, 4], [975528.71964473, 13], [975528.903717724, 21], [975529.088259778, 2], [975529.274060036, 18], [975529.457470891, 29], [975529.690551189, 27], [975529.928042641, 24], [975530.079026225, 4], [975530.257606507, 16], [975530.496690572, 10], [975530.680835379, 31], [975530.826081804, 8], [975531.011697998, 11], [975531.198284466, 16], [975531.384747675, 12], [975531.56929582, 39], [975531.743382526, 18], [975531.926091255, 11], [975532.109205575, 16], [975532.303155466, 16], [975532.450063594, 11], [975532.633404339, 6], [975532.818352589, 9], [975533.003419817, 29], [975533.192585597, 22], [975533.37974838, 8], [975533.529138792, 18], [975533.71521607, 18], [975533.897717487, 34], [975534.081351034, 10], [975534.273052361, 14], [975534.456992683, 13], [975534.640553975, 2], [975534.824775169, 36], [975535.011700465, 42], [975535.199092915, 26], [975535.352068415, 17], [975535.537969709, 34], [975535.778954407, 12], [975535.960168466, 36], [975536.25415923, 50], [975536.438221814, 2], [975536.765994412, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-2a80cb094923f3ed1bfea68c4b530448", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033009975, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.08273168, "time_to_first_token": 0.123437321, "token_sha": "2b28aa2108de", "tokens_per_second": 25.290765250236234}, "seed": 1234, "sent": 975526.557113907, "speculative": {"acceptance_rate": 0.5442359249329759, "accepted": 203, "drafted": 373, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1253099211025983, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 373, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.281884783979645, "done": 975536.768567681, "finish_reason": "length", "first": 975526.682254793, "full_response_s": 10.21150953299366, "last": 975536.768528114, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975526.682254793, 2], [975526.865604869, 7], [975527.013945926, 4], [975527.23547503, 63], [975527.472329652, 10], [975527.654237885, 31], [975527.835648725, 29], [975528.020304035, 22], [975528.204476527, 14], [975528.389837513, 24], [975528.571579628, 4], [975528.718671142, 13], [975528.903894822, 21], [975529.088014121, 2], [975529.275292079, 18], [975529.455914265, 29], [975529.692748836, 27], [975529.928241787, 24], [975530.07742128, 4], [975530.257100138, 16], [975530.498068868, 10], [975530.679640662, 31], [975530.826756952, 8], [975531.012563156, 11], [975531.199510287, 16], [975531.384071503, 12], [975531.566918625, 39], [975531.743109078, 18], [975531.923679134, 11], [975532.110704971, 16], [975532.30101836, 16], [975532.453015268, 11], [975532.633138747, 6], [975532.816394743, 9], [975533.003982985, 29], [975533.192939667, 22], [975533.384218378, 8], [975533.529173143, 18], [975533.712221757, 18], [975533.896783162, 34], [975534.080660174, 10], [975534.271817165, 14], [975534.456917741, 13], [975534.639491542, 2], [975534.823103218, 36], [975535.011344251, 42], [975535.199914475, 26], [975535.354645012, 17], [975535.540816746, 34], [975535.77885497, 12], [975535.959170143, 36], [975536.253130747, 50], [975536.439392564, 2], [975536.768528114, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-fe5a4b60e45bded41671d875e9dc3dce", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033155683, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.082581604, "time_to_first_token": 0.122702302, "token_sha": "2b28aa2108de", "tokens_per_second": 25.29114169518206}, "seed": 1234, "sent": 975526.557058148, "speculative": {"acceptance_rate": 0.5471698113207547, "accepted": 203, "drafted": 371, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12519664503633976, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 371, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.297956504217193, "done": 975536.765289072, "finish_reason": "length", "first": 975526.685403053, "full_response_s": 10.20727219991386, "last": 975536.765268593, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975526.685403053, 2], [975526.866952077, 7], [975527.015646788, 4], [975527.23491359, 63], [975527.475178992, 10], [975527.654663008, 31], [975527.837486416, 29], [975528.02225553, 22], [975528.204023677, 14], [975528.390241437, 24], [975528.571735815, 4], [975528.719895539, 13], [975528.903275272, 21], [975529.086602322, 2], [975529.274599716, 18], [975529.456189073, 29], [975529.692472044, 27], [975529.928626047, 24], [975530.079244651, 4], [975530.256415006, 16], [975530.498290317, 10], [975530.679978012, 31], [975530.825819268, 8], [975531.013599142, 11], [975531.199332196, 16], [975531.38657015, 12], [975531.569027763, 39], [975531.744926561, 18], [975531.924714304, 11], [975532.109307828, 16], [975532.300515751, 16], [975532.449487611, 11], [975532.633683563, 6], [975532.818170227, 9], [975533.003496375, 29], [975533.193802682, 22], [975533.382510363, 8], [975533.529495997, 18], [975533.713712114, 18], [975533.89810626, 34], [975534.08223928, 10], [975534.272756226, 14], [975534.45632203, 13], [975534.640477386, 2], [975534.825095496, 36], [975535.010886729, 42], [975535.200869424, 26], [975535.352659134, 17], [975535.539802407, 34], [975535.776170904, 12], [975535.961101174, 36], [975536.25318633, 50], [975536.439869382, 2], [975536.765268593, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-786ca6998f834bcd0dc8734dd837021c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033119668, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.082794734, "time_to_first_token": 0.123051459, "token_sha": "2b28aa2108de", "tokens_per_second": 25.290607091317586}, "seed": 1234, "sent": 975526.558016872, "speculative": {"acceptance_rate": 0.5471698113207547, "accepted": 203, "drafted": 371, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1273861809168011, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 371, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.28822647331038, "done": 975536.765929277, "finish_reason": "length", "first": 975526.68216398, "full_response_s": 10.208008770016022, "last": 975536.765907902, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975526.68216398, 2], [975526.866651206, 7], [975527.013777659, 4], [975527.234983188, 63], [975527.474116671, 10], [975527.656132229, 31], [975527.837570349, 29], [975528.020729943, 22], [975528.203955935, 14], [975528.390848731, 24], [975528.573060881, 4], [975528.719543645, 13], [975528.903595807, 21], [975529.087303614, 2], [975529.276247092, 18], [975529.456746512, 29], [975529.690368458, 27], [975529.92812283, 24], [975530.078483137, 4], [975530.256129655, 16], [975530.49718275, 10], [975530.682289433, 31], [975530.826171226, 8], [975531.011911079, 11], [975531.198807731, 16], [975531.38594652, 12], [975531.567335301, 39], [975531.74085276, 18], [975531.92380353, 11], [975532.108806067, 16], [975532.300113411, 16], [975532.450243429, 11], [975532.632967712, 6], [975532.81669843, 9], [975533.003693873, 29], [975533.194597747, 22], [975533.382400527, 8], [975533.529877378, 18], [975533.713405691, 18], [975533.896917622, 34], [975534.081045362, 10], [975534.272812288, 14], [975534.455927386, 13], [975534.639698992, 2], [975534.822986837, 36], [975535.011773887, 42], [975535.200228546, 26], [975535.356448272, 17], [975535.536981689, 34], [975535.777955044, 12], [975535.961135381, 36], [975536.254237691, 50], [975536.437426845, 2], [975536.765907902, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-76a85dd4dc95c8ad54b0fea55c3680b8", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033194002, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.082547637, "time_to_first_token": 0.122563554, "token_sha": "2b28aa2108de", "tokens_per_second": 25.291226898271685}, "seed": 1234, "sent": 975526.557920507, "speculative": {"acceptance_rate": 0.5501355013550135, "accepted": 203, "drafted": 369, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12424347293563187, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 369, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.290883076918423, "done": 975536.768025793, "finish_reason": "length", "first": 975526.685319263, "full_response_s": 10.209701425977983, "last": 975536.768003969, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975526.685319263, 2], [975526.865937611, 7], [975527.015154547, 4], [975527.234610831, 63], [975527.47464744, 10], [975527.655020182, 31], [975527.835858431, 29], [975528.020818004, 22], [975528.203759876, 14], [975528.389900759, 24], [975528.571769494, 4], [975528.719189911, 13], [975528.903561696, 21], [975529.089156984, 2], [975529.274860476, 18], [975529.456547574, 29], [975529.69133411, 27], [975529.929105025, 24], [975530.080541685, 4], [975530.256230324, 16], [975530.498401434, 10], [975530.679718548, 31], [975530.826624524, 8], [975531.013400396, 11], [975531.200259497, 16], [975531.385857499, 12], [975531.568685101, 39], [975531.744354065, 18], [975531.925290911, 11], [975532.109407441, 16], [975532.301910494, 16], [975532.452267722, 11], [975532.632607275, 6], [975532.817660402, 9], [975533.003597972, 29], [975533.194160783, 22], [975533.380959945, 8], [975533.52781867, 18], [975533.712354666, 18], [975533.898367996, 34], [975534.083213475, 10], [975534.273888817, 14], [975534.458479039, 13], [975534.640514344, 2], [975534.824086165, 36], [975535.011664754, 42], [975535.200667973, 26], [975535.355715109, 17], [975535.537462363, 34], [975535.776858148, 12], [975535.960443706, 36], [975536.252399665, 50], [975536.437152197, 2], [975536.768003969, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-0c48a206050f91208727d4b00cbbbe48", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033469385, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.08274328, "time_to_first_token": 0.122478901, "token_sha": "2b28aa2108de", "tokens_per_second": 25.290736153702802}, "seed": 1234, "sent": 975526.558324367, "speculative": {"acceptance_rate": 0.553133514986376, "accepted": 203, "drafted": 367, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12699489598162472, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 367, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.292469691548067, "done": 975536.766541004, "finish_reason": "length", "first": 975526.682832984, "full_response_s": 10.209213407943025, "last": 975536.764885196, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975526.682832984, 2], [975526.86623261, 7], [975527.014334651, 4], [975527.23566504, 63], [975527.474196717, 10], [975527.655264303, 31], [975527.836250692, 29], [975528.021921028, 22], [975528.204702105, 14], [975528.390099329, 24], [975528.574800014, 4], [975528.72058923, 13], [975528.904491189, 21], [975529.088398958, 2], [975529.276467453, 18], [975529.456881452, 29], [975529.692520619, 27], [975529.92881377, 24], [975530.079685358, 4], [975530.257559341, 16], [975530.497339705, 10], [975530.679816881, 31], [975530.827274729, 8], [975531.012865099, 11], [975531.198130839, 16], [975531.384587008, 12], [975531.566987279, 39], [975531.744795461, 18], [975531.924819932, 11], [975532.109784438, 16], [975532.302153383, 16], [975532.450790613, 11], [975532.632704616, 6], [975532.816330584, 9], [975533.003849229, 29], [975533.194060194, 22], [975533.38147425, 8], [975533.527694242, 18], [975533.713993578, 18], [975533.89686908, 34], [975534.083556969, 10], [975534.274156089, 14], [975534.457585769, 13], [975534.641247059, 2], [975534.82364709, 36], [975535.011418441, 42], [975535.199323036, 26], [975535.353086081, 17], [975535.539161002, 34], [975535.778495285, 12], [975535.961055, 36], [975536.252262213, 50], [975536.437748356, 2], [975536.764885196, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-4aede7bbec09050c15cbf3fff9fac358", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033284895, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.08244532, "time_to_first_token": 0.122323497, "token_sha": "2b28aa2108de", "tokens_per_second": 25.29148355450739}, "seed": 1234, "sent": 975526.557327596, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12550538801588118, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.291465491145836, "done": 975536.766601306, "finish_reason": "length", "first": 975526.684123954, "full_response_s": 10.20853971503675, "last": 975536.766576475, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975526.684123954, 2], [975526.866027944, 7], [975527.013876952, 4], [975527.23560701, 63], [975527.473469618, 10], [975527.656242242, 31], [975527.83678842, 29], [975528.020247573, 22], [975528.204145929, 14], [975528.390905865, 24], [975528.572670876, 4], [975528.720416675, 13], [975528.904138111, 21], [975529.08710826, 2], [975529.275737106, 18], [975529.45771714, 29], [975529.692260947, 27], [975529.9279389, 24], [975530.079881032, 4], [975530.255997578, 16], [975530.497597505, 10], [975530.681427938, 31], [975530.827427781, 8], [975531.012991736, 11], [975531.198208965, 16], [975531.384676045, 12], [975531.568029585, 39], [975531.742087284, 18], [975531.92559583, 11], [975532.110263704, 16], [975532.302612394, 16], [975532.449601608, 11], [975532.633449266, 6], [975532.817767055, 9], [975533.003557253, 29], [975533.192416466, 22], [975533.383885203, 8], [975533.527874733, 18], [975533.712925113, 18], [975533.8972747, 34], [975534.081764302, 10], [975534.27371231, 14], [975534.458222215, 13], [975534.640987003, 2], [975534.823204479, 36], [975535.010952663, 42], [975535.201511069, 26], [975535.352944006, 17], [975535.540897048, 34], [975535.778221885, 12], [975535.95989505, 36], [975536.253088397, 50], [975536.437972317, 2], [975536.766576475, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-47b54e2ae7227676c01d53141fdc9cc8", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.03343313, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.082691073, "time_to_first_token": 0.12257037, "token_sha": "2b28aa2108de", "tokens_per_second": 25.290867106188884}, "seed": 1234, "sent": 975526.558061591, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1260623630369082, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.294143614773578, "done": 975536.765093574, "finish_reason": "length", "first": 975526.683683583, "full_response_s": 10.207909621996805, "last": 975536.765068582, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975526.683683583, 2], [975526.867366753, 7], [975527.013661039, 4], [975527.23613413, 63], [975527.472673545, 10], [975527.656890671, 31], [975527.835731171, 29], [975528.021271959, 22], [975528.204429249, 14], [975528.390614994, 24], [975528.572879222, 4], [975528.718975806, 13], [975528.904295899, 21], [975529.089411056, 2], [975529.275508521, 18], [975529.457040568, 29], [975529.692192453, 27], [975529.92888372, 24], [975530.077807877, 4], [975530.25634992, 16], [975530.498607172, 10], [975530.680340434, 31], [975530.826024622, 8], [975531.011820122, 11], [975531.200170075, 16], [975531.385194222, 12], [975531.568529586, 39], [975531.743622631, 18], [975531.925426139, 11], [975532.109469119, 16], [975532.302359025, 16], [975532.45137914, 11], [975532.63199934, 6], [975532.818262272, 9], [975533.003769135, 29], [975533.194379385, 22], [975533.38152972, 8], [975533.529081241, 18], [975533.713071957, 18], [975533.897599138, 34], [975534.081285291, 10], [975534.273319089, 14], [975534.456799216, 13], [975534.640723794, 2], [975534.824608006, 36], [975535.012223554, 42], [975535.200736499, 26], [975535.353696704, 17], [975535.538720775, 34], [975535.779167681, 12], [975535.960289982, 36], [975536.252715224, 50], [975536.439080637, 2], [975536.765068582, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-87e35e7a599a27aef0f46c3cb9fd5091", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033396075, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.082726352, "time_to_first_token": 0.12248938, "token_sha": "2b28aa2108de", "tokens_per_second": 25.290778614597475}, "seed": 1234, "sent": 975526.557183952, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12649963109288365, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.294056061294803, "done": 975536.766493293, "finish_reason": "length", "first": 975526.685035543, "full_response_s": 10.208624577033333, "last": 975536.766455438, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975526.685035543, 2], [975526.866300656, 7], [975527.014964824, 4], [975527.23655159, 63], [975527.473058462, 10], [975527.656399613, 31], [975527.837071884, 29], [975528.020387217, 22], [975528.204266118, 14], [975528.390286044, 24], [975528.572959108, 4], [975528.719581756, 13], [975528.903655197, 21], [975529.088323104, 2], [975529.274227695, 18], [975529.457664597, 29], [975529.691854591, 27], [975529.928186908, 24], [975530.079805531, 4], [975530.257494879, 16], [975530.497749821, 10], [975530.679166756, 31], [975530.826222984, 8], [975531.013643429, 11], [975531.199686042, 16], [975531.386444554, 12], [975531.567726409, 39], [975531.744245893, 18], [975531.926332752, 11], [975532.110478338, 16], [975532.301571864, 16], [975532.45255069, 11], [975532.634022241, 6], [975532.815852486, 9], [975533.003087811, 29], [975533.194113873, 22], [975533.382895984, 8], [975533.529441103, 18], [975533.715275956, 18], [975533.89733777, 34], [975534.080477827, 10], [975534.272344574, 14], [975534.459068734, 13], [975534.640047686, 2], [975534.82398668, 36], [975535.010729405, 42], [975535.201245765, 26], [975535.353348938, 17], [975535.540277098, 34], [975535.777638926, 12], [975535.960390283, 36], [975536.251734244, 50], [975536.437505771, 2], [975536.766455438, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-ae533997709f92cb7ab65fb98f8f3ad4", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033504664, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.082335339, "time_to_first_token": 0.122475109, "token_sha": "2b28aa2108de", "tokens_per_second": 25.291759441249823}, "seed": 1234, "sent": 975526.557868716, "speculative": {"acceptance_rate": 0.553133514986376, "accepted": 203, "drafted": 367, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12716682709287852, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 367, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.288930305569803, "done": 975536.768354183, "finish_reason": "length", "first": 975526.683804652, "full_response_s": 10.21085798391141, "last": 975536.767267927, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975526.683804652, 2], [975526.866532553, 7], [975527.015711283, 4], [975527.235830107, 63], [975527.475079395, 10], [975527.65652321, 31], [975527.836695319, 29], [975528.021425811, 22], [975528.204072923, 14], [975528.39069288, 24], [975528.574493799, 4], [975528.720472786, 13], [975528.904820187, 21], [975529.087654228, 2], [975529.2754231, 18], [975529.457183379, 29], [975529.691458346, 27], [975529.928515731, 24], [975530.077906434, 4], [975530.257324836, 16], [975530.497501588, 10], [975530.683192846, 31], [975530.826417922, 8], [975531.012749791, 11], [975531.197796641, 16], [975531.383809366, 12], [975531.566842515, 39], [975531.740947109, 18], [975531.924667137, 11], [975532.109577772, 16], [975532.301226322, 16], [975532.451972435, 11], [975532.633485729, 6], [975532.816913672, 9], [975533.003327212, 29], [975533.193862952, 22], [975533.381226945, 8], [975533.528972717, 18], [975533.712982439, 18], [975533.896490211, 34], [975534.080351591, 10], [975534.272171619, 14], [975534.456538536, 13], [975534.640138259, 2], [975534.824672196, 36], [975535.012063126, 42], [975535.198901609, 26], [975535.352179164, 17], [975535.538209894, 34], [975535.775751973, 12], [975535.959609266, 36], [975536.252795461, 50], [975536.438146632, 2], [975536.767267927, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-603333a5fc2502c8ea3802d1e290b083", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033542327, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.083942861, "time_to_first_token": 0.122250763, "token_sha": "2b28aa2108de", "tokens_per_second": 25.28772757987566}, "seed": 1234, "sent": 975526.557496199, "speculative": {"acceptance_rate": 0.553133514986376, "accepted": 203, "drafted": 367, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12630845292005688, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 367, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.288718680554517, "done": 975536.76749712, "finish_reason": "length", "first": 975526.683928952, "full_response_s": 10.208891064976342, "last": 975536.767476609, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975526.683928952, 2], [975526.86672106, 7], [975527.016134022, 4], [975527.2370422, 63], [975527.474900632, 10], [975527.655630964, 31], [975527.83609156, 29], [975528.020479726, 22], [975528.204357443, 14], [975528.390759406, 24], [975528.573687278, 4], [975528.719931585, 13], [975528.904247436, 21], [975529.088190244, 2], [975529.276718438, 18], [975529.457838368, 29], [975529.691131364, 27], [975529.927884485, 24], [975530.078277799, 4], [975530.256674231, 16], [975530.498972185, 10], [975530.683066466, 31], [975530.827083263, 8], [975531.013847983, 11], [975531.198577082, 16], [975531.385242621, 12], [975531.568219947, 39], [975531.743190947, 18], [975531.924914762, 11], [975532.10895459, 16], [975532.302060234, 16], [975532.450326995, 11], [975532.632780518, 6], [975532.817355275, 9], [975533.003894187, 29], [975533.193357495, 22], [975533.380590579, 8], [975533.528404877, 18], [975533.712717599, 18], [975533.896830281, 34], [975534.083784259, 10], [975534.273933407, 14], [975534.457350064, 13], [975534.640304127, 2], [975534.824133364, 36], [975535.012129077, 42], [975535.200098454, 26], [975535.355061256, 17], [975535.539440354, 34], [975535.778796284, 12], [975535.960232304, 36], [975536.251648983, 50], [975536.438774006, 2], [975536.767476609, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-34df0a2916d4ea8df3e4a744a35fe677", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.03332251, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.082688753, "time_to_first_token": 0.122322665, "token_sha": "2b28aa2108de", "tokens_per_second": 25.290872925550477}, "seed": 1234, "sent": 975526.558606055, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12532289698719978, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 24.98555129654745, "done": 975536.767829622, "finish_reason": "length", "first": 975526.561234282, "full_response_s": 10.210587735055014, "last": 975536.767132762, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975526.561234282, 2], [975526.650280052, 7], [975526.867061322, 4], [975527.014886475, 72], [975527.234758075, 1], [975527.474530483, 27], [975527.65746603, 30], [975527.836435742, 15], [975528.021711498, 14], [975528.203624984, 20], [975528.390466646, 14], [975528.572146075, 4], [975528.719395425, 13], [975528.903168428, 21], [975529.089063914, 2], [975529.27590355, 18], [975529.456665219, 29], [975529.690952873, 27], [975529.928370407, 24], [975530.077692024, 4], [975530.256913632, 16], [975530.496538768, 10], [975530.681626028, 31], [975530.825941312, 8], [975531.013341966, 11], [975531.199591916, 16], [975531.384319224, 12], [975531.567567182, 39], [975531.743709988, 18], [975531.926244083, 11], [975532.11014222, 16], [975532.303102796, 16], [975532.45013484, 11], [975532.63213764, 6], [975532.816228155, 9], [975533.003935338, 29], [975533.192538335, 22], [975533.382091576, 8], [975533.52852521, 18], [975533.712643345, 18], [975533.896605839, 34], [975534.081562659, 10], [975534.272687684, 14], [975534.457123175, 13], [975534.640892029, 2], [975534.824301007, 36], [975535.011111138, 42], [975535.199240735, 26], [975535.353418536, 17], [975535.53846819, 34], [975535.778333145, 12], [975535.959398152, 36], [975536.253538352, 50], [975536.439806296, 2], [975536.767132762, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-05051f73fa5227b10c9a770b69b1ad5f", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.002323388, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.203652658, "time_to_first_token": 0.002910251, "token_sha": "2b28aa2108de", "tokens_per_second": 24.991050611672048}, "seed": 1234, "sent": 975526.557241887, "speculative": {"acceptance_rate": 0.5358090185676393, "accepted": 202, "drafted": 377, "rounds": 54, "tokens_per_round": 4.7407407407407405}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.003992395009845495, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 202, "drafted": 377, "rounds": 54}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.284416671358073, "done": 975536.767788455, "finish_reason": "length", "first": 975526.682484258, "full_response_s": 10.210148563957773, "last": 975536.767747577, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975526.682484258, 2], [975526.865699906, 7], [975527.016592153, 4], [975527.236039605, 63], [975527.475023205, 10], [975527.654937688, 31], [975527.836913888, 29], [975528.01961076, 22], [975528.20356305, 14], [975528.389639647, 24], [975528.571674601, 4], [975528.720262728, 13], [975528.904735646, 21], [975529.086317291, 2], [975529.275976347, 18], [975529.458025195, 29], [975529.69303494, 27], [975529.929352986, 24], [975530.08022979, 4], [975530.256846642, 16], [975530.499314895, 10], [975530.678931963, 31], [975530.82656795, 8], [975531.01243508, 11], [975531.19981295, 16], [975531.384198683, 12], [975531.568620991, 39], [975531.742546486, 18], [975531.92421315, 11], [975532.109034652, 16], [975532.300684066, 16], [975532.450660425, 11], [975532.632848372, 6], [975532.817905547, 9], [975533.003008293, 29], [975533.193280105, 22], [975533.38186691, 8], [975533.528664134, 18], [975533.713271087, 18], [975533.897388184, 34], [975534.082027638, 10], [975534.272875774, 14], [975534.457476797, 13], [975534.639618259, 2], [975534.82371552, 36], [975535.011836333, 42], [975535.199585637, 26], [975535.352772011, 17], [975535.537207923, 34], [975535.778137359, 12], [975535.960349452, 36], [975536.253258056, 50], [975536.437024393, 2], [975536.767747577, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-42a8e38388810b51bd3bf9ccf8b77923", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033231473, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.082555956, "time_to_first_token": 0.122159806, "token_sha": "2b28aa2108de", "tokens_per_second": 25.29120603077365}, "seed": 1234, "sent": 975526.557639891, "speculative": {"acceptance_rate": 0.5501355013550135, "accepted": 203, "drafted": 369, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12484436691738665, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 369, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.2866772186748, "done": 975536.768435301, "finish_reason": "length", "first": 975526.684035525, "full_response_s": 10.211151223047636, "last": 975536.768397254, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975526.684035525, 2], [975526.86754254, 7], [975527.014586196, 4], [975527.236814414, 63], [975527.473800184, 10], [975527.654708975, 31], [975527.836842723, 29], [975528.020575851, 22], [975528.203487756, 14], [975528.390172703, 24], [975528.572079949, 4], [975528.719140601, 13], [975528.903384453, 21], [975529.089461359, 2], [975529.274457576, 18], [975529.456782671, 29], [975529.690667409, 27], [975529.928563857, 24], [975530.079140622, 4], [975530.25676434, 16], [975530.498345867, 10], [975530.68184071, 31], [975530.8271799, 8], [975531.013285903, 11], [975531.199196168, 16], [975531.385988039, 12], [975531.567898884, 39], [975531.742243311, 18], [975531.925700707, 11], [975532.110046414, 16], [975532.303513312, 16], [975532.449872144, 11], [975532.633066189, 6], [975532.817425337, 9], [975533.003236927, 29], [975533.193592704, 22], [975533.381775313, 8], [975533.529810596, 18], [975533.714231907, 18], [975533.897647457, 34], [975534.081812172, 10], [975534.273249731, 14], [975534.457974878, 13], [975534.6415007, 2], [975534.825041529, 36], [975535.011180992, 42], [975535.199856269, 26], [975535.354545959, 17], [975535.541175631, 34], [975535.777750154, 12], [975535.960118723, 36], [975536.252512381, 50], [975536.438577755, 2], [975536.768397254, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-6e8663cdae94b3ca00989628cedd72da", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033048054, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.082999688, "time_to_first_token": 0.123509494, "token_sha": "2b28aa2108de", "tokens_per_second": 25.290093017009724}, "seed": 1234, "sent": 975526.557284078, "speculative": {"acceptance_rate": 0.5471698113207547, "accepted": 203, "drafted": 371, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.1267514469800517, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 371, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.298783599682732, "done": 975536.765843296, "finish_reason": "length", "first": 975526.685255313, "full_response_s": 10.207658892963082, "last": 975536.764791311, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975526.685255313, 2], [975526.866581448, 7], [975527.015447706, 4], [975527.236640851, 63], [975527.472086075, 10], [975527.654580355, 31], [975527.83672471, 29], [975528.021816343, 22], [975528.203075609, 14], [975528.389765147, 24], [975528.574256526, 4], [975528.718844033, 13], [975528.905058964, 21], [975529.087746801, 2], [975529.275188818, 18], [975529.456120307, 29], [975529.691078213, 27], [975529.929144992, 24], [975530.08091553, 4], [975530.257670953, 16], [975530.498130274, 10], [975530.681892452, 31], [975530.826128587, 8], [975531.01393958, 11], [975531.197460635, 16], [975531.384474355, 12], [975531.56777612, 39], [975531.74158821, 18], [975531.925485977, 11], [975532.109526989, 16], [975532.301356895, 16], [975532.449334832, 11], [975532.634093199, 6], [975532.817853788, 9], [975533.003649891, 29], [975533.19302848, 22], [975533.381645781, 8], [975533.52939064, 18], [975533.71198266, 18], [975533.897925305, 34], [975534.080187707, 10], [975534.272967227, 14], [975534.457881281, 13], [975534.639944425, 2], [975534.824824288, 36], [975535.011038532, 42], [975535.20106041, 26], [975535.353854987, 17], [975535.539241784, 34], [975535.779303469, 12], [975535.961458556, 36], [975536.253905861, 50], [975536.439473457, 2], [975536.764791311, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-c660ee5d6d206000d81b64c83ebbaabd", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033359725, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.082610643, "time_to_first_token": 0.122635169, "token_sha": "2b28aa2108de", "tokens_per_second": 25.29106885398153}, "seed": 1234, "sent": 975526.558184403, "speculative": {"acceptance_rate": 0.5516304347826086, "accepted": 203, "drafted": 368, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12707090994808823, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 368, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "code", "request": {"cache_state": "reused", "cached_tokens": 14, "case_id": null, "complete": true, "decode_tps": 25.28785581294544, "done": 975536.76613412, "finish_reason": "length", "first": 975526.682204603, "full_response_s": 10.209152241935953, "last": 975536.766096329, "output_sha256": "aafe5ed4d4636e0ee4268bf2173d5de3929d2acfae0d404b79b67567f06e98dd", "pieces": [[975526.682204603, 2], [975526.866085878, 7], [975527.014681905, 4], [975527.235109328, 63], [975527.473363333, 10], [975527.654453847, 31], [975527.835804385, 29], [975528.019199044, 22], [975528.203226164, 14], [975528.390520421, 24], [975528.573379831, 4], [975528.719452624, 13], [975528.904185726, 21], [975529.086489222, 2], [975529.27471896, 18], [975529.457266737, 29], [975529.692017594, 27], [975529.928296473, 24], [975530.080699808, 4], [975530.256506204, 16], [975530.497694127, 10], [975530.682704636, 31], [975530.827027489, 8], [975531.013689459, 11], [975531.198749861, 16], [975531.385761213, 12], [975531.567972402, 39], [975531.743918558, 18], [975531.926167237, 11], [975532.110194154, 16], [975532.301978748, 16], [975532.451635245, 11], [975532.633346773, 6], [975532.818084293, 9], [975533.003150209, 29], [975533.193137693, 22], [975533.380093554, 8], [975533.529658873, 18], [975533.714875984, 18], [975533.898221008, 34], [975534.08258655, 10], [975534.274591804, 14], [975534.45894349, 13], [975534.641714022, 2], [975534.823533541, 36], [975535.010817515, 42], [975535.200791394, 26], [975535.35349119, 17], [975535.536878636, 34], [975535.777135564, 12], [975535.960856606, 36], [975536.254034273, 50], [975536.437855984, 2], [975536.766096329, 56]], "prompt": "code", "prompt_tokens": 14, "request_body": {"ignore_eos": true, "max_tokens": 256, "model": "qwen27-pr608", "prompt": "Write a short Python function that computes the Fibonacci sequence and explain it.", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "2165e1a652ecce90f9614eb77c7f68d5e0f1db98ad00f4b841bd9aacade58b01", "request_path": "/v1/completions", "response_id": "cmpl-41f1fe29488f45e5056baf5bf3953e00", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033083717, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 10.083004072, "time_to_first_token": 0.123008517, "token_sha": "2b28aa2108de", "tokens_per_second": 25.290082021103444}, "seed": 1234, "sent": 975526.556981878, "speculative": {"acceptance_rate": 0.5471698113207547, "accepted": 203, "drafted": 371, "rounds": 53, "tokens_per_round": 4.830188679245283}, "token_sha": "2b28aa2108de", "tokens": 256, "ttft_s": 0.12522272497881204, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 14, "prompt_tokens_details": {"cached_tokens": 14}, "total_tokens": 270}, "work": {"accepted": 203, "drafted": 371, "rounds": 53}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "candidate", "burst": null, "phase": "uncached_first_use", "prompt": "chat", "request": {"cache_state": "cold", "cached_tokens": 0, "case_id": null, "complete": true, "decode_tps": 49.46169356000755, "done": 975542.106072966, "finish_reason": "length", "first": 975536.950521354, "full_response_s": 5.319703722954728, "last": 975542.106026183, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975536.950521354, 3], [975537.037829474, 26], [975537.11988725, 15], [975537.203517925, 34], [975537.290109122, 21], [975537.372764385, 25], [975537.453096483, 14], [975537.533692254, 14], [975537.614425045, 18], [975537.695051231, 26], [975537.77576335, 13], [975537.856273381, 13], [975537.937611692, 13], [975538.018212105, 23], [975538.099949733, 32], [975538.181743152, 7], [975538.268300336, 23], [975538.351383045, 9], [975538.432380038, 13], [975538.513208828, 15], [975538.594072146, 19], [975538.67429009, 12], [975538.755153519, 5], [975538.835733213, 23], [975538.919561919, 9], [975539.000059377, 17], [975539.08098743, 3], [975539.162988573, 21], [975539.250785643, 10], [975539.33444261, 24], [975539.416309804, 19], [975539.496753296, 14], [975539.577759091, 13], [975539.65822503, 5], [975539.738582509, 22], [975539.819277129, 13], [975539.900628661, 51], [975539.981910627, 15], [975540.062895017, 6], [975540.143893407, 8], [975540.229534638, 9], [975540.314073757, 16], [975540.395395066, 16], [975540.4762397, 9], [975540.557148924, 32], [975540.637825963, 18], [975540.718749059, 13], [975540.799743433, 11], [975540.883346694, 15], [975540.963916186, 8], [975541.045383669, 18], [975541.119936455, 25], [975541.203726174, 19], [975541.291471699, 8], [975541.373325747, 40], [975541.454108433, 16], [975541.534837953, 64], [975541.615792154, 6], [975541.696763683, 6], [975541.777692381, 11], [975541.858622952, 15], [975541.940378732, 17], [975542.021282889, 21], [975542.106026183, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-0207246053741659255ee0e2a195f1c2", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.162796278, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 5.155944913, "time_to_first_token": 0.163295944, "token_sha": "8a91591c94a3", "tokens_per_second": 49.45747177341885}, "seed": 1234, "sent": 975536.786369243, "speculative": {"acceptance_rate": 0.2052910052910053, "accepted": 194, "drafted": 945, "rounds": 63, "tokens_per_round": 4.063492063492063}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.16415211092680693, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 0}, "total_tokens": 287}, "work": {"accepted": 194, "drafted": 945, "rounds": 63}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 49.39876373402444, "done": 975547.286923471, "finish_reason": "length", "first": 975542.124781513, "full_response_s": 5.171864876989275, "last": 975547.286854017, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975542.124781513, 3], [975542.216722599, 26], [975542.302216015, 15], [975542.383266648, 34], [975542.463948011, 21], [975542.544356807, 25], [975542.62504473, 14], [975542.70563384, 14], [975542.786647402, 18], [975542.869861398, 26], [975542.950683367, 13], [975543.031166435, 13], [975543.112468358, 13], [975543.195405419, 23], [975543.281775644, 32], [975543.363813386, 7], [975543.445269546, 23], [975543.525858338, 9], [975543.606371308, 13], [975543.686906134, 15], [975543.7677166, 19], [975543.848370288, 12], [975543.929765443, 5], [975544.010297311, 23], [975544.091663043, 9], [975544.172502326, 17], [975544.259954795, 3], [975544.343364228, 21], [975544.424501422, 10], [975544.505237413, 24], [975544.586188181, 19], [975544.666654643, 14], [975544.747322891, 13], [975544.827892534, 5], [975544.911873441, 22], [975544.992298867, 13], [975545.073517917, 51], [975545.154469615, 15], [975545.24047128, 6], [975545.324644917, 8], [975545.406395952, 9], [975545.486991501, 16], [975545.567923904, 16], [975545.648812196, 9], [975545.729924257, 32], [975545.810452944, 18], [975545.892231116, 13], [975545.972885929, 11], [975546.054303984, 15], [975546.135157703, 8], [975546.220648281, 18], [975546.298931338, 25], [975546.380797988, 19], [975546.461275206, 8], [975546.542568737, 40], [975546.623749695, 16], [975546.704159267, 64], [975546.785380863, 6], [975546.869150532, 6], [975546.951856488, 11], [975547.033937534, 15], [975547.115730397, 17], [975547.198563693, 21], [975547.286854017, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-5a36f5504ebed66e079bddd997e31431", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.008824641, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 5.162006041, "time_to_first_token": 0.009178007, "token_sha": "8a91591c94a3", "tokens_per_second": 49.39939976331384}, "seed": 1234, "sent": 975542.115058594, "speculative": {"acceptance_rate": 0.2052910052910053, "accepted": 194, "drafted": 945, "rounds": 63, "tokens_per_round": 4.063492063492063}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.009722918970510364, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 194, "drafted": 945, "rounds": 63}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 49.506776796320494, "done": 975552.459181218, "finish_reason": "length", "first": 975547.308320135, "full_response_s": 5.154137868899852, "last": 975552.459130115, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975547.308320135, 3], [975547.3967034, 26], [975547.478654945, 15], [975547.559051992, 34], [975547.639613498, 21], [975547.720110605, 25], [975547.801059556, 14], [975547.88211473, 14], [975547.96287052, 18], [975548.044038523, 26], [975548.125027938, 13], [975548.208805706, 13], [975548.294928942, 13], [975548.376707119, 23], [975548.457797348, 32], [975548.538921384, 7], [975548.619198692, 23], [975548.699765032, 9], [975548.780451752, 13], [975548.863243677, 15], [975548.944820918, 19], [975549.025329374, 12], [975549.106740908, 5], [975549.187995774, 23], [975549.275254772, 9], [975549.35796822, 17], [975549.439255005, 3], [975549.51973047, 21], [975549.600694801, 10], [975549.680977919, 24], [975549.761984584, 19], [975549.842719306, 14], [975549.92418804, 13], [975550.004789888, 5], [975550.086026965, 22], [975550.166346948, 13], [975550.253154409, 51], [975550.337232076, 15], [975550.418598302, 6], [975550.499125815, 8], [975550.57974435, 9], [975550.660753529, 16], [975550.741451646, 16], [975550.822402891, 9], [975550.906329813, 32], [975550.987193575, 18], [975551.068727494, 13], [975551.149407053, 11], [975551.235280591, 15], [975551.319655564, 8], [975551.401844504, 18], [975551.476024153, 25], [975551.556762319, 19], [975551.637370296, 8], [975551.71823369, 40], [975551.799386099, 16], [975551.880683771, 64], [975551.961758649, 6], [975552.043070224, 6], [975552.124687534, 11], [975552.208642106, 15], [975552.295941605, 17], [975552.377886602, 21], [975552.459130115, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b654926632b0ff07ef4695ebd5993d3a", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.002240543, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 5.150807917, "time_to_first_token": 0.002613845, "token_sha": "8a91591c94a3", "tokens_per_second": 49.50679662473618}, "seed": 1234, "sent": 975547.305043349, "speculative": {"acceptance_rate": 0.2052910052910053, "accepted": 194, "drafted": 945, "rounds": 63, "tokens_per_round": 4.063492063492063}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.003276785952039063, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 194, "drafted": 945, "rounds": 63}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 49.522409744383566, "done": 975557.632512705, "finish_reason": "length", "first": 975552.483173891, "full_response_s": 5.15388342004735, "last": 975557.632357893, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975552.483173891, 3], [975552.570684232, 26], [975552.652428451, 15], [975552.732982832, 34], [975552.813097066, 21], [975552.897313776, 25], [975552.977842927, 14], [975553.058998893, 14], [975553.139678697, 18], [975553.225500545, 26], [975553.309388032, 13], [975553.390671371, 13], [975553.471907878, 13], [975553.552521955, 23], [975553.633369434, 32], [975553.714241008, 7], [975553.794789503, 23], [975553.876321252, 9], [975553.956803751, 13], [975554.036891558, 15], [975554.118491161, 19], [975554.200335461, 12], [975554.287349502, 5], [975554.368957697, 23], [975554.450580499, 9], [975554.531212994, 17], [975554.611709493, 3], [975554.692259318, 21], [975554.772959539, 10], [975554.854033975, 24], [975554.937251854, 19], [975555.017457051, 14], [975555.099220524, 13], [975555.179178192, 5], [975555.266367606, 22], [975555.349931044, 13], [975555.43051015, 51], [975555.512265079, 15], [975555.593134049, 6], [975555.673422076, 8], [975555.754449266, 9], [975555.835276334, 16], [975555.916785272, 16], [975555.997599542, 9], [975556.078962645, 32], [975556.159853985, 18], [975556.24552386, 13], [975556.330200788, 11], [975556.411481861, 15], [975556.492682744, 8], [975556.573672865, 18], [975556.647980968, 25], [975556.728462208, 19], [975556.809359067, 8], [975556.892869567, 40], [975556.974154609, 16], [975557.055030608, 64], [975557.136437311, 6], [975557.221396489, 6], [975557.306582701, 11], [975557.38861825, 15], [975557.46909442, 17], [975557.550447221, 21], [975557.632357893, 14]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-91474844dd1b199c4ca9eb7c23f438d7", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 16, "prefill_raised": [], "prefill_seconds": 0.002225984, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 5.149665029, "time_to_first_token": 0.003173301, "token_sha": "8a91591c94a3", "tokens_per_second": 49.517783887686726}, "seed": 1234, "sent": 975552.478629285, "speculative": {"acceptance_rate": 0.2052910052910053, "accepted": 194, "drafted": 945, "rounds": 63, "tokens_per_round": 4.063492063492063}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.0045446059666574, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 194, "drafted": 945, "rounds": 63}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 1} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.69506827267512, "done": 975571.510928924, "finish_reason": "length", "first": 975557.870944214, "full_response_s": 13.839746168931015, "last": 975571.5109051, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975557.870944214, 3], [975558.019781655, 11], [975558.20421093, 30], [975558.390278926, 19], [975558.572040469, 21], [975558.753329402, 15], [975558.905055899, 19], [975559.053119894, 17], [975559.236755149, 12], [975559.424196375, 5], [975559.59311776, 5], [975559.775408989, 18], [975559.957260347, 21], [975560.143934192, 9], [975560.331515483, 9], [975560.47874445, 16], [975560.661952265, 5], [975560.844627153, 14], [975561.027487527, 9], [975561.213131951, 27], [975561.365154929, 11], [975561.547285004, 8], [975561.696314915, 16], [975561.841535767, 5], [975561.991072772, 9], [975562.164840769, 14], [975562.320421394, 20], [975562.468181426, 8], [975562.617711183, 12], [975562.766939844, 5], [975562.918562569, 14], [975563.100067135, 14], [975563.25501391, 8], [975563.438986951, 13], [975563.612536671, 3], [975563.790693252, 10], [975563.939380464, 11], [975564.121420588, 9], [975564.312063044, 10], [975564.495748626, 20], [975564.670563338, 14], [975564.85037903, 14], [975565.082288324, 13], [975565.269249737, 5], [975565.455150269, 22], [975565.684834073, 3], [975565.920097931, 32], [975566.103877103, 33], [975566.29620285, 11], [975566.482963474, 6], [975566.654472289, 8], [975566.803581113, 9], [975566.953246118, 13], [975567.104158719, 8], [975567.257242171, 20], [975567.410786362, 17], [975567.593673165, 20], [975567.740378285, 13], [975567.915979904, 6], [975568.099847195, 13], [975568.252328412, 9], [975568.441367702, 11], [975568.589101885, 8], [975568.77630105, 15], [975568.959362768, 16], [975569.172246046, 27], [975569.42166039, 4], [975569.569217238, 8], [975569.752864076, 25], [975569.936372874, 18], [975570.085502561, 13], [975570.322589755, 64], [975570.472556618, 2], [975570.657177082, 10], [975570.839909696, 11], [975570.992280112, 15], [975571.143903781, 17], [975571.301536769, 14], [975571.5109051, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-0ded5c86ade9fef38403569865b3ba7f", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.116025782, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.639825498, "time_to_first_token": 0.196987634, "token_sha": "8a91591c94a3", "tokens_per_second": 18.69525383864995}, "seed": 1234, "sent": 975557.671182755, "speculative": {"acceptance_rate": 0.42042755344418054, "accepted": 177, "drafted": 421, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.19976145902182907, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 421, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.696688953996034, "done": 975571.510395595, "finish_reason": "length", "first": 975557.870486195, "full_response_s": 13.846610149019398, "last": 975571.509264731, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975557.870486195, 3], [975558.020171115, 11], [975558.20308717, 30], [975558.390723474, 19], [975558.571511461, 21], [975558.753445911, 15], [975558.905699753, 19], [975559.050737178, 17], [975559.237423898, 12], [975559.423103254, 5], [975559.593242573, 5], [975559.776783574, 27], [975559.958742769, 12], [975560.142105988, 13], [975560.330717458, 5], [975560.47811058, 16], [975560.663365233, 5], [975560.843297703, 14], [975561.026488068, 9], [975561.215079767, 27], [975561.365842429, 11], [975561.547452231, 8], [975561.696643978, 16], [975561.844025185, 5], [975561.994752188, 9], [975562.166549969, 14], [975562.321965991, 20], [975562.471258026, 8], [975562.620972802, 12], [975562.767284794, 5], [975562.917038852, 14], [975563.102182323, 14], [975563.25324532, 8], [975563.441177001, 13], [975563.610686691, 3], [975563.79217081, 10], [975563.938458698, 11], [975564.121177251, 9], [975564.311858058, 10], [975564.495691427, 20], [975564.670231236, 14], [975564.849471936, 14], [975565.08122421, 13], [975565.270421208, 5], [975565.45694945, 22], [975565.683524494, 3], [975565.919881233, 32], [975566.104535612, 33], [975566.29740128, 11], [975566.479805915, 6], [975566.655090191, 8], [975566.802080036, 9], [975566.95331842, 13], [975567.106378769, 8], [975567.257825851, 20], [975567.411780334, 17], [975567.593857015, 20], [975567.741035658, 13], [975567.91414402, 6], [975568.10064794, 13], [975568.252912316, 9], [975568.4397281, 11], [975568.58998298, 8], [975568.775328789, 15], [975568.958951739, 16], [975569.171752492, 27], [975569.420526566, 4], [975569.56884504, 8], [975569.754317907, 25], [975569.935632142, 18], [975570.087801696, 13], [975570.32311038, 64], [975570.473165177, 2], [975570.657497233, 10], [975570.840587149, 11], [975570.993089289, 15], [975571.144167245, 17], [975571.301021103, 14], [975571.509264731, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-d7e9b5dbbb21d1180cf95aa78b8711c5", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.115632913, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.640291293, "time_to_first_token": 0.204436798, "token_sha": "8a91591c94a3", "tokens_per_second": 18.69461542444202}, "seed": 1234, "sent": 975557.663785446, "speculative": {"acceptance_rate": 0.41451990632318503, "accepted": 177, "drafted": 427, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.20670074899680912, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 427, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.69442079289305, "done": 975571.510342252, "finish_reason": "length", "first": 975557.86987106, "full_response_s": 13.842940988950431, "last": 975571.510304365, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975557.86987106, 3], [975558.020481395, 11], [975558.202634639, 30], [975558.392742504, 19], [975558.571855915, 21], [975558.752313767, 15], [975558.902941287, 19], [975559.051695663, 17], [975559.237631348, 12], [975559.421362248, 5], [975559.593050562, 5], [975559.776460719, 27], [975559.957782188, 12], [975560.141109664, 13], [975560.333633215, 5], [975560.478341645, 16], [975560.660166412, 5], [975560.842761862, 14], [975561.026361927, 9], [975561.216170104, 27], [975561.365269774, 11], [975561.546777946, 8], [975561.694845709, 16], [975561.842208692, 5], [975561.994408725, 9], [975562.165300804, 14], [975562.31945571, 20], [975562.468866702, 8], [975562.61891614, 12], [975562.768258159, 5], [975562.916499475, 14], [975563.101831757, 14], [975563.252705608, 8], [975563.440455133, 13], [975563.61536707, 3], [975563.791504797, 10], [975563.937722575, 11], [975564.121085749, 9], [975564.313348912, 10], [975564.496860066, 20], [975564.66815883, 14], [975564.848154085, 14], [975565.080829917, 13], [975565.270050163, 5], [975565.456877052, 22], [975565.684172124, 3], [975565.919573097, 32], [975566.104992319, 33], [975566.296412508, 11], [975566.483501634, 6], [975566.653599433, 8], [975566.8009461, 9], [975566.952367903, 13], [975567.10283746, 8], [975567.257333609, 20], [975567.409903731, 17], [975567.59375233, 20], [975567.741777125, 13], [975567.91456572, 6], [975568.100155538, 13], [975568.253434717, 9], [975568.438539781, 11], [975568.590717679, 8], [975568.774528012, 15], [975568.961464164, 16], [975569.172654962, 27], [975569.423374982, 4], [975569.567416153, 8], [975569.753443756, 25], [975569.936182895, 18], [975570.085430947, 13], [975570.324699583, 64], [975570.472081272, 2], [975570.657640365, 10], [975570.839756644, 11], [975570.991881179, 15], [975571.14327135, 17], [975571.302072161, 14], [975571.510304365, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-e481d0e7725f5cef3b6d128dbe093b8b", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.115711583, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.640018452, "time_to_first_token": 0.201274152, "token_sha": "8a91591c94a3", "tokens_per_second": 18.69498937243813}, "seed": 1234, "sent": 975557.667401263, "speculative": {"acceptance_rate": 0.4164705882352941, "accepted": 177, "drafted": 425, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.20246979699004441, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 425, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.42305391631848, "done": 975571.509810027, "finish_reason": "length", "first": 975557.668418786, "full_response_s": 13.84740382200107, "last": 975571.509772188, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975557.668418786, 3], [975557.754791091, 26], [975558.019206519, 15], [975558.202255401, 19], [975558.391579033, 21], [975558.572237536, 15], [975558.753934073, 19], [975558.901982659, 17], [975559.053617752, 6], [975559.23657997, 11], [975559.422368459, 5], [975559.592841736, 18], [975559.774467608, 21], [975559.958418458, 5], [975560.142040214, 8], [975560.334508038, 5], [975560.480943651, 16], [975560.659768679, 5], [975560.842872803, 14], [975561.02801876, 9], [975561.215321216, 27], [975561.364014145, 11], [975561.546566, 8], [975561.695676549, 16], [975561.842663511, 5], [975561.994337863, 9], [975562.165932546, 14], [975562.319699143, 20], [975562.471782555, 8], [975562.6214629, 12], [975562.767412231, 5], [975562.916212283, 14], [975563.102484858, 14], [975563.254037986, 8], [975563.438442582, 13], [975563.61148406, 3], [975563.791675896, 10], [975563.93875501, 11], [975564.120495622, 9], [975564.313454349, 10], [975564.496250355, 20], [975564.67098427, 14], [975564.848016473, 14], [975565.080942522, 13], [975565.268860084, 5], [975565.45426687, 22], [975565.682843042, 3], [975565.921277945, 32], [975566.103943181, 33], [975566.296634677, 11], [975566.481175732, 6], [975566.653964847, 8], [975566.802813359, 9], [975566.952793779, 13], [975567.10378969, 8], [975567.255877474, 20], [975567.411151184, 17], [975567.592120761, 20], [975567.743043698, 13], [975567.916682044, 6], [975568.101385168, 13], [975568.251976358, 9], [975568.438894987, 11], [975568.587234273, 8], [975568.776546067, 15], [975568.960123082, 16], [975569.171844233, 27], [975569.421536265, 4], [975569.568965069, 8], [975569.754102553, 25], [975569.93541642, 18], [975570.086120655, 13], [975570.321901838, 64], [975570.472827219, 2], [975570.655335102, 10], [975570.840537038, 11], [975570.992173363, 15], [975571.143964307, 17], [975571.299743363, 14], [975571.509772188, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-03677a7e4c4201bf1a7fb8cc8fe38177", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.002616421, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.841989577, "time_to_first_token": 0.00350366, "token_sha": "8a91591c94a3", "tokens_per_second": 18.422207196551483}, "seed": 1234, "sent": 975557.662406205, "speculative": {"acceptance_rate": 0.39461883408071746, "accepted": 176, "drafted": 446, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.006012581055983901, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 446, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.696105950494644, "done": 975571.509012306, "finish_reason": "length", "first": 975557.869767863, "full_response_s": 13.846181232947856, "last": 975571.508971699, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975557.869767863, 3], [975558.018893952, 11], [975558.204406812, 30], [975558.391077607, 19], [975558.571346873, 21], [975558.75299042, 15], [975558.903590981, 19], [975559.05271061, 17], [975559.237138386, 12], [975559.421733021, 5], [975559.591447376, 5], [975559.775232066, 27], [975559.956825447, 12], [975560.14357849, 13], [975560.33203478, 5], [975560.477892074, 16], [975560.660954678, 5], [975560.843421219, 14], [975561.028273089, 9], [975561.214554006, 27], [975561.364167117, 11], [975561.546975333, 8], [975561.69763891, 16], [975561.844384167, 5], [975561.992301297, 9], [975562.166671629, 14], [975562.319136615, 20], [975562.470802503, 8], [975562.61865522, 12], [975562.768187553, 5], [975562.918122037, 14], [975563.102792354, 14], [975563.253082717, 8], [975563.439922684, 13], [975563.614793775, 3], [975563.792822951, 10], [975563.938577079, 11], [975564.120754719, 9], [975564.312574022, 10], [975564.496154838, 20], [975564.667482961, 14], [975564.848115254, 14], [975565.080269453, 13], [975565.270254253, 5], [975565.454571885, 22], [975565.684651006, 3], [975565.922536022, 32], [975566.105642269, 33], [975566.295345066, 11], [975566.480603684, 6], [975566.655606897, 8], [975566.802353468, 9], [975566.955135425, 13], [975567.102757015, 8], [975567.255936256, 20], [975567.409349987, 17], [975567.592218918, 20], [975567.740441163, 13], [975567.913884251, 6], [975568.101089656, 13], [975568.252454329, 9], [975568.440275572, 11], [975568.589661389, 8], [975568.775724634, 15], [975568.960719114, 16], [975569.172119681, 27], [975569.421426988, 4], [975569.567770047, 8], [975569.752429176, 25], [975569.936458759, 18], [975570.086746926, 13], [975570.324522996, 64], [975570.472733621, 2], [975570.656467646, 10], [975570.840292533, 11], [975570.993717559, 15], [975571.14362902, 17], [975571.299925422, 14], [975571.508971699, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-ebd32f25862384279230e34a2ce1aca2", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.115510053, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.640066627, "time_to_first_token": 0.205022669, "token_sha": "8a91591c94a3", "tokens_per_second": 18.694923344086682}, "seed": 1234, "sent": 975557.662831073, "speculative": {"acceptance_rate": 0.4097222222222222, "accepted": 177, "drafted": 432, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2069367899093777, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 432, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.69424811352667, "done": 975571.511256723, "finish_reason": "length", "first": 975557.870659918, "full_response_s": 13.8481506499229, "last": 975571.51121922, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975557.870659918, 3], [975558.022187618, 11], [975558.203826765, 30], [975558.390969355, 19], [975558.571228269, 21], [975558.753805917, 15], [975558.902635456, 19], [975559.051137983, 17], [975559.237215232, 12], [975559.422713249, 5], [975559.591855636, 5], [975559.775509675, 27], [975559.957829323, 12], [975560.142656628, 13], [975560.3338858, 5], [975560.478605206, 16], [975560.66136529, 5], [975560.84324108, 14], [975561.028547785, 9], [975561.216243126, 27], [975561.364357223, 11], [975561.547038883, 8], [975561.69516642, 16], [975561.842570762, 5], [975561.991680227, 9], [975562.164925039, 14], [975562.321842218, 20], [975562.469104871, 8], [975562.619075624, 12], [975562.767523284, 5], [975562.918762707, 14], [975563.099812246, 14], [975563.254101552, 8], [975563.440745301, 13], [975563.611902129, 3], [975563.791420175, 10], [975563.941812363, 11], [975564.121032103, 9], [975564.313015433, 10], [975564.494774381, 20], [975564.6707849, 14], [975564.84969033, 14], [975565.081973965, 13], [975565.269788554, 5], [975565.455722556, 22], [975565.684410789, 3], [975565.921177484, 32], [975566.105412948, 33], [975566.297088137, 11], [975566.482734664, 6], [975566.654608445, 8], [975566.801207228, 9], [975566.953763063, 13], [975567.104070626, 8], [975567.256114347, 20], [975567.411960713, 17], [975567.594616674, 20], [975567.74118839, 13], [975567.91760101, 6], [975568.099313754, 13], [975568.253676182, 9], [975568.439540505, 11], [975568.590342873, 8], [975568.774420287, 15], [975568.959606601, 16], [975569.171919895, 27], [975569.421196627, 4], [975569.567583108, 8], [975569.752727584, 25], [975569.936040659, 18], [975570.086149951, 13], [975570.321830832, 64], [975570.473129386, 2], [975570.658231388, 10], [975570.839861185, 11], [975570.994165707, 15], [975571.142817347, 17], [975571.301956357, 14], [975571.51121922, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-6a98c1e7e37811753a20195ae881d962", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.11586577, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.640008037, "time_to_first_token": 0.198085427, "token_sha": "8a91591c94a3", "tokens_per_second": 18.695003647232824}, "seed": 1234, "sent": 975557.663106073, "speculative": {"acceptance_rate": 0.4164705882352941, "accepted": 177, "drafted": 425, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.20755384489893913, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 425, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.696465263096247, "done": 975571.510482296, "finish_reason": "length", "first": 975557.871503222, "full_response_s": 13.843987343949266, "last": 975571.510444937, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975557.871503222, 3], [975558.018628119, 11], [975558.202456164, 30], [975558.393130029, 19], [975558.573772948, 21], [975558.754431467, 15], [975558.902875689, 19], [975559.050684619, 17], [975559.236834906, 12], [975559.42204722, 5], [975559.592209258, 5], [975559.775659046, 27], [975559.959213539, 12], [975560.142354573, 13], [975560.330320429, 5], [975560.478398395, 16], [975560.661824445, 5], [975560.843343125, 14], [975561.026723229, 9], [975561.214281438, 27], [975561.365587157, 11], [975561.546513202, 8], [975561.697583567, 16], [975561.843378659, 5], [975561.994673278, 9], [975562.165559149, 14], [975562.321538691, 20], [975562.47097725, 8], [975562.619413534, 12], [975562.767187949, 5], [975562.91661608, 14], [975563.10107653, 14], [975563.254518708, 8], [975563.440571962, 13], [975563.61121098, 3], [975563.791937825, 10], [975563.941071168, 11], [975564.120672449, 9], [975564.314270806, 10], [975564.495876558, 20], [975564.667752026, 14], [975564.849115674, 14], [975565.081922126, 13], [975565.268710472, 5], [975565.456675122, 22], [975565.68425449, 3], [975565.920727561, 32], [975566.104679448, 33], [975566.297473166, 11], [975566.481034872, 6], [975566.655240107, 8], [975566.803086087, 9], [975566.953401393, 13], [975567.106079657, 8], [975567.257897689, 20], [975567.411899979, 17], [975567.593820217, 20], [975567.742874502, 13], [975567.915844019, 6], [975568.099538084, 13], [975568.252869901, 9], [975568.44091629, 11], [975568.589752698, 8], [975568.777650116, 15], [975568.959177829, 16], [975569.172168384, 27], [975569.423691229, 4], [975569.570195802, 8], [975569.753157396, 25], [975569.935688861, 18], [975570.085858247, 13], [975570.322741238, 64], [975570.474196988, 2], [975570.658326458, 10], [975570.840658571, 11], [975570.993146999, 15], [975571.145800703, 17], [975571.301745707, 14], [975571.510444937, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-ac63ab2b728a862fab1a81c20427d8a5", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.115922937, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.640066003, "time_to_first_token": 0.198516726, "token_sha": "8a91591c94a3", "tokens_per_second": 18.69492419933417}, "seed": 1234, "sent": 975557.666494952, "speculative": {"acceptance_rate": 0.4164705882352941, "accepted": 177, "drafted": 425, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.20500826998613775, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 425, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.697479451062595, "done": 975571.509200348, "finish_reason": "length", "first": 975557.870966245, "full_response_s": 13.840444100089371, "last": 975571.509168157, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975557.870966245, 3], [975558.020903223, 11], [975558.202681549, 30], [975558.392054428, 19], [975558.573528123, 21], [975558.752378661, 15], [975558.90269291, 19], [975559.050551471, 17], [975559.237391227, 12], [975559.42213493, 5], [975559.59368616, 5], [975559.774219919, 27], [975559.959132085, 12], [975560.143234324, 13], [975560.332415458, 5], [975560.480630044, 16], [975560.662664549, 5], [975560.844140687, 14], [975561.027070723, 9], [975561.215848785, 27], [975561.366412909, 11], [975561.547525205, 8], [975561.696998928, 16], [975561.841660484, 5], [975561.992948687, 9], [975562.165165352, 14], [975562.321274202, 20], [975562.472362555, 8], [975562.619737525, 12], [975562.769412638, 5], [975562.918304656, 14], [975563.10138033, 14], [975563.253924709, 8], [975563.43853122, 13], [975563.609810556, 3], [975563.790825472, 10], [975563.937596802, 11], [975564.120241757, 9], [975564.315089023, 10], [975564.494491285, 20], [975564.669141458, 14], [975564.850066895, 14], [975565.08009693, 13], [975565.269122861, 5], [975565.454122234, 22], [975565.684093678, 3], [975565.920183224, 32], [975566.10411236, 33], [975566.296327262, 11], [975566.482050827, 6], [975566.654538047, 8], [975566.803313473, 9], [975566.953157944, 13], [975567.101923822, 8], [975567.257442214, 20], [975567.412045399, 17], [975567.594298075, 20], [975567.740253216, 13], [975567.917268619, 6], [975568.099167742, 13], [975568.252968522, 9], [975568.438650162, 11], [975568.589390228, 8], [975568.772671136, 15], [975568.961287609, 16], [975569.172726128, 27], [975569.419844729, 4], [975569.56709117, 8], [975569.751384694, 25], [975569.936299212, 18], [975570.085309062, 13], [975570.321685508, 64], [975570.471690659, 2], [975570.656580987, 10], [975570.839385118, 11], [975570.993056218, 15], [975571.144318553, 17], [975571.301475266, 14], [975571.509168157, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-a0516a5178712b8059dfef0ed714e620", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.115947416, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.63971547, "time_to_first_token": 0.198062947, "token_sha": "8a91591c94a3", "tokens_per_second": 18.69540464834931}, "seed": 1234, "sent": 975557.668756248, "speculative": {"acceptance_rate": 0.4164705882352941, "accepted": 177, "drafted": 425, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2022099969908595, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 425, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.69817766110507, "done": 975571.509301882, "finish_reason": "length", "first": 975557.871596531, "full_response_s": 13.843325347057544, "last": 975571.509289178, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975557.871596531, 3], [975558.019884084, 11], [975558.203717056, 30], [975558.391488684, 19], [975558.571645569, 21], [975558.75474773, 15], [975558.902813067, 19], [975559.050297766, 17], [975559.236129247, 12], [975559.42402046, 5], [975559.592972293, 5], [975559.775453164, 27], [975559.957674943, 12], [975560.142928796, 13], [975560.335337022, 5], [975560.479142406, 16], [975560.662283712, 5], [975560.842200678, 14], [975561.026604224, 9], [975561.214442681, 27], [975561.366316224, 11], [975561.546739163, 8], [975561.69558676, 16], [975561.841940892, 5], [975561.991939676, 9], [975562.164417453, 14], [975562.322083523, 20], [975562.469691879, 8], [975562.619595545, 12], [975562.766730682, 5], [975562.917818382, 14], [975563.100976789, 14], [975563.255430746, 8], [975563.439561942, 13], [975563.61037046, 3], [975563.791859187, 10], [975563.939637801, 11], [975564.12055586, 9], [975564.312726817, 10], [975564.496913729, 20], [975564.668987079, 14], [975564.848719861, 14], [975565.082092537, 13], [975565.26901304, 5], [975565.456069955, 22], [975565.685307596, 3], [975565.922174272, 32], [975566.103672485, 33], [975566.295664721, 11], [975566.479571137, 6], [975566.653825603, 8], [975566.802187121, 9], [975566.95394941, 13], [975567.105559192, 8], [975567.256355988, 20], [975567.409294309, 17], [975567.591765011, 20], [975567.742244584, 13], [975567.914476522, 6], [975568.099965288, 13], [975568.252551526, 9], [975568.441836152, 11], [975568.588566012, 8], [975568.776805724, 15], [975568.959061848, 16], [975569.172327372, 27], [975569.422401361, 4], [975569.571156079, 8], [975569.752096018, 25], [975569.936874331, 18], [975570.087437994, 13], [975570.322281587, 64], [975570.473524479, 2], [975570.657421379, 10], [975570.839530682, 11], [975570.991774862, 15], [975571.142905361, 17], [975571.300716552, 14], [975571.509289178, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4fa88d9a5ca43cbdd8775794ad2041e3", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.115671136, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.639902632, "time_to_first_token": 0.201496017, "token_sha": "8a91591c94a3", "tokens_per_second": 18.69514811650893}, "seed": 1234, "sent": 975557.665976535, "speculative": {"acceptance_rate": 0.41451990632318503, "accepted": 177, "drafted": 427, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.20561999606434256, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 427, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.69657516611737, "done": 975571.509997158, "finish_reason": "length", "first": 975557.871044963, "full_response_s": 13.846122307004407, "last": 975571.509906505, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975557.871044963, 3], [975558.022265696, 11], [975558.20251573, 30], [975558.391792003, 19], [975558.571431799, 21], [975558.75528933, 15], [975558.904435725, 19], [975559.052502664, 17], [975559.236672207, 12], [975559.42481063, 5], [975559.592539681, 5], [975559.775588008, 18], [975559.957874441, 21], [975560.141305035, 13], [975560.334760767, 5], [975560.48036106, 16], [975560.66298798, 5], [975560.843633485, 14], [975561.026674494, 9], [975561.216680634, 27], [975561.364587377, 11], [975561.546635278, 8], [975561.695776018, 16], [975561.845086563, 5], [975561.994087487, 9], [975562.166473571, 14], [975562.320490624, 20], [975562.470080588, 8], [975562.617973639, 12], [975562.770278101, 5], [975562.918986605, 14], [975563.101902187, 14], [975563.253146795, 8], [975563.438772077, 13], [975563.610954571, 3], [975563.790498873, 10], [975563.938662548, 11], [975564.119915143, 9], [975564.311147582, 10], [975564.495518824, 20], [975564.667326598, 14], [975564.84825045, 14], [975565.08219863, 13], [975565.269994388, 5], [975565.453786067, 22], [975565.683227319, 3], [975565.921134701, 32], [975566.104341922, 33], [975566.297574491, 11], [975566.479948567, 6], [975566.654921108, 8], [975566.80178038, 9], [975566.954397669, 13], [975567.105273664, 8], [975567.256698443, 20], [975567.409235558, 17], [975567.592755223, 20], [975567.742793465, 13], [975567.914934429, 6], [975568.101887489, 13], [975568.253218019, 9], [975568.442158639, 11], [975568.587355198, 8], [975568.773117412, 15], [975568.958768145, 16], [975569.172588724, 27], [975569.420902107, 4], [975569.570567024, 8], [975569.75399518, 25], [975569.935935366, 18], [975570.08715317, 13], [975570.323351125, 64], [975570.474029041, 2], [975570.65695768, 10], [975570.839220403, 11], [975570.992448603, 15], [975571.142695111, 17], [975571.300020699, 14], [975571.509906505, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-9af62a95f7ff3c583632eb80e555414a", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.115986487, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.639846186, "time_to_first_token": 0.1978798, "token_sha": "8a91591c94a3", "tokens_per_second": 18.695225482948125}, "seed": 1234, "sent": 975557.663874851, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.20717011205852032, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.69316174965196, "done": 975571.511514811, "finish_reason": "length", "first": 975557.870126413, "full_response_s": 13.847391278948635, "last": 975571.511478444, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975557.870126413, 3], [975558.019840581, 11], [975558.20237839, 30], [975558.390084756, 19], [975558.571800124, 21], [975558.753151999, 15], [975558.90531986, 19], [975559.052119539, 17], [975559.23770429, 12], [975559.421513859, 5], [975559.592661117, 5], [975559.77798522, 27], [975559.958908476, 12], [975560.144587229, 13], [975560.331145462, 5], [975560.478224048, 16], [975560.660519106, 5], [975560.842822388, 14], [975561.027952442, 9], [975561.21385665, 27], [975561.365934747, 11], [975561.547689792, 8], [975561.697159899, 16], [975561.842044057, 5], [975561.992907792, 9], [975562.164652647, 14], [975562.319030858, 20], [975562.470459665, 8], [975562.621358439, 12], [975562.766417747, 5], [975562.916401318, 14], [975563.101609699, 14], [975563.253348725, 8], [975563.441535758, 13], [975563.61006794, 3], [975563.793534803, 10], [975563.939094168, 11], [975564.121621142, 9], [975564.314855301, 10], [975564.495047189, 20], [975564.669757185, 14], [975564.848532954, 14], [975565.081595687, 13], [975565.269716028, 5], [975565.455335991, 22], [975565.685129601, 3], [975565.919333312, 32], [975566.103810353, 33], [975566.297147943, 11], [975566.480773328, 6], [975566.654692123, 8], [975566.802480728, 9], [975566.954758651, 13], [975567.106461966, 8], [975567.257620657, 20], [975567.410477891, 17], [975567.594696768, 20], [975567.742054398, 13], [975567.91552966, 6], [975568.101638232, 13], [975568.253746164, 9], [975568.439268689, 11], [975568.587541497, 8], [975568.774145255, 15], [975568.960064204, 16], [975569.172393418, 27], [975569.423793338, 4], [975569.566761739, 8], [975569.751159996, 25], [975569.936805741, 18], [975570.08732291, 13], [975570.324836523, 64], [975570.473900021, 2], [975570.656791621, 10], [975570.841098318, 11], [975570.993624538, 15], [975571.144066, 17], [975571.301332726, 14], [975571.511478444, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-e382a5eead375f28c5ea23ca05c1c0ef", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.115595634, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.640036836, "time_to_first_token": 0.203392684, "token_sha": "8a91591c94a3", "tokens_per_second": 18.694964175388534}, "seed": 1234, "sent": 975557.664123532, "speculative": {"acceptance_rate": 0.4116279069767442, "accepted": 177, "drafted": 430, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2060028809355572, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 430, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.69587852339914, "done": 975571.510726289, "finish_reason": "length", "first": 975557.871333995, "full_response_s": 13.845326217007823, "last": 975571.510703746, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975557.871333995, 3], [975558.019384882, 11], [975558.204600615, 30], [975558.390899725, 19], [975558.574158729, 21], [975558.754523624, 15], [975558.903181745, 19], [975559.051036769, 17], [975559.236480757, 12], [975559.423966702, 5], [975559.592345286, 5], [975559.777058126, 27], [975559.957114351, 12], [975560.141905289, 13], [975560.332794279, 5], [975560.479265331, 16], [975560.662045287, 5], [975560.84509698, 14], [975561.027360027, 9], [975561.215246003, 27], [975561.364739309, 11], [975561.54763773, 8], [975561.69636493, 16], [975561.842099175, 5], [975561.991590053, 9], [975562.16613886, 14], [975562.320845638, 20], [975562.46843625, 8], [975562.620306725, 12], [975562.768052245, 5], [975562.916797291, 14], [975563.103114697, 14], [975563.253611646, 8], [975563.438047025, 13], [975563.612250343, 3], [975563.790885326, 10], [975563.938159763, 11], [975564.121494586, 9], [975564.31144303, 10], [975564.496106807, 20], [975564.6678242, 14], [975564.848198916, 14], [975565.081527897, 13], [975565.269196107, 5], [975565.456319388, 22], [975565.684484819, 3], [975565.919438013, 32], [975566.10448595, 33], [975566.296919741, 11], [975566.483188267, 6], [975566.654315141, 8], [975566.802746657, 9], [975566.953706969, 13], [975567.102987328, 8], [975567.256482097, 20], [975567.411548517, 17], [975567.593287016, 20], [975567.741268436, 13], [975567.918178418, 6], [975568.101983455, 13], [975568.252804991, 9], [975568.440575996, 11], [975568.589552112, 8], [975568.773822688, 15], [975568.959794388, 16], [975569.172217103, 27], [975569.423031471, 4], [975569.567293884, 8], [975569.751628351, 25], [975569.936569684, 18], [975570.088016202, 13], [975570.323031182, 64], [975570.472343744, 2], [975570.65690629, 10], [975570.840059131, 11], [975570.993255316, 15], [975571.143444178, 17], [975571.300104649, 14], [975571.510703746, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b9dcb75f09c895586e082fdb46265795", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.115787469, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.640031108, "time_to_first_token": 0.199534698, "token_sha": "8a91591c94a3", "tokens_per_second": 18.694972026159107}, "seed": 1234, "sent": 975557.665400072, "speculative": {"acceptance_rate": 0.4164705882352941, "accepted": 177, "drafted": 425, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.20593392301816493, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 425, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.69723613010393, "done": 975571.509667343, "finish_reason": "length", "first": 975557.871268668, "full_response_s": 13.846471225027926, "last": 975571.509648064, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975557.871268668, 3], [975558.019097866, 11], [975558.202768891, 30], [975558.390403643, 19], [975558.574095499, 21], [975558.753588387, 15], [975558.903421914, 19], [975559.050176074, 17], [975559.236398279, 12], [975559.425183307, 5], [975559.594035558, 5], [975559.777587583, 27], [975559.958127346, 12], [975560.142575334, 13], [975560.333293273, 5], [975560.479709222, 16], [975560.663423055, 5], [975560.845155234, 14], [975561.027735808, 9], [975561.216610268, 27], [975561.365645187, 11], [975561.546903031, 8], [975561.696159512, 16], [975561.845512055, 5], [975561.993709385, 9], [975562.166805434, 14], [975562.319344641, 20], [975562.47197831, 8], [975562.618379452, 12], [975562.769702662, 5], [975562.918049911, 14], [975563.101789278, 14], [975563.254854875, 8], [975563.439227824, 13], [975563.610888349, 3], [975563.79414701, 10], [975563.941363128, 11], [975564.121678085, 9], [975564.312233695, 10], [975564.495337981, 20], [975564.669610789, 14], [975564.848655175, 14], [975565.082155639, 13], [975565.269857368, 5], [975565.455800346, 22], [975565.683909811, 3], [975565.920963522, 32], [975566.104862691, 33], [975566.295548356, 11], [975566.481645255, 6], [975566.654099403, 8], [975566.8040503, 9], [975566.952489387, 13], [975567.103452307, 8], [975567.256025598, 20], [975567.409068347, 17], [975567.591437292, 20], [975567.741745654, 13], [975567.913970808, 6], [975568.099012451, 13], [975568.252110626, 9], [975568.438326763, 11], [975568.587826608, 8], [975568.777160834, 15], [975568.960807959, 16], [975569.172936698, 27], [975569.422780374, 4], [975569.568538233, 8], [975569.75278083, 25], [975569.935560752, 18], [975570.085110108, 13], [975570.322089081, 64], [975570.472192965, 2], [975570.655410668, 10], [975570.839827154, 11], [975570.992621222, 15], [975571.142591162, 17], [975571.300909794, 14], [975571.509648064, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-6abc6c98ff79a967bc3934d4141dde3d", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.115557187, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.640018661, "time_to_first_token": 0.205329492, "token_sha": "8a91591c94a3", "tokens_per_second": 18.694989085983043}, "seed": 1234, "sent": 975557.663196118, "speculative": {"acceptance_rate": 0.41067285382830626, "accepted": 177, "drafted": 431, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.20807255001273006, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 431, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.696943992795223, "done": 975571.510158673, "finish_reason": "length", "first": 975557.871551716, "full_response_s": 13.842913581989706, "last": 975571.51014421, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975557.871551716, 3], [975558.021719135, 11], [975558.202813354, 30], [975558.39266705, 19], [975558.572586278, 21], [975558.755387695, 15], [975558.904994749, 19], [975559.051303498, 17], [975559.237751392, 12], [975559.422445945, 5], [975559.593910458, 5], [975559.776105258, 27], [975559.958455513, 12], [975560.141198254, 13], [975560.334231742, 5], [975560.478440858, 16], [975560.66109013, 5], [975560.84235029, 14], [975561.028157604, 9], [975561.216370563, 27], [975561.365045668, 11], [975561.547595251, 8], [975561.697391781, 16], [975561.842863122, 5], [975561.992772308, 9], [975562.165610763, 14], [975562.319620105, 20], [975562.469343361, 8], [975562.620625148, 12], [975562.767564114, 5], [975562.917656882, 14], [975563.101218286, 14], [975563.254295371, 8], [975563.440245315, 13], [975563.61390292, 3], [975563.79392468, 10], [975563.938251296, 11], [975564.121141332, 9], [975564.311558403, 10], [975564.496631657, 20], [975564.668790236, 14], [975564.849758344, 14], [975565.081863232, 13], [975565.269581152, 5], [975565.455098238, 22], [975565.684768955, 3], [975565.920313061, 32], [975566.105128108, 33], [975566.295455111, 11], [975566.479725645, 6], [975566.656031493, 8], [975566.802530407, 9], [975566.954471235, 13], [975567.102546061, 8], [975567.256167914, 20], [975567.412315727, 17], [975567.593191802, 20], [975567.74211894, 13], [975567.91527098, 6], [975568.102175241, 13], [975568.252222671, 9], [975568.439408493, 11], [975568.589906982, 8], [975568.778028521, 15], [975568.959427262, 16], [975569.173023544, 27], [975569.422068282, 4], [975569.567631074, 8], [975569.752353978, 25], [975569.936514182, 18], [975570.085908693, 13], [975570.323814792, 64], [975570.473024925, 2], [975570.655854447, 10], [975570.841307944, 11], [975570.992370077, 15], [975571.144021105, 17], [975571.300340594, 14], [975571.51014421, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-6eab84d704d7265ff9b800601923f302", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.11574947, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.640282029, "time_to_first_token": 0.200239973, "token_sha": "8a91591c94a3", "tokens_per_second": 18.69462812116757}, "seed": 1234, "sent": 975557.667245091, "speculative": {"acceptance_rate": 0.4164705882352941, "accepted": 177, "drafted": 425, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.20430662494618446, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 425, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.693700036535553, "done": 975571.514127554, "finish_reason": "length", "first": 975557.87058104, "full_response_s": 13.85016141005326, "last": 975571.511540267, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975557.87058104, 3], [975558.019342467, 11], [975558.20323715, 30], [975558.392273429, 19], [975558.571064017, 21], [975558.752564656, 15], [975558.903805871, 19], [975559.050402659, 17], [975559.237068052, 12], [975559.423367551, 5], [975559.592919574, 5], [975559.776312132, 18], [975559.956978547, 21], [975560.142448746, 9], [975560.332162265, 9], [975560.47762189, 16], [975560.661200927, 5], [975560.842984384, 14], [975561.028705029, 9], [975561.21399951, 27], [975561.365742864, 11], [975561.547752431, 8], [975561.696121577, 16], [975561.84251206, 5], [975561.991223712, 9], [975562.164333072, 14], [975562.320546991, 20], [975562.472799471, 8], [975562.619127814, 12], [975562.767617489, 5], [975562.917884172, 14], [975563.101859884, 14], [975563.253706187, 8], [975563.43823318, 13], [975563.613644415, 3], [975563.791569867, 10], [975563.937852859, 11], [975564.121558728, 9], [975564.314530382, 10], [975564.495990331, 20], [975564.671141562, 14], [975564.848795187, 14], [975565.081781954, 13], [975565.26993087, 5], [975565.45468889, 22], [975565.684585456, 3], [975565.919491756, 32], [975566.104936913, 33], [975566.295800157, 11], [975566.480076595, 6], [975566.653399439, 8], [975566.801522083, 9], [975566.952748244, 13], [975567.103286504, 8], [975567.255757685, 20], [975567.410304824, 17], [975567.592362802, 20], [975567.741595099, 13], [975567.917136975, 6], [975568.100724306, 13], [975568.252372459, 9], [975568.439632998, 11], [975568.589184554, 8], [975568.777107747, 15], [975568.961374375, 16], [975569.17202858, 27], [975569.422173095, 4], [975569.567222846, 8], [975569.752215598, 25], [975569.936237997, 18], [975570.085591198, 13], [975570.323572831, 64], [975570.473555342, 2], [975570.657774169, 10], [975570.83997259, 11], [975570.992698308, 15], [975571.145544374, 17], [975571.300661769, 14], [975571.511540267, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-09fc5c338263578a7e403761a8c94cad", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.116063141, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.640795727, "time_to_first_token": 0.196813111, "token_sha": "8a91591c94a3", "tokens_per_second": 18.69392410116252}, "seed": 1234, "sent": 975557.663966144, "speculative": {"acceptance_rate": 0.42042755344418054, "accepted": 177, "drafted": 421, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.2066148960730061, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 421, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "candidate", "burst": 0, "phase": "primed_first_burst", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.695645004829764, "done": 975571.510867374, "finish_reason": "length", "first": 975557.87073086, "full_response_s": 13.849237259011716, "last": 975571.510270974, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975557.87073086, 3], [975558.018957822, 11], [975558.203326859, 30], [975558.392852805, 19], [975558.57320146, 21], [975558.752178267, 15], [975558.902374552, 19], [975559.052647076, 17], [975559.236239259, 12], [975559.423461484, 5], [975559.593737439, 5], [975559.774719649, 27], [975559.957725629, 12], [975560.1409829, 13], [975560.331602249, 5], [975560.479858034, 16], [975560.660620719, 5], [975560.842452623, 14], [975561.028057479, 9], [975561.213305946, 27], [975561.364433861, 11], [975561.547359402, 8], [975561.695454796, 16], [975561.845874876, 5], [975561.992986078, 9], [975562.165031356, 14], [975562.320301622, 20], [975562.470543263, 8], [975562.619813475, 12], [975562.769992701, 5], [975562.91718592, 14], [975563.10072614, 14], [975563.255215872, 8], [975563.440969726, 13], [975563.612947587, 3], [975563.792434114, 10], [975563.940063933, 11], [975564.120409721, 9], [975564.313914048, 10], [975564.494898602, 20], [975564.668332025, 14], [975564.850205403, 14], [975565.081323311, 13], [975565.269505682, 5], [975565.454428881, 22], [975565.683799174, 3], [975565.921605456, 32], [975566.105472578, 33], [975566.295236461, 11], [975566.480215279, 6], [975566.654181065, 8], [975566.802286974, 9], [975566.952552825, 13], [975567.102155224, 8], [975567.256413891, 20], [975567.409168296, 17], [975567.591610615, 20], [975567.740899214, 13], [975567.917981255, 6], [975568.101490461, 13], [975568.252705633, 9], [975568.442541348, 11], [975568.590130751, 8], [975568.773502473, 15], [975568.961638208, 16], [975569.171969878, 27], [975569.423891127, 4], [975569.569591323, 8], [975569.751885464, 25], [975569.936752591, 18], [975570.086080513, 13], [975570.32247195, 64], [975570.474474212, 2], [975570.657894902, 10], [975570.84097669, 11], [975570.994107516, 15], [975571.144524291, 17], [975571.300818453, 14], [975571.510270974, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-431bb873ef38b3a014ddb5e625872e4f", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.115826539, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.639743789, "time_to_first_token": 0.19908375, "token_sha": "8a91591c94a3", "tokens_per_second": 18.695365832725464}, "seed": 1234, "sent": 975557.661630115, "speculative": {"acceptance_rate": 0.4164705882352941, "accepted": 177, "drafted": 425, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.20910074503626674, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 425, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.646402134923527, "done": 975585.340034067, "finish_reason": "length", "first": 975571.664417564, "full_response_s": 13.802466261084192, "last": 975585.339978037, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975571.664417564, 3], [975571.814160294, 11], [975571.995699766, 30], [975572.180183155, 19], [975572.368843979, 21], [975572.551973726, 15], [975572.697188331, 19], [975572.845287064, 17], [975573.031280943, 12], [975573.214552339, 5], [975573.388812468, 5], [975573.572664424, 27], [975573.753388643, 12], [975573.938645026, 13], [975574.120166284, 5], [975574.272696739, 16], [975574.460558763, 5], [975574.640350373, 14], [975574.824871899, 9], [975575.010080194, 27], [975575.156661508, 11], [975575.345191309, 8], [975575.493736328, 16], [975575.642625865, 5], [975575.789161357, 9], [975575.963965419, 14], [975576.114452036, 20], [975576.266132011, 8], [975576.418402913, 12], [975576.566662888, 5], [975576.715381841, 14], [975576.900662941, 14], [975577.047127306, 8], [975577.235503666, 13], [975577.414574766, 3], [975577.595666289, 10], [975577.740512299, 11], [975577.926392396, 9], [975578.109806211, 10], [975578.300480079, 20], [975578.476885915, 14], [975578.656473053, 14], [975578.889444332, 13], [975579.073746559, 5], [975579.261564816, 22], [975579.49616255, 3], [975579.737559326, 43], [975579.924113541, 22], [975580.109481167, 11], [975580.298343352, 6], [975580.47279549, 8], [975580.622338468, 9], [975580.769836975, 13], [975580.922535868, 8], [975581.070485566, 20], [975581.223934391, 17], [975581.413272279, 20], [975581.561855272, 13], [975581.734045494, 6], [975581.922060845, 13], [975582.071777618, 9], [975582.260022021, 11], [975582.413310983, 8], [975582.5968763, 15], [975582.782622213, 16], [975582.995628571, 27], [975583.24409943, 4], [975583.396082304, 8], [975583.57956326, 25], [975583.766742018, 18], [975583.915445401, 13], [975584.145125174, 64], [975584.29956851, 2], [975584.488926764, 10], [975584.671943018, 11], [975584.821525211, 15], [975584.975977927, 17], [975585.128581463, 14], [975585.339978037, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-1a589ed06db97a62397034738b96505b", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033346501, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.677097965, "time_to_first_token": 0.122907837, "token_sha": "8a91591c94a3", "tokens_per_second": 18.644306025485136}, "seed": 1234, "sent": 975571.537567806, "speculative": {"acceptance_rate": 0.4135514018691589, "accepted": 177, "drafted": 428, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12684975808952004, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 428, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.644137258970215, "done": 975585.341105365, "finish_reason": "length", "first": 975571.663852076, "full_response_s": 13.80198897793889, "last": 975585.341073846, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975571.663852076, 3], [975571.81369714, 11], [975571.99535104, 30], [975572.180386078, 19], [975572.369368812, 21], [975572.550033861, 15], [975572.697236138, 19], [975572.845033135, 17], [975573.030113168, 12], [975573.214493205, 5], [975573.388332066, 5], [975573.57202505, 27], [975573.754206796, 12], [975573.938253069, 13], [975574.120686589, 5], [975574.272814208, 16], [975574.45858973, 5], [975574.642925549, 14], [975574.823183754, 9], [975575.008466783, 27], [975575.155110767, 11], [975575.346501449, 8], [975575.493440881, 16], [975575.640317418, 5], [975575.788641307, 9], [975575.964423215, 14], [975576.111507686, 20], [975576.266643724, 8], [975576.418251045, 12], [975576.5676575, 5], [975576.715461311, 14], [975576.899770118, 14], [975577.047942259, 8], [975577.234701624, 13], [975577.411560498, 3], [975577.594623503, 10], [975577.74170241, 11], [975577.925924521, 9], [975578.110535775, 10], [975578.301630607, 20], [975578.475047758, 14], [975578.658533027, 14], [975578.891744828, 13], [975579.074428508, 5], [975579.263401293, 22], [975579.497080461, 3], [975579.737312245, 43], [975579.923198079, 22], [975580.109286389, 11], [975580.298934935, 6], [975580.472978173, 8], [975580.622419138, 9], [975580.771253256, 13], [975580.922322386, 8], [975581.072089218, 20], [975581.223732797, 17], [975581.414478742, 20], [975581.562805149, 13], [975581.735248516, 6], [975581.922777018, 13], [975582.071248945, 9], [975582.26049612, 11], [975582.411930333, 8], [975582.597823666, 15], [975582.782977819, 16], [975582.996142461, 27], [975583.242188828, 4], [975583.395670795, 8], [975583.581127873, 25], [975583.765254155, 18], [975583.915716226, 13], [975584.144043588, 64], [975584.30103703, 2], [975584.489119975, 10], [975584.673151753, 11], [975584.821713093, 15], [975584.975426646, 17], [975585.127844939, 14], [975585.341073846, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-000f56e38fb7158fec6b2e1b61d1df2b", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033487617, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.677867176, "time_to_first_token": 0.122420043, "token_sha": "8a91591c94a3", "tokens_per_second": 18.64325751367422}, "seed": 1234, "sent": 975571.539116387, "speculative": {"acceptance_rate": 0.4154929577464789, "accepted": 177, "drafted": 426, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12473568902350962, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 426, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.64722451535244, "done": 975585.33949053, "finish_reason": "length", "first": 975571.664231522, "full_response_s": 13.801866644993424, "last": 975585.339188875, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975571.664231522, 3], [975571.812998343, 11], [975571.99592056, 30], [975572.179268013, 19], [975572.369025894, 21], [975572.549634144, 15], [975572.697557537, 19], [975572.845764683, 17], [975573.031497113, 12], [975573.214067745, 5], [975573.388647561, 5], [975573.57313497, 27], [975573.753625996, 12], [975573.937199899, 13], [975574.119127801, 5], [975574.272908813, 16], [975574.458494885, 5], [975574.639581787, 14], [975574.825148195, 9], [975575.010346378, 27], [975575.158182697, 11], [975575.347381104, 8], [975575.493895332, 16], [975575.640924585, 5], [975575.789582097, 9], [975575.964780581, 14], [975576.11264199, 20], [975576.266178441, 8], [975576.418052427, 12], [975576.565768865, 5], [975576.715664425, 14], [975576.899969585, 14], [975577.049183505, 8], [975577.235605839, 13], [975577.415048849, 3], [975577.594879719, 10], [975577.739347404, 11], [975577.926039878, 9], [975578.109142758, 10], [975578.300762935, 20], [975578.475336518, 14], [975578.657576558, 14], [975578.89104288, 13], [975579.073243277, 5], [975579.262281196, 22], [975579.498277227, 3], [975579.736432366, 43], [975579.923557685, 22], [975580.108863105, 11], [975580.301390835, 6], [975580.473289061, 8], [975580.621450285, 9], [975580.769649365, 13], [975580.924453431, 8], [975581.072368778, 20], [975581.222496959, 17], [975581.414278747, 20], [975581.560965073, 13], [975581.735521709, 6], [975581.921899394, 13], [975582.0708643, 9], [975582.260593941, 11], [975582.411652085, 8], [975582.597474492, 15], [975582.784746906, 16], [975582.997045124, 27], [975583.241851253, 4], [975583.396164686, 8], [975583.579845765, 25], [975583.766162066, 18], [975583.913267846, 13], [975584.145954639, 64], [975584.299757001, 2], [975584.489619929, 10], [975584.672132309, 11], [975584.822012285, 15], [975584.973991566, 17], [975585.124690291, 14], [975585.339188875, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-c541ff9f26b47431530b685b1b8e5e80", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033273447, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.677032735, "time_to_first_token": 0.122780705, "token_sha": "8a91591c94a3", "tokens_per_second": 18.644394945948047}, "seed": 1234, "sent": 975571.537623885, "speculative": {"acceptance_rate": 0.41067285382830626, "accepted": 177, "drafted": 431, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1266076370375231, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 431, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.639349506804404, "done": 975585.344586805, "finish_reason": "length", "first": 975571.663497558, "full_response_s": 13.806880554999225, "last": 975585.344232495, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975571.663497558, 3], [975571.812890922, 11], [975571.996398291, 30], [975572.178851673, 19], [975572.368078384, 21], [975572.551920207, 15], [975572.696764279, 19], [975572.845702716, 17], [975573.031366285, 12], [975573.215171538, 5], [975573.391831999, 5], [975573.572806004, 18], [975573.754098607, 21], [975573.937606591, 9], [975574.119574284, 9], [975574.272228288, 16], [975574.457932213, 5], [975574.640433187, 14], [975574.824442199, 9], [975575.009782026, 27], [975575.156986762, 11], [975575.346840895, 8], [975575.494479203, 16], [975575.641779553, 5], [975575.788862981, 9], [975575.963466393, 14], [975576.113964129, 20], [975576.265101368, 8], [975576.41736347, 12], [975576.567957859, 5], [975576.716523889, 14], [975576.901636034, 14], [975577.048176413, 8], [975577.235858104, 13], [975577.415343464, 3], [975577.59543188, 10], [975577.740191556, 11], [975577.925564675, 9], [975578.112082483, 10], [975578.298959162, 20], [975578.476744351, 14], [975578.657325013, 14], [975578.892083843, 13], [975579.074231458, 5], [975579.263287744, 22], [975579.497261064, 3], [975579.736580778, 43], [975579.92394409, 22], [975580.108985821, 11], [975580.299831678, 6], [975580.47346352, 8], [975580.62097849, 9], [975580.769929885, 13], [975580.921073573, 8], [975581.071099261, 20], [975581.224147793, 17], [975581.411913933, 20], [975581.560246869, 13], [975581.734859199, 6], [975581.92227204, 13], [975582.071537785, 9], [975582.2599414, 11], [975582.414425495, 8], [975582.598577709, 15], [975582.784673116, 16], [975582.997254398, 27], [975583.242663486, 4], [975583.397181425, 8], [975583.581323755, 25], [975583.764708827, 18], [975583.914034721, 13], [975584.144253582, 64], [975584.300132255, 2], [975584.488554119, 10], [975584.674312664, 11], [975584.823332136, 15], [975584.974593485, 17], [975585.124900957, 14], [975585.344232495, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-dd4216494a306bb38b8b14a8b4f171f2", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033795081, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.681690446, "time_to_first_token": 0.120696267, "token_sha": "8a91591c94a3", "tokens_per_second": 18.638047762186595}, "seed": 1234, "sent": 975571.53770625, "speculative": {"acceptance_rate": 0.4194312796208531, "accepted": 177, "drafted": 422, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12579130800440907, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 422, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.64404827549493, "done": 975585.34165007, "finish_reason": "length", "first": 975571.664332719, "full_response_s": 13.803059237077832, "last": 975585.341619767, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975571.664332719, 3], [975571.814289315, 11], [975571.996624124, 30], [975572.180495466, 19], [975572.367860903, 21], [975572.549351752, 15], [975572.698789214, 19], [975572.845821417, 17], [975573.029981604, 12], [975573.214786733, 5], [975573.38968574, 5], [975573.571146946, 27], [975573.753958419, 12], [975573.937473107, 13], [975574.120744572, 5], [975574.272175298, 16], [975574.459936556, 5], [975574.639542364, 14], [975574.824186894, 9], [975575.009117725, 27], [975575.157131558, 11], [975575.346342077, 8], [975575.493011549, 16], [975575.642289603, 5], [975575.790176112, 9], [975575.964227412, 14], [975576.114880392, 20], [975576.265892113, 8], [975576.417520986, 12], [975576.566470013, 5], [975576.714465723, 14], [975576.899434272, 14], [975577.047332196, 8], [975577.23522241, 13], [975577.411168237, 3], [975577.593911411, 10], [975577.741577998, 11], [975577.927491469, 9], [975578.110325317, 10], [975578.298568917, 20], [975578.475904182, 14], [975578.656236883, 14], [975578.890108266, 13], [975579.073391433, 5], [975579.262501974, 22], [975579.496307346, 3], [975579.738121135, 43], [975579.924398509, 22], [975580.108139813, 11], [975580.299502279, 6], [975580.474147677, 8], [975580.620908588, 9], [975580.771765242, 13], [975580.921909182, 8], [975581.070764855, 20], [975581.223436325, 17], [975581.413092108, 20], [975581.562158847, 13], [975581.735782501, 6], [975581.920917773, 13], [975582.070628562, 9], [975582.260414363, 11], [975582.411801841, 8], [975582.598801015, 15], [975582.781662688, 16], [975582.996324264, 27], [975583.242288553, 4], [975583.396440502, 8], [975583.57944968, 25], [975583.76602663, 18], [975583.916374768, 13], [975584.145555498, 64], [975584.301120211, 2], [975584.488417962, 10], [975584.674358663, 11], [975584.823426902, 15], [975584.9767972, 17], [975585.126869766, 14], [975585.341619767, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-1e9377280e987de1f4853ae6bb1379b5", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033636318, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.679129988, "time_to_first_token": 0.122235504, "token_sha": "8a91591c94a3", "tokens_per_second": 18.641536429853247}, "seed": 1234, "sent": 975571.538590833, "speculative": {"acceptance_rate": 0.4154929577464789, "accepted": 177, "drafted": 426, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12574188609141856, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 426, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.644063913326967, "done": 975585.339917014, "finish_reason": "length", "first": 975571.662598016, "full_response_s": 13.802004609024152, "last": 975585.339873592, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975571.662598016, 3], [975571.813794001, 11], [975571.994417034, 30], [975572.177819094, 19], [975572.368552227, 21], [975572.55027923, 15], [975572.69643232, 19], [975572.845901463, 17], [975573.030518261, 12], [975573.214441814, 5], [975573.389813448, 5], [975573.571951868, 27], [975573.754432822, 12], [975573.937403461, 13], [975574.121373082, 5], [975574.272455882, 16], [975574.457482273, 5], [975574.64167704, 14], [975574.8246896, 9], [975575.010498358, 27], [975575.156250975, 11], [975575.346745026, 8], [975575.492470108, 16], [975575.642681752, 5], [975575.789427189, 9], [975575.962993095, 14], [975576.114675437, 20], [975576.265629289, 8], [975576.418158136, 12], [975576.566177125, 5], [975576.714590632, 14], [975576.900942405, 14], [975577.04777884, 8], [975577.23479199, 13], [975577.412069476, 3], [975577.592204018, 10], [975577.741483568, 11], [975577.927126487, 9], [975578.111876425, 10], [975578.299976701, 20], [975578.474182998, 14], [975578.657120971, 14], [975578.891092558, 13], [975579.074101925, 5], [975579.262362346, 22], [975579.496580043, 3], [975579.738704958, 43], [975579.92516436, 22], [975580.108023512, 11], [975580.299335436, 6], [975580.472585464, 8], [975580.619908488, 9], [975580.7724014, 13], [975580.922644217, 8], [975581.070590875, 20], [975581.22360944, 17], [975581.414389224, 20], [975581.562445111, 13], [975581.73491515, 6], [975581.92062503, 13], [975582.071823393, 9], [975582.259485396, 11], [975582.414510549, 8], [975582.598518798, 15], [975582.781271595, 16], [975582.996239114, 27], [975583.243508535, 4], [975583.396350568, 8], [975583.580506418, 25], [975583.765080304, 18], [975583.914942663, 13], [975584.145338448, 64], [975584.299661836, 2], [975584.489712182, 10], [975584.674407078, 11], [975584.823697406, 15], [975584.976286094, 17], [975585.126017342, 14], [975585.339873592, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-8fa508d0f0858aa338af0b0d14411b08", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033235336, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.676986416, "time_to_first_token": 0.122852879, "token_sha": "8a91591c94a3", "tokens_per_second": 18.644458087761837}, "seed": 1234, "sent": 975571.537912405, "speculative": {"acceptance_rate": 0.4097222222222222, "accepted": 177, "drafted": 432, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1246856109937653, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 432, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.641047950249447, "done": 975585.343155069, "finish_reason": "length", "first": 975571.663643394, "full_response_s": 13.804679527995177, "last": 975585.343131837, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975571.663643394, 3], [975571.814556219, 11], [975571.995441501, 30], [975572.18060132, 19], [975572.367674204, 21], [975572.550541126, 15], [975572.697699277, 19], [975572.845516226, 17], [975573.030944921, 12], [975573.214158446, 5], [975573.389890678, 5], [975573.57373137, 18], [975573.754370423, 21], [975573.938450152, 9], [975574.121617123, 9], [975574.272359325, 16], [975574.458045857, 5], [975574.641054657, 14], [975574.8238434, 9], [975575.008152664, 27], [975575.156576198, 11], [975575.346281567, 8], [975575.493155417, 16], [975575.641511865, 5], [975575.789099582, 9], [975575.964147718, 14], [975576.115230558, 20], [975576.26521562, 8], [975576.417054263, 12], [975576.567055069, 5], [975576.714315471, 14], [975576.899596379, 14], [975577.047577453, 8], [975577.234546956, 13], [975577.415868298, 3], [975577.592944174, 10], [975577.740649416, 11], [975577.926300798, 9], [975578.10993168, 10], [975578.30029962, 20], [975578.474669113, 14], [975578.658093759, 14], [975578.890530334, 13], [975579.07514044, 5], [975579.262057794, 22], [975579.497983443, 3], [975579.737835191, 43], [975579.924843745, 22], [975580.10953091, 11], [975580.300074631, 6], [975580.472323456, 8], [975580.621324673, 9], [975580.771917445, 13], [975580.923481554, 8], [975581.071498706, 20], [975581.2230316, 17], [975581.412450654, 20], [975581.5627084, 13], [975581.73603123, 6], [975581.921679352, 13], [975582.071144388, 9], [975582.259780972, 11], [975582.412357521, 8], [975582.597753028, 15], [975582.782803216, 16], [975582.996073791, 27], [975583.243289997, 4], [975583.395341876, 8], [975583.579776743, 25], [975583.764465425, 18], [975583.915565558, 13], [975584.145697206, 64], [975584.300787677, 2], [975584.487937656, 10], [975584.674129534, 11], [975584.823970503, 15], [975584.974433426, 17], [975585.128475754, 14], [975585.343131837, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-244d9b51ec8dccb81eb670fd5330ecbb", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033755754, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.680606092, "time_to_first_token": 0.120802456, "token_sha": "8a91591c94a3", "tokens_per_second": 18.6395250535805}, "seed": 1234, "sent": 975571.538475541, "speculative": {"acceptance_rate": 0.4194312796208531, "accepted": 177, "drafted": 422, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12516785296611488, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 422, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.644278043641652, "done": 975585.339829209, "finish_reason": "length", "first": 975571.662666782, "full_response_s": 13.801551550976, "last": 975585.339785274, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975571.662666782, 3], [975571.812575283, 11], [975571.995263954, 30], [975572.180738468, 19], [975572.368614289, 21], [975572.552137065, 15], [975572.699038359, 19], [975572.84699596, 17], [975573.031036454, 12], [975573.214690623, 5], [975573.389243976, 5], [975573.573234472, 27], [975573.75428617, 12], [975573.938186831, 13], [975574.120042495, 5], [975574.272109492, 16], [975574.460332641, 5], [975574.640789673, 14], [975574.824494197, 9], [975575.008631962, 27], [975575.155713374, 11], [975575.345935609, 8], [975575.495238078, 16], [975575.641186546, 5], [975575.789232827, 9], [975575.964822147, 14], [975576.112917343, 20], [975576.265575674, 8], [975576.417968621, 12], [975576.567488897, 5], [975576.717219678, 14], [975576.899081402, 14], [975577.048621088, 8], [975577.235362566, 13], [975577.413185445, 3], [975577.595200942, 10], [975577.739891085, 11], [975577.926837583, 9], [975578.109277762, 10], [975578.298844605, 20], [975578.475783529, 14], [975578.657792328, 14], [975578.892261678, 13], [975579.073925786, 5], [975579.262932266, 22], [975579.496470494, 3], [975579.738475093, 43], [975579.924719988, 22], [975580.111024548, 11], [975580.298743613, 6], [975580.473930291, 8], [975580.621377647, 9], [975580.770400416, 13], [975580.924225149, 8], [975581.072293132, 20], [975581.22274116, 17], [975581.413521664, 20], [975581.561236665, 13], [975581.735292323, 6], [975581.921807861, 13], [975582.071113573, 9], [975582.259282122, 11], [975582.414912506, 8], [975582.598326612, 15], [975582.781048209, 16], [975582.995710745, 27], [975583.242889368, 4], [975583.397066277, 8], [975583.579951874, 25], [975583.764867446, 18], [975583.914439429, 13], [975584.145461532, 64], [975584.299476657, 2], [975584.488094643, 10], [975584.672295313, 11], [975584.82220388, 15], [975584.976652964, 17], [975585.124527543, 14], [975585.339785274, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-415c42274dd07e1907c19547df0f0257", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033414579, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.677087309, "time_to_first_token": 0.12258847, "token_sha": "8a91591c94a3", "tokens_per_second": 18.644320551511075}, "seed": 1234, "sent": 975571.538277658, "speculative": {"acceptance_rate": 0.4154929577464789, "accepted": 177, "drafted": 426, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12438912398647517, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 426, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.643923153788304, "done": 975585.34045468, "finish_reason": "length", "first": 975571.663026915, "full_response_s": 13.801771337050013, "last": 975585.340405753, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975571.663026915, 3], [975571.814760982, 11], [975571.99549846, 30], [975572.179484487, 19], [975572.367774617, 21], [975572.551678822, 15], [975572.696581404, 19], [975572.846522917, 17], [975573.030572819, 12], [975573.215225232, 5], [975573.388491325, 5], [975573.573316405, 27], [975573.75484281, 12], [975573.936795622, 13], [975574.120459588, 5], [975574.272723314, 16], [975574.459856543, 5], [975574.639992639, 14], [975574.823013807, 9], [975575.010784478, 27], [975575.15599975, 11], [975575.345106336, 8], [975575.49409883, 16], [975575.641983547, 5], [975575.788781623, 9], [975575.964863522, 14], [975576.11299798, 20], [975576.265370912, 8], [975576.41723725, 12], [975576.567320277, 5], [975576.716240985, 14], [975576.902213138, 14], [975577.047828854, 8], [975577.235416052, 13], [975577.412597333, 3], [975577.593819989, 10], [975577.739672195, 11], [975577.926171106, 9], [975578.110068604, 10], [975578.299666694, 20], [975578.474380961, 14], [975578.656838163, 14], [975578.891692749, 13], [975579.076391349, 5], [975579.263185219, 22], [975579.495784849, 3], [975579.736529211, 43], [975579.924466523, 22], [975580.110665038, 11], [975580.29856365, 6], [975580.472710485, 8], [975580.62262614, 9], [975580.770467406, 13], [975580.922136903, 8], [975581.07180761, 20], [975581.223829274, 17], [975581.412326721, 20], [975581.561293543, 13], [975581.734788257, 6], [975581.922147595, 13], [975582.071192546, 9], [975582.260246223, 11], [975582.412517149, 8], [975582.598126873, 15], [975582.784321142, 16], [975582.995531982, 27], [975583.24427341, 4], [975583.396761789, 8], [975583.580143644, 25], [975583.764586542, 18], [975583.914346888, 13], [975584.144861997, 64], [975584.299852551, 2], [975584.4886621, 10], [975584.67254521, 11], [975584.822471856, 15], [975584.976097684, 17], [975585.125870114, 14], [975585.340405753, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-5fb08ec5f3c5e5e3265b38133687169c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.03345085, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.676938289, "time_to_first_token": 0.122497832, "token_sha": "8a91591c94a3", "tokens_per_second": 18.644523694684633}, "seed": 1234, "sent": 975571.538683343, "speculative": {"acceptance_rate": 0.4154929577464789, "accepted": 177, "drafted": 426, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12434357206802815, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 426, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.6411381040942, "done": 975585.342482031, "finish_reason": "length", "first": 975571.662956549, "full_response_s": 13.803460121969692, "last": 975585.342378834, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975571.662956549, 3], [975571.814212805, 11], [975571.995154902, 30], [975572.180081382, 19], [975572.36746285, 21], [975572.550382043, 15], [975572.697124781, 19], [975572.84536263, 17], [975573.030234749, 12], [975573.214899785, 5], [975573.390630801, 5], [975573.57241819, 18], [975573.753535711, 21], [975573.937706557, 13], [975574.119734904, 5], [975574.271930953, 16], [975574.459672452, 5], [975574.639471534, 14], [975574.825319294, 9], [975575.007770514, 27], [975575.157425278, 11], [975575.345323946, 8], [975575.493643355, 16], [975575.642055017, 5], [975575.789301897, 9], [975575.964275795, 14], [975576.11417334, 20], [975576.26552566, 8], [975576.419761979, 12], [975576.566951552, 5], [975576.71486616, 14], [975576.903083946, 14], [975577.049947915, 8], [975577.23607357, 13], [975577.413574314, 3], [975577.594205386, 10], [975577.740702438, 11], [975577.924975603, 9], [975578.108444553, 10], [975578.301472676, 20], [975578.475288583, 14], [975578.658834283, 14], [975578.890638539, 13], [975579.074712724, 5], [975579.261949269, 22], [975579.4973861, 3], [975579.736663815, 43], [975579.925219094, 22], [975580.108526698, 11], [975580.299577909, 6], [975580.473192983, 8], [975580.620723361, 9], [975580.77030101, 13], [975580.921402524, 8], [975581.071560112, 20], [975581.223692734, 17], [975581.412423263, 20], [975581.561734923, 13], [975581.736784697, 6], [975581.920463018, 13], [975582.070809517, 9], [975582.259705886, 11], [975582.412260244, 8], [975582.597146773, 15], [975582.782919645, 16], [975582.996595888, 27], [975583.24252341, 4], [975583.396523604, 8], [975583.580260409, 25], [975583.7635139, 18], [975583.916121223, 13], [975584.145243362, 64], [975584.300205469, 2], [975584.489398703, 10], [975584.672647863, 11], [975584.823243643, 15], [975584.975506756, 17], [975585.125474989, 14], [975585.342378834, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-8ec0b67a24e911cf13887ec92e67e752", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033718955, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.679948382, "time_to_first_token": 0.122139971, "token_sha": "8a91591c94a3", "tokens_per_second": 18.640421212080565}, "seed": 1234, "sent": 975571.539021909, "speculative": {"acceptance_rate": 0.4164705882352941, "accepted": 177, "drafted": 425, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12393463996704668, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 425, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.64323505250243, "done": 975585.34309387, "finish_reason": "length", "first": 975571.663548933, "full_response_s": 13.805274519021623, "last": 975585.341432588, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975571.663548933, 3], [975571.813306686, 11], [975571.994208384, 30], [975572.177668122, 19], [975572.367977187, 21], [975572.549435301, 15], [975572.69695749, 19], [975572.846717408, 17], [975573.030728351, 12], [975573.214833419, 5], [975573.390987335, 5], [975573.57228485, 27], [975573.753474321, 12], [975573.937327143, 13], [975574.120619087, 5], [975574.272419707, 16], [975574.459028086, 5], [975574.642153346, 14], [975574.822785973, 9], [975575.010597347, 27], [975575.155364904, 11], [975575.345673568, 8], [975575.494231002, 16], [975575.640644945, 5], [975575.789877417, 9], [975575.964640104, 14], [975576.115157552, 20], [975576.266502608, 8], [975576.419644574, 12], [975576.566531611, 5], [975576.714912703, 14], [975576.901234877, 14], [975577.046870305, 8], [975577.235276392, 13], [975577.411839962, 3], [975577.593631706, 10], [975577.740374671, 11], [975577.924428771, 9], [975578.110807655, 10], [975578.29958572, 20], [975578.473879167, 14], [975578.657475825, 14], [975578.891610048, 13], [975579.074906719, 5], [975579.262702128, 22], [975579.497751834, 3], [975579.737214952, 43], [975579.923852957, 22], [975580.10839339, 11], [975580.301090779, 6], [975580.474560209, 8], [975580.622111803, 9], [975580.770812724, 13], [975580.922438799, 8], [975581.071634798, 20], [975581.222588653, 17], [975581.412558379, 20], [975581.56083538, 13], [975581.735031978, 6], [975581.921352129, 13], [975582.07149985, 9], [975582.26015581, 11], [975582.412786165, 8], [975582.598079131, 15], [975582.782376076, 16], [975582.996831066, 27], [975583.244020025, 4], [975583.396827275, 8], [975583.580847929, 25], [975583.763602313, 18], [975583.914861802, 13], [975584.145758068, 64], [975584.301827648, 2], [975584.48880176, 10], [975584.673662315, 11], [975584.822830726, 15], [975584.976903613, 17], [975585.124019525, 14], [975585.341432588, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-3a07c084d75ec883abef3e4247a8deb7", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033673437, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.679019751, "time_to_first_token": 0.122087108, "token_sha": "8a91591c94a3", "tokens_per_second": 18.641686658969718}, "seed": 1234, "sent": 975571.537819351, "speculative": {"acceptance_rate": 0.4154929577464789, "accepted": 177, "drafted": 426, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12572958203963935, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 426, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.64524548300284, "done": 975585.339692173, "finish_reason": "length", "first": 975571.663119281, "full_response_s": 13.801549294963479, "last": 975585.339528113, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975571.663119281, 3], [975571.812781469, 11], [975571.995790244, 30], [975572.180910431, 19], [975572.366961888, 21], [975572.550850382, 15], [975572.698260589, 19], [975572.846335898, 17], [975573.031723091, 12], [975573.214741038, 5], [975573.391342413, 5], [975573.57285941, 27], [975573.754156845, 12], [975573.93778145, 13], [975574.121199471, 5], [975574.272297502, 16], [975574.458358073, 5], [975574.640269271, 14], [975574.825105028, 9], [975575.009329031, 27], [975575.156740529, 11], [975575.346450938, 8], [975575.49276234, 16], [975575.642454382, 5], [975575.789934615, 9], [975575.963908061, 14], [975576.11338061, 20], [975576.265964879, 8], [975576.418817381, 12], [975576.566041433, 5], [975576.714232578, 14], [975576.902478555, 14], [975577.048582225, 8], [975577.235927782, 13], [975577.412279886, 3], [975577.593232774, 10], [975577.740433454, 11], [975577.924663884, 9], [975578.10954225, 10], [975578.300222199, 20], [975578.476503397, 14], [975578.657432434, 14], [975578.889749668, 13], [975579.073810878, 5], [975579.263543833, 22], [975579.498935513, 3], [975579.737256151, 43], [975579.924805442, 22], [975580.109720025, 11], [975580.299200544, 6], [975580.474746652, 8], [975580.620440521, 9], [975580.770942033, 13], [975580.925268752, 8], [975581.071424148, 20], [975581.222942451, 17], [975581.413904982, 20], [975581.560493502, 13], [975581.736270776, 6], [975581.921206485, 13], [975582.070721584, 9], [975582.259160653, 11], [975582.413136043, 8], [975582.598904996, 15], [975582.783951472, 16], [975582.99665659, 27], [975583.24388542, 4], [975583.397360236, 8], [975583.580672174, 25], [975583.763933472, 18], [975583.913338036, 13], [975584.144590517, 64], [975584.301588918, 2], [975584.48999723, 10], [975584.673916707, 11], [975584.822098459, 15], [975584.975031889, 17], [975585.124452617, 14], [975585.339528113, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-a7c69482b9eb3f951795b10715899349", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033383364, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.677067838, "time_to_first_token": 0.122568391, "token_sha": "8a91591c94a3", "tokens_per_second": 18.644347094010516}, "seed": 1234, "sent": 975571.538142878, "speculative": {"acceptance_rate": 0.4154929577464789, "accepted": 177, "drafted": 426, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12497640296351165, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 426, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.645981965076768, "done": 975585.339318551, "finish_reason": "length", "first": 975571.663436712, "full_response_s": 13.800974079058506, "last": 975585.339305351, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975571.663436712, 3], [975571.813505641, 11], [975571.994308973, 30], [975572.178187435, 19], [975572.368387176, 21], [975572.550790447, 15], [975572.696513886, 19], [975572.845089166, 17], [975573.03162551, 12], [975573.214626129, 5], [975573.389733002, 5], [975573.571866478, 27], [975573.754707214, 12], [975573.936923587, 13], [975574.119301204, 5], [975574.272869054, 16], [975574.46078258, 5], [975574.642861295, 14], [975574.823364789, 9], [975575.009185755, 27], [975575.157897601, 11], [975575.344911653, 8], [975575.494822954, 16], [975575.642854819, 5], [975575.78969451, 9], [975575.963573702, 14], [975576.112295152, 20], [975576.266580462, 8], [975576.419449076, 12], [975576.567364292, 5], [975576.713792638, 14], [975576.899318579, 14], [975577.047694282, 8], [975577.234877779, 13], [975577.413223796, 3], [975577.591771998, 10], [975577.739428538, 11], [975577.926941309, 9], [975578.109040105, 10], [975578.299392926, 20], [975578.475517649, 14], [975578.655982379, 14], [975578.892182112, 13], [975579.07464759, 5], [975579.261680221, 22], [975579.498574291, 3], [975579.736749381, 43], [975579.924616103, 22], [975580.110740636, 11], [975580.299405018, 6], [975580.472234146, 8], [975580.620831294, 9], [975580.77245951, 13], [975580.9247092, 8], [975581.071328951, 20], [975581.223293049, 17], [975581.41396714, 20], [975581.561335702, 13], [975581.734187826, 6], [975581.922229241, 13], [975582.071469387, 9], [975582.259646816, 11], [975582.413965524, 8], [975582.597645607, 15], [975582.781538211, 16], [975582.99747676, 27], [975583.242452308, 4], [975583.397103171, 8], [975583.579663802, 25], [975583.765304234, 18], [975583.91564122, 13], [975584.144699666, 64], [975584.300678944, 2], [975584.488979099, 10], [975584.674078783, 11], [975584.823169277, 15], [975584.975644464, 17], [975585.125939392, 14], [975585.339305351, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-b2e764e14451ba5c26a026518ea8e5fe", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033310006, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.67686242, "time_to_first_token": 0.122733266, "token_sha": "8a91591c94a3", "tokens_per_second": 18.644627120552695}, "seed": 1234, "sent": 975571.538344472, "speculative": {"acceptance_rate": 0.4135514018691589, "accepted": 177, "drafted": 428, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12509224005043507, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 428, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.644062014594454, "done": 975585.341875392, "finish_reason": "length", "first": 975571.664561816, "full_response_s": 13.803666435997002, "last": 975585.341838785, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975571.664561816, 3], [975571.813913581, 11], [975571.994695058, 30], [975572.178620415, 19], [975572.368448886, 21], [975572.551870977, 15], [975572.697427588, 19], [975572.846419272, 17], [975573.030874651, 12], [975573.215120931, 5], [975573.391653172, 5], [975573.573983619, 27], [975573.754767644, 12], [975573.938362538, 13], [975574.120978933, 5], [975574.273052057, 16], [975574.459426795, 5], [975574.640174634, 14], [975574.823919957, 9], [975575.009028095, 27], [975575.157210036, 11], [975575.347129463, 8], [975575.494182476, 16], [975575.642404672, 5], [975575.788729497, 9], [975575.963285422, 14], [975576.113699881, 20], [975576.265757157, 8], [975576.418491406, 12], [975576.566613833, 5], [975576.714426508, 14], [975576.900402101, 14], [975577.050332224, 8], [975577.23555712, 13], [975577.412806095, 3], [975577.593470479, 10], [975577.740795236, 11], [975577.927838691, 9], [975578.108750017, 10], [975578.301042096, 20], [975578.474865955, 14], [975578.657527423, 14], [975578.891198699, 13], [975579.075046091, 5], [975579.26177569, 22], [975579.496642409, 3], [975579.736994846, 43], [975579.925283141, 22], [975580.111380794, 11], [975580.298482052, 6], [975580.473369922, 8], [975580.620347612, 9], [975580.769764337, 13], [975580.923940997, 8], [975581.071238873, 20], [975581.224360155, 17], [975581.412749878, 20], [975581.560699304, 13], [975581.734272768, 6], [975581.922429523, 13], [975582.070506454, 9], [975582.259832891, 11], [975582.412619754, 8], [975582.597692933, 15], [975582.782215856, 16], [975582.995182903, 27], [975583.243417209, 4], [975583.396296058, 8], [975583.580041615, 25], [975583.765772989, 18], [975583.915379179, 13], [975584.145640023, 64], [975584.299626317, 2], [975584.487560898, 10], [975584.673329476, 11], [975584.822672123, 15], [975584.976732994, 17], [975585.12477432, 14], [975585.341838785, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-bcf39e8d400f4abc393f6899dde4b8bb", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033544832, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.679195763, "time_to_first_token": 0.122589654, "token_sha": "8a91591c94a3", "tokens_per_second": 18.641446793950674}, "seed": 1234, "sent": 975571.538208956, "speculative": {"acceptance_rate": 0.4154929577464789, "accepted": 177, "drafted": 426, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12635286001022905, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 426, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.64520471602984, "done": 975585.338956385, "finish_reason": "length", "first": 975571.662477699, "full_response_s": 13.800884033087641, "last": 975585.338916434, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975571.662477699, 3], [975571.8139667, 11], [975571.994823135, 30], [975572.181108841, 19], [975572.367139467, 21], [975572.551269602, 15], [975572.697610271, 19], [975572.846911306, 17], [975573.03140654, 12], [975573.213928213, 5], [975573.389023982, 5], [975573.573435314, 27], [975573.75449714, 12], [975573.938410857, 13], [975574.12078721, 5], [975574.272020438, 16], [975574.460248052, 5], [975574.642595702, 14], [975574.823652605, 9], [975575.009849592, 27], [975575.157651528, 11], [975575.346585558, 8], [975575.493264262, 16], [975575.642352001, 5], [975575.789367143, 9], [975575.964189621, 14], [975576.111652258, 20], [975576.265819875, 8], [975576.418099449, 12], [975576.566869858, 5], [975576.713682161, 14], [975576.901934234, 14], [975577.048859642, 8], [975577.234401617, 13], [975577.414845062, 3], [975577.592571192, 10], [975577.739747521, 11], [975577.926118276, 9], [975578.111439269, 10], [975578.300843877, 20], [975578.475955781, 14], [975578.656778356, 14], [975578.891343687, 13], [975579.076025456, 5], [975579.262428184, 22], [975579.496697671, 3], [975579.73690688, 43], [975579.924906991, 22], [975580.110155436, 11], [975580.300034553, 6], [975580.473114138, 8], [975580.62220524, 9], [975580.770601146, 13], [975580.921691412, 8], [975581.071372454, 20], [975581.222873621, 17], [975581.413454322, 20], [975581.561360741, 13], [975581.73496814, 6], [975581.920258864, 13], [975582.071052102, 9], [975582.260202352, 11], [975582.412036378, 8], [975582.597277601, 15], [975582.781833643, 16], [975582.995054843, 27], [975583.242375894, 4], [975583.396243787, 8], [975583.580569744, 25], [975583.763738166, 18], [975583.914760572, 13], [975584.14516802, 64], [975584.300960232, 2], [975584.488367196, 10], [975584.672428173, 11], [975584.822556206, 15], [975584.977100968, 17], [975585.127228172, 14], [975585.338916434, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-900edc20dcc8aed36c4e98488f57e402", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033194362, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.676888274, "time_to_first_token": 0.122566871, "token_sha": "8a91591c94a3", "tokens_per_second": 18.64459187582598}, "seed": 1234, "sent": 975571.538072352, "speculative": {"acceptance_rate": 0.40877598152424943, "accepted": 177, "drafted": 433, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12440534704364836, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 433, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "candidate", "burst": 1, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.481993835824827, "done": 975585.340744847, "finish_reason": "length", "first": 975571.541889029, "full_response_s": 13.803249182994477, "last": 975585.339101725, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975571.541889029, 3], [975571.629352359, 26], [975571.81247287, 15], [975571.994112627, 19], [975572.177585532, 21], [975572.366846371, 15], [975572.550921516, 19], [975572.69784868, 17], [975572.844894291, 6], [975573.030442983, 11], [975573.214313658, 5], [975573.388734278, 18], [975573.571340701, 21], [975573.753305349, 5], [975573.93752189, 8], [975574.121473079, 5], [975574.27179654, 16], [975574.458819372, 5], [975574.639346145, 14], [975574.824128592, 9], [975575.00829482, 27], [975575.15801499, 11], [975575.346067461, 8], [975575.494515794, 16], [975575.639997203, 5], [975575.789648751, 9], [975575.963690915, 14], [975576.111902219, 20], [975576.265305922, 8], [975576.420043843, 12], [975576.567436082, 5], [975576.715302164, 14], [975576.900152924, 14], [975577.049554038, 8], [975577.235968773, 13], [975577.412473225, 3], [975577.59313004, 10], [975577.739232495, 11], [975577.925260684, 9], [975578.109584969, 10], [975578.298721377, 20], [975578.474485982, 14], [975578.655748337, 14], [975578.8914661, 13], [975579.074947806, 5], [975579.26364903, 22], [975579.498837451, 3], [975579.736185381, 43], [975579.92507873, 22], [975580.110272073, 11], [975580.30054257, 6], [975580.474217099, 8], [975580.61976606, 9], [975580.772087393, 13], [975580.920832156, 8], [975581.072550677, 20], [975581.222829014, 17], [975581.412199365, 20], [975581.562955929, 13], [975581.736539856, 6], [975581.923329498, 13], [975582.071429388, 9], [975582.259570498, 11], [975582.412441695, 8], [975582.597601928, 15], [975582.783314178, 16], [975582.996759755, 27], [975583.24197549, 4], [975583.396678431, 8], [975583.58166645, 25], [975583.765514292, 18], [975583.913876597, 13], [975584.144987705, 64], [975584.299516384, 2], [975584.489031881, 10], [975584.673993761, 11], [975584.821622344, 15], [975584.976194177, 17], [975585.12614057, 14], [975585.339101725, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-4833e9ac1a73abe0e776bdd58aef6a26", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.002368877, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.797031054, "time_to_first_token": 0.002770914, "token_sha": "8a91591c94a3", "tokens_per_second": 18.48223715681723}, "seed": 1234, "sent": 975571.537495664, "speculative": {"acceptance_rate": 0.39373601789709173, "accepted": 176, "drafted": 447, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.004393365001305938, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 447, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.701344515338754, "done": 975599.1452026, "finish_reason": "length", "first": 975585.501934657, "full_response_s": 13.770564614096656, "last": 975599.13731792, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975585.501934657, 3], [975585.654331894, 11], [975585.835799157, 30], [975586.018473685, 19], [975586.20303741, 21], [975586.390930194, 15], [975586.5388254, 19], [975586.685413347, 17], [975586.870332983, 12], [975587.054564257, 5], [975587.226160345, 5], [975587.412997515, 18], [975587.59777439, 21], [975587.781036395, 9], [975587.962180335, 9], [975588.113677033, 16], [975588.299977134, 5], [975588.486039562, 14], [975588.668636726, 9], [975588.853318826, 27], [975588.999609735, 11], [975589.187224077, 8], [975589.339455799, 16], [975589.490158362, 5], [975589.637859361, 9], [975589.812526317, 14], [975589.958515783, 20], [975590.108518274, 8], [975590.261509482, 12], [975590.411770093, 5], [975590.562324681, 14], [975590.744371549, 14], [975590.889754906, 8], [975591.074556935, 13], [975591.252087724, 3], [975591.438849475, 10], [975591.5855703, 11], [975591.767963675, 9], [975591.951635899, 10], [975592.138274953, 20], [975592.315152709, 14], [975592.500788512, 14], [975592.731815429, 13], [975592.916054568, 5], [975593.100413674, 22], [975593.338189643, 3], [975593.578134319, 43], [975593.764295152, 22], [975593.949273124, 11], [975594.132966477, 6], [975594.314389701, 8], [975594.464803155, 9], [975594.613792265, 13], [975594.761870119, 8], [975594.912897399, 20], [975595.062881829, 17], [975595.251045175, 20], [975595.402959104, 13], [975595.578159272, 6], [975595.761728728, 13], [975595.911056923, 9], [975596.061667643, 11], [975596.210770021, 8], [975596.400813192, 15], [975596.585719833, 16], [975596.800130846, 27], [975597.043518139, 4], [975597.192524331, 8], [975597.386127185, 25], [975597.569932965, 18], [975597.719717951, 13], [975597.95053721, 64], [975598.100313608, 2], [975598.293285845, 10], [975598.481265146, 11], [975598.627910542, 15], [975598.779890929, 17], [975598.929549029, 14], [975599.13731792, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-1b4ead24ffef52377697caeec72726ee", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033798357, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.635549195, "time_to_first_token": 0.122949864, "token_sha": "8a91591c94a3", "tokens_per_second": 18.70111693729986}, "seed": 1234, "sent": 975585.374637986, "speculative": {"acceptance_rate": 0.423444976076555, "accepted": 177, "drafted": 418, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12729667103849351, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 418, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 0, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.70248744318064, "done": 975599.146900073, "finish_reason": "length", "first": 975585.503172942, "full_response_s": 13.77054251905065, "last": 975599.137722933, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975585.503172942, 3], [975585.653776566, 11], [975585.835557851, 30], [975586.01930907, 19], [975586.202842551, 21], [975586.392213054, 15], [975586.537959984, 19], [975586.685574142, 17], [975586.870398805, 12], [975587.053957714, 5], [975587.225372367, 5], [975587.41275005, 18], [975587.595197326, 21], [975587.77979347, 9], [975587.962640658, 9], [975588.112131028, 16], [975588.299580553, 5], [975588.485606582, 14], [975588.666661325, 9], [975588.851655368, 27], [975589.000214135, 11], [975589.186803769, 8], [975589.339653041, 16], [975589.489444334, 5], [975589.637802467, 9], [975589.809523312, 14], [975589.958883485, 20], [975590.111040876, 8], [975590.26097988, 12], [975590.412050198, 5], [975590.560354559, 14], [975590.742270455, 14], [975590.889337509, 8], [975591.076447778, 13], [975591.252445554, 3], [975591.43859385, 10], [975591.585137288, 11], [975591.766878873, 9], [975591.951303572, 10], [975592.136898287, 20], [975592.316047117, 14], [975592.498567373, 14], [975592.731671289, 13], [975592.914071759, 5], [975593.10026379, 22], [975593.338010528, 3], [975593.5794351, 43], [975593.762810153, 22], [975593.948689156, 11], [975594.133631787, 6], [975594.314887639, 8], [975594.46367469, 9], [975594.612733238, 13], [975594.761490162, 8], [975594.912992021, 20], [975595.062815303, 17], [975595.250721888, 20], [975595.401797216, 13], [975595.576729439, 6], [975595.761333331, 13], [975595.911156344, 9], [975596.061571262, 11], [975596.211306374, 8], [975596.401618226, 15], [975596.58712341, 16], [975596.798880064, 27], [975597.043634392, 4], [975597.193293798, 8], [975597.389358072, 25], [975597.570099168, 18], [975597.718767018, 13], [975597.951961523, 64], [975598.099971474, 2], [975598.293145304, 10], [975598.479113733, 11], [975598.627268624, 15], [975598.776204166, 17], [975598.92863107, 14], [975599.137722933, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-9064caec214468138fb31dec204d0162", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033835396, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.635675175, "time_to_first_token": 0.122748366, "token_sha": "8a91591c94a3", "tokens_per_second": 18.700944157684514}, "seed": 1234, "sent": 975585.376357554, "speculative": {"acceptance_rate": 0.423444976076555, "accepted": 177, "drafted": 418, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12681538797914982, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 418, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 1, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.699772981677693, "done": 975599.145516991, "finish_reason": "length", "first": 975585.501381264, "full_response_s": 13.77081795106642, "last": 975599.137910448, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975585.501381264, 3], [975585.654824328, 11], [975585.834492409, 30], [975586.019850543, 19], [975586.201825139, 21], [975586.39213256, 15], [975586.539412344, 19], [975586.686314826, 17], [975586.869583211, 12], [975587.055149504, 5], [975587.225061976, 5], [975587.412915982, 27], [975587.596833632, 12], [975587.779854268, 13], [975587.962074034, 5], [975588.110887254, 16], [975588.300465057, 5], [975588.487762571, 14], [975588.666554736, 9], [975588.851726662, 27], [975588.999869968, 11], [975589.186496001, 8], [975589.339514613, 16], [975589.490683548, 5], [975589.63855427, 9], [975589.813847321, 14], [975589.958299741, 20], [975590.111407938, 8], [975590.260413448, 12], [975590.410835879, 5], [975590.562437158, 14], [975590.743251628, 14], [975590.891677589, 8], [975591.075878914, 13], [975591.251340401, 3], [975591.438275011, 10], [975591.584879599, 11], [975591.765983298, 9], [975591.950390957, 10], [975592.138032896, 20], [975592.316700059, 14], [975592.499253002, 14], [975592.730130451, 13], [975592.914998613, 5], [975593.098716329, 22], [975593.337742999, 3], [975593.580225494, 43], [975593.7629973, 22], [975593.948411516, 11], [975594.133407473, 6], [975594.314615855, 8], [975594.464462252, 9], [975594.614050866, 13], [975594.761977124, 8], [975594.913194175, 20], [975595.061028536, 17], [975595.250657474, 20], [975595.404520661, 13], [975595.577573096, 6], [975595.760590664, 13], [975595.911656906, 9], [975596.060183124, 11], [975596.210713622, 8], [975596.403400225, 15], [975596.586303801, 16], [975596.800448021, 27], [975597.044810472, 4], [975597.192966015, 8], [975597.385258249, 25], [975597.568476909, 18], [975597.719225037, 13], [975597.952257179, 64], [975598.100766764, 2], [975598.293368306, 10], [975598.480857717, 11], [975598.628252661, 15], [975598.777629103, 17], [975598.929189055, 14], [975599.137910448, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-3f7d293c387b6eb242c9a8967eb52956", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033378657, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.635939472, "time_to_first_token": 0.124883042, "token_sha": "8a91591c94a3", "tokens_per_second": 18.70058168882432}, "seed": 1234, "sent": 975585.37469904, "speculative": {"acceptance_rate": 0.41451990632318503, "accepted": 177, "drafted": 427, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12668222398497164, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 427, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 2, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.701146122843223, "done": 975599.144837218, "finish_reason": "length", "first": 975585.502404436, "full_response_s": 13.770063412026502, "last": 975599.137932351, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975585.502404436, 3], [975585.653150567, 11], [975585.837334794, 30], [975586.019071301, 19], [975586.203578259, 21], [975586.392644354, 15], [975586.538045662, 19], [975586.686131983, 17], [975586.868805313, 12], [975587.054388678, 5], [975587.226639868, 5], [975587.412662485, 27], [975587.59672082, 12], [975587.781278277, 13], [975587.962303996, 5], [975588.11191681, 16], [975588.299657751, 5], [975588.486678489, 14], [975588.667896219, 9], [975588.85208998, 27], [975588.999506634, 11], [975589.185625817, 8], [975589.342633391, 16], [975589.4879166, 5], [975589.637207939, 9], [975589.811356173, 14], [975589.960071468, 20], [975590.107782022, 8], [975590.258941073, 12], [975590.412587447, 5], [975590.56069087, 14], [975590.745474431, 14], [975590.891088085, 8], [975591.077497797, 13], [975591.250686403, 3], [975591.436838618, 10], [975591.585062554, 11], [975591.7664889, 9], [975591.950831153, 10], [975592.135548821, 20], [975592.315744997, 14], [975592.498380258, 14], [975592.730352429, 13], [975592.913974018, 5], [975593.099667535, 22], [975593.337657881, 3], [975593.580126536, 43], [975593.764578776, 22], [975593.950482851, 11], [975594.13309089, 6], [975594.314114716, 8], [975594.464768372, 9], [975594.611856926, 13], [975594.762570676, 8], [975594.913487351, 20], [975595.061989134, 17], [975595.249887495, 20], [975595.402644649, 13], [975595.578457647, 6], [975595.760060902, 13], [975595.910868688, 9], [975596.061150985, 11], [975596.21109454, 8], [975596.404067519, 15], [975596.588327089, 16], [975596.797952074, 27], [975597.04151213, 4], [975597.191652851, 8], [975597.388338388, 25], [975597.570481638, 18], [975597.720029831, 13], [975597.950924479, 64], [975598.101621941, 2], [975598.292956126, 10], [975598.478679489, 11], [975598.628356786, 15], [975598.780353524, 17], [975598.929434376, 14], [975599.137932351, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-33b705341fffce44e31bdeb6eb3916f8", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.03341544, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.635818403, "time_to_first_token": 0.125255176, "token_sha": "8a91591c94a3", "tokens_per_second": 18.700747726582936}, "seed": 1234, "sent": 975585.374773806, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12763063004240394, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 3, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.700345857076154, "done": 975599.146560658, "finish_reason": "length", "first": 975585.502315254, "full_response_s": 13.771373727009632, "last": 975599.13842669, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975585.502315254, 3], [975585.65363121, 11], [975585.83358549, 30], [975586.018279579, 19], [975586.201756149, 21], [975586.390295203, 15], [975586.537099112, 19], [975586.685611965, 17], [975586.869091705, 12], [975587.053392929, 5], [975587.225978238, 5], [975587.414727387, 27], [975587.596370253, 12], [975587.7794374, 13], [975587.962575252, 5], [975588.110689372, 16], [975588.301271882, 5], [975588.485087045, 14], [975588.66765541, 9], [975588.850965099, 27], [975588.999807106, 11], [975589.184940028, 8], [975589.339111984, 16], [975589.490441666, 5], [975589.636951402, 9], [975589.81076619, 14], [975589.957833386, 20], [975590.10899146, 8], [975590.259729515, 12], [975590.411390488, 5], [975590.561866997, 14], [975590.743729311, 14], [975590.890126655, 8], [975591.077094688, 13], [975591.251754805, 3], [975591.436681183, 10], [975591.583795437, 11], [975591.765761704, 9], [975591.949527301, 10], [975592.137750456, 20], [975592.317082368, 14], [975592.501611785, 14], [975592.729717743, 13], [975592.914867689, 5], [975593.100108371, 22], [975593.336852656, 3], [975593.579771522, 43], [975593.76357306, 22], [975593.9474058, 11], [975594.134116606, 6], [975594.313490494, 8], [975594.462580704, 9], [975594.611777328, 13], [975594.762622179, 8], [975594.913557509, 20], [975595.060914923, 17], [975595.250068018, 20], [975595.403403332, 13], [975595.577238289, 6], [975595.760515738, 13], [975595.910692645, 9], [975596.059897436, 11], [975596.211375668, 8], [975596.401846444, 15], [975596.586255514, 16], [975596.800303929, 27], [975597.043159093, 4], [975597.19061152, 8], [975597.386848829, 25], [975597.571476058, 18], [975597.720781714, 13], [975597.949675906, 64], [975598.099449072, 2], [975598.294726733, 10], [975598.478254845, 11], [975598.628550525, 15], [975598.7761178, 17], [975598.928517122, 14], [975599.13842669, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-e1d28095aa6d0bcc342949493fd67ed5", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033326627, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.635982942, "time_to_first_token": 0.125172234, "token_sha": "8a91591c94a3", "tokens_per_second": 18.700522073445697}, "seed": 1234, "sent": 975585.375186931, "speculative": {"acceptance_rate": 0.4135514018691589, "accepted": 177, "drafted": 428, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1271283229580149, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 428, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 4, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.70097900266035, "done": 975599.146313401, "finish_reason": "length", "first": 975585.501717847, "full_response_s": 13.770970763056539, "last": 975599.137367615, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975585.501717847, 3], [975585.653030298, 11], [975585.836782185, 30], [975586.018375128, 19], [975586.202669116, 21], [975586.391687645, 15], [975586.537400272, 19], [975586.686457238, 17], [975586.869822357, 12], [975587.056370015, 5], [975587.225513195, 5], [975587.412068277, 18], [975587.596514681, 21], [975587.779130224, 13], [975587.962016548, 5], [975588.113121048, 16], [975588.300791032, 5], [975588.484690912, 14], [975588.668172931, 9], [975588.852711291, 27], [975589.000287813, 11], [975589.187527733, 8], [975589.341771686, 16], [975589.490040749, 5], [975589.638032908, 9], [975589.80980884, 14], [975589.959361631, 20], [975590.110502315, 8], [975590.261074118, 12], [975590.411464854, 5], [975590.561206152, 14], [975590.744859008, 14], [975590.890955753, 8], [975591.076978964, 13], [975591.251701367, 3], [975591.437959211, 10], [975591.584959997, 11], [975591.767446266, 9], [975591.950236145, 10], [975592.136232786, 20], [975592.314750449, 14], [975592.49896941, 14], [975592.730697668, 13], [975592.915554262, 5], [975593.098828838, 22], [975593.339219614, 3], [975593.577927429, 43], [975593.762096573, 22], [975593.94775659, 11], [975594.132719412, 6], [975594.315135632, 8], [975594.462465668, 9], [975594.61336986, 13], [975594.761390084, 8], [975594.913149088, 20], [975595.061536394, 17], [975595.250480055, 20], [975595.402273539, 13], [975595.5790248, 6], [975595.760324607, 13], [975595.910333711, 9], [975596.059727728, 11], [975596.20977304, 8], [975596.40134537, 15], [975596.587572742, 16], [975596.799010844, 27], [975597.044540143, 4], [975597.190790107, 8], [975597.387308497, 25], [975597.572535133, 18], [975597.72047745, 13], [975597.949749424, 64], [975598.100966598, 2], [975598.293747576, 10], [975598.479244209, 11], [975598.629007552, 15], [975598.77895297, 17], [975598.929473223, 14], [975599.137367615, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-c2231a998368ba249c8620ba98177f11", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033761686, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.635678951, "time_to_first_token": 0.124836307, "token_sha": "8a91591c94a3", "tokens_per_second": 18.70093897900838}, "seed": 1234, "sent": 975585.375342638, "speculative": {"acceptance_rate": 0.42042755344418054, "accepted": 177, "drafted": 421, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1263752089580521, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 421, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 5, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.702349993237622, "done": 975599.14593802, "finish_reason": "length", "first": 975585.503114352, "full_response_s": 13.771016937913373, "last": 975599.137764548, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975585.503114352, 3], [975585.654887943, 11], [975585.836676444, 30], [975586.019355709, 19], [975586.203338473, 21], [975586.391868584, 15], [975586.537741398, 19], [975586.686639089, 17], [975586.869742487, 12], [975587.053110521, 5], [975587.224962587, 5], [975587.411812476, 27], [975587.59691979, 12], [975587.779637682, 13], [975587.962375178, 5], [975588.114086781, 16], [975588.30005814, 5], [975588.485170882, 14], [975588.667372921, 9], [975588.853018034, 27], [975589.000605228, 11], [975589.186009951, 8], [975589.34003287, 16], [975589.488720338, 5], [975589.636659874, 9], [975589.81350221, 14], [975589.960869222, 20], [975590.108122989, 8], [975590.261308399, 12], [975590.410380804, 5], [975590.560298881, 14], [975590.741795924, 14], [975590.891607383, 8], [975591.075620089, 13], [975591.252672476, 3], [975591.436463077, 10], [975591.585723, 11], [975591.767692627, 9], [975591.950685365, 10], [975592.135665617, 20], [975592.31461866, 14], [975592.501329873, 14], [975592.72953722, 13], [975592.915311581, 5], [975593.102529152, 22], [975593.338282184, 3], [975593.580040251, 43], [975593.763749023, 22], [975593.950248665, 11], [975594.134878777, 6], [975594.313878707, 8], [975594.464407806, 9], [975594.614804205, 13], [975594.762277324, 8], [975594.913619379, 20], [975595.063022529, 17], [975595.25125349, 20], [975595.403077277, 13], [975595.579121837, 6], [975595.760242769, 13], [975595.912356167, 9], [975596.060633864, 11], [975596.211503521, 8], [975596.401040546, 15], [975596.587912892, 16], [975596.799143177, 27], [975597.044868006, 4], [975597.193390691, 8], [975597.388526255, 25], [975597.573821658, 18], [975597.719018115, 13], [975597.949961274, 64], [975598.100124878, 2], [975598.294160877, 10], [975598.479209202, 11], [975598.629852713, 15], [975598.777172715, 17], [975598.929638723, 14], [975599.137764548, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-943a5fe3f6675c24c309a4944aa64b76", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033452895, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.635908672, "time_to_first_token": 0.124900802, "token_sha": "8a91591c94a3", "tokens_per_second": 18.70062392861412}, "seed": 1234, "sent": 975585.374921082, "speculative": {"acceptance_rate": 0.41745283018867924, "accepted": 177, "drafted": 424, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12819326994940639, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 424, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 6, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.70160492733541, "done": 975599.144804227, "finish_reason": "length", "first": 975585.502766634, "full_response_s": 13.769581761094742, "last": 975599.13796003, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975585.502766634, 3], [975585.655461479, 11], [975585.836210137, 30], [975586.019722339, 19], [975586.202743898, 21], [975586.393607175, 15], [975586.539326058, 19], [975586.686928617, 17], [975586.869196438, 12], [975587.055463784, 5], [975587.226232439, 5], [975587.414110908, 27], [975587.597445919, 12], [975587.780755971, 13], [975587.962458343, 5], [975588.111348121, 16], [975588.299485772, 5], [975588.485794305, 14], [975588.667444743, 9], [975588.852407523, 27], [975589.000499007, 11], [975589.186949669, 8], [975589.340371933, 16], [975589.489039273, 5], [975589.638250454, 9], [975589.813250409, 14], [975589.95976674, 20], [975590.108735292, 8], [975590.258857059, 12], [975590.412525528, 5], [975590.559701025, 14], [975590.741550011, 14], [975590.890708959, 8], [975591.077590771, 13], [975591.250739425, 3], [975591.437402875, 10], [975591.584447483, 11], [975591.767205392, 9], [975591.949682881, 10], [975592.135276316, 20], [975592.313859849, 14], [975592.497475771, 14], [975592.73147595, 13], [975592.913791255, 5], [975593.101645912, 22], [975593.337332114, 3], [975593.579880159, 43], [975593.761915458, 22], [975593.949753095, 11], [975594.13481993, 6], [975594.312842463, 8], [975594.462977317, 9], [975594.612633945, 13], [975594.761035854, 8], [975594.913737808, 20], [975595.062589613, 17], [975595.250967258, 20], [975595.401623509, 13], [975595.578205958, 6], [975595.761790279, 13], [975595.911413185, 9], [975596.060567609, 11], [975596.209840238, 8], [975596.401690544, 15], [975596.588009674, 16], [975596.797689633, 27], [975597.044124138, 4], [975597.193153722, 8], [975597.388989155, 25], [975597.571593895, 18], [975597.721042523, 13], [975597.9517606, 64], [975598.101440458, 2], [975598.294470244, 10], [975598.478149776, 11], [975598.626734431, 15], [975598.777321143, 17], [975598.928385429, 14], [975599.13796003, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-8b8abda126fe7910afad6acfe47e3584", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033488878, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.635743077, "time_to_first_token": 0.125062862, "token_sha": "8a91591c94a3", "tokens_per_second": 18.700851032469185}, "seed": 1234, "sent": 975585.375222466, "speculative": {"acceptance_rate": 0.4194312796208531, "accepted": 177, "drafted": 422, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1275441680336371, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 422, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 7, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.69950195910024, "done": 975599.145043932, "finish_reason": "length", "first": 975585.501435999, "full_response_s": 13.770049524027854, "last": 975599.138162825, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975585.501435999, 3], [975585.654788553, 11], [975585.834635717, 30], [975586.018947848, 19], [975586.202413203, 21], [975586.392997368, 15], [975586.538095388, 19], [975586.686749518, 17], [975586.870035135, 12], [975587.053480543, 5], [975587.226376563, 5], [975587.413343794, 27], [975587.597667065, 12], [975587.779993432, 13], [975587.961821609, 5], [975588.112346798, 16], [975588.300881781, 5], [975588.484774461, 14], [975588.666709116, 9], [975588.852908549, 27], [975588.999747908, 11], [975589.186075501, 8], [975589.339737903, 16], [975589.48995944, 5], [975589.636885484, 9], [975589.811049398, 14], [975589.958419497, 20], [975590.109229262, 8], [975590.260218621, 12], [975590.41058555, 5], [975590.560589497, 14], [975590.744066342, 14], [975590.891512345, 8], [975591.075257587, 13], [975591.25084755, 3], [975591.436108063, 10], [975591.583913274, 11], [975591.76670771, 9], [975591.949994968, 10], [975592.137286325, 20], [975592.314020709, 14], [975592.500656035, 14], [975592.72961037, 13], [975592.915706082, 5], [975593.099507651, 22], [975593.336764226, 3], [975593.579990156, 43], [975593.76580527, 22], [975593.950771243, 11], [975594.133930835, 6], [975594.313615354, 8], [975594.464262146, 9], [975594.61445399, 13], [975594.761604079, 8], [975594.912322647, 20], [975595.061930351, 17], [975595.249998308, 20], [975595.401988667, 13], [975595.577529065, 6], [975595.76066959, 13], [975595.910813281, 9], [975596.061862358, 11], [975596.209915292, 8], [975596.402627334, 15], [975596.584995725, 16], [975596.797778222, 27], [975597.0427672, 4], [975597.192017753, 8], [975597.387693974, 25], [975597.572797974, 18], [975597.721187047, 13], [975597.951156793, 64], [975598.099862325, 2], [975598.292758259, 10], [975598.479552953, 11], [975598.629297464, 15], [975598.780460881, 17], [975598.928313559, 14], [975599.138162825, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-ab9ad461b10bb58eb0e9511d2d1a6f43", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033593771, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.635661735, "time_to_first_token": 0.124788789, "token_sha": "8a91591c94a3", "tokens_per_second": 18.700962590283854}, "seed": 1234, "sent": 975585.374994408, "speculative": {"acceptance_rate": 0.4194312796208531, "accepted": 177, "drafted": 422, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1264415909536183, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 422, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 8, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.705065554093213, "done": 975599.145126922, "finish_reason": "length", "first": 975585.504218881, "full_response_s": 13.769683807040565, "last": 975599.136889628, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975585.504218881, 3], [975585.654955845, 11], [975585.833996695, 30], [975586.018103632, 19], [975586.201891634, 21], [975586.391776282, 15], [975586.538300887, 19], [975586.685505584, 17], [975586.870708892, 12], [975587.054846793, 5], [975587.226110635, 5], [975587.413706392, 27], [975587.597065098, 12], [975587.780494954, 13], [975587.962607347, 5], [975588.113973953, 16], [975588.300143002, 5], [975588.484425511, 14], [975588.667333147, 9], [975588.85069421, 27], [975589.000355155, 11], [975589.188179587, 8], [975589.341476111, 16], [975589.48960089, 5], [975589.63754257, 9], [975589.812704824, 14], [975589.95968975, 20], [975590.111341635, 8], [975590.259877655, 12], [975590.41181414, 5], [975590.559364203, 14], [975590.74520375, 14], [975590.889845415, 8], [975591.074950892, 13], [975591.251993663, 3], [975591.437770801, 10], [975591.584539016, 11], [975591.767531399, 9], [975591.949865228, 10], [975592.137553005, 20], [975592.315536235, 14], [975592.501252611, 14], [975592.730626998, 13], [975592.914786315, 5], [975593.101271427, 22], [975593.339131217, 3], [975593.580396401, 43], [975593.762277192, 22], [975593.947931001, 11], [975594.134559505, 6], [975594.31302729, 8], [975594.46469751, 9], [975594.614199437, 13], [975594.76250463, 8], [975594.913432041, 20], [975595.061659527, 17], [975595.251336367, 20], [975595.404761407, 13], [975595.57697916, 6], [975595.761840613, 13], [975595.911747048, 9], [975596.060973582, 11], [975596.21158523, 8], [975596.404539858, 15], [975596.588425534, 16], [975596.799512383, 27], [975597.042440457, 4], [975597.193597918, 8], [975597.386387226, 25], [975597.573656494, 18], [975597.719327098, 13], [975597.949835021, 64], [975598.10003128, 2], [975598.292841985, 10], [975598.480497215, 11], [975598.629915463, 15], [975598.78072113, 17], [975598.928203802, 14], [975599.136889628, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-444ee31eed29bc53ed0e4d330894739c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033561948, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.635711254, "time_to_first_token": 0.124704199, "token_sha": "8a91591c94a3", "tokens_per_second": 18.700894676483884}, "seed": 1234, "sent": 975585.375443115, "speculative": {"acceptance_rate": 0.4194312796208531, "accepted": 177, "drafted": 422, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1287757660029456, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 422, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 9, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.702777186065635, "done": 975599.146232155, "finish_reason": "length", "first": 975585.503673632, "full_response_s": 13.77120029204525, "last": 975599.138012397, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975585.503673632, 3], [975585.654237177, 11], [975585.83746655, 30], [975586.017906901, 19], [975586.202274359, 21], [975586.391225418, 15], [975586.537837587, 19], [975586.686193261, 17], [975586.870619855, 12], [975587.054272745, 5], [975587.226848406, 5], [975587.414413572, 27], [975587.596988988, 12], [975587.780850896, 13], [975587.962789774, 5], [975588.111103408, 16], [975588.300231127, 5], [975588.484849963, 14], [975588.666890599, 9], [975588.851887729, 27], [975589.000655243, 11], [975589.186663549, 8], [975589.342382693, 16], [975589.49036762, 5], [975589.639080015, 9], [975589.812247685, 14], [975589.960317205, 20], [975590.109619107, 8], [975590.260170719, 12], [975590.411709119, 5], [975590.561595293, 14], [975590.742070477, 14], [975590.890496069, 8], [975591.076237768, 13], [975591.25216801, 3], [975591.436584561, 10], [975591.58543624, 11], [975591.766787676, 9], [975591.951579724, 10], [975592.134377653, 20], [975592.314880717, 14], [975592.498893684, 14], [975592.730257344, 13], [975592.91433612, 5], [975593.099788411, 22], [975593.339027316, 3], [975593.579353342, 43], [975593.762906438, 22], [975593.950197307, 11], [975594.134425237, 6], [975594.315358666, 8], [975594.465233703, 9], [975594.611951147, 13], [975594.762679361, 8], [975594.912566128, 20], [975595.062073819, 17], [975595.250114193, 20], [975595.403619838, 13], [975595.577434299, 6], [975595.760845121, 13], [975595.911698233, 9], [975596.060508027, 11], [975596.210365712, 8], [975596.400679788, 15], [975596.586674431, 16], [975596.799595484, 27], [975597.043978318, 4], [975597.192273474, 8], [975597.388081468, 25], [975597.573278521, 18], [975597.719103312, 13], [975597.952188077, 64], [975598.101528887, 2], [975598.293482255, 10], [975598.478381113, 11], [975598.626879147, 15], [975598.779365183, 17], [975598.929108737, 14], [975599.138012397, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-c64f96148b605edf5782a94f7509a0f6", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033526141, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.635751669, "time_to_first_token": 0.125007359, "token_sha": "8a91591c94a3", "tokens_per_second": 18.70083924890815}, "seed": 1234, "sent": 975585.375031863, "speculative": {"acceptance_rate": 0.4194312796208531, "accepted": 177, "drafted": 422, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12864176905713975, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 422, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 10, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.70228718416907, "done": 975599.144590808, "finish_reason": "length", "first": 975585.502728427, "full_response_s": 13.769333894946612, "last": 975599.137424413, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975585.502728427, 3], [975585.654079085, 11], [975585.837388937, 30], [975586.019477178, 19], [975586.202352597, 21], [975586.390526733, 15], [975586.538334662, 19], [975586.686708879, 17], [975586.870285016, 12], [975587.055790095, 5], [975587.2240505, 5], [975587.412830608, 27], [975587.595727647, 12], [975587.779923722, 13], [975587.962522165, 5], [975588.113431952, 16], [975588.30057763, 5], [975588.488242573, 14], [975588.667553172, 9], [975588.852826775, 27], [975588.999678566, 11], [975589.186723691, 8], [975589.339293771, 16], [975589.489195461, 5], [975589.637058855, 9], [975589.811939693, 14], [975589.959563562, 20], [975590.109450392, 8], [975590.259255864, 12], [975590.412324286, 5], [975590.56002604, 14], [975590.742955556, 14], [975590.891248865, 8], [975591.074186097, 13], [975591.251064152, 3], [975591.435975266, 10], [975591.585293412, 11], [975591.766596657, 9], [975591.950776434, 10], [975592.134879879, 20], [975592.316901813, 14], [975592.499445973, 14], [975592.72922262, 13], [975592.914425957, 5], [975593.100915516, 22], [975593.337049594, 3], [975593.577842279, 43], [975593.762415556, 22], [975593.948972813, 11], [975594.13397021, 6], [975594.312926957, 8], [975594.463106946, 9], [975594.613311814, 13], [975594.761157323, 8], [975594.913089154, 20], [975595.062959571, 17], [975595.250155584, 20], [975595.4032422, 13], [975595.577928542, 6], [975595.760396845, 13], [975595.910452907, 9], [975596.06040859, 11], [975596.210012474, 8], [975596.402092149, 15], [975596.586974774, 16], [975596.798766643, 27], [975597.044637116, 4], [975597.19096143, 8], [975597.385800554, 25], [975597.571112948, 18], [975597.720959757, 13], [975597.950072391, 64], [975598.100551154, 2], [975598.293329667, 10], [975598.477995524, 11], [975598.628676377, 15], [975598.778541718, 17], [975598.928847192, 14], [975599.137424413, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-912cdae873e454de593f89abd4079b6c", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033668137, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.635571418, "time_to_first_token": 0.124965183, "token_sha": "8a91591c94a3", "tokens_per_second": 18.701086458568245}, "seed": 1234, "sent": 975585.375256913, "speculative": {"acceptance_rate": 0.4194312796208531, "accepted": 177, "drafted": 422, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12747151392977685, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 422, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 11, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.53394205188682, "done": 975599.144527898, "finish_reason": "length", "first": 975585.379143909, "full_response_s": 13.769461348070763, "last": 975599.137684822, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975585.379143909, 3], [975585.468362246, 26], [975585.655800477, 15], [975585.833487877, 19], [975586.019675844, 21], [975586.201659928, 15], [975586.390807765, 19], [975586.538200969, 17], [975586.686266299, 6], [975586.86892435, 11], [975587.052839745, 5], [975587.225845762, 18], [975587.411617074, 21], [975587.595101328, 5], [975587.778887223, 8], [975587.961924886, 5], [975588.110492481, 16], [975588.299318257, 5], [975588.483842135, 14], [975588.666785578, 9], [975588.850562182, 27], [975589.000569757, 11], [975589.185372656, 8], [975589.339582291, 16], [975589.48813949, 5], [975589.636483543, 9], [975589.812856164, 14], [975589.959063944, 20], [975590.109524726, 8], [975590.259163979, 12], [975590.411316442, 5], [975590.558982757, 14], [975590.742882742, 14], [975590.891168771, 8], [975591.076667644, 13], [975591.251615193, 3], [975591.438173077, 10], [975591.583653985, 11], [975591.765638027, 9], [975591.94935065, 10], [975592.136807682, 20], [975592.314439273, 14], [975592.497297616, 14], [975592.7290712, 13], [975592.915189104, 5], [975593.098560061, 22], [975593.33597044, 3], [975593.579080501, 43], [975593.762548672, 22], [975593.947281819, 11], [975594.132550025, 6], [975594.313690968, 8], [975594.46434024, 9], [975594.613869783, 13], [975594.762433624, 8], [975594.912450884, 20], [975595.061478892, 17], [975595.249956837, 20], [975595.402371776, 13], [975595.576598162, 6], [975595.761231206, 13], [975595.912281369, 9], [975596.059537942, 11], [975596.210608185, 8], [975596.400300998, 15], [975596.587801856, 16], [975596.80069323, 27], [975597.041379238, 4], [975597.192777732, 8], [975597.384925762, 25], [975597.568365104, 18], [975597.718590238, 13], [975597.952450341, 64], [975598.100243178, 2], [975598.29266879, 10], [975598.480989954, 11], [975598.627472859, 15], [975598.77705139, 17], [975598.928710556, 14], [975599.137684822, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-af74a014d83135c8dcfa427e88ae24cc", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.002319952, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.757403344, "time_to_first_token": 0.002702837, "token_sha": "8a91591c94a3", "tokens_per_second": 18.535474582215606}, "seed": 1234, "sent": 975585.37506655, "speculative": {"acceptance_rate": 0.3972911963882618, "accepted": 176, "drafted": 443, "rounds": 79, "tokens_per_round": 3.240506329113924}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.004077358986251056, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 176, "drafted": 443, "rounds": 79}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 12, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.703068255904267, "done": 975599.146611777, "finish_reason": "length", "first": 975585.503042594, "full_response_s": 13.770741441985592, "last": 975599.137169172, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975585.503042594, 3], [975585.654190554, 11], [975585.836854039, 30], [975586.018685712, 19], [975586.202968292, 21], [975586.392176271, 15], [975586.53861867, 19], [975586.686862394, 17], [975586.869017227, 12], [975587.054083886, 5], [975587.226304789, 5], [975587.411952632, 27], [975587.597128408, 12], [975587.779731168, 13], [975587.962749743, 5], [975588.112813105, 16], [975588.29976026, 5], [975588.485421931, 14], [975588.668238689, 9], [975588.851324881, 27], [975589.000534206, 11], [975589.185942609, 8], [975589.340657701, 16], [975589.489256787, 5], [975589.637712901, 9], [975589.810656545, 14], [975589.95877376, 20], [975590.11169169, 8], [975590.259813993, 12], [975590.411114415, 5], [975590.559097922, 14], [975590.742691948, 14], [975590.890870459, 8], [975591.077192062, 13], [975591.252361397, 3], [975591.437879774, 10], [975591.58426216, 11], [975591.766132606, 9], [975591.950726772, 10], [975592.135958457, 20], [975592.316524688, 14], [975592.498214103, 14], [975592.732323031, 13], [975592.916231747, 5], [975593.102308118, 22], [975593.336223841, 3], [975593.578615442, 43], [975593.765353939, 22], [975593.948322223, 11], [975594.134070815, 6], [975594.314023039, 8], [975594.464931968, 9], [975594.612184165, 13], [975594.762783806, 8], [975594.912656334, 20], [975595.062153817, 17], [975595.250907307, 20], [975595.403176442, 13], [975595.578050459, 6], [975595.761600108, 13], [975595.910547881, 9], [975596.061807271, 11], [975596.21081602, 8], [975596.403018875, 15], [975596.58531466, 16], [975596.799249446, 27], [975597.04193951, 4], [975597.192894017, 8], [975597.3854637, 25], [975597.569761081, 18], [975597.718918549, 13], [975597.950449852, 64], [975598.099638507, 2], [975598.293219478, 10], [975598.478631954, 11], [975598.627354894, 15], [975598.780945764, 17], [975598.928053022, 14], [975599.137169172, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-2e1261fc484f1a9904e83316262e0964", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033714039, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.635665592, "time_to_first_token": 0.124486013, "token_sha": "8a91591c94a3", "tokens_per_second": 18.700957300508136}, "seed": 1234, "sent": 975585.375870335, "speculative": {"acceptance_rate": 0.4194312796208531, "accepted": 177, "drafted": 422, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12717225891537964, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 422, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 13, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.701871402301148, "done": 975599.145854918, "finish_reason": "length", "first": 975585.502254968, "full_response_s": 13.770729266107082, "last": 975599.137254082, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975585.502254968, 3], [975585.654449875, 11], [975585.836948357, 30], [975586.019266479, 19], [975586.201957312, 21], [975586.392556933, 15], [975586.539095105, 19], [975586.686788604, 17], [975586.869306483, 12], [975587.054218234, 5], [975587.224876541, 5], [975587.413149543, 27], [975587.597187799, 12], [975587.779541653, 13], [975587.962848668, 5], [975588.112278704, 16], [975588.301147198, 5], [975588.486286307, 14], [975588.668404525, 9], [975588.853260603, 27], [975589.000412945, 11], [975589.186757866, 8], [975589.342078958, 16], [975589.490880998, 5], [975589.637493099, 9], [975589.809309638, 14], [975589.96129025, 20], [975590.109926923, 8], [975590.260573988, 12], [975590.411023906, 5], [975590.561131514, 14], [975590.745682937, 14], [975590.891431691, 8], [975591.076079292, 13], [975591.252934629, 3], [975591.438377072, 10], [975591.585378625, 11], [975591.76714021, 9], [975591.950514138, 10], [975592.136695797, 20], [975592.315276434, 14], [975592.499757036, 14], [975592.729432262, 13], [975592.915788384, 5], [975593.103073665, 22], [975593.338084958, 3], [975593.579697508, 43], [975593.763081217, 22], [975593.949469295, 11], [975594.133781623, 6], [975594.31341664, 8], [975594.464084599, 9], [975594.61280058, 13], [975594.762331083, 8], [975594.913691137, 20], [975595.062527887, 17], [975595.25153673, 20], [975595.404208126, 13], [975595.578245317, 6], [975595.761645035, 13], [975595.911096938, 9], [975596.06119388, 11], [975596.211211417, 8], [975596.402240161, 15], [975596.585986049, 16], [975596.800026705, 27], [975597.044279558, 4], [975597.19270455, 8], [975597.38442336, 25], [975597.56944125, 18], [975597.719836012, 13], [975597.951589453, 64], [975598.1001763, 2], [975598.293985073, 10], [975598.480176264, 11], [975598.628135096, 15], [975598.779799651, 17], [975598.928926438, 14], [975599.137254082, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-821229bbddf8416c8c55071ea8dbc320", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 3, "prefill_raised": [], "prefill_seconds": 0.033631674, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.635721637, "time_to_first_token": 0.12467988, "token_sha": "8a91591c94a3", "tokens_per_second": 18.700880436578245}, "seed": 1234, "sent": 975585.375125652, "speculative": {"acceptance_rate": 0.4194312796208531, "accepted": 177, "drafted": 422, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.1271293160971254, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 422, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 14, "streams": 16} +{"arm": "candidate", "burst": 2, "phase": "repeat", "prompt": "chat", "request": {"cache_state": "reused", "cached_tokens": 31, "case_id": null, "complete": true, "decode_tps": 18.70093072818591, "done": 975599.145331172, "finish_reason": "length", "first": 975585.502639373, "full_response_s": 13.770791023038328, "last": 975599.13832434, "output_sha256": "d5e2af618b7bab2c585fd951191098691c8095c39e2449b19d713334b28c5503", "pieces": [[975585.502639373, 3], [975585.653526941, 11], [975585.837559284, 30], [975586.019166578, 19], [975586.202128427, 21], [975586.391102701, 15], [975586.53874769, 19], [975586.685268311, 17], [975586.869485742, 12], [975587.053593804, 5], [975587.224455513, 5], [975587.412506473, 27], [975587.597967793, 12], [975587.779038963, 13], [975587.962695153, 5], [975588.111770334, 16], [975588.299029705, 5], [975588.484092592, 14], [975588.667295644, 9], [975588.850888717, 27], [975588.999939758, 11], [975589.187128896, 8], [975589.341030523, 16], [975589.488477769, 5], [975589.638807527, 9], [975589.812338466, 14], [975589.960688859, 20], [975590.109812542, 8], [975590.26083734, 12], [975590.410695355, 5], [975590.560412126, 14], [975590.74196304, 14], [975590.889662252, 8], [975591.075991663, 13], [975591.250590278, 3], [975591.436780108, 10], [975591.584789202, 11], [975591.767084484, 9], [975591.951100553, 10], [975592.136123653, 20], [975592.316291462, 14], [975592.498030908, 14], [975592.730533048, 13], [975592.913896788, 5], [975593.102773161, 22], [975593.338573248, 3], [975593.578345738, 43], [975593.764122661, 22], [975593.948113316, 11], [975594.134646735, 6], [975594.31274261, 8], [975594.46195485, 9], [975594.613256487, 13], [975594.762039907, 8], [975594.912799978, 20], [975595.061599816, 17], [975595.250851005, 20], [975595.403747514, 13], [975595.577092693, 6], [975595.760150612, 13], [975595.910756499, 9], [975596.061378323, 11], [975596.211842391, 8], [975596.402946797, 15], [975596.585501263, 16], [975596.798305584, 27], [975597.04232158, 4], [975597.192604697, 8], [975597.386617972, 25], [975597.57024982, 18], [975597.71961989, 13], [975597.950883888, 64], [975598.101093491, 2], [975598.292553977, 10], [975598.478466455, 11], [975598.626825132, 15], [975598.776497854, 17], [975598.928788234, 14], [975599.13832434, 21]], "prompt": "chat", "prompt_tokens": 31, "request_body": {"chat_template_kwargs": {"enable_thinking": false}, "ignore_eos": true, "max_tokens": 256, "messages": [{"content": "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", "role": "user"}], "model": "qwen27-pr608", "seed": 1234, "stream": true, "stream_options": {"include_usage": true}, "temperature": 0.0}, "request_body_sha256": "8c2f02371f337ce1377e7ec8eeee5311cf9cb78be8547719cddf6ead3a58052c", "request_path": "/v1/chat/completions", "response_id": "chatcmpl-d03335cc10510804280fe184b1bf2fe4", "runtime": {"drafts": true, "enable_thinking": false, "engine": "lanes", "min_rows": 4, "prefill_raised": [], "prefill_seconds": 0.033281908, "prefill_widths": [], "reasoning_effort": "none", "sampling": "greedy", "seconds": 13.635942447, "time_to_first_token": 0.125231288, "token_sha": "8a91591c94a3", "tokens_per_second": 18.700577608854733}, "seed": 1234, "sent": 975585.374540149, "speculative": {"acceptance_rate": 0.4125874125874126, "accepted": 177, "drafted": 429, "rounds": 78, "tokens_per_round": 3.282051282051282}, "token_sha": "8a91591c94a3", "tokens": 256, "ttft_s": 0.12809922394808382, "usage": {"completion_tokens": 256, "completion_tokens_details": {"reasoning_tokens": 0}, "prompt_tokens": 31, "prompt_tokens_details": {"cached_tokens": 31}, "total_tokens": 287}, "work": {"accepted": 177, "drafted": 429, "rounds": 78}, "work_source": "speculative"}, "schema": "pr608_three_way_public_request_v1", "stream": 15, "streams": 16} diff --git a/validation/pr608-three-way/run_http.py b/validation/pr608-three-way/run_http.py new file mode 100644 index 000000000..8906f6eb6 --- /dev/null +++ b/validation/pr608-three-way/run_http.py @@ -0,0 +1,341 @@ +"""Preserve raw SSE evidence for the fresh three-way PR608 greedy code/chat comparison.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import math +import os +from pathlib import Path +import re +import signal +import statistics +import sys +import time +from typing import Any + +import bench_concurrent as bench + + +SCHEMA = "pr608_three_way_http_v1" +PARAMETERS = { + "prompts": ["code", "chat"], + "levels": [1, 16], + "repetitions": 3, + "uncached_first_use_tokens": 256, + "measured_tokens": 256, + "temperature": 0.0, + "seed": 1234, +} +EXPECTED_PROMPTS = { + "code": ("completion", "Write a short Python function that computes the Fibonacci sequence and explain it.", 14), + "chat": ("chat", "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", 31), +} + + +def sha(path: Path) -> str: + """Hash the exact source bytes.""" + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def source_hashes() -> dict[str, str]: + """Bind the runner and its copied SSE/evidence helpers.""" + root = Path(__file__).resolve().parent + return {name: sha(root / name) for name in ("run_http.py", "bench_concurrent.py", "bench_evidence.py")} + + +def prompts() -> dict[str, dict[str, Any]]: + """Require the upstream prompt text, kind and order exactly.""" + items = bench.PROMPTS + if [item.get("name") for item in items] != PARAMETERS["prompts"]: + raise ValueError("original prompt order changed") + for item in items: + kind, text, _ = EXPECTED_PROMPTS[item["name"]] + if item.get("kind") != kind or item.get("prompt") != text: + raise ValueError("original prompt text or route changed") + return {item["name"]: item for item in items} + + +def write_report(path: Path, report: dict[str, Any]) -> None: + """Atomically preserve partial evidence after each burst.""" + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text(json.dumps(report, indent=2, sort_keys=True, allow_nan=False) + "\n") + temporary.replace(path) + + +def expected_body(model: str, item: dict[str, Any], tokens: int) -> tuple[str, dict[str, Any]]: + """Rebuild the unchanged upstream greedy request body and route.""" + body: dict[str, Any] = { + "model": model, + "max_tokens": tokens, + "temperature": 0.0, + "stream": True, + "stream_options": {"include_usage": True}, + "ignore_eos": True, + "seed": 1234, + } + if item["kind"] == "chat": + body["messages"] = [{"role": "user", "content": item["prompt"]}] + body["chat_template_kwargs"] = {"enable_thinking": False} + return "/v1/chat/completions", body + body["prompt"] = item["prompt"] + return "/v1/completions", body + + +def validate_request( + row: dict[str, Any], *, item: dict[str, Any], model: str, base: str, + tokens: int, cached: int, +) -> None: + """Require one complete SSE response with literal work, cache and clock evidence.""" + if row.get("error") or row.get("complete") is not True or row.get("unmeasured"): + raise ValueError("failed, incomplete or unmeasured SSE request") + if row.get("prompt") != item["name"] or row.get("seed") != 1234: + raise ValueError("prompt/seed drift") + suffix, body = expected_body(model, item, tokens) + if row.get("request_body") != body or row.get("request_url") != base + suffix: + raise ValueError("literal HTTP request drift") + if row.get("request_body_sha256") != hashlib.sha256(json.dumps(body).encode()).hexdigest(): + raise ValueError("HTTP body hash drift") + if row.get("finish_reason") != "length" or row.get("tokens") != tokens: + raise ValueError("response did not complete forced output length") + usage = row.get("usage") + _, _, prompt_tokens = EXPECTED_PROMPTS[item["name"]] + if not isinstance(usage, dict) or usage.get("prompt_tokens") != prompt_tokens: + raise ValueError("prompt token count drift") + if usage.get("completion_tokens") != tokens or row.get("prompt_tokens") != prompt_tokens: + raise ValueError("completion/prompt usage drift") + details = usage.get("prompt_tokens_details") + if not isinstance(details, dict) or details.get("cached_tokens") != cached: + raise ValueError("actual cached-token count differs from predeclared arm") + if row.get("cached_tokens") != cached or row.get("cache_state") != ("reused" if cached else "cold"): + raise ValueError("normalized cache state drift") + if not isinstance(row.get("response_id"), str) or not row["response_id"]: + raise ValueError("missing response identity") + if not isinstance(row.get("output_sha256"), str) or not re.fullmatch(r"[0-9a-f]{64}", row["output_sha256"]): + raise ValueError("missing text output hash") + if not isinstance(row.get("token_sha"), str) or not re.fullmatch(r"(?:[0-9a-f]{12}|[0-9a-f]{64})", row["token_sha"]): + raise ValueError("missing token fingerprint") + runtime = row.get("runtime") + if not isinstance(runtime, dict) or runtime.get("token_sha") != row["token_sha"]: + raise ValueError("runtime token fingerprint mismatch") + work = row.get("work") + raw_work = row.get("speculative") or runtime + origin = "speculative" if row.get("speculative") else "tensorfold" + if row.get("work_source") != origin or work != {key: raw_work.get(key) for key in ("rounds", "accepted", "drafted")}: + raise ValueError("speculative work/raw provenance mismatch") + if not isinstance(work, dict) or any(type(work.get(key)) is not int or work[key] < 0 + for key in ("rounds", "accepted", "drafted")): + raise ValueError("missing actual speculative work") + if work["rounds"] <= 0 or work["accepted"] > work["drafted"]: + raise ValueError("invalid speculative work") + clocks = [row.get(key) for key in ("sent", "first", "last", "done")] + if any(type(value) not in (int, float) or not math.isfinite(value) for value in clocks): + raise ValueError("missing SSE or DONE timestamp") + sent, first, last, done = clocks + if not sent < first < last <= done: + raise ValueError("nonmonotonic SSE timestamps") + for key, actual in (("ttft_s", first - sent), ("full_response_s", done - sent), + ("decode_tps", (tokens - 1) / (last - first))): + value = row.get(key) + if type(value) not in (int, float) or not math.isclose(value, actual, rel_tol=1e-12): + raise ValueError("SSE timing arithmetic mismatch") + pieces = row.get("pieces") + if not isinstance(pieces, list) or len(pieces) < bench.MIN_PIECES or pieces[0][0] != first or pieces[-1][0] != last: + raise ValueError("missing nonempty SSE pieces") + previous = sent + for arrived, characters in pieces: + if type(arrived) not in (int, float) or not previous <= arrived <= done: + raise ValueError("invalid SSE piece arrival") + if type(characters) is not int or characters <= 0: + raise ValueError("empty or invalid SSE piece") + previous = arrived + + +def validate_report(report: dict[str, Any]) -> dict[str, int]: + """Validate two uncached first uses and 102 primed requests, all 256 outputs.""" + if report.get("schema") != SCHEMA or report.get("complete") is not True: + raise ValueError("incomplete three-way comparison arm") + if report.get("parameters") != PARAMETERS or report.get("source_sha256") != source_hashes(): + raise ValueError("parameters or source changed") + label = report.get("label") + if label not in ("stock", "candidate", "python"): + raise ValueError("expected stock, candidate or Python label") + items = prompts() + cells = report.get("cells", []) + if [cell.get("prompt") for cell in cells] != PARAMETERS["prompts"]: + raise ValueError("missing prompt cell") + ids: set[str] = set() + requests = 0 + total_prompt = 0 + total_output = 0 + for cell in cells: + item = items[cell["prompt"]] + prompt_n = EXPECTED_PROMPTS[item["name"]][2] + expected_cached = 0 if label == "stock" else prompt_n - 1 if label == "python" else prompt_n + uncached_first_use = cell.get("uncached_first_use") + if not isinstance(uncached_first_use, dict): + raise ValueError("missing 256-token uncached first-use request") + validate_request(uncached_first_use, item=item, model=report["model"], base=report["base"], tokens=256, cached=0) + ids.add(uncached_first_use["response_id"]) + requests += 1 + total_prompt += uncached_first_use["prompt_tokens"] + total_output += 256 + levels = cell.get("levels", []) + if [level.get("streams") for level in levels] != [1, 16]: + raise ValueError("original n1/n16 order changed") + for level in levels: + bursts = level.get("bursts", []) + if len(bursts) != 3: + raise ValueError("missing measured repetition") + for index, burst in enumerate(bursts): + if (burst.get("index") != index + or burst.get("phase") != ("primed_first_burst" if index == 0 else "repeat")): + raise ValueError("repetition order changed") + rows = burst.get("requests", []) + if len(rows) != level["streams"]: + raise ValueError("missing simultaneous request") + for row in rows: + validate_request(row, item=item, model=report["model"], base=report["base"], + tokens=256, cached=expected_cached) + ids.add(row["response_id"]) + requests += 1 + total_prompt += row["prompt_tokens"] + total_output += 256 + if requests != 104 or len(ids) != 104 or total_output != 26624: + raise ValueError("request identity/count drift") + return {"requests": requests, "prompt_tokens": total_prompt, "output_tokens": total_output} + + +def summarize_rows(rows: list[dict[str, Any]]) -> dict[str, float]: + """Derive TTFT, decode-span rate and complete wall time from retained clocks.""" + return { + "median_ttft_s": statistics.median(row["ttft_s"] for row in rows), + "slowest_ttft_s": max(row["ttft_s"] for row in rows), + "median_decode_tps": statistics.median(row["decode_tps"] for row in rows), + "minimum_decode_tps": min(row["decode_tps"] for row in rows), + "aggregate_decode_tps": sum(row["tokens"] - 1 for row in rows) + / (max(row["last"] for row in rows) - min(row["first"] for row in rows)), + "median_full_response_s": statistics.median(row["full_response_s"] for row in rows), + "batch_wall_s": max(row["done"] for row in rows) - min(row["sent"] for row in rows), + } + + +def compare_three_reports(reports: dict[str, dict[str, Any]]) -> dict[str, Any]: + """Require all 104 literal request/output pairs for all three backends.""" + if set(reports) != {"stock", "python", "candidate"}: + raise ValueError("missing three-way arm") + for label, report in reports.items(): + validate_report(report) + if report["label"] != label: + raise ValueError("three-way arm identity mismatch") + observations = [] + unequal_work = {"stock_python": 0, "stock_candidate": 0, "python_candidate": 0} + for cell_index, name in enumerate(PARAMETERS["prompts"]): + cells = {arm: report["cells"][cell_index] for arm, report in reports.items()} + groups = [("uncached_first_use", 1, None, + {arm: [cell["uncached_first_use"]] for arm, cell in cells.items()})] + for level_index, n in enumerate(PARAMETERS["levels"]): + for burst_index in range(PARAMETERS["repetitions"]): + groups.append(("primed_first_burst" if burst_index == 0 else "repeat", n, + burst_index, {arm: cell["levels"][level_index]["bursts"] + [burst_index]["requests"] for arm, cell in cells.items()})) + for phase, n, repetition, grouped in groups: + for left_arm, right_arm in (("stock", "python"), ("stock", "candidate"), + ("python", "candidate")): + for left, right in zip(grouped[left_arm], grouped[right_arm]): + if (left["request_body"] != right["request_body"] or + left["request_body_sha256"] != right["request_body_sha256"]): + raise ValueError("three-way literal request mismatch") + if (left["output_sha256"] != right["output_sha256"] or + left["token_sha"] != right["token_sha"]): + raise ValueError("three-way output mismatch") + unequal_work[f"{left_arm}_{right_arm}"] += left["work"] != right["work"] + observations.append({"prompt": name, "streams": n, "phase": phase, + "repetition": repetition, + "arms": {arm: summarize_rows(rows) for arm, rows in grouped.items()}}) + return {"schema": "pr608_three_way_http_comparison_v1", "complete": True, + "requests_per_backend": 104, "total_requests": 312, + "uncached_first_use_per_backend": 2, "primed_requests_per_backend": 102, + "unequal_speculative_work_requests": unequal_work, "observations": observations} + + +def run(args: argparse.Namespace) -> dict[str, Any]: + """Run one uncached prompt request, then the unchanged primed n1/n16 panel.""" + items = prompts() + base = args.base.rstrip("/") + report: dict[str, Any] = { + "schema": SCHEMA, "complete": False, "label": args.label, "model": args.model, + "base": base, "parameters": PARAMETERS, "source_sha256": source_hashes(), "cells": [], + } + write_report(args.output, report) + deadline = time.monotonic() + args.max_seconds + for name in PARAMETERS["prompts"]: + item = items[name] + cell: dict[str, Any] = {"prompt": name, "uncached_first_use": None, "levels": []} + report["cells"].append(cell) + if deadline - time.monotonic() <= 0: + raise TimeoutError("client deadline exceeded") + bench.REQUEST_TIMEOUT = min(1800, deadline - time.monotonic()) + cell["uncached_first_use"] = bench.together(base, args.model, [(item, 1234)], 256, 0.0)[0] + validate_request(cell["uncached_first_use"], item=item, model=args.model, base=base, tokens=256, cached=0) + cell["uncached_first_use_metrics"] = summarize_rows([cell["uncached_first_use"]]) + write_report(args.output, report) + for streams in PARAMETERS["levels"]: + level: dict[str, Any] = {"streams": streams, "bursts": []} + cell["levels"].append(level) + for index in range(3): + if deadline - time.monotonic() <= 0: + raise TimeoutError("client deadline exceeded") + bench.REQUEST_TIMEOUT = min(1800, deadline - time.monotonic()) + rows = bench.together(base, args.model, [(item, 1234)] * streams, 256, 0.0) + burst = {"index": index, "phase": "primed_first_burst" if index == 0 else "repeat", + "requests": rows, "aggregate": bench.aggregates(rows)} + level["bursts"].append(burst) + write_report(args.output, report) + prompt_n = EXPECTED_PROMPTS[name][2] + expected_cached = 0 if args.label == "stock" else prompt_n - 1 if args.label == "python" else prompt_n + for row in rows: + validate_request(row, item=item, model=args.model, base=base, tokens=256, cached=expected_cached) + burst["metrics"] = summarize_rows(rows) + write_report(args.output, report) + print(json.dumps({"label": args.label, "prompt": name, "streams": streams, + "repetition": index, "median_ttft_s": statistics.median(row["ttft_s"] for row in rows), + "slowest_ttft_s": max(row["ttft_s"] for row in rows)}), flush=True) + report["complete"] = True + report["health_totals"] = validate_report(report) + write_report(args.output, report) + return report + + +def main() -> None: + """Run one fresh three-way arm with an explicit output and bounded deadline.""" + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--base", required=True) + parser.add_argument("--model", required=True) + parser.add_argument("--label", choices=("stock", "candidate", "python"), required=True) + parser.add_argument("--output", type=Path, required=True) + parser.add_argument("--max-seconds", type=int, default=1200) + args = parser.parse_args() + if args.max_seconds <= 0: + parser.error("max-seconds must be positive") + + def expired(signum: int, frame: Any) -> None: + """Retain the partial report when the whole client window expires.""" + print("three-way panel deadline exceeded; partial report retained", file=sys.stderr, flush=True) + os._exit(1) + + signal.signal(signal.SIGALRM, expired) + signal.alarm(args.max_seconds) + try: + run(args) + except Exception as exc: + print(f"{type(exc).__name__}: {exc}; partial report retained", file=sys.stderr) + raise SystemExit(1) from exc + finally: + signal.alarm(0) + + +if __name__ == "__main__": + main() diff --git a/validation/pr608-three-way/summary.json b/validation/pr608-three-way/summary.json new file mode 100644 index 000000000..2ef5072fc --- /dev/null +++ b/validation/pr608-three-way/summary.json @@ -0,0 +1,1764 @@ +{ + "balanced": { + "chat_1": { + "candidate": { + "all_three_mean": { + "aggregate_decode_tps": 49.45799939046145, + "batch_wall_s": 5.161746880311209, + "median_per_stream_decode_tps": 49.45799939046145, + "median_ttft_s": 0.005783846291402975, + "slowest_ttft_s": 0.005783846291402975 + }, + "max_three_slowest_ttft_s": 0.009807865950278938, + "primed_first_burst": { + "aggregate_decode_tps": 49.39763007474622, + "batch_wall_s": 5.17205502249999, + "median_per_stream_decode_tps": 49.39763007474622, + "median_ttft_s": 0.009807865950278938, + "slowest_ttft_s": 0.009807865950278938 + }, + "uncached_first_use": { + "decode_tps": 49.375239434030306, + "full_response_s": 5.326590047974605, + "ttft_s": 0.1619835624587722 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 49.48818404831906, + "batch_wall_s": 5.156592809216818, + "median_per_stream_decode_tps": 49.48818404831906, + "median_ttft_s": 0.0037718364619649947, + "slowest_ttft_s": 0.0037718364619649947 + } + }, + "candidate_to_python_geometric_ratio": { + "all_three_mean.median_ttft_s": 0.05092265052517674, + "max_three_slowest_ttft_s": 0.0839791084726518, + "primed_first_burst.median_ttft_s": 0.0873164559887524, + "uncached_first_use.full_response_s": 1.0246375010354485, + "uncached_first_use.ttft_s": 1.3111469356165018, + "warm_repeated_mean.aggregate_decode_tps": 0.9825919935891159, + "warm_repeated_mean.batch_wall_s": 0.9957908026527561, + "warm_repeated_mean.median_per_stream_decode_tps": 0.9825919935891159, + "warm_repeated_mean.median_ttft_s": 0.033010639524623304 + }, + "candidate_to_stock_geometric_ratio": { + "all_three_mean.median_ttft_s": 0.043258168237145074, + "max_three_slowest_ttft_s": 0.07013393545911323, + "primed_first_burst.median_ttft_s": 0.07537160752270512, + "uncached_first_use.full_response_s": 1.0071777360389, + "uncached_first_use.ttft_s": 1.2329014306176742, + "warm_repeated_mean.aggregate_decode_tps": 0.999941269629073, + "warm_repeated_mean.batch_wall_s": 0.9751527690822342, + "warm_repeated_mean.median_per_stream_decode_tps": 0.999941269629073, + "warm_repeated_mean.median_ttft_s": 0.02782084340318505 + }, + "python": { + "all_three_mean": { + "aggregate_decode_tps": 50.39181945156115, + "batch_wall_s": 5.175065946493609, + "median_per_stream_decode_tps": 50.39181945156115, + "median_ttft_s": 0.1135775421668465, + "slowest_ttft_s": 0.1135775421668465 + }, + "max_three_slowest_ttft_s": 0.11682745697908103, + "primed_first_burst": { + "aggregate_decode_tps": 50.445048948908, + "batch_wall_s": 5.168351072468795, + "median_per_stream_decode_tps": 50.445048948908, + "median_ttft_s": 0.11232938850298524, + "slowest_ttft_s": 0.11232938850298524 + }, + "uncached_first_use": { + "decode_tps": 50.25228787760051, + "full_response_s": 5.198522475955542, + "ttft_s": 0.1235442579491064 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 50.36520470288771, + "batch_wall_s": 5.178423383506015, + "median_per_stream_decode_tps": 50.36520470288771, + "median_ttft_s": 0.11420161899877712, + "slowest_ttft_s": 0.11420161899877712 + } + }, + "stock": { + "all_three_mean": { + "aggregate_decode_tps": 49.48457245224549, + "batch_wall_s": 5.286878769480003, + "median_per_stream_decode_tps": 49.48457245224549, + "median_ttft_s": 0.13369720334109542, + "slowest_ttft_s": 0.13369720334109542 + }, + "max_three_slowest_ttft_s": 0.1398405895452015, + "primed_first_burst": { + "aggregate_decode_tps": 49.471442156723946, + "batch_wall_s": 5.2846574309514835, + "median_per_stream_decode_tps": 49.471442156723946, + "median_ttft_s": 0.1301235775463283, + "slowest_ttft_s": 0.1301235775463283 + }, + "uncached_first_use": { + "decode_tps": 49.445364444419056, + "full_response_s": 5.2886253574397415, + "ttft_s": 0.13137344748247415 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 49.49113760000627, + "batch_wall_s": 5.287989438744262, + "median_per_stream_decode_tps": 49.49113760000627, + "median_ttft_s": 0.13548401623847894, + "slowest_ttft_s": 0.13548401623847894 + } + } + }, + "chat_16": { + "candidate": { + "all_three_mean": { + "aggregate_decode_tps": 295.8976309040778, + "batch_wall_s": 13.797114933355868, + "median_per_stream_decode_tps": 18.81438324681892, + "median_ttft_s": 0.15191014715431567, + "slowest_ttft_s": 0.15393049070068326 + }, + "max_three_slowest_ttft_s": 0.20478613901650533, + "primed_first_burst": { + "aggregate_decode_tps": 296.8627921369239, + "batch_wall_s": 13.754259423003532, + "median_per_stream_decode_tps": 18.826041006240363, + "median_ttft_s": 0.20205506597994827, + "slowest_ttft_s": 0.20478613901650533 + }, + "uncached_first_use": { + "decode_tps": 49.375239434030306, + "full_response_s": 5.326590047974605, + "ttft_s": 0.1619835624587722 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 295.4150502876547, + "batch_wall_s": 13.818542688532034, + "median_per_stream_decode_tps": 18.8085543671082, + "median_ttft_s": 0.1268376877414994, + "slowest_ttft_s": 0.1285026665427722 + } + }, + "candidate_to_python_geometric_ratio": { + "all_three_mean.median_ttft_s": 0.6688034210735514, + "max_three_slowest_ttft_s": 0.8277880193644991, + "primed_first_burst.median_ttft_s": 0.9375444865934698, + "uncached_first_use.full_response_s": 1.0246375010354485, + "uncached_first_use.ttft_s": 1.3111469356165018, + "warm_repeated_mean.aggregate_decode_tps": 0.9691212588193892, + "warm_repeated_mean.batch_wall_s": 1.013549279399794, + "warm_repeated_mean.median_per_stream_decode_tps": 0.9870030070169513, + "warm_repeated_mean.median_ttft_s": 0.5444461591761499 + }, + "candidate_to_stock_geometric_ratio": { + "all_three_mean.median_ttft_s": 0.18176257249857122, + "max_three_slowest_ttft_s": 0.2406748121996162, + "primed_first_burst.median_ttft_s": 0.24041079885500424, + "uncached_first_use.full_response_s": 1.0071777360389, + "uncached_first_use.ttft_s": 1.2329014306176742, + "warm_repeated_mean.aggregate_decode_tps": 1.033602680317958, + "warm_repeated_mean.batch_wall_s": 0.9584352159565875, + "warm_repeated_mean.median_per_stream_decode_tps": 1.0016272614889603, + "warm_repeated_mean.median_ttft_s": 0.15217783077290545 + }, + "python": { + "all_three_mean": { + "aggregate_decode_tps": 305.0906885377039, + "batch_wall_s": 13.61726926335056, + "median_per_stream_decode_tps": 19.072406676690427, + "median_ttft_s": 0.22713589458726346, + "slowest_ttft_s": 0.22975341153020662 + }, + "max_three_slowest_ttft_s": 0.24736385903088376, + "primed_first_burst": { + "aggregate_decode_tps": 305.6155271594281, + "batch_wall_s": 13.58413630654104, + "median_per_stream_decode_tps": 19.105601314847707, + "median_ttft_s": 0.21547950778040104, + "slowest_ttft_s": 0.21916994056664407 + }, + "uncached_first_use": { + "decode_tps": 50.25228787760051, + "full_response_s": 5.198522475955542, + "ttft_s": 0.1235442579491064 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 304.8282692268418, + "batch_wall_s": 13.63383574175532, + "median_per_stream_decode_tps": 19.055809357611793, + "median_ttft_s": 0.23296408799069468, + "slowest_ttft_s": 0.23504514701198786 + } + }, + "stock": { + "all_three_mean": { + "aggregate_decode_tps": 286.0539658124822, + "batch_wall_s": 14.403276264686912, + "median_per_stream_decode_tps": 18.801620489085604, + "median_ttft_s": 0.8357501368154772, + "slowest_ttft_s": 0.8382253816816956 + }, + "max_three_slowest_ttft_s": 0.8507165310438722, + "primed_first_burst": { + "aggregate_decode_tps": 286.53496300108156, + "batch_wall_s": 14.374037461529952, + "median_per_stream_decode_tps": 18.849554478085288, + "median_ttft_s": 0.8403004154679365, + "slowest_ttft_s": 0.8439503944828175 + }, + "uncached_first_use": { + "decode_tps": 49.445364444419056, + "full_response_s": 5.2886253574397415, + "ttft_s": 0.13137344748247415 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 285.81346721818255, + "batch_wall_s": 14.417895666265395, + "median_per_stream_decode_tps": 18.777653494585763, + "median_ttft_s": 0.8334749974892475, + "slowest_ttft_s": 0.8353628752811346 + } + } + }, + "code_1": { + "candidate": { + "all_three_mean": { + "aggregate_decode_tps": 69.42707590417663, + "batch_wall_s": 3.6782100791654857, + "median_per_stream_decode_tps": 69.42707590417663, + "median_ttft_s": 0.005219442168405901, + "slowest_ttft_s": 0.005219442168405901 + }, + "max_three_slowest_ttft_s": 0.00883530848659575, + "primed_first_burst": { + "aggregate_decode_tps": 69.38695512874594, + "batch_wall_s": 3.683951170009095, + "median_per_stream_decode_tps": 69.38695512874594, + "median_ttft_s": 0.00883530848659575, + "slowest_ttft_s": 0.00883530848659575 + }, + "uncached_first_use": { + "decode_tps": 69.4395742921337, + "full_response_s": 3.821134602476377, + "ttft_s": 0.14875945000676438 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 69.44713629189198, + "batch_wall_s": 3.6753395337436814, + "median_per_stream_decode_tps": 69.44713629189198, + "median_ttft_s": 0.0034115090093109757, + "slowest_ttft_s": 0.0034115090093109757 + } + }, + "candidate_to_python_geometric_ratio": { + "all_three_mean.median_ttft_s": 0.046357912125498876, + "max_three_slowest_ttft_s": 0.07569037161787866, + "primed_first_burst.median_ttft_s": 0.07681321799015932, + "uncached_first_use.full_response_s": 0.9496112435665919, + "uncached_first_use.ttft_s": 0.7222073000901735, + "warm_repeated_mean.aggregate_decode_tps": 1.0195593624648003, + "warm_repeated_mean.batch_wall_s": 0.9530656198180948, + "warm_repeated_mean.median_per_stream_decode_tps": 1.0195593624648003, + "warm_repeated_mean.median_ttft_s": 0.030626770673123437 + }, + "candidate_to_stock_geometric_ratio": { + "all_three_mean.median_ttft_s": 0.040657385557502285, + "max_three_slowest_ttft_s": 0.06825345934504048, + "primed_first_burst.median_ttft_s": 0.06871276486029368, + "uncached_first_use.full_response_s": 0.9987999885260397, + "uncached_first_use.ttft_s": 1.0197051676924906, + "warm_repeated_mean.aggregate_decode_tps": 1.0094859836459178, + "warm_repeated_mean.batch_wall_s": 0.9582524216632564, + "warm_repeated_mean.median_per_stream_decode_tps": 1.0094859836459178, + "warm_repeated_mean.median_ttft_s": 0.026578163721150357 + }, + "python": { + "all_three_mean": { + "aggregate_decode_tps": 68.0833954457377, + "batch_wall_s": 3.859272798174061, + "median_per_stream_decode_tps": 68.0833954457377, + "median_ttft_s": 0.11260935712683326, + "slowest_ttft_s": 0.11260935712683326 + }, + "max_three_slowest_ttft_s": 0.11677433893783018, + "primed_first_burst": { + "aggregate_decode_tps": 68.02038495680785, + "batch_wall_s": 3.8651467470335774, + "median_per_stream_decode_tps": 68.02038495680785, + "median_ttft_s": 0.115148673474323, + "slowest_ttft_s": 0.115148673474323 + }, + "uncached_first_use": { + "decode_tps": 66.80393325606488, + "full_response_s": 4.023853203980252, + "ttft_s": 0.20587272651027888 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 68.1149006902026, + "batch_wall_s": 3.8563358237443026, + "median_per_stream_decode_tps": 68.1149006902026, + "median_ttft_s": 0.11133969895308837, + "slowest_ttft_s": 0.11133969895308837 + } + }, + "stock": { + "all_three_mean": { + "aggregate_decode_tps": 68.9467751556868, + "batch_wall_s": 3.8274457831673017, + "median_per_stream_decode_tps": 68.9467751556868, + "median_ttft_s": 0.12837543002873036, + "slowest_ttft_s": 0.12837543002873036 + }, + "max_three_slowest_ttft_s": 0.12939125654520467, + "primed_first_burst": { + "aggregate_decode_tps": 69.24564337106997, + "batch_wall_s": 3.811117196455598, + "median_per_stream_decode_tps": 69.24564337106997, + "median_ttft_s": 0.12852637650212273, + "slowest_ttft_s": 0.12852637650212273 + }, + "uncached_first_use": { + "decode_tps": 69.29723770172161, + "full_response_s": 3.8256879440159537, + "ttft_s": 0.1458312449976802 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 68.79734104799522, + "batch_wall_s": 3.835610076523153, + "median_per_stream_decode_tps": 68.79734104799522, + "median_ttft_s": 0.1282999567920342, + "slowest_ttft_s": 0.1282999567920342 + } + } + }, + "code_16": { + "candidate": { + "all_three_mean": { + "aggregate_decode_tps": 402.5133627169887, + "batch_wall_s": 10.142272455152124, + "median_per_stream_decode_tps": 25.577809342622018, + "median_ttft_s": 0.16844404517905787, + "slowest_ttft_s": 0.17010721046244726 + }, + "max_three_slowest_ttft_s": 0.25533725693821907, + "primed_first_burst": { + "aggregate_decode_tps": 401.11969855363577, + "batch_wall_s": 10.178845075482968, + "median_per_stream_decode_tps": 25.704202606269178, + "median_ttft_s": 0.25296483177226037, + "slowest_ttft_s": 0.25533725693821907 + }, + "uncached_first_use": { + "decode_tps": 69.4395742921337, + "full_response_s": 3.821134602476377, + "ttft_s": 0.14875945000676438 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 403.21019479866516, + "batch_wall_s": 10.123986144986702, + "median_per_stream_decode_tps": 25.51461271079844, + "median_ttft_s": 0.12618365188245662, + "slowest_ttft_s": 0.12749218722456135 + } + }, + "candidate_to_python_geometric_ratio": { + "all_three_mean.median_ttft_s": 0.6877341404295031, + "max_three_slowest_ttft_s": 0.852227315752772, + "primed_first_burst.median_ttft_s": 0.8544522200624272, + "uncached_first_use.full_response_s": 0.9496112435665919, + "uncached_first_use.ttft_s": 0.7222073000901735, + "warm_repeated_mean.aggregate_decode_tps": 1.005249005730396, + "warm_repeated_mean.batch_wall_s": 0.9728118869678636, + "warm_repeated_mean.median_per_stream_decode_tps": 1.0174169151052752, + "warm_repeated_mean.median_ttft_s": 0.5749258059825096 + }, + "candidate_to_stock_geometric_ratio": { + "all_three_mean.median_ttft_s": 0.25111388880930463, + "max_three_slowest_ttft_s": 0.36975549351081055, + "primed_first_burst.median_ttft_s": 0.38926756657611733, + "uncached_first_use.full_response_s": 0.9987999885260397, + "uncached_first_use.ttft_s": 1.0197051676924906, + "warm_repeated_mean.aggregate_decode_tps": 1.0572535271470918, + "warm_repeated_mean.batch_wall_s": 0.9345448905739632, + "warm_repeated_mean.median_per_stream_decode_tps": 1.0152565361694306, + "warm_repeated_mean.median_ttft_s": 0.18519331704654565 + }, + "python": { + "all_three_mean": { + "aggregate_decode_tps": 400.5183020466885, + "batch_wall_s": 10.450377476828482, + "median_per_stream_decode_tps": 25.04193173401694, + "median_ttft_s": 0.24478995916433632, + "slowest_ttft_s": 0.24698000135443485 + }, + "max_three_slowest_ttft_s": 0.29903407901292667, + "primed_first_burst": { + "aggregate_decode_tps": 399.24497720672076, + "batch_wall_s": 10.534728072001599, + "median_per_stream_decode_tps": 24.96390519435763, + "median_ttft_s": 0.2953906310140155, + "slowest_ttft_s": 0.29903407901292667 + }, + "uncached_first_use": { + "decode_tps": 66.80393325606488, + "full_response_s": 4.023853203980252, + "ttft_s": 0.20587272651027888 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 401.1549644666724, + "batch_wall_s": 10.408202179241925, + "median_per_stream_decode_tps": 25.080945003846598, + "median_ttft_s": 0.21948962323949672, + "slowest_ttft_s": 0.22095296252518892 + } + }, + "stock": { + "all_three_mean": { + "aggregate_decode_tps": 382.5167944414286, + "batch_wall_s": 10.801649247354362, + "median_per_stream_decode_tps": 25.18368595578516, + "median_ttft_s": 0.6707027665979695, + "slowest_ttft_s": 0.6722567756854307 + }, + "max_three_slowest_ttft_s": 0.6897106120013632, + "primed_first_burst": { + "aggregate_decode_tps": 384.7878234395605, + "batch_wall_s": 10.738553897070233, + "median_per_stream_decode_tps": 25.2887995008036, + "median_ttft_s": 0.6484896795009263, + "slowest_ttft_s": 0.650459508469794 + }, + "uncached_first_use": { + "decode_tps": 69.29723770172161, + "full_response_s": 3.8256879440159537, + "ttft_s": 0.1458312449976802 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 381.3812799423626, + "batch_wall_s": 10.833196922496427, + "median_per_stream_decode_tps": 25.131129183275938, + "median_ttft_s": 0.681809310146491, + "slowest_ttft_s": 0.6831554092932492 + } + } + } + }, + "complete": true, + "limits": [ + "Cold here means no cached prompt tokens after server readiness, not model startup time.", + "Code is first request in each process; chat first-use follows code traffic.", + "Bursts share a process and their requests are correlated; two orders are not confidence intervals.", + "Different speculative work is retained and does not invalidate literal output parity, but limits causal attribution." + ], + "orders": { + "forward": { + "cells": { + "chat_1": { + "candidate": { + "all_three_mean": { + "aggregate_decode_tps": 49.4400153560134, + "batch_wall_s": 5.163531705310258, + "median_per_stream_decode_tps": 49.4400153560134, + "median_ttft_s": 0.0057195889530703425, + "slowest_ttft_s": 0.0057195889530703425 + }, + "bursts": [ + { + "aggregate_decode_tps": 49.39649641546799, + "batch_wall_s": 5.172245168010704, + "median_per_stream_decode_tps": 49.39649641546799, + "median_ttft_s": 0.009892812930047512, + "slowest_ttft_s": 0.009892812930047512 + }, + { + "aggregate_decode_tps": 49.46127542017963, + "batch_wall_s": 5.159113991889171, + "median_per_stream_decode_tps": 49.46127542017963, + "median_ttft_s": 0.0035265889018774033, + "slowest_ttft_s": 0.0035265889018774033 + }, + { + "aggregate_decode_tps": 49.46227423239256, + "batch_wall_s": 5.159235956030898, + "median_per_stream_decode_tps": 49.46227423239256, + "median_ttft_s": 0.0037393650272861123, + "slowest_ttft_s": 0.0037393650272861123 + } + ], + "max_three_slowest_ttft_s": 0.009892812930047512, + "primed_first_burst": { + "aggregate_decode_tps": 49.39649641546799, + "batch_wall_s": 5.172245168010704, + "median_per_stream_decode_tps": 49.39649641546799, + "median_ttft_s": 0.009892812930047512, + "slowest_ttft_s": 0.009892812930047512 + }, + "uncached_first_use": { + "decode_tps": 49.288785308053065, + "full_response_s": 5.3334763729944825, + "ttft_s": 0.1598150139907375 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 49.461774826286096, + "batch_wall_s": 5.1591749739600345, + "median_per_stream_decode_tps": 49.461774826286096, + "median_ttft_s": 0.003632976964581758, + "slowest_ttft_s": 0.003632976964581758 + } + }, + "python": { + "all_three_mean": { + "aggregate_decode_tps": 50.541924731948306, + "batch_wall_s": 5.15885404466341, + "median_per_stream_decode_tps": 50.541924731948306, + "median_ttft_s": 0.1126811063537995, + "slowest_ttft_s": 0.1126811063537995 + }, + "bursts": [ + { + "aggregate_decode_tps": 50.562689637348726, + "batch_wall_s": 5.157443576026708, + "median_per_stream_decode_tps": 50.562689637348726, + "median_ttft_s": 0.11367716500535607, + "slowest_ttft_s": 0.11367716500535607 + }, + { + "aggregate_decode_tps": 50.52897724159633, + "batch_wall_s": 5.159980249009095, + "median_per_stream_decode_tps": 50.52897724159633, + "median_ttft_s": 0.11238703108392656, + "slowest_ttft_s": 0.11238703108392656 + }, + { + "aggregate_decode_tps": 50.534107316899856, + "batch_wall_s": 5.159138308954425, + "median_per_stream_decode_tps": 50.534107316899856, + "median_ttft_s": 0.11197912297211587, + "slowest_ttft_s": 0.11197912297211587 + } + ], + "max_three_slowest_ttft_s": 0.11367716500535607, + "primed_first_burst": { + "aggregate_decode_tps": 50.562689637348726, + "batch_wall_s": 5.157443576026708, + "median_per_stream_decode_tps": 50.562689637348726, + "median_ttft_s": 0.11367716500535607, + "slowest_ttft_s": 0.11367716500535607 + }, + "uncached_first_use": { + "decode_tps": 50.394547279094006, + "full_response_s": 5.185988562996499, + "ttft_s": 0.1252604149049148 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 50.53154227924809, + "batch_wall_s": 5.15955927898176, + "median_per_stream_decode_tps": 50.53154227924809, + "median_ttft_s": 0.11218307702802122, + "slowest_ttft_s": 0.11218307702802122 + } + }, + "stock": { + "all_three_mean": { + "aggregate_decode_tps": 49.54151614609533, + "batch_wall_s": 5.2811487526632845, + "median_per_stream_decode_tps": 49.54151614609533, + "median_ttft_s": 0.1339018833435451, + "slowest_ttft_s": 0.1339018833435451 + }, + "bursts": [ + { + "aggregate_decode_tps": 49.496096210048464, + "batch_wall_s": 5.28274655691348, + "median_per_stream_decode_tps": 49.496096210048464, + "median_ttft_s": 0.13078091200441122, + "slowest_ttft_s": 0.13078091200441122 + }, + { + "aggregate_decode_tps": 49.55497011356417, + "batch_wall_s": 5.277474235976115, + "median_per_stream_decode_tps": 49.55497011356417, + "median_ttft_s": 0.13162297592498362, + "slowest_ttft_s": 0.13162297592498362 + }, + { + "aggregate_decode_tps": 49.573482114673375, + "batch_wall_s": 5.283225465100259, + "median_per_stream_decode_tps": 49.573482114673375, + "median_ttft_s": 0.13930176210124046, + "slowest_ttft_s": 0.13930176210124046 + } + ], + "max_three_slowest_ttft_s": 0.13930176210124046, + "primed_first_burst": { + "aggregate_decode_tps": 49.496096210048464, + "batch_wall_s": 5.28274655691348, + "median_per_stream_decode_tps": 49.496096210048464, + "median_ttft_s": 0.13078091200441122, + "slowest_ttft_s": 0.13078091200441122 + }, + "uncached_first_use": { + "decode_tps": 49.450674171111686, + "full_response_s": 5.28751365293283, + "ttft_s": 0.13081464997958392 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 49.56422611411877, + "batch_wall_s": 5.280349850538187, + "median_per_stream_decode_tps": 49.56422611411877, + "median_ttft_s": 0.13546236901311204, + "slowest_ttft_s": 0.13546236901311204 + } + } + }, + "chat_16": { + "candidate": { + "all_three_mean": { + "aggregate_decode_tps": 296.1751705380474, + "batch_wall_s": 13.78358036535792, + "median_per_stream_decode_tps": 18.94825651955628, + "median_ttft_s": 0.1510745648217077, + "slowest_ttft_s": 0.15295222502512237 + }, + "bursts": [ + { + "aggregate_decode_tps": 298.9943702484223, + "batch_wall_s": 13.656021406990476, + "median_per_stream_decode_tps": 18.956089775533833, + "median_ttft_s": 0.19814172998303548, + "slowest_ttft_s": 0.20047153299674392 + }, + { + "aggregate_decode_tps": 294.8797683702987, + "batch_wall_s": 13.84100312308874, + "median_per_stream_decode_tps": 18.952941100876842, + "median_ttft_s": 0.12677289301063865, + "slowest_ttft_s": 0.1284269770840183 + }, + { + "aggregate_decode_tps": 294.6513729954212, + "batch_wall_s": 13.853716565994546, + "median_per_stream_decode_tps": 18.935738682258172, + "median_ttft_s": 0.128309071471449, + "slowest_ttft_s": 0.12995816499460489 + } + ], + "max_three_slowest_ttft_s": 0.20047153299674392, + "primed_first_burst": { + "aggregate_decode_tps": 298.9943702484223, + "batch_wall_s": 13.656021406990476, + "median_per_stream_decode_tps": 18.956089775533833, + "median_ttft_s": 0.19814172998303548, + "slowest_ttft_s": 0.20047153299674392 + }, + "uncached_first_use": { + "decode_tps": 49.288785308053065, + "full_response_s": 5.3334763729944825, + "ttft_s": 0.1598150139907375 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 294.7655706828599, + "batch_wall_s": 13.847359844541643, + "median_per_stream_decode_tps": 18.94433989156751, + "median_ttft_s": 0.12754098224104382, + "slowest_ttft_s": 0.1291925710393116 + } + }, + "python": { + "all_three_mean": { + "aggregate_decode_tps": 305.5929102443623, + "batch_wall_s": 13.596407022016743, + "median_per_stream_decode_tps": 19.10335654781022, + "median_ttft_s": 0.22811600348601738, + "slowest_ttft_s": 0.23117880670664212 + }, + "bursts": [ + { + "aggregate_decode_tps": 305.37031899733915, + "batch_wall_s": 13.596175380051136, + "median_per_stream_decode_tps": 19.089454350011216, + "median_ttft_s": 0.2169110294780694, + "slowest_ttft_s": 0.22151819104328752 + }, + { + "aggregate_decode_tps": 305.978150366696, + "batch_wall_s": 13.568922774982639, + "median_per_stream_decode_tps": 19.128050693717192, + "median_ttft_s": 0.2185539790079929, + "slowest_ttft_s": 0.22085483302362263 + }, + { + "aggregate_decode_tps": 305.4302613690518, + "batch_wall_s": 13.624122911016457, + "median_per_stream_decode_tps": 19.09256459970225, + "median_ttft_s": 0.24888300197198987, + "slowest_ttft_s": 0.2511633960530162 + } + ], + "max_three_slowest_ttft_s": 0.2511633960530162, + "primed_first_burst": { + "aggregate_decode_tps": 305.37031899733915, + "batch_wall_s": 13.596175380051136, + "median_per_stream_decode_tps": 19.089454350011216, + "median_ttft_s": 0.2169110294780694, + "slowest_ttft_s": 0.22151819104328752 + }, + "uncached_first_use": { + "decode_tps": 50.394547279094006, + "full_response_s": 5.185988562996499, + "ttft_s": 0.1252604149049148 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 305.7042058678739, + "batch_wall_s": 13.596522842999548, + "median_per_stream_decode_tps": 19.11030764670972, + "median_ttft_s": 0.23371849048999138, + "slowest_ttft_s": 0.2360091145383194 + } + }, + "stock": { + "all_three_mean": { + "aggregate_decode_tps": 287.15060478291, + "batch_wall_s": 14.354952813009731, + "median_per_stream_decode_tps": 18.86614226666673, + "median_ttft_s": 0.8342468039869951, + "slowest_ttft_s": 0.8364021483575925 + }, + "bursts": [ + { + "aggregate_decode_tps": 287.15204122502047, + "batch_wall_s": 14.34217473398894, + "median_per_stream_decode_tps": 18.89543511652972, + "median_ttft_s": 0.8412457454251125, + "slowest_ttft_s": 0.8445613490184769 + }, + { + "aggregate_decode_tps": 287.24737933007697, + "batch_wall_s": 14.354036255041137, + "median_per_stream_decode_tps": 18.866784706837493, + "median_ttft_s": 0.8340961739886552, + "slowest_ttft_s": 0.836003654054366 + }, + { + "aggregate_decode_tps": 287.0523937936327, + "batch_wall_s": 14.368647449999116, + "median_per_stream_decode_tps": 18.836206976632987, + "median_ttft_s": 0.8273984925472178, + "slowest_ttft_s": 0.8286414419999346 + } + ], + "max_three_slowest_ttft_s": 0.8445613490184769, + "primed_first_burst": { + "aggregate_decode_tps": 287.15204122502047, + "batch_wall_s": 14.34217473398894, + "median_per_stream_decode_tps": 18.89543511652972, + "median_ttft_s": 0.8412457454251125, + "slowest_ttft_s": 0.8445613490184769 + }, + "uncached_first_use": { + "decode_tps": 49.450674171111686, + "full_response_s": 5.28751365293283, + "ttft_s": 0.13081464997958392 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 287.1498865618548, + "batch_wall_s": 14.361341852520127, + "median_per_stream_decode_tps": 18.85149584173524, + "median_ttft_s": 0.8307473332679365, + "slowest_ttft_s": 0.8323225480271503 + } + } + }, + "code_1": { + "candidate": { + "all_three_mean": { + "aggregate_decode_tps": 69.25701592237247, + "batch_wall_s": 3.6871991273170956, + "median_per_stream_decode_tps": 69.25701592237247, + "median_ttft_s": 0.005199970367054145, + "slowest_ttft_s": 0.005199970367054145 + }, + "bursts": [ + { + "aggregate_decode_tps": 69.16417465259032, + "batch_wall_s": 3.695488329976797, + "median_per_stream_decode_tps": 69.16417465259032, + "median_ttft_s": 0.008572331978939474, + "slowest_ttft_s": 0.008572331978939474 + }, + { + "aggregate_decode_tps": 69.3822845686003, + "batch_wall_s": 3.679035292007029, + "median_per_stream_decode_tps": 69.3822845686003, + "median_ttft_s": 0.0036992140812799335, + "slowest_ttft_s": 0.0036992140812799335 + }, + { + "aggregate_decode_tps": 69.22458854592682, + "batch_wall_s": 3.6870737599674612, + "median_per_stream_decode_tps": 69.22458854592682, + "median_ttft_s": 0.0033283650409430265, + "slowest_ttft_s": 0.0033283650409430265 + } + ], + "max_three_slowest_ttft_s": 0.008572331978939474, + "primed_first_burst": { + "aggregate_decode_tps": 69.16417465259032, + "batch_wall_s": 3.695488329976797, + "median_per_stream_decode_tps": 69.16417465259032, + "median_ttft_s": 0.008572331978939474, + "slowest_ttft_s": 0.008572331978939474 + }, + "uncached_first_use": { + "decode_tps": 69.1970505168244, + "full_response_s": 3.8389058320317417, + "ttft_s": 0.15367080504074693 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 69.30343655726355, + "batch_wall_s": 3.683054525987245, + "median_per_stream_decode_tps": 69.30343655726355, + "median_ttft_s": 0.00351378956111148, + "slowest_ttft_s": 0.00351378956111148 + } + }, + "python": { + "all_three_mean": { + "aggregate_decode_tps": 68.26437426540988, + "batch_wall_s": 3.8474062600095444, + "median_per_stream_decode_tps": 68.26437426540988, + "median_ttft_s": 0.11048518229896824, + "slowest_ttft_s": 0.11048518229896824 + }, + "bursts": [ + { + "aggregate_decode_tps": 68.23875411554083, + "batch_wall_s": 3.8472263420699164, + "median_per_stream_decode_tps": 68.23875411554083, + "median_ttft_s": 0.10877824400085956, + "slowest_ttft_s": 0.10877824400085956 + }, + { + "aggregate_decode_tps": 68.246555769264, + "batch_wall_s": 3.848474205005914, + "median_per_stream_decode_tps": 68.246555769264, + "median_ttft_s": 0.11064772796817124, + "slowest_ttft_s": 0.11064772796817124 + }, + { + "aggregate_decode_tps": 68.30781291142482, + "batch_wall_s": 3.8465182329528034, + "median_per_stream_decode_tps": 68.30781291142482, + "median_ttft_s": 0.11202957492787391, + "slowest_ttft_s": 0.11202957492787391 + } + ], + "max_three_slowest_ttft_s": 0.11202957492787391, + "primed_first_burst": { + "aggregate_decode_tps": 68.23875411554083, + "batch_wall_s": 3.8472263420699164, + "median_per_stream_decode_tps": 68.23875411554083, + "median_ttft_s": 0.10877824400085956, + "slowest_ttft_s": 0.10877824400085956 + }, + "uncached_first_use": { + "decode_tps": 66.91543941169725, + "full_response_s": 4.018838191987015, + "ttft_s": 0.20746252895332873 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 68.2771843403444, + "batch_wall_s": 3.8474962189793587, + "median_per_stream_decode_tps": 68.2771843403444, + "median_ttft_s": 0.11133865144802257, + "slowest_ttft_s": 0.11133865144802257 + } + }, + "stock": { + "all_three_mean": { + "aggregate_decode_tps": 69.39438070313894, + "batch_wall_s": 3.8029184699989855, + "median_per_stream_decode_tps": 69.39438070313894, + "median_ttft_s": 0.1282266010530293, + "slowest_ttft_s": 0.1282266010530293 + }, + "bursts": [ + { + "aggregate_decode_tps": 69.31728211845895, + "batch_wall_s": 3.8071185839362442, + "median_per_stream_decode_tps": 69.31728211845895, + "median_ttft_s": 0.12834576901514083, + "slowest_ttft_s": 0.12834576901514083 + }, + { + "aggregate_decode_tps": 69.39164790811509, + "batch_wall_s": 3.8016050670994446, + "median_per_stream_decode_tps": 69.39164790811509, + "median_ttft_s": 0.12678102508652955, + "slowest_ttft_s": 0.12678102508652955 + }, + { + "aggregate_decode_tps": 69.47421208284278, + "batch_wall_s": 3.8000317589612678, + "median_per_stream_decode_tps": 69.47421208284278, + "median_ttft_s": 0.1295530090574175, + "slowest_ttft_s": 0.1295530090574175 + } + ], + "max_three_slowest_ttft_s": 0.1295530090574175, + "primed_first_burst": { + "aggregate_decode_tps": 69.31728211845895, + "batch_wall_s": 3.8071185839362442, + "median_per_stream_decode_tps": 69.31728211845895, + "median_ttft_s": 0.12834576901514083, + "slowest_ttft_s": 0.12834576901514083 + }, + "uncached_first_use": { + "decode_tps": 69.3467691433056, + "full_response_s": 3.8202944709919393, + "ttft_s": 0.14307712903246284 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 69.43292999547893, + "batch_wall_s": 3.800818413030356, + "median_per_stream_decode_tps": 69.43292999547893, + "median_ttft_s": 0.12816701707197353, + "slowest_ttft_s": 0.12816701707197353 + } + } + }, + "code_16": { + "candidate": { + "all_three_mean": { + "aggregate_decode_tps": 405.34713260215597, + "batch_wall_s": 10.070973776979372, + "median_per_stream_decode_tps": 25.746675071525562, + "median_ttft_s": 0.16264202917227522, + "slowest_ttft_s": 0.16469130665063858 + }, + "bursts": [ + { + "aggregate_decode_tps": 403.83920569000463, + "batch_wall_s": 10.109565221937373, + "median_per_stream_decode_tps": 25.84193958206844, + "median_ttft_s": 0.23595618351828307, + "slowest_ttft_s": 0.2394248238997534 + }, + { + "aggregate_decode_tps": 406.4921769411092, + "batch_wall_s": 10.042497499031015, + "median_per_stream_decode_tps": 25.72396603189202, + "median_ttft_s": 0.12578125798609108, + "slowest_ttft_s": 0.12665084702894092 + }, + { + "aggregate_decode_tps": 405.7100151753541, + "batch_wall_s": 10.060858609969728, + "median_per_stream_decode_tps": 25.674119600616223, + "median_ttft_s": 0.1261886460124515, + "slowest_ttft_s": 0.12799824902322143 + } + ], + "max_three_slowest_ttft_s": 0.2394248238997534, + "primed_first_burst": { + "aggregate_decode_tps": 403.83920569000463, + "batch_wall_s": 10.109565221937373, + "median_per_stream_decode_tps": 25.84193958206844, + "median_ttft_s": 0.23595618351828307, + "slowest_ttft_s": 0.2394248238997534 + }, + "uncached_first_use": { + "decode_tps": 69.1970505168244, + "full_response_s": 3.8389058320317417, + "ttft_s": 0.15367080504074693 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 406.10109605823163, + "batch_wall_s": 10.051678054500371, + "median_per_stream_decode_tps": 25.69904281625412, + "median_ttft_s": 0.1259849519992713, + "slowest_ttft_s": 0.12732454802608117 + } + }, + "python": { + "all_three_mean": { + "aggregate_decode_tps": 407.7275804987154, + "batch_wall_s": 10.263866891036741, + "median_per_stream_decode_tps": 25.493184287752122, + "median_ttft_s": 0.2426686871719236, + "slowest_ttft_s": 0.24475442602609596 + }, + "bursts": [ + { + "aggregate_decode_tps": 406.9414871241619, + "batch_wall_s": 10.332885487005115, + "median_per_stream_decode_tps": 25.44842431595651, + "median_ttft_s": 0.29356824001297355, + "slowest_ttft_s": 0.29734581196680665 + }, + { + "aggregate_decode_tps": 408.7259089892155, + "batch_wall_s": 10.21644577209372, + "median_per_stream_decode_tps": 25.552838747786744, + "median_ttft_s": 0.21837356151081622, + "slowest_ttft_s": 0.21964519005268812 + }, + { + "aggregate_decode_tps": 407.5153453827687, + "batch_wall_s": 10.242269414011389, + "median_per_stream_decode_tps": 25.478289799513114, + "median_ttft_s": 0.2160642599919811, + "slowest_ttft_s": 0.21727227605879307 + } + ], + "max_three_slowest_ttft_s": 0.29734581196680665, + "primed_first_burst": { + "aggregate_decode_tps": 406.9414871241619, + "batch_wall_s": 10.332885487005115, + "median_per_stream_decode_tps": 25.44842431595651, + "median_ttft_s": 0.29356824001297355, + "slowest_ttft_s": 0.29734581196680665 + }, + "uncached_first_use": { + "decode_tps": 66.91543941169725, + "full_response_s": 4.018838191987015, + "ttft_s": 0.20746252895332873 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 408.12062718599213, + "batch_wall_s": 10.229357593052555, + "median_per_stream_decode_tps": 25.51556427364993, + "median_ttft_s": 0.21721891075139865, + "slowest_ttft_s": 0.2184587330557406 + } + }, + "stock": { + "all_three_mean": { + "aggregate_decode_tps": 386.9575936520032, + "batch_wall_s": 10.681176661668966, + "median_per_stream_decode_tps": 25.433093957874064, + "median_ttft_s": 0.6502029061860716, + "slowest_ttft_s": 0.6516914096816132 + }, + "bursts": [ + { + "aggregate_decode_tps": 391.1324532413707, + "batch_wall_s": 10.565081494045444, + "median_per_stream_decode_tps": 25.693181493782305, + "median_ttft_s": 0.6364343640161678, + "slowest_ttft_s": 0.6383471799781546 + }, + { + "aggregate_decode_tps": 388.85412696727576, + "batch_wall_s": 10.622148239985108, + "median_per_stream_decode_tps": 25.61006726676286, + "median_ttft_s": 0.6623910785419866, + "slowest_ttft_s": 0.6635625059716403 + }, + { + "aggregate_decode_tps": 380.8862007473631, + "batch_wall_s": 10.856300250976346, + "median_per_stream_decode_tps": 24.996033113077022, + "median_ttft_s": 0.6517832760000601, + "slowest_ttft_s": 0.6531645430950448 + } + ], + "max_three_slowest_ttft_s": 0.6635625059716403, + "primed_first_burst": { + "aggregate_decode_tps": 391.1324532413707, + "batch_wall_s": 10.565081494045444, + "median_per_stream_decode_tps": 25.693181493782305, + "median_ttft_s": 0.6364343640161678, + "slowest_ttft_s": 0.6383471799781546 + }, + "uncached_first_use": { + "decode_tps": 69.3467691433056, + "full_response_s": 3.8202944709919393, + "ttft_s": 0.14307712903246284 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 384.8701638573194, + "batch_wall_s": 10.739224245480727, + "median_per_stream_decode_tps": 25.303050189919944, + "median_ttft_s": 0.6570871772710234, + "slowest_ttft_s": 0.6583635245333426 + } + } + } + }, + "process_order_expected": [ + "python", + "stock", + "candidate" + ], + "provenance_sha256": "9326f2f13e7425fc9672dccdacd8712529560c8e89ffe5523d26f733b3361a66", + "requests_per_arm": 104, + "source_report_sha256": { + "candidate": "d093352f4066db9f06d4640aa0c0d4bbf54926d64e74a182756429267a4d4fa7", + "python": "463f5fc88ec2e616270f2527bb5d45b942bec01f0205387a4720fb2f65e5d1c7", + "stock": "200c016071bc876246e895a4ef01333491a9268e5ec6ba1c5c85f0c6ca6ad24a" + }, + "status_sha256": "f24c0a2526605f9ed17200003a2afee98ec999a34d047c9fea33d6aa794ac4e0", + "work_difference_counts": { + "python_candidate": 104, + "stock_candidate": 95 + } + }, + "reverse": { + "cells": { + "chat_1": { + "candidate": { + "all_three_mean": { + "aggregate_decode_tps": 49.4759834249095, + "batch_wall_s": 5.1599620553121595, + "median_per_stream_decode_tps": 49.4759834249095, + "median_ttft_s": 0.005848103629735609, + "slowest_ttft_s": 0.005848103629735609 + }, + "bursts": [ + { + "aggregate_decode_tps": 49.39876373402444, + "batch_wall_s": 5.171864876989275, + "median_per_stream_decode_tps": 49.39876373402444, + "median_ttft_s": 0.009722918970510364, + "slowest_ttft_s": 0.009722918970510364 + }, + { + "aggregate_decode_tps": 49.506776796320494, + "batch_wall_s": 5.154137868899852, + "median_per_stream_decode_tps": 49.506776796320494, + "median_ttft_s": 0.003276785952039063, + "slowest_ttft_s": 0.003276785952039063 + }, + { + "aggregate_decode_tps": 49.522409744383566, + "batch_wall_s": 5.15388342004735, + "median_per_stream_decode_tps": 49.522409744383566, + "median_ttft_s": 0.0045446059666574, + "slowest_ttft_s": 0.0045446059666574 + } + ], + "max_three_slowest_ttft_s": 0.009722918970510364, + "primed_first_burst": { + "aggregate_decode_tps": 49.39876373402444, + "batch_wall_s": 5.171864876989275, + "median_per_stream_decode_tps": 49.39876373402444, + "median_ttft_s": 0.009722918970510364, + "slowest_ttft_s": 0.009722918970510364 + }, + "uncached_first_use": { + "decode_tps": 49.46169356000755, + "full_response_s": 5.319703722954728, + "ttft_s": 0.16415211092680693 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 49.51459327035203, + "batch_wall_s": 5.154010644473601, + "median_per_stream_decode_tps": 49.51459327035203, + "median_ttft_s": 0.0039106959593482316, + "slowest_ttft_s": 0.0039106959593482316 + } + }, + "python": { + "all_three_mean": { + "aggregate_decode_tps": 50.24171417117398, + "batch_wall_s": 5.191277848323807, + "median_per_stream_decode_tps": 50.24171417117398, + "median_ttft_s": 0.11447397797989349, + "slowest_ttft_s": 0.11447397797989349 + }, + "bursts": [ + { + "aggregate_decode_tps": 50.32740826046728, + "batch_wall_s": 5.179258568910882, + "median_per_stream_decode_tps": 50.32740826046728, + "median_ttft_s": 0.1109816120006144, + "slowest_ttft_s": 0.1109816120006144 + }, + { + "aggregate_decode_tps": 50.03491411725481, + "batch_wall_s": 5.217459577019326, + "median_per_stream_decode_tps": 50.03491411725481, + "median_ttft_s": 0.119977748952806, + "slowest_ttft_s": 0.119977748952806 + }, + { + "aggregate_decode_tps": 50.36282013579986, + "batch_wall_s": 5.177115399041213, + "median_per_stream_decode_tps": 50.36282013579986, + "median_ttft_s": 0.11246257298626006, + "slowest_ttft_s": 0.11246257298626006 + } + ], + "max_three_slowest_ttft_s": 0.119977748952806, + "primed_first_burst": { + "aggregate_decode_tps": 50.32740826046728, + "batch_wall_s": 5.179258568910882, + "median_per_stream_decode_tps": 50.32740826046728, + "median_ttft_s": 0.1109816120006144, + "slowest_ttft_s": 0.1109816120006144 + }, + "uncached_first_use": { + "decode_tps": 50.11002847610702, + "full_response_s": 5.211056388914585, + "ttft_s": 0.121828100993298 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 50.19886712652733, + "batch_wall_s": 5.19728748803027, + "median_per_stream_decode_tps": 50.19886712652733, + "median_ttft_s": 0.11622016096953303, + "slowest_ttft_s": 0.11622016096953303 + } + }, + "stock": { + "all_three_mean": { + "aggregate_decode_tps": 49.42762875839565, + "batch_wall_s": 5.292608786296721, + "median_per_stream_decode_tps": 49.42762875839565, + "median_ttft_s": 0.1334925233386457, + "slowest_ttft_s": 0.1334925233386457 + }, + "bursts": [ + { + "aggregate_decode_tps": 49.44678810339943, + "batch_wall_s": 5.286568304989487, + "median_per_stream_decode_tps": 49.44678810339943, + "median_ttft_s": 0.1294662430882454, + "slowest_ttft_s": 0.1294662430882454 + }, + { + "aggregate_decode_tps": 49.38695027655718, + "batch_wall_s": 5.294021509937011, + "median_per_stream_decode_tps": 49.38695027655718, + "median_ttft_s": 0.13063190993852913, + "slowest_ttft_s": 0.13063190993852913 + }, + { + "aggregate_decode_tps": 49.44914789523035, + "batch_wall_s": 5.297236543963663, + "median_per_stream_decode_tps": 49.44914789523035, + "median_ttft_s": 0.14037941698916256, + "slowest_ttft_s": 0.14037941698916256 + } + ], + "max_three_slowest_ttft_s": 0.14037941698916256, + "primed_first_burst": { + "aggregate_decode_tps": 49.44678810339943, + "batch_wall_s": 5.286568304989487, + "median_per_stream_decode_tps": 49.44678810339943, + "median_ttft_s": 0.1294662430882454, + "slowest_ttft_s": 0.1294662430882454 + }, + "uncached_first_use": { + "decode_tps": 49.44005471772643, + "full_response_s": 5.289737061946653, + "ttft_s": 0.13193224498536438 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 49.41804908589376, + "batch_wall_s": 5.295629026950337, + "median_per_stream_decode_tps": 49.41804908589376, + "median_ttft_s": 0.13550566346384585, + "slowest_ttft_s": 0.13550566346384585 + } + } + }, + "chat_16": { + "candidate": { + "all_three_mean": { + "aggregate_decode_tps": 295.62009127010816, + "batch_wall_s": 13.810649501353813, + "median_per_stream_decode_tps": 18.680509974081563, + "median_ttft_s": 0.15274572948692366, + "slowest_ttft_s": 0.15490875637624413 + }, + "bursts": [ + { + "aggregate_decode_tps": 294.7312140254254, + "batch_wall_s": 13.852497439016588, + "median_per_stream_decode_tps": 18.695992236946893, + "median_ttft_s": 0.20596840197686106, + "slowest_ttft_s": 0.20910074503626674 + }, + { + "aggregate_decode_tps": 295.60197585716986, + "batch_wall_s": 13.807091141003184, + "median_per_stream_decode_tps": 18.64406296396071, + "median_ttft_s": 0.12503432150697336, + "slowest_ttft_s": 0.12684975808952004 + }, + { + "aggregate_decode_tps": 296.5270839277292, + "batch_wall_s": 13.772359924041666, + "median_per_stream_decode_tps": 18.70147472133708, + "median_ttft_s": 0.12723446497693658, + "slowest_ttft_s": 0.1287757660029456 + } + ], + "max_three_slowest_ttft_s": 0.20910074503626674, + "primed_first_burst": { + "aggregate_decode_tps": 294.7312140254254, + "batch_wall_s": 13.852497439016588, + "median_per_stream_decode_tps": 18.695992236946893, + "median_ttft_s": 0.20596840197686106, + "slowest_ttft_s": 0.20910074503626674 + }, + "uncached_first_use": { + "decode_tps": 49.46169356000755, + "full_response_s": 5.319703722954728, + "ttft_s": 0.16415211092680693 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 296.0645298924495, + "batch_wall_s": 13.789725532522425, + "median_per_stream_decode_tps": 18.672768842648896, + "median_ttft_s": 0.12613439324195497, + "slowest_ttft_s": 0.12781276204623282 + } + }, + "python": { + "all_three_mean": { + "aggregate_decode_tps": 304.5884668310455, + "batch_wall_s": 13.638131504684376, + "median_per_stream_decode_tps": 19.04145680557064, + "median_ttft_s": 0.22615578568850955, + "slowest_ttft_s": 0.2283280163537711 + }, + "bursts": [ + { + "aggregate_decode_tps": 305.860735321517, + "batch_wall_s": 13.572097233030945, + "median_per_stream_decode_tps": 19.121748279684198, + "median_ttft_s": 0.21404798608273268, + "slowest_ttft_s": 0.21682169009000063 + }, + { + "aggregate_decode_tps": 304.47733604691, + "batch_wall_s": 13.659275179030374, + "median_per_stream_decode_tps": 19.034165179416313, + "median_ttft_s": 0.24240608396939933, + "slowest_ttft_s": 0.24356432200875133 + }, + { + "aggregate_decode_tps": 303.4273291247095, + "batch_wall_s": 13.68302210199181, + "median_per_stream_decode_tps": 18.96845695761141, + "median_ttft_s": 0.22201328701339662, + "slowest_ttft_s": 0.2245980369625613 + } + ], + "max_three_slowest_ttft_s": 0.24356432200875133, + "primed_first_burst": { + "aggregate_decode_tps": 305.860735321517, + "batch_wall_s": 13.572097233030945, + "median_per_stream_decode_tps": 19.121748279684198, + "median_ttft_s": 0.21404798608273268, + "slowest_ttft_s": 0.21682169009000063 + }, + "uncached_first_use": { + "decode_tps": 50.11002847610702, + "full_response_s": 5.211056388914585, + "ttft_s": 0.121828100993298 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 303.95233258580976, + "batch_wall_s": 13.671148640511092, + "median_per_stream_decode_tps": 19.00131106851386, + "median_ttft_s": 0.23220968549139798, + "slowest_ttft_s": 0.23408117948565632 + } + }, + "stock": { + "all_three_mean": { + "aggregate_decode_tps": 284.9573268420544, + "batch_wall_s": 14.451599716364095, + "median_per_stream_decode_tps": 18.737098711504476, + "median_ttft_s": 0.8372534696439592, + "slowest_ttft_s": 0.8400486150057986 + }, + "bursts": [ + { + "aggregate_decode_tps": 285.9178847771426, + "batch_wall_s": 14.405900189070962, + "median_per_stream_decode_tps": 18.803673839640854, + "median_ttft_s": 0.8393550855107605, + "slowest_ttft_s": 0.8433394399471581 + }, + { + "aggregate_decode_tps": 284.6789486672785, + "batch_wall_s": 14.465742636006325, + "median_per_stream_decode_tps": 18.739980600964433, + "median_ttft_s": 0.8555932089802809, + "slowest_ttft_s": 0.8568717130692676 + }, + { + "aggregate_decode_tps": 284.27514708174203, + "batch_wall_s": 14.483156324014999, + "median_per_stream_decode_tps": 18.667641693908138, + "median_ttft_s": 0.816812114440836, + "slowest_ttft_s": 0.8199346920009702 + } + ], + "max_three_slowest_ttft_s": 0.8568717130692676, + "primed_first_burst": { + "aggregate_decode_tps": 285.9178847771426, + "batch_wall_s": 14.405900189070962, + "median_per_stream_decode_tps": 18.803673839640854, + "median_ttft_s": 0.8393550855107605, + "slowest_ttft_s": 0.8433394399471581 + }, + "uncached_first_use": { + "decode_tps": 49.44005471772643, + "full_response_s": 5.289737061946653, + "ttft_s": 0.13193224498536438 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 284.4770478745103, + "batch_wall_s": 14.474449480010662, + "median_per_stream_decode_tps": 18.703811147436284, + "median_ttft_s": 0.8362026617105585, + "slowest_ttft_s": 0.8384032025351189 + } + } + }, + "code_1": { + "candidate": { + "all_three_mean": { + "aggregate_decode_tps": 69.59713588598078, + "batch_wall_s": 3.669221031013876, + "median_per_stream_decode_tps": 69.59713588598078, + "median_ttft_s": 0.0052389139697576565, + "slowest_ttft_s": 0.0052389139697576565 + }, + "bursts": [ + { + "aggregate_decode_tps": 69.60973560490154, + "batch_wall_s": 3.6724140100413933, + "median_per_stream_decode_tps": 69.60973560490154, + "median_ttft_s": 0.009098284994252026, + "slowest_ttft_s": 0.009098284994252026 + }, + { + "aggregate_decode_tps": 69.5278153956902, + "batch_wall_s": 3.670958764036186, + "median_per_stream_decode_tps": 69.5278153956902, + "median_ttft_s": 0.003326411941088736, + "slowest_ttft_s": 0.003326411941088736 + }, + { + "aggregate_decode_tps": 69.65385665735059, + "batch_wall_s": 3.664290318964049, + "median_per_stream_decode_tps": 69.65385665735059, + "median_ttft_s": 0.0032920449739322066, + "slowest_ttft_s": 0.0032920449739322066 + } + ], + "max_three_slowest_ttft_s": 0.009098284994252026, + "primed_first_burst": { + "aggregate_decode_tps": 69.60973560490154, + "batch_wall_s": 3.6724140100413933, + "median_per_stream_decode_tps": 69.60973560490154, + "median_ttft_s": 0.009098284994252026, + "slowest_ttft_s": 0.009098284994252026 + }, + "uncached_first_use": { + "decode_tps": 69.68209806744301, + "full_response_s": 3.8033633729210123, + "ttft_s": 0.14384809497278184 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 69.59083602652039, + "batch_wall_s": 3.6676245415001176, + "median_per_stream_decode_tps": 69.59083602652039, + "median_ttft_s": 0.0033092284575104713, + "slowest_ttft_s": 0.0033092284575104713 + } + }, + "python": { + "all_three_mean": { + "aggregate_decode_tps": 67.90241662606549, + "batch_wall_s": 3.8711393363385773, + "median_per_stream_decode_tps": 67.90241662606549, + "median_ttft_s": 0.11473353195469826, + "slowest_ttft_s": 0.11473353195469826 + }, + "bursts": [ + { + "aggregate_decode_tps": 67.80201579807485, + "batch_wall_s": 3.8830671519972384, + "median_per_stream_decode_tps": 67.80201579807485, + "median_ttft_s": 0.12151910294778645, + "slowest_ttft_s": 0.12151910294778645 + }, + { + "aggregate_decode_tps": 67.90787877889488, + "batch_wall_s": 3.867010178975761, + "median_per_stream_decode_tps": 67.90787877889488, + "median_ttft_s": 0.11116309091448784, + "slowest_ttft_s": 0.11116309091448784 + }, + { + "aggregate_decode_tps": 67.99735530122675, + "batch_wall_s": 3.863340678042732, + "median_per_stream_decode_tps": 67.99735530122675, + "median_ttft_s": 0.1115184020018205, + "slowest_ttft_s": 0.1115184020018205 + } + ], + "max_three_slowest_ttft_s": 0.12151910294778645, + "primed_first_burst": { + "aggregate_decode_tps": 67.80201579807485, + "batch_wall_s": 3.8830671519972384, + "median_per_stream_decode_tps": 67.80201579807485, + "median_ttft_s": 0.12151910294778645, + "slowest_ttft_s": 0.12151910294778645 + }, + "uncached_first_use": { + "decode_tps": 66.69242710043252, + "full_response_s": 4.028868215973489, + "ttft_s": 0.20428292406722903 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 67.95261704006082, + "batch_wall_s": 3.8651754285092466, + "median_per_stream_decode_tps": 67.95261704006082, + "median_ttft_s": 0.11134074645815417, + "slowest_ttft_s": 0.11134074645815417 + } + }, + "stock": { + "all_three_mean": { + "aggregate_decode_tps": 68.49916960823467, + "batch_wall_s": 3.8519730963356174, + "median_per_stream_decode_tps": 68.49916960823467, + "median_ttft_s": 0.12852425900443146, + "slowest_ttft_s": 0.12852425900443146 + }, + "bursts": [ + { + "aggregate_decode_tps": 69.174004623681, + "batch_wall_s": 3.8151158089749515, + "median_per_stream_decode_tps": 69.174004623681, + "median_ttft_s": 0.12870698398910463, + "slowest_ttft_s": 0.12870698398910463 + }, + { + "aggregate_decode_tps": 69.1720748582593, + "batch_wall_s": 3.8141463570063934, + "median_per_stream_decode_tps": 69.1720748582593, + "median_ttft_s": 0.12763628899119794, + "slowest_ttft_s": 0.12763628899119794 + }, + { + "aggregate_decode_tps": 67.1514293427637, + "batch_wall_s": 3.9266571230255067, + "median_per_stream_decode_tps": 67.1514293427637, + "median_ttft_s": 0.12922950403299183, + "slowest_ttft_s": 0.12922950403299183 + } + ], + "max_three_slowest_ttft_s": 0.12922950403299183, + "primed_first_burst": { + "aggregate_decode_tps": 69.174004623681, + "batch_wall_s": 3.8151158089749515, + "median_per_stream_decode_tps": 69.174004623681, + "median_ttft_s": 0.12870698398910463, + "slowest_ttft_s": 0.12870698398910463 + }, + "uncached_first_use": { + "decode_tps": 69.24770626013763, + "full_response_s": 3.831081417039968, + "ttft_s": 0.14858536096289754 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 68.1617521005115, + "batch_wall_s": 3.87040174001595, + "median_per_stream_decode_tps": 68.1617521005115, + "median_ttft_s": 0.12843289651209489, + "slowest_ttft_s": 0.12843289651209489 + } + } + }, + "code_16": { + "candidate": { + "all_three_mean": { + "aggregate_decode_tps": 399.6795928318214, + "batch_wall_s": 10.213571133324876, + "median_per_stream_decode_tps": 25.408943613718478, + "median_ttft_s": 0.17424606118584052, + "slowest_ttft_s": 0.17552311427425593 + }, + "bursts": [ + { + "aggregate_decode_tps": 398.4001914172669, + "batch_wall_s": 10.248124929028563, + "median_per_stream_decode_tps": 25.566465630469917, + "median_ttft_s": 0.26997348002623767, + "slowest_ttft_s": 0.27124968997668475 + }, + { + "aggregate_decode_tps": 400.9244153142096, + "batch_wall_s": 10.18100266798865, + "median_per_stream_decode_tps": 25.37154071762336, + "median_ttft_s": 0.1269808280048892, + "slowest_ttft_s": 0.12793347192928195 + }, + { + "aggregate_decode_tps": 399.7141717639878, + "batch_wall_s": 10.211585802957416, + "median_per_stream_decode_tps": 25.288824493062158, + "median_ttft_s": 0.1257838755263947, + "slowest_ttft_s": 0.1273861809168011 + } + ], + "max_three_slowest_ttft_s": 0.27124968997668475, + "primed_first_burst": { + "aggregate_decode_tps": 398.4001914172669, + "batch_wall_s": 10.248124929028563, + "median_per_stream_decode_tps": 25.566465630469917, + "median_ttft_s": 0.26997348002623767, + "slowest_ttft_s": 0.27124968997668475 + }, + "uncached_first_use": { + "decode_tps": 69.68209806744301, + "full_response_s": 3.8033633729210123, + "ttft_s": 0.14384809497278184 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 400.3192935390987, + "batch_wall_s": 10.196294235473033, + "median_per_stream_decode_tps": 25.33018260534276, + "median_ttft_s": 0.12638235176564194, + "slowest_ttft_s": 0.12765982642304152 + } + }, + "python": { + "all_three_mean": { + "aggregate_decode_tps": 393.30902359466165, + "batch_wall_s": 10.636888062620224, + "median_per_stream_decode_tps": 24.59067918028176, + "median_ttft_s": 0.24691123115674904, + "slowest_ttft_s": 0.24920557668277374 + }, + "bursts": [ + { + "aggregate_decode_tps": 391.54846728927964, + "batch_wall_s": 10.736570656998083, + "median_per_stream_decode_tps": 24.47938607275875, + "median_ttft_s": 0.2972130220150575, + "slowest_ttft_s": 0.3007223460590467 + }, + { + "aggregate_decode_tps": 394.67734873430715, + "batch_wall_s": 10.5699442649493, + "median_per_stream_decode_tps": 24.679377333073038, + "median_ttft_s": 0.217286629951559, + "slowest_ttft_s": 0.21892027102876455 + }, + { + "aggregate_decode_tps": 393.70125476039823, + "batch_wall_s": 10.604149265913293, + "median_per_stream_decode_tps": 24.613274135013494, + "median_ttft_s": 0.22623404150363058, + "slowest_ttft_s": 0.22797411296050996 + } + ], + "max_three_slowest_ttft_s": 0.3007223460590467, + "primed_first_burst": { + "aggregate_decode_tps": 391.54846728927964, + "batch_wall_s": 10.736570656998083, + "median_per_stream_decode_tps": 24.47938607275875, + "median_ttft_s": 0.2972130220150575, + "slowest_ttft_s": 0.3007223460590467 + }, + "uncached_first_use": { + "decode_tps": 66.69242710043252, + "full_response_s": 4.028868215973489, + "ttft_s": 0.20428292406722903 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 394.1893017473527, + "batch_wall_s": 10.587046765431296, + "median_per_stream_decode_tps": 24.646325734043266, + "median_ttft_s": 0.2217603357275948, + "slowest_ttft_s": 0.22344719199463725 + } + }, + "stock": { + "all_three_mean": { + "aggregate_decode_tps": 378.07599523085395, + "batch_wall_s": 10.922121833039759, + "median_per_stream_decode_tps": 24.93427795369625, + "median_ttft_s": 0.6912026270098673, + "slowest_ttft_s": 0.6928221416892484 + }, + "bursts": [ + { + "aggregate_decode_tps": 378.44319363775037, + "batch_wall_s": 10.912026300095022, + "median_per_stream_decode_tps": 24.88441750782489, + "median_ttft_s": 0.6605449949856848, + "slowest_ttft_s": 0.6625718369614333 + }, + { + "aggregate_decode_tps": 374.3631794297214, + "batch_wall_s": 11.0277284020558, + "median_per_stream_decode_tps": 24.733083189033003, + "median_ttft_s": 0.7142909269896336, + "slowest_ttft_s": 0.715858718031086 + }, + { + "aggregate_decode_tps": 381.42161262509006, + "batch_wall_s": 10.826610796968453, + "median_per_stream_decode_tps": 25.185333164230855, + "median_ttft_s": 0.6987719590542838, + "slowest_ttft_s": 0.7000358700752258 + } + ], + "max_three_slowest_ttft_s": 0.715858718031086, + "primed_first_burst": { + "aggregate_decode_tps": 378.44319363775037, + "batch_wall_s": 10.912026300095022, + "median_per_stream_decode_tps": 24.88441750782489, + "median_ttft_s": 0.6605449949856848, + "slowest_ttft_s": 0.6625718369614333 + }, + "uncached_first_use": { + "decode_tps": 69.24770626013763, + "full_response_s": 3.831081417039968, + "ttft_s": 0.14858536096289754 + }, + "warm_repeated_mean": { + "aggregate_decode_tps": 377.89239602740577, + "batch_wall_s": 10.927169599512126, + "median_per_stream_decode_tps": 24.95920817663193, + "median_ttft_s": 0.7065314430219587, + "slowest_ttft_s": 0.7079472940531559 + } + } + } + }, + "process_order_expected": [ + "candidate", + "stock", + "python" + ], + "provenance_sha256": "966838354657c7b6c31fd0bc912cc561b584a818cf4ca65ce060708301dc985f", + "requests_per_arm": 104, + "source_report_sha256": { + "candidate": "5e6746c9c52e67ac43801927ba015c86601e9294ba453e667cc4395fadaf7876", + "python": "2b737254aa61a58e488023d30ab2e9802ba16130a4820dc869efe90962880b2a", + "stock": "26c9714b8d9807eaceb024d934151f2d6ed25e93e1996b0a570eed49044e93b4" + }, + "status_sha256": "3d54b21b1ba7e6acbf81dfffa7ad6b97269f9ff17609713997228b2bddc1041c", + "work_difference_counts": { + "python_candidate": 104, + "stock_candidate": 85 + } + } + }, + "schema": "pr608_three_way_independent_analysis_v1" +} diff --git a/validation/pr608-three-way/test_verify.py b/validation/pr608-three-way/test_verify.py new file mode 100644 index 000000000..e9d81294e --- /dev/null +++ b/validation/pr608-three-way/test_verify.py @@ -0,0 +1,108 @@ +"""Exercise fail-closed checks against the retained portable three-way evidence.""" +from __future__ import annotations + +import json +from pathlib import Path +import shutil +import tempfile +import unittest + +import verify + + +class EvidenceTests(unittest.TestCase): + """Copy only sanitized evidence, with no model or network dependencies.""" + + def setUp(self) -> None: + """Use the bundled valid evidence as each mutation's control.""" + self.temporary = tempfile.TemporaryDirectory() + self.addCleanup(self.temporary.cleanup) + self.root = Path(self.temporary.name) + source = Path(__file__).resolve().parent + for name in ('provenance.json', 'qualification.json', 'evidence-forward.json', + 'evidence-reverse.json', 'requests-forward.jsonl', 'requests-reverse.jsonl'): + shutil.copyfile(source / name, self.root / name) + + def change(self, field: str, value: object, *, cold: bool = False) -> None: + """Renew the file digest so tests reach the semantic gate.""" + path = self.root / 'requests-forward.jsonl' + rows = [json.loads(line) for line in path.read_text().splitlines()] + selected = next(record['request'] for record in rows + if record['arm'] == 'candidate' + and (record['phase'] == 'uncached_first_use') == cold) + selected[field] = value + path.write_text(''.join(json.dumps(record) + '\n' for record in rows)) + receipt_path = self.root / 'evidence-forward.json' + receipt = json.loads(receipt_path.read_text()) + receipt['requests']['sha256'] = verify.digest(path.read_bytes()) + receipt_path.write_text(json.dumps(receipt)) + + def test_valid_control(self) -> None: + """The complete control has all 104 requests per arm in both orders.""" + result = verify.analyse(self.root) + self.assertTrue(result['complete']) + self.assertEqual(set(result['orders']), {'forward', 'reverse'}) + self.assertTrue(all(order['requests_per_arm'] == 104 for order in result['orders'].values())) + + def test_first_use_output_mismatch(self) -> None: + """Uncached first-use output participates in strict three-way parity.""" + self.change('output_sha256', '0' * 64, cold=True) + with self.assertRaisesRegex(ValueError, 'parity drift'): + verify.analyse(self.root) + + def test_changed_decode_rate(self) -> None: + """The decode check uses actual output count and first/last clocks.""" + self.change('decode_tps', 1.0) + with self.assertRaisesRegex(ValueError, 'decode_tps arithmetic'): + verify.analyse(self.root) + + def test_cold_cache_mismatch(self) -> None: + """An uncached first use must carry observed cache count zero.""" + self.change('cached_tokens', 14, cold=True) + with self.assertRaisesRegex(ValueError, 'cache count'): + verify.analyse(self.root) + + def test_literal_body_hash(self) -> None: + """A rehashed envelope cannot hide an invalid literal-body digest.""" + self.change('request_body_sha256', '0' * 64) + with self.assertRaisesRegex(ValueError, 'body SHA'): + verify.analyse(self.root) + + def test_incomplete_response(self) -> None: + """Partial output cannot become a timing or throughput measurement.""" + self.change('complete', False) + with self.assertRaisesRegex(ValueError, 'incomplete request'): + verify.analyse(self.root) + + def test_missing_row(self) -> None: + """The panel requires its declared row count despite a valid digest.""" + path = self.root / 'requests-forward.jsonl' + path.write_text('\n'.join(path.read_text().splitlines()[:-1]) + '\n') + receipt_path = self.root / 'evidence-forward.json' + receipt = json.loads(receipt_path.read_text()) + receipt['requests']['sha256'] = verify.digest(path.read_bytes()) + receipt_path.write_text(json.dumps(receipt)) + with self.assertRaisesRegex(ValueError, '312-request'): + verify.analyse(self.root) + + def test_wrong_model(self) -> None: + """Model repository owner and revision are both part of provenance.""" + path = self.root / 'provenance.json' + receipt = json.loads(path.read_text()) + receipt['models'][0]['repo'] = 'TensorFold/Qwen3.8-27B-MLX-4bit' + path.write_text(json.dumps(receipt)) + with self.assertRaisesRegex(ValueError, 'model identity'): + verify.analyse(self.root) + + def test_wrong_flags(self) -> None: + """A mislabeled final or stock runtime policy fails closed.""" + path = self.root / 'provenance.json' + receipt = json.loads(path.read_text()) + receipt['flags']['candidate']['TF_PR608_EXACT_CACHE_SKIP_RESET'] = '0' + path.write_text(json.dumps(receipt)) + with self.assertRaisesRegex(ValueError, 'runtime flag'): + verify.analyse(self.root) + + +if __name__ == '__main__': + unittest.main() diff --git a/validation/pr608-three-way/verify.py b/validation/pr608-three-way/verify.py new file mode 100644 index 000000000..2387a5270 --- /dev/null +++ b/validation/pr608-three-way/verify.py @@ -0,0 +1,373 @@ +"""Reconstruct three-way metrics from sanitized portable request evidence.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import math +import statistics +from pathlib import Path +from typing import Any +from urllib.parse import urlparse + + +PROMPTS = { + "code": ("/v1/completions", "Write a short Python function that computes the Fibonacci sequence and explain it.", 14), + "chat": ("/v1/chat/completions", "Explain how matrix multiplication uses a GPU in plain English, then give a small numerical example.", 31), +} +ARMS = ("stock", "python", "candidate") +ORDERS = (("python", "stock", "candidate"), ("candidate", "stock", "python")) +PARAMETERS = { + "prompts": ["code", "chat"], "levels": [1, 16], "repetitions": 3, + "uncached_first_use_tokens": 256, "measured_tokens": 256, + "temperature": 0.0, "seed": 1234, +} + + +def require(condition: bool, message: str) -> None: + """Reject incomplete or inconsistent evidence.""" + if not condition: + raise ValueError(message) + + +def digest(value: bytes) -> str: + """Hash literal bytes.""" + return hashlib.sha256(value).hexdigest() + + +def expected_body(model: str, prompt: str) -> tuple[str, dict[str, Any]]: + """Build the fixed upstream greedy request without client imports.""" + route, text, _ = PROMPTS[prompt] + body: dict[str, Any] = { + "model": model, + "max_tokens": 256, + "temperature": 0.0, + "stream": True, + "stream_options": {"include_usage": True}, + "ignore_eos": True, + "seed": 1234, + } + if prompt == "chat": + body["messages"] = [{"role": "user", "content": text}] + body["chat_template_kwargs"] = {"enable_thinking": False} + else: + body["prompt"] = text + return route, body + + +def check_request(row: dict[str, Any], *, prompt: str, arm: str, cold: bool, model: str) -> None: + """Require literal request, usage, work, output and SSE clock evidence.""" + route, body = expected_body(model, prompt) + require(row.get("complete") is True and not row.get("error") and not row.get("unmeasured"), "incomplete request") + require(row.get("prompt") == prompt and row.get("seed") == 1234, "prompt/seed drift") + require(row.get("request_body") == body, "body drift") + require(row.get("request_body_sha256") == digest(json.dumps(body).encode()), "body SHA drift") + require(urlparse(row.get("request_url", "")).path == route, "route drift") + require(row.get("tokens") == 256 and row.get("finish_reason") == "length", "output length/finish drift") + prompt_n = PROMPTS[prompt][2] + cached = 0 if cold or arm == "stock" else prompt_n - 1 if arm == "python" else prompt_n + usage = row.get("usage") or {} + details = usage.get("prompt_tokens_details") or {} + require((row.get("prompt_tokens"), usage.get("prompt_tokens"), usage.get("completion_tokens")) + == (prompt_n, prompt_n, 256), "token usage drift") + require((row.get("cached_tokens"), details.get("cached_tokens")) == (cached, cached), "cache count drift") + require(row.get("cache_state") == ("reused" if cached else "cold"), "cache state drift") + require(isinstance(row.get("response_id"), str) and row["response_id"], "response ID missing") + for field, lengths in (("output_sha256", {64}), ("token_sha", {12, 64})): + value = row.get(field) + require(isinstance(value, str) and len(value) in lengths + and all(c in "0123456789abcdef" for c in value), f"{field} missing") + runtime = row.get("runtime") or {} + require(runtime.get("token_sha") == row["token_sha"], "runtime token SHA drift") + raw_work = row.get("speculative") or runtime + work = row.get("work") or {} + require(row.get("work_source") == ("speculative" if row.get("speculative") else "tensorfold"), "work origin drift") + require(work == {key: raw_work.get(key) for key in ("rounds", "accepted", "drafted")}, "work raw drift") + require(all(type(work.get(key)) is int and work[key] >= 0 for key in ("rounds", "accepted", "drafted")) + and work["rounds"] > 0 and work["accepted"] <= work["drafted"], "invalid work") + clocks = [row.get(key) for key in ("sent", "first", "last", "done")] + require(all(type(value) in (int, float) and math.isfinite(value) for value in clocks), "clock missing") + sent, first, last, done = clocks + require(sent < first < last <= done, "clock order drift") + pieces = row.get("pieces") + require(isinstance(pieces, list) and len(pieces) >= 4 + and pieces[0][0] == first and pieces[-1][0] == last, "SSE pieces missing") + previous = sent + for arrived, characters in pieces: + require(type(arrived) in (int, float) and math.isfinite(arrived) + and previous <= arrived <= done and type(characters) is int + and characters > 0, "SSE piece drift") + previous = arrived + for field, value in (("ttft_s", first - sent), ("full_response_s", done - sent), + ("decode_tps", 255 / (last - first))): + observed = row.get(field) + require(type(observed) in (int, float) and math.isclose(observed, value, rel_tol=1e-12), + f"{field} arithmetic drift") + + +def report_rows(report: dict[str, Any]) -> dict[tuple[str, int, int | None, int], dict[str, Any]]: + """Flatten one fresh process's cold first use and three warm bursts.""" + require(report.get("schema") == "pr608_three_way_http_v1" and report.get("complete") is True, "report incomplete") + require(report.get("parameters") == PARAMETERS, "parameters drift") + arm = report.get("label") + require(arm in ARMS, "arm label drift") + cells = report.get("cells") + require(isinstance(cells, list) and [cell.get("prompt") for cell in cells] == list(PROMPTS), "prompt order drift") + model = report.get("model") + require(isinstance(model, str) and model, "model missing") + rows: dict[tuple[str, int, int | None, int], dict[str, Any]] = {} + ids: set[str] = set() + for cell in cells: + prompt = cell["prompt"] + cold = cell.get("uncached_first_use") + require(isinstance(cold, dict), "uncached first use missing") + check_request(cold, prompt=prompt, arm=arm, cold=True, model=model) + rows[(prompt, 1, None, 0)] = cold + require(cold["response_id"] not in ids, "duplicate cold response ID") + ids.add(cold["response_id"]) + levels = cell.get("levels") + require(isinstance(levels, list) and [level.get("streams") for level in levels] == [1, 16], "levels drift") + for level in levels: + n = level["streams"] + bursts = level.get("bursts") + require(isinstance(bursts, list) and len(bursts) == 3, "burst count drift") + for b, burst in enumerate(bursts): + require(burst.get("index") == b, "burst index drift") + require(burst.get("phase") == ("primed_first_burst" if b == 0 else "repeat"), + "burst phase drift") + requests = burst.get("requests") + require(isinstance(requests, list) and len(requests) == n, "request count drift") + for i, row in enumerate(requests): + check_request(row, prompt=prompt, arm=arm, cold=False, model=model) + rows[(prompt, n, b, i)] = row + require(row["response_id"] not in ids, "duplicate response ID") + ids.add(row["response_id"]) + require(len(rows) == len(ids) == 104, "104-request panel drift") + require(all(row["sent"] > rows[("code", 1, None, 0)]["done"] + for key, row in rows.items() if key[0] == "code" and key[2] is not None), + "code cold request was not first") + require(rows[("chat", 1, None, 0)]["sent"] + > max(row["done"] for key, row in rows.items() if key[0] == "code"), + "chat first use did not follow code panel") + for prompt in PROMPTS: + previous = rows[(prompt, 1, None, 0)]["done"] + for n in (1, 16): + for b in range(3): + group = [rows[(prompt, n, b, i)] for i in range(n)] + require(min(row["sent"] for row in group) > previous, "burst ordering drift") + previous = max(row["done"] for row in group) + totals = report.get("health_totals") or {} + require(totals.get("requests") == 104 and totals.get("prompt_tokens") == 2340 + and totals.get("output_tokens") == 26624, "report aggregate drift") + return rows + + +def burst_metrics(rows: list[dict[str, Any]]) -> dict[str, float]: + """Compute client timing and decode metrics for one literal burst.""" + return { + "median_ttft_s": statistics.median(row["ttft_s"] for row in rows), + "slowest_ttft_s": max(row["ttft_s"] for row in rows), + "batch_wall_s": max(row["done"] for row in rows) - min(row["sent"] for row in rows), + "median_per_stream_decode_tps": statistics.median(row["decode_tps"] for row in rows), + "aggregate_decode_tps": sum(row["tokens"] - 1 for row in rows) + / (max(row["last"] for row in rows) - min(row["first"] for row in rows)), + } + + +def phase_metrics(rows: dict[tuple[str, int, int | None, int], dict[str, Any]], + prompt: str, n: int) -> dict[str, Any]: + """Separate uncached first use from primed first/repeated bursts.""" + cold = rows[(prompt, 1, None, 0)] + bursts = [burst_metrics([rows[(prompt, n, b, i)] for i in range(n)]) for b in range(3)] + fields = bursts[0].keys() + return { + "uncached_first_use": {key: cold[key] for key in ("ttft_s", "full_response_s", "decode_tps")}, + "bursts": bursts, + "primed_first_burst": bursts[0], + "warm_repeated_mean": {key: statistics.mean(b[key] for b in bursts[1:]) for key in fields}, + "all_three_mean": {key: statistics.mean(b[key] for b in bursts) for key in fields}, + "max_three_slowest_ttft_s": max(b["slowest_ttft_s"] for b in bursts), + } + + +def geometric_ratio(values: list[float]) -> float: + """Balance two within-order ratios without treating requests as replicates.""" + require(len(values) == 2 and all(value > 0 for value in values), "ratio count drift") + return math.sqrt(values[0] * values[1]) + + +def read_order(root: Path, label: str, expected: tuple[str, ...], + provenance: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]: + """Validate one derived receipt and reconstruct reports in memory.""" + receipt = json.loads((root / f"evidence-{label}.json").read_text()) + require(receipt.get("schema") == "pr608_three_way_public_order_v1" + and receipt.get("sanitized") is True and receipt.get("complete") is True, + "wrong or incomplete public receipt") + require(receipt["process_order"] == list(expected), "process order drift") + info = receipt["requests"] + require(info["file"] == f"requests-{label}.jsonl", "request file drift") + payload = (root / info["file"]).read_bytes() + require(digest(payload) == info["sha256"], "request file hash drift") + records = [json.loads(line) for line in payload.decode().splitlines()] + require(len(records) == info["count"] == 312, "312-request evidence drift") + require(set(receipt["reports"]) == set(ARMS), "arm inventory drift") + indexed = {arm: {} for arm in ARMS} + for record in records: + require(record.get("schema") == "pr608_three_way_public_request_v1", "request schema drift") + arm, prompt = record["arm"], record["prompt"] + n, burst, stream = record["streams"], record["burst"], record["stream"] + require(arm in ARMS and prompt in PROMPTS and type(n) is int and n in (1, 16) + and type(stream) is int and 0 <= stream < n, "request identity drift") + require((burst is None and n == 1 and stream == 0 + and record["phase"] == "uncached_first_use") or + (type(burst) is int and burst in (0, 1, 2) + and record["phase"] == ("primed_first_burst" if burst == 0 else "repeat")), + "request phase drift") + key = (prompt, n, burst, stream) + require(key not in indexed[arm], "duplicate request slot") + row = record["request"] + require("request_url" not in row and row["request_path"] == PROMPTS[prompt][0], + "unsanitized or incorrect route") + indexed[arm][key] = dict(row, request_url=row["request_path"]) + reports = {} + for arm in ARMS: + meta = receipt["reports"][arm] + require(meta["source_sha256"] == provenance["tested_client_source_sha256"], + "tested client source drift") + cells = [] + for prompt in PROMPTS: + cell = {"prompt": prompt, "uncached_first_use": indexed[arm].get((prompt, 1, None, 0)), + "levels": []} + for n in (1, 16): + bursts = [{"index": b, "phase": "primed_first_burst" if b == 0 else "repeat", + "requests": [indexed[arm].get((prompt, n, b, i)) for i in range(n)]} + for b in range(3)] + require(all(row is not None for burst in bursts for row in burst["requests"]), + "missing primed request") + cell["levels"].append({"streams": n, "bursts": bursts}) + cells.append(cell) + reports[arm] = {"schema": "pr608_three_way_http_v1", "complete": True, + "label": arm, "model": meta["model"], "parameters": meta["parameters"], + "health_totals": meta["health_totals"], "source_sha256": meta["source_sha256"], + "cells": cells} + return receipt, reports + + +def analyse(root: Path, source_root: Path | None = None) -> dict[str, Any]: + """Check all 624 rows and reproduce the independent metric definitions.""" + provenance = json.loads((root / "provenance.json").read_text()) + require(provenance["schema"] == "pr608_three_way_public_provenance_v1" + and provenance["sanitized"] is True, "provenance drift") + require(provenance["stock_binary_sha256"] == + "73a0e0434ce5adf3031a22fe2a70cbc9c671150464e4a6ecc4016b8defc12c8d" + and provenance["native_binary_sha256"] == + "469b917ca87959fbf3f38964cd91388da433e1395a5773556560d4982fc7d761", "binary identity drift") + require(provenance["models"] == [ + {"name": "target", "repo": "Vontra/Qwen3.8-27B-MLX-4bit", + "revision": "70ae7fac63274ff2eac54152031433374cb80f2f"}, + {"name": "drafter", "repo": "z-lab/Qwen3.8-27B-DFlash2", + "revision": "50307d4c4cde6860d4eee73e2547cd786fe8e8a4"}], "model identity drift") + expected_flags = {"TF_PR608_EXACT_PROMPT_CACHE", "TF_PR608_EXACT_CACHE_SEQ_REUSE", + "TF_PR608_EXACT_CACHE_LOGITS", "TF_PR608_EXACT_CACHE_DRAFT_REUSE", + "TF_PR608_EXACT_CACHE_SKIP_RESET"} + flags = provenance["flags"] + require(set(flags) == set(ARMS) and flags["python"] == {}, "arm flag inventory drift") + for arm in ("stock", "candidate"): + require(set(flags[arm]) == expected_flags and + set(flags[arm].values()) == {"1" if arm == "candidate" else "0"}, + "runtime flag values drift") + qualification = (root / "qualification.json").read_bytes() + require(digest(qualification) == provenance["qualification_sha256"] + and json.loads(qualification)["passed"] is True, "qualification attestation drift") + sources = provenance["source_sha256"] + require(len(sources) == provenance["source_count"] == 19, "runtime source count drift") + if source_root is not None: + for name, expected_hash in sources.items(): + require(name.startswith("zig/src/families/qwen27/cuda/") + and ".." not in Path(name).parts, "unsafe source path") + require(digest((source_root / name).read_bytes()) == expected_hash, "runtime source changed") + orders: dict[str, Any] = {} + for label, expected in (("forward", ORDERS[0]), ("reverse", ORDERS[1])): + receipt, reports = read_order(root, label, expected, provenance) + rows = {arm: report_rows(report) for arm, report in reports.items()} + require({report["model"] for report in reports.values()} == {"qwen27-pr608"}, "model alias drift") + for key in rows["stock"]: + bodies = {json.dumps(rows[arm][key]["request_body"], sort_keys=True) for arm in ARMS} + outputs = {(rows[arm][key]["output_sha256"], rows[arm][key]["token_sha"]) for arm in ARMS} + require(len(bodies) == len(outputs) == 1, f"three-arm parity drift: {key}") + results = {} + for prompt in PROMPTS: + for n in (1, 16): + key = f"{prompt}_{n}" + results[key] = {arm: phase_metrics(rows[arm], prompt, n) for arm in ARMS} + state = receipt["lifecycle_attestation"] + require(state.get("complete") is True and state.get("restored") is True + and state.get("all_jobs_passed") is True, "lifecycle attestation incomplete") + require(all(state["jobs"][arm]["passed"] is True for arm in ARMS), "arm attestation failed") + orders[label] = {"process_order_expected": list(expected), "requests_per_arm": 104, + "status_sha256": receipt["status_sha256"], + "provenance_sha256": receipt["provenance_sha256"], + "source_report_sha256": {arm: receipt["reports"][arm]["source_report_sha256"] for arm in ARMS}, + "work_difference_counts": { + "stock_candidate": sum(rows["stock"][key]["work"] != rows["candidate"][key]["work"] + for key in rows["stock"]), + "python_candidate": sum(rows["python"][key]["work"] != rows["candidate"][key]["work"] + for key in rows["stock"]), + }, "cells": results} + balanced = {} + for cell in orders["forward"]["cells"]: + balanced[cell] = {} + for arm in ARMS: + phases = [orders[o]["cells"][cell][arm] for o in orders] + values = {} + for name in ("uncached_first_use", "warm_repeated_mean", "all_three_mean"): + values[name] = {key: statistics.mean(p[name][key] for p in phases) + for key in phases[0][name]} + values["primed_first_burst"] = {key: statistics.mean(p["bursts"][0][key] for p in phases) + for key in phases[0]["bursts"][0]} + values["max_three_slowest_ttft_s"] = statistics.mean(p["max_three_slowest_ttft_s"] for p in phases) + balanced[cell][arm] = values + for other in ("stock", "python"): + ratio = {} + for name, field in (("uncached_first_use", "ttft_s"), + ("uncached_first_use", "full_response_s"), + ("primed_first_burst", "median_ttft_s"), + ("warm_repeated_mean", "median_ttft_s"), + ("warm_repeated_mean", "median_per_stream_decode_tps"), + ("warm_repeated_mean", "aggregate_decode_tps"), + ("warm_repeated_mean", "batch_wall_s"), + ("all_three_mean", "median_ttft_s")): + vals = [orders[o]["cells"][cell]["candidate"][name][field] + / orders[o]["cells"][cell][other][name][field] for o in orders] + ratio[f"{name}.{field}"] = geometric_ratio(vals) + vals = [orders[o]["cells"][cell]["candidate"]["max_three_slowest_ttft_s"] + / orders[o]["cells"][cell][other]["max_three_slowest_ttft_s"] for o in orders] + ratio["max_three_slowest_ttft_s"] = geometric_ratio(vals) + balanced[cell][f"candidate_to_{other}_geometric_ratio"] = ratio + return {"schema": "pr608_three_way_independent_analysis_v1", "complete": True, + "orders": orders, "balanced": balanced, + "limits": ["Cold here means no cached prompt tokens after server readiness, not model startup time.", + "Code is first request in each process; chat first-use follows code traffic.", + "Bursts share a process and their requests are correlated; two orders are not confidence intervals.", + "Different speculative work is retained and does not invalidate literal output parity, but limits causal attribution."]} + + + +def main() -> None: + """Validate offline; optionally check the nineteen runtime source bytes.""" + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--root", type=Path, default=Path(__file__).resolve().parent) + parser.add_argument("--source-root", type=Path) + parser.add_argument("--output", type=Path) + args = parser.parse_args() + result = analyse(args.root, args.source_root) + rendered = json.dumps(result, indent=2, sort_keys=True, allow_nan=False) + "\n" + if args.output: + args.output.write_text(rendered) + else: + print(rendered, end="") + + +if __name__ == "__main__": + main()