#define _POSIX_C_SOURCE 200809L

#include <assert.h>          /* assert */
#include <stdint.h>          /* uint64_t */
#include <stdlib.h>          /* exit */
#include <sys/wait.h>        /* waitpid */
#include <unistd.h>          /* fork, pipe */

/* Jednou ze základních technik distribuovaného počítání je
 * algoritmus map-reduce. V tomto příkladě si naprogramujeme jeho
 * zjednodušenou verzi.
 *
 * Parametry ‹reduce›:
 *
 *  • ‹combine› funkce, která sloučí dvě vstupní hodnoty,
 *  • ‹input› pole vstupních hodnot,
 *  • ‹count› počet vstupních hodnot,
 *  • ‹output› výstupní parametr pro výsledné číslo.
 *
 * Podprogram ‹reduce› bude opakovaně používat asociativní funkci
 * ‹combine› na vstupní hodnoty a mezivýsledky, dokud nevytvoří
 * jedinou hodnotu. Zároveň budeme předpokládat, že výpočet
 * ‹combine› je časově náročný a tedy bude výhodné tyto výpočty
 * provádět souběžně. K tomu využijeme samostatné procesy – můžete
 * použít pro každé volání jeden, nebo omezit celkový počet současně
 * spuštěných procesů konstantou. Dbejte na to, aby výpočet skutečně
 * probíhal ve více procesech zároveň (tzn. procesy na sebe zbytečně
 * nečekaly).
 *
 * Návratová hodnota bude 0 v případě, že výpočet proběhl bez chyby
 * do konce, jinak -1. */

int reduce( uint64_t ( *combine )( uint64_t, uint64_t ),
            const uint64_t *input, int count, uint64_t *output );

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

uint64_t add( uint64_t x, uint64_t y )
{
    return x + y;
}

int main( void )
{
    uint64_t arr[ 32 ];
    uint64_t result = 42;

    for ( unsigned i = 0; i < 32; ++ i )
        arr[ i ] = i;

    assert( reduce( add, arr, 32, &result ) == 0 );
    assert( result == 496 );

    assert( reduce( add, arr, 23, &result ) == 0 );
    assert( result == 253 );
    return 0;
}