Инструментирование CPython с помощью DTrace и SystemTap

Включение статических маркеров

В macOS имеется встроенная поддержка DTrace. В Linux для сборки CPython со встроенными маркерами SystemTap необходимо установить инструменты разработки SystemTap.

В Linux это можно сделать с помощью:

$ yum install systemtap-sdt-devel

или:

$ sudo apt-get install systemtap-sdt-dev

Затем необходимо собрать CPython с параметром configured with the --with-dtrace option:

checking for --with-dtrace... yes

В macOS можно вывести список доступных проб DTrace, запустив процесс Python в фоновом режиме и перечислив все пробы, предоставляемые провайдером Python:

$ python3.6 -q &
$ sudo dtrace -l -P python$!  # or: dtrace -l -m python3.6

   ID   PROVIDER            MODULE                          FUNCTION NAME
29564 python18035        python3.6          _PyEval_EvalFrameDefault function-entry
29565 python18035        python3.6             dtrace_function_entry function-entry
29566 python18035        python3.6          _PyEval_EvalFrameDefault function-return
29567 python18035        python3.6            dtrace_function_return function-return
29568 python18035        python3.6                           collect gc-done
29569 python18035        python3.6                           collect gc-start
29570 python18035        python3.6          _PyEval_EvalFrameDefault line
29571 python18035        python3.6                 maybe_dtrace_line line

В Linux можно проверить наличие статических маркеров SystemTap в собранном двоичном файле, убедившись, что он содержит раздел «.note.stapsdt».

$ readelf -S ./python | grep .note.stapsdt
[30] .note.stapsdt        NOTE         0000000000000000 00308d78

Если Python собран как разделяемая библиотека (с параметром настройки --enable-shared), искать нужно в самой разделяемой библиотеке. Например:

$ readelf -S libpython3.3dm.so.1.0 | grep .note.stapsdt
[29] .note.stapsdt        NOTE         0000000000000000 00365b68

Достаточно современная версия readelf может вывести метаданные:

$ readelf -n ./python

Displaying notes found at file offset 0x00000254 with length 0x00000020:
    Owner                 Data size          Description
    GNU                  0x00000010          NT_GNU_ABI_TAG (ABI version tag)
        OS: Linux, ABI: 2.6.32

Displaying notes found at file offset 0x00000274 with length 0x00000024:
    Owner                 Data size          Description
    GNU                  0x00000014          NT_GNU_BUILD_ID (unique build ID bitstring)
        Build ID: df924a2b08a7e89f6e11251d4602022977af2670

Displaying notes found at file offset 0x002d6c30 with length 0x00000144:
    Owner                 Data size          Description
    stapsdt              0x00000031          NT_STAPSDT (SystemTap probe descriptors)
        Provider: python
        Name: gc__start
        Location: 0x00000000004371c3, Base: 0x0000000000630ce2, Semaphore: 0x00000000008d6bf6
        Arguments: -4@%ebx
    stapsdt              0x00000030          NT_STAPSDT (SystemTap probe descriptors)
        Provider: python
        Name: gc__done
        Location: 0x00000000004374e1, Base: 0x0000000000630ce2, Semaphore: 0x00000000008d6bf8
        Arguments: -8@%rax
    stapsdt              0x00000045          NT_STAPSDT (SystemTap probe descriptors)
        Provider: python
        Name: function__entry
        Location: 0x000000000053db6c, Base: 0x0000000000630ce2, Semaphore: 0x00000000008d6be8
        Arguments: 8@%rbp 8@%r12 -4@%eax
    stapsdt              0x00000046          NT_STAPSDT (SystemTap probe descriptors)
        Provider: python
        Name: function__return
        Location: 0x000000000053dba8, Base: 0x0000000000630ce2, Semaphore: 0x00000000008d6bea
        Arguments: 8@%rbp 8@%r12 -4@%eax

Приведённые выше метаданные содержат информацию для SystemTap о том, как можно исправить специально размещённые инструкции машинного кода, чтобы включить хуки трассировки, используемые сценарием SystemTap.

Статические пробы DTrace

Следующий пример сценария DTrace можно использовать для отображения иерархии вызовов и возвратов в сценарии Python. Трассировка ведётся только во время вызова функции «start». Иными словами, вызовы функций во время импорта отображаться не будут:

self int indent;

