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 #include "barrier.h"
18
19 #include "base/mutex.h"
20 #include "base/time_utils.h"
21 #include "thread.h"
22
23 namespace art {
24
Barrier(int count)25 Barrier::Barrier(int count)
26 : count_(count),
27 lock_("GC barrier lock", kThreadSuspendCountLock),
28 condition_("GC barrier condition", lock_) {
29 }
30
Pass(Thread * self)31 void Barrier::Pass(Thread* self) {
32 MutexLock mu(self, lock_);
33 SetCountLocked(self, count_ - 1);
34 }
35
Wait(Thread * self)36 void Barrier::Wait(Thread* self) {
37 Increment(self, -1);
38 }
39
Init(Thread * self,int count)40 void Barrier::Init(Thread* self, int count) {
41 MutexLock mu(self, lock_);
42 SetCountLocked(self, count);
43 }
44
Increment(Thread * self,int delta)45 void Barrier::Increment(Thread* self, int delta) {
46 MutexLock mu(self, lock_);
47 SetCountLocked(self, count_ + delta);
48
49 // Increment the count. If it becomes zero after the increment
50 // then all the threads have already passed the barrier. If
51 // it is non-zero then there is still one or more threads
52 // that have not yet called the Pass function. When the
53 // Pass function is called by the last thread, the count will
54 // be decremented to zero and a Broadcast will be made on the
55 // condition variable, thus waking this up.
56 while (count_ != 0) {
57 condition_.Wait(self);
58 }
59 }
60
Increment(Thread * self,int delta,uint32_t timeout_ms)61 bool Barrier::Increment(Thread* self, int delta, uint32_t timeout_ms) {
62 MutexLock mu(self, lock_);
63 SetCountLocked(self, count_ + delta);
64 bool timed_out = false;
65 if (count_ != 0) {
66 uint32_t timeout_ns = 0;
67 uint64_t abs_timeout = NanoTime() + MsToNs(timeout_ms);
68 for (;;) {
69 timed_out = condition_.TimedWait(self, timeout_ms, timeout_ns);
70 if (timed_out || count_ == 0) return timed_out;
71 // Compute time remaining on timeout.
72 uint64_t now = NanoTime();
73 int64_t time_left = abs_timeout - now;
74 if (time_left <= 0) return true;
75 timeout_ns = time_left % (1000*1000);
76 timeout_ms = time_left / (1000*1000);
77 }
78 }
79 return timed_out;
80 }
81
SetCountLocked(Thread * self,int count)82 void Barrier::SetCountLocked(Thread* self, int count) {
83 count_ = count;
84 if (count == 0) {
85 condition_.Broadcast(self);
86 }
87 }
88
~Barrier()89 Barrier::~Barrier() {
90 CHECK_EQ(count_, 0) << "Attempted to destroy barrier with non zero count";
91 }
92
93 } // namespace art
94