blob: 94977fb741c8ed9cd82747b80dfb8b92dafd1775 [file] [log] [blame]
Mathieu Chartier858f1c52012-10-17 17:45:55 -07001/*
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
Hans Boehm5567c112014-12-02 18:31:31 -080017// 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
Brian Carlstromfc0e3212013-07-17 14:40:12 -070027#ifndef ART_RUNTIME_BARRIER_H_
28#define ART_RUNTIME_BARRIER_H_
Mathieu Chartier858f1c52012-10-17 17:45:55 -070029
Ian Rogers700a4022014-05-19 16:49:03 -070030#include <memory>
Elliott Hughes76b61672012-12-12 17:47:30 -080031#include "base/mutex.h"
Mathieu Chartier858f1c52012-10-17 17:45:55 -070032
33namespace art {
34
Hans Boehm5567c112014-12-02 18:31:31 -080035// TODO: Maybe give this a better name.
Mathieu Chartier858f1c52012-10-17 17:45:55 -070036class Barrier {
37 public:
Brian Carlstrom93ba8932013-07-17 21:31:49 -070038 explicit Barrier(int count);
Mathieu Chartier858f1c52012-10-17 17:45:55 -070039 virtual ~Barrier();
40
Hans Boehm5567c112014-12-02 18:31:31 -080041 // Pass through the barrier, decrement the count but do not block.
Mathieu Chartier90443472015-07-16 20:32:27 -070042 void Pass(Thread* self) REQUIRES(!lock_);
Mathieu Chartier858f1c52012-10-17 17:45:55 -070043
44 // Wait on the barrier, decrement the count.
Mathieu Chartier90443472015-07-16 20:32:27 -070045 void Wait(Thread* self) REQUIRES(!lock_);
Mathieu Chartier858f1c52012-10-17 17:45:55 -070046
Hans Boehm5567c112014-12-02 18:31:31 -080047 // 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.
Mathieu Chartier858f1c52012-10-17 17:45:55 -070052
53 // Increment the count by delta, wait on condition if count is non zero.
Mathieu Chartier90ef3db2015-08-04 15:19:41 -070054 void Increment(Thread* self, int delta) REQUIRES(!lock_);
Mathieu Chartier858f1c52012-10-17 17:45:55 -070055
Ian Rogers7b078e82014-09-10 14:44:24 -070056 // Increment the count by delta, wait on condition if count is non zero, with a timeout. Returns
57 // true if time out occurred.
Mathieu Chartier90443472015-07-16 20:32:27 -070058 bool Increment(Thread* self, int delta, uint32_t timeout_ms) REQUIRES(!lock_);
Dave Allison0aded082013-11-07 13:15:11 -080059
Hans Boehm5567c112014-12-02 18:31:31 -080060 // 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.
Mathieu Chartier90443472015-07-16 20:32:27 -070062 void Init(Thread* self, int count) REQUIRES(!lock_);
Hans Boehm5567c112014-12-02 18:31:31 -080063
Mathieu Chartier858f1c52012-10-17 17:45:55 -070064 private:
Mathieu Chartier90443472015-07-16 20:32:27 -070065 void SetCountLocked(Thread* self, int count) REQUIRES(lock_);
Mathieu Chartier858f1c52012-10-17 17:45:55 -070066
67 // Counter, when this reaches 0 all people blocked on the barrier are signalled.
68 int count_ GUARDED_BY(lock_);
69
Ian Rogers8409ec42014-11-04 17:57:02 -080070 Mutex lock_ ACQUIRED_AFTER(Locks::abort_lock_);
Mathieu Chartier858f1c52012-10-17 17:45:55 -070071 ConditionVariable condition_ GUARDED_BY(lock_);
72};
73
74} // namespace art
Brian Carlstromfc0e3212013-07-17 14:40:12 -070075#endif // ART_RUNTIME_BARRIER_H_