upload android base code part3

android/art/runtime/barrier.h

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// CAUTION: THIS IS NOT A FULLY GENERAL BARRIER API.
+
+// It may either be used as a "latch" or single-use barrier, or it may be reused under
+// very limited conditions, e.g. if only Pass(), but not Wait() is called.  Unlike a standard
+// latch API, it is possible to initialize the latch to a count of zero, repeatedly call
+// Pass() or Wait(), and only then set the count using the Increment() method.  Threads at
+// a Wait() are only awoken if the count reaches zero AFTER the decrement is applied.
+// This works because, also unlike most latch APIs, there is no way to Wait() without
+// decrementing the count, and thus nobody can spuriosly wake up on the initial zero.
+
+#ifndef ART_RUNTIME_BARRIER_H_
+#define ART_RUNTIME_BARRIER_H_
+
+#include <memory>
+#include "base/mutex.h"
+
+namespace art {
+
+// TODO: Maybe give this a better name.
+class Barrier {
+ public:
+  explicit Barrier(int count);
+  virtual ~Barrier();
+
+  // Pass through the barrier, decrement the count but do not block.
+  void Pass(Thread* self) REQUIRES(!lock_);
+
+  // Wait on the barrier, decrement the count.
+  void Wait(Thread* self) REQUIRES(!lock_);
+
+  // The following three calls are only safe if we somehow know that no other thread both
+  // - has been woken up, and
+  // - has not left the Wait() or Increment() call.
+  // If these calls are made in that situation, the offending thread is likely to go back
+  // to sleep, resulting in a deadlock.
+
+  // Increment the count by delta, wait on condition if count is non zero.
+  void Increment(Thread* self, int delta) REQUIRES(!lock_);
+
+  // 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_);
+
+  // 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_);
+
+  int GetCount(Thread* self) REQUIRES(!lock_);
+
+ private:
+  void SetCountLocked(Thread* self, int count) REQUIRES(lock_);
+
+  // Counter, when this reaches 0 all people blocked on the barrier are signalled.
+  int count_ GUARDED_BY(lock_);
+
+  Mutex lock_ ACQUIRED_AFTER(Locks::abort_lock_);
+  ConditionVariable condition_ GUARDED_BY(lock_);
+};
+
+}  // namespace art
+#endif  // ART_RUNTIME_BARRIER_H_