513 lines
14 KiB
C#
513 lines
14 KiB
C#
using MoShiro.Protocol;
|
||
|
||
namespace MoShiro.Backend.Analysis;
|
||
|
||
public enum Dir
|
||
{
|
||
Up,
|
||
Down,
|
||
Total,
|
||
}
|
||
|
||
public enum GapOutput
|
||
{
|
||
Count,
|
||
MaxMs,
|
||
}
|
||
|
||
/// <summary>回显流（stream <c>msg</c>）的列：t1/t4 是 Probe 时钟，t2/t3 是 Agent 时钟；缺失的 t2 表示上行丢失，缺失的 t4 表示下行丢失。</summary>
|
||
internal readonly struct EchoColumns
|
||
{
|
||
public EchoColumns(RawStream stream)
|
||
{
|
||
Count = stream.Count;
|
||
Seq = stream.Find("seq");
|
||
T1 = stream.Find("t1");
|
||
T2 = stream.Find("t2");
|
||
T3 = stream.Find("t3");
|
||
T4 = stream.Find("t4");
|
||
}
|
||
|
||
public int Count { get; }
|
||
|
||
public RawColumn? Seq { get; }
|
||
|
||
public RawColumn? T1 { get; }
|
||
|
||
public RawColumn? T2 { get; }
|
||
|
||
public RawColumn? T3 { get; }
|
||
|
||
public RawColumn? T4 { get; }
|
||
|
||
public bool HasBasics => T1 is not null && T4 is not null;
|
||
|
||
/// <summary>行 i 的发送时刻（UTC 毫秒）。</summary>
|
||
public long SentUtcMs(ChunkView view, int i) => view.ColumnToUtcMs(T1!, T1!.Values[i]);
|
||
|
||
public bool IsUpLost(int i) => T2 is not null && !T2.IsValid(i);
|
||
|
||
public bool IsReplyLost(int i) => T4 is null || !T4.IsValid(i);
|
||
|
||
/// <summary>按到达时间（t4）排序后的行号，只含收到回复的行。</summary>
|
||
public int[] ArrivalOrder()
|
||
{
|
||
var rows = new List<int>(Count);
|
||
for (int i = 0; i < Count; i++)
|
||
{
|
||
if (!IsReplyLost(i))
|
||
{
|
||
rows.Add(i);
|
||
}
|
||
}
|
||
|
||
int[] order = [.. rows];
|
||
long[] keys = new long[order.Length];
|
||
for (int i = 0; i < order.Length; i++)
|
||
{
|
||
keys[i] = T4!.Values[order[i]];
|
||
}
|
||
|
||
Array.Sort(keys, order);
|
||
return order;
|
||
}
|
||
}
|
||
|
||
internal sealed class RttOp : MetricOp
|
||
{
|
||
public override string Signature => "rtt/1";
|
||
|
||
public override void Evaluate(ChunkView view, RawStream stream, IObservationSink sink)
|
||
{
|
||
var c = new EchoColumns(stream);
|
||
if (!c.HasBasics)
|
||
{
|
||
return;
|
||
}
|
||
|
||
for (int i = 0; i < c.Count; i++)
|
||
{
|
||
if (c.IsReplyLost(i) || !c.T1!.IsValid(i))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
long rttUs = c.T4!.Values[i] - c.T1.Values[i];
|
||
if (c.T2 is not null && c.T3 is not null && c.T2.IsValid(i) && c.T3.IsValid(i))
|
||
{
|
||
rttUs -= c.T3.Values[i] - c.T2.Values[i];
|
||
}
|
||
|
||
if (rttUs >= 0)
|
||
{
|
||
sink.Emit(c.SentUtcMs(view, i), rttUs / 1000.0);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 长尾回显：每个有回复的回显一个观测（是否"慢"）。阈值以同一个块（10 秒）里 RTT 的中位数为基线：
|
||
/// <c>max(1.8 × 基线, 基线 + max(15 ms, 0.35 × 基线))</c>。基线取自块内数据，所以每个观测只依赖自己所在的块，窗口合并仍然精确；
|
||
/// 块里的样本少于 <c>minSamples</c> 时基线不可靠，不产生观测。TCP 的长尾通常是丢包后的重传（RTT 聚在 RTO 附近）或队头阻塞。
|
||
/// </summary>
|
||
internal sealed class SlowShareOp : MetricOp
|
||
{
|
||
private readonly int _minSamples;
|
||
|
||
public SlowShareOp(int minSamples)
|
||
{
|
||
_minSamples = minSamples;
|
||
}
|
||
|
||
public override string Signature => $"slow_share/{_minSamples}/1";
|
||
|
||
public override void Evaluate(ChunkView view, RawStream stream, IObservationSink sink)
|
||
{
|
||
var c = new EchoColumns(stream);
|
||
if (!c.HasBasics)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var rtts = new List<(int Row, double Ms)>(c.Count);
|
||
for (int i = 0; i < c.Count; i++)
|
||
{
|
||
if (c.IsReplyLost(i) || !c.T1!.IsValid(i))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
long rttUs = c.T4!.Values[i] - c.T1.Values[i];
|
||
if (c.T2 is not null && c.T3 is not null && c.T2.IsValid(i) && c.T3.IsValid(i))
|
||
{
|
||
rttUs -= c.T3.Values[i] - c.T2.Values[i];
|
||
}
|
||
|
||
if (rttUs >= 0)
|
||
{
|
||
rtts.Add((i, rttUs / 1000.0));
|
||
}
|
||
}
|
||
|
||
if (rtts.Count < _minSamples)
|
||
{
|
||
return;
|
||
}
|
||
|
||
double[] sorted = [.. rtts.Select(r => r.Ms).Order()];
|
||
double baseline = sorted[sorted.Length / 2];
|
||
double threshold = Math.Max(baseline * 1.8, baseline + Math.Max(15, baseline * 0.35));
|
||
foreach ((int row, double ms) in rtts)
|
||
{
|
||
sink.Emit(c.SentUtcMs(view, row), ms >= threshold ? 1 : 0, 1);
|
||
}
|
||
}
|
||
}
|
||
|
||
internal sealed class LossOp : MetricOp
|
||
{
|
||
private readonly Dir _dir;
|
||
|
||
public LossOp(Dir dir)
|
||
{
|
||
_dir = dir;
|
||
}
|
||
|
||
public override string Signature => "loss/" + _dir + "/1";
|
||
|
||
public override void Evaluate(ChunkView view, RawStream stream, IObservationSink sink)
|
||
{
|
||
var c = new EchoColumns(stream);
|
||
if (!c.HasBasics || (_dir != Dir.Total && c.T2 is null))
|
||
{
|
||
return;
|
||
}
|
||
|
||
for (int i = 0; i < c.Count; i++)
|
||
{
|
||
if (!c.T1!.IsValid(i))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
switch (_dir)
|
||
{
|
||
case Dir.Up:
|
||
sink.Emit(c.SentUtcMs(view, i), c.IsUpLost(i) ? 1 : 0, 1);
|
||
break;
|
||
case Dir.Down:
|
||
// 只统计上行已经到达 Agent 的包：回复没回来就是下行丢失。
|
||
if (!c.IsUpLost(i))
|
||
{
|
||
sink.Emit(c.SentUtcMs(view, i), c.IsReplyLost(i) ? 1 : 0, 1);
|
||
}
|
||
|
||
break;
|
||
default:
|
||
sink.Emit(c.SentUtcMs(view, i), c.IsReplyLost(i) ? 1 : 0, 1);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>去除偏移和线性漂移后的单向时延变化：上行用 t2−t1，下行用 t4−t3。</summary>
|
||
internal sealed class OwdVarOp : MetricOp
|
||
{
|
||
private readonly Dir _dir;
|
||
|
||
public OwdVarOp(Dir dir)
|
||
{
|
||
_dir = dir;
|
||
}
|
||
|
||
public override string Signature => "owd_var/" + _dir + "/1";
|
||
|
||
public override void Evaluate(ChunkView view, RawStream stream, IObservationSink sink)
|
||
{
|
||
var c = new EchoColumns(stream);
|
||
RawColumn? a = _dir == Dir.Up ? c.T1 : c.T3;
|
||
RawColumn? b = _dir == Dir.Up ? c.T2 : c.T4;
|
||
if (c.T1 is null || a is null || b is null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var times = new List<double>(c.Count);
|
||
var delays = new List<double>(c.Count);
|
||
var utc = new List<long>(c.Count);
|
||
for (int i = 0; i < c.Count; i++)
|
||
{
|
||
if (!c.T1.IsValid(i) || !a.IsValid(i) || !b.IsValid(i))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
times.Add(c.T1.Values[i]);
|
||
delays.Add(b.Values[i] - a.Values[i]);
|
||
utc.Add(c.SentUtcMs(view, i));
|
||
}
|
||
|
||
JitterEmitter.Emit(times, delays, utc, sink);
|
||
}
|
||
}
|
||
|
||
internal static class JitterEmitter
|
||
{
|
||
public static void Emit(List<double> timesUs, List<double> delaysUs, List<long> utcMs, IObservationSink sink)
|
||
{
|
||
double[]? jitter = ClockDriftFit.Jitter([.. timesUs], [.. delaysUs]);
|
||
if (jitter is null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
for (int i = 0; i < jitter.Length; i++)
|
||
{
|
||
sink.Emit(utcMs[i], jitter[i] / 1000.0);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>连续丢失段的长度（按发送顺序）。</summary>
|
||
internal sealed class LossRunsOp : MetricOp
|
||
{
|
||
private readonly Dir _direction;
|
||
|
||
public LossRunsOp(Dir direction)
|
||
{
|
||
_direction = direction;
|
||
}
|
||
|
||
public override string Signature => $"loss_runs/{_direction}/2";
|
||
|
||
public override void Evaluate(ChunkView view, RawStream stream, IObservationSink sink)
|
||
{
|
||
var c = new EchoColumns(stream);
|
||
if (!c.HasBasics)
|
||
{
|
||
return;
|
||
}
|
||
|
||
int run = 0;
|
||
long runStart = 0;
|
||
for (int i = 0; i < c.Count; i++)
|
||
{
|
||
if (!c.T1!.IsValid(i))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
bool lost = _direction switch
|
||
{
|
||
Dir.Up => c.IsUpLost(i),
|
||
Dir.Down => !c.IsUpLost(i) && c.IsReplyLost(i),
|
||
_ => c.IsReplyLost(i),
|
||
};
|
||
if (lost)
|
||
{
|
||
if (run == 0)
|
||
{
|
||
runStart = c.SentUtcMs(view, i);
|
||
}
|
||
|
||
run++;
|
||
}
|
||
else if (run > 0)
|
||
{
|
||
sink.Emit(runStart, run);
|
||
run = 0;
|
||
}
|
||
}
|
||
|
||
if (run > 0)
|
||
{
|
||
sink.Emit(runStart, run);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>每个块一个最长连续丢包值；无丢包的有效块明确输出 0。</summary>
|
||
internal sealed class LossRunMaxOp(Dir direction) : MetricOp
|
||
{
|
||
public override string Signature => $"loss_run_max/{direction}/1";
|
||
|
||
public override void Evaluate(ChunkView view, RawStream stream, IObservationSink sink)
|
||
{
|
||
var c = new EchoColumns(stream);
|
||
if (!c.HasBasics || (direction != Dir.Total && c.T2 is null))
|
||
{
|
||
return;
|
||
}
|
||
|
||
int run = 0;
|
||
int maximum = 0;
|
||
bool hasSample = false;
|
||
long sampleAt = 0;
|
||
for (int i = 0; i < c.Count; i++)
|
||
{
|
||
if (!c.T1!.IsValid(i))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
bool lost = direction switch
|
||
{
|
||
Dir.Up => c.IsUpLost(i),
|
||
Dir.Down => !c.IsUpLost(i) && c.IsReplyLost(i),
|
||
_ => c.IsReplyLost(i),
|
||
};
|
||
if (direction == Dir.Down && c.IsUpLost(i))
|
||
{
|
||
// A request lost before reaching the Agent is not a downstream sample.
|
||
run = 0;
|
||
continue;
|
||
}
|
||
|
||
if (!hasSample)
|
||
{
|
||
sampleAt = c.SentUtcMs(view, i);
|
||
hasSample = true;
|
||
}
|
||
run = lost ? run + 1 : 0;
|
||
maximum = Math.Max(maximum, run);
|
||
}
|
||
|
||
if (hasSample)
|
||
{
|
||
sink.Emit(sampleAt, maximum);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>乱序：按到达顺序，序号比之前见过的最大序号还小。重复的序号不算乱序。</summary>
|
||
internal sealed class ReorderOp : MetricOp
|
||
{
|
||
public override string Signature => "reorder/1";
|
||
|
||
public override void Evaluate(ChunkView view, RawStream stream, IObservationSink sink)
|
||
{
|
||
var c = new EchoColumns(stream);
|
||
if (!c.HasBasics || c.Seq is null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var seen = new HashSet<long>();
|
||
long maxSeq = long.MinValue;
|
||
foreach (int row in c.ArrivalOrder())
|
||
{
|
||
long seq = c.Seq.Values[row];
|
||
if (!seen.Add(seq))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (seq < maxSeq)
|
||
{
|
||
sink.Emit(view.ColumnToUtcMs(c.T4!, c.T4!.Values[row]), 1);
|
||
}
|
||
|
||
maxSeq = Math.Max(maxSeq, seq);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>重复：同一个序号收到不止一次。</summary>
|
||
internal sealed class DupOp : MetricOp
|
||
{
|
||
public override string Signature => "dup/1";
|
||
|
||
public override void Evaluate(ChunkView view, RawStream stream, IObservationSink sink)
|
||
{
|
||
var c = new EchoColumns(stream);
|
||
if (!c.HasBasics || c.Seq is null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var seen = new HashSet<long>();
|
||
foreach (int row in c.ArrivalOrder())
|
||
{
|
||
if (!seen.Add(c.Seq.Values[row]))
|
||
{
|
||
sink.Emit(view.ColumnToUtcMs(c.T4!, c.T4!.Values[row]), 1);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>卡顿：到达间隔超过“期望间隔 + 阈值”。</summary>
|
||
internal sealed class GapOp : MetricOp
|
||
{
|
||
private readonly GapOutput _output;
|
||
private readonly string _rateParam;
|
||
private readonly double _thresholdMs;
|
||
|
||
public GapOp(GapOutput output, string rateParam, double thresholdMs)
|
||
{
|
||
_output = output;
|
||
_rateParam = rateParam;
|
||
_thresholdMs = thresholdMs;
|
||
}
|
||
|
||
public override string Signature => $"gap/{_output}/{_rateParam}/{_thresholdMs}/1";
|
||
|
||
public override void Evaluate(ChunkView view, RawStream stream, IObservationSink sink)
|
||
{
|
||
var c = new EchoColumns(stream);
|
||
if (!c.HasBasics)
|
||
{
|
||
return;
|
||
}
|
||
|
||
double rate = Math.Max(0.1, view.ParamNumber(_rateParam, 1));
|
||
double expectedMs = 1000.0 / rate;
|
||
int[] order = c.ArrivalOrder();
|
||
for (int i = 1; i < order.Length; i++)
|
||
{
|
||
double gapMs = (c.T4!.Values[order[i]] - c.T4.Values[order[i - 1]]) / 1000.0;
|
||
if (gapMs - expectedMs <= _thresholdMs)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
long at = view.ColumnToUtcMs(c.T4, c.T4.Values[order[i]]);
|
||
sink.Emit(at, _output == GapOutput.Count ? 1 : gapMs);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>每一行一个观测值，用于统计样本量。</summary>
|
||
internal sealed class RowCountOp : MetricOp
|
||
{
|
||
public override string Signature => "row_count/1";
|
||
|
||
public override void Evaluate(ChunkView view, RawStream stream, IObservationSink sink)
|
||
{
|
||
RawColumn? time = null;
|
||
foreach (RawColumn column in stream.Columns)
|
||
{
|
||
if (column.Role != ColumnRole.None)
|
||
{
|
||
time = column;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (time is null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
for (int i = 0; i < stream.Count; i++)
|
||
{
|
||
if (time.IsValid(i))
|
||
{
|
||
sink.Emit(view.ColumnToUtcMs(time, time.Values[i]), 1);
|
||
}
|
||
}
|
||
}
|
||
}
|