1 /* 2 * Copyright (C) 2012 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 #ifndef ART_RUNTIME_GC_ACCOUNTING_HEAP_BITMAP_H_ 18 #define ART_RUNTIME_GC_ACCOUNTING_HEAP_BITMAP_H_ 19 20 #include "base/allocator.h" 21 #include "base/logging.h" 22 #include "object_callbacks.h" 23 #include "space_bitmap.h" 24 25 namespace art { 26 namespace gc { 27 28 class Heap; 29 30 namespace accounting { 31 32 class HeapBitmap { 33 public: 34 bool Test(const mirror::Object* obj) SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_); 35 void Clear(const mirror::Object* obj) EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_); 36 template<typename LargeObjectSetVisitor> 37 bool Set(const mirror::Object* obj, const LargeObjectSetVisitor& visitor) 38 EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) ALWAYS_INLINE; 39 template<typename LargeObjectSetVisitor> 40 bool AtomicTestAndSet(const mirror::Object* obj, const LargeObjectSetVisitor& visitor) 41 EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) ALWAYS_INLINE; 42 ContinuousSpaceBitmap* GetContinuousSpaceBitmap(const mirror::Object* obj) const; 43 44 void Walk(ObjectCallback* callback, void* arg) 45 SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_); 46 47 template <typename Visitor> 48 void Visit(const Visitor& visitor) 49 EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) 50 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 51 52 // Find and replace a bitmap pointer, this is used by for the bitmap swapping in the GC. 53 void ReplaceBitmap(ContinuousSpaceBitmap* old_bitmap, ContinuousSpaceBitmap* new_bitmap) 54 EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_); 55 56 // Find and replace a object set pointer, this is used by for the bitmap swapping in the GC. 57 void ReplaceLargeObjectBitmap(LargeObjectBitmap* old_bitmap, LargeObjectBitmap* new_bitmap) 58 EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_); 59 60 explicit HeapBitmap(Heap* heap) : heap_(heap) {} 61 62 private: 63 const Heap* const heap_; 64 65 void AddContinuousSpaceBitmap(ContinuousSpaceBitmap* bitmap); 66 void RemoveContinuousSpaceBitmap(ContinuousSpaceBitmap* bitmap); 67 void AddLargeObjectBitmap(LargeObjectBitmap* bitmap); 68 void RemoveLargeObjectBitmap(LargeObjectBitmap* bitmap); 69 70 // Bitmaps covering continuous spaces. 71 std::vector<ContinuousSpaceBitmap*, 72 TrackingAllocator<ContinuousSpaceBitmap*, kAllocatorTagHeapBitmap>> 73 continuous_space_bitmaps_; 74 75 // Sets covering discontinuous spaces. 76 std::vector<LargeObjectBitmap*, 77 TrackingAllocator<LargeObjectBitmap*, kAllocatorTagHeapBitmapLOS>> 78 large_object_bitmaps_; 79 80 friend class art::gc::Heap; 81 }; 82 83 } // namespace accounting 84 } // namespace gc 85 } // namespace art 86 87 #endif // ART_RUNTIME_GC_ACCOUNTING_HEAP_BITMAP_H_ 88
