Fix review: H-L9-01 and H-L9-03 (internal/sfu)

From mnema-talk v3.3.13, rendered on this site.

Reviewer: phase 3, read-only. I wrote neither the findings nor the fixes. Nothing was changed, committed or pushed in the repository; temporary worktrees (removed afterwards) and probe test files inside them (deleted before removal).

FixBranch, commit (on lane 9 test state e6e84cfcd)Verdict
H-L9-01msch128/fix-h-l9-01, c7ad16daa fix: keep the SFU's stored times on the monotonic clockMERGE
H-L9-03msch128/fix-h-l9-03, fdc2212c5 fix: continue a layer switch after the newest numbers sentMERGE AFTER FIXES (one SHOULD-FIX test; no blocker)

The two branches merge cleanly (doc/architecture.md auto-merged, the two paragraphs are in different sections), and the merged state passes everything listed under "What I ran".


H-L9-01: stored times on the monotonic clock

What the fix does

steadyNanos(t) = steadyStartUnix + int64(t.Sub(steadyStart)) (internal/sfu/layers.go:53-69), with steadyStart = time.Now() taken once at package load. For a t with a monotonic reading, Sub uses the monotonic readings, so the result moves only with the monotonic clock; for a t without one, Sub falls back to wall times and the result is exactly t.UnixNano(). The five fields (lastPLI, stoppedAt, lastPkt, the layer group's rateAt, resentAt) stay int64 / atomic.Int64, and every comparison site keeps its arithmetic. requestKeyframe, the stop and the resume read layerNow() instead of time.Now() (identical in production; the seam lets the tests step them).

Cause removed, for every variant?

Yes. The cause the finding and the refuter name is the stored form (UnixNano / time.Unix(0, x) dropping the monotonic reading). All five sites the finding lists (three measured, two "same pattern") are converted: room_tracks.go:58 and :255, room_attach.go:389, layer_viewers.go:104 and :161, layers.go:313, layer_wanted.go:82, nack_history.go:308 and :336.

Mixing of scales (the probe the lead asked for). A value would be on the wrong scale only if a time without a monotonic reading reached steadyNanos in production. I checked every caller:

  • Direct: steadyNanos(layerNow()) (requestKeyframe, stop, resume, layerGroup.write); layerNow() is time.Now() unless a test installs layerClock.
  • Through a now time.Time parameter: recent/flowing/resolveFlowing get layerNow() (viewer_track.go:92, :169, stalledLocked); sampleRates gets layerNow() (bandwidthSampleLocked) or the upload governor's now: time.Now (upload_limit_run.go:59, :149); find/mayResend/size get n.now(), which is time.Now (nack_responder.go:35-38).
  • No production file in internal/sfu calls Round, Truncate, AddDate, time.Date, UTC, In or Local (grep over every non-test file: no hits), and no value comes from JSON, the database or time.Unix.
  • Correction to the brief's premise: t.UTC(), t.In() and t.Local() do strip the monotonic reading (Go's time package documentation says so, and my probe measured it: steadyNanos(stepped) - steadyNanos(stepped.UTC()) = 1h0m0.000007s after a wall step of -1 h). This matters only if such a call is added later; today there is none on these paths. See NOTE 01-1.

Exported or logged values. None of the five fields is read outside the sites above (grep of the field names over all production files of the package): nothing in metrics, stats, logs or the API carries them. Their scale (unix nanoseconds at load, then monotonic) drifts away from the wall clock after a step; that is invisible and is documented in the steadyNanos comment.

Host suspend and resume. Go's monotonic clock does not advance while the host sleeps (Linux CLOCK_MONOTONIC; on macOS the clock Go reads also stops in sleep). Effect after the fix: a hold-off that was running at the moment of suspend continues after wake for the rest of its constant length, at most keyframeMinInterval (300 ms), resumeHoldoff (500 ms), the 1 s "flowing" window, the resend interval or rateEvery. Before the fix the wall clock jumped across the sleep and these expired at once. The new behaviour is bounded by the constants, matches every other time.Time timer in the package (adapter, ingress, upload governor) and Pion's own ICE timers, and has no lasting effect. Not measured on a sleeping host (I did not suspend this machine). NOTE only.

Zero and edge values: steadyNanos(now) - 0 is about 1.8e18, so a zero field still reads as "long ago" (resentAt checks 0 explicitly anyway). steadyNanos(time.Time{}) is -7.4e18, no overflow. Overflow would need a time more than about 230 years after the process started.

