[python_basic_memory] Initial commit

Author: KowalskiThomas

scenarios/python_basic_memory_3.11/Dockerfile

@@ -0,0 +1,19 @@
+ARG BASE_IMAGE="prof-python-3.11"
+FROM $BASE_IMAGE
+
+# Copy the Python target into the container
+COPY ./scenarios/python_basic_memory_3.11/requirements.txt /app/requirements.txt
+RUN chmod 644 /app/*
+
+RUN pip install -r /app/requirements.txt
+
+COPY ./scenarios/python_basic_memory_3.11/main.py /app/main.py
+
+# Set the working directory to the location of the program
+WORKDIR /app
+
+ENV DD_TRACE_DEBUG=false
+
+# Run the program when the container starts
+CMD python main.py
+# CMD ddprof -l notice --preset cpu_live_heap python main.py

scenarios/python_basic_memory_3.11/README.md

@@ -0,0 +1,29 @@
+## Basic Memory Profiling
+
+This test validates that the Datadog Python profiler correctly profiles memory allocations.
+
+## Test Application
+
+- Creates a list of `None` of a target size (1e6 items)
+- The list is then filled by two functions `allocate_memory_1` and `allocate_memory_2` that allocate
+  1024 bytes and 3 \* 1024 bytes respectively. The list is filled until the last item is not `None`.
+
+## Expected Profile
+
+### Samples
+
+Those represent the number of times the function called the allocator. This is hard to estimate manually
+because of how the sampling logic works
+(see [here](https://github.com/datadog/dd-trace-py/blob/9af78604497d1993826c59c351e1a4e53f817783/ddtrace/profiling/collector/_memalloc_tb.cpp#L329-L360)),
+but the numbers are stable.
+
+- `^<module>;run;allocate_memory_1$` should be present and should account for 25% of the samples.
+- `^<module>;run;allocate_memory_2$` should be present and should account for 45% of the samples.
+- `^<module>;__init__;grow_list$` should be present and should account for 20% of the samples.
+
+### Space
+
+- `^<module>;run;allocate_memory_1$` should be present and should account for 25% of the space (1024 bytes)
+- `^<module>;run;allocate_memory_2$` should be present and should account for 75% of the space (3 \* 1024 bytes)
+- `^<module>;__init__;grow_list$` should be present and should account for 3% of the space
+  (list container, noise compared to the other allocations)

scenarios/python_basic_memory_3.11/expected_profile.json

@@ -0,0 +1,127 @@
+{
+  "test_name": "python_memory_basic",
+  "pprof-regex": "",
+  "stacks": [
+    {
+      "profile-type": "alloc-samples",
+      "pprof-regex": "",
+      "stack-content": [
+        {
+          "regular_expression": "^\u003cmodule\u003e;run;allocate_memory_1.*$",
+          "percent": 35,
+          "error_margin": 5,
+          "labels": [
+            {
+              "key": "thread name",
+              "values": [
+                "MainThread"
+              ],
+              "values_regex": ""
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "profile-type": "alloc-samples",
+      "pprof-regex": "",
+      "stack-content": [
+        {
+          "regular_expression": "^\u003cmodule\u003e;run;allocate_memory_2.*$",
+          "percent": 45,
+          "error_margin": 5,
+          "labels": [
+            {
+              "key": "thread name",
+              "values": [
+                "MainThread"
+              ],
+              "values_regex": ""
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "profile-type": "alloc-samples",
+      "pprof-regex": "",
+      "stack-content": [
+        {
+          "regular_expression": "^.*__init__;.*grow_list.*$",
+          "percent": 19,
+          "error_margin": 5,
+          "labels": [
+            {
+              "key": "thread name",
+              "values": [
+                "MainThread"
+              ],
+              "values_regex": ""
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "profile-type": "alloc-space",
+      "pprof-regex": "",
+      "stack-content": [
+        {
+          "regular_expression": "^\u003cmodule\u003e;run;allocate_memory_1.*$",
+          "percent": 25,
+          "error_margin": 5,
+          "labels": [
+            {
+              "key": "thread name",
+              "values": [
+                "MainThread"
+              ],
+              "values_regex": ""
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "profile-type": "alloc-space",
+      "pprof-regex": "",
+      "stack-content": [
+        {
+          "regular_expression": "^\u003cmodule\u003e;run;allocate_memory_2.*$",
+          "percent": 75,
+          "error_margin": 5,
+          "labels": [
+            {
+              "key": "thread name",
+              "values": [
+                "MainThread"
+              ],
+              "values_regex": ""
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "profile-type": "alloc-space",
+      "pprof-regex": "",
+      "stack-content": [
+        {
+          "regular_expression": "^.*grow_list.*$",
+          "percent": 3,
+          "error_margin": 3,
+          "labels": [
+            {
+              "key": "thread name",
+              "values": [
+                "MainThread"
+              ],
+              "values_regex": ""
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "scale_by_duration": false
+}

scenarios/python_basic_memory_3.11/main.py

@@ -0,0 +1,37 @@
+from ddtrace.profiling import Profiler
+
+
+class Target:
+    def __init__(self) -> None:
+        self.memory: list[bytearray | None] = []
+        self.index = 0
+        self.grow_list(target=int(1e6))
+
+    def run(self) -> None:
+        while self.memory[-1] is None:
+            self.allocate_memory_1(1024)
+            self.allocate_memory_2(1024)
+
+    def grow_list(self, target: int) -> None:
+        self.memory = [None for _ in range(target)]
+
+    def allocate_memory_1(self, size: int) -> None:
+        self.memory[self.index] = bytearray(size)
+        self.index += 1
+
+    def allocate_memory_2(self, size: int) -> None:
+        self.memory[self.index] = bytearray(3 * size)
+        self.index += 1
+
+
+if __name__ == "__main__":
+    # Simple application that creates two threads with different durations:
+    # - MainThread runs target() for 2 seconds
+    # - Worker Thread-1 runs target() for 1 second
+    # The profiler should capture both threads with their respective durations.
+    prof = Profiler()
+    prof.start()  # Should be as early as possible, eg before other imports, to ensure everything is profiled
+
+    Target().run()
+
+    prof.stop()

scenarios/python_basic_memory_3.11/requirements.txt

@@ -0,0 +1 @@
+ddtrace==4.0.0