gstreamer/gst/schedulers/gthread-cothreads.h
Benjamin Otte b7077cab18 make gst_thread_get_current() work with threaded cothreads
Original commit message from CVS:
make gst_thread_get_current() work with threaded cothreads
2003-04-21 18:37:13 +00:00

223 lines
7.2 KiB
C

/* GStreamer
* Copyright (C) 2003 Benjamin Otte <in7y118@public.uni-hamburg.de>
*
* gthread-cothreads.c: cothreads implemented via GThread for compatibility
* They're probably slooooooow
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include <glib.h>
#include <gst/gstthread.h>
/* the name of this cothreads */
#define COTHREADS_NAME "gthread"
#define COTHREADS_NAME_CAPITAL "GThread"
/**
* Theory of operation:
* Instead of using cothreads, GThreads and 1 mutex are used.
* Every thread may only run if it holds the mutex. Otherwise it holds its own
* cond which has to be signaled to wakeit up.
*/
/* define "cothread", "cothread_context" and "cothread_func" */
typedef void (*cothread_func) (int, char **);
typedef struct _cothread cothread;
typedef struct _cothread_context cothread_context;
struct _cothread_context {
GSList * cothreads; /* contains all threads but main */
cothread * main;
cothread * current;
GMutex * mutex;
GstThread * gst_thread; /* the GstThread we're running from */
};
struct _cothread {
GThread * thread;
GCond * cond;
cothread_func run;
int argc;
char ** argv;
cothread * creator;
gboolean die;
cothread_context * context;
};
/* define functions
* Functions starting with "do_" are used by the scheduler.
*/
static void do_cothreads_init (void *unused);
static cothread_context *do_cothread_context_init (void);
static void do_cothread_context_destroy (cothread_context *context);
static cothread * cothread_create (cothread_context *context,
cothread_func func,
int argc,
char **argv);
#define do_cothread_create(new_cothread, context, func, argc, argv) \
G_STMT_START{ \
new_cothread = cothread_create ((context), (func), argc, (char**) (argv)); \
}G_STMT_END
static void do_cothread_switch (cothread *to);
static void do_cothread_setfunc (cothread *thread,
cothread_context *context,
cothread_func func,
int argc,
char **argv);
static void do_cothread_destroy (cothread *thread);
#define do_cothread_lock(cothread) /* FIXME */
#define do_cothread_unlock(cothread) /* FIXME */
#define do_cothread_get_current(context) ((context)->current)
#define do_cothread_get_main(context) ((context)->main)
static void
do_cothreads_init (void *unused)
{
if (!g_thread_supported ()) g_thread_init (NULL);
}
static cothread_context *
do_cothread_context_init (void)
{
cothread_context *ret = g_new0 (cothread_context, 1);
ret->main = g_new0 (cothread, 1);
ret->main->thread = g_thread_self ();
ret->main->cond = g_cond_new ();
ret->main->die = FALSE;
ret->main->context = ret;
ret->mutex = g_mutex_new ();
ret->cothreads = NULL;
ret->current = ret->main;
ret->gst_thread = gst_thread_get_current();
g_mutex_lock (ret->mutex);
return ret;
}
static void
do_cothread_context_destroy (cothread_context *context)
{
g_assert (g_thread_self() == context->main->thread);
while (context->cothreads) {
do_cothread_destroy ((cothread *) context->cothreads->data);
}
g_mutex_unlock (context->mutex);
g_mutex_free (context->mutex);
g_free (context);
}
static void
die (cothread *to_die) {
g_cond_free (to_die->cond);
to_die->context->cothreads = g_slist_remove (to_die->context->cothreads, to_die);
g_free (to_die);
g_thread_exit (to_die);
/* don't unlock the mutex here, the thread waiting for us to die is gonna take it */
}
static gpointer
run_new_thread (gpointer data)
{
cothread *self = (cothread *) data;
g_mutex_lock (self->context->mutex);
g_private_set (gst_thread_current, self->context->gst_thread);
g_cond_signal (self->creator->cond);
g_cond_wait (self->cond, self->context->mutex);
if (self->die)
die (self);
while (TRUE) {
self->run (self->argc, self->argv);
/* compatibility */
do_cothread_switch (do_cothread_get_main (self->context));
}
g_assert_not_reached ();
return NULL;
}
static cothread *
cothread_create (cothread_context *context, cothread_func func, int argc, char **argv)
{
cothread *ret;
if ((ret = g_new (cothread, 1)) == NULL) {
goto out1;
}
ret->cond = g_cond_new ();
ret->run = func;
ret->argc = argc;
ret->argv = argv;
ret->creator = do_cothread_get_current (context);
ret->die = FALSE;
ret->context = context;
context->cothreads = g_slist_prepend (context->cothreads, ret);
ret->thread = g_thread_create (run_new_thread, ret, TRUE, NULL);
if (ret->thread == NULL) goto out2;
g_cond_wait (do_cothread_get_current (context)->cond, context->mutex);
return ret;
out2:
context->cothreads = g_slist_remove (context->cothreads, ret);
g_free (ret);
out1:
return NULL;
}
static void do_cothread_switch (cothread *to)
{
cothread *self = do_cothread_get_current(to->context);
if (self == to) {
g_warning ("trying to switch to the same cothread, not allowed");
} else {
self->context->current = to;
g_cond_signal (to->cond);
g_cond_wait (self->cond, self->context->mutex);
if (self->die)
die (self);
}
}
static void
do_cothread_setfunc (cothread *thread, cothread_context *context,
cothread_func func, int argc, char **argv)
{
thread->run = func;
thread->argc = argc;
thread->argv = argv;
}
static void
do_cothread_destroy (cothread *thread)
{
GThread *join;
cothread_context *context;
g_return_if_fail (thread != thread->context->main);
g_return_if_fail (thread != thread->context->current);
thread->die = TRUE;
join = thread->thread;
context = thread->context;
g_cond_signal (thread->cond);
g_mutex_unlock (thread->context->mutex);
g_thread_join (join);
/* the mutex was locked by the thread that we joined, no need to lock again */
}
#define do_cothread_lock(cothread) /* FIXME */
#define do_cothread_unlock(cothread) /* FIXME */
#define do_cothread_get_current(context) ((context)->current)
#define do_cothread_get_main(context) ((context)->main)