Spot-check of the author's table of other stored times (five)

All five are time.Time, written from a monotonic now, and compared with Sub/Before:

  • ingress.go:46-77 ingressBucket.last, windowStart: now is time.Now() (room_attach.go:352).
  • candidates.go:70, :183-186 warnWindow: now := time.Now().
  • upload_limit.go:45, :60-95 squeezeHoldUntil: governor's now is time.Now (upload_limit_run.go:59).
  • viewer_keyframe.go:13, :26 lastKeyAsk: layerNow(); reset to time.Time{} (reads as long ago, as intended).
  • nack_budget.go:46, :60-65 resendBudget.at: n.now() = time.Now. The only remaining wall-clock read is adapt_report.go:36 (t.Unix() for the NTP middle 32 bits of a receiver report), which is wall clock on purpose (RFC 3550 RTT).

The test helper (wallStepped, unsafe)

wallStepped reinterprets a copy of a time.Time as {wall uint64; ext int64; loc *Location} and moves the seconds field (bits 30..62 of wall) when the hasMonotonic bit is set. Is the self-check sound? Yes: checkWallStep asserts both that the monotonic difference is 0 and that the wall difference is exactly the step. Any layout change makes at least one of them wrong and the test fails, it never passes silently:

  • Mutation: an extra int64 field before wall in timeLayout (models a reordered struct). All eight tests FAIL with "wallStepped does not model a wall clock step: monotonic moved by 0s, wall by 0s".
  • A layout where the hasMonotonic bit moves: wallStepped returns the time unchanged, wall difference 0, check fails. A layout where the seconds field moves: the wall difference is not 1 h, check fails.
  • go vet and -race (checkptr) are clean. It is brittle against a toolchain change in the sense that such a change will turn these eight tests red until the helper is adapted, which is the right failure mode. A cleaner way without unsafe would need a production seam that reads the monotonic and the wall part separately (for example steadyNanos taking a monotonic duration from an injectable function). That adds production surface in a protected area for a test's sake; I do not ask for it. NOTE 01-2.

Revert check

steadyNanos replaced by return t.UnixNano() (the old semantics): all eight tests of clock_step_test.go FAIL (TestClockStepBackKeepsKeyframeRequests, ...ForwardKeepsTheKeyframeRateLimit, KeyframeRateLimitIgnoresASmallStepBack, ...BackResumesAStoppedCamera, ...ForwardKeepsTheResumeHoldoff, ...BackKeepsASilentLayerSilent, ...BackKeepsResends, ...BackKeepsMeasuringBitrates). With the fix all eight pass. They are normal tests (no build tag, no env gate).

Own situations (not in the tests)

  1. A step back of 7 s on a track that had just asked for a keyframe: the next two requests, each 320 ms apart, both reach the publisher (before the fix: refused for 7.3 s).
  2. Two steps: a camera stopped, wall clock +3 h, a late packet at once (stays stopped: holdoff kept), then -2 h, wait 550 ms, packet: resumes. Correct both ways.
  3. Scales: steadyNanos(now) - steadyNanos(wallStepped(now, -1h)) = 0 (stepped time on the monotonic scale); steadyNanos(now) - now.UnixNano() = 7 us at the start of the test process (ordinary wall-clock slew since load; no effect, only differences are compared).

Other checks

  • Behaviour beyond the finding: none in production (layerNow() is time.Now() there). Tests with a fake layerClock now also drive requestKeyframe, stop and resume: the whole package passes.
  • Hot path: one atomic pointer load (layerNow) more in requestKeyframe; layerGroup.write was already reading layerNow(). make bench-allocs: 0 allocs/op on all four forward benchmarks, ns/op equal to the base commit within noise (base 59 / 294 / 171 / 1939 ns, fix 53 / 281 / 168 / 1953 ns; machine at load 11 to 13, both far above the recorded baseline for that reason).
  • API: unexported only; doc/api-stability.md unaffected.
  • Gates: no allowlist, limit or test changed; layers.go 357 lines; gofmt, vet (with and without -tags=integration), complexity-check, internal/repo tests and the English check pass on the merge. Commit type fix:, no !.
  • Documentation: doc/architecture.md:387-391 states that the rate limit, the 500 ms hold-off, a layer's last packet, resends and bitrate measurements follow the monotonic clock. Matches the code.

