Display rolling-window throughput while a side is actively transferring

The displayed rate was averaged over the side's whole active window (stats start → last byte), which dilutes the streaming portion with the auth + ref-listing setup time before bytes start flowing. For a sync that spends ~3s on setup then streams a pack at 44 MB/s for 10s, the headline reads ~33 MB/s and only slowly drifts upward — much lower than what the user's network monitor reports.

Take a sample on every render tick and keep the last sampleCapacity (10 → ~2s at the default 200ms interval) per side. Compute the displayed rate from the oldest-vs-newest delta within that window, so the number tracks recent wire throughput instead of a session-wide average. Once a side goes idle (no bytes for >idleThreshold) or on the final frame, fall back to the active-window average — a stable post-transfer headline that won't jump around as the ring drains.

The end-of-run "throughput:" line still uses the active-window average (formatSide called with instantRate=0), which is the right summary for a completed sync.

Sessions

Changes

3

• internal/syncer

• Mprogress.go+106/-17

• Mprogress_test.go+97/-3

• Msyncer.go+4/-1

// cursor-up + erase-to-end-of-screen to overwrite the whole region in // place, so '\r'-terminated sideband updates from go-git read as a // single updating row instead of scrolling line by line. // // On every render we also push the current per-side byte total into a // short ring buffer (samples) so the displayed rate reflects recent // throughput rather than a session-wide average — the latter // undercounts the actual transfer rate because the divisor includes // auth and ref-listing time when no pack data is flowing. type progressReporter struct { out io.Writer stats *statsCollector done chan struct{}
mu sync.Mutex rowsDrawn int // rows currently occupying the live region lastLine string // last progress line, kept so setTransient can redraw without re-sampling transient string // current sideband-progress line, "" when none samples map[string]*sampleRing // per-side sliding window of recent (time, bytes) snapshots }

func newProgressReporter(out io.Writer, stats *statsCollector, interval time.Duration) *progressReporter { return &progressReporter{ out: out, stats: stats, done: make(chan struct{}), samples: map[string]*sampleRing{}, } }

// formatSide renders a single side as host + bytes + rate, with a flow // arrow positioned to indicate direction: source on the left of its // counter, target on the right of its counter. Sides with neither label // fall back to "name: bytes @ rate". func formatSide(side SideBytes, fallbackDur time.Duration, instantBytesPerSec float64, forceDone bool) string { name := side.Display if name == "" { name = side.Label } name = truncateHost(name, maxHostnameWidth)

rateDur := fallbackDur if side.ActiveNanos > 0 { rateDur = time.Duration(side.ActiveNanos) } rate := formatBytes(side.Bytes) + " @ " + formatRate(side.Bytes, rateDur)

done := side.Bytes > 0 && (forceDone || time.Duration(side.IdleNanos) >= idleThreshold)

var rateText string if !done && instantBytesPerSec > 0 { rateText = formatBytes(int64(instantBytesPerSec)) + "/s" } else { rateDur := fallbackDur if side.ActiveNanos > 0 { rateDur = time.Duration(side.ActiveNanos) } rateText = formatRate(side.Bytes, rateDur) }

rate := formatBytes(side.Bytes) + " @ " + rateText if done { rate += doneMark }

return rate }