Drop free event tracking from native malloc profiler

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: jbachorik

ddprof-lib/src/main/cpp/arguments.cpp

@@ -380,13 +380,6 @@ Error Arguments::parse(const char *args) {
         msg = "nativemem must be >= 0";
       }
 
-      CASE("nofree")
-      if (value != NULL && (value[0] == 'f' || value[0] == 'n' || value[0] == '0')) {
-        _nofree = false;
-      } else {
-        _nofree = true;
-      }
-
       DEFAULT()
       if (_unknown_arg == NULL)
         _unknown_arg = arg;

ddprof-lib/src/main/cpp/arguments.h

@@ -177,7 +177,6 @@ class Arguments {
   bool _record_heap_usage;
   bool _gc_generations;
   long _nativemem;
-  bool _nofree;
   int  _jstackdepth;
   int _safe_mode;
   StackWalkFeatures _features;
@@ -213,7 +212,6 @@ class Arguments {
         _record_heap_usage(false),
         _gc_generations(false),
         _nativemem(-1),
-        _nofree(true),
         _jstackdepth(DEFAULT_JSTACKDEPTH),
         _safe_mode(0),
         _features{1, 1, 1, 1, 1, 1},

ddprof-lib/src/main/cpp/flightRecorder.cpp

@@ -1578,15 +1578,13 @@ void Recording::recordAllocation(RecordingBuffer *buf, int tid,
 void Recording::recordMallocSample(Buffer *buf, int tid, u64 call_trace_id,
                                    MallocEvent *event) {
   int start = buf->skip(1);
-  buf->putVar64(event->_size != 0 ? T_MALLOC : T_FREE);
+  buf->putVar64(T_MALLOC);
   buf->putVar64(event->_start_time);
   buf->putVar32(tid);
   buf->putVar64(call_trace_id);
   buf->putVar64(event->_address);
-  if (event->_size != 0) {
-    buf->putVar64(event->_size);
-    buf->putFloat(event->_weight);
-  }
+  buf->putVar64(event->_size);
+  buf->putFloat(event->_weight);
   writeContext(buf, Contexts::get());
   writeEventSizePrefix(buf, start);
   flushIfNeeded(buf);

ddprof-lib/src/main/cpp/jfrMetadata.cpp

@@ -299,16 +299,6 @@ void JfrMetadata::initialize(
                   << field("localRootSpanId", T_LONG, "Local Root Span ID") ||
               contextAttributes)
 
-          << (type("profiler.Free", T_FREE, "free")
-                  << category("Java Virtual Machine", "Native Memory")
-                  << field("startTime", T_LONG, "Start Time", F_TIME_TICKS)
-                  << field("eventThread", T_THREAD, "Event Thread", F_CPOOL)
-                  << field("stackTrace", T_STACK_TRACE, "Stack Trace", F_CPOOL)
-                  << field("address", T_LONG, "Address", F_ADDRESS)
-                  << field("spanId", T_LONG, "Span ID")
-                  << field("localRootSpanId", T_LONG, "Local Root Span ID") ||
-              contextAttributes)
-
           << (type("jdk.OSInformation", T_OS_INFORMATION, "OS Information")
               << category("Operating System")
               << field("startTime", T_LONG, "Start Time", F_TIME_TICKS)

ddprof-lib/src/main/cpp/jfrMetadata.h

@@ -80,7 +80,6 @@ enum JfrType {
   T_DATADOG_COUNTER = 125,
   T_UNWIND_FAILURE = 126,
   T_MALLOC = 127,
-  T_FREE = 128,
   T_ANNOTATION = 200,
   T_LABEL = 201,
   T_CATEGORY = 202,

ddprof-lib/src/main/cpp/mallocTracer.cpp

@@ -62,24 +62,14 @@ void* calloc_hook_dummy(size_t num, size_t size) {
 
 extern "C" void* realloc_hook(void* addr, size_t size) {
     void* ret = _orig_realloc(addr, size);
-    if (MallocTracer::running()) {
-        // On POSIX, realloc(ptr, 0) may return NULL and free ptr.
-        // Only record the free if allocation didn't simply fail (size > 0 with NULL ret = ENOMEM).
-        if (addr && !MallocTracer::nofree() && (ret != NULL || size == 0)) {
-            MallocTracer::recordFree(addr);
-        }
-        if (ret != NULL && size > 0) {
-            MallocTracer::recordMalloc(ret, size);
-        }
+    if (MallocTracer::running() && ret != NULL && size > 0) {
+        MallocTracer::recordMalloc(ret, size);
     }
     return ret;
 }
 
 extern "C" void free_hook(void* addr) {
     _orig_free(addr);
-    if (MallocTracer::running() && !MallocTracer::nofree() && addr) {
-        MallocTracer::recordFree(addr);
-    }
 }
 
 extern "C" int posix_memalign_hook(void** memptr, size_t alignment, size_t size) {
@@ -105,7 +95,6 @@ extern "C" void* aligned_alloc_hook(size_t alignment, size_t size) {
 }
 
 volatile u64 MallocTracer::_interval;
-bool MallocTracer::_nofree;
 volatile u64 MallocTracer::_bytes_until_sample;
 u64 MallocTracer::_configured_interval;
 volatile u64 MallocTracer::_sample_count;
@@ -298,22 +287,12 @@ void MallocTracer::recordMalloc(void* address, size_t size) {
     }
 }
 
-void MallocTracer::recordFree(void* address) {
-    MallocEvent event;
-    event._start_time = TSC::ticks();
-    event._address = (uintptr_t)address;
-    event._size = 0;
-
-    Profiler::instance()->recordSample(NULL, 0, OS::threadId(), BCI_NATIVE_MALLOC, 0, &event);
-}
-
 Error MallocTracer::start(Arguments& args) {
     _configured_interval = args._nativemem > 0 ? args._nativemem : 0;
     _interval = _configured_interval;
-    _nofree = args._nofree;
     _bytes_until_sample = _configured_interval > 1 ? nextPoissonInterval() : 0;
     _sample_count = 0;
-    _last_config_update_ts = OS::nanotime();
+    __atomic_store_n(&_last_config_update_ts, OS::nanotime(), __ATOMIC_RELEASE);
 
     if (!_initialized) {
         initialize();

ddprof-lib/src/main/cpp/mallocTracer.h

@@ -15,7 +15,6 @@
 class MallocTracer : public Engine {
   private:
     static volatile u64 _interval;
-    static bool _nofree;
     static volatile u64 _bytes_until_sample;
 
     static u64 _configured_interval;
@@ -53,12 +52,7 @@ class MallocTracer : public Engine {
         }
     }
 
-    static inline bool nofree() {
-        return _nofree;
-    }
-
     static void recordMalloc(void* address, size_t size);
-    static void recordFree(void* address);
 };
 
 #endif // _MALLOCTRACER_H

ddprof-test/src/test/java/com/datadoghq/profiler/nativemem/NativememProfilerTest.java

@@ -20,16 +20,14 @@
 
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.openjdk.jmc.common.item.Attribute.attr;
 import static org.openjdk.jmc.common.unit.UnitLookup.ADDRESS;
 
 /**
- * Smoke tests for native memory (malloc/free) profiling.
+ * Smoke tests for native memory (malloc) profiling.
  *
  * <p>Runs with {@code cstack=vm} and {@code cstack=vmx}. In {@code vmx} mode the
  * stack trace is expected to contain {@code allocateDirect} because the mixed-mode
@@ -94,57 +92,4 @@ public void shouldRecordMallocSamples() throws InterruptedException {
         buffers.clear(); // keep alive until after stop
     }
 
-    @RetryTest(3)
-    @TestTemplate
-    @ValueSource(strings = {"vm", "vmx"})
-    public void shouldRecordFreeEvents() throws InterruptedException {
-        Assumptions.assumeFalse(isAsan() || isTsan());
-
-        // Allocate and immediately abandon so the GC Cleaner will call free()
-        for (int i = 0; i < 1000; i++) {
-            ByteBuffer.allocateDirect(1024);
-        }
-        for (int attempt = 0; attempt < 5; attempt++) {
-            System.gc();
-            Thread.sleep(200);
-        }
-
-        stopProfiler();
-
-        IItemCollection mallocEvents = verifyEvents("profiler.Malloc");
-        IItemCollection freeEvents = verifyEvents("profiler.Free");
-
-        // Collect all recorded malloc addresses
-        Set<Long> mallocAddresses = new HashSet<>();
-        for (IItemIterable items : mallocEvents) {
-            IMemberAccessor<IQuantity, IItem> addrAccessor = MALLOC_ADDRESS.getAccessor(items.getType());
-            if (addrAccessor == null) {
-                continue;
-            }
-            for (IItem item : items) {
-                IQuantity addr = addrAccessor.getMember(item);
-                if (addr != null) {
-                    mallocAddresses.add(addr.longValue());
-                }
-            }
-        }
-
-        // At least one free event address must match a previously recorded malloc address
-        boolean foundCorrelation = false;
-        outer:
-        for (IItemIterable items : freeEvents) {
-            IMemberAccessor<IQuantity, IItem> addrAccessor = MALLOC_ADDRESS.getAccessor(items.getType());
-            if (addrAccessor == null) {
-                continue;
-            }
-            for (IItem item : items) {
-                IQuantity addr = addrAccessor.getMember(item);
-                if (addr != null && mallocAddresses.contains(addr.longValue())) {
-                    foundCorrelation = true;
-                    break outer;
-                }
-            }
-        }
-        assertTrue(foundCorrelation, "expected at least one free event whose address matches a recorded malloc");
-    }
 }