Findings

  • NOTE 01-1 (layers.go:60-69): the "no monotonic reading gives UnixNano" fallback silently mixes scales if a future caller passes a time that went through Round(0), Truncate, UTC, In, Local, AddDate or a parse. Today no caller does. The comment could say "pass only readings of layerNow/time.Now". Not blocking.
  • NOTE 01-2 (clock_step_test.go:23-56): the unsafe helper is tied to the time.Time layout; the self-check fails loudly on a change. Acceptable as is.
  • NOTE 01-3: after host suspend the constant hold-offs (300 ms to 1 s) finish after wake instead of expiring during sleep. Bounded, harmless, same as every other timer in the package.

Verdict H-L9-01: MERGE.


H-L9-03: a layer switch continues after the newest numbers sent

What the fix does

sentNumbers (viewer_keyframe.go:70-118) keeps the newest sequence number and timestamp sent (serial comparison int16(a-b) > 0, int32(a-b) > 0). switchLocked (viewer_track.go:350-352) rebases on them instead of the last packet's. rebase also marks the newest number before the switch as base; writeLocked (viewer_track.go:333) drops a packet of the current layer whose outgoing number would be at or before base (fresh). The mark retires in note once a sent number is 16384 or more past base.

Serial-number comparison: my own table

Measured (seqNewer(a, b) and the reverse), for b in {0, 1, 100, 32767, 32768, 65534, 65535}:

a - b (mod 2^16)seqNewer(a, b)seqNewer(b, a)
0falsefalse
+1truefalse
-1falsetrue
+32767truefalse
+32768 = -32768falsefalse
-32767falsetrue
65535 -> 0seqNewer(0, 65535) trueseqNewer(65535, 0) false

Same for tsNewer with 2^31 (b in {0, 2^31, 2^32-1}; tsNewer(0, 0xffffffff) true). Correct RFC 1982 behaviour; the exact half-way point is "neither newer", which RFC 1982 leaves undefined and which only means note keeps the old maximum for a jump of exactly 32768. Mutating seqNewer to plain a > b fails the numbers test and seeds 1 and 5; tsNewer to a > b fails seed 1.

Outgoing space, numbering restarts

"Highest sent" is tracked in the outgoing space: note is called in sendPacketLocked with out.Header.SequenceNumber/Timestamp after the offsets were applied (viewer_track.go:317). Each layer has its own source space; the switch maps the new layer's keyframe to newest+1, so independent layer spaces are handled. A publisher that reconnects gets a new track and a new viewerTrack (fresh state). A resumed camera on the same transceiver keeps its SSRC and its numbering (browsers continue the sequence per SSRC), so no restart reaches this path from a browser.

A source discontinuity within the 16384 numbers after a switch (not producible by a browser, only by a modified client against its own viewers): measured, a backward jump of k source numbers right after a switch drops k-2 of the next k+5 packets (k = 100: 98 dropped; k = 5000: 4998; k = 30000: 29998). Before the fix these packets went out under numbers the viewer already held (or older), which its packet buffer drops as well, so the visible effect is the same. NOTE 03-3.

The new drop of late packets from before the keyframe

  • Needed by a decoder? No. Such a packet belongs to a frame of the new layer before the keyframe the viewer joined at; that frame references frames the viewer never got, so it can not be decoded. Confirmed in the code: the switch happens only at keyStart (a VP8 keyframe packet with the start bit, or an H.264 SPS/IDR start), so every packet of the keyframe itself has a source number at or after the switch packet and maps above base.
  • Repairs of the keyframe after the switch are delivered. Probe: layer 1 keyframe K, K+1 and K+2 lost, K+3, K+4, then repairs K+2, K+1, and K+1 again. Delivered: ... 105(K) 108 109 107 106 106: the repairs get their own numbers above the base, a duplicate repair keeps its number. A packet K-1 after that: dropped.
  • How long: measured, a pre-keyframe packet after 16380 newer packets is still dropped, after 16383 newer packets (the keyframe plus 16383 = 16384 numbers) it passes. After retirement such a packet would map to a number 16384 behind the newest, far outside a receiver's window (libwebrtc's packet buffer holds at most a few thousand), so it is harmless. The retirement is needed: without it the int16 comparison turns round after 32768 numbers.
  • Quick switches (own probe): layer 0 with a late packet, switch to 1 at its keyframe, a pre-keyframe packet of layer 1, switch to 2, an old packet of layer 1, switch back to 0 at a keyframe, a pre-keyframe packet of layer 0. Delivered sequence numbers 100 102 101 103 104 105, timestamps 0 6000 3000 6090 6270 6450: no reuse, every switch strictly after the newest number and timestamp.
  • The finding's minimal case (65533 K, 65535, 0, late 65534, switch to layer 2): delivered 65533 65535 0 65534 1 2 (before: ... 65534 65535 0).

