Allow perf to work without frame pointers

Signed-off-by: Pablo Galindo <pablogsal@gmail.com>

Author: pablogsal

Include/cpython/sysmodule.h

@@ -19,7 +19,7 @@ PyAPI_FUNC(int) PyUnstable_PerfMapState_Init(void);
 PyAPI_FUNC(int) PyUnstable_WritePerfMapEntry(
  const void *code_addr,
  unsigned int code_size,
- const char *entry_name);
+ PyCodeObject *entry_name);
 PyAPI_FUNC(void) PyUnstable_PerfMapState_Fini(void);
 PyAPI_FUNC(int) PyUnstable_CopyPerfMapFile(const char* parent_filename);
 PyAPI_FUNC(int) PyUnstable_PerfTrampoline_CompileCode(PyCodeObject *);

Include/internal/pycore_ceval.h

@@ -103,16 +103,19 @@ typedef struct {
  unsigned int code_size, PyCodeObject* code);
  // Callback to free the trampoline state
  int (*free_state)(void* state);
+ int (*copy_file)(const char* filename);
 } _PyPerf_Callbacks;
 
 extern int _PyPerfTrampoline_SetCallbacks(_PyPerf_Callbacks *);
 extern void _PyPerfTrampoline_GetCallbacks(_PyPerf_Callbacks *);
+extern void* _PyPerfTrampoline_GetState(void);
 extern int _PyPerfTrampoline_Init(int activate);
 extern int _PyPerfTrampoline_Fini(void);
 extern int _PyIsPerfTrampolineActive(void);
 extern PyStatus _PyPerfTrampoline_AfterFork_Child(void);
 #ifdef PY_HAVE_PERF_TRAMPOLINE
 extern _PyPerf_Callbacks _Py_perfmap_callbacks;
+extern _PyPerf_Callbacks _Py_perfmap_jit_callbacks;
 #endif
 
 static inline PyObject*

Include/internal/pycore_ceval_state.h

@@ -43,6 +43,7 @@ struct trampoline_api_st {
  void (*write_state)(void* state, const void *code_addr,
  unsigned int code_size, PyCodeObject* code);
  int (*free_state)(void* state);
+ int (*copy_file)(const char* filename);
  void *state;
 };
 #endif

Lib/test/test_perf_profiler.py

@@ -5,6 +5,7 @@
 import sysconfig
 import os
 import pathlib
