Mercurial > hg > graal-compiler
view agent/src/os/win32/Monitor.cpp @ 512:db4caa99ef11
6787106: Hotspot 32 bit build fails on platforms having different definitions for intptr_t & int32_t
Summary: Avoid casting between int32_t and intptr_t specifically for MasmAssembler::movptr in 32 bit platforms.
Reviewed-by: jrose, kvn
author | xlu |
---|---|
date | Wed, 24 Dec 2008 13:06:09 -0800 |
parents | a61af66fc99e |
children | c18cbe5936b8 |
line wrap: on
line source
/* * 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()); }