• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2011 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include <algorithm>
18 
19 #include "base/metrics/metrics.h"
20 #include "class_linker-inl.h"
21 #include "common_runtime_test.h"
22 #include "gc/accounting/card_table-inl.h"
23 #include "gc/accounting/space_bitmap-inl.h"
24 #include "handle_scope-inl.h"
25 #include "mirror/class-inl.h"
26 #include "mirror/object-inl.h"
27 #include "mirror/object_array-alloc-inl.h"
28 #include "mirror/object_array-inl.h"
29 #include "scoped_thread_state_change-inl.h"
30 
31 namespace art {
32 namespace gc {
33 
34 class HeapTest : public CommonRuntimeTest {
35  public:
HeapTest()36   HeapTest() {
37     use_boot_image_ = true;  // Make the Runtime creation cheaper.
38   }
39 
SetUp()40   void SetUp() override {
41     MemMap::Init();
42     std::string error_msg;
43     // Reserve the preferred address to force the heap to use another one for testing.
44     reserved_ = MemMap::MapAnonymous("ReserveMap",
45                                      gc::Heap::kPreferredAllocSpaceBegin,
46                                      16 * KB,
47                                      PROT_READ,
48                                      /*low_4gb=*/ true,
49                                      /*reuse=*/ false,
50                                      /*reservation=*/ nullptr,
51                                      &error_msg);
52     // There is no guarantee that reserved_ will be valid (due to ASLR). See b/175018342.
53     CommonRuntimeTest::SetUp();
54   }
55 
56  private:
57   MemMap reserved_;
58 };
59 
TEST_F(HeapTest,ClearGrowthLimit)60 TEST_F(HeapTest, ClearGrowthLimit) {
61   Heap* heap = Runtime::Current()->GetHeap();
62   int64_t max_memory_before = heap->GetMaxMemory();
63   int64_t total_memory_before = heap->GetTotalMemory();
64   heap->ClearGrowthLimit();
65   int64_t max_memory_after = heap->GetMaxMemory();
66   int64_t total_memory_after = heap->GetTotalMemory();
67   EXPECT_GE(max_memory_after, max_memory_before);
68   EXPECT_GE(total_memory_after, total_memory_before);
69 }
70 
TEST_F(HeapTest,GarbageCollectClassLinkerInit)71 TEST_F(HeapTest, GarbageCollectClassLinkerInit) {
72   {
73     ScopedObjectAccess soa(Thread::Current());
74     // garbage is created during ClassLinker::Init
75 
76     StackHandleScope<1> hs(soa.Self());
77     Handle<mirror::Class> c(
78         hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/Object;")));
79     for (size_t i = 0; i < 1024; ++i) {
80       StackHandleScope<1> hs2(soa.Self());
81       Handle<mirror::ObjectArray<mirror::Object>> array(hs2.NewHandle(
82           mirror::ObjectArray<mirror::Object>::Alloc(soa.Self(), c.Get(), 2048)));
83       for (size_t j = 0; j < 2048; ++j) {
84         ObjPtr<mirror::String> string =
85             mirror::String::AllocFromModifiedUtf8(soa.Self(), "hello, world!");
86         // handle scope operator -> deferences the handle scope before running the method.
87         array->Set<false>(j, string);
88       }
89     }
90   }
91   Runtime::Current()->GetHeap()->CollectGarbage(/* clear_soft_references= */ false);
92 }
93 
TEST_F(HeapTest,HeapBitmapCapacityTest)94 TEST_F(HeapTest, HeapBitmapCapacityTest) {
95   uint8_t* heap_begin = reinterpret_cast<uint8_t*>(0x1000);
96   const size_t heap_capacity = kObjectAlignment * (sizeof(intptr_t) * 8 + 1);
97   accounting::ContinuousSpaceBitmap bitmap(
98       accounting::ContinuousSpaceBitmap::Create("test bitmap", heap_begin, heap_capacity));
99   mirror::Object* fake_end_of_heap_object =
100       reinterpret_cast<mirror::Object*>(&heap_begin[heap_capacity - kObjectAlignment]);
101   bitmap.Set(fake_end_of_heap_object);
102 }
103 
TEST_F(HeapTest,DumpGCPerformanceOnShutdown)104 TEST_F(HeapTest, DumpGCPerformanceOnShutdown) {
105   Runtime::Current()->GetHeap()->CollectGarbage(/* clear_soft_references= */ false);
106   Runtime::Current()->SetDumpGCPerformanceOnShutdown(true);
107 }
108 
AnyIsFalse(bool x,bool y)109 bool AnyIsFalse(bool x, bool y) { return !x || !y; }
110 
TEST_F(HeapTest,GCMetrics)111 TEST_F(HeapTest, GCMetrics) {
112   // Allocate a few string objects (to be collected), then trigger garbage
113   // collection, and check that GC metrics are updated (where applicable).
114   {
115     constexpr const size_t kNumObj = 128;
116     ScopedObjectAccess soa(Thread::Current());
117     StackHandleScope<kNumObj> hs(soa.Self());
118     for (size_t i = 0u; i < kNumObj; ++i) {
119       Handle<mirror::String> string [[maybe_unused]] (
120           hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "test")));
121     }
122   }
123   Heap* heap = Runtime::Current()->GetHeap();
124   heap->CollectGarbage(/* clear_soft_references= */ false);
125 
126   // ART Metrics.
127   metrics::ArtMetrics* metrics = Runtime::Current()->GetMetrics();
128   // ART full-heap GC metrics.
129   metrics::MetricsBase<int64_t>* full_gc_collection_time = metrics->FullGcCollectionTime();
130   metrics::MetricsBase<uint64_t>* full_gc_count = metrics->FullGcCount();
131   metrics::MetricsBase<uint64_t>* full_gc_count_delta = metrics->FullGcCountDelta();
132   metrics::MetricsBase<int64_t>* full_gc_throughput = metrics->FullGcThroughput();
133   metrics::MetricsBase<int64_t>* full_gc_tracing_throughput = metrics->FullGcTracingThroughput();
134   metrics::MetricsBase<uint64_t>* full_gc_throughput_avg = metrics->FullGcThroughputAvg();
135   metrics::MetricsBase<uint64_t>* full_gc_tracing_throughput_avg =
136       metrics->FullGcTracingThroughputAvg();
137   metrics::MetricsBase<uint64_t>* full_gc_scanned_bytes = metrics->FullGcScannedBytes();
138   metrics::MetricsBase<uint64_t>* full_gc_scanned_bytes_delta = metrics->FullGcScannedBytesDelta();
139   metrics::MetricsBase<uint64_t>* full_gc_freed_bytes = metrics->FullGcFreedBytes();
140   metrics::MetricsBase<uint64_t>* full_gc_freed_bytes_delta = metrics->FullGcFreedBytesDelta();
141   metrics::MetricsBase<uint64_t>* full_gc_duration = metrics->FullGcDuration();
142   metrics::MetricsBase<uint64_t>* full_gc_duration_delta = metrics->FullGcDurationDelta();
143   // ART young-generation GC metrics.
144   metrics::MetricsBase<int64_t>* young_gc_collection_time = metrics->YoungGcCollectionTime();
145   metrics::MetricsBase<uint64_t>* young_gc_count = metrics->YoungGcCount();
146   metrics::MetricsBase<uint64_t>* young_gc_count_delta = metrics->YoungGcCountDelta();
147   metrics::MetricsBase<int64_t>* young_gc_throughput = metrics->YoungGcThroughput();
148   metrics::MetricsBase<int64_t>* young_gc_tracing_throughput = metrics->YoungGcTracingThroughput();
149   metrics::MetricsBase<uint64_t>* young_gc_throughput_avg = metrics->YoungGcThroughputAvg();
150   metrics::MetricsBase<uint64_t>* young_gc_tracing_throughput_avg =
151       metrics->YoungGcTracingThroughputAvg();
152   metrics::MetricsBase<uint64_t>* young_gc_scanned_bytes = metrics->YoungGcScannedBytes();
153   metrics::MetricsBase<uint64_t>* young_gc_scanned_bytes_delta =
154       metrics->YoungGcScannedBytesDelta();
155   metrics::MetricsBase<uint64_t>* young_gc_freed_bytes = metrics->YoungGcFreedBytes();
156   metrics::MetricsBase<uint64_t>* young_gc_freed_bytes_delta = metrics->YoungGcFreedBytesDelta();
157   metrics::MetricsBase<uint64_t>* young_gc_duration = metrics->YoungGcDuration();
158   metrics::MetricsBase<uint64_t>* young_gc_duration_delta = metrics->YoungGcDurationDelta();
159 
160   CollectorType fg_collector_type = heap->GetForegroundCollectorType();
161   if (fg_collector_type == kCollectorTypeCC || fg_collector_type == kCollectorTypeCMC) {
162     // Only the Concurrent Copying and Concurrent Mark-Compact collectors enable
163     // GC metrics at the moment.
164     if (heap->GetUseGenerationalCC()) {
165       // Check that full-heap and/or young-generation GC metrics are non-null
166       // after trigerring the collection.
167       EXPECT_PRED2(
168           AnyIsFalse, full_gc_collection_time->IsNull(), young_gc_collection_time->IsNull());
169       EXPECT_PRED2(AnyIsFalse, full_gc_count->IsNull(), young_gc_count->IsNull());
170       EXPECT_PRED2(AnyIsFalse, full_gc_count_delta->IsNull(), young_gc_count_delta->IsNull());
171       EXPECT_PRED2(AnyIsFalse, full_gc_throughput->IsNull(), young_gc_throughput->IsNull());
172       EXPECT_PRED2(
173           AnyIsFalse, full_gc_tracing_throughput->IsNull(), young_gc_tracing_throughput->IsNull());
174       EXPECT_PRED2(AnyIsFalse, full_gc_throughput_avg->IsNull(), young_gc_throughput_avg->IsNull());
175       EXPECT_PRED2(AnyIsFalse,
176                    full_gc_tracing_throughput_avg->IsNull(),
177                    young_gc_tracing_throughput_avg->IsNull());
178       EXPECT_PRED2(AnyIsFalse, full_gc_scanned_bytes->IsNull(), young_gc_scanned_bytes->IsNull());
179       EXPECT_PRED2(AnyIsFalse,
180                    full_gc_scanned_bytes_delta->IsNull(),
181                    young_gc_scanned_bytes_delta->IsNull());
182       EXPECT_PRED2(AnyIsFalse, full_gc_freed_bytes->IsNull(), young_gc_freed_bytes->IsNull());
183       EXPECT_PRED2(
184           AnyIsFalse, full_gc_freed_bytes_delta->IsNull(), young_gc_freed_bytes_delta->IsNull());
185       // We have observed that sometimes the GC duration (both for full-heap and
186       // young-generation collections) is null (b/271112044). Temporarily
187       // suspend the following checks while we investigate.
188       //
189       // TODO(b/271112044): Investigate and adjust these expectations and/or the
190       // corresponding metric logic.
191 #if 0
192       EXPECT_PRED2(AnyIsFalse, full_gc_duration->IsNull(), young_gc_duration->IsNull());
193       EXPECT_PRED2(AnyIsFalse, full_gc_duration_delta->IsNull(), young_gc_duration_delta->IsNull());
194 #endif
195     } else {
196       // Check that only full-heap GC metrics are non-null after trigerring the collection.
197       EXPECT_FALSE(full_gc_collection_time->IsNull());
198       EXPECT_FALSE(full_gc_count->IsNull());
199       EXPECT_FALSE(full_gc_count_delta->IsNull());
200       EXPECT_FALSE(full_gc_throughput->IsNull());
201       EXPECT_FALSE(full_gc_tracing_throughput->IsNull());
202       EXPECT_FALSE(full_gc_throughput_avg->IsNull());
203       EXPECT_FALSE(full_gc_tracing_throughput_avg->IsNull());
204       EXPECT_FALSE(full_gc_scanned_bytes->IsNull());
205       EXPECT_FALSE(full_gc_scanned_bytes_delta->IsNull());
206       EXPECT_FALSE(full_gc_freed_bytes->IsNull());
207       EXPECT_FALSE(full_gc_freed_bytes_delta->IsNull());
208       EXPECT_FALSE(full_gc_duration->IsNull());
209       EXPECT_FALSE(full_gc_duration_delta->IsNull());
210 
211       EXPECT_TRUE(young_gc_collection_time->IsNull());
212       EXPECT_TRUE(young_gc_count->IsNull());
213       EXPECT_TRUE(young_gc_count_delta->IsNull());
214       EXPECT_TRUE(young_gc_throughput->IsNull());
215       EXPECT_TRUE(young_gc_tracing_throughput->IsNull());
216       EXPECT_TRUE(young_gc_throughput_avg->IsNull());
217       EXPECT_TRUE(young_gc_tracing_throughput_avg->IsNull());
218       EXPECT_TRUE(young_gc_scanned_bytes->IsNull());
219       EXPECT_TRUE(young_gc_scanned_bytes_delta->IsNull());
220       EXPECT_TRUE(young_gc_freed_bytes->IsNull());
221       EXPECT_TRUE(young_gc_freed_bytes_delta->IsNull());
222       EXPECT_TRUE(young_gc_duration->IsNull());
223       EXPECT_TRUE(young_gc_duration_delta->IsNull());
224     }
225   } else {
226     // Check that all metrics are null after trigerring the collection.
227     EXPECT_TRUE(full_gc_collection_time->IsNull());
228     EXPECT_TRUE(full_gc_count->IsNull());
229     EXPECT_TRUE(full_gc_count_delta->IsNull());
230     EXPECT_TRUE(full_gc_throughput->IsNull());
231     EXPECT_TRUE(full_gc_tracing_throughput->IsNull());
232     EXPECT_TRUE(full_gc_throughput_avg->IsNull());
233     EXPECT_TRUE(full_gc_tracing_throughput_avg->IsNull());
234     EXPECT_TRUE(full_gc_scanned_bytes->IsNull());
235     EXPECT_TRUE(full_gc_scanned_bytes_delta->IsNull());
236     EXPECT_TRUE(full_gc_freed_bytes->IsNull());
237     EXPECT_TRUE(full_gc_freed_bytes_delta->IsNull());
238     EXPECT_TRUE(full_gc_duration->IsNull());
239     EXPECT_TRUE(full_gc_duration_delta->IsNull());
240 
241     EXPECT_TRUE(young_gc_collection_time->IsNull());
242     EXPECT_TRUE(young_gc_count->IsNull());
243     EXPECT_TRUE(young_gc_count_delta->IsNull());
244     EXPECT_TRUE(young_gc_throughput->IsNull());
245     EXPECT_TRUE(young_gc_tracing_throughput->IsNull());
246     EXPECT_TRUE(young_gc_throughput_avg->IsNull());
247     EXPECT_TRUE(young_gc_tracing_throughput_avg->IsNull());
248     EXPECT_TRUE(young_gc_scanned_bytes->IsNull());
249     EXPECT_TRUE(young_gc_scanned_bytes_delta->IsNull());
250     EXPECT_TRUE(young_gc_freed_bytes->IsNull());
251     EXPECT_TRUE(young_gc_freed_bytes_delta->IsNull());
252     EXPECT_TRUE(young_gc_duration->IsNull());
253     EXPECT_TRUE(young_gc_duration_delta->IsNull());
254   }
255 }
256 
257 class ZygoteHeapTest : public CommonRuntimeTest {
258  public:
ZygoteHeapTest()259   ZygoteHeapTest() {
260     use_boot_image_ = true;  // Make the Runtime creation cheaper.
261   }
262 
SetUpRuntimeOptions(RuntimeOptions * options)263   void SetUpRuntimeOptions(RuntimeOptions* options) override {
264     CommonRuntimeTest::SetUpRuntimeOptions(options);
265     options->push_back(std::make_pair("-Xzygote", nullptr));
266   }
267 };
268 
TEST_F(ZygoteHeapTest,PreZygoteFork)269 TEST_F(ZygoteHeapTest, PreZygoteFork) {
270   // Exercise Heap::PreZygoteFork() to check it does not crash.
271   Runtime::Current()->GetHeap()->PreZygoteFork();
272 }
273 
274 }  // namespace gc
275 }  // namespace art
276