/*

 * 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());

}