summaryrefslogtreecommitdiff
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/ChangeLog42
-rw-r--r--lib/thread.c283
-rw-r--r--lib/thread.h22
3 files changed, 242 insertions, 105 deletions
diff --git a/lib/ChangeLog b/lib/ChangeLog
index d8328499..3bd151bf 100644
--- a/lib/ChangeLog
+++ b/lib/ChangeLog
@@ -1,3 +1,45 @@
+2005-04-22 Paul Jakma <paul.jakma@sun.com>
+
+ * thread.h: Add background thread type and thread_add_background
+ macro and accompanying funcname_... function.
+ export thread_should_yield, background threads can use it.
+ Lower thread yield time to 10ms, 100ms is noticeable lag and
+ a thread would only be /starting/ to finish sometime afterward.
+ * thread.c: (general) Add background thread type and schedule
+ nearly all thread types through the ready list for fairness.
+ (timeval_adjust) static qualifier missing
+ (vty_out_cpu_thread_history) add support for printout of
+ background threads
+ (show_thread_cpu) ditto.
+ (thread_master_debug) add debug of background list
+ (thread_master_create) fixup long line
+ (thread_add_unuse) add asserts for required state.
+ (thread_master_free) free background thread list
+ (funcname_thread_add_timer_timeval) make generic, able to
+ support arbitrary timer-like thread types.
+ (funcname_thread_add_timer) pass thread type to .._add_timer_timeval
+ (funcname_thread_add_timer_msec) ditto
+ (funcname_thread_add_background) Add a background thread, with an
+ optional millisecond delay factor, using .._add_timer_timeval.
+ (thread_cancel) Add background thread type.
+ Move the thread_list_delete common to all cases to bottom of
+ function, after the switch statement..
+ (thread_cancel_event) indent
+ (thread_timer_wait) Static qualifier, and make it able to cope
+ with arbitrary timer-like thread lists, so its of use to
+ background threads too.
+ (thread_process_fd) static qualifier. Again, make it take a list
+ reference rather than thread_master. Fix indentation.
+ (thread_timer_process) Check for ready timer-like threads in the
+ given list and move them on to the ready list - code originally
+ embedded in thread_fetch.
+ (thread_fetch) Schedule all threads, other than events, through
+ the ready list, to ensure fairness. Timer readying code moved to
+ thread_timer_process so it can be reused for background threads.
+ Remove the unneeded quagga_sigevent_process, as pointed out by
+ John Lin <john.ch.lin@gmail.com>.
+ (thread_should_yield) make this available.
+
2005-04-16 Andrew J. Schorr <ajschorr@alumni.princeton.edu>
* thread.h (thread_consumed_time): Declare new function to calculate
diff --git a/lib/thread.c b/lib/thread.c
index d1c925c4..33331242 100644
--- a/lib/thread.c
+++ b/lib/thread.c
@@ -35,7 +35,7 @@ static struct hash *cpu_record = NULL;
/* Struct timeval's tv_usec one second value. */
#define TIMER_SECOND_MICRO 1000000L
-struct timeval
+static struct timeval
timeval_adjust (struct timeval a)
{
while (a.tv_usec >= TIMER_SECOND_MICRO)
@@ -87,7 +87,7 @@ timeval_elapsed (struct timeval a, struct timeval b)
+ (a.tv_usec - b.tv_usec));
}
-static unsigned int
+static unsigned int
cpu_record_hash_key (struct cpu_thread_history *a)
{
return (unsigned int) a->func;
@@ -114,7 +114,7 @@ static inline void
vty_out_cpu_thread_history(struct vty* vty,
struct cpu_thread_history *a)
{
- vty_out(vty, " %7ld.%03ld %9d %8ld %10ld %c%c%c%c%c %s%s",
+ vty_out(vty, " %7ld.%03ld %9d %8ld %10ld %c%c%c%c%c%c %s%s",
a->total/1000, a->total%1000, a->total_calls,
a->total/a->total_calls, a->max,
a->types & (1 << THREAD_READ) ? 'R':' ',
@@ -122,6 +122,7 @@ vty_out_cpu_thread_history(struct vty* vty,
a->types & (1 << THREAD_TIMER) ? 'T':' ',
a->types & (1 << THREAD_EVENT) ? 'E':' ',
a->types & (1 << THREAD_EXECUTE) ? 'X':' ',
+ a->types & (1 << THREAD_BACKGROUND) ? 'B' : ' ',
a->funcname, VTY_NEWLINE);
}
@@ -133,8 +134,7 @@ cpu_record_hash_print(struct hash_backet *bucket,
struct vty *vty = args[1];
unsigned char *filter = args[2];
struct cpu_thread_history *a = bucket->data;
-
-
+
a = bucket->data;
if ( !(a->types & *filter) )
return;
@@ -172,7 +172,7 @@ DEFUN(show_thread_cpu,
SHOW_STR
"Thread information\n"
"Thread CPU usage\n"
- "Display filter (rwtex)\n")
+ "Display filter (rwtexb)\n")
{
int i = 0;
unsigned char filter = 0xff;
@@ -204,6 +204,10 @@ DEFUN(show_thread_cpu,
case 'X':
filter |= (1 << THREAD_EXECUTE);
break;
+ case 'b':
+ case 'B':
+ filter |= (1 << THREAD_BACKGROUND);
+ break;
default:
break;
}
@@ -211,7 +215,8 @@ DEFUN(show_thread_cpu,
}
if (filter == 0)
{
- vty_out(vty, "Invalid filter \"%s\" specified, must contain at least one of 'RWTEX'%s",
+ vty_out(vty, "Invalid filter \"%s\" specified,"
+ " must contain at least one of 'RWTEXB'%s",
argv[0], VTY_NEWLINE);
return CMD_WARNING;
}
@@ -244,6 +249,8 @@ thread_master_debug (struct thread_master *m)
thread_list_debug (&m->event);
printf ("unuselist : ");
thread_list_debug (&m->unuse);
+ printf ("bgndlist : ");
+ thread_list_debug (&m->background);
printf ("total alloc: [%ld]\n", m->alloc);
printf ("-----------\n");
}
@@ -253,9 +260,9 @@ struct thread_master *
thread_master_create ()
{
if (cpu_record == NULL)
- {
- cpu_record = hash_create_size( 1011, cpu_record_hash_key, cpu_record_hash_cmp);
- }
+ cpu_record = hash_create_size (1011, cpu_record_hash_key,
+ cpu_record_hash_cmp);
+
return (struct thread_master *) XCALLOC (MTYPE_THREAD_MASTER,
sizeof (struct thread_master));
}
@@ -311,7 +318,7 @@ thread_list_delete (struct thread_list *list, struct thread *thread)
static void
thread_add_unuse (struct thread_master *m, struct thread *thread)
{
- assert (m != NULL);
+ assert (m != NULL && thread != NULL);
assert (thread->next == NULL);
assert (thread->prev == NULL);
assert (thread->type == THREAD_UNUSED);
@@ -346,7 +353,8 @@ thread_master_free (struct thread_master *m)
thread_list_free (m, &m->event);
thread_list_free (m, &m->ready);
thread_list_free (m, &m->unuse);
-
+ thread_list_free (m, &m->background);
+
XFREE (MTYPE_THREAD_MASTER, m);
}
@@ -485,19 +493,36 @@ funcname_thread_add_write (struct thread_master *m,
static struct thread *
funcname_thread_add_timer_timeval (struct thread_master *m,
int (*func) (struct thread *),
+ int type,
void *arg,
struct timeval *time_relative,
const char* funcname)
{
struct thread *thread;
struct timeval timer_now;
+ struct thread_list *list;
#ifndef TIMER_NO_SORT
struct thread *tt;
#endif /* TIMER_NO_SORT */
assert (m != NULL);
- thread = thread_get (m, THREAD_TIMER, func, arg, funcname);
+ assert (type == THREAD_TIMER || THREAD_BACKGROUND);
+ assert (time_relative);
+
+ switch (type)
+ {
+ case THREAD_TIMER:
+ list = &m->timer;
+ break;
+ case THREAD_BACKGROUND:
+ list = &m->background;
+ break;
+ default:
+ return NULL;
+ }
+
+ thread = thread_get (m, type, func, arg, funcname);
/* Do we need jitter here? */
gettimeofday (&timer_now, NULL);
@@ -508,16 +533,16 @@ funcname_thread_add_timer_timeval (struct thread_master *m,
/* Sort by timeval. */
#ifdef TIMER_NO_SORT
- thread_list_add (&m->timer, thread);
+ thread_list_add (list, thread);
#else
- for (tt = m->timer.head; tt; tt = tt->next)
+ for (tt = list->head; tt; tt = tt->next)
if (timeval_cmp (thread->u.sands, tt->u.sands) <= 0)
break;
if (tt)
- thread_list_add_before (&m->timer, tt, thread);
+ thread_list_add_before (list, tt, thread);
else
- thread_list_add (&m->timer, thread);
+ thread_list_add (list, thread);
#endif /* TIMER_NO_SORT */
return thread;
@@ -537,7 +562,8 @@ funcname_thread_add_timer (struct thread_master *m,
trel.tv_sec = timer;
trel.tv_usec = 0;
- return funcname_thread_add_timer_timeval (m, func, arg, &trel, funcname);
+ return funcname_thread_add_timer_timeval (m, func, THREAD_TIMER, arg,
+ &trel, funcname);
}
/* Add timer event thread with "millisecond" resolution */
@@ -553,7 +579,34 @@ funcname_thread_add_timer_msec (struct thread_master *m,
trel.tv_sec = timer / 1000;
trel.tv_usec = 1000*(timer % 1000);
- return funcname_thread_add_timer_timeval (m, func, arg, &trel, funcname);
+ return funcname_thread_add_timer_timeval (m, func, THREAD_TIMER,
+ arg, &trel, funcname);
+}
+
+/* Add a background thread, with an optional millisec delay */
+struct thread *
+funcname_thread_add_background (struct thread_master *m,
+ int (*func) (struct thread *),
+ void *arg, long delay,
+ const char *funcname)
+{
+ struct timeval trel;
+
+ assert (m != NULL);
+
+ if (delay)
+ {
+ trel.tv_sec = delay / 1000;
+ trel.tv_usec = 1000*(delay % 1000);
+ }
+ else
+ {
+ trel.tv_sec = 0;
+ trel.tv_usec = 0;
+ }
+
+ return funcname_thread_add_timer_timeval (m, func, THREAD_BACKGROUND,
+ arg, &trel, funcname);
}
/* Add simple event thread. */
@@ -576,30 +629,36 @@ funcname_thread_add_event (struct thread_master *m,
void
thread_cancel (struct thread *thread)
{
+ struct thread_list *list;
+
switch (thread->type)
{
case THREAD_READ:
assert (FD_ISSET (thread->u.fd, &thread->master->readfd));
FD_CLR (thread->u.fd, &thread->master->readfd);
- thread_list_delete (&thread->master->read, thread);
+ list = &thread->master->read;
break;
case THREAD_WRITE:
assert (FD_ISSET (thread->u.fd, &thread->master->writefd));
FD_CLR (thread->u.fd, &thread->master->writefd);
- thread_list_delete (&thread->master->write, thread);
+ list = &thread->master->write;
break;
case THREAD_TIMER:
- thread_list_delete (&thread->master->timer, thread);
+ list = &thread->master->timer;
break;
case THREAD_EVENT:
- thread_list_delete (&thread->master->event, thread);
+ list = &thread->master->event;
break;
case THREAD_READY:
- thread_list_delete (&thread->master->ready, thread);
+ list = &thread->master->ready;
break;
+ case THREAD_BACKGROUND:
+ list = &thread->master->background;
default:
+ return;
break;
}
+ thread_list_delete (list, thread);
thread->type = THREAD_UNUSED;
thread_add_unuse (thread->master, thread);
}
@@ -619,17 +678,17 @@ thread_cancel_event (struct thread_master *m, void *arg)
thread = t->next;
if (t->arg == arg)
- {
- thread_list_delete (&m->event, t);
- t->type = THREAD_UNUSED;
- thread_add_unuse (m, t);
- }
+ {
+ thread_list_delete (&m->event, t);
+ t->type = THREAD_UNUSED;
+ thread_add_unuse (m, t);
+ }
}
}
#ifdef TIMER_NO_SORT
-struct timeval *
-thread_timer_wait (struct thread_master *m, struct timeval *timer_val)
+static struct timeval *
+thread_timer_wait (struct thread_list *tlist, struct timeval *timer_val)
{
struct timeval timer_now;
struct timeval timer_min;
@@ -638,7 +697,7 @@ thread_timer_wait (struct thread_master *m, struct timeval *timer_val)
gettimeofday (&timer_now, NULL);
timer_wait = NULL;
- for (thread = m->timer.head; thread; thread = thread->next)
+ for (thread = tlist->head; thread; thread = thread->next)
{
if (! timer_wait)
timer_wait = &thread->u.sands;
@@ -646,7 +705,7 @@ thread_timer_wait (struct thread_master *m, struct timeval *timer_val)
timer_wait = &thread->u.sands;
}
- if (m->timer.head)
+ if (tlist->head)
{
timer_min = *timer_wait;
timer_min = timeval_subtract (timer_min, timer_now);
@@ -668,16 +727,16 @@ thread_timer_wait (struct thread_master *m, struct timeval *timer_val)
return NULL;
}
#else /* ! TIMER_NO_SORT */
-struct timeval *
-thread_timer_wait (struct thread_master *m, struct timeval *timer_val)
+static struct timeval *
+thread_timer_wait (struct thread_list *tlist, struct timeval *timer_val)
{
struct timeval timer_now;
struct timeval timer_min;
- if (m->timer.head)
+ if (tlist->head)
{
gettimeofday (&timer_now, NULL);
- timer_min = m->timer.head->u.sands;
+ timer_min = tlist->head->u.sands;
timer_min = timeval_subtract (timer_min, timer_now);
if (timer_min.tv_sec < 0)
{
@@ -701,105 +760,140 @@ thread_run (struct thread_master *m, struct thread *thread,
return fetch;
}
-int
-thread_process_fd (struct thread_master *m, struct thread_list *list,
- fd_set *fdset, fd_set *mfdset)
+static int
+thread_process_fd (struct thread_list *list, fd_set *fdset, fd_set *mfdset)
{
struct thread *thread;
struct thread *next;
int ready = 0;
-
+
+ assert (list);
+
for (thread = list->head; thread; thread = next)
{
next = thread->next;
if (FD_ISSET (THREAD_FD (thread), fdset))
- {
- assert (FD_ISSET (THREAD_FD (thread), mfdset));
- FD_CLR(THREAD_FD (thread), mfdset);
- thread_list_delete (list, thread);
- thread_list_add (&m->ready, thread);
- thread->type = THREAD_READY;
- ready++;
- }
+ {
+ assert (FD_ISSET (THREAD_FD (thread), mfdset));
+ FD_CLR(THREAD_FD (thread), mfdset);
+ thread_list_delete (list, thread);
+ thread_list_add (&thread->master->ready, thread);
+ thread->type = THREAD_READY;
+ ready++;
+ }
}
return ready;
}
+/* fetch next timer-like thread thread from the list and return it */
+static unsigned int
+thread_timer_process (struct thread_list *list, struct timeval *timenow)
+{
+ struct thread *thread;
+ unsigned int ready = 0;
+
+ assert (list && timenow);
+
+ for (thread = list->head; thread; thread = thread->next)
+ if (timeval_cmp (*timenow, thread->u.sands) >= 0)
+ {
+ thread_list_delete (list, thread);
+ assert (thread->next == thread->prev && thread->next == NULL);
+ thread->next = thread->prev = NULL;
+ thread->type = THREAD_READY;
+ thread_list_add (&thread->master->ready, thread);
+ ready++;
+ }
+ return ready;
+}
+
/* Fetch next ready thread. */
struct thread *
thread_fetch (struct thread_master *m, struct thread *fetch)
{
- int num;
- int ready;
struct thread *thread;
fd_set readfd;
fd_set writefd;
fd_set exceptfd;
struct timeval timer_now;
struct timeval timer_val;
+ struct timeval timer_val_bg;
struct timeval *timer_wait;
- struct timeval timer_nowait;
-
- timer_nowait.tv_sec = 0;
- timer_nowait.tv_usec = 0;
+ struct timeval *timer_wait_bg;
while (1)
{
+ int num = 0;
+ int ready = m->ready.count;
+
/* Signals are highest priority */
quagga_sigevent_process ();
/* Normal event are the next highest priority. */
if ((thread = thread_trim_head (&m->event)) != NULL)
return thread_run (m, thread, fetch);
-
+
/* Execute timer. */
gettimeofday (&timer_now, NULL);
-
- for (thread = m->timer.head; thread; thread = thread->next)
- if (timeval_cmp (timer_now, thread->u.sands) >= 0)
- {
- thread_list_delete (&m->timer, thread);
- return thread_run (m, thread, fetch);
- }
-
- /* If there are any ready threads, process top of them. */
+
+ /* Timer threads */
+ ready += thread_timer_process (&m->timer, &timer_now);
+
+ /* If there are any ready threads from previous scheduler runs,
+ * process top of them.
+ */
if ((thread = thread_trim_head (&m->ready)) != NULL)
return thread_run (m, thread, fetch);
-
+
/* Structure copy. */
readfd = m->readfd;
writefd = m->writefd;
exceptfd = m->exceptfd;
-
- /* Calculate select wait timer. */
- timer_wait = thread_timer_wait (m, &timer_val);
-
+
+ /* Calculate select wait timer if nothing else to do */
+ if (ready == 0)
+ {
+ timer_wait = thread_timer_wait (&m->timer, &timer_val);
+ timer_wait_bg = thread_timer_wait (&m->background, &timer_val_bg);
+
+ if (timer_wait && timer_wait_bg &&
+ (timeval_cmp (*timer_wait, *timer_wait_bg) > 0))
+ timer_wait = timer_wait_bg;
+ else if (!timer_wait && timer_wait_bg)
+ timer_wait = timer_wait_bg;
+ }
+ else
+ {
+ timer_val.tv_sec = timer_val.tv_usec = 0;
+ timer_wait = &timer_val;
+ }
+
num = select (FD_SETSIZE, &readfd, &writefd, &exceptfd, timer_wait);
-
- if (num == 0)
- continue;
-
+
+ /* Signals should get quick treatment */
if (num < 0)
{
if (errno == EINTR)
- {
- /* signal received */
- quagga_sigevent_process ();
- continue;
- }
-
+ continue; /* signal received - process it */
zlog_warn ("select() error: %s", safe_strerror (errno));
return NULL;
}
-
- /* Normal priority read thead. */
- ready = thread_process_fd (m, &m->read, &readfd, &m->readfd);
-
- /* Write thead. */
- ready = thread_process_fd (m, &m->write, &writefd, &m->writefd);
-
- if ((thread = thread_trim_head (&m->ready)) != NULL)
+
+ /* Got IO, process it */
+ if (num > 0)
+ {
+ /* Normal priority read thead. */
+ ready += thread_process_fd (&m->read, &readfd, &m->readfd);
+ /* Write thead. */
+ ready += thread_process_fd (&m->write, &writefd, &m->writefd);
+ }
+
+ /* Background timer/events, lowest priority */
+ ready += thread_timer_process (&m->background, &timer_now);
+
+ /* if any threads were made ready above.. */
+ if ((ready > 0) && (thread = thread_trim_head (&m->ready)) != NULL)
return thread_run (m, thread, fetch);
}
}
@@ -821,10 +915,6 @@ thread_consumed_time (RUSAGE_T *now, RUSAGE_T *start)
return thread_time;
}
-#if 0
-
-/* This function is not currently used: threads never yield! */
-
/* We should aim to yield after THREAD_YIELD_TIME_SLOT
milliseconds. */
int
@@ -833,15 +923,10 @@ thread_should_yield (struct thread *thread)
RUSAGE_T ru;
GETRUSAGE (&ru);
-
- if (thread_consumed_time (&ru, &thread->ru) > THREAD_YIELD_TIME_SLOT)
- return 1;
- else
- return 0;
+
+ return (thread_consumed_time (&ru, &thread->ru) > THREAD_YIELD_TIME_SLOT);
}
-#endif
-
/* We check thread consumed time. If the system has getrusage, we'll
use that to get indepth stats on the performance of the thread. If
not - we'll use gettimeofday for some guestimation. */
diff --git a/lib/thread.h b/lib/thread.h
index 4008ba72..8f683c8b 100644
--- a/lib/thread.h
+++ b/lib/thread.h
@@ -47,6 +47,7 @@ struct thread_master
struct thread_list event;
struct thread_list ready;
struct thread_list unuse;
+ struct thread_list background;
fd_set readfd;
fd_set writefd;
fd_set exceptfd;
@@ -57,8 +58,8 @@ struct thread_master
struct thread
{
unsigned char type; /* thread type */
- unsigned char add_type; /* thread type */
- struct thread *next; /* next pointer of the thread */
+ unsigned add_type; /* thread type */
+ struct thread *next; /* next pointer of the thread */
struct thread *prev; /* previous pointer of the thread */
struct thread_master *master; /* pointer to the struct thread_master. */
int (*func) (struct thread *); /* event function */
@@ -72,7 +73,7 @@ struct thread
char* funcname;
};
-struct cpu_thread_history {
+struct cpu_thread_history {
int (*func)(struct thread *);
const char *funcname;
unsigned int total_calls;
@@ -86,11 +87,12 @@ struct cpu_thread_history {
#define THREAD_TIMER 2
#define THREAD_EVENT 3
#define THREAD_READY 4
-#define THREAD_UNUSED 5
-#define THREAD_EXECUTE 6
+#define THREAD_BACKGROUND 5
+#define THREAD_UNUSED 6
+#define THREAD_EXECUTE 7
/* Thread yield time. */
-#define THREAD_YIELD_TIME_SLOT 100 * 1000L /* 100ms */
+#define THREAD_YIELD_TIME_SLOT 10 * 1000L /* 100ms */
/* Macros. */
#define THREAD_ARG(X) ((X)->arg)
@@ -134,6 +136,7 @@ struct cpu_thread_history {
#define thread_add_timer_msec(m,f,a,v) funcname_thread_add_timer_msec(m,f,a,v,#f)
#define thread_add_event(m,f,a,v) funcname_thread_add_event(m,f,a,v,#f)
#define thread_execute(m,f,a,v) funcname_thread_execute(m,f,a,v,#f)
+#define thread_add_background(m,f,a,v) funcname_thread_add_background(m,f,a,v,#f)
/* Prototypes. */
struct thread_master *thread_master_create ();
@@ -147,6 +150,11 @@ struct thread *funcname_thread_add_timer_msec (struct thread_master *,
int (*)(struct thread *), void *, long, const char*);
struct thread *funcname_thread_add_event (struct thread_master *,
int (*)(struct thread *), void *, int, const char*);
+struct thread *funcname_thread_add_background (struct thread_master *,
+ int (*)(struct thread *),
+ void *,
+ long, const char*);
+
void thread_cancel (struct thread *);
void thread_cancel_event (struct thread_master *, void *);
@@ -155,8 +163,10 @@ struct thread *funcname_thread_execute (struct thread_master *,
int (*)(struct thread *), void *, int, const char *);
void thread_call (struct thread *);
unsigned long thread_timer_remain_second (struct thread *);
+int thread_should_yield (struct thread *);
extern struct cmd_element show_thread_cpu_cmd;
+extern struct cmd_element show_thread_work_queues_cmd;
extern unsigned long thread_consumed_time(RUSAGE_T *after, RUSAGE_T *before);
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-27 23:49:54 +0000