{"id":5723,"date":"2020-01-28T15:00:25","date_gmt":"2020-01-28T15:00:25","guid":{"rendered":"http:\/\/writeasync.net\/?p=5723"},"modified":"2020-01-27T03:44:30","modified_gmt":"2020-01-27T03:44:30","slug":"low-latency-latency-measurement","status":"publish","type":"post","link":"https:\/\/writeasync.net\/?p=5723","title":{"rendered":"Low-latency latency measurement"},"content":{"rendered":"

Measuring latency is easy with .NET. Just use a Stopwatch<\/a>!<\/p>\n

\r\nStopwatch stopwatch = Stopwatch.StartNew();\r\n\/\/ . . . do The Operation(s) here\r\nTimeSpan elapsed = stopwatch.Elapsed;\r\n\/\/ elapsed == how long it took to do The Operation(s)\r\n<\/pre>\n
This is certainly the most commonly recommended way<\/a> to measure operational timings<\/a>. But is it the fastest way?<\/p>\n
It seems almost absurd to ask for a low-latency latency measurement, but good performance discipline requires us to measure<\/a>. As they saying goes, “one test is worth a thousand expert opinions<\/a>.” So let’s come up with a benchmark:<\/p>\n
\r\n[SimpleJob(RuntimeMoniker.NetCoreApp31)]\r\n[MemoryDiagnoser]\r\npublic class Benchmarks\r\n{\r\n    [Benchmark]\r\n    public long Watch()\r\n    {\r\n        Stopwatch stopwatch = Stopwatch.StartNew();\r\n        return stopwatch.Elapsed.Ticks;\r\n    }\r\n}\r\n<\/pre>\n
The result:<\/p>\n
\r\n| Method |     Mean |    Error |   StdDev |  Gen 0 | Gen 1 | Gen 2 | Allocated |\r\n|------- |---------:|---------:|---------:|-------:|------:|------:|----------:|\r\n|  Watch | 55.01 ns | 1.702 ns | 1.421 ns | 0.0051 |     - |     - |      40 B |\r\n<\/pre>\n
It’s pretty fast! There is one problem, though — what are we even supposed to compare this with? Is there another way to measure time that could actually be faster? I see only one realistic optimization opportunity here which is to get rid of the memory allocation penalty. Yes, Stopwatch is reference type<\/a> (it is stateful after all) and thus requires heap allocation.<\/p>\n
The key realization is that calculating elapsed time merely requires subtracting a start time and an end time — two 64-bit integers if we are using ticks<\/a>. We should in principle be able to do this without allocating any additional memory. It just so happens that Stopwatch is still our friend in this journey, as it provides a GetTimestamp static method<\/a>. The only problem is that it returns a value in units of timer<\/em> ticks. Ah, but look, it also has a Frequency field<\/a> which gives the conversion between timer ticks and seconds. These insights give us the blueprint for a new struct type which marks points in time:<\/p>\n
\r\npublic readonly struct TimePoint\r\n{\r\n    private static readonly double TicksPerTimerTick = 10000000.0 \/ Stopwatch.Frequency;\r\n\r\n    private readonly long timerTicks;\r\n\r\n    private TimePoint(long timerTicks)\r\n    {\r\n        this.timerTicks = timerTicks;\r\n    }\r\n\r\n    public static TimeSpan operator -(TimePoint x, TimePoint y)\r\n    {\r\n        long deltaTimerTicks = x.timerTicks - y.timerTicks;\r\n        double deltaTicks = TicksPerTimerTick * deltaTimerTicks;\r\n        return new TimeSpan((long)deltaTicks);\r\n    }\r\n\r\n    public static TimePoint Now() => new TimePoint(Stopwatch.GetTimestamp());\r\n\r\n    public TimeSpan Elapsed() => Now() - this;\r\n}\r\n<\/pre>\n
At last, we have a comparison benchmark for a maybe-faster latency tracker:<\/p>\n
\r\n[Benchmark]\r\npublic long Point()\r\n{\r\n    TimePoint start = TimePoint.Now();\r\n    return start.Elapsed().Ticks;\r\n}\r\n<\/pre>\n
The results:<\/p>\n
\r\n| Method |     Mean |    Error |   StdDev |  Gen 0 | Gen 1 | Gen 2 | Allocated |\r\n|------- |---------:|---------:|---------:|-------:|------:|------:|----------:|\r\n|  Watch | 54.18 ns | 1.512 ns | 1.263 ns | 0.0051 |     - |     - |      40 B |\r\n|  Point | 40.20 ns | 0.417 ns | 0.325 ns |      - |     - |     - |         - |\r\n<\/pre>\n
We managed to get a 25% performance improvement! For now, I’m comfortable calling TimePoint<\/code> the lowest latency low-latency latency measurement approach. Can you come up with a better way in .NET?<\/p>\n","protected":false},"excerpt":{"rendered":"
Measuring latency is easy with .NET. Just use a Stopwatch! Stopwatch stopwatch = Stopwatch.StartNew(); \/\/ . . . do The Operation(s) here TimeSpan elapsed = stopwatch.Elapsed; \/\/ elapsed == how long it took to do The Operation(s) This is certainly… <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[71,104],"tags":[],"class_list":["post-5723","post","type-post","status-publish","format-standard","hentry","category-diagnostics","category-performance"],"_links":{"self":[{"href":"https:\/\/writeasync.net\/index.php?rest_route=\/wp\/v2\/posts\/5723","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/writeasync.net\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/writeasync.net\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/writeasync.net\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/writeasync.net\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=5723"}],"version-history":[{"count":1,"href":"https:\/\/writeasync.net\/index.php?rest_route=\/wp\/v2\/posts\/5723\/revisions"}],"predecessor-version":[{"id":5724,"href":"https:\/\/writeasync.net\/index.php?rest_route=\/wp\/v2\/posts\/5723\/revisions\/5724"}],"wp:attachment":[{"href":"https:\/\/writeasync.net\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=5723"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/writeasync.net\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=5723"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/writeasync.net\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=5723"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}