python$target:::function-entry
/copyinstr(arg1) == "start"/
{
        self->trace = 1;
}

python$target:::function-entry
/self->trace/
{
        printf("%d\t%*s:", timestamp, 15, probename);
        printf("%*s", self->indent, "");
        printf("%s:%s:%d\n", basename(copyinstr(arg0)), copyinstr(arg1), arg2);
        self->indent++;
}

python$target:::function-return
/self->trace/
{
        self->indent--;
        printf("%d\t%*s:", timestamp, 15, probename);
        printf("%*s", self->indent, "");
        printf("%s:%s:%d\n", basename(copyinstr(arg0)), copyinstr(arg1), arg2);
}

python$target:::function-return
/copyinstr(arg1) == "start"/
{
        self->trace = 0;
}

Его можно запустить так:

$ sudo dtrace -q -s call_stack.d -c "python3.6 script.py"

Результат будет выглядеть так:

156641360502280  function-entry:call_stack.py:start:23
156641360518804  function-entry: call_stack.py:function_1:1
156641360532797  function-entry:  call_stack.py:function_3:9
156641360546807 function-return:  call_stack.py:function_3:10
156641360563367 function-return: call_stack.py:function_1:2
156641360578365  function-entry: call_stack.py:function_2:5
156641360591757  function-entry:  call_stack.py:function_1:1
156641360605556  function-entry:   call_stack.py:function_3:9
156641360617482 function-return:   call_stack.py:function_3:10
156641360629814 function-return:  call_stack.py:function_1:2
156641360642285 function-return: call_stack.py:function_2:6
156641360656770  function-entry: call_stack.py:function_3:9
156641360669707 function-return: call_stack.py:function_3:10
156641360687853  function-entry: call_stack.py:function_4:13
156641360700719 function-return: call_stack.py:function_4:14
156641360719640  function-entry: call_stack.py:function_5:18
156641360732567 function-return: call_stack.py:function_5:21
156641360747370 function-return:call_stack.py:start:28

Статические маркеры SystemTap

Низкоуровневый способ использовать интеграцию с SystemTap — обращаться напрямую к статическим маркерам. Для этого необходимо явно указать двоичный файл, который их содержит.

Например, следующий сценарий SystemTap можно использовать для отображения иерархии вызовов и возвратов в сценарии Python:

probe process("python").mark("function__entry") {
     filename = user_string($arg1);
     funcname = user_string($arg2);
     lineno = $arg3;

     printf("%s => %s in %s:%d\\n",
            thread_indent(1), funcname, filename, lineno);
}

probe process("python").mark("function__return") {
    filename = user_string($arg1);
    funcname = user_string($arg2);
    lineno = $arg3;

    printf("%s <= %s in %s:%d\\n",
           thread_indent(-1), funcname, filename, lineno);
}

Его можно запустить так:

$ stap \
  show-call-hierarchy.stp \
  -c "./python test.py"

Результат будет выглядеть так:

11408 python(8274):        => __contains__ in Lib/_abcoll.py:362
11414 python(8274):         => __getitem__ in Lib/os.py:425
11418 python(8274):          => encode in Lib/os.py:490
11424 python(8274):          <= encode in Lib/os.py:493
11428 python(8274):         <= __getitem__ in Lib/os.py:426
11433 python(8274):        <= __contains__ in Lib/_abcoll.py:366

Столбцы обозначают:

• время в микросекундах с начала выполнения сценария
• имя исполняемого файла
• PID процесса

Остальная часть вывода показывает иерархию вызовов и возвратов во время выполнения сценария.

В сборке CPython с параметром --enable-shared маркеры находятся в разделяемой библиотеке libpython, и это должно быть отражено в пути пробы с точками. Например, эту строку из приведённого выше примера:

