Add a test checking that ART Metrics are enabled in ART's CMC collector.
ART GC Metrics are currently only enabled in ART's Concurrent Copying
(CC) collector; add a test to ensure this is and will still be true.
Test: ART_USE_READ_BARRIER=true ART_USE_GENERATIONAL_CC=true \
m test-art-host-gtest-art_runtime_tests
Test: ART_USE_READ_BARRIER=true ART_USE_GENERATIONAL_CC=false \
m test-art-host-gtest-art_runtime_tests
Test: ART_USE_READ_BARRIER=false \
m test-art-host-gtest-art_runtime_tests
Bug: 270391874
Change-Id: I00bc64fdb665fe1a61b7b571963231ae51e82fea
diff --git a/libartbase/base/metrics/metrics.h b/libartbase/base/metrics/metrics.h
index baaa7d8..512ce34 100644
--- a/libartbase/base/metrics/metrics.h
+++ b/libartbase/base/metrics/metrics.h
@@ -29,6 +29,7 @@
#include "android-base/logging.h"
#include "base/bit_utils.h"
+#include "base/macros.h"
#include "base/time_utils.h"
#include "tinyxml2.h"
@@ -106,6 +107,17 @@
struct RuntimeArgumentMap;
namespace metrics {
+template <typename value_t>
+class MetricsBase;
+} // namespace metrics
+
+namespace gc {
+class HeapTest_GCMetrics_Test;
+template <typename T>
+bool AnyIsNonNull(const metrics::MetricsBase<T>* x, const metrics::MetricsBase<T>* y);
+} // namespace gc
+
+namespace metrics {
/**
* An enumeration of all ART counters and histograms.
@@ -286,6 +298,15 @@
public:
virtual void Add(value_t value) = 0;
virtual ~MetricsBase() { }
+
+ private:
+ // Is the metric "null", i.e. never updated or freshly reset?
+ // Used for testing purpose only.
+ virtual bool IsNull() const = 0;
+
+ ART_FRIEND_TEST(gc::HeapTest, GCMetrics);
+ template <typename T>
+ friend bool gc::AnyIsNonNull(const MetricsBase<T>* x, const MetricsBase<T>* y);
};
template <DatumId counter_type, typename T = uint64_t>
@@ -316,6 +337,8 @@
value_t Value() const { return value_.load(std::memory_order::memory_order_relaxed); }
private:
+ bool IsNull() const override { return Value() == 0; }
+
std::atomic<value_t> value_;
static_assert(std::atomic<value_t>::is_always_lock_free);
@@ -366,6 +389,10 @@
}
private:
+ count_t Count() const { return count_.load(std::memory_order::memory_order_relaxed); }
+
+ bool IsNull() const override { return Count() == 0; }
+
std::atomic<count_t> count_;
static_assert(std::atomic<count_t>::is_always_lock_free);
@@ -400,6 +427,10 @@
void Reset() { value_ = 0; }
private:
+ value_t Value() const { return value_.load(std::memory_order::memory_order_relaxed); }
+
+ bool IsNull() const override { return Value() == 0; }
+
std::atomic<value_t> value_;
static_assert(std::atomic<value_t>::is_always_lock_free);
@@ -465,6 +496,11 @@
return std::vector<value_t>{buckets_.begin(), buckets_.end()};
}
+ bool IsNull() const override {
+ std::vector<value_t> buckets = GetBuckets();
+ return std::all_of(buckets.cbegin(), buckets.cend(), [](value_t i) { return i == 0; });
+ }
+
std::array<std::atomic<value_t>, num_buckets_> buckets_;
static_assert(std::atomic<value_t>::is_always_lock_free);
@@ -508,6 +544,8 @@
private:
T Value() const { return value_.load(std::memory_order::memory_order_relaxed); }
+ bool IsNull() const override { return Value() == 0; }
+
std::atomic<T> value_;
friend class ArtMetrics;
diff --git a/runtime/gc/heap_test.cc b/runtime/gc/heap_test.cc
index 55ddd72..7fa37f3 100644
--- a/runtime/gc/heap_test.cc
+++ b/runtime/gc/heap_test.cc
@@ -14,6 +14,9 @@
* limitations under the License.
*/
+#include <algorithm>
+
+#include "base/metrics/metrics.h"
#include "class_linker-inl.h"
#include "common_runtime_test.h"
#include "gc/accounting/card_table-inl.h"
@@ -103,6 +106,143 @@
Runtime::Current()->SetDumpGCPerformanceOnShutdown(true);
}
+template <typename T>
+bool AnyIsNonNull(const metrics::MetricsBase<T>* x, const metrics::MetricsBase<T>* y) {
+ return !x->IsNull() || !y->IsNull();
+}
+
+TEST_F(HeapTest, GCMetrics) {
+ // Allocate a few string objects (to be collected), then trigger garbage
+ // collection, and check that GC metrics are updated (where applicable).
+ {
+ constexpr const size_t kNumObj = 128;
+ ScopedObjectAccess soa(Thread::Current());
+ StackHandleScope<kNumObj> hs(soa.Self());
+ for (size_t i = 0u; i < kNumObj; ++i) {
+ Handle<mirror::String> string [[maybe_unused]] (
+ hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "test")));
+ }
+ }
+ Heap* heap = Runtime::Current()->GetHeap();
+ heap->CollectGarbage(/* clear_soft_references= */ false);
+
+ // ART Metrics.
+ metrics::ArtMetrics* metrics = Runtime::Current()->GetMetrics();
+ // ART full-heap GC metrics.
+ metrics::MetricsBase<int64_t>* full_gc_collection_time = metrics->FullGcCollectionTime();
+ metrics::MetricsBase<uint64_t>* full_gc_count = metrics->FullGcCount();
+ metrics::MetricsBase<uint64_t>* full_gc_count_delta = metrics->FullGcCountDelta();
+ metrics::MetricsBase<int64_t>* full_gc_throughput = metrics->FullGcThroughput();
+ metrics::MetricsBase<int64_t>* full_gc_tracing_throughput = metrics->FullGcTracingThroughput();
+ metrics::MetricsBase<uint64_t>* full_gc_throughput_avg = metrics->FullGcThroughputAvg();
+ metrics::MetricsBase<uint64_t>* full_gc_tracing_throughput_avg =
+ metrics->FullGcTracingThroughputAvg();
+ metrics::MetricsBase<uint64_t>* full_gc_scanned_bytes = metrics->FullGcScannedBytes();
+ metrics::MetricsBase<uint64_t>* full_gc_scanned_bytes_delta = metrics->FullGcScannedBytesDelta();
+ metrics::MetricsBase<uint64_t>* full_gc_freed_bytes = metrics->FullGcFreedBytes();
+ metrics::MetricsBase<uint64_t>* full_gc_freed_bytes_delta = metrics->FullGcFreedBytesDelta();
+ metrics::MetricsBase<uint64_t>* full_gc_duration = metrics->FullGcDuration();
+ metrics::MetricsBase<uint64_t>* full_gc_duration_delta = metrics->FullGcDurationDelta();
+ // ART young-generation GC metrics.
+ metrics::MetricsBase<int64_t>* young_gc_collection_time = metrics->YoungGcCollectionTime();
+ metrics::MetricsBase<uint64_t>* young_gc_count = metrics->YoungGcCount();
+ metrics::MetricsBase<uint64_t>* young_gc_count_delta = metrics->YoungGcCountDelta();
+ metrics::MetricsBase<int64_t>* young_gc_throughput = metrics->YoungGcThroughput();
+ metrics::MetricsBase<int64_t>* young_gc_tracing_throughput = metrics->YoungGcTracingThroughput();
+ metrics::MetricsBase<uint64_t>* young_gc_throughput_avg = metrics->YoungGcThroughputAvg();
+ metrics::MetricsBase<uint64_t>* young_gc_tracing_throughput_avg =
+ metrics->YoungGcTracingThroughputAvg();
+ metrics::MetricsBase<uint64_t>* young_gc_scanned_bytes = metrics->YoungGcScannedBytes();
+ metrics::MetricsBase<uint64_t>* young_gc_scanned_bytes_delta =
+ metrics->YoungGcScannedBytesDelta();
+ metrics::MetricsBase<uint64_t>* young_gc_freed_bytes = metrics->YoungGcFreedBytes();
+ metrics::MetricsBase<uint64_t>* young_gc_freed_bytes_delta = metrics->YoungGcFreedBytesDelta();
+ metrics::MetricsBase<uint64_t>* young_gc_duration = metrics->YoungGcDuration();
+ metrics::MetricsBase<uint64_t>* young_gc_duration_delta = metrics->YoungGcDurationDelta();
+
+ CollectorType fg_collector_type = heap->GetForegroundCollectorType();
+ if (fg_collector_type == kCollectorTypeCC) {
+ // Only the Concurrent Copying collector enables GC metrics at the moment.
+ if (heap->GetUseGenerationalCC()) {
+ // Check that full-heap and/or young-generation GC metrics are non-null
+ // after trigerring the collection.
+ EXPECT_PRED2(AnyIsNonNull<int64_t>, full_gc_collection_time, young_gc_collection_time);
+ EXPECT_PRED2(AnyIsNonNull<uint64_t>, full_gc_count, young_gc_count);
+ EXPECT_PRED2(AnyIsNonNull<uint64_t>, full_gc_count_delta, young_gc_count_delta);
+ EXPECT_PRED2(AnyIsNonNull<int64_t>, full_gc_throughput, young_gc_throughput);
+ EXPECT_PRED2(AnyIsNonNull<int64_t>, full_gc_tracing_throughput, young_gc_tracing_throughput);
+ EXPECT_PRED2(AnyIsNonNull<uint64_t>, full_gc_throughput_avg, young_gc_throughput_avg);
+ EXPECT_PRED2(
+ AnyIsNonNull<uint64_t>, full_gc_tracing_throughput_avg, young_gc_tracing_throughput_avg);
+ EXPECT_PRED2(AnyIsNonNull<uint64_t>, full_gc_scanned_bytes, young_gc_scanned_bytes);
+ EXPECT_PRED2(
+ AnyIsNonNull<uint64_t>, full_gc_scanned_bytes_delta, young_gc_scanned_bytes_delta);
+ EXPECT_PRED2(AnyIsNonNull<uint64_t>, full_gc_freed_bytes, young_gc_freed_bytes);
+ EXPECT_PRED2(AnyIsNonNull<uint64_t>, full_gc_freed_bytes_delta, young_gc_freed_bytes_delta);
+ EXPECT_PRED2(AnyIsNonNull<uint64_t>, full_gc_duration, young_gc_duration);
+ EXPECT_PRED2(AnyIsNonNull<uint64_t>, full_gc_duration_delta, young_gc_duration_delta);
+ } else {
+ // Check that only full-heap GC metrics are non-null after trigerring the collection.
+ EXPECT_FALSE(full_gc_collection_time->IsNull());
+ EXPECT_FALSE(full_gc_count->IsNull());
+ EXPECT_FALSE(full_gc_count_delta->IsNull());
+ EXPECT_FALSE(full_gc_throughput->IsNull());
+ EXPECT_FALSE(full_gc_tracing_throughput->IsNull());
+ EXPECT_FALSE(full_gc_throughput_avg->IsNull());
+ EXPECT_FALSE(full_gc_tracing_throughput_avg->IsNull());
+ EXPECT_FALSE(full_gc_scanned_bytes->IsNull());
+ EXPECT_FALSE(full_gc_scanned_bytes_delta->IsNull());
+ EXPECT_FALSE(full_gc_freed_bytes->IsNull());
+ EXPECT_FALSE(full_gc_freed_bytes_delta->IsNull());
+ EXPECT_FALSE(full_gc_duration->IsNull());
+ EXPECT_FALSE(full_gc_duration_delta->IsNull());
+
+ EXPECT_TRUE(young_gc_collection_time->IsNull());
+ EXPECT_TRUE(young_gc_count->IsNull());
+ EXPECT_TRUE(young_gc_count_delta->IsNull());
+ EXPECT_TRUE(young_gc_throughput->IsNull());
+ EXPECT_TRUE(young_gc_tracing_throughput->IsNull());
+ EXPECT_TRUE(young_gc_throughput_avg->IsNull());
+ EXPECT_TRUE(young_gc_tracing_throughput_avg->IsNull());
+ EXPECT_TRUE(young_gc_scanned_bytes->IsNull());
+ EXPECT_TRUE(young_gc_scanned_bytes_delta->IsNull());
+ EXPECT_TRUE(young_gc_freed_bytes->IsNull());
+ EXPECT_TRUE(young_gc_freed_bytes_delta->IsNull());
+ EXPECT_TRUE(young_gc_duration->IsNull());
+ EXPECT_TRUE(young_gc_duration_delta->IsNull());
+ }
+ } else {
+ // Check that all metrics are null after trigerring the collection.
+ EXPECT_TRUE(full_gc_collection_time->IsNull());
+ EXPECT_TRUE(full_gc_count->IsNull());
+ EXPECT_TRUE(full_gc_count_delta->IsNull());
+ EXPECT_TRUE(full_gc_throughput->IsNull());
+ EXPECT_TRUE(full_gc_tracing_throughput->IsNull());
+ EXPECT_TRUE(full_gc_throughput_avg->IsNull());
+ EXPECT_TRUE(full_gc_tracing_throughput_avg->IsNull());
+ EXPECT_TRUE(full_gc_scanned_bytes->IsNull());
+ EXPECT_TRUE(full_gc_scanned_bytes_delta->IsNull());
+ EXPECT_TRUE(full_gc_freed_bytes->IsNull());
+ EXPECT_TRUE(full_gc_freed_bytes_delta->IsNull());
+ EXPECT_TRUE(full_gc_duration->IsNull());
+ EXPECT_TRUE(full_gc_duration_delta->IsNull());
+
+ EXPECT_TRUE(young_gc_collection_time->IsNull());
+ EXPECT_TRUE(young_gc_count->IsNull());
+ EXPECT_TRUE(young_gc_count_delta->IsNull());
+ EXPECT_TRUE(young_gc_throughput->IsNull());
+ EXPECT_TRUE(young_gc_tracing_throughput->IsNull());
+ EXPECT_TRUE(young_gc_throughput_avg->IsNull());
+ EXPECT_TRUE(young_gc_tracing_throughput_avg->IsNull());
+ EXPECT_TRUE(young_gc_scanned_bytes->IsNull());
+ EXPECT_TRUE(young_gc_scanned_bytes_delta->IsNull());
+ EXPECT_TRUE(young_gc_freed_bytes->IsNull());
+ EXPECT_TRUE(young_gc_freed_bytes_delta->IsNull());
+ EXPECT_TRUE(young_gc_duration->IsNull());
+ EXPECT_TRUE(young_gc_duration_delta->IsNull());
+ }
+}
+
class ZygoteHeapTest : public CommonRuntimeTest {
public:
ZygoteHeapTest() {