ZM:

ZM is C library to handle concurrency throught finite state machines.

It allow to create many concurrent tasks with small footprints that
interact with events or other tasks.

Task execution is splitted in code chunks, this allow
to suspend, resume, run step by step but also
raise, catch and also recover from an exceptions.

Library is written in C99 without external dependecy or
machine-specific code.

Portable:

ZM is implemented only with C control flow without any kind of
assembly code or non-local-jumps functions like setjump and ucontext.

ZM can be compiled in C99 without any requirements or in ansi-c,
ansi-c++ defining uint8_t and uint32_t if stdint.h is not
avaible.

Self-Contained:

It doesn't require any external, specific or non-standard
libraries, everything is inside two files: zm.h, zm.c.

Hello world:

#include <stdlib.h>
#include <zm.h>

ZMTASKDEF( mytask )
{
    ZMSTART

    zmstate 1:
        printf("my task: -init-\n");
        zmyield 2;

    zmstate 2:
        printf("my task: Hello world\n");
        zmyield zmTERM;

    zmstate ZM_TERM:
        printf("my task: -end-\n");

    ZMEND
}


int main()
{
    zm_VM *vm = zm_newVM("test VM");
    zm_State *s = zm_newTask(vm, mytask, NULL);
    zm_resume(vm, s, NULL);

    while(zm_go(vm, 1, NULL))
        printf("(step)\n");

    zm_freeTask(vm, s);
    zm_freeVM(vm);

    return 0;
}

Output:

my task: -init-
(step)
my task: Hello world
(step)
my task: -end-
(step)
(step)

This example define the task class mytask, instance task s and execute
it step by step. The zmyield operator break task execution and define
the next operation as change zmstate or term task. The same operator
can also be used to: suspend, wait other task, wait event, catch exception,
undo an exception ...

Hello (some) worlds:

#include <stdlib.h>
#include <string.h>
#include <zm.h>


ZMTASKDEF( He )
{
    char *self = zmdata;

    enum { HELLO = 1, VENUS_NOTE };

    ZMSTART

    zmstate ZM_INIT:
        printf("open connection from world %s\n", self);
        zmdata = self = strdup(self);
        zmyield zmDONE;

    zmstate HELLO:
        printf(" Hello from %s!\n", self);

        if (self[0] == 'V')
            zmyield VENUS_NOTE;

        zmyield zmTERM;

    zmstate VENUS_NOTE:
        printf("note by %s: It's warm here!\n", self);
        zmyield zmTERM;

    zmstate ZM_TERM:
        printf("close connection from word %s\n", self);
        free(self);

    ZMEND
}


int main()
{
    zm_VM *vm = zm_newVM("test VM");

    zm_resume(vm, zm_newTasklet(vm, He, "Earth"), NULL);
    zm_resume(vm, zm_newTasklet(vm, He, "Mars"), NULL);
    zm_resume(vm, zm_newTasklet(vm, He, "Venus"), NULL);
    zm_resume(vm, zm_newTasklet(vm, He, "Omicron Persei 8"), NULL);

    while(zm_go(vm, 1, NULL));

    zm_freeVM(vm);

    return 0;
}

This example instance 4 task and execute it:

open connection from world Earth
open connection from world Mars
open connection from world Venus
open connection from world Omicron Persei 8
 Hello from Earth!
 Hello from Mars!
 Hello from Venus!
 Hello from Omicron Persei 8!
close connection from word Earth
close connection from word Mars
note by Venus: It's warm here!
close connection from word Omicron Persei 8
close connection from word Venus

The idea behind ZM:

The idea behind ZM is to split code with switch-case
and use return to send directives to task manager as the
next block of code to execute or what the current task must
wait for.

For more detail see MANUAL.md.

Feature:

• Instance and execute tasks (green threads) with small memory footprint.
• Instance and execute subtask (iterator, coroutine).
• Tasks can be suspended, resumed, wait other tasks or events.
• Task can raise and catch exceptions.
• Task can raise, catch and unraise continuable exception (return to
  the point that signaled the exception).
• It is developed for event driven applications.

Levin:

This library has been created to give a concurrency model
to Levin server. Levin is an event driven server that store
keys with approximate search cababilities.

ZM is implemented to handle concurrency in Levin project. Levin is an event
driven server that store keys with approximate search cababilities.

References:

• Levin
• Continuations
• Coroutine
• Green thread
• VikBZ web comic.
• an implementation of coroutine in C by Simon Tatham.
• other coroutine libraries.