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 // CAUTION: THIS IS NOT A FULLY GENERAL BARRIER API. 18 19 // It may either be used as a "latch" or single-use barrier, or it may be reused under 20 // very limited conditions, e.g. if only Pass(), but not Wait() is called. Unlike a standard 21 // latch API, it is possible to initialize the latch to a count of zero, repeatedly call 22 // Pass() or Wait(), and only then set the count using the Increment() method. Threads at 23 // a Wait() are only awoken if the count reaches zero AFTER the decrement is applied. 24 // This works because, also unlike most latch APIs, there is no way to Wait() without 25 // decrementing the count, and thus nobody can spuriosly wake up on the initial zero. 26 27 #ifndef ART_RUNTIME_BARRIER_H_ 28 #define ART_RUNTIME_BARRIER_H_ 29 30 #include <memory> 31 #include "base/mutex.h" 32 33 namespace art { 34 35 // TODO: Maybe give this a better name. 36 class Barrier { 37 public: 38 enum LockHandling { 39 kAllowHoldingLocks, 40 kDisallowHoldingLocks, 41 }; 42 43 explicit Barrier(int count); 44 virtual ~Barrier(); 45 46 // Pass through the barrier, decrement the count but do not block. 47 void Pass(Thread* self) REQUIRES(!lock_); 48 49 // Wait on the barrier, decrement the count. 50 void Wait(Thread* self) REQUIRES(!lock_); 51 52 // The following three calls are only safe if we somehow know that no other thread both 53 // - has been woken up, and 54 // - has not left the Wait() or Increment() call. 55 // If these calls are made in that situation, the offending thread is likely to go back 56 // to sleep, resulting in a deadlock. 57 58 // Increment the count by delta, wait on condition if count is non zero. If LockHandling is 59 // kAllowHoldingLocks we will not check that all locks are released when waiting. 60 template <Barrier::LockHandling locks = kDisallowHoldingLocks> 61 void Increment(Thread* self, int delta) REQUIRES(!lock_); 62 63 // Increment the count by delta, wait on condition if count is non zero, with a timeout. Returns 64 // true if time out occurred. 65 bool Increment(Thread* self, int delta, uint32_t timeout_ms) REQUIRES(!lock_); 66 67 // Set the count to a new value. This should only be used if there is no possibility that 68 // another thread is still in Wait(). See above. 69 void Init(Thread* self, int count) REQUIRES(!lock_); 70 71 int GetCount(Thread* self) REQUIRES(!lock_); 72 73 private: 74 void SetCountLocked(Thread* self, int count) REQUIRES(lock_); 75 76 // Counter, when this reaches 0 all people blocked on the barrier are signalled. 77 int count_ GUARDED_BY(lock_); 78 79 Mutex lock_ ACQUIRED_AFTER(Locks::abort_lock_); 80 ConditionVariable condition_ GUARDED_BY(lock_); 81 }; 82 83 } // namespace art 84 #endif // ART_RUNTIME_BARRIER_H_ 85