1 /*
2  * Copyright (C) 2014 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_COLLECTOR_IMMUNE_REGION_H_
18 #define ART_RUNTIME_GC_COLLECTOR_IMMUNE_REGION_H_
19 
20 #include "base/macros.h"
21 #include "base/mutex.h"
22 
23 namespace art {
24 namespace mirror {
25 class Object;
26 }  // namespace mirror
27 namespace gc {
28 namespace space {
29 class ContinuousSpace;
30 }  // namespace space
31 
32 namespace collector {
33 
34 // An immune region is a continuous region of memory for which all objects contained are assumed to
35 // be marked. This is used as an optimization in the GC to avoid needing to test the mark bitmap of
36 // the zygote, image spaces, and sometimes non moving spaces. Doing the ContainsObject check is
37 // faster than doing a bitmap read. There is no support for discontinuous spaces and you need to be
38 // careful that your immune region doesn't contain any large objects.
39 class ImmuneRegion {
40  public:
41   ImmuneRegion();
42   void Reset();
43   bool AddContinuousSpace(space::ContinuousSpace* space)
44       EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
45   bool ContainsSpace(const space::ContinuousSpace* space) const;
46   // Returns true if an object is inside of the immune region (assumed to be marked).
ContainsObject(const mirror::Object * obj)47   bool ContainsObject(const mirror::Object* obj) const ALWAYS_INLINE {
48     // Note: Relies on integer underflow behavior.
49     return reinterpret_cast<uintptr_t>(obj) - reinterpret_cast<uintptr_t>(begin_) < size_;
50   }
SetBegin(mirror::Object * begin)51   void SetBegin(mirror::Object* begin) {
52     begin_ = begin;
53     UpdateSize();
54   }
SetEnd(mirror::Object * end)55   void SetEnd(mirror::Object* end) {
56     end_ = end;
57     UpdateSize();
58   }
59 
Begin()60   mirror::Object* Begin() {
61     return begin_;
62   }
End()63   mirror::Object* End() {
64     return end_;
65   }
66 
67  private:
IsEmpty()68   bool IsEmpty() const {
69     return size_ == 0;
70   }
UpdateSize()71   void UpdateSize() {
72     size_ = reinterpret_cast<uintptr_t>(end_) - reinterpret_cast<uintptr_t>(begin_);
73   }
74 
75   mirror::Object* begin_;
76   mirror::Object* end_;
77   uintptr_t size_;
78 };
79 
80 }  // namespace collector
81 }  // namespace gc
82 }  // namespace art
83 
84 #endif  // ART_RUNTIME_GC_COLLECTOR_IMMUNE_REGION_H_
85