probe process("python").mark("function__entry") {

следует заменить на:

probe process("python").library("libpython3.6dm.so.1.0").mark("function__entry") {

(предполагается отладочная сборка CPython 3.6)

Доступные статические маркеры

function__entry(str filename, str funcname, int lineno)

Этот маркер указывает, что началось выполнение функции Python. Он срабатывает только для функций на чистом Python (байткод).

Имя файла, имя функции и номер строки передаются сценарию трассировки в качестве позиционных аргументов. Для доступа к ним следует использовать $arg1, $arg2, $arg3:

• $arg1 : (const char *) имя файла, доступное через user_string($arg1)
• $arg2 : (const char *) имя функции, доступное через user_string($arg2)
• $arg3 : int номер строки

function__return(str filename, str funcname, int lineno)

Этот маркер является противоположностью function__entry() и указывает, что выполнение функции Python завершилось (через return или исключение). Он срабатывает только для функций на чистом Python (байткод).

Аргументы те же, что и для function__entry()

line(str filename, str funcname, int lineno)

Этот маркер указывает, что сейчас будет выполнена строка Python. Он эквивалентен построчной трассировке с помощью профилировщика Python. Внутри функций C он не срабатывает.

Аргументы те же, что и для function__entry().

gc__start(int generation)

Срабатывает, когда интерпретатор Python начинает цикл сборки мусора. arg0 — поколение для сканирования, как в gc.collect().

gc__done(long collected)

Срабатывает, когда интерпретатор Python завершает цикл сборки мусора. arg0 — число собранных объектов.

import__find__load__start(str modulename)

Срабатывает перед тем, как importlib попытается найти и загрузить модуль. arg0 — имя модуля.

Добавлено в версии 3.7.

import__find__load__done(str modulename, int found)

Срабатывает после вызова функции find_and_load из importlib. arg0 — имя модуля, arg1 указывает, был ли модуль успешно загружен.

Добавлено в версии 3.7.

audit(str event, void *tuple)

Срабатывает при вызове sys.audit() или PySys_Audit(). arg0 — имя события в виде строки C, arg1 — указатель PyObject на объект-кортеж.

Добавлено в версии 3.8.

Тапсеты SystemTap

Высокоуровневый способ использовать интеграцию с SystemTap — воспользоваться «тапсетом»: аналогом библиотеки в SystemTap, который скрывает некоторые низкоуровневые детали статических маркеров.

Ниже приведён файл тапсета, основанный на сборке CPython без разделяемой библиотеки:

/*
   Provide a higher-level wrapping around the function__entry and
   function__return markers:
 \*/
probe python.function.entry = process("python").mark("function__entry")
{
    filename = user_string($arg1);
    funcname = user_string($arg2);
    lineno = $arg3;
    frameptr = $arg4
}
probe python.function.return = process("python").mark("function__return")
{
    filename = user_string($arg1);
    funcname = user_string($arg2);
    lineno = $arg3;
    frameptr = $arg4
}

Если установить этот файл в каталог тапсетов SystemTap (например, /usr/share/systemtap/tapset), станут доступны следующие дополнительные точки проб:

python.function.entry(str filename, str funcname, int lineno, frameptr)

Эта точка пробы указывает, что началось выполнение функции Python. Она срабатывает только для функций на чистом Python (байткод).

python.function.return(str filename, str funcname, int lineno, frameptr)

Эта точка пробы является противоположностью python.function.return и указывает, что выполнение функции Python завершилось (через return или исключение). Она срабатывает только для функций на чистом Python (байткод).

Примеры

Следующий сценарий SystemTap использует приведённый выше тапсет, чтобы более наглядно реализовать описанный выше пример трассировки иерархии вызовов функций Python, не требуя прямого указания статических маркеров:

probe python.function.entry
{
  printf("%s => %s in %s:%d\n",
         thread_indent(1), funcname, filename, lineno);
}

probe python.function.return
{
  printf("%s <= %s in %s:%d\n",
         thread_indent(-1), funcname, filename, lineno);
}

Следующий сценарий использует приведённый выше тапсет, чтобы отображать все выполняющиеся процессы CPython в виде таблицы, похожей на top. Каждую секунду по всей системе выводятся 20 наиболее часто вызываемых кадров байткода:

global fn_calls;

probe python.function.entry
{
    fn_calls[pid(), filename, funcname, lineno] += 1;
}

probe timer.ms(1000) {
    printf("\033[2J\033[1;1H") /* clear screen \*/
    printf("%6s %80s %6s %30s %6s\n",
           "PID", "FILENAME", "LINE", "FUNCTION", "CALLS")
    foreach ([pid, filename, funcname, lineno] in fn_calls- limit 20) {
        printf("%6d %80s %6d %30s %6d\n",
            pid, filename, lineno, funcname,
            fn_calls[pid, filename, funcname, lineno]);
    }
    delete fn_calls;
}