cothreads

Name

cothreads -- userspace threads

Synopsis


#include <gst/gst.h>


struct      cothread_state;
struct      cothread_context;
int         (*cothread_func)                (int argc,
                                             char **argv);
#define     COTHREAD_STARTED
#define     COTHREAD_DESTROYED
cothread_context* cothread_context_init     (void);
void        cothread_context_free           (cothread_context *ctx);
gpointer    cothread_get_private            (cothread_state *cothread);
void        cothread_set_private            (cothread_state *cothread,
                                             gpointer data);
cothread_state* cothread_create             (cothread_context *ctx);
void        cothread_free                   (cothread_state *cothread);
void        cothread_setfunc                (cothread_state *cothread,
                                             cothread_func func,
                                             int argc,
                                             char **argv);
void        cothread_stop                   (cothread_state *cothread);
void        cothread_switch                 (cothread_state *cothread);
gpointer    cothread_context_get_data       (cothread_state *cothread,
                                             gchar *key);
void        cothread_context_set_data       (cothread_state *cothread,
                                             gchar *key,
                                             gpointer data);
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);
cothread_state* cothread_current            (void);

Description

Cothreads are a simple user-space method for switching between subtasks. They're based on setjmp()/longjmp() in their current form.

Cothreads are used for loop-based elements that pull data instead of being fed with data. Cothreads are usually used by a GstScheduler.

Details

struct cothread_state

struct cothread_state {

  cothread_context 	*ctx;
  int			 cothreadnum;
  gpointer		 priv;

  cothread_func		 func;
  int			 argc;
  char		       **argv;

  int			 flags;
  void			*sp;
  jmp_buf		 jmp;
  void			*stack_base;
  unsigned long		 stack_size;

  int			 magic_number;
};

The cothread state structure


struct cothread_context

struct cothread_context;

The cothread context structure


cothread_func ()

int         (*cothread_func)                (int argc,
                                             char **argv);

the function that will be called when the cothread starts. The function prototype is like a main() function, so you can do whatever you want with it.

argc :

a main-like argument count

argv :

a main-like array of arguments

Returns :

a return code


COTHREAD_STARTED

#define COTHREAD_STARTED	0x01

Indicates the cothread is started.


COTHREAD_DESTROYED

#define COTHREAD_DESTROYED	0x02

Indicates the cothread is destroyed.


cothread_context_init ()

cothread_context* cothread_context_init     (void);

Create and initialize a new cothread context

Returns :

the new cothread context


cothread_context_free ()

void        cothread_context_free           (cothread_context *ctx);

Free the cothread context.

ctx :

the cothread context to free


cothread_get_private ()

gpointer    cothread_get_private            (cothread_state *cothread);

get the private data from the cothread

cothread :

the cothread state

Returns :

the private data of the cothread


cothread_set_private ()

void        cothread_set_private            (cothread_state *cothread,
                                             gpointer data);

set private data for the cothread.

cothread :

the cothread state

data :

the data


cothread_create ()

cothread_state* cothread_create             (cothread_context *ctx);

Create a new cothread state in the given context

ctx :

the cothread context

Returns :

the new cothread state or NULL on error


cothread_free ()

void        cothread_free                   (cothread_state *cothread);

Free the given cothread state

cothread :

the cothread state


cothread_setfunc ()

void        cothread_setfunc                (cothread_state *cothread,
                                             cothread_func func,
                                             int argc,
                                             char **argv);

Set the cothread function

cothread :

the cothread state

func :

the function to call

argc :

argument count for the cothread function

argv :

arguments for the cothread function


cothread_stop ()

void        cothread_stop                   (cothread_state *cothread);

Stop the cothread and reset the stack and program counter.

cothread :

the cothread to stop


cothread_switch ()

void        cothread_switch                 (cothread_state *cothread);

Switches to the given cothread state

cothread :

cothread state to switch to


cothread_context_get_data ()

gpointer    cothread_context_get_data       (cothread_state *cothread,
                                             gchar *key);

get data from the cothread

cothread :

the cothread state

key :

a key for the data

Returns :

the data associated with the key


cothread_context_set_data ()

void        cothread_context_set_data       (cothread_state *cothread,
                                             gchar *key,
                                             gpointer data);

adds data to a cothread

cothread :

the cothread state

key :

a key for the data

data :

the data


cothread_lock ()

void        cothread_lock                   (cothread_state *cothread);

Locks the cothread state.

cothread :

cothread state to lock


cothread_trylock ()

gboolean    cothread_trylock                (cothread_state *cothread);

Try to lock the cothread state

cothread :

cothread state to try to lock

Returns :

TRUE if the cothread could be locked.


cothread_unlock ()

void        cothread_unlock                 (cothread_state *cothread);

Unlock the cothread state.

cothread :

cothread state to unlock


cothread_main ()

cothread_state* cothread_main               (cothread_context *ctx);

Gets the main thread.

ctx :

cothread context to find main cothread of.

Returns :

the cothread_state of the main (0th) cothread.


cothread_current_main ()

cothread_state* cothread_current_main       (void);

Get the main thread in the current GThread.

Returns :

the cothread_state of the main (0th) thread in the current GThread


cothread_current ()

cothread_state* cothread_current            (void);

Get the currenttly executing cothread

Returns :

the cothread_state of the current cothread

See Also

GstScheduler