ART: Hide Mutex & ConditionVariable in Barrier
Ensure that barrier.h does not pull in mutex.h
Bug: 119869270
Test: m test-art-host
Change-Id: I54ea467c92562ec912ea5b1705049eb23cda380e
diff --git a/runtime/barrier.cc b/runtime/barrier.cc
index 8d3cf45..a1a3659 100644
--- a/runtime/barrier.cc
+++ b/runtime/barrier.cc
@@ -27,15 +27,15 @@
Barrier::Barrier(int count)
: count_(count),
- lock_("GC barrier lock", kThreadSuspendCountLock),
- condition_("GC barrier condition", lock_) {
+ lock_(new Mutex("GC barrier lock", kThreadSuspendCountLock)),
+ condition_(new ConditionVariable("GC barrier condition", *lock_)) {
}
template void Barrier::Increment<Barrier::kAllowHoldingLocks>(Thread* self, int delta);
template void Barrier::Increment<Barrier::kDisallowHoldingLocks>(Thread* self, int delta);
void Barrier::Pass(Thread* self) {
- MutexLock mu(self, lock_);
+ MutexLock mu(self, *GetLock());
SetCountLocked(self, count_ - 1);
}
@@ -44,13 +44,13 @@
}
void Barrier::Init(Thread* self, int count) {
- MutexLock mu(self, lock_);
+ MutexLock mu(self, *GetLock());
SetCountLocked(self, count);
}
template <Barrier::LockHandling locks>
void Barrier::Increment(Thread* self, int delta) {
- MutexLock mu(self, lock_);
+ MutexLock mu(self, *GetLock());
SetCountLocked(self, count_ + delta);
// Increment the count. If it becomes zero after the increment
@@ -62,22 +62,22 @@
// condition variable, thus waking this up.
while (count_ != 0) {
if (locks == kAllowHoldingLocks) {
- condition_.WaitHoldingLocks(self);
+ condition_->WaitHoldingLocks(self);
} else {
- condition_.Wait(self);
+ condition_->Wait(self);
}
}
}
bool Barrier::Increment(Thread* self, int delta, uint32_t timeout_ms) {
- MutexLock mu(self, lock_);
+ MutexLock mu(self, *GetLock());
SetCountLocked(self, count_ + delta);
bool timed_out = false;
if (count_ != 0) {
uint32_t timeout_ns = 0;
uint64_t abs_timeout = NanoTime() + MsToNs(timeout_ms);
for (;;) {
- timed_out = condition_.TimedWait(self, timeout_ms, timeout_ns);
+ timed_out = condition_->TimedWait(self, timeout_ms, timeout_ns);
if (timed_out || count_ == 0) return timed_out;
// Compute time remaining on timeout.
uint64_t now = NanoTime();
@@ -91,14 +91,14 @@
}
int Barrier::GetCount(Thread* self) {
- MutexLock mu(self, lock_);
+ MutexLock mu(self, *GetLock());
return count_;
}
void Barrier::SetCountLocked(Thread* self, int count) {
count_ = count;
if (count == 0) {
- condition_.Broadcast(self);
+ condition_->Broadcast(self);
}
}
diff --git a/runtime/barrier.h b/runtime/barrier.h
index 8a38c4c..e21627e 100644
--- a/runtime/barrier.h
+++ b/runtime/barrier.h
@@ -28,10 +28,14 @@
#define ART_RUNTIME_BARRIER_H_
#include <memory>
-#include "base/mutex.h"
+
+#include "base/locks.h"
namespace art {
+class ConditionVariable;
+class LOCKABLE Mutex;
+
// TODO: Maybe give this a better name.
class Barrier {
public:
@@ -44,10 +48,10 @@
virtual ~Barrier();
// Pass through the barrier, decrement the count but do not block.
- void Pass(Thread* self) REQUIRES(!lock_);
+ void Pass(Thread* self) REQUIRES(!GetLock());
// Wait on the barrier, decrement the count.
- void Wait(Thread* self) REQUIRES(!lock_);
+ void Wait(Thread* self) REQUIRES(!GetLock());
// The following three calls are only safe if we somehow know that no other thread both
// - has been woken up, and
@@ -58,26 +62,30 @@
// Increment the count by delta, wait on condition if count is non zero. If LockHandling is
// kAllowHoldingLocks we will not check that all locks are released when waiting.
template <Barrier::LockHandling locks = kDisallowHoldingLocks>
- void Increment(Thread* self, int delta) REQUIRES(!lock_);
+ void Increment(Thread* self, int delta) REQUIRES(!GetLock());
// Increment the count by delta, wait on condition if count is non zero, with a timeout. Returns
// true if time out occurred.
- bool Increment(Thread* self, int delta, uint32_t timeout_ms) REQUIRES(!lock_);
+ bool Increment(Thread* self, int delta, uint32_t timeout_ms) REQUIRES(!GetLock());
// Set the count to a new value. This should only be used if there is no possibility that
// another thread is still in Wait(). See above.
- void Init(Thread* self, int count) REQUIRES(!lock_);
+ void Init(Thread* self, int count) REQUIRES(!GetLock());
- int GetCount(Thread* self) REQUIRES(!lock_);
+ int GetCount(Thread* self) REQUIRES(!GetLock());
private:
- void SetCountLocked(Thread* self, int count) REQUIRES(lock_);
+ void SetCountLocked(Thread* self, int count) REQUIRES(GetLock());
+
+ Mutex* GetLock() {
+ return lock_.get();
+ }
// Counter, when this reaches 0 all people blocked on the barrier are signalled.
- int count_ GUARDED_BY(lock_);
+ int count_ GUARDED_BY(GetLock());
- Mutex lock_ ACQUIRED_AFTER(Locks::abort_lock_);
- ConditionVariable condition_ GUARDED_BY(lock_);
+ std::unique_ptr<Mutex> lock_ ACQUIRED_AFTER(Locks::abort_lock_);
+ std::unique_ptr<ConditionVariable> condition_ GUARDED_BY(GetLock());
};
} // namespace art
