[Prototype] Lazy jmethodIDs phase 2: keep names of classes unloaded before the dump

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

@@ -304,8 +304,13 @@ Error Arguments::parse(const char *args) {
       if (value != nullptr) {
         if (strcmp(value, "false") == 0) {
           _force_jmethodID = false;
+          _lazy_jmethodID = false;
         } else if (strcmp(value, "true") == 0) {
           _force_jmethodID = true;
+          _lazy_jmethodID = false;
+        } else if (strcmp(value, "lazy") == 0) {
+          _force_jmethodID = false;
+          _lazy_jmethodID = true;
         } else {
           msg = "Invalid jmethodID creation value";
         }

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

@@ -274,6 +274,7 @@ class Arguments {
   bool _nativesocket;
   long _nativesocket_interval;  // initial sampling period in nanoseconds; 0 = engine default
   bool _force_jmethodID;       // Load all jmethodIDs, true by default
+  bool _lazy_jmethodID;        // fjmethodid=lazy: allocate jmethodIDs only for sampled classes, at dump time
 
   Arguments(bool persistent = false)
       : _buf(NULL),
@@ -324,7 +325,8 @@ class Arguments {
         _jvmtistacks(false),
         _nativesocket(false),
         _nativesocket_interval(0),
-        _force_jmethodID(true) {}
+        _force_jmethodID(true),
+        _lazy_jmethodID(false) {}
 
   ~Arguments();
 

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

@@ -169,10 +169,66 @@
   X(METHOD_RESOLVE_FAULT_RECOVERED, "method_resolve_fault_recovered")         \
   /* Symbol length/body rejected during the same resolution: unreadable body,  \
    * empty (recycled slot), or over MAX_SYMBOL_LEN. A name that merely exceeds \
-   * the fixed inline buffers in hotspotSupport.cpp's ResolvedNames still      \
+   * the fixed inline buffers in ResolvedMethod (hotspotSupport.h) still     \
    * resolves via its malloc fallback and does not land here. The frame        \
    * serializes as "unknown". */                                               \
   X(METHOD_RESOLVE_SYMBOL_UNREADABLE, "method_resolve_symbol_unreadable")     \
+  /* fjmethodid=lazy resolution outcomes. UNLOADED: the frame's class is no   \
+   * longer registered or reachable. NOT_CURRENT: the class is alive but the  \
+   * Method* is not among its current methods (freed or redefined). Both      \
+   * serialize as "unknown". RESOLVED: raw frames whose names were read from  \
+   * VM metadata, once per method and tag per dump. */                        \
+  X(METHOD_RESOLVE_LAZY_UNLOADED, "method_resolve_lazy_unloaded")             \
+  X(METHOD_RESOLVE_LAZY_NOT_CURRENT, "method_resolve_lazy_not_current")       \
+  X(METHOD_RESOLVE_LAZY_RESOLVED, "method_resolve_lazy_resolved")             \
+  /* STALE: the class now at the frame's holder address is a different load \
+   * (its trace ID differs); serializes as "unknown".                        \
+   * ADD_FAILED: registration failed, so the class was preloaded instead.    \
+   * UNTAGGABLE: a Method* using address bits the raw-frame tag needs, or   \
+   * an unreadable holder trace ID; the frame is stored as not walkable. */  \
+  X(METHOD_RESOLVE_LAZY_STALE, "method_resolve_lazy_stale")                   \
+  /* REDEFINED: raw frame of a class that has been redefined (its Method*s   \
+   * may have been freed and reused); serializes as "unknown". */            \
+  X(METHOD_RESOLVE_LAZY_REDEFINED, "method_resolve_lazy_redefined")           \
+  /* Registered classes marked by the redefinition hooks (once per class   \
+   * per redefine/retransform call). */                                      \
+  X(KLASS_REGISTRY_REDEFINITIONS_MARKED, "klass_registry_redefinitions_marked") \
+  /* Registrations whose class trace ID no longer fits in a raw frame's     \
+   * 25-bit tag. Nonzero means trace-ID tags of two classes can now collide: \
+   * a frame sampled from an unloaded class could then, if a newer class     \
+   * also took over its Method* memory, resolve to that class's method. */   \
+  X(KLASS_TRACE_ID_BEYOND_TAG_RANGE, "klass_trace_id_beyond_tag_range")       \
+  /* Raw Method* frame occurrences answered from Lookup's per-dump cache    \
+   * instead of resolving them again. */                                     \
+  X(RAW_FRAME_RESOLVE_CACHE_HITS, "raw_frame_resolve_cache_hits")             \
+  X(KLASS_REGISTRY_ADD_FAILED, "klass_registry_add_failed")                   \
+  /* PROTOTYPE UnloadCapture (DDPROF_CAPTURE_UNLOADING=1). */                 \
+  X(UNLOAD_CAPTURE_PENDING_ADDED, "unload_capture_pending_added")             \
+  X(UNLOAD_CAPTURE_PENDING_OVERFLOW, "unload_capture_pending_overflow")       \
+  X(UNLOAD_CAPTURE_HOOK_CALLS, "unload_capture_hook_calls")                   \
+  X(UNLOAD_CAPTURE_HOOK_BUSY, "unload_capture_hook_busy")                     \
+  X(UNLOAD_CAPTURE_HOOK_NS, "unload_capture_hook_ns")                         \
+  X(UNLOAD_CAPTURE_HOOK_MAX_NS, "unload_capture_hook_max_ns")                 \
+  X(UNLOAD_CAPTURE_CAPTURED, "unload_capture_captured")                       \
+  X(UNLOAD_CAPTURE_REFUSED, "unload_capture_refused")                         \
+  X(UNLOAD_CAPTURE_CACHE_FULL, "unload_capture_cache_full")                   \
+  X(UNLOAD_CAPTURE_USED, "unload_capture_used")                               \
+  X(UNLOAD_CAPTURE_BG_PASSES, "unload_capture_bg_passes")                     \
+  X(UNLOAD_CAPTURE_BG_NS, "unload_capture_bg_ns")                             \
+  X(UNLOAD_CAPTURE_BG_CPU_NS, "unload_capture_bg_cpu_ns")                     \
+  X(UNLOAD_CAPTURE_PENDING_EVICTED, "unload_capture_pending_evicted")         \
+  X(UNLOAD_CAPTURE_BG_MAX_NS, "unload_capture_bg_max_ns")                     \
+  X(UNLOAD_CAPTURE_BG_CAPTURED, "unload_capture_bg_captured")                 \
+  X(UNLOAD_CAPTURE_BG_REFUSED, "unload_capture_bg_refused")                   \
+  X(UNLOAD_CAPTURE_HOOK_DRAINED, "unload_capture_hook_drained")               \
+  /* PROTOTYPE: lazy frames whose Method* could not even be read at dump      \
+   * (freed metadata), not covered by the method_resolve_lazy_* counters. */  \
+  X(METHOD_RESOLVE_LAZY_UNREADABLE, "method_resolve_lazy_unreadable")         \
+  X(WALKVM_RAW_FRAME_UNTAGGABLE, "walkvm_raw_frame_untaggable")               \
+  /* Gauge, set at each fjmethodid=lazy start: the Klass::_trace_id offset  \
+   * raw frames are tagged with, or -1 if it was not found (lazy mode then    \
+   * falls back to fjmethodid=false). 0 if lazy mode was never requested. */  \
+  X(KLASS_TRACE_ID_OFFSET, "klass_trace_id_offset")                           \
   /* Strict subset of SAMPLES_DROPPED_THREAD_LOCAL, not an independent count: \
    * ThreadLocalDataPool::claim() increments this on capacity exhaustion, and \
    * every acquireCurrent() caller that gets nullptr back -- for this or any  \