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 explicit Barrier(int count); 39 virtual ~Barrier(); 40 41 // Pass through the barrier, decrement the count but do not block. 42 void Pass(Thread* self) REQUIRES(!lock_); 43 44 // Wait on the barrier, decrement the count. 45 void Wait(Thread* self) REQUIRES(!lock_); 46 47 // The following three calls are only safe if we somehow know that no other thread both 48 // - has been woken up, and 49 // - has not left the Wait() or Increment() call. 50 // If these calls are made in that situation, the offending thread is likely to go back 51 // to sleep, resulting in a deadlock. 52 53 // Increment the count by delta, wait on condition if count is non zero. 54 void Increment(Thread* self, int delta) REQUIRES(!lock_); 55 56 // Increment the count by delta, wait on condition if count is non zero, with a timeout. Returns 57 // true if time out occurred. 58 bool Increment(Thread* self, int delta, uint32_t timeout_ms) REQUIRES(!lock_); 59 60 // Set the count to a new value. This should only be used if there is no possibility that 61 // another thread is still in Wait(). See above. 62 void Init(Thread* self, int count) REQUIRES(!lock_); 63 64 int GetCount(Thread* self) REQUIRES(!lock_); 65 66 private: 67 void SetCountLocked(Thread* self, int count) REQUIRES(lock_); 68 69 // Counter, when this reaches 0 all people blocked on the barrier are signalled. 70 int count_ GUARDED_BY(lock_); 71 72 Mutex lock_ ACQUIRED_AFTER(Locks::abort_lock_); 73 ConditionVariable condition_ GUARDED_BY(lock_); 74 }; 75 76 } // namespace art 77 #endif // ART_RUNTIME_BARRIER_H_ 78