+import shutil
 from test import support
 from test.support.script_helper import (
  make_script,
@@ -76,14 +77,27 @@ def baz():
  perf_file = pathlib.Path(f"/tmp/perf-{process.pid}.map")
  self.assertTrue(perf_file.exists())
  perf_file_contents = perf_file.read_text()
- perf_lines = perf_file_contents.splitlines();
- expected_symbols = [f"py::foo:{script}", f"py::bar:{script}", f"py::baz:{script}"]
+ perf_lines = perf_file_contents.splitlines()
+ expected_symbols = [
+ f"py::foo:{script}",
+ f"py::bar:{script}",
+ f"py::baz:{script}",
+ ]
  for expected_symbol in expected_symbols:
- perf_line = next((line for line in perf_lines if expected_symbol in line), None)
- self.assertIsNotNone(perf_line, f"Could not find {expected_symbol} in perf file")
+ perf_line = next(
+ (line for line in perf_lines if expected_symbol in line), None
+ )
+ self.assertIsNotNone(
+ perf_line, f"Could not find {expected_symbol} in perf file"
+ )
  perf_addr = perf_line.split(" ")[0]
- self.assertFalse(perf_addr.startswith("0x"), "Address should not be prefixed with 0x")
- self.assertTrue(set(perf_addr).issubset(string.hexdigits), "Address should contain only hex characters")
+ self.assertFalse(
+ perf_addr.startswith("0x"), "Address should not be prefixed with 0x"
+ )
+ self.assertTrue(
+ set(perf_addr).issubset(string.hexdigits),
+ "Address should contain only hex characters",
+ )
 
  def test_trampoline_works_with_forks(self):
  code = """if 1:
@@ -212,7 +226,7 @@ def test_sys_api_get_status(self):
  assert_python_ok("-c", code)
 
 
-def is_unwinding_reliable():
+def is_unwinding_reliable_with_frame_pointers():
  cflags = sysconfig.get_config_var("PY_CORE_CFLAGS")
  if not cflags:
  return False
@@ -259,24 +273,49 @@ def perf_command_works():
  return True
 
 
-def run_perf(cwd, *args, **env_vars):
+def run_perf(cwd, *args, use_jit=False, **env_vars):
  if env_vars:
  env = os.environ.copy()
  env.update(env_vars)
  else:
  env = None
  output_file = cwd + "/perf_output.perf"
- base_cmd = ("perf", "record", "-g", "--call-graph=fp", "-o", output_file, "--")
+ if not use_jit:
+ base_cmd = ("perf", "record", "-g", "--call-graph=fp", "-o", output_file, "--")
+ else:
+ base_cmd = (
+ "perf",
+ "record",
+ "-g",
+ "--call-graph=dwarf,65528",
+ "-F99",
+ "-k1",
+ "-o",
+ output_file,
+ "--",
+ )
  proc = subprocess.run(
  base_cmd + args,
  stdout=subprocess.PIPE,
  stderr=subprocess.PIPE,
  env=env,
  )
  if proc.returncode:
- print(proc.stderr)
+ print(proc.stderr, file=sys.stderr)
  raise ValueError(f"Perf failed with return code {proc.returncode}")
 
+ if use_jit:
+ jit_output_file = cwd + "/jit_output.dump"
+ command = ("perf", "inject", "-j", "-i", output_file, "-o", jit_output_file)
+ proc = subprocess.run(
+ command, stderr=subprocess.PIPE, stdout=subprocess.PIPE, env=env
+ )
+ if proc.returncode:
+ print(proc.stderr)
+ raise ValueError(f"Perf failed with return code {proc.returncode}")
+ # Copy the jit_output_file to the output_file
+ os.rename(jit_output_file, output_file)
+
  base_cmd = ("perf", "script")
  proc = subprocess.run(
  ("perf", "script", "-i", output_file),
@@ -290,20 +329,9 @@ def run_perf(cwd, *args, **env_vars):
  )
 
 
-@unittest.skipUnless(perf_command_works(), "perf command doesn't work")
-@unittest.skipUnless(is_unwinding_reliable(), "Unwinding is unreliable")
-class TestPerfProfiler(unittest.TestCase):
- def setUp(self):
- super().setUp()
- self.perf_files = set(pathlib.Path("/tmp/").glob("perf-*.map"))
-
- def tearDown(self) -> None:
- super().tearDown()
- files_to_delete = (
- set(pathlib.Path("/tmp/").glob("perf-*.map")) - self.perf_files
- )
- for file in files_to_delete:
- file.unlink()
+class TestPerfProfilerMixin:
+ def run_perf(self, script_dir, perf_mode, script):
+ raise NotImplementedError()
 
  def test_python_calls_appear_in_the_stack_if_perf_activated(self):
  with temp_dir() as script_dir:
@@ -322,14 +350,14 @@ def baz(n):
  baz(10000000)
  """
  script = make_script(script_dir, "perftest", code)
- stdout, stderr = run_perf(script_dir, sys.executable, "-Xperf", script)
+ stdout, stderr = self.run_perf(script_dir, script)
  self.assertEqual(stderr, "")
 
  self.assertIn(f"py::foo:{script}", stdout)
  self.assertIn(f"py::bar:{script}", stdout)
  self.assertIn(f"py::baz:{script}", stdout)
 
- def test_python_calls_do_not_appear_in_the_stack_if_perf_activated(self):
+ def test_python_calls_do_not_appear_in_the_stack_if_perf_deactivated(self):
  with temp_dir() as script_dir:
  code = """if 1:
  def foo(n):
@@ -346,7 +374,9 @@ def baz(n):
  baz(10000000)
  """
  script = make_script(script_dir, "perftest", code)
- stdout, stderr = run_perf(script_dir, sys.executable, script)
+ stdout, stderr = self.run_perf(
+ script_dir, script, activate_trampoline=False
+ )
  self.assertEqual(stderr, "")
 
  self.assertNotIn(f"py::foo:{script}", stdout)
@@ -423,12 +453,56 @@ def compile_trampolines_for_all_functions():
  # identical in both the parent and child perf-map files.
  perf_file_lines = perf_file_contents.split("\n")
  for line in perf_file_lines:
- if (
- f"py::foo_fork:{script}" in line
- or f"py::bar_fork:{script}" in line
- ):
+ if f"py::foo_fork:{script}" in line or f"py::bar_fork:{script}" in line:
  self.assertIn(line, child_perf_file_contents)
 
 
+@unittest.skipUnless(perf_command_works(), "perf command doesn't work")
+@unittest.skipUnless(
+ is_unwinding_reliable_with_frame_pointers(),
+ "Unwinding is unreliable with frame pointers",
+)
+class TestPerfProfiler(unittest.TestCase, TestPerfProfilerMixin):
+ def run_perf(self, script_dir, script, activate_trampoline=True):
+ if activate_trampoline:
+ return run_perf(script_dir, sys.executable, "-Xperf", script)
+ return run_perf(script_dir, sys.executable, script)
+
+ def setUp(self):
+ super().setUp()
+ self.perf_files = set(pathlib.Path("/tmp/").glob("perf-*.map"))
+
+ def tearDown(self) -> None:
+ super().tearDown()
+ files_to_delete = (
+ set(pathlib.Path("/tmp/").glob("perf-*.map")) - self.perf_files
+ )
+ for file in files_to_delete:
+ file.unlink()
+
+
+@unittest.skipUnless(perf_command_works(), "perf command doesn't work")
+class TestPerfProfilerWithDwarf(unittest.TestCase, TestPerfProfilerMixin):
+ def run_perf(self, script_dir, script, activate_trampoline=True):
+ if activate_trampoline:
+ return run_perf(
+ script_dir, sys.executable, "-Xperfjit", script, use_jit=True
+ )
+ return run_perf(script_dir, sys.executable, script, use_jit=True)
+
+ def setUp(self):
+ super().setUp()
+ self.perf_files = set(pathlib.Path("/tmp/").glob("jit*.dump"))
+ self.perf_files |= set(pathlib.Path("/tmp/").glob("jitted-*.so"))
+
+ def tearDown(self) -> None:
+ super().tearDown()
+ files_to_delete = set(pathlib.Path("/tmp/").glob("jit*.dump"))
+ files_to_delete |= set(pathlib.Path("/tmp/").glob("jitted-*.so"))
+ files_to_delete = files_to_delete - self.perf_files
+ for file in files_to_delete:
+ file.unlink()
+
+
 if __name__ == "__main__":
  unittest.main()

Lib/test/test_perfmaps.py

@@ -7,13 +7,22 @@
 if sys.platform != 'linux':
  raise unittest.SkipTest('Linux only')
 
+def entry1():
+ pass
+
+def entry2():
+ pass
 
 class TestPerfMapWriting(unittest.TestCase):
  def test_write_perf_map_entry(self):
- self.assertEqual(write_perf_map_entry(0x1234, 5678, "entry1"), 0)
- self.assertEqual(write_perf_map_entry(0x2345, 6789, "entry2"), 0)
- with open(f"/tmp/perf-{os.getpid()}.map") as f:
- perf_file_contents = f.read()
- self.assertIn("1234 162e entry1", perf_file_contents)
- self.assertIn("2345 1a85 entry2", perf_file_contents)
- perf_map_state_teardown()
+ sys.activate_stack_trampoline("perf")
+ try:
+ self.assertEqual(write_perf_map_entry(0x1234, 5678, entry1.__code__), 0)
+ self.assertEqual(write_perf_map_entry(0x2345, 6789, entry2.__code__), 0)
+ with open(f"/tmp/perf-{os.getpid()}.map") as f:
+ perf_file_contents = f.read()
+ self.assertIn("1234 162e py::entry1", perf_file_contents)
+ self.assertIn("2345 1a85 py::entry2", perf_file_contents)
+ perf_map_state_teardown()
+ finally:
+ sys.deactivate_stack_trampoline()

Modules/_testinternalcapi.c

@@ -893,9 +893,9 @@ write_perf_map_entry(PyObject *self, PyObject *args)
  PyObject *code_addr_v;
  const void *code_addr;
  unsigned int code_size;
- const char *entry_name;
+ PyCodeObject *entry_name;
 
- if (!PyArg_ParseTuple(args, "OIs", &code_addr_v, &code_size, &entry_name))
+ if (!PyArg_ParseTuple(args, "OIO", &code_addr_v, &code_size, &entry_name))
  return NULL;
  code_addr = PyLong_AsVoidPtr(code_addr_v);
  if (code_addr == NULL) {

Python/asm_trampoline.S

@@ -9,9 +9,10 @@
 # }
 _Py_trampoline_func_start:
 #ifdef __x86_64__
- sub $8, %rsp
+ pushq %rbp
+ movq %rsp, %rbp
  call *%rcx
- add $8, %rsp
+ popq %rbp
  ret
 #endif // __x86_64__
 #if defined(__aarch64__) && defined(__AARCH64EL__) && !defined(__ILP32__)

Python/initconfig.c

@@ -1697,6 +1697,20 @@ config_init_perf_profiling(PyConfig *config)
  if (xoption) {
  config->perf_profiling = 1;
  }
+ env = config_get_env(config, "PYTHONPERFJITSUPPORT");
+ if (env) {
+ if (_Py_str_to_int(env, &active) != 0) {
+ active = 0;
+ }
+ if (active) {
+ config->perf_profiling = 2;
+ }
+ }
+ xoption = config_get_xoption(config, L"perfjit");
+ if (xoption) {
+ config->perf_profiling = 2;
+ }
+
  return _PyStatus_OK();
 
 }

Python/lel.c

@@ -0,0 +1,8 @@
+typedef void* (py_evaluator)(void* ts, void* f, int t);
+
+void*
+trampoline(void *ts, void *f,
+ int throwflag, py_evaluator evaluator)
+{
+ return evaluator(ts, f, throwflag);
+}