jdk8-mips64-public/hotspot: src/os/windows/vm/threadCritical

     1 /*

     2  * Copyright 2001-2003 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    25 # include "incls/_precompiled.incl"

    26 # include "incls/_threadCritical_windows.cpp.incl"

    28 // OS-includes here

    29 # include <windows.h>

    30 # include <winbase.h>

    32 //

    33 // See threadCritical.hpp for details of this class.

    34 //

    36 static bool initialized = false;

    37 static volatile jint lock_count = -1;

    38 static HANDLE lock_event;

    39 static DWORD lock_owner = -1;

    41 //

    42 // Note that Microsoft's critical region code contains a race

    43 // condition, and is not suitable for use. A thread holding the

    44 // critical section cannot safely suspend a thread attempting

    45 // to enter the critical region. The failure mode is that both

    46 // threads are permanently suspended.

    47 //

    48 // I experiemented with the use of ordinary windows mutex objects

    49 // and found them ~30 times slower than the critical region code.

    50 //

    52 void ThreadCritical::initialize() {

    53 }

    55 void ThreadCritical::release() {

    56   assert(lock_owner == -1, "Mutex being deleted while owned.");

    57   assert(lock_count == -1, "Mutex being deleted while recursively locked");

    58   assert(lock_event != NULL, "Sanity check");

    59   CloseHandle(lock_event);

    60 }

    62 ThreadCritical::ThreadCritical() {

    63   DWORD current_thread = GetCurrentThreadId();

    65   if (lock_owner != current_thread) {

    66     // Grab the lock before doing anything.

    67     while (Atomic::cmpxchg(0, &lock_count, -1) != -1) {

    68       if (initialized) {

    69         DWORD ret = WaitForSingleObject(lock_event,  INFINITE);

    70         assert(ret == WAIT_OBJECT_0, "unexpected return value from WaitForSingleObject");

    71       }

    72     }

    74     // Make sure the event object is allocated.

    75     if (!initialized) {

    76       // Locking will not work correctly unless this is autoreset.

    77       lock_event = CreateEvent(NULL, false, false, NULL);

    78       initialized = true;

    79     }

    81     assert(lock_owner == -1, "Lock acquired illegally.");

    82     lock_owner = current_thread;

    83   } else {

    84     // Atomicity isn't required. Bump the recursion count.

    85     lock_count++;

    86   }

    88   assert(lock_owner == GetCurrentThreadId(), "Lock acquired illegally.");

    89 }

    91 ThreadCritical::~ThreadCritical() {

    92   assert(lock_owner == GetCurrentThreadId(), "unlock attempt by wrong thread");

    93   assert(lock_count >= 0, "Attempt to unlock when already unlocked");

    95   if (lock_count == 0) {

    96     // We're going to unlock

    97     lock_owner = -1;

    98     lock_count = -1;

    99     // No lost wakeups, lock_event stays signaled until reset.

   100     DWORD ret = SetEvent(lock_event);

   101     assert(ret != 0, "unexpected return value from SetEvent");

   102   } else {

   103     // Just unwinding a recursive lock;

   104     lock_count--;

   105   }

   106 }

src/os/windows/vm/threadCritical_windows.cpp@a61af66fc99e