#define _POSIX_C_SOURCE 200809L
#include <sys/wait.h>   /* waitpid */
#include <unistd.h>     /* close */
#include <string.h>     /* memcmp */
#include <fcntl.h>      /* fcntl, F_*, FD_* */
#include <err.h>
#include <errno.h>
#include <assert.h>

/* Občas je výhodné delší výpočet provádět asynchronně, tzn. tak,
 * aby zbytek programu mohl během výpočtu normálně pracovat (a
 * například reagovat na vnější události). Vaším úkolem bude
 * naprogramovat dvojici podprogramů ‹async_start› a ‹async_wait›,
 * které realizují takovýto asynchronní výpočet v pomocném procesu.
 * Pro jednoduchost bude vstupem a výstupem výpočtu jediné 64bitové
 * číslo.
 *
 * Podprogram ‹async_start› obdrží dva parametry:
 *
 *  • ‹func› je ukazatel na funkci, kterou chceme provést,
 *  • ‹arg› je 64bitové číslo, které bude vstupem pro ‹func›.
 *
 * Výsledkem ‹async_start› je ukazatel ‹handle›, který později
 * předáme podprogramu ‹async_wait› a obdržíme tak výsledek výpočtu.
 * Podprogram ‹async_wait› zároveň uvolní veškeré zdroje s ‹handle›
 * spojené.
 *
 * Není-li možné vytvořit nový proces, výsledkem ‹async_start› bude
 * nulový ukazatel. Výsledkem ‹async_wait› je v případě úspěchu 0,
 * jinak -1. Výsledek výpočtu je volajícímu předán výstupním
 * parametrem ‹result›. */

void *async_start( uint64_t ( *func )( uint64_t ), uint64_t arg );
int   async_wait( void *handle, uint64_t *result );

/* ┄┄┄┄┄┄┄ %< ┄┄┄┄┄┄┄┄┄┄ následují testy ┄┄┄┄┄┄┄┄┄┄ %< ┄┄┄┄┄┄┄ */

uint64_t slowpoke( uint64_t val )
{
    sleep( 5 );
    return val * 13;
}

int main( void )
{
    void *a_handle = async_start( slowpoke, 1 ),
         *b_handle = async_start( slowpoke, 2 ),
         *c_handle = async_start( slowpoke, 3 );

    alarm( 7 );

    uint64_t a_res, b_res, c_res;

    assert( async_wait( a_handle, &a_res ) == 0 );
    assert( async_wait( b_handle, &b_res ) == 0 );
    assert( async_wait( c_handle, &c_res ) == 0 );

    assert( a_res == 13 );
    assert( b_res == 26 );
    assert( c_res == 39 );

    return 0;
}