Sample-based performance measuring with `prefmon`

[skyne98]

Switch from time calculation and aggregation to sampling in prefmon. This means moving from calculating time spent in a function or block of code and reporting it to reporting a place in code where execution currently happens whenever the external monitoring tool requires it. It should resolve the issue of too much overhead from aggregating data and allow for nearly infinite (and configurable) granularity in measurements.

Source of inspiration: .NET, JS and Dart debugging tools.

Acceptance criteria:

1. There is an isolate (or any other agent running in parallel to the program) that keeps track of the current block of code in execution, based on the program itself reporting it (without some specific rate, real-time)
2. prefmon, having a TCP (WS) connection to it, requests or receives a current executing scope at a specified rate
3. Over a specific timeframe, prefmon should receive a specific number of samples (for example 1 000 000 over 1000 ms or 1000 per 1 ms) so that it can make an educated guess about the % of time that was spent in a specific part of code
4. Either come up with an automatic way of reporting the current place of execution, or make a performanceEnter(<function or block name>) and performanceLeave() functions that directly report to the isolate with as little overhead as possible
5. Performance measuring functions get stripped in release mode, so that they don't influence performance
6. Old performance measuring code goes away completely

Some notes: On the isolate side, the current place of execution is probably not a single name, but a stack, which represents the current call stack. Otherwise, the performanceLeave() will have nothing to reset and "prefmon" will not be able to decide in which exact "child" function it is.

[Dev-Owl]

Would this not spoil the code with hunderts of enter/leave codes? It looks like a more complicated way to archive the same. Only advantage is that it goes to an isolate.

For me it should be KISS:

• You want to know how long x runs, either report the time or report enter and leave
• No need to report that you are still in XXX
• If enter & leave is reported there is an option to miss one
• Avoiding missing one could be done with an extra function that wraps the actual code
• no idea if getting the stack is fast, and needed because that would mean everything needs to report enter leave

I would vote for a dead simple function to wrap any call, it would report start and end. If performance testing is off it just calls the function. If the performance flag is const the compiler should kickoff the not needed code.

This would allow the user to call any function with thus to monitor it.

[Dev-Owl]

In addition to the above, I would currently vote for using: Pub.dev as it provides a solution for all target platforms.