From: "Julian Graham" <joolean@gmail.com>
To: "Neil Jerram" <neil@ossau.uklinux.net>
Cc: "Ludovic Courtès" <ludo@gnu.org>, guile-devel@gnu.org
Subject: Re: srfi-18 requirements
Date: Sat, 19 Jan 2008 15:10:48 -0500 [thread overview]
Message-ID: <2bc5f8210801191210h72903a37q1c8f60e3638bfdba@mail.gmail.com> (raw)
In-Reply-To: <874pddcjdf.fsf@ossau.uklinux.net>
Hi Neil,
> OK. While looking through the docs, though, and playing with possible
> solutions, I noted a couple of other pitfalls (which the current code
> also appears to suffer from).
>
> 1. pthread_cond_wait() returning does not necessarily mean that the
> cond var was signalled. Apparently pthread_cond_wait() can return
> early because of an interrupt.
Yes, the pthreads docs refer to this as a "spurious wakeup."
> 2. If two threads are using pthread_cond_wait and pthread_cond_signal
> to communicate, and using the cond_var itself as a state
> indication, they have to be certain that the pthread_cond_wait
> starts before the pthread_cond_signal, otherwise it won't work.
Right -- holding the right mutexes when you signal / broadcast is
pretty important.
> The practical impact of these is that one shouldn't use the cond_var
> itself as an indication of "reached so-and-so state". Instead, one
> can represent the state using an explicit variable, which is protected
> by the associated mutex, and then interpret the cond_var as indicating
> simply that the variable _might_ have changed.
>
> In our case, I think the state variable could be
> scm_i_thread_go_to_sleep, protected by thread_admin_mutex. Here's a
> possible solution based on this, but it isn't yet complete, because it
> doesn't explain how num_guile_threads_awake is calculated. (And I
> have to go to bed!)
I've come up with something similar that seems to work decently and
seems a bit simple. See what you think (apologies for the
formatting):
static scm_i_pthread_cond_t wake_up_cond;
static scm_i_pthread_mutex_t wake_up_mutex;
static int wake_up_flag = 0;
int scm_i_thread_go_to_sleep;
void
scm_i_thread_put_to_sleep ()
{
if (threads_initialized_p)
{
scm_i_thread *t;
scm_leave_guile ();
scm_i_pthread_mutex_lock (&thread_admin_mutex);
wake_up_flag = 0;
scm_i_thread_go_to_sleep = 1;
for (t = all_threads; t; t = t->next_thread)
{
scm_i_pthread_mutex_lock (&t->heap_mutex);
}
scm_i_thread_go_to_sleep = 0;
}
}
void
scm_i_thread_wake_up ()
{
if (threads_initialized_p)
{
scm_i_thread *t;
scm_i_pthread_mutex_lock (&wake_up_mutex);
wake_up_flag = 1;
scm_i_pthread_cond_broadcast (&wake_up_cond);
scm_i_pthread_mutex_unlock (&wake_up_mutex);
for (t = all_threads; t; t = t->next_thread)
{
scm_i_pthread_mutex_unlock (&t->heap_mutex);
}
scm_i_pthread_mutex_unlock (&thread_admin_mutex);
scm_enter_guile ((scm_t_guile_ticket) SCM_I_CURRENT_THREAD);
}
}
void
scm_i_thread_sleep_for_gc ()
{
scm_i_thread *t = suspend ();
scm_i_pthread_cleanup_push ((void (*)(void *)) scm_i_pthread_mutex_unlock,
&wake_up_mutex);
scm_i_pthread_mutex_lock (&wake_up_mutex);
scm_i_pthread_mutex_unlock (&t->heap_mutex);
do
{
scm_i_pthread_cond_wait (&wake_up_cond, &wake_up_mutex);
}
while (!wake_up_flag);
scm_i_pthread_mutex_lock (&t->heap_mutex);
scm_i_pthread_mutex_unlock (&wake_up_mutex);
scm_i_pthread_cleanup_pop (0);
resume (t);
}
> > So why hasn't this been reported before? I'm not really sure, except
> > that based on my logs, a GC involving more than two threads (one
> > thread stays awake, of course, to manage the collection) is kind of
> > rare. It doesn't even necessarily happen during an entire run of my
> > SRFI-18 test suite, which lasts for several seconds and is fairly
> > multi-threaded.
>
> Not sure what you mean here. Surely if there are >2 threads, they all
> have to go to sleep before GC can proceed?
Of course -- all I meant by this was that in the existing thread tests
(and in much of the SRFI-18 test code I wrote) the lifespans of
threads besides the main thread (and the signal delivery thread) are
usually short enough that they don't end up participating in this
whole co-op GC process. Maybe we need some test code for
longer-running, guile-mode threads. (Perhaps developers with
multi-threaded Guile application development under their belts would
care to chime in here?)
> > It *is* possible, because a thread can enter and leave guile mode and
> > do a fair number of things without SCM_TICK getting called. I don't
> > know if that's significant or not.
>
> That may mean that we need some more SCM_TICK calls. What kind of
> processing was the thread doing?
I'm not totally sure -- I'll have to add some more logs and get back
to you. I think are definitely some places where an extra SCM_TICK
might do some good (in fat_cond_timedwait, e.g.).
Regards,
Julian
next prev parent reply other threads:[~2008-01-19 20:10 UTC|newest]
Thread overview: 75+ messages / expand[flat|nested] mbox.gz Atom feed top
2007-10-11 1:54 srfi-18 requirements Julian Graham
2007-10-12 8:42 ` Ludovic Courtès
2007-10-12 15:31 ` Julian Graham
2007-10-15 22:26 ` Julian Graham
2007-10-15 22:35 ` Stephen Compall
2007-10-15 22:47 ` Julian Graham
2007-10-29 14:37 ` Julian Graham
2007-11-26 18:11 ` Julian Graham
2007-11-27 9:14 ` Ludovic Courtès
2007-11-28 18:23 ` Ludovic Courtès
2007-11-28 18:55 ` Julian Graham
2007-12-01 5:08 ` Julian Graham
2007-12-01 10:21 ` Ludovic Courtès
2007-12-02 3:59 ` Julian Graham
2007-12-04 22:20 ` Neil Jerram
2007-12-04 22:29 ` Neil Jerram
2007-12-11 4:20 ` Julian Graham
2007-12-18 4:30 ` Julian Graham
2007-12-28 18:46 ` Ludovic Courtès
2007-12-28 19:08 ` Julian Graham
2007-12-28 22:35 ` Neil Jerram
2007-12-30 11:04 ` Neil Jerram
2007-12-30 20:38 ` Julian Graham
2008-01-01 19:09 ` Neil Jerram
2008-01-04 5:01 ` Julian Graham
2008-01-05 0:30 ` Neil Jerram
2008-01-06 21:41 ` Julian Graham
2008-01-08 23:11 ` Neil Jerram
2008-01-11 2:39 ` Julian Graham
2008-01-17 1:48 ` Neil Jerram
2008-01-19 20:10 ` Julian Graham [this message]
2008-01-23 22:46 ` Neil Jerram
2008-01-23 23:23 ` Julian Graham
2008-01-25 1:07 ` Neil Jerram
2008-01-25 1:38 ` Julian Graham
2008-01-28 2:06 ` Julian Graham
2008-02-03 0:30 ` Neil Jerram
2008-02-05 6:27 ` Julian Graham
2008-02-07 1:23 ` Neil Jerram
2008-02-07 3:06 ` Julian Graham
2008-02-07 23:26 ` Neil Jerram
2008-02-07 23:33 ` Julian Graham
2008-02-07 23:38 ` Neil Jerram
2008-02-08 0:04 ` Julian Graham
2008-02-11 5:14 ` Julian Graham
2008-02-19 22:48 ` Neil Jerram
2008-02-20 2:10 ` Julian Graham
2008-02-22 0:33 ` Neil Jerram
2008-02-22 4:14 ` Julian Graham
2008-02-24 9:41 ` Neil Jerram
2008-02-24 18:17 ` Julian Graham
2008-02-24 23:29 ` Neil Jerram
2008-03-01 19:56 ` Julian Graham
2008-03-08 16:34 ` Neil Jerram
2008-03-11 4:02 ` Julian Graham
2008-03-22 18:55 ` Julian Graham
2008-03-23 23:57 ` Neil Jerram
2008-03-24 22:03 ` Neil Jerram
2008-03-26 15:55 ` Julian Graham
2008-04-03 0:18 ` Neil Jerram
2008-04-03 19:07 ` Julian Graham
2008-04-09 21:29 ` Neil Jerram
2008-04-14 0:43 ` Julian Graham
2008-05-14 1:23 ` Julian Graham
2008-05-14 21:13 ` Neil Jerram
2008-05-14 23:11 ` Neil Jerram
2008-05-15 5:05 ` Julian Graham
2008-05-24 11:42 ` Neil Jerram
2008-05-24 13:55 ` Neil Jerram
2008-05-25 2:07 ` Julian Graham
2008-05-31 21:41 ` Ludovic Courtès
2008-06-02 4:48 ` Julian Graham
2008-06-21 5:03 ` Julian Graham
2008-06-30 17:51 ` Ludovic Courtès
2008-01-08 23:41 ` Neil Jerram
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
List information: https://www.gnu.org/software/guile/
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=2bc5f8210801191210h72903a37q1c8f60e3638bfdba@mail.gmail.com \
--to=joolean@gmail.com \
--cc=guile-devel@gnu.org \
--cc=ludo@gnu.org \
--cc=neil@ossau.uklinux.net \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).