Picture ID and TL0PICIDX (left continuing from the last packet forwarded)

When the last packet forwarded is a late one of an older frame (picture ID P-1 while P was already delivered), the new keyframe gets picture ID P and TL0PICIDX likewise: an ID the viewer already decoded. In libwebrtc (Chrome, Firefox and Safari use its receive path) the VP8 reference finder hands a keyframe off without references, and the frame buffer, for a frame whose ID is not newer than the last decoded one, accepts it when it is a keyframe with a newer RTP timestamp (it clears and restarts); otherwise it drops it. The fix makes the switch timestamp strictly newer than everything sent (measured above and asserted by the tests and the fuzz target), so the keyframe is accepted. This is from my reading of libwebrtc's source from memory, not measured in a browser, and the acceptance path is a legacy tolerance in libwebrtc rather than a guarantee. So: not a demonstrated remaining defect, but a latent weakness with a cheap remedy (keep the newest picture ID and TL0PICIDX the same way as the sequence number). The fuzz target pins the current behaviour (checkSwitch: picture ID = previous delivered + 1). NOTE 03-2, recommended as a follow-up.

H.264 and AV1: the SFU switches H.264 layers at an SPS or an IDR (layer_wanted.go:13-27); the sequence/timestamp base and the fresh drop are codec independent (sendPacketLocked/writeLocked), so H.264 gets the fix too; H.264 has no picture ID to rewrite. VP9 and AV1 are codecOther, forwarded as a single layer (keyStart only for layer 0), so only the drop after a re-attach applies to them, with the same reasoning.

NACK responder

Unchanged, and better off: the per-viewer resend history (nack_history.go) is filled with the outgoing packets, so before the fix a reused number overwrote the slot of the packet the viewer had under that number; now no number is given to two packets, and dropped stale packets never enter the history.

