In debugging, how to know the stats (max-min, average, distribution...) of an argument in a repetitive calls to a function? - c++

Question

Supposed I have a function void Myclass::func(x), and various other code make thousands of calls to it. Now I want to know some stats of the argument x, for example, the average, max, min, or even a distribution graph.
void Myclass::func(int x) {
while(foo.doFancyStuff(x)) {
// ...
}
}
Here's some ad-hoc methods that come to my mind:
Print each value of x to log. Then use external tools/scripts to analyze them.
Caveats: Mixed with other info in logs. Writing each value of x into external log or file on filesystem is slow.
Define global variable to store them and analyze at the end of execution of interest.
Caveats: Global variables are bad. They will get confusing in the future.
Store them in class Myclass.
Caveats: Not reusable code. What about next time I want to analyze Otherclass::doOtherStuff(y) ? And bad integration, because that stats code should not be coupled with the Myclass itself.
Is there any tool/library to do this? I'm using Visual Studio on Windows, so would like an answer usable for this platform. Cross-platform tools are welcome, too.

Answer 1

Here is an example using the scripting API of lldb (which works on Windows, too). Take this trivial program,
void func(int x) {}
int main(int, char **)
{
for (int i = 0; i < 1000; ++i)
func(i);
}
which you can analyze with such a script
import lldb
import os
fArgs = []
def analyzeFrame(frame, bpLocation, dict):
variables = frame.GetVariables(True, False, False, False)
x = variables.GetValueAtIndex(0).GetValueAsSigned()
fArgs.append(x)
return False
debugger = lldb.SBDebugger.Create()
debugger.SetAsync(False)
target = debugger.CreateTargetWithFileAndArch("pathToYourExecutable", "")
bp = target.BreakpointCreateByName("func", 4, lldb.SBFileSpecList(), lldb.SBFileSpecList())
bp.SetScriptCallbackFunction("analyzeFrame")
process = target.Launch(target.GetDebugger().GetListener(), [], [],
None, None, None, os.getcwd(), 0, False, lldb.SBError())
print("max: {}".format(max(fArgs)))
print("min: {}".format(min(fArgs)))
You need to make sure the python interpreter finds the lldb module. The path can be seen by executing lldb -P on the command line.

Answer 2

Unfortunately, there is no single simple answer. What you want is a variation of instrumentation debugging, which means that someone needs to inject additional code in your class to handle this case.
For a portable way, the only option you have is to add a cache of the previous values, then in your class destructor, output the statistics that you want. The way you cache data is up to you, you can design a simple Stats<> class, member of the class that you want to monitor and make calls to it to store new values. That would be what I would try first, as it's portable, almost clean and reusable.