From a7d20a157ab17cd479c2a4af62e67ac4f6349cb0 Mon Sep 17 00:00:00 2001 From: rpj Date: Thu, 23 Jul 1998 14:55:59 +0000 Subject: Fri Jul 24 00:21:21 1998 Ross Johnson * create.c (pthread_create): Arg to _pthread_new_thread_entry() changed. See next entry. Move mutex locks out. Changes made yesterday and today allow us to start the new thread running rather than temporarily suspended. * private.c (_pthread_new_thread_entry): _pthread_thread_table was changed back to a table of thread structures rather than pointers. As such we're trading storage for increaded speed. This routine was modified to work with the new table. Mutex lock put in around global data accesses. (_pthread_find_thread_entry): Ditto (_pthread_delete_thread_entry): Ditto --- ChangeLog | 15 +++++++++++++++ create.c | 45 +++++++++++++++---------------------------- private.c | 65 ++++++++++++++++++++++++++++++--------------------------------- 3 files changed, 61 insertions(+), 64 deletions(-) diff --git a/ChangeLog b/ChangeLog index 7d61a9d..2227088 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,18 @@ +Fri Jul 24 00:21:21 1998 Ross Johnson + + * create.c (pthread_create): Arg to _pthread_new_thread_entry() + changed. See next entry. Move mutex locks out. Changes made yesterday + and today allow us to start the new thread running rather than + temporarily suspended. + + * private.c (_pthread_new_thread_entry): _pthread_thread_table + was changed back to a table of thread structures rather than pointers. + As such we're trading storage for increaded speed. This routine + was modified to work with the new table. Mutex lock put in around + global data accesses. + (_pthread_find_thread_entry): Ditto + (_pthread_delete_thread_entry): Ditto + Thu Jul 23 23:25:30 1998 Ross Johnson * global.c: New. Global data objects declared here. These moved from diff --git a/create.c b/create.c index 37ce88f..b4a6c99 100644 --- a/create.c +++ b/create.c @@ -12,15 +12,20 @@ #include "implement.h" unsigned -_pthread_start_call(void *this) +_pthread_start_call(void * call) { /* We're now in a running thread. Any local variables here are on this threads private stack so we're safe to leave data in them until we leave. */ - unsigned (*func)(void *) = this->call.routine; - void * arg = this->call.arg; + _pthread_call_t * this; + unsigned (*func)(void *); + void * arg; unsigned ret; + this = (_pthread_call_t *) call; + func = call->routine; + arg = call->arg; + ret = (*func)(arg); /* If we get to here then we're returning naturally and haven't @@ -40,30 +45,19 @@ pthread_create(pthread_t *thread, HANDLE handle = NULL; unsigned flags; void * security = NULL; - - /* FIXME: This needs to be moved into process space. - Perhaps into a structure that contains all - per thread info that is Win32 thread specific but - not visible from the pthreads API, and - accessible through HANDLE (or pthread_t). - */ - SECURITY_ATTRIBUTES security_attr; DWORD threadID; - /* Success unless otherwise set. */ - int ret = 0; pthread_attr_t * attr_copy; _pthread_threads_thread_t * this; + /* Success unless otherwise set. */ + int ret = 0; - /* CRITICAL SECTION */ - pthread_mutex_lock(&_pthread_count_mutex); - - if (_pthread_new_thread_entry((pthread_t) handle, &this) == 0) + if (_pthread_new_thread_entry((pthread_t) handle, this) == 0) { attr_copy = &(this->attr); if (attr != NULL) { - /* Map attributes */ + /* Map attributes. */ if (attr_copy->stacksize == 0) { attr_copy->stacksize = PTHREAD_STACK_MIN; @@ -72,15 +66,13 @@ pthread_create(pthread_t *thread, attr_copy->cancelability = attr->cancelability; } - /* Start suspended and resume at the last moment to avoid - race conditions, ie. where a thread may enquire it's - attributes before we finish storing them away. */ - flags = 1; + /* Start running, not suspended. */ + flags = 0; handle = (HANDLE) _beginthreadex(security, attr_copy->stacksize, _pthread_start_call, - (void *) this, + (void *) &(this->call), flags, &threadID); @@ -94,17 +86,10 @@ pthread_create(pthread_t *thread, ret = EAGAIN; } - /* Let others in as soon as possible. */ - pthread_mutex_unlock(&_pthread_count_mutex); - /* END CRITICAL SECTION */ - if (ret == 0) { /* Let the caller know the thread handle. */ *thread = (pthread_t) handle; - - /* POSIX threads are always running after creation. */ - ResumeThread(handle); } else { diff --git a/private.c b/private.c index 77f0334..4e5f9ed 100644 --- a/private.c +++ b/private.c @@ -25,10 +25,12 @@ */ int -_pthread_new_thread_entry(pthread_t thread, - _pthread_threads_thread_t ** entry) +_pthread_new_thread_entry(pthread_t thread, _pthread_threads_thread_t * entry) { - _pthread_threads_thread_t ** this; + _pthread_threads_thread_t * this; + + /* CRITICAL SECTION */ + pthread_mutex_lock(&_pthread_count_mutex); if (_pthread_threads_count >= PTHREAD_THREADS_MAX) { @@ -37,7 +39,7 @@ _pthread_new_thread_entry(pthread_t thread, this = &_pthread_threads_table[_PTHREAD_HASH_INDEX(thread)]; - while ((*this)->thread != NULL) + while (this->thread != NULL) { this++; @@ -48,45 +50,40 @@ _pthread_new_thread_entry(pthread_t thread, } } - if ((*this)->thread != NULL) + if (this->thread != NULL) { /* INTERNAL ERROR: There should be at least one slot left. */ return ESRCH; } else { - new = (_pthread_threads_thread_t *) malloc(sizeof(_pthread_threads_thread_t)); - - if (new == NULL) - { - return ENOMEM; - } - - new->thread = thread; - pthread_attr_init(&(new->attr)); - new->cleanupstack = NULL; - new->destructorstack = NULL; - new->forkpreparestack = NULL; - new->forkparentstack = NULL; - new->forkchildstack = NULL; - *this = new; + this->thread = thread; + pthread_attr_init(&(this->attr)); + this->cleanupstack = NULL; + this->destructorstack = NULL; + this->forkpreparestack = NULL; + this->forkparentstack = NULL; + this->forkchildstack = NULL; } _pthread_threads_count++; entry = this; + pthread_mutex_unlock(&_pthread_count_mutex); + /* END CRITICAL SECTION */ + return 0; } -_pthread_threads_thread ** +_pthread_threads_thread * _pthread_find_thread_entry(pthread_t thread) { - _pthread_threads_thread_t ** this; - _pthread_threads_thread_t ** start; + _pthread_threads_thread_t * this; + _pthread_threads_thread_t * start; start = this = &_pthread_threads_table[_PTHREAD_HASH_INDEX(thread)]; - while ((*this)->thread != thread) + while (this->thread != thread) { this++; @@ -96,7 +93,7 @@ _pthread_find_thread_entry(pthread_t thread) this = _pthread_threads_table; } - if ((*this)->thread == NULL || this == start) + if (this->thread == NULL || this == start) { /* Failed to find the thread. */ return -1; @@ -107,12 +104,12 @@ _pthread_find_thread_entry(pthread_t thread) } void -_pthread_delete_thread_entry(_pthread_threads_thread_t ** this) +_pthread_delete_thread_entry(_pthread_threads_thread_t * this) { /* We don't check that the thread has been properly cleaned up, so it had better be done already. */ - _pthread_threads_thread ** this; - _pthread_threads_thread ** entry; + _pthread_threads_thread_t * this; + _pthread_threads_thread_t * entry; /* CRITICAL SECTION */ pthread_mutex_lock(&_pthread_count_mutex); @@ -125,12 +122,9 @@ _pthread_delete_thread_entry(_pthread_threads_thread_t ** this) this = _PTHREAD_THIS; } - if (this != NULL) + if (this->thread != NULL) { - entry = this; - /* Do this first to avoid contention and then free the storage. */ - this = NULL; - free(*entry); + this->thread = NULL; if (_pthread_threads_count > 0) { @@ -141,8 +135,11 @@ _pthread_delete_thread_entry(_pthread_threads_thread_t ** this) /* FIXME: INTERNAL ERROR: This should not happen. */ } } + else + { + /* FIXME: INTERNAL ERROR: This should not happen. */ + } pthread_mutex_unlock(&_pthread_count_mutex); /* END CRITICAL SECTION */ } - -- cgit v1.2.3