OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

win32-threads.cc: (ensure_interrupt_event_initialized) New function for lazy initialization of an... 

* win32-threads.cc: (ensure_interrupt_event_initialized) New
	function for lazy initialization of an auto-reset event.
	(_Jv_CondWait) Added thread interrupt support.
	(_Jv_ThreadInitData) Added initialization of interrupt support
	members.
	(_Jv_ThreadDestroyData) Added cleanup of interrupt support members.
	(_Jv_ThreadStart) Removed unused code.
	(_Jv_Win32GetInterruptEvent) New method for returning interrupt event
	to an external caller.
	(_Jv_ThreadInterrupt) Implemented.
	* include/win32-threads.h: (_Jv_Thread_t) Added a Win32 auto-reset
	event for interrupt support as well as a mutex which regulates
	access to this.
	(_Jv_Win32GetInterruptEvent) Declared new method for returning interrupt
	event to an external caller.
	* java/lang/natWin32Process.cc: (cleanup) Close handle to spawned
	process.
	(waitFor) Added interrupt support.

From-SVN: r71562
This commit is contained in:
Mohan Embar 2003-09-19 08:28:43 +00:00 committed by Mohan Embar
parent 65f070242b
commit b90e0e3cdb
4 changed files with 152 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
libjava/ChangeLog
View File

@ -1,3 +1,24 @@
2003-09-19 Mohan Embar <gnustuff@thisiscool.com>
* win32-threads.cc: (ensure_interrupt_event_initialized) New
function for lazy initialization of an auto-reset event.
(_Jv_CondWait) Added thread interrupt support.
(_Jv_ThreadInitData) Added initialization of interrupt support
members.
(_Jv_ThreadDestroyData) Added cleanup of interrupt support members.
(_Jv_ThreadStart) Removed unused code.
(_Jv_Win32GetInterruptEvent) New method for returning interrupt event
to an external caller.
(_Jv_ThreadInterrupt) Implemented.
* include/win32-threads.h: (_Jv_Thread_t) Added a Win32 auto-reset
event for interrupt support as well as a mutex which regulates
access to this.
(_Jv_Win32GetInterruptEvent) Declared new method for returning interrupt
event to an external caller.
* java/lang/natWin32Process.cc: (cleanup) Close handle to spawned
process.
(waitFor) Added interrupt support.
2003-09-19 Michael Koch <konqueror@gmx.de>
* java/net/DatagramSocket.java (getLocalAddress):

26
libjava/include/win32-threads.h
View File

@ -50,6 +50,14 @@ typedef struct
{
int flags; // Flags are defined in implementation.
HANDLE handle; // Actual handle to the thread
// Protects access to the thread's interrupt_flag and
// interrupt_event variables within this module.
CRITICAL_SECTION interrupt_mutex;
// A Win32 auto-reset event for thread interruption
HANDLE interrupt_event;
java::lang::Thread *thread_obj;
} _Jv_Thread_t;
@ -150,6 +158,24 @@ void _Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data,
void _Jv_ThreadWait (void);
void _Jv_ThreadInterrupt (_Jv_Thread_t *data);
//
// Thread interruption support
//
// Gets the auto-reset event for the current thread which is
// signalled by _Jv_ThreadInterrupt. The caller can wait on this
// event in addition to other waitable objects.
//
// NOTE: After waiting on this event with WaitForMultipleObjects,
// you should ALWAYS use the return value of WaitForMultipleObjects
// to test whether this event was signalled and whether thread
// interruption has occurred. You should do this instead of checking
// the thread's interrupted_flag, because someone could have reset
// this flag in the interval of time between the return of
// WaitForMultipleObjects and the time you query interrupted_flag.
// See java/lang/natWin32Process.cc (waitFor) for an example.
HANDLE _Jv_Win32GetInterruptEvent (void);
// Remove defines from <windows.h> that conflict with various things in libgcj code
#undef TRUE

29
libjava/java/lang/natWin32Process.cc
View File

