[trace][intel pt] Add a memory usage test

[wallace]

Summary

The existing tests that check for the memory usage of the decoded trace are using small binaries, and in this case the memory usage is dominated by the static size of the structures. In order to check the dynamic cost of the trace, I'm creating a new test that runs a program that is compiled at test time and then the total number of instructions and memory usage is asserted.

This serves as an example of a test that doesn't require to check in a prebuilt binary, which is costly for git.

[jj10306]

What is the intention of this test? To catch changes that may increase the memory by a lot? I'm concerned this could be very flaky given that it's dependent on external factors (compiler output, context switches, etc).
Now that we have this test, is there any value in having the check for the memory information output in the trace dump test or can that be removed?

[wallace]

To catch changes that may increase the memory by a lot?

exactly. We might introduce changes in the decoder that might produce erroneous data and increase the memory usage or number of instructions by too much. For example, all our current tests work with small number of instructions, so they are easy to assert. But when dealing with milllions of instructions, it's hard to assert what will happen unless we look for statistics. In this specific case, because we only care about x86, the number of instructions shouldn't change because we compile without optimizations, so I doubt it'll be flaky. In terms of context switches, each context switch only adds a minimal amount of bytes. In fact, each context switch only contributes one entry in the events map.

But besides all that, which doesn't sound very convincing, what I want to start having is tests with binaries that are compiled at the moment without the need of prebuilt binaries. People complain too much every time someone tries to commit a prebuilt binary because of two reasons: it's very heavy for the source control system, and it might fail on some machines with a different setup for some system libraries. When the test binary is compiled at the moment, then the compiler will ensure that it can run on the current machine.

So this is more like a learning step for me while being useful to test some other things.

[wallace]

I think I can do better than this

lldb/test/API/commands/trace/memory-usage/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/commands/trace/memory-usage/TestTraceMemoryUsage.py

+import lldb
+from intelpt_testcase import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+from lldbsuite.test.decorators import *
+import re
+
+class TestTraceMemoryUsage(TraceIntelPTTestCaseBase):
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64']))
+    def testDumpBigTraceSize(self):
+        '''
+            The purpose of this test is to ensure that the memory footprint
+            of a decoded trace is small.
+        '''
+        self.build()
+        self.expect("file " + self.getBuildArtifact("a.out"))
+        self.expect("b main")
+        self.expect("r")
+        self.expect("thread trace start -s 0x100000") # 1 MB of trace
+        self.expect("b 5")
+        self.expect("c")
+        self.runCmd("thread trace dump info")
+        m = re.search(
+            'Average memory usage per instruction \(excluding raw trace\): (.*) bytes',
+            self.res.GetOutput())
+        avg_byte_per_insn = float(m.group(1))
+        # As the program being run is compiled every time it runs, the total number
+        # of instructions and events might slightly change. Besides that, the number of
+        # events might change (e.g. different number of context switches), so we can't
+        # look for an exact byte size. Therefore we expect the avg byte usage per
+        #instruction to be 13 +- an error.
+        self.assertLess(abs(avg_byte_per_insn - 13), 0.1)
+
+        # Similarly, we expect the number of instructions to be 10000000 +- an error.
+        m = re.search(
+            'Total number of instructions: (.*)',
+            self.res.GetOutput())
+        insn_count = int(m.group(1))
+        self.assertLess(abs(insn_count - 10000000), 100000)

lldb/test/API/commands/trace/memory-usage/main.cpp

+int main() {
+  int x = 0;
+  for (int i = 0; i < 1000000; i++)
+    x += i * i;
+  return x;
+}