fix(profiling): remove slow getpid call from memalloc path [backport 2.18]

ddtrace/profiling/collector/_memalloc.c

@@ -57,6 +57,28 @@ static alloc_tracker_t* global_alloc_tracker;
 static void
 memalloc_init(void);
 
+static void
+memalloc_prefork(void)
+{
+    // Lock the mutex prior to forking. This ensures that the memory profiler
+    // data structures will be in a consistent state in the child process.
+    // The rest of the memalloc calls do trylock so we don't run the risk
+    // of deadlocking if some other fork handler allocates
+    memlock_lock(&g_memalloc_lock);
+}
+
+static void
+memalloc_postfork_parent(void)
+{
+    memlock_unlock(&g_memalloc_lock);
+}
+
+static void
+memalloc_postfork_child(void)
+{
+    memlock_unlock(&g_memalloc_lock);
+}
+
 #ifdef _MSC_VER
 #pragma section(".CRT$XCU", read)
 __declspec(allocate(".CRT$XCU")) void (*memalloc_init_func)(void) = memalloc_init;
@@ -81,6 +103,9 @@ memalloc_init()
         }
     }
     memlock_init(&g_memalloc_lock, crash_on_mutex_pass);
+#ifndef _WIN32
+    pthread_atfork(memalloc_prefork, memalloc_postfork_parent, memalloc_postfork_child);
+#endif
 }
 
 static void

ddtrace/profiling/collector/_memalloc_heap.c

@@ -36,6 +36,25 @@ static heap_tracker_t global_heap_tracker;
 static void
 memheap_init(void);
 
+static void
+memheap_prefork(void)
+{
+    // See memalloc_prefork for an explanation of why this is here
+    memlock_lock(&g_memheap_lock);
+}
+
+static void
+memheap_postfork_parent(void)
+{
+    memlock_unlock(&g_memheap_lock);
+}
+
+static void
+memheap_postfork_child(void)
+{
+    memlock_unlock(&g_memheap_lock);
+}
+
 #ifdef _MSC_VER
 #pragma section(".CRT$XCU", read)
 __declspec(allocate(".CRT$XCU")) void (*memheap_init_func)(void) = memheap_init;
@@ -60,6 +79,9 @@ memheap_init()
         }
     }
     memlock_init(&g_memheap_lock, crash_on_mutex_pass);
+#ifndef _WIN32
+    pthread_atfork(memheap_prefork, memheap_postfork_parent, memheap_postfork_child);
+#endif
 }
 
 static uint32_t

ddtrace/profiling/collector/_memalloc_reentrant.h

@@ -125,19 +125,6 @@ memlock_trylock(memlock_t* lock)
     if (!lock)
         return false;
 
-#ifdef __linux__
-    // On Linux, we need to make sure we didn't just fork
-    // pthreads will guarantee the lock is consistent, but we at least need to clear it
-    static pid_t my_pid = 0;
-    if (my_pid == 0) {
-        my_pid = getpid();
-    } else if (my_pid != getpid()) {
-        // We've forked, so we need to free the lock
-        memlock_unlock(lock);
-        my_pid = getpid();
-    }
-#endif
-
 #ifdef _WIN32
     bool result = WAIT_OBJECT_0 == WaitForSingleObject(lock->mutex, 0); // 0ms timeout -> no wait
 #else
@@ -153,6 +140,19 @@ memlock_trylock(memlock_t* lock)
     return result;
 }
 
+static inline void
+memlock_lock(memlock_t* lock)
+{
+    if (!lock)
+        return;
+
+#ifdef _WIN32
+    WaitForSingleObject(lock->mutex, INFINITE);
+#else
+    pthread_mutex_lock(&lock->mutex);
+#endif
+}
+
 // Cleanup function
 static inline bool
 memlock_destroy(memlock_t* lock)

releasenotes/notes/profiling-remove-getpid-from-memalloc-74f54043accdfc9e.yaml

@@ -0,0 +1,5 @@
+---
+fixes:
+  - |
+    profiling: Removed a system call from the memory allocation profiler, used to detect forks,
+    which ran on every allocation and resulted in a significant slowdown.