heap_bitmap.h revision 5369c40f75fdcb1be7a7c06db212ce965c83a164 
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
25namespace art {
26namespace gc {
27
28class Heap;
29
30namespace accounting {
31
32class 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