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 #include "monitor_pool.h"
18
19 #include "base/logging.h"
20 #include "base/mutex-inl.h"
21 #include "thread-inl.h"
22 #include "monitor.h"
23
24 namespace art {
25
26 namespace mirror {
27 class Object;
28 } // namespace mirror
29
MonitorPool()30 MonitorPool::MonitorPool()
31 : num_chunks_(0), capacity_(0), first_free_(nullptr) {
32 AllocateChunk(); // Get our first chunk.
33 }
34
35 // Assumes locks are held appropriately when necessary.
36 // We do not need a lock in the constructor, but we need one when in CreateMonitorInPool.
AllocateChunk()37 void MonitorPool::AllocateChunk() {
38 DCHECK(first_free_ == nullptr);
39
40 // Do we need to resize?
41 if (num_chunks_ == capacity_) {
42 if (capacity_ == 0U) {
43 // Initialization.
44 capacity_ = kInitialChunkStorage;
45 uintptr_t* new_backing = new uintptr_t[capacity_];
46 monitor_chunks_.StoreRelaxed(new_backing);
47 } else {
48 size_t new_capacity = 2 * capacity_;
49 uintptr_t* new_backing = new uintptr_t[new_capacity];
50 uintptr_t* old_backing = monitor_chunks_.LoadRelaxed();
51 memcpy(new_backing, old_backing, sizeof(uintptr_t) * capacity_);
52 monitor_chunks_.StoreRelaxed(new_backing);
53 capacity_ = new_capacity;
54 old_chunk_arrays_.push_back(old_backing);
55 VLOG(monitor) << "Resizing to capacity " << capacity_;
56 }
57 }
58
59 // Allocate the chunk.
60 void* chunk = allocator_.allocate(kChunkSize);
61 // Check we allocated memory.
62 CHECK_NE(reinterpret_cast<uintptr_t>(nullptr), reinterpret_cast<uintptr_t>(chunk));
63 // Check it is aligned as we need it.
64 CHECK_EQ(0U, reinterpret_cast<uintptr_t>(chunk) % kMonitorAlignment);
65
66 // Add the chunk.
67 *(monitor_chunks_.LoadRelaxed() + num_chunks_) = reinterpret_cast<uintptr_t>(chunk);
68 num_chunks_++;
69
70 // Set up the free list
71 Monitor* last = reinterpret_cast<Monitor*>(reinterpret_cast<uintptr_t>(chunk) +
72 (kChunkCapacity - 1) * kAlignedMonitorSize);
73 last->next_free_ = nullptr;
74 // Eagerly compute id.
75 last->monitor_id_ = OffsetToMonitorId((num_chunks_ - 1) * kChunkSize +
76 (kChunkCapacity - 1) * kAlignedMonitorSize);
77 for (size_t i = 0; i < kChunkCapacity - 1; ++i) {
78 Monitor* before = reinterpret_cast<Monitor*>(reinterpret_cast<uintptr_t>(last) -
79 kAlignedMonitorSize);
80 before->next_free_ = last;
81 // Derive monitor_id from last.
82 before->monitor_id_ = OffsetToMonitorId(MonitorIdToOffset(last->monitor_id_) -
83 kAlignedMonitorSize);
84
85 last = before;
86 }
87 DCHECK(last == reinterpret_cast<Monitor*>(chunk));
88 first_free_ = last;
89 }
90
CreateMonitorInPool(Thread * self,Thread * owner,mirror::Object * obj,int32_t hash_code)91 Monitor* MonitorPool::CreateMonitorInPool(Thread* self, Thread* owner, mirror::Object* obj,
92 int32_t hash_code)
93 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
94 // We are gonna allocate, so acquire the writer lock.
95 MutexLock mu(self, *Locks::allocated_monitor_ids_lock_);
96
97 // Enough space, or need to resize?
98 if (first_free_ == nullptr) {
99 VLOG(monitor) << "Allocating a new chunk.";
100 AllocateChunk();
101 }
102
103 Monitor* mon_uninitialized = first_free_;
104 first_free_ = first_free_->next_free_;
105
106 // Pull out the id which was preinitialized.
107 MonitorId id = mon_uninitialized->monitor_id_;
108
109 // Initialize it.
110 Monitor* monitor = new(mon_uninitialized) Monitor(self, owner, obj, hash_code, id);
111
112 return monitor;
113 }
114
ReleaseMonitorToPool(Thread * self,Monitor * monitor)115 void MonitorPool::ReleaseMonitorToPool(Thread* self, Monitor* monitor) {
116 // Might be racy with allocation, so acquire lock.
117 MutexLock mu(self, *Locks::allocated_monitor_ids_lock_);
118
119 // Keep the monitor id. Don't trust it's not cleared.
120 MonitorId id = monitor->monitor_id_;
121
122 // Call the destructor.
123 // TODO: Exception safety?
124 monitor->~Monitor();
125
126 // Add to the head of the free list.
127 monitor->next_free_ = first_free_;
128 first_free_ = monitor;
129
130 // Rewrite monitor id.
131 monitor->monitor_id_ = id;
132 }
133
ReleaseMonitorsToPool(Thread * self,MonitorList::Monitors * monitors)134 void MonitorPool::ReleaseMonitorsToPool(Thread* self, MonitorList::Monitors* monitors) {
135 for (Monitor* mon : *monitors) {
136 ReleaseMonitorToPool(self, mon);
137 }
138 }
139
140 } // namespace art
141