Tests and fuzz target

  • TestLatePacketBeforeASwitchReusesNoSequenceNumbers is a normal test now (400 cases, 171 late), and asserts both no duplicate and "newer than the newest sent" for numbers and timestamps.
  • FuzzViewerLayerRewrite's new invariants are the right ones: an independent owner map (no outgoing number for two different source packets), the switch at newest+1 with the timestamp moved by the elapsed ticks from the newest, every packet after a switch newer than everything before it, and an independent oracle for which late packets go through (stale uses source numbers against the keyframe's source number, not the implementation's out-space comparison).
  • Revert and mutation results (seeds run as normal tests, plus the numbers test):
    MutationResult
    viewer_track.go reverted to e6e84cfcdnumbers test FAIL, seeds 5, 6, 7 FAIL (author's claim confirmed)
    fresh check removedseed 7 FAIL
    seqNewer as a > bnumbers test, seeds 1 and 5 FAIL
    tsNewer as a > bseed 1 FAIL
    note keeps the last seq, not the newestnumbers test, seeds 5, 6 FAIL
    retire at once (>= 1)seed 7 FAIL
    note keeps the last timestamp, not the newestall seeds PASS; the fuzzer finds it in under 1 s ("timestamp moved -2820 ticks across a switch")
    retirement removed (if false)everything PASSES, fuzzer included (scripts are at most 4096 ops)
  • Fuzzing: 120 s with a fresh fuzz cache (not the author's) and four seeds of my own (start numbers 65530, 32765, 0, 65535; timestamps near 2^32 and 2^31; 7-bit and 15-bit picture IDs; scripts dense in hold/release and switch operations): 754178 executions, 81 new interesting inputs, no failure. My four seeds also pass as normal tests.

Findings

  • SHOULD-FIX 03-1 (viewer_keyframe.go:103-105, no test): the retirement of the stale-drop mark is untested, and it is load-bearing. With it removed every test and the fuzzer pass, but the stream stops: my probe sent 40000 in-order packets after a switch and only 32766 were delivered, then every packet was dropped (at about 100 packets per second, a share frozen for about 5.5 minutes after each switch until the numbers come round). The fuzz target can not reach it (fuzzMaxOps = 4096). Add a normal test: after a switch, more than 32768 in-order packets are all delivered, and a pre-keyframe packet is dropped before the retirement point.
  • NOTE 03-2 (viewer_track.go:365-377): picture ID and TL0PICIDX continue from the last packet forwarded, so after a late packet the new keyframe can reuse a picture ID the viewer decoded; it relies on libwebrtc accepting a keyframe with an older ID and newer timestamp, which this fix guarantees. Follow-up: track the newest picture ID and TL0PICIDX as for the sequence number (and adapt checkSwitch).
  • NOTE 03-3: a source numbering jump of k packets backwards within 16384 numbers after a switch drops those k packets; same receiver-visible effect as before the fix; not producible by a browser.
  • NOTE 03-4 (doc/architecture.md:441): the new sentence ends in an over-long line ("... dropped for the same reason. The sender declares the layers (webrtc_layers,"); cosmetic rewrap.
  • NOTE 03-5: viewer_track.go is at exactly 400 lines (the file limit); internal/repo passes, but the next change to this file has to move code out.

Other checks: no allowlist, limit or test weakened; gofmt, vet (with and without -tags=integration), complexity-check, internal/repo and the English check pass on the merge; unexported only (doc/api-stability.md unaffected); commit type fix:; make bench-allocs 0 allocs/op on all four forward benchmarks, ns/op equal to the H-L9-01 branch and the base within noise (53 / 290 / 168 / 1977 ns at load 13). No race: the new state lives in viewerTrack under vt.mu like the fields it replaces.

Verdict H-L9-03: MERGE AFTER FIXES: SHOULD-FIX 03-1 (a test for the mark's retirement). The production change itself is correct; NOTE 03-2 is recommended as a follow-up, not for this merge.


What I ran

All with nice -n 10, one heavy job at a time; load 8 to 15 during the session (benchmarks started below 12 or right at it).

  • go test -p 2 -race -count=1 ./internal/sfu/: c7ad16daa ok (78.9 s); fdc2212c5 ok (81.0 s); local merge of both ok (78.8 s), together with ./internal/repo ok.
  • make bench-allocs on e6e84cfcd, c7ad16daa, fdc2212c5 and the merge: 0 allocs/op everywhere.
  • gofmt -l, go vet with and without -tags=integration, make complexity-check, node scripts/check-english-only.mjs on the merge: clean.
  • The revert and mutation checks in the two sections above; probe tests for the own situations (deleted).
  • go test -fuzz FuzzViewerLayerRewrite -fuzztime 120s -parallel 2 with a fresh fuzz cache and own seeds.

What I did not check

  • Any effect in a real browser (no audio, camera or browser media on this machine); the libwebrtc behaviour for a repeated picture ID is from reading its source from memory.
  • A real host clock step or suspend; the step is modelled by the tests' wallStepped.
  • H-L9-02 (web client back-offs): not part of these fixes.
  • The NACK responder's own paths beyond reading where its history is filled.

Second round: H-L9-03, commit 4ea1feeb9 (on fdc2212c5)

Reviewed only fix: continue picture IDs after the newest sent and test the long run after a switch, after git fetch origin, in a temporary worktree (removed). Probe files deleted before removal.

03-1 (retirement untested): closed

New test TestAStreamFlowsLongAfterASwitch (numbers_switch_test.go:155-179): a switch, a late pre-keyframe packet of the new layer that must be dropped while the mark holds, then 40000 in-order packets, all of which must be delivered. The fuzz target gets a burst op (at most three runs of 20000 packets per script) and a new seed. With the retirement removed (if false): TestAStreamFlowsLongAfterASwitch FAILS, and so does FuzzViewerLayerRewrite/seed#10 (the long-run seed). With the retirement in place both pass.

03-2 (picture ID and TL0PICIDX): fixed

  • The move is clean. carryVP8OffsetsLocked and patchVP8Locked went from viewer_track.go to viewer_keyframe.go unchanged except for two things: they now read vt.sent.pic/vt.sent.tl0 instead of vt.lastPic/vt.lastTl0, and patchVP8Locked records through notePic (masks to the packet's width, as the old code did) and noteTl0 instead of assigning. The two fields are gone from viewerTrack. viewer_track.go now has 359 lines, viewer_keyframe.go 188.
  • picNewer: serial comparison within half the range of the width (63 for 7 bits, 16383 for 15 bits). noteTl0: int8 of the difference. Both are correct for wrap-around.
  • My own generated cases (3000; random widths per layer, picture IDs half of them within 8 of the 15-bit wrap, TL0PICIDX present on 3 of 4 layers, 0 to 4 late packets before the first switch, some repairs delivered twice, switches 0 -> 2 -> 1 -> 0): for the 1519 cases where all layers have the same width, no picture ID was delivered for two different frames, and every switch keyframe's TL0PICIDX was the newest earlier one + 1. As a negative control, the same probe on fdc2212c5 fails at case 10 ("picture ID 39 delivered for layer 2 and before for layer 0"), so it does detect the old behaviour.
  • TL0PICIDX with temporal layers on and off (own probe): layer 0 with TL0PICIDX, layer 1 with, layer 2 without, back to layer 0. The keyframe after the layer without TL0PICIDX continues after the newest TL0PICIDX seen before it (10 after 9): that layer does not reset it. A first TL0PICIDX after a stream that had none starts at 1, as before.
  • A switch between layers with different picture ID widths, and a stream that changes width: the newest ID is kept masked to the width of the last packet that set it, and the new layer continues from that number in its own width (measured: 15-bit 32753 -> 7-bit 116 -> 15-bit 119). This is unchanged from before (the old code masked the same way). libwebrtc always sends 15-bit IDs on every layer, so a browser does not produce it; NOTE R2-1.
  • Mutations (normal test run: the numbers test, the new test, the fuzz seeds and my probe):
    MutationResult
    retirement removedTestAStreamFlowsLongAfterASwitch, seed#10 FAIL
    picture ID keeps the last, not the newestnumbers test, my probe, seeds #8, #9 FAIL
    TL0PICIDX keeps the lastmy probe, seeds #8, #9 FAIL
    picNewer without the half-range boundnumbers test, my probe, seeds #8, #9 FAIL
    picNewer always 15 bits widemy probe, seeds #2, #6, #9 FAIL
    sequence number keeps the last (the original defect)numbers test, seeds #5, #6, #8, #9 FAIL

The fuzz checker's new owner rule

checkOwner now reports a number given to two different source packets only when the earlier delivery was fewer than 2^15 deliveries ago (it counts deliveries; the map always holds the latest owner of each number). A reuse caused by a switch lies a few packets apart, far inside that window. The last mutation in the table (the original defect, reintroduced) is still caught by the checker on the seeds. The rule exempts only reuse after half a turn of the counter, which the bursts make legitimate (40000+ packets). It hides no real duplicate.

Other checks

  • Commit message: it calls the long-run seed "seed 8" and the picture ID seeds "8 and 9". The test runner names them seed#10 and seed#8/#9 (zero-based; the lead counted 9 and 10). Cosmetic.
  • 03-4: the paragraph in doc/architecture.md is rewrapped and now names picture ID and TL0PICIDX. It matches the code. One line (447, 85 characters) is still over the wrap width, and viewer_keyframe.go:73 is a 102-character comment line; both cosmetic, NOTE R2-2.
  • 03-3 left as is with the reasoning I gave; agreed.
  • 03-5 resolved (viewer_track.go 359 lines).
  • go test -p 2 -race -count=1 ./internal/sfu/ on 4ea1feeb9: ok (78.0 s).
  • Fuzz 120 s with a fresh fuzz cache on five seeds of my own (three with burst ops; start numbers 65530, 32765, 0, 65535, 1000; 7-bit and 15-bit IDs near their wraps): 125559 executions (fewer per second than in round 1, because of the bursts), 69 new interesting inputs, no failure. My seeds also pass as normal tests.
  • make bench-allocs: 0 allocs/op on all four forward benchmarks. The 1-minute load reached 16 during this run, so ns/op (52 / 185 / 155 / 1143 ns) is not comparable; the allocation count does not depend on load.
  • Merge with origin/msch128/fix-h-l9-01 (still c7ad16daa): clean (doc auto-merged); gofmt clean; vet with and without -tags=integration clean; go test -race ./internal/sfu/ ./internal/repo/ ok; complexity-check and the English check pass.

Findings

  • NOTE R2-1: picture ID width changes between layers carry the newest ID masked to the old width; same as before the fix; a browser does not produce it.
  • NOTE R2-2: one 85-character line in doc/architecture.md:447 and a 102-character comment line at viewer_keyframe.go:73. Cosmetic.
  • NOTE R2-3: seed numbering in the commit message (cosmetic).

Second-round verdict H-L9-03 (fdc2212c5 + 4ea1feeb9): MERGE. 03-1 and 03-2 are closed, with no new defect.

Something wrong on this page? Tell us.