contributed by < RZHuangjeff
>
linux2021
This is a program that helps to handle coroutines of a process. With coroutine, a program can switch to other routine while the current executing routine is waiting for certain conditions happend, rather than blocks entire program. To be able to resume the execution point of former routine, a GCC extension called Labels as Values performs the key role, since it allows the address of a label being saved and jump (goto
) to it later, via saved address.
The typical use case of coroutine is to maintain I/O operations between different input sources and ouput destinations. Just like the example shown in the quiz, which handles I/O operations between standard I/O and a socket, those operations are executed simultaneously, which means that block waiting on standard input will not cause reading from socket being blocked.
For the example shown in quiz, a wait on a condition is performed by macro cr_wait
, once the condition that it waits for has not happened yet, this macro will return from the current function after address of the checkpoint, a unique label generated automaticaly, is saved. While that function is invoked later, macro cr_begin
will realize that a checkpoint was saved and will jump to that checkpoint to resume execution. By wrapping several routines that should be executed simultaneously in a loop, next routine will be invoked while previous one is waiting.
commit c8d6f79
The original version of coroutine implemented in quiz 5 has basic functions that performs coroutine, but there are several cons I discovered:
misuse macros
With the origin definition of macros, one may writes program as following:
which may lead to unexpected result since once the condition being waited in line 10 has not happened yet, the program will return from main_loop
, rather than execute next routine, although such program makes sence.
To avoid such misusing, using of such macros should be limited in particular functions. To fulfill that, the argument o
of all macros that should be limited are removed, instead, the context of coroutine mentioned in those macros is hardcoded as __ct
. A macro cr_func_def
is introduced that is used when someone wants to define a coroutine function, those functions contain a single argument named __ct
that represents context corresponding to that routine. Following is definition of cr_func_def
macro:
And one may define a routine like:
With these changes, compiler will report errors for the program shown above.
cr_context
and cr_run
The macro cr_context
helps to declare a struct cr
variable, which acts as context of specific coroutine.
The macro cr_run
is a wrapper that wraps invocation of coroutine function with its context. If there is no declaration of such coroutine or context for such coroutine, a compilation error will be reported, this helps one to make sure that all required job was done.
Following are definitions of macros mentioned above:
field local
In the definition of struct cr
, we can find that there is a pointer named local
, which is declared but not used.
Since we have introduced a series of macro that help defining routine functions, with this definition of routine function, there is no way to pass arguments to these functions. To deal with such problem, the macro cr_init
is modified and renamed as cr_context_init
which accepts a pointer that will be assigned to local
.
To reference variable that is pointed by local
, one may use one of following two macros: cr_priv_var
or cr_grab_priv_var
, the first macro will cast __ct->local
to a pointer of given type, while second one will return a pointer that points to the given field with in the structure that __cr->local
points to. Following are definitions of those macros:
cr_local
macro
A macro cr_local
is introduced to wrap declaration of static local variables, which aims to highlight that such variable is a part of coroutine. Following is definition of cr_local
: