Référence du fichier tasks.h

#include "coroutine/cotask.h"
#include "coroutine/coevent.h"
#include "coroutine/cosched.h"
#include <limits.h>
#include "macro.h"

Aller au code source de ce fichier.

Macros
#define	TASK_ARGS_TYPE(name)
#define	TASK_ARGSDELAY_NAME(name)
#define	TASK_ARGSDELAY(name)
#define	TASK_ARGSCOND_NAME(name)
#define	TASK_ARGSCOND(name)
#define	TASK_IFACE_NAME(iface, suffix)
#define	TASK_IFACE_ARGS_TYPE(iface)
#define	TASK_IFACE_ARGS_SIZED_PTR_TYPE(iface)
#define	TASK_INDIRECT_TYPE(iface)
#define	TASK_IFACE_SARGS(iface, ...)
#define	DEFINE_TASK_INTERFACE(iface, argstruct)
#define	DEFINE_TASK_INTERFACE_WITH_BASE(iface, ibase, argstruct)
#define	TASK_INDIRECT_TYPE_ALIAS(task)
#define	ARGS   (*_cotask_args)
#define	TASK_ARGS_STRUCT(argstruct)
#define	TASK_COMMON_PRIVATE_DECLARATIONS(name)
#define	TASK_COMMON_DECLARATIONS(name, argstype, handletype, linkage)
#define	TASK_COMMON_THUNK_DEFINITIONS(name, linkage)
#define	TASK_COMMON_BEGIN_BODY_DEFINITION(name, linkage)
#define	DECLARE_TASK_EXPLICIT(name, argstype, handletype, linkage)
#define	DEFINE_TASK_EXPLICIT(name, linkage)
#define	DECLARE_TASK(name, ...)
#define	DECLARE_TASK_1(name, ...)
#define	DECLARE_TASK_0(name)
#define	DECLARE_TASK_WITH_INTERFACE(name, iface)
#define	DEFINE_TASK(name)
#define	TASK(name, ...)
#define	TASK_WITH_INTERFACE(name, iface)
#define	DECLARE_EXTERN_TASK(name, ...)
#define	DECLARE_EXTERN_TASK_1(name, ...)
#define	DECLARE_EXTERN_TASK_0(name)
#define	DECLARE_EXTERN_TASK_WITH_INTERFACE(name, iface)
#define	DEFINE_EXTERN_TASK(name)
#define	INVOKE_TASK(_task, ...)
#define	INVOKE_SUBTASK(_task, ...)
#define	SCHED_INVOKE_TASK(_sched, _task, ...)
#define	_internal_INVOKE_TASK(sched, task_constructor, name, ...)
#define	INVOKE_TASK_DELAYED(_delay, _task, ...)
#define	INVOKE_SUBTASK_DELAYED(_delay, _task, ...)
#define	SCHED_INVOKE_TASK_DELAYED(_sched, _delay, _task, ...)
#define	_internal_INVOKE_TASK_DELAYED(sched, task_constructor, _delay, name, ...)
#define	INVOKE_TASK_WHEN(_event, _task, ...)
#define	INVOKE_SUBTASK_WHEN(_event, _task, ...)
#define	SCHED_INVOKE_TASK_WHEN(_sched, _event, _task, ...)
#define	INVOKE_TASK_AFTER(_event, _task, ...)
#define	INVOKE_SUBTASK_AFTER(_event, _task, ...)
#define	SCHED_INVOKE_TASK_AFTER(_sched, _event, _task, ...)
#define	_internal_INVOKE_TASK_ON_EVENT(sched, task_constructor, is_unconditional, _event, name, ...)
#define	CANCEL_TASK_WHEN(_event, _task)
#define	CANCEL_TASK_AFTER(_event, _task)
#define	CANCEL_TASK(boxed_task)
#define	TASK_INDIRECT(iface, task)
#define	TASK_INDIRECT_INIT(iface, task)
#define	INVOKE_TASK_INDIRECT_(sched, task_constructor, iface, taskhandle, ...)
#define	SCHED_INVOKE_TASK_INDIRECT(_sched, _iface, _handle, ...)
#define	INVOKE_TASK_INDIRECT(_iface, _handle, ...)
#define	INVOKE_SUBTASK_INDIRECT(_iface, _handle, ...)
#define	THIS_TASK   cotask_box(cotask_active())
#define	TASK_EVENTS(task)
#define	TASK_MALLOC(size)
#define	THIS_SCHED   cotask_get_sched(cotask_active())
#define	TASK_HOST_ENT()
#define	TASK_HOST_EVENTS(events_array)
#define	YIELD   cotask_yield(NULL)
#define	WAIT(delay)
#define	WAIT_EVENT(e)
#define	WAIT_EVENT_OR_DIE(e)
#define	WAIT_EVENT_ONCE(e)
#define	STALL   cotask_wait(INT_MAX)
#define	AWAIT_SUBTASKS   cotask_wait_substasks()
#define	NOT_NULL_OR_DIE(expr)
#define	TASK_BIND(ent)

Fonctions
	DECLARE_EXTERN_TASK (_cancel_task_helper, { BoxedTask task;})

Documentation des macros

_internal_INVOKE_TASK

#define _internal_INVOKE_TASK	(		sched,
			task_constructor,
			name,
			... )

Valeur :

    ( \
    (void)COTASK_UNUSED_CHECK_##name, \
    task_constructor( \
        sched, \
        COTASKTHUNK_##name, \
        (&(TASK_ARGS_TYPE(name)) { __VA_ARGS__ }), \
        sizeof(TASK_ARGS_TYPE(name)) \
    ) \
)

_internal_INVOKE_TASK_DELAYED

#define _internal_INVOKE_TASK_DELAYED	(		sched,
			task_constructor,
			_delay,
			name,
			... )

Valeur :

    ( \
    (void)COTASK_UNUSED_CHECK_##name, \
    task_constructor( \
        sched, \
        COTASKTHUNKDELAY_##name, \
        (&(TASK_ARGSDELAY(name)) { \
            .real_args = { __VA_ARGS__ }, \
            .delay = (_delay) \
        }), \
        sizeof(TASK_ARGSDELAY(name)) \
    ) \
)

_internal_INVOKE_TASK_ON_EVENT

#define _internal_INVOKE_TASK_ON_EVENT	(		sched,
			task_constructor,
			is_unconditional,
			_event,
			name,
			... )

Valeur :

    ( \
    (void)COTASK_UNUSED_CHECK_##name, \
    task_constructor( \
        sched, \
        COTASKTHUNKCOND_##name, \
        (&(TASK_ARGSCOND(name)) { \
            .real_args = { __VA_ARGS__ }, \
            .event = (_event), \
            .unconditional = is_unconditional \
        }), \
        sizeof(TASK_ARGSCOND(name)) \
    ) \
)

ARGS

#define ARGS   (*_cotask_args)

AWAIT_SUBTASKS

#define AWAIT_SUBTASKS   cotask_wait_substasks()

CANCEL_TASK

#define CANCEL_TASK

(

boxed_task

)

Valeur :

cotask_cancel(cotask_unbox(boxed_task))

CANCEL_TASK_AFTER

#define CANCEL_TASK_AFTER	(		_event,
			_task )

Valeur :

INVOKE_TASK_AFTER(_event, _cancel_task_helper, _task)

CANCEL_TASK_WHEN

#define CANCEL_TASK_WHEN	(		_event,
			_task )

Valeur :

INVOKE_TASK_WHEN(_event, _cancel_task_helper, _task)

DECLARE_EXTERN_TASK

#define DECLARE_EXTERN_TASK	(		name,
			... )

Valeur :

MACRO_OVERLOAD_HASARGS(DECLARE_EXTERN_TASK_, __VA_ARGS__ )(name, ##__VA_ARGS__)

DECLARE_EXTERN_TASK_0

#define DECLARE_EXTERN_TASK_0

(

name

)

Valeur :

DECLARE_EXTERN_TASK_1(name, { })

DECLARE_EXTERN_TASK_1

#define DECLARE_EXTERN_TASK_1	(		name,
			... )

Valeur :

DECLARE_TASK_EXPLICIT(name, TASK_ARGS_STRUCT(__VA_ARGS__), void, extern)

DECLARE_EXTERN_TASK_WITH_INTERFACE

#define DECLARE_EXTERN_TASK_WITH_INTERFACE	(		name,
			iface )

Valeur :

DECLARE_TASK_EXPLICIT(name, TASK_IFACE_ARGS_TYPE(iface), TASK_INDIRECT_TYPE(iface), extern)

DECLARE_TASK

#define DECLARE_TASK	(		name,
			... )

Valeur :

MACRO_OVERLOAD_HASARGS(DECLARE_TASK_, __VA_ARGS__)(name, ##__VA_ARGS__)

DECLARE_TASK_0

#define DECLARE_TASK_0

(

name

)

Valeur :

DECLARE_TASK_1(name, { })

DECLARE_TASK_1

#define DECLARE_TASK_1	(		name,
			... )

Valeur :

DECLARE_TASK_EXPLICIT(name, TASK_ARGS_STRUCT(__VA_ARGS__), void, static)

DECLARE_TASK_EXPLICIT

#define DECLARE_TASK_EXPLICIT	(		name,
			argstype,
			handletype,
			linkage )

Valeur :

TASK_COMMON_DECLARATIONS(name, argstype, handletype, linkage)

DECLARE_TASK_WITH_INTERFACE

#define DECLARE_TASK_WITH_INTERFACE	(		name,
			iface )

Valeur :

DECLARE_TASK_EXPLICIT(name, TASK_IFACE_ARGS_TYPE(iface), TASK_INDIRECT_TYPE(iface), static)

DEFINE_EXTERN_TASK

#define DEFINE_EXTERN_TASK

(

name

)

Valeur :

char COTASK_UNUSED_CHECK_##name; \
DEFINE_TASK_EXPLICIT(name, extern)

DEFINE_TASK

#define DEFINE_TASK

(

name

)

Valeur :

DEFINE_TASK_EXPLICIT(name, static)

DEFINE_TASK_EXPLICIT

#define DEFINE_TASK_EXPLICIT	(		name,
			linkage )

Valeur :

TASK_COMMON_PRIVATE_DECLARATIONS(name); \
TASK_COMMON_THUNK_DEFINITIONS(name, linkage) \
TASK_COMMON_BEGIN_BODY_DEFINITION(name, linkage)

DEFINE_TASK_INTERFACE

#define DEFINE_TASK_INTERFACE	(		iface,
			argstruct )

Valeur :

typedef TASK_ARGS_STRUCT(argstruct) TASK_IFACE_ARGS_TYPE(iface); \
typedef struct { \
    TASK_IFACE_ARGS_TYPE(iface) *ptr; \
    size_t size; \
} TASK_IFACE_ARGS_SIZED_PTR_TYPE(iface); \
typedef struct { \
    CoTaskFunc _cotask_##iface##_thunk; \
} TASK_INDIRECT_TYPE(iface)

DEFINE_TASK_INTERFACE_WITH_BASE

#define DEFINE_TASK_INTERFACE_WITH_BASE	(		iface,
			ibase,
			argstruct )

Valeur :

typedef struct { \
    TASK_IFACE_ARGS_TYPE(ibase) base; \
    TASK_ARGS_STRUCT(argstruct); \
} TASK_IFACE_ARGS_TYPE(iface); \
typedef struct { \
    union { \
        TASK_IFACE_ARGS_SIZED_PTR_TYPE(ibase) base; \
        struct { \
            TASK_IFACE_ARGS_TYPE(iface) *ptr; \
            size_t size; \
        }; \
    }; \
} TASK_IFACE_ARGS_SIZED_PTR_TYPE(iface); \
typedef struct { \
    union { \
        TASK_INDIRECT_TYPE(ibase) base; \
        CoTaskFunc _cotask_##iface##_thunk; \
        CoTaskFunc _cotask_##ibase##_thunk; \
    }; \
} TASK_INDIRECT_TYPE(iface) \

INVOKE_SUBTASK

#define INVOKE_SUBTASK	(		_task,
			... )

Valeur :

_internal_INVOKE_TASK(THIS_SCHED, cosched_new_subtask, _task, ##__VA_ARGS__)

INVOKE_SUBTASK_AFTER

#define INVOKE_SUBTASK_AFTER	(		_event,
			_task,
			... )

Valeur :

_internal_INVOKE_TASK_ON_EVENT(THIS_SCHED, cosched_new_subtask, true, _event, _task, ## __VA_ARGS__)

INVOKE_SUBTASK_DELAYED

#define INVOKE_SUBTASK_DELAYED	(		_delay,
			_task,
			... )

Valeur :

_internal_INVOKE_TASK_DELAYED(THIS_SCHED, cosched_new_subtask, _delay, _task, ##__VA_ARGS__)

INVOKE_SUBTASK_INDIRECT

#define INVOKE_SUBTASK_INDIRECT	(		_iface,
			_handle,
			... )

Valeur :

INVOKE_TASK_INDIRECT_(THIS_SCHED, cosched_new_subtask, iface, _handle, ##__VA_ARGS__)

INVOKE_SUBTASK_WHEN

#define INVOKE_SUBTASK_WHEN	(		_event,
			_task,
			... )

Valeur :

_internal_INVOKE_TASK_ON_EVENT(THIS_SCHED, cosched_new_subtask, false, _event, _task, ##__VA_ARGS__)

INVOKE_TASK

#define INVOKE_TASK	(		_task,
			... )

Valeur :

_internal_INVOKE_TASK(THIS_SCHED, cosched_new_task, _task, ##__VA_ARGS__)

INVOKE_TASK_AFTER

#define INVOKE_TASK_AFTER	(		_event,
			_task,
			... )

Valeur :

_internal_INVOKE_TASK_ON_EVENT(THIS_SCHED, cosched_new_task, true, _event, _task, ## __VA_ARGS__)

INVOKE_TASK_DELAYED

#define INVOKE_TASK_DELAYED	(		_delay,
			_task,
			... )

Valeur :

_internal_INVOKE_TASK_DELAYED(THIS_SCHED, cosched_new_task, _delay, _task, ##__VA_ARGS__)

INVOKE_TASK_INDIRECT

#define INVOKE_TASK_INDIRECT	(		_iface,
			_handle,
			... )

Valeur :

INVOKE_TASK_INDIRECT_(THIS_SCHED, cosched_new_task, _iface, _handle, ##__VA_ARGS__)

INVOKE_TASK_INDIRECT_

#define INVOKE_TASK_INDIRECT_	(		sched,
			task_constructor,
			iface,
			taskhandle,
			... )

Valeur :

    ( \
    task_constructor( \
        sched, \
        taskhandle._cotask_##iface##_thunk, \
        (&(TASK_IFACE_ARGS_TYPE(iface)) { __VA_ARGS__ }), \
        sizeof(TASK_IFACE_ARGS_TYPE(iface)) \
    ) \
)

INVOKE_TASK_WHEN

#define INVOKE_TASK_WHEN	(		_event,
			_task,
			... )

Valeur :

_internal_INVOKE_TASK_ON_EVENT(THIS_SCHED, cosched_new_task, false, _event, _task, ##__VA_ARGS__)

NOT_NULL_OR_DIE

#define NOT_NULL_OR_DIE

(

expr

)

Valeur :

    ({ \
    auto _not_null_ptr = (expr); \
    if (_not_null_ptr == NULL) { \
        cotask_cancel(cotask_active()); \
    } \
})

SCHED_INVOKE_TASK

#define SCHED_INVOKE_TASK	(		_sched,
			_task,
			... )

Valeur :

_internal_INVOKE_TASK(_sched, cosched_new_task, _task, ##__VA_ARGS__)

SCHED_INVOKE_TASK_AFTER

#define SCHED_INVOKE_TASK_AFTER	(		_sched,
			_event,
			_task,
			... )

Valeur :

_internal_INVOKE_TASK_ON_EVENT(_sched, cosched_new_task, true, _event, _task, ##__VA_ARGS__)

SCHED_INVOKE_TASK_DELAYED

#define SCHED_INVOKE_TASK_DELAYED	(		_sched,
			_delay,
			_task,
			... )

Valeur :

_internal_INVOKE_TASK_DELAYED(_sched, cosched_new_task, _delay, _task, ##__VA_ARGS__)

SCHED_INVOKE_TASK_INDIRECT

#define SCHED_INVOKE_TASK_INDIRECT	(		_sched,
			_iface,
			_handle,
			... )

Valeur :

INVOKE_TASK_INDIRECT_(_sched, cosched_new_task, _iface, _handle, ##__VA_ARGS__)

SCHED_INVOKE_TASK_WHEN

#define SCHED_INVOKE_TASK_WHEN	(		_sched,
			_event,
			_task,
			... )

Valeur :

_internal_INVOKE_TASK_ON_EVENT(_sched, cosched_new_task, false, _event, _task, ##__VA_ARGS__)

STALL

#define STALL   cotask_wait(INT_MAX)

TASK

#define TASK	(		name,
			... )

Valeur :

DECLARE_TASK(name, ##__VA_ARGS__); \
DEFINE_TASK(name)

TASK_ARGS_STRUCT

#define TASK_ARGS_STRUCT

(

argstruct

)

Valeur :

struct {struct argstruct ; }

TASK_ARGS_TYPE

#define TASK_ARGS_TYPE

(

name

)

Valeur :

COARGS_##name

TASK_ARGSCOND

#define TASK_ARGSCOND

(

name

)

Valeur :

struct TASK_ARGSCOND_NAME(name)

TASK_ARGSCOND_NAME

#define TASK_ARGSCOND_NAME

(

name

)

Valeur :

COARGSCOND_##name

TASK_ARGSDELAY

#define TASK_ARGSDELAY

(

name

)

Valeur :

struct TASK_ARGSDELAY_NAME(name)

TASK_ARGSDELAY_NAME

#define TASK_ARGSDELAY_NAME

(

name

)

Valeur :

COARGSDELAY_##name

TASK_BIND

#define TASK_BIND

(

ent

)

Valeur :

cotask_bind_to_entity(cotask_active(), (ent))

TASK_COMMON_BEGIN_BODY_DEFINITION

#define TASK_COMMON_BEGIN_BODY_DEFINITION	(		name,
			linkage )

Valeur :

linkage void COTASK_##name(TASK_ARGS_TYPE(name) *_cotask_args)

TASK_COMMON_DECLARATIONS

#define TASK_COMMON_DECLARATIONS	(		name,
			argstype,
			handletype,
			linkage )

Valeur :

linkage char COTASK_UNUSED_CHECK_##name; \
typedef handletype TASK_INDIRECT_TYPE_ALIAS(name); \
typedef argstype TASK_ARGS_TYPE(name); \
struct TASK_ARGSDELAY_NAME(name) { \
    int delay; \
    TASK_ARGS_TYPE(name) real_args; \
}; \
struct TASK_ARGSCOND_NAME(name) { \
    CoEvent *event; \
    bool unconditional; \
    TASK_ARGS_TYPE(name) real_args; \
}; \
linkage void *COTASKTHUNK_##name(void *arg, size_t arg_size); \
linkage void *COTASKTHUNK_DELAYED_##name(void *arg, size_t arg_size); \
linkage void *COTASKTHUNK_COND_##name(void *arg, size_t arg_size) \

TASK_COMMON_PRIVATE_DECLARATIONS

#define TASK_COMMON_PRIVATE_DECLARATIONS

(

name

)

Valeur :

static void COTASK_##name(TASK_ARGS_TYPE(name) *_cotask_args)

TASK_COMMON_THUNK_DEFINITIONS

#define TASK_COMMON_THUNK_DEFINITIONS	(		name,
			linkage )

Valeur :

linkage void *COTASKTHUNK_##name(void *arg, size_t arg_size) { \
    TASK_ARGS_TYPE(name) args_copy = { }; \
    memcpy(&args_copy, arg, arg_size); \
    COTASK_##name(&args_copy); \
    return NULL; \
} \
linkage void *COTASKTHUNKDELAY_##name(void *arg, size_t arg_size) { \
    TASK_ARGSDELAY(name) args_copy = { }; \
    memcpy(&args_copy, arg, arg_size); \
    if (args_copy.delay < 0) return NULL; \
    WAIT(args_copy.delay); \
    COTASK_##name(&args_copy.real_args); \
    return NULL; \
} \
linkage void *COTASKTHUNKCOND_##name(void *arg, size_t arg_size) { \
    TASK_ARGSCOND(name) args_copy = { }; \
    memcpy(&args_copy, arg, arg_size); \
    if (WAIT_EVENT(args_copy.event).event_status == CO_EVENT_SIGNALED || args_copy.unconditional) { \
        COTASK_##name(&args_copy.real_args); \
    } \
    return NULL; \
}

TASK_EVENTS

#define TASK_EVENTS

(

task

)

Valeur :

cotask_get_events(cotask_unbox(task))

TASK_HOST_ENT

#define TASK_HOST_ENT

(

)

Valeur :

cotask_host_entity(cotask_active())

TASK_HOST_EVENTS

#define TASK_HOST_EVENTS

(

events_array

)

Valeur :

    ({ \
    (events_array) = cotask_malloc(cotask_active(), sizeof(*(events_array))); \
    cotask_host_events(cotask_active(), sizeof(*events_array)/sizeof(CoEvent), &((events_array)->_first_event_)); \
})

TASK_IFACE_ARGS_SIZED_PTR_TYPE

#define TASK_IFACE_ARGS_SIZED_PTR_TYPE

(

iface

)

Valeur :

TASK_IFACE_NAME(iface, ARGS_SPTR)

TASK_IFACE_ARGS_TYPE

#define TASK_IFACE_ARGS_TYPE

(

iface

)

Valeur :

TASK_IFACE_NAME(iface, ARGS)

TASK_IFACE_NAME

#define TASK_IFACE_NAME	(		iface,
			suffix )

Valeur :

COTASKIFACE_##iface##_##suffix

TASK_IFACE_SARGS

#define TASK_IFACE_SARGS	(		iface,
			... )

Valeur :

((TASK_IFACE_ARGS_SIZED_PTR_TYPE(iface)) { \
    .size = sizeof(TASK_IFACE_ARGS_TYPE(iface)), \
    .ptr (&(TASK_IFACE_ARGS_TYPE(iface)) { __VA_ARGS__ }) \
})

TASK_INDIRECT

#define TASK_INDIRECT	(		iface,
			task )

Valeur :

    ( \
    (void)COTASK_UNUSED_CHECK_##task, \
    (TASK_INDIRECT_TYPE_ALIAS(task)) { ._cotask_##iface##_thunk = COTASKTHUNK_##task } \
)

TASK_INDIRECT_INIT

#define TASK_INDIRECT_INIT	(		iface,
			task )

Valeur :

{ ._cotask_##iface##_thunk = COTASKTHUNK_##task } \

TASK_INDIRECT_TYPE

#define TASK_INDIRECT_TYPE

(

iface

)

Valeur :

TASK_IFACE_NAME(iface)

TASK_INDIRECT_TYPE_ALIAS

#define TASK_INDIRECT_TYPE_ALIAS

(

task

)

Valeur :

TASK_IFACE_NAME(task, HANDLEALIAS)

TASK_MALLOC

#define TASK_MALLOC

(

size

)

Valeur :

cotask_malloc(cotask_active(), size)

TASK_WITH_INTERFACE

#define TASK_WITH_INTERFACE	(		name,
			iface )

Valeur :

DECLARE_TASK_WITH_INTERFACE(name, iface); \
DEFINE_TASK(name)

THIS_SCHED

#define THIS_SCHED   cotask_get_sched(cotask_active())

THIS_TASK

#define THIS_TASK   cotask_box(cotask_active())

WAIT

#define WAIT

(

delay

)

Valeur :

cotask_wait(delay)

WAIT_EVENT

#define WAIT_EVENT

(

e

)

Valeur :

cotask_wait_event(e)

WAIT_EVENT_ONCE

#define WAIT_EVENT_ONCE

(

e

)

Valeur :

cotask_wait_event_once(e)

WAIT_EVENT_OR_DIE

#define WAIT_EVENT_OR_DIE

(

e

)

Valeur :

cotask_wait_event_or_die(e)

YIELD

#define YIELD   cotask_yield(NULL)

Documentation des fonctions

DECLARE_EXTERN_TASK()

DECLARE_EXTERN_TASK	(	_cancel_task_helper	,
		{ BoxedTask task;}	)