[intel-pt] Implement a basic test case

[wallace]

Summary

Depends on D76872.

There was no test for the Intel PT support on LLDB, so I'm creating one, which
will help making progress on solid grounds.

The test is skipped if the Intel PT plugin library is not built.

[wallace]

Added a stop command invocation in the test

[clayborg]

I am worried if this test will be flaky on loaded machines. Not sure how we can ever guarantee we will see processor traces with our stuff in it if the machine is busy running many tests or even doing other things.

lldb/test/API/tools/intel-features/intel-pt/test/TestIntelPTSimpleBinary.py

51–55

can we guarantee we will see any of these on a fully loaded machine running many tests simultaneously? Maybe we need to settle for the header of the output only to know that it tried to display something?

[labath]

It's nice to see this code getting some use. I was starting to think we should delete it...

lldb/test/API/tools/intel-features/intel-pt/test/TestIntelPTSimpleBinary.py

31–37

lldbutil.run_to_name_breakpoint

51

better avoid referencing functions from the system library... makes the test more hermetic

51–55

What exactly is the case you're worried about? I'm not very familiar with how all this works, but I would think that the kernel trace buffer for this is application specific, and is automatically switched off when the os schedules a different process (anything else would be a security breach). If that is true, then we should have pretty good control over what goes into the buffer, and we can ensure that it is: (a) big enough; and/or (b) application does not execute too much code and overflows it (not calling rand would help us get a reasonable upper bound on that).

(Nonetheless it would be good to run some stress tests to verify this is stable.)

lldb/test/API/tools/intel-features/intel-pt/test/main.cpp

3–9

We're not putting license headers on tests.

(Do these get automatically created by some IDEs or something? Can they be configured not to do that?)

[wallace]

lldb/test/API/tools/intel-features/intel-pt/test/TestIntelPTSimpleBinary.py

51–55

This is how it works: by default Intel PT has to be enabled on each logical CPU, where it traces everything, regardless of which thread if running. The kernel has the ability to switch Intel PT on and off on each logical CPU whenever there's a thread context switch, and this kind of filtering is what this LLDB plugin is using.

For some context, that kind of filtering is expensive because of the constant enabling/disabling of Intel PT and could incur in up to 5% total CPU cost according to Intel. Another drawback of this approach is that threads spawned by an already traced thread are not traced by default. The user has to enable filtered tracing explicitly for these threads.

A faster approach is to enable Intel PT on all CPUs without filtering. That leads to a ~2% total CPU cost according to some tests some colleagues and I ran. However, this needs having a secondary trace of context switches to be able to attribute Intel PT packets to individual threads. We are not following that approach in this plugin because of the added complexity. However, I plan to make this plugin flexible enough to be able to load Intel PT traces collected by other mechanisms which can do global tracing correctly.

Lastly, the PT Trace unit in the cpu writes PT packets on memory without interrupting the CPU itself nor the kernel. The only case in which packets couldn't be written is when the BUS is completely full. However, this is extremely rare and the CPU would retry later.

---

That being said, I see no reason why the trace wouldn't be collected at that point. Just in case I'll add a 0.1 ms wait time for the CPU to have enough time to send all the packets, which should be more than enough.

lldb/test/API/tools/intel-features/intel-pt/test/main.cpp

3–9

I just copy pasted it from another test

[wallace]

Addressed comments

Also ran the test in parallel to a 'stress -c 100 -i 100' invocation, and it
passed correctly

[wallace]

clang-format

[wallace]

Noise, for some reason I can't run clang-format as part of arc lint on this device.
I'm running it manually anyway

[labath]

lldb/test/API/tools/intel-features/intel-pt/test/TestIntelPTSimpleBinary.py

51–55

Ok, that sounds good to me, though I'd be very surprised if 100ms makes any difference -- I've seen flaky tests with much bigger delays.

lldb/test/API/tools/intel-features/intel-pt/test/main.cpp

3–9

Which one? I don't see any test like that in the lldb repo. Was it from the swift fork or something?

[wallace]

lldb/test/API/tools/intel-features/intel-pt/test/main.cpp

3–9

I copied it from here https://github.com/llvm/llvm-project/blob/master/lldb/tools/intel-features/intel-mpx/test/main.cpp
I'll remove the header from that file as well

lldb/test/API/tools/intel-features/intel-pt/test/Makefile

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

lldb/test/API/tools/intel-features/intel-pt/test/TestIntelPTSimpleBinary.py