@ -46,6 +46,11 @@ java::lang::ConcreteProcess::cleanup (void)
errorStream->close ();
errorStream = NULL;
}
if (procHandle)
{
CloseHandle((HANDLE) procHandle);
procHandle = (jint) INVALID_HANDLE_VALUE;
}
}
void
@ -92,8 +97,28 @@ java::lang::ConcreteProcess::waitFor (void)
{
DWORD exitStatus = 0UL;
// FIXME: The wait should be interruptible.
WaitForSingleObject ((HANDLE) procHandle, INFINITE);
// Set up our waitable objects array
// - 0: the handle to the process we just launched
// - 1: our thread's interrupt event
HANDLE arh[2];
arh[0] = (HANDLE) procHandle;
arh[1] = _Jv_Win32GetInterruptEvent ();
DWORD rval = WaitForMultipleObjects (2, arh, 0, INFINITE);
// Use the returned value from WaitForMultipleObjects
// instead of our thread's interrupt_flag to test for
// thread interruption. See the comment for
// _Jv_Win32GetInterruptEvent().
bool bInterrupted = rval == (WAIT_OBJECT_0 + 1);
if (bInterrupted)
{
// Querying this forces a reset our thread's interrupt flag.
Thread::interrupted();
cleanup ();
throw new InterruptedException ();
}
GetExitCodeProcess ((HANDLE) procHandle, &exitStatus);
exitCode = exitStatus;

87
libjava/win32-threads.cc
View File

@ -81,6 +81,16 @@ ensure_condvar_initialized(_Jv_ConditionVariable_t *cv)
}
}
inline void
ensure_interrupt_event_initialized(HANDLE& rhEvent)
{
if (!rhEvent)
{
rhEvent = CreateEvent (NULL, 0, 0, NULL);
if (!rhEvent) JvFail("CreateEvent() failed");
}
}
// Reimplementation of the general algorithm described at
// http://www.cs.wustl.edu/~schmidt/win32-cv-1.html (isomorphic to
// 3.2, not a cut-and-paste).
@ -91,6 +101,21 @@ _Jv_CondWait(_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu, jlong millis, jint na
if (mu->owner != GetCurrentThreadId ( ))
return _JV_NOT_OWNER;
_Jv_Thread_t *current = _Jv_ThreadCurrentData ();
java::lang::Thread *current_obj = _Jv_ThreadCurrent ();
// Now that we hold the interrupt mutex, check if this thread has been
// interrupted already.
EnterCriticalSection (&current->interrupt_mutex);
ensure_interrupt_event_initialized (current->interrupt_event);
jboolean interrupted = current_obj->interrupt_flag;
LeaveCriticalSection (&current->interrupt_mutex);
if (interrupted)
{
return _JV_INTERRUPTED;
}
EnterCriticalSection (&cv->count_mutex);
ensure_condvar_initialized (cv);
cv->blocked_count++;
@ -103,7 +128,31 @@ _Jv_CondWait(_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu, jlong millis, jint na
_Jv_MutexUnlock (mu);
DWORD rval = WaitForMultipleObjects (2, &(cv->ev[0]), 0, time);
// Set up our array of three events:
// - the auto-reset event (for notify())
// - the manual-reset event (for notifyAll())
// - the interrupt event (for interrupt())
// We wait for any one of these to be signaled.
HANDLE arh[3];
arh[0] = cv->ev[0];
arh[1] = cv->ev[1];
arh[2] = current->interrupt_event;
DWORD rval = WaitForMultipleObjects (3, arh, 0, time);
EnterCriticalSection (&current->interrupt_mutex);
// If we were unblocked by the third event (our thread's interrupt
// event), set the thread's interrupt flag. I think this sanity
// check guards against someone resetting our interrupt flag
// in the time between when interrupt_mutex is released in
// _Jv_ThreadInterrupt and the interval of time between the
// WaitForMultipleObjects call we just made and our acquisition
// of interrupt_mutex.
if (rval == (WAIT_OBJECT_0 + 2))
current_obj->interrupt_flag = true;
interrupted = current_obj->interrupt_flag;
LeaveCriticalSection (&current->interrupt_mutex);
EnterCriticalSection(&cv->count_mutex);
cv->blocked_count--;
@ -116,8 +165,8 @@ _Jv_CondWait(_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu, jlong millis, jint na
ResetEvent (cv->ev[1]);
_Jv_MutexLock (mu);
return 0;
return interrupted ? _JV_INTERRUPTED : 0;
}
void
@ -197,6 +246,8 @@ _Jv_ThreadInitData (java::lang::Thread* obj)
_Jv_Thread_t *data = (_Jv_Thread_t*)_Jv_Malloc(sizeof(_Jv_Thread_t));
data->flags = 0;
data->thread_obj = obj;
data->interrupt_event = 0;
InitializeCriticalSection (&data->interrupt_mutex);
return data;
}
@ -204,6 +255,9 @@ _Jv_ThreadInitData (java::lang::Thread* obj)
void
_Jv_ThreadDestroyData (_Jv_Thread_t *data)
{
DeleteCriticalSection (&data->interrupt_mutex);
if (data->interrupt_event)
CloseHandle(data->interrupt_event);
_Jv_Free(data);
}
@ -308,11 +362,8 @@ _Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data, _Jv_ThreadStart
else
data->flags |= FLAG_DAEMON;
HANDLE h = GC_CreateThread(NULL, 0, really_start, info, 0, &id);
GC_CreateThread(NULL, 0, really_start, info, 0, &id);
_Jv_ThreadSetPriority(data, thread->getPriority());
//if (!h)
//JvThrow ();
}
void
@ -326,9 +377,27 @@ _Jv_ThreadWait (void)
}
}
//
// Interrupt support
//
HANDLE
_Jv_Win32GetInterruptEvent (void)
{
_Jv_Thread_t *current = _Jv_ThreadCurrentData ();
EnterCriticalSection (&current->interrupt_mutex);
ensure_interrupt_event_initialized (current->interrupt_event);
HANDLE hEvent = current->interrupt_event;
LeaveCriticalSection (&current->interrupt_mutex);
return hEvent;
}
void
_Jv_ThreadInterrupt (_Jv_Thread_t *data)
{
MessageBox(NULL, "Unimplemented", "win32-threads.cc:_Jv_ThreadInterrupt", MB_OK);
// FIXME:
EnterCriticalSection (&data->interrupt_mutex);
ensure_interrupt_event_initialized (data->interrupt_event);
data->thread_obj->interrupt_flag = true;
SetEvent (data->interrupt_event);
LeaveCriticalSection (&data->interrupt_mutex);
}