mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-06-03 16:29:24 +00:00
Renamed the thread argument to cothread to avoid confusion
Original commit message from CVS: Renamed the thread argument to cothread to avoid confusion Documentation updates
This commit is contained in:
Wim Taymans
parent
840056aded
commit
8c5466095f
125
gst/cothreads.c
125
gst/cothreads.c
|
|
@ -49,7 +49,7 @@
|
|||
#define COTHREAD_MAXTHREADS 16
|
||||
#define COTHREAD_STACKSIZE (STACK_SIZE/COTHREAD_MAXTHREADS)
|
||||
|
||||
static void cothread_destroy (cothread_state *thread);
|
||||
static void cothread_destroy (cothread_state *cothread);
|
||||
|
||||
struct _cothread_context
|
||||
{
|
||||
|
|
@ -308,21 +308,21 @@ cothread_create (cothread_context *ctx)
|
|||
|
||||
/**
|
||||
* cothread_free:
|
||||
* @thread: the cothread state
|
||||
* @cothread: the cothread state
|
||||
*
|
||||
* Free the given cothread state
|
||||
*/
|
||||
void
|
||||
cothread_free (cothread_state *thread)
|
||||
cothread_free (cothread_state *cothread)
|
||||
{
|
||||
g_return_if_fail (thread != NULL);
|
||||
g_return_if_fail (cothread != NULL);
|
||||
|
||||
GST_INFO (GST_CAT_COTHREADS, "flag cothread %d for destruction",
|
||||
thread->cothreadnum);
|
||||
cothread->cothreadnum);
|
||||
|
||||
/* we simply flag the cothread for destruction here */
|
||||
if (thread)
|
||||
thread->flags |= COTHREAD_DESTROYED;
|
||||
if (cothread)
|
||||
cothread->flags |= COTHREAD_DESTROYED;
|
||||
else
|
||||
g_warning ("somebody set up us the bomb");
|
||||
}
|
||||
|
|
@ -365,7 +365,7 @@ cothread_destroy (cothread_state *cothread)
|
|||
|
||||
/**
|
||||
* cothread_setfunc:
|
||||
* @thread: the cothread state
|
||||
* @cothread: the cothread state
|
||||
* @func: the function to call
|
||||
* @argc: argument count for the cothread function
|
||||
* @argv: arguments for the cothread function
|
||||
|
|
@ -373,23 +373,23 @@ cothread_destroy (cothread_state *cothread)
|
|||
* Set the cothread function
|
||||
*/
|
||||
void
|
||||
cothread_setfunc (cothread_state * thread, cothread_func func, int argc, char **argv)
|
||||
cothread_setfunc (cothread_state* cothread, cothread_func func, int argc, char **argv)
|
||||
{
|
||||
thread->func = func;
|
||||
thread->argc = argc;
|
||||
thread->argv = argv;
|
||||
cothread->func = func;
|
||||
cothread->argc = argc;
|
||||
cothread->argv = argv;
|
||||
}
|
||||
|
||||
/**
|
||||
* cothread_stop:
|
||||
* @thread: the cothread to stop
|
||||
* @cothread: the cothread to stop
|
||||
*
|
||||
* Stop the cothread and reset the stack and program counter.
|
||||
*/
|
||||
void
|
||||
cothread_stop (cothread_state * thread)
|
||||
cothread_stop (cothread_state* cothread)
|
||||
{
|
||||
thread->flags &= ~COTHREAD_STARTED;
|
||||
cothread->flags &= ~COTHREAD_STARTED;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -400,8 +400,8 @@ cothread_stop (cothread_state * thread)
|
|||
*
|
||||
* Returns: the #cothread_state of the main (0th) cothread.
|
||||
*/
|
||||
cothread_state *
|
||||
cothread_main (cothread_context * ctx)
|
||||
cothread_state*
|
||||
cothread_main (cothread_context* ctx)
|
||||
{
|
||||
g_assert (ctx->thread == g_thread_self());
|
||||
|
||||
|
|
@ -417,7 +417,7 @@ cothread_main (cothread_context * ctx)
|
|||
*
|
||||
* Returns: the #cothread_state of the main (0th) thread in the current GThread
|
||||
*/
|
||||
cothread_state *
|
||||
cothread_state*
|
||||
cothread_current_main (void)
|
||||
{
|
||||
cothread_context *ctx = cothread_get_current_context();
|
||||
|
|
@ -432,7 +432,7 @@ cothread_current_main (void)
|
|||
*
|
||||
* Returns: the #cothread_state of the current cothread
|
||||
*/
|
||||
cothread_state *
|
||||
cothread_state*
|
||||
cothread_current (void)
|
||||
{
|
||||
cothread_context *ctx = cothread_get_current_context();
|
||||
|
|
@ -444,24 +444,24 @@ static void
|
|||
cothread_stub (void)
|
||||
{
|
||||
cothread_context *ctx = cothread_get_current_context();
|
||||
cothread_state *thread = ctx->cothreads[ctx->current];
|
||||
cothread_state *cothread = ctx->cothreads[ctx->current];
|
||||
|
||||
GST_DEBUG_ENTER ("");
|
||||
|
||||
GST_DEBUG (GST_CAT_COTHREADS, "stack addr %p\n", &ctx);
|
||||
|
||||
thread->flags |= COTHREAD_STARTED;
|
||||
cothread->flags |= COTHREAD_STARTED;
|
||||
|
||||
while (TRUE) {
|
||||
thread->func (thread->argc, thread->argv);
|
||||
cothread->func (cothread->argc, cothread->argv);
|
||||
|
||||
GST_DEBUG (GST_CAT_COTHREADS, "cothread[%d] thread->func exited",ctx->current);
|
||||
GST_DEBUG (GST_CAT_COTHREADS, "cothread[%d] thread->func exited", ctx->current);
|
||||
|
||||
GST_DEBUG (GST_CAT_COTHREADS, "sp=%p",CURRENT_STACK_FRAME);
|
||||
GST_DEBUG (GST_CAT_COTHREADS, "ctx=%p current=%p",ctx,cothread_get_current_context());
|
||||
g_assert(ctx == cothread_get_current_context());
|
||||
GST_DEBUG (GST_CAT_COTHREADS, "sp=%p", CURRENT_STACK_FRAME);
|
||||
GST_DEBUG (GST_CAT_COTHREADS, "ctx=%p current=%p", ctx,cothread_get_current_context());
|
||||
g_assert (ctx == cothread_get_current_context());
|
||||
|
||||
g_assert(ctx->current != 0);
|
||||
g_assert (ctx->current != 0);
|
||||
|
||||
/* we do this to avoid ever returning, we just switch to 0th thread */
|
||||
cothread_switch (cothread_main (ctx));
|
||||
|
|
@ -485,32 +485,33 @@ cothread_getcurrent (void)
|
|||
|
||||
if (!ctx)
|
||||
return -1;
|
||||
|
||||
return ctx->current;
|
||||
}
|
||||
|
||||
/**
|
||||
* cothread_set_private:
|
||||
* @thread: the cothread state
|
||||
* @cothread: the cothread state
|
||||
* @data: the data
|
||||
*
|
||||
* set private data for the cothread.
|
||||
*/
|
||||
void
|
||||
cothread_set_private (cothread_state *thread, gpointer data)
|
||||
cothread_set_private (cothread_state *cothread, gpointer data)
|
||||
{
|
||||
thread->priv = data;
|
||||
cothread->priv = data;
|
||||
}
|
||||
|
||||
/**
|
||||
* cothread_context_set_data:
|
||||
* @thread: the cothread state
|
||||
* @cothread: the cothread state
|
||||
* @key: a key for the data
|
||||
* @data: the data
|
||||
*
|
||||
* adds data to a cothread
|
||||
*/
|
||||
void
|
||||
cothread_context_set_data (cothread_state *thread, gchar *key, gpointer data)
|
||||
cothread_context_set_data (cothread_state *cothread, gchar *key, gpointer data)
|
||||
{
|
||||
cothread_context *ctx = cothread_get_current_context();
|
||||
|
||||
|
|
@ -519,21 +520,21 @@ cothread_context_set_data (cothread_state *thread, gchar *key, gpointer data)
|
|||
|
||||
/**
|
||||
* cothread_get_private:
|
||||
* @thread: the cothread state
|
||||
* @cothread: the cothread state
|
||||
*
|
||||
* get the private data from the cothread
|
||||
*
|
||||
* Returns: the private data of the cothread
|
||||
*/
|
||||
gpointer
|
||||
cothread_get_private (cothread_state *thread)
|
||||
cothread_get_private (cothread_state *cothread)
|
||||
{
|
||||
return thread->priv;
|
||||
return cothread->priv;
|
||||
}
|
||||
|
||||
/**
|
||||
* cothread_context_get_data:
|
||||
* @thread: the cothread state
|
||||
* @cothread: the cothread state
|
||||
* @key: a key for the data
|
||||
*
|
||||
* get data from the cothread
|
||||
|
|
@ -541,7 +542,7 @@ cothread_get_private (cothread_state *thread)
|
|||
* Returns: the data associated with the key
|
||||
*/
|
||||
gpointer
|
||||
cothread_context_get_data (cothread_state * thread, gchar * key)
|
||||
cothread_context_get_data (cothread_state *cothread, gchar *key)
|
||||
{
|
||||
cothread_context *ctx = cothread_get_current_context();
|
||||
|
||||
|
|
@ -550,22 +551,22 @@ cothread_context_get_data (cothread_state * thread, gchar * key)
|
|||
|
||||
/**
|
||||
* cothread_switch:
|
||||
* @thread: cothread state to switch to
|
||||
* @cothread: cothread state to switch to
|
||||
*
|
||||
* Switches to the given cothread state
|
||||
*/
|
||||
void
|
||||
cothread_switch (cothread_state * thread)
|
||||
cothread_switch (cothread_state *cothread)
|
||||
{
|
||||
cothread_context *ctx;
|
||||
cothread_state *current;
|
||||
int enter;
|
||||
|
||||
#ifdef COTHREAD_PARANOID
|
||||
if (thread == NULL)
|
||||
if (cothread == NULL)
|
||||
goto nothread;
|
||||
#endif
|
||||
ctx = thread->ctx;
|
||||
ctx = cothread->ctx;
|
||||
|
||||
/* paranoia check to make sure we're in the right thread */
|
||||
g_assert (ctx->thread == g_thread_self());
|
||||
|
|
@ -580,15 +581,15 @@ cothread_switch (cothread_state * thread)
|
|||
if (current == NULL)
|
||||
goto nocurrent;
|
||||
#endif
|
||||
if (current == thread)
|
||||
if (current == cothread)
|
||||
goto selfswitch;
|
||||
|
||||
|
||||
/* find the number of the thread to switch to */
|
||||
GST_INFO (GST_CAT_COTHREAD_SWITCH,
|
||||
"switching from cothread #%d to cothread #%d",
|
||||
ctx->current, thread->cothreadnum);
|
||||
ctx->current = thread->cothreadnum;
|
||||
ctx->current, cothread->cothreadnum);
|
||||
ctx->current = cothread->cothreadnum;
|
||||
|
||||
g_static_private_set (&_gst_debug_cothread_index, (void *)ctx->current, NULL);
|
||||
|
||||
|
|
@ -611,12 +612,12 @@ cothread_switch (cothread_state * thread)
|
|||
cothread_destroy (current);
|
||||
}
|
||||
|
||||
GST_DEBUG (GST_CAT_COTHREADS, "set stack to %p", thread->sp);
|
||||
GST_DEBUG (GST_CAT_COTHREADS, "set stack to %p", cothread->sp);
|
||||
/* restore stack pointer and other stuff of new cothread */
|
||||
if (thread->flags & COTHREAD_STARTED) {
|
||||
GST_DEBUG (GST_CAT_COTHREADS, "via longjmp() jmpbuf %p", thread->jmp);
|
||||
if (cothread->flags & COTHREAD_STARTED) {
|
||||
GST_DEBUG (GST_CAT_COTHREADS, "via longjmp() jmpbuf %p", cothread->jmp);
|
||||
/* switch to it */
|
||||
longjmp (thread->jmp, 1);
|
||||
longjmp (cothread->jmp, 1);
|
||||
}
|
||||
else {
|
||||
#ifdef HAVE_MAKECONTEXT
|
||||
|
|
@ -624,16 +625,16 @@ cothread_switch (cothread_state * thread)
|
|||
|
||||
GST_DEBUG (GST_CAT_COTHREADS, "making context");
|
||||
|
||||
g_assert(thread != cothread_main(ctx));
|
||||
g_assert (cothread != cothread_main(ctx));
|
||||
|
||||
getcontext(&ucp);
|
||||
ucp.uc_stack.ss_sp = (void *)thread->stack_base;
|
||||
ucp.uc_stack.ss_size = thread->stack_size;
|
||||
makecontext(&ucp, cothread_stub, 0);
|
||||
setcontext(&ucp);
|
||||
getcontext (&ucp);
|
||||
ucp.uc_stack.ss_sp = (void *)cothread->stack_base;
|
||||
ucp.uc_stack.ss_size = cothread->stack_size;
|
||||
makecontext (&ucp, cothread_stub, 0);
|
||||
setcontext (&ucp);
|
||||
#else
|
||||
GST_ARCH_SETUP_STACK ((char*)thread->sp);
|
||||
GST_ARCH_SET_SP (thread->sp);
|
||||
GST_ARCH_SETUP_STACK ((char*)cothread->sp);
|
||||
GST_ARCH_SET_SP (cothread->sp);
|
||||
/* start it */
|
||||
GST_ARCH_CALL (cothread_stub);
|
||||
#endif
|
||||
|
|
@ -662,36 +663,36 @@ selfswitch:
|
|||
|
||||
/**
|
||||
* cothread_lock:
|
||||
* @thread: cothread state to lock
|
||||
* @cothread: cothread state to lock
|
||||
*
|
||||
* Locks the cothread state.
|
||||
*/
|
||||
void
|
||||
cothread_lock (cothread_state * thread)
|
||||
cothread_lock (cothread_state *cothread)
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* cothread_trylock:
|
||||
* @thread: cothread state to try to lock
|
||||
* @cothread: cothread state to try to lock
|
||||
*
|
||||
* Try to lock the cothread state
|
||||
*
|
||||
* Returns: TRUE if the cothread could be locked.
|
||||
*/
|
||||
gboolean
|
||||
cothread_trylock (cothread_state * thread)
|
||||
cothread_trylock (cothread_state *cothread)
|
||||
{
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* cothread_unlock:
|
||||
* @thread: cothread state to unlock
|
||||
* @cothread: cothread state to unlock
|
||||
*
|
||||
* Unlock the cothread state.
|
||||
*/
|
||||
void
|
||||
cothread_unlock (cothread_state * thread)
|
||||
cothread_unlock (cothread_state *cothread)
|
||||
{
|
||||
}
|
||||
|
|
|
|||
|
|
@ -60,24 +60,24 @@ struct _cothread_state {
|
|||
|
||||
cothread_context* cothread_context_init (void);
|
||||
void cothread_context_free (cothread_context *ctx);
|
||||
void cothread_context_set_data (cothread_state *thread,
|
||||
void cothread_context_set_data (cothread_state *cothread,
|
||||
gchar *key, gpointer data);
|
||||
gpointer cothread_context_get_data (cothread_state *thread, gchar *key);
|
||||
gpointer cothread_context_get_data (cothread_state *cothread, gchar *key);
|
||||
|
||||
cothread_state* cothread_create (cothread_context *ctx);
|
||||
void cothread_free (cothread_state *thread);
|
||||
void cothread_setfunc (cothread_state *thread, cothread_func func,
|
||||
void cothread_free (cothread_state *cothread);
|
||||
void cothread_setfunc (cothread_state *cothread, cothread_func func,
|
||||
int argc, char **argv);
|
||||
void cothread_stop (cothread_state *thread);
|
||||
void cothread_stop (cothread_state *cothread);
|
||||
|
||||
void cothread_switch (cothread_state *thread);
|
||||
void cothread_set_private (cothread_state *thread,
|
||||
void cothread_switch (cothread_state *cothread);
|
||||
void cothread_set_private (cothread_state *cothread,
|
||||
gpointer data);
|
||||
gpointer cothread_get_private (cothread_state *thread);
|
||||
gpointer cothread_get_private (cothread_state *cothread);
|
||||
|
||||
void cothread_lock (cothread_state *thread);
|
||||
gboolean cothread_trylock (cothread_state *thread);
|
||||
void cothread_unlock (cothread_state *thread);
|
||||
void cothread_lock (cothread_state *cothread);
|
||||
gboolean cothread_trylock (cothread_state *cothread);
|
||||
void cothread_unlock (cothread_state *cothread);
|
||||
|
||||
cothread_state* cothread_main (cothread_context *ctx);
|
||||
cothread_state* cothread_current_main (void);
|
||||
|
|
|
|||
|
|
@ -57,7 +57,19 @@ populate (GstMemChunk *mem_chunk)
|
|||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* gst_mem_chunk_new:
|
||||
* @name: the name of the chunk
|
||||
* @atom_size: the size of the allocated atoms
|
||||
* @area_size: the initial size of the memory area
|
||||
* @type: the allocation strategy to use
|
||||
*
|
||||
* Creates a new memchunk that will allocate atom_sized memchunks.
|
||||
* The initial area is set to area_size and will grow automatically
|
||||
* when it is too small (with a small overhead when that happens)
|
||||
*
|
||||
* Returns: a new #GstMemChunk
|
||||
*/
|
||||
GstMemChunk*
|
||||
gst_mem_chunk_new (gchar* name, gint atom_size, gulong area_size, gint type)
|
||||
{
|
||||
|
|
@ -90,6 +102,12 @@ free_area (gpointer key, gpointer value, gpointer user_data)
|
|||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* gst_mem_chunk_destroy:
|
||||
* @mem_chunk: the GstMemChunk to destroy
|
||||
*
|
||||
* Free the memory allocated by the memchunk
|
||||
*/
|
||||
void
|
||||
gst_mem_chunk_destroy (GstMemChunk *mem_chunk)
|
||||
{
|
||||
|
|
@ -113,6 +131,16 @@ gst_mem_chunk_destroy (GstMemChunk *mem_chunk)
|
|||
g_free (mem_chunk);
|
||||
}
|
||||
|
||||
/**
|
||||
* gst_mem_chunk_alloc:
|
||||
* @mem_chunk: the mem chunk to use
|
||||
*
|
||||
* Allocate a new memory region from the chunk. The size
|
||||
* of the allocated memory was specified when the memchunk
|
||||
* was created.
|
||||
*
|
||||
* Returns: a pointer to the allocated memory region.
|
||||
*/
|
||||
gpointer
|
||||
gst_mem_chunk_alloc (GstMemChunk *mem_chunk)
|
||||
{
|
||||
|
|
@ -134,6 +162,16 @@ again:
|
|||
return GST_MEM_CHUNK_DATA (chunk);
|
||||
}
|
||||
|
||||
/**
|
||||
* gst_mem_chunk_alloc0:
|
||||
* @mem_chunk: the mem chunk to use
|
||||
*
|
||||
* Allocate a new memory region from the chunk. The size
|
||||
* of the allocated memory was specified when the memchunk
|
||||
* was created. The memory will be set to all zeroes.
|
||||
*
|
||||
* Returns: a pointer to the allocated memory region.
|
||||
*/
|
||||
gpointer
|
||||
gst_mem_chunk_alloc0 (GstMemChunk *mem_chunk)
|
||||
{
|
||||
|
|
@ -145,6 +183,13 @@ gst_mem_chunk_alloc0 (GstMemChunk *mem_chunk)
|
|||
return mem;
|
||||
}
|
||||
|
||||
/**
|
||||
* gst_mem_chunk_free:
|
||||
* @mem_chunk: the mem chunk to use
|
||||
* @mem: the memory region to hand back to the chunk
|
||||
*
|
||||
* Free the memeory region allocated from the chunk.
|
||||
*/
|
||||
void
|
||||
gst_mem_chunk_free (GstMemChunk *mem_chunk, gpointer mem)
|
||||
{
|
||||
|
|
|
|||
Loading…
Reference in a new issue