+from __future__ import print_function
+
+import os
+import lldb
+import time
+
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestIntelPTSimpleBinary(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
+
+    @skipIf(oslist=no_match(['linux']))
+    @skipIf(archs=no_match(['i386', 'x86_64']))
+    @skipIfRemote
+    def test_basic_flow(self):
+        """Test collection, decoding, and dumping instructions"""
+        lldb_exec_dir = os.environ["LLDB_IMPLIB_DIR"]
+        lldb_lib_dir = os.path.join(lldb_exec_dir, os.pardir, "lib")
+        plugin_file = os.path.join(lldb_lib_dir, "liblldbIntelFeatures.so")
+        if not os.path.isfile(plugin_file):
+            self.skipTest("features plugin missing.")
+
+        self.build()
+
+        self.runCmd("plugin load " + plugin_file)
+
+        exe = self.getBuildArtifact("a.out")
+        lldbutil.run_to_name_breakpoint(self, "main", exe_name=exe)
+        # We start tracing from main
+        self.runCmd("processor-trace start all")
+
+        # We check the trace after the for loop
+        self.runCmd("b " + str(line_number('main.cpp', '// Break 1')))
+        self.runCmd("c")
+
+        # We wait a little bit to ensure the processor has send the PT packets to
+        # the memory
+        time.sleep(.1)
+
+        # We find the start address of the 'fun' function for a later check
+        target = self.dbg.GetSelectedTarget()
+        fun_start_adddress = target.FindFunctions("fun")[0].GetSymbol() \
+            .GetStartAddress().GetLoadAddress(target)
+
+        # We print the last instructions
+        self.expect("processor-trace show-instr-log -c 100",
+            patterns=[
+                # We expect to have seen the first instruction of 'fun'
+                hex(fun_start_adddress),  
+                # We expect to see the exit condition of the for loop
+                "at main.cpp:" + str(line_number('main.cpp', '// Break for loop')) 
+            ])
+
+        self.runCmd("processor-trace stop")

lldb/test/API/tools/intel-features/intel-pt/test/main.cpp

+#include <iostream>
+
+using namespace std;
+
+int fun(int a) { return a * a + 1; }
+
+int main() {
+  int z = 0;
+  for (int i = 0; i < 10000; i++) { // Break for loop
+    z += fun(z);
+  }
+
+  return 0; // Break 1
+}

lldb/tools/intel-features/intel-pt/cli-wrapper-pt.cpp

virtual bool DoExecute(lldb::SBDebugger debugger, char **command,
 
     // Start trace
     pt_decoder_sp->StartProcessorTrace(process, lldb_SBTraceOptions, error);
     if (!error.Success()) {
       result.Printf("error: %s\n", error.GetCString());
       result.SetStatus(lldb::eReturnStatusFailed);
       return false;
     }
+    result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
     return true;
   }
 
 private:
   std::shared_ptr<ptdecoder::PTDecoder> pt_decoder_sp;
   const uint32_t m_max_trace_buff_size = 0x3fff;
   const uint32_t m_default_trace_buff_size = 4096;
 };
for (size_t i = 0; i < loop_count; i++) {
       res.Printf("thread #%" PRIu32 ": tid=%" PRIu64
                  ", trace buffer size=%" PRIu64 ", meta buffer size=%" PRIu64
                  ", trace type=%" PRIu32 ", custom trace params=%s",
                  thread.GetIndexID(), thread_id, options.GetTraceBufferSize(),
                  options.GetMetaDataBufferSize(), options.GetType(),
                  s.GetData());
       result.AppendMessage(res.GetOutput());
     }
+    result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
     return true;
   }
 
 private:
   std::shared_ptr<ptdecoder::PTDecoder> pt_decoder_sp;
 };
 
 class ProcessorTraceShowInstrLog : public lldb::SBCommandPluginInterface {
for (size_t i = 0; i < loop_count; i++) {
                                                    first_new_line_index - 1))
                                 .c_str());
         else
           res.AppendMessage(
               (result_str.substr(0, result_str.length() - 1)).c_str());
       }
       result.AppendMessage(res.GetOutput());
     }
+    result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
     return true;
   }
 
 private:
   std::shared_ptr<ptdecoder::PTDecoder> pt_decoder_sp;
   const uint32_t m_default_count = 10;
 };
 
virtual bool DoExecute(lldb::SBDebugger debugger, char **command,
     // Stop trace
     lldb::SBError error;
     pt_decoder_sp->StopProcessorTrace(process, error, thread_id);
     if (!error.Success()) {
       result.Printf("error: %s\n", error.GetCString());
       result.SetStatus(lldb::eReturnStatusFailed);
       return false;
     }
+    result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
     return true;
   }
 
 private:
   std::shared_ptr<ptdecoder::PTDecoder> pt_decoder_sp;
 };
 
 bool PTPluginInitialize(lldb::SBDebugger &debugger) {