d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
c207703465
freebsd-nq/lib/libpthread/thread/thr_gc.c

281 lines
7.4 KiB
C
Raw Normal View History

Move the cleanup code that frees memory allocated for a dead thread from the thread kernel into a garbage collector thread which is started when the fisrt thread is created (other than the initial thread). This removes the window of opportunity where a context switch will cause a thread that has locked the malloc spinlock, to enter the thread kernel, find there is a dead thread and try to free memory, therefore trying to lock the malloc spinlock against itself. The garbage collector thread acts just like any other thread, so instead of having a spinlock to control accesses to the dead thread list, it uses a mutex and a condition variable so that it can happily wait to be signalled when a thread exists.
1998-09-30 06:36:56 +00:00
/*
* Copyright (c) 1998 John Birrell <jb@cimlogic.com.au>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by John Birrell.
* 4. Neither the name of the author nor the names of any co-contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
[ The author's description... ] o Runnable threads are now maintained in priority queues. The implementation requires two things: 1.) The priority queues must be protected during insertion and removal of threads. Since the kernel scheduler must modify the priority queues, a spinlock for protection cannot be used. The functions _thread_kern_sched_defer() and _thread_kern_sched_undefer() were added to {un}defer kernel scheduler activation. 2.) A thread (active) priority change can be performed only when the thread is removed from the priority queue. The implementation uses a threads active priority when inserting it into the queue. A by-product is that thread switches are much faster. A separate queue is used for waiting and/or blocked threads, and it is searched at most 2 times in the kernel scheduler when there are active threads. It should be possible to reduce this to once by combining polling of threads waiting on I/O with the loop that looks for timed out threads and the minimum timeout value. o Functions to defer kernel scheduler activation were added. These are _thread_kern_sched_defer() and _thread_kern_sched_undefer() and may be called recursively. These routines do not block the scheduling signal, but latch its occurrence. The signal handler will not call the kernel scheduler when the running thread has deferred scheduling, but it will be called when running thread undefers scheduling. o Added support for _POSIX_THREAD_PRIORITY_SCHEDULING. All the POSIX routines required by this should now be implemented. One note, SCHED_OTHER, SCHED_FIFO, and SCHED_RR are required to be defined by including pthread.h. These defines are currently in sched.h. I modified pthread.h to include sched.h but don't know if this is the proper thing to do. o Added support for priority protection and inheritence mutexes. This allows definition of _POSIX_THREAD_PRIO_PROTECT and _POSIX_THREAD_PRIO_INHERIT. o Added additional error checks required by POSIX for mutexes and condition variables. o Provided a wrapper for sigpending which is marked as a hidden syscall. o Added a non-portable function as a debugging aid to allow an application to monitor thread context switches. An application can install a routine that gets called everytime a thread (explicitly created by the application) gets context switched. The routine gets passed the pthread IDs of the threads that are being switched in and out. Submitted by: Dan Eischen <eischen@vigrid.com> Changes by me: o Added a PS_SPINBLOCK state to deal with the priority inversion problem most often (I think) seen by threads calling malloc/free/realloc. o Dispatch signals to the running thread directly rather than at a context switch to avoid the situation where the switch never occurs.
1999-03-23 05:07:56 +00:00
* $Id: uthread_gc.c,v 1.2 1998/09/30 19:17:51 dt Exp $
Move the cleanup code that frees memory allocated for a dead thread from the thread kernel into a garbage collector thread which is started when the fisrt thread is created (other than the initial thread). This removes the window of opportunity where a context switch will cause a thread that has locked the malloc spinlock, to enter the thread kernel, find there is a dead thread and try to free memory, therefore trying to lock the malloc spinlock against itself. The garbage collector thread acts just like any other thread, so instead of having a spinlock to control accesses to the dead thread list, it uses a mutex and a condition variable so that it can happily wait to be signalled when a thread exists.
1998-09-30 06:36:56 +00:00
*
* Garbage collector thread. Frees memory allocated for dead threads.
*
*/
#include <errno.h>
#include <time.h>
#include <unistd.h>
#include <sys/types.h>
#include <pthread.h>
#include "pthread_private.h"
pthread_addr_t
_thread_gc(pthread_addr_t arg)
{
int f_debug;
int f_done = 0;
int ret;
[ The author's description... ] o Runnable threads are now maintained in priority queues. The implementation requires two things: 1.) The priority queues must be protected during insertion and removal of threads. Since the kernel scheduler must modify the priority queues, a spinlock for protection cannot be used. The functions _thread_kern_sched_defer() and _thread_kern_sched_undefer() were added to {un}defer kernel scheduler activation. 2.) A thread (active) priority change can be performed only when the thread is removed from the priority queue. The implementation uses a threads active priority when inserting it into the queue. A by-product is that thread switches are much faster. A separate queue is used for waiting and/or blocked threads, and it is searched at most 2 times in the kernel scheduler when there are active threads. It should be possible to reduce this to once by combining polling of threads waiting on I/O with the loop that looks for timed out threads and the minimum timeout value. o Functions to defer kernel scheduler activation were added. These are _thread_kern_sched_defer() and _thread_kern_sched_undefer() and may be called recursively. These routines do not block the scheduling signal, but latch its occurrence. The signal handler will not call the kernel scheduler when the running thread has deferred scheduling, but it will be called when running thread undefers scheduling. o Added support for _POSIX_THREAD_PRIORITY_SCHEDULING. All the POSIX routines required by this should now be implemented. One note, SCHED_OTHER, SCHED_FIFO, and SCHED_RR are required to be defined by including pthread.h. These defines are currently in sched.h. I modified pthread.h to include sched.h but don't know if this is the proper thing to do. o Added support for priority protection and inheritence mutexes. This allows definition of _POSIX_THREAD_PRIO_PROTECT and _POSIX_THREAD_PRIO_INHERIT. o Added additional error checks required by POSIX for mutexes and condition variables. o Provided a wrapper for sigpending which is marked as a hidden syscall. o Added a non-portable function as a debugging aid to allow an application to monitor thread context switches. An application can install a routine that gets called everytime a thread (explicitly created by the application) gets context switched. The routine gets passed the pthread IDs of the threads that are being switched in and out. Submitted by: Dan Eischen <eischen@vigrid.com> Changes by me: o Added a PS_SPINBLOCK state to deal with the priority inversion problem most often (I think) seen by threads calling malloc/free/realloc. o Dispatch signals to the running thread directly rather than at a context switch to avoid the situation where the switch never occurs.
1999-03-23 05:07:56 +00:00
sigset_t mask;
Move the cleanup code that frees memory allocated for a dead thread from the thread kernel into a garbage collector thread which is started when the fisrt thread is created (other than the initial thread). This removes the window of opportunity where a context switch will cause a thread that has locked the malloc spinlock, to enter the thread kernel, find there is a dead thread and try to free memory, therefore trying to lock the malloc spinlock against itself. The garbage collector thread acts just like any other thread, so instead of having a spinlock to control accesses to the dead thread list, it uses a mutex and a condition variable so that it can happily wait to be signalled when a thread exists.
1998-09-30 06:36:56 +00:00
pthread_t pthread;
pthread_t pthread_cln;
pthread_t pthread_nxt;
pthread_t pthread_prv;
struct timespec abstime;
void *p_stack;
[ The author's description... ] o Runnable threads are now maintained in priority queues. The implementation requires two things: 1.) The priority queues must be protected during insertion and removal of threads. Since the kernel scheduler must modify the priority queues, a spinlock for protection cannot be used. The functions _thread_kern_sched_defer() and _thread_kern_sched_undefer() were added to {un}defer kernel scheduler activation. 2.) A thread (active) priority change can be performed only when the thread is removed from the priority queue. The implementation uses a threads active priority when inserting it into the queue. A by-product is that thread switches are much faster. A separate queue is used for waiting and/or blocked threads, and it is searched at most 2 times in the kernel scheduler when there are active threads. It should be possible to reduce this to once by combining polling of threads waiting on I/O with the loop that looks for timed out threads and the minimum timeout value. o Functions to defer kernel scheduler activation were added. These are _thread_kern_sched_defer() and _thread_kern_sched_undefer() and may be called recursively. These routines do not block the scheduling signal, but latch its occurrence. The signal handler will not call the kernel scheduler when the running thread has deferred scheduling, but it will be called when running thread undefers scheduling. o Added support for _POSIX_THREAD_PRIORITY_SCHEDULING. All the POSIX routines required by this should now be implemented. One note, SCHED_OTHER, SCHED_FIFO, and SCHED_RR are required to be defined by including pthread.h. These defines are currently in sched.h. I modified pthread.h to include sched.h but don't know if this is the proper thing to do. o Added support for priority protection and inheritence mutexes. This allows definition of _POSIX_THREAD_PRIO_PROTECT and _POSIX_THREAD_PRIO_INHERIT. o Added additional error checks required by POSIX for mutexes and condition variables. o Provided a wrapper for sigpending which is marked as a hidden syscall. o Added a non-portable function as a debugging aid to allow an application to monitor thread context switches. An application can install a routine that gets called everytime a thread (explicitly created by the application) gets context switched. The routine gets passed the pthread IDs of the threads that are being switched in and out. Submitted by: Dan Eischen <eischen@vigrid.com> Changes by me: o Added a PS_SPINBLOCK state to deal with the priority inversion problem most often (I think) seen by threads calling malloc/free/realloc. o Dispatch signals to the running thread directly rather than at a context switch to avoid the situation where the switch never occurs.
1999-03-23 05:07:56 +00:00
/* Block all signals */
sigfillset (&mask);
sigprocmask (SIG_BLOCK, &mask, NULL);
/* Mark this thread as a library thread (not a user thread). */
_thread_run->flags |= PTHREAD_FLAGS_PRIVATE;
Move the cleanup code that frees memory allocated for a dead thread from the thread kernel into a garbage collector thread which is started when the fisrt thread is created (other than the initial thread). This removes the window of opportunity where a context switch will cause a thread that has locked the malloc spinlock, to enter the thread kernel, find there is a dead thread and try to free memory, therefore trying to lock the malloc spinlock against itself. The garbage collector thread acts just like any other thread, so instead of having a spinlock to control accesses to the dead thread list, it uses a mutex and a condition variable so that it can happily wait to be signalled when a thread exists.
1998-09-30 06:36:56 +00:00
/* Set a debug flag based on an environment variable. */
Debug when an environment variable set, no when it is unset.
1998-09-30 19:17:51 +00:00
f_debug = (getenv("LIBC_R_DEBUG") != NULL);
Move the cleanup code that frees memory allocated for a dead thread from the thread kernel into a garbage collector thread which is started when the fisrt thread is created (other than the initial thread). This removes the window of opportunity where a context switch will cause a thread that has locked the malloc spinlock, to enter the thread kernel, find there is a dead thread and try to free memory, therefore trying to lock the malloc spinlock against itself. The garbage collector thread acts just like any other thread, so instead of having a spinlock to control accesses to the dead thread list, it uses a mutex and a condition variable so that it can happily wait to be signalled when a thread exists.
1998-09-30 06:36:56 +00:00
/* Set the name of this thread. */
pthread_set_name_np(_thread_run,"GC");
while (!f_done) {
/* Check if debugging this application. */
if (f_debug)
/* Dump thread info to file. */
_thread_dump_info();
/* Lock the thread list: */
_lock_thread_list();
/* Check if this is the last running thread: */
if (_thread_link_list == _thread_run &&
_thread_link_list->nxt == NULL)
/*
* This is the last thread, so it can exit
* now.
*/
f_done = 1;
/* Unlock the thread list: */
_unlock_thread_list();
/*
* Lock the garbage collector mutex which ensures that
* this thread sees another thread exit:
*/
if (pthread_mutex_lock(&_gc_mutex) != 0)
PANIC("Cannot lock gc mutex");
/* No stack of thread structure to free yet: */
p_stack = NULL;
pthread_cln = NULL;
/* Point to the first dead thread (if there are any): */
pthread = _thread_dead;
/* There is no previous dead thread: */
pthread_prv = NULL;
/*
* Enter a loop to search for the first dead thread that
* has memory to free.
*/
while (p_stack == NULL && pthread_cln == NULL &&
pthread != NULL) {
/* Save a pointer to the next thread: */
pthread_nxt = pthread->nxt_dead;
/* Check if the initial thread: */
if (pthread == _thread_initial)
/* Don't destroy the initial thread. */
pthread_prv = pthread;
/*
* Check if this thread has detached:
*/
else if ((pthread->attr.flags &
PTHREAD_DETACHED) != 0) {
/*
* Check if there is no previous dead
* thread:
*/
if (pthread_prv == NULL)
/*
* The dead thread is at the head
* of the list:
*/
_thread_dead = pthread_nxt;
else
/*
* The dead thread is not at the
* head of the list:
*/
pthread_prv->nxt_dead =
pthread->nxt_dead;
/*
* Check if the stack was not specified by
* the caller to pthread_create and has not
* been destroyed yet:
*/
if (pthread->attr.stackaddr_attr == NULL &&
pthread->stack != NULL) {
/*
* Point to the stack that must
* be freed outside the locks:
*/
p_stack = pthread->stack;
}
/*
* Point to the thread structure that must
* be freed outside the locks:
*/
pthread_cln = pthread;
} else {
/*
* This thread has not detached, so do
* not destroy it:
*/
pthread_prv = pthread;
/*
* Check if the stack was not specified by
* the caller to pthread_create and has not
* been destroyed yet:
*/
if (pthread->attr.stackaddr_attr == NULL &&
pthread->stack != NULL) {
/*
* Point to the stack that must
* be freed outside the locks:
*/
p_stack = pthread->stack;
/*
* NULL the stack pointer now
* that the memory has been freed:
*/
pthread->stack = NULL;
}
}
/* Point to the next thread: */
pthread = pthread_nxt;
}
/*
* Check if this is not the last thread and there is no
* memory to free this time around.
*/
if (!f_done && p_stack == NULL && pthread_cln == NULL) {
/* Get the current time. */
if (clock_gettime(CLOCK_REALTIME,&abstime) != 0)
PANIC("gc cannot get time");
/*
* Do a backup poll in 10 seconds if no threads
* die before then.
*/
abstime.tv_sec += 10;
/*
* Wait for a signal from a dying thread or a
* timeout (for a backup poll).
*/
if ((ret = pthread_cond_timedwait(&_gc_cond,
&_gc_mutex, &abstime)) != 0 && ret != ETIMEDOUT)
PANIC("gc cannot wait for a signal");
}
/* Unlock the garbage collector mutex: */
if (pthread_mutex_unlock(&_gc_mutex) != 0)
PANIC("Cannot unlock gc mutex");
/*
* If there is memory to free, do it now. The call to
* free() might block, so this must be done outside the
* locks.
*/
if (p_stack != NULL)
free(p_stack);
if (pthread_cln != NULL) {
/* Lock the thread list: */
_lock_thread_list();
/*
* Check if the thread is at the head of the
* linked list.
*/
if (_thread_link_list == pthread_cln)
/* There is no previous thread: */
_thread_link_list = pthread_cln->nxt;
else {
/* Point to the first thread in the list: */
pthread = _thread_link_list;
/*
* Enter a loop to find the thread in the
* linked list before the thread that is
* about to be freed.
*/
while (pthread != NULL &&
pthread->nxt != pthread_cln)
/* Point to the next thread: */
pthread = pthread->nxt;
/* Check that a previous thread was found: */
if (pthread != NULL) {
/*
* Point the previous thread to
* the one after the thread being
* freed:
*/
pthread->nxt = pthread_cln->nxt;
}
}
/* Unlock the thread list: */
_unlock_thread_list();
/*
* Free the memory allocated for the thread
* structure.
*/
free(pthread_cln);
}
}
return (NULL);
}
Reference in New Issue Copy Permalink