--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/agent/src/os/win32/Monitor.cpp	Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,176 @@
+/*
+ * Copyright 2001 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+#include <stdio.h>
+#include <assert.h>
+#include "Monitor.hpp"
+
+Monitor::Monitor() {
+  _lock_count = -1;       // No threads have entered the critical section
+  _owner = NULL;
+  _lock_event = CreateEvent(NULL, false, false, NULL);
+  _wait_event = CreateEvent(NULL, true, false, NULL);
+  _counter = 0;
+  _tickets = 0;
+  _waiters = 0;
+}
+
+Monitor::~Monitor() {
+  assert(_owner == NULL);    // Otherwise, owned monitor being deleted
+  assert(_lock_count == -1); // Otherwise, monitor being deleted with non -1 lock count
+  CloseHandle(_lock_event);
+  CloseHandle(_wait_event);
+}
+
+void
+Monitor::lock() {
+  if (InterlockedIncrement(&_lock_count) == 0) {
+    // Success, we now own the lock
+  } else {
+    DWORD dwRet = WaitForSingleObject((HANDLE)_lock_event,  INFINITE);
+    assert(dwRet == WAIT_OBJECT_0); // Unexpected return value from WaitForSingleObject
+  }
+  assert(owner() == NULL); // Otherwise, lock count and owner are inconsistent
+  setOwner(GetCurrentThread());
+}
+
+void
+Monitor::unlock() {
+  setOwner(NULL);
+  if (InterlockedDecrement(&_lock_count) >= 0) {
+    // Wake a waiting thread up
+    DWORD dwRet = SetEvent(_lock_event);
+    assert(dwRet != 0); // Unexpected return value from SetEvent
+  }
+}
+
+bool
+Monitor::wait(long timeout) {
+  assert(owner() != NULL);
+  assert(owner() == GetCurrentThread());
+
+  // 0 means forever. Convert to Windows specific code.
+  DWORD timeout_value = (timeout == 0) ? INFINITE : timeout;
+  DWORD which;
+
+  long c = _counter;
+  bool retry = false;
+
+  _waiters++;
+  // Loop until condition variable is signaled.  The event object is
+  // set whenever the condition variable is signaled, and tickets will
+  // reflect the number of threads which have been notified. The counter
+  // field is used to make sure we don't respond to notifications that
+  // have occurred *before* we started waiting, and is incremented each
+  // time the condition variable is signaled.
+
+  while (true) {
+
+    // Leave critical region
+    unlock();
+
+    // If this is a retry, let other low-priority threads have a chance
+    // to run.  Make sure that we sleep outside of the critical section.
+    if (retry) {
+      Sleep(1);
+    } else {
+      retry = true;
+    }
+
+    which = WaitForSingleObject(_wait_event, timeout_value);
+    // Enter critical section
+    lock();
+
+    if (_tickets != 0 && _counter != c) break;
+
+    if (which == WAIT_TIMEOUT) {
+      --_waiters;
+      return true;
+    }
+  }
+  _waiters--;
+
+  // If this was the last thread to be notified, then we need to reset
+  // the event object.
+  if (--_tickets == 0) {
+    ResetEvent(_wait_event);
+  }
+
+  return false;
+}
+
+// Notify a single thread waiting on this monitor
+bool
+Monitor::notify() {
+  assert(ownedBySelf()); // Otherwise, notify on unknown thread
+
+  if (_waiters > _tickets) {
+    if (!SetEvent(_wait_event)) {
+      return false;
+    }
+    _tickets++;
+    _counter++;
+  }
+
+  return true;
+}
+
+// Notify all threads waiting on this monitor
+bool
+Monitor::notifyAll() {
+  assert(ownedBySelf()); // Otherwise, notifyAll on unknown thread
+
+  if (_waiters > 0) {
+    if (!SetEvent(_wait_event)) {
+      return false;
+    }
+    _tickets = _waiters;
+    _counter++;
+  }
+
+  return true;
+}
+
+HANDLE
+Monitor::owner() {
+  return _owner;
+}
+
+void
+Monitor::setOwner(HANDLE owner) {
+  if (owner != NULL) {
+    assert(_owner == NULL);                 // Setting owner thread of already owned monitor
+    assert(owner == GetCurrentThread());    // Else should not be doing this
+  } else {
+    HANDLE oldOwner = _owner;
+    assert(oldOwner != NULL);               // Removing the owner thread of an unowned mutex
+    assert(oldOwner == GetCurrentThread());
+  }
+  _owner = owner;
+}
+
+bool
+Monitor::ownedBySelf() {
+  return (_owner == GetCurrentThread());
+}