Revert "Add API to ART/Perfetto Java Heap Profiler"
This reverts commit 08e44f1a6289695530fcae887312fe69079ddf9a.
Bug: 160214819
Reason for revert: Tests breakage on target:
+CANNOT LINK EXECUTABLE "/apex/com.android.art/bin/dex2oatd32": library "heapprofd_client_api.so" not found: needed by /apex/com.android.art/lib/libartd.so in namespace com_android_art
Change-Id: I9509cc1e3c85ed4b1ec3347317c0e33fc1f96dea
diff --git a/runtime/Android.bp b/runtime/Android.bp
index 403a4c3..913a32f 100644
--- a/runtime/Android.bp
+++ b/runtime/Android.bp
@@ -380,7 +380,6 @@
"libicu",
"libstatssocket",
"libz", // For adler32.
- "heapprofd_client_api",
],
static_libs: [
"libstatslog_art",
diff --git a/runtime/gc/heap.cc b/runtime/gc/heap.cc
index 7cfa0fa..4ca6bf7 100644
--- a/runtime/gc/heap.cc
+++ b/runtime/gc/heap.cc
@@ -92,9 +92,6 @@
#include "mirror/var_handle.h"
#include "nativehelper/scoped_local_ref.h"
#include "obj_ptr-inl.h"
-#ifdef ART_TARGET_ANDROID
-#include "perfetto/heap_profile.h"
-#endif
#include "reflection.h"
#include "runtime.h"
#include "javaheapprof/javaheapsampler.h"
@@ -105,36 +102,6 @@
namespace art {
-#ifdef ART_TARGET_ANDROID
-namespace {
-
-// Enable the heap sampler Callback function used by Perfetto.
-void EnableHeapSamplerCallback(void* enable_ptr,
- const AHeapProfileEnableCallbackInfo* enable_info_ptr) {
- HeapSampler* sampler_self = reinterpret_cast<HeapSampler*>(enable_ptr);
- // Set the ART profiler sampling interval to the value from Perfetto.
- uint64_t interval = AHeapProfileEnableCallbackInfo_getSamplingInterval(enable_info_ptr);
- if (interval > 0) {
- sampler_self->SetSamplingInterval(interval);
- }
- // Else default is 4K sampling interval. However, default case shouldn't happen for Perfetto API.
- // AHeapProfileEnableCallbackInfo_getSamplingInterval should always give the requested
- // (non-negative) sampling interval. It is a uint64_t and gets checked for != 0
- // Do not call heap as a temp here, it will build but test run will silently fail.
- // Heap is not fully constructed yet in some cases.
- sampler_self->EnableHeapSampler();
-}
-
-// Disable the heap sampler Callback function used by Perfetto.
-void DisableHeapSamplerCallback(void* disable_ptr,
- const AHeapProfileDisableCallbackInfo* info_ptr ATTRIBUTE_UNUSED) {
- HeapSampler* sampler_self = reinterpret_cast<HeapSampler*>(disable_ptr);
- sampler_self->DisableHeapSampler();
-}
-
-} // namespace
-#endif
-
namespace gc {
DEFINE_RUNTIME_DEBUG_FLAG(Heap, kStressCollectorTransition);
@@ -382,6 +349,7 @@
kGcCountRateMaxBucketCount),
alloc_tracking_enabled_(false),
alloc_record_depth_(AllocRecordObjectMap::kDefaultAllocStackDepth),
+ perfetto_javaheapprof_heapid_(0),
backtrace_lock_(nullptr),
seen_backtrace_count_(0u),
unique_backtrace_count_(0u),
@@ -782,7 +750,7 @@
InitPerfettoJavaHeapProf();
} else {
// Disable the Java Heap Profiler.
- GetHeapSampler().DisableHeapSampler();
+ GetHeapSampler().DisableHeapSampler(/*disable_ptr=*/nullptr, /*disable_info_ptr=*/nullptr);
}
instrumentation::Instrumentation* const instrumentation = runtime->GetInstrumentation();
@@ -4078,25 +4046,15 @@
// Perfetto initialization.
void Heap::InitPerfettoJavaHeapProf() {
- // Initialize Perfetto Heap info and Heap id.
- uint32_t heap_id = 1; // Initialize to 1, to be overwritten by Perfetto heap id.
-#ifdef ART_TARGET_ANDROID
// Register the heap and create the heapid.
- // Use a Perfetto heap name = "com.android.art" for the Java Heap Profiler.
- AHeapInfo* info = AHeapInfo_create("com.android.art");
+ // Use a heap name = "HeapSampler".
+ // Initialize Perfetto Heap info and Heap id.
+ static uint32_t heap_id = 1; // Initialize to 1, to be overwritten by Perfetto heap id.
+ SetPerfettoJavaHeapProfHeapID(heap_id);
+ // Enable the Java Heap Profiler.
+ GetHeapSampler().EnableHeapSampler(/*enable_ptr=*/nullptr, /*enable_info_ptr=*/nullptr);
// Set the Enable Callback, there is no callback data ("nullptr").
- AHeapInfo_setEnabledCallback(info, &EnableHeapSamplerCallback, &heap_sampler_);
// Set the Disable Callback.
- AHeapInfo_setDisabledCallback(info, &DisableHeapSamplerCallback, &heap_sampler_);
- heap_id = AHeapProfile_registerHeap(info);
- // Do not enable the Java Heap Profiler in this case, wait for Perfetto to enable it through
- // the callback function.
-#else
- // This is the host case, enable the Java Heap Profiler for host testing.
- // Perfetto API is currently not available on host.
- heap_sampler_.EnableHeapSampler();
-#endif
- heap_sampler_.SetHeapID(heap_id);
VLOG(heap) << "Java Heap Profiler Initialized";
}
diff --git a/runtime/gc/heap.h b/runtime/gc/heap.h
index 35dce5e..d45f276 100644
--- a/runtime/gc/heap.h
+++ b/runtime/gc/heap.h
@@ -836,6 +836,16 @@
void DumpBlockingGcCountRateHistogram(std::ostream& os) const REQUIRES(!*gc_complete_lock_);
// Perfetto Art Heap Profiler Support.
+ // HeapID is a heap identifier used by the Perfetto API and is used in allocation reporting
+ // to Perfetto API.
+ void SetPerfettoJavaHeapProfHeapID(uint32_t heapid) {
+ perfetto_javaheapprof_heapid_ = heapid;
+ }
+
+ uint32_t GetPerfettoJavaHeapProfHeapID() const {
+ return perfetto_javaheapprof_heapid_;
+ }
+
HeapSampler& GetHeapSampler() {
return heap_sampler_;
}
@@ -1595,6 +1605,7 @@
size_t alloc_record_depth_;
// Perfetto Java Heap Profiler support.
+ uint32_t perfetto_javaheapprof_heapid_;
HeapSampler heap_sampler_;
// GC stress related data structures.
diff --git a/runtime/javaheapprof/javaheapsampler.cc b/runtime/javaheapprof/javaheapsampler.cc
index a73ed0b..a1c58d8 100644
--- a/runtime/javaheapprof/javaheapsampler.cc
+++ b/runtime/javaheapprof/javaheapsampler.cc
@@ -18,9 +18,6 @@
#include "base/locks.h"
#include "gc/heap.h"
#include "javaheapprof/javaheapsampler.h"
-#ifdef ART_TARGET_ANDROID
-#include "perfetto/heap_profile.h"
-#endif
#include "runtime.h"
namespace art {
@@ -61,13 +58,8 @@
// Also bytes_until_sample can only be updated after the allocation and reporting is done.
// Thus next bytes_until_sample is previously calculated (before allocation) to be able to
// get the next tlab_size, but only saved/updated here.
-void HeapSampler::ReportSample(art::mirror::Object* obj, size_t allocation_size) {
+void HeapSampler::ReportSample(art::mirror::Object* obj ATTRIBUTE_UNUSED, size_t allocation_size) {
VLOG(heap) << "JHP:***Report Perfetto Allocation: alloc_size: " << allocation_size;
- uint64_t perf_alloc_id = reinterpret_cast<uint64_t>(obj);
- VLOG(heap) << "JHP:***Report Perfetto Allocation: obj: " << perf_alloc_id;
-#ifdef ART_TARGET_ANDROID
- AHeapProfile_reportSample(perfetto_heap_id_, perf_alloc_id, allocation_size);
-#endif
}
// Check whether we should take a sample or not at this allocation and calculate the sample
@@ -131,19 +123,51 @@
<< " next_bytes_until_sample = " << next_bytes_until_sample;
}
+// Enable the heap sampler and initialize/set the sampling interval.
+void HeapSampler::EnableHeapSampler(void* enable_ptr ATTRIBUTE_UNUSED,
+ const void* enable_info_ptr ATTRIBUTE_UNUSED) {
+ uint64_t interval = 4 * 1024;
+ // Set the ART profiler sampling interval to the value from AHeapProfileSessionInfo
+ // Set interval to sampling interval from AHeapProfileSessionInfo
+ if (interval > 0) {
+ // Make sure that rng_ and geo_dist are thread safe by acquiring a lock to access.
+ art::MutexLock mu(art::Thread::Current(), geo_dist_rng_lock_);
+ SetSamplingInterval(interval);
+ }
+ // Else default is 4K sampling interval. However, default case shouldn't happen for Perfetto API.
+ // AHeapProfileEnableCallbackInfo_getSamplingInterval should always give the requested
+ // (non-negative) sampling interval. It is a uint64_t and gets checked for != 0
+ // Do not call heap->GetPerfettoJavaHeapProfHeapID() as a temp here, it will build but test run
+ // will silently fail. Heap is not fully constructed yet.
+ // heap_id will be set through the Perfetto API.
+ perfetto_heap_id_ = 1; // To be set by Perfetto API
+ enabled_.store(true, std::memory_order_release);
+}
+
bool HeapSampler::IsEnabled() {
return enabled_.load(std::memory_order_acquire);
}
+void HeapSampler::DisableHeapSampler(void* disable_ptr ATTRIBUTE_UNUSED,
+ const void* disable_info_ptr ATTRIBUTE_UNUSED) {
+ enabled_.store(false, std::memory_order_release);
+}
+
int HeapSampler::GetSamplingInterval() {
return p_sampling_interval_.load(std::memory_order_acquire);
}
void HeapSampler::SetSamplingInterval(int sampling_interval) {
- // Make sure that rng_ and geo_dist are thread safe by acquiring a lock to access.
- art::MutexLock mu(art::Thread::Current(), geo_dist_rng_lock_);
p_sampling_interval_.store(sampling_interval, std::memory_order_release);
geo_dist_.param(std::geometric_distribution<size_t>::param_type(1.0/p_sampling_interval_));
}
+void HeapSampler::SetSessionInfo(void* info) {
+ perfetto_session_info_ = info;
+}
+
+void* HeapSampler::GetSessionInfo() {
+ return perfetto_session_info_;
+}
+
} // namespace art
diff --git a/runtime/javaheapprof/javaheapsampler.h b/runtime/javaheapprof/javaheapsampler.h
index 618893c..02cb7b7 100644
--- a/runtime/javaheapprof/javaheapsampler.h
+++ b/runtime/javaheapprof/javaheapsampler.h
@@ -42,15 +42,6 @@
thread_local size_t bytes_until_sample = 0;
return &bytes_until_sample;
}
- void SetHeapID(uint32_t heap_id) {
- perfetto_heap_id_ = heap_id;
- }
- void EnableHeapSampler() {
- enabled_.store(true, std::memory_order_release);
- }
- void DisableHeapSampler() {
- enabled_.store(false, std::memory_order_release);
- }
// Report a sample to Perfetto.
void ReportSample(art::mirror::Object* obj, size_t allocation_size);
// Check whether we should take a sample or not at this allocation, and return the
@@ -69,10 +60,16 @@
void AdjustSampleOffset(size_t adjustment);
// Is heap sampler enabled?
bool IsEnabled();
+ void EnableHeapSampler(void* enable_ptr, const void* enable_info_ptr);
+ void DisableHeapSampler(void* disable_ptr, const void* disable_info_ptr);
// Set the sampling interval.
- void SetSamplingInterval(int sampling_interval) REQUIRES(!geo_dist_rng_lock_);
+ void SetSamplingInterval(int sampling_interval) REQUIRES(geo_dist_rng_lock_);
// Return the sampling interval.
int GetSamplingInterval();
+ // Set the Perfetto Session Info.
+ void SetSessionInfo(void* info);
+ // Get the Perfetto Session Info.
+ void* GetSessionInfo();
private:
size_t NextGeoDistRandSample() REQUIRES(!geo_dist_rng_lock_);
@@ -84,6 +81,7 @@
// Default sampling interval is 4kb.
// Writes guarded by geo_dist_rng_lock_.
std::atomic<int> p_sampling_interval_{4 * 1024};
+ void* perfetto_session_info_;
uint32_t perfetto_heap_id_ = 0;
// std random number generator.
std::minstd_rand rng_ GUARDED_BY(geo_dist_rng_lock_); // Holds the state