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 "class_linker-inl.h"
18 #include "common_runtime_test.h"
19 #include "gc/accounting/card_table-inl.h"
20 #include "gc/accounting/space_bitmap-inl.h"
21 #include "handle_scope-inl.h"
22 #include "mirror/class-inl.h"
23 #include "mirror/object-inl.h"
24 #include "mirror/object_array-inl.h"
25 #include "scoped_thread_state_change-inl.h"
26
27 namespace art {
28 namespace gc {
29
30 class HeapTest : public CommonRuntimeTest {
31 public:
SetUp()32 void SetUp() OVERRIDE {
33 MemMap::Init();
34 std::string error_msg;
35 // Reserve the preferred address to force the heap to use another one for testing.
36 reserved_.reset(MemMap::MapAnonymous("ReserveMap",
37 gc::Heap::kPreferredAllocSpaceBegin,
38 16 * KB,
39 PROT_READ,
40 /*low_4gb*/ true,
41 /*reuse*/ false,
42 &error_msg));
43 ASSERT_TRUE(reserved_ != nullptr) << error_msg;
44 CommonRuntimeTest::SetUp();
45 }
46
47 private:
48 std::unique_ptr<MemMap> reserved_;
49 };
50
TEST_F(HeapTest,ClearGrowthLimit)51 TEST_F(HeapTest, ClearGrowthLimit) {
52 Heap* heap = Runtime::Current()->GetHeap();
53 int64_t max_memory_before = heap->GetMaxMemory();
54 int64_t total_memory_before = heap->GetTotalMemory();
55 heap->ClearGrowthLimit();
56 int64_t max_memory_after = heap->GetMaxMemory();
57 int64_t total_memory_after = heap->GetTotalMemory();
58 EXPECT_GE(max_memory_after, max_memory_before);
59 EXPECT_GE(total_memory_after, total_memory_before);
60 }
61
TEST_F(HeapTest,GarbageCollectClassLinkerInit)62 TEST_F(HeapTest, GarbageCollectClassLinkerInit) {
63 {
64 ScopedObjectAccess soa(Thread::Current());
65 // garbage is created during ClassLinker::Init
66
67 StackHandleScope<1> hs(soa.Self());
68 Handle<mirror::Class> c(
69 hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/Object;")));
70 for (size_t i = 0; i < 1024; ++i) {
71 StackHandleScope<1> hs2(soa.Self());
72 Handle<mirror::ObjectArray<mirror::Object>> array(hs2.NewHandle(
73 mirror::ObjectArray<mirror::Object>::Alloc(soa.Self(), c.Get(), 2048)));
74 for (size_t j = 0; j < 2048; ++j) {
75 mirror::String* string = mirror::String::AllocFromModifiedUtf8(soa.Self(), "hello, world!");
76 // handle scope operator -> deferences the handle scope before running the method.
77 array->Set<false>(j, string);
78 }
79 }
80 }
81 Runtime::Current()->GetHeap()->CollectGarbage(/* clear_soft_references */ false);
82 }
83
TEST_F(HeapTest,HeapBitmapCapacityTest)84 TEST_F(HeapTest, HeapBitmapCapacityTest) {
85 uint8_t* heap_begin = reinterpret_cast<uint8_t*>(0x1000);
86 const size_t heap_capacity = kObjectAlignment * (sizeof(intptr_t) * 8 + 1);
87 std::unique_ptr<accounting::ContinuousSpaceBitmap> bitmap(
88 accounting::ContinuousSpaceBitmap::Create("test bitmap", heap_begin, heap_capacity));
89 mirror::Object* fake_end_of_heap_object =
90 reinterpret_cast<mirror::Object*>(&heap_begin[heap_capacity - kObjectAlignment]);
91 bitmap->Set(fake_end_of_heap_object);
92 }
93
TEST_F(HeapTest,DumpGCPerformanceOnShutdown)94 TEST_F(HeapTest, DumpGCPerformanceOnShutdown) {
95 Runtime::Current()->GetHeap()->CollectGarbage(/* clear_soft_references */ false);
96 Runtime::Current()->SetDumpGCPerformanceOnShutdown(true);
97 }
98
99 class ZygoteHeapTest : public CommonRuntimeTest {
SetUpRuntimeOptions(RuntimeOptions * options)100 void SetUpRuntimeOptions(RuntimeOptions* options) {
101 CommonRuntimeTest::SetUpRuntimeOptions(options);
102 options->push_back(std::make_pair("-Xzygote", nullptr));
103 }
104 };
105
TEST_F(ZygoteHeapTest,PreZygoteFork)106 TEST_F(ZygoteHeapTest, PreZygoteFork) {
107 // Exercise Heap::PreZygoteFork() to check it does not crash.
108 Runtime::Current()->GetHeap()->PreZygoteFork();
109 }
110
111 } // namespace gc
112 } // namespace art
113