int fas(address * location, int replacement) {
        int old = *location;
        *location = replacement;
        return old;
}

int cas(address location, int compare, int replacement) {
    int old = *location;
    if(*location == compare) {
        *location = replacement;
    }
    return old;
}

Guard guard = ...; // Shared
...
Job * job = ...
Job * cur;
if (NULL != (cur = guard.vouch(job))) do {
    run(cur);
} while (NULL != (cur = guard.clear()));

Element * vouch (Element * item) {
    item->next = NULL ;
    Element * last = FAS(_tail, item ); // V1
    if (last && CAS (last->_next, NULL, item )) // V2
        return NULL ;
    _head = item ; // V3
    return item ;
}

Element * clear() {
    Element * item = _head;
    Element * next = FAS(item->_next, DONE); // C1
    if (!next)
        CAS(_tail , item, NULL); // C2
    CAS(_head, item, next);  // C3
    return next ;
}

function sum(xPromise, yPromise) {
    return Promise.all([xPromise, yPromise])
    .then(function(values) {
        return values[0] + values[1];
    } );
}

sum(fetchX(), fetchY())
.then(function(sum) {
    console.log(sum);
});

#include <iostream>
#include <thread>
#include <future>

void initiazer(std::promise<int> * promiseObject)
{
    std::cout << "Inside Thread" << std::endl;
    promiseObject->set_value(35);
}

int main()
{
    std::promise<int> promiseObj;
    std::future<int> futureObject = promiseObj.get_future();
    std::thread thread(initiazer, &promiseObj);
    std::cout << futureObject.get() << std::endl;
    thread.join();
    return 0;
}

typedef struct
{
    chain_t* next;
} chain_t;

typedef struct
{
    chain_t* head;
    chain_t* tail;
} guard_t;

typedef struct
{
    chain_t* head;
    chain_t* tail;
    sleep_t wait;
} actor_t;

void guard_setup(guard_t* self)
{
    self->head = self->tail = NULL;
}

chain_t* guard_vouch(guard_t* self, chain_t* item)
{
    item->next = NULL;
    chain_t* last = FAS(&self->tail, item); // V1
    if (last)
    {
        if (CAS(&last->next, NULL, item)) // V2
            return NULL;
        // last->next == DONE
    }
    self->head = item; // V3
    return item;
}

chain_t* guard_clear(guard_t* self)
{
    chain_t* item = self->head; // C1
    // item != NULL
    chain_t* next = FAS(&item->next, DONE); // C2
    if (!next)
        CAS(&self->tail, item, NULL); // C3
    CAS(&self->head, item, next); // C4
    return next;
}

template<typename T>
static T fas(volatile T & value, volatile T replacement) {
    ASM("lock xchgl %1, %2" : "=a"(replacement) : "a"(replacement), "m"(value) : "memory");
    return replacement;
}

// EPOS CAS Component Test Program

#include <utility/ostream.h>
#include <architecture/ia32/cpu.h>

using namespace EPOS;
OStream cout;

int main()
{
    cout << endl << "Welcome to the CPU::cas() instruction test!" << endl;
    int original = 5;
    int compare = 5;
    int replacement = 6;
    int replaced;

    cout << "original=" << original
            << ", compare=" << compare
            << ", replacement=" << replacement
            << ", replaced=" << replaced
            << endl;

    replaced = CPU::cas(original, compare, replacement);

    cout << "original=" << original
            << ", compare=" << compare
            << ", replacement=" << replacement
            << ", replaced=" << replaced
            << endl;

    cout << "The CPU::cas() instruction set ran successfully!" << endl << endl;
}

Welcome to the CPU::cas() instruction test!
original=5, compare=5, replacement=6, replaced=0
original=6, compare=5, replacement=6, replaced=5
The CPU::cas() instruction set ran successfully!

The last thread has exited!
Rebooting the machine ...

class Critical_Section
{
public:
    friend class Guard;
    typedef Handler::Function Function;
    typedef List_Elements::Singly_Linked<Critical_Section> Element;

public:
    Critical_Section(Function * h): _handler(h), _link(this) {}
    ~Critical_Section() {}

    void operator()() { _handler(); }
    void run()        { _handler(); } // Alias for ()

private:
    Function * _handler;
    Element _link; // Inspired by the thread code
};

// Simple List Element
template<typename T>
class Singly_Linked
{
public:
    friend class _UTIL::Guard;
    typedef T Object_Type;
    typedef Singly_Linked Element;

public:
    Singly_Linked(const T * o): _object(o), _next(0) {}

    T * object() const { return const_cast<T *>(_object); }

    Element * next() const { return _next; }
    void next(Element * e) { _next = e; }

private:
    const T * _object;
    Element * _next;
};

class Guard
{
public:
   typedef Closure::Element Element;

private:
   static const int NULL = 0;
   static const int DONE = 1;

public:
   Guard();
   ~Guard();

   void submit(Closure * cs);
   Element * vouch(Element * item);
   Element * clear();

private:
   Element * _head;
   Element * _tail;
};

// Object Methods
Guard::Guard(): _head(0), _tail(0) {
    DB( Synchronizer, TRC, "Guard(head=" << _head << ", tail=" << _tail
            << ") => " << this << endl )
}

Guard::~Guard() {
    DB( Synchronizer, TRC, "~Guard(this=" << this << ")" << endl )
}

void Guard::submit(Closure * cs)
{
   Element * cur = vouch(&(cs->_link));
   if (cur != NULL) do {
       cur->object()->run();
       cur = clear();
   } while (cur != NULL);
}

Guard::Element * Guard::vouch(Element * item)
{
    DB( Synchronizer, TRC, "Guard::vouch(this=" << this
            << " head=" << _head << " tail=" << _tail
            << " item=" << item << ", size=" << CPU::finc(_size) + 1 )

    item->next(reinterpret_cast<Element *>(NULL));
    Element * last = CPU::fas(_tail, item);
    DB( Synchronizer, TRC, ", last=" << last << ")" << endl )

    if (last) {
        if (CPU::cas(last->_next, reinterpret_cast<Element *>(NULL), item)
                    == reinterpret_cast<Element *>(NULL))

            return reinterpret_cast<Element *>(NULL);
        delete last->object();
    }
    _head = item;
    return item;
}

Guard::Element * Guard::clear()
{
    DB( Synchronizer, TRC, "Guard::clear(this=" << this
            << " head=" << _head << " tail=" << _tail
            << ", size=" << CPU::fdec(_size) - 1 )

    Element * item = _head;
    Element * next = CPU::fas(item->_next, reinterpret_cast<Element *>(DONE));
    DB( Synchronizer, TRC, ", next=" << next << ")" << endl )

    bool mine = true;
    if (!next)
        mine = CPU::cas(_tail, item, reinterpret_cast<Element *> (NULL)) == item;

    CPU::cas(_head, item, next);
    if (mine)
        delete item->object();

    return next;
}

// /include/archtecture/ia_32/cpu.h
template<typename T>
static T fas(volatile T & value, volatile T replacement)
{
    ASM("lock xchgl %1, %2" : "=a"(replacement) : "a"(replacement), "m"(value) : "memory");
    return replacement;
}

// /include/cpu.h
static int fas(volatile int & value, volatile int & replacement) {
     int old = value;
     value = replacement;
     return old;
 }

// EPOS Debug Utility Declarations

#include <utility/debug.h>
#include <semaphore.h>

#ifndef __debug_sync_h
#define __debug_sync_h

// You can define it anywhere before including this file
// #define DEBUG_SYNC

#ifdef DEBUG_SYNC

__BEGIN_UTIL
    Semaphore _debug_syncronized_semaphore_lock;
__END_UTIL

    // A debug function cannot call this recursively, otherwise a deadlock happens.
    // Unless you replace the `_debug_syncronized_semaphore_lock` by a recursive
    // semaphore or mutex. See:
    // https://stackoverflow.com/questions/36619715/a-shared-recursive-mutex-in-standard-c
    #define DB(name,level,...) do { \
        _debug_syncronized_semaphore_lock.lock(); \
            db<name>(level) << __VA_ARGS__; \
        _debug_syncronized_semaphore_lock.unlock(); } while(0);

#else
    #define DB(name,level,...) db<name>(level) << __VA_ARGS__;

#endif

#define LOG(...) DB(Debug, WRN, __VA_ARGS__)

#endif

class StringStream;

...
    // Implemented on `ostream.cc`, because `stringstream.h` includes `ostream.h`,
    // hence, `ostream.h` cannot include `stringstream.h` back (cyclic reference)
    OStream & operator<<(const StringStream * stream);

    // // ostream.cc
    // #include <utility/stringstream.h>
    //
    // OStream & OStream::operator<<(const StringStream * stream)
    // {
    //     return operator<<(stream->buffer());
    // }

private:
    virtual void print(const char * s) { _print(s); }

EPOS bootable image tool

  EPOS mode: library
  Machine: pc
  Model: legacy_pc
  Processor: ia32 (32 bits, little-endian)
  Memory: 262144 KBytes
  Boot Length: 512 - 512 (min - max) KBytes
  Node id: will get from the network
  EPOS Image UUID: 7bb9c483078f0692
  Creating EPOS bootable image in "scheduler_cpu_affinity_test.img":
    Adding boot strap "/Epos2x86/img/pc_boot": done.
    Adding setup "/Epos2x86/img/pc_setup": done.
    Adding application "scheduler_cpu_affinity_test": done.
    Adding system info: done.

  Adding specific boot features of "pc": done.

  Image successfully generated (172868 bytes)!

make[2]: Leaving directory '/Epos2x86/img'
(cd img && make --print-directory run)
make[2]: Entering directory '/Epos2x86/img'
# qemu-system-i386 -smp 2 -m 262144k -nographic -no-reboot -drive format=raw,index=0,if=floppy,file=scheduler_cpu_affinity_test.img | tee scheduler_cpu_affinity_test.out
qemu-system-i386 -smp 2 -m 262144k -nographic -no-reboot -drive format=raw,index=0,if=floppy,file=scheduler_cpu_affinity_test.img
<0>: make[2]: Leaving directory '/Epos2x86/img'
make[1]: Leaving directory '/home/linux/OperatingSystems/Epos2x86'

template<class StreamType>
class OStream_Base
{
public:
    struct Begl {};
    struct Endl {};

    struct Hex {};
    struct Dec {};
    struct Oct {};
    struct Bin {};

public:
    OStream_Base(): _base(10) {}

    StreamType& operator<<(const Hex & hex) {
        _set_base(16);
        return *static_cast<StreamType*>(this);
    }
    StreamType& operator<<(const Dec & dec) {
        _set_base(10);
        return *static_cast<StreamType*>(this);
    }
    StreamType& operator<<(const Oct & oct) {
        _set_base(8);
        return *static_cast<StreamType*>(this);
    }
    StreamType& operator<<(const Bin & bin) {
        _set_base(2);
        return *static_cast<StreamType*>(this);
    }

    StreamType& operator<<(char c) {
        char buf[2];
        buf[0] = c;
        buf[1] = '\0';
        print(buf);
        return *static_cast<StreamType*>(this);
    }
    StreamType& operator<<(unsigned char c) {
        return operator<<(static_cast<unsigned int>(c));
    }

    StreamType& operator<<(int i) {
        char buf[64];
        buf[itoa(i, buf)] = '\0';
        print(buf);
        return *static_cast<StreamType*>(this);
    }
    StreamType& operator<<(short s) {
        return operator<<(static_cast<int>(s));
    }
    StreamType& operator<<(long l) {
        return operator<<(static_cast<int>(l));
    }

    StreamType& operator<<(unsigned int u) {
        char buf[64];
        buf[utoa(u, buf)] = '\0';
        print(buf);
        return *static_cast<StreamType*>(this);
    }
    StreamType& operator<<(unsigned short s) {
        return operator<<(static_cast<unsigned int>(s));
    }
    StreamType& operator<<(unsigned long l) {
        return operator<<(static_cast<unsigned int>(l));
    }

    StreamType& operator<<(long long int u) {
        char buf[64];
        buf[llitoa(u, buf)] = '\0';
        print(buf);
        return *static_cast<StreamType*>(this);
    }

    StreamType& operator<<(unsigned long long int u) {
        char buf[64];
        buf[llutoa(u, buf)] = '\0';
        print(buf);
        return *static_cast<StreamType*>(this);
    }

    StreamType& operator<<(const void * p) {
        char buf[64];
        buf[ptoa(p, buf)] = '\0';
        print(buf);
        return *static_cast<StreamType*>(this);
    }

    StreamType& operator<<(const char * s) {
        print(s);
        return *static_cast<StreamType*>(this);
    }

    StreamType& operator<<(float f) {
        if(f < 0.0001f && f > -0.0001f)
            (*this) << "0.0000";

        int b = 0;
        int m = 0;

        float x = f;
        if(x >= 0.0001f) {
            while(x >= 1.0000f) {
                x -= 1.0f;
                b++;
            }
            (*this) << b << ".";
            for(int i = 0; i < 3; i++) {
                m = 0;
                x *= 10.0f;
                while(x >= 1.000f) {
                    x -= 1.0f;
                    m++;
                }
                (*this) << m;
            }
        } else {
            while(x <= -1.000f) {
                x += 1.0f;
                b++;
            }
            (*this) << "-" << b << ".";
            for(int i = 0; i < 3; i++) {
                m = 0;
                x *= 10.0f;
                while(x <= -1.000f) {
                    x += 1.0f;
                    m++;
                }
                (*this) << m;
            }
        }
        return *static_cast<StreamType*>(this);
    }

protected:
    int itoa(int v, char * s)
    {
        unsigned int i = 0;

        if(v < 0) {
            v = -v;
            s[i++] = '-';
        }

        return utoa(static_cast<unsigned int>(v), s, i);
    }

    int utoa(unsigned int v, char * s, unsigned int i = 0)
    {
        unsigned int j;

        if(!v) {
            s[i++] = '0';
            return i;
        }

        if(v > 256) {
            if(_base == 8 || _base == 16)
                s[i++] = '0';
            if(_base == 16)
                s[i++] = 'x';
        }

        for(j = v; j != 0; i++, j /= _base);
        for(j = 0; v != 0; j++, v /= _base)
            s[i - 1 - j] = _digits[v % _base];

        return i;
    }

    int llitoa(long long int v, char * s)
    {
        unsigned int i = 0;

        if(v < 0) {
            v = -v;
            s[i++] = '-';
        }

        return llutoa(static_cast<unsigned long long int>(v), s, i);
    }

    int llutoa(unsigned long long int v, char * s, unsigned int i = 0)
    {
        unsigned long long int j;

        if(!v) {
            s[i++] = '0';
            return i;
        }

        if(v > 256) {
            if(_base == 8 || _base == 16)
                s[i++] = '0';
            if(_base == 16)
                s[i++] = 'x';
        }

        for(j = v; j != 0; i++, j /= _base);
        for(j = 0; v != 0; j++, v /= _base)
            s[i - 1 - j] = _digits[v % _base];

        return i;
    }

    int ptoa(const void * p, char * s)
    {
        unsigned int j, v = reinterpret_cast<unsigned int>(p);

        s[0] = '0';
        s[1] = 'x';

        for(j = 0; j < sizeof(void *) * 2; j++, v >>= 4)
            s[2 + sizeof(void *) * 2 - 1 - j]
                = _digits[v & 0xf];

        return j + 2;
    }

    // https://stackoverflow.com/questions/34222703/how-to-override-static-method
    inline void print(const char * s)
        { StreamType::print(static_cast<StreamType*>(this), s); }

    inline void _set_base(int v) { _base = v; }

    int _base;
    static const char _digits[];
};

// Class Attributes
// https://stackoverflow.com/questions/3531060/how-to-initialize-a-static-const-member
template<class OStream>
const char OStream_Base<OStream>::_digits[] = "0123456789abcdef";

// https://stackoverflow.com/questions/11761506/inheritance-function-that-returns-self-type
class OStream : public OStream_Base<OStream>
{
public:
    struct Err {};

public:
    OStream(): _error(false) {}

    // Implemented on `ostream.cc`, because `stringstream.h` includes `ostream.h`,
    // hence, `ostream.h` cannot include `stringstream.h` back (cyclic reference)
    OStream & operator<<(const StringStream * stream);

    OStream & operator<<(const Begl & begl) {
        if(Traits<System>::multicore)
            _print_preamble();
        return *this;
    }

    OStream & operator<<(const Endl & endl) {
        if(Traits<System>::multicore)
            _print_trailler(_error);
        OStream_Base<OStream>::print("\n");
        _set_base(10);
        return *this;
    }

    OStream & operator<<(const Err & err) {
        _error = true;
        return *this;
    }

    using OStream_Base<OStream>::operator<<;

    // Adding virtual to the print() function caused EPOS to completely break
    static void print(OStream* that, const char * s) { _print(s); }

private:
    volatile bool _error;
};

class StringStream : public OStream_Base<StringStream>
{
private:
    char* _buffer;
    unsigned int _last_position;
    const unsigned int _buffer_size;

public:
    StringStream(const unsigned int _buffer_size) :
            _last_position(0), _buffer_size(_buffer_size)
    {
        DB( Synchronizer, TRC, "StringStream::StringStream(_buffer_size="
                << _buffer_size << ") => " << reinterpret_cast<int *>(this) << endl )

        assert(_buffer_size > 0);
        _buffer = new char[_buffer_size];
    }

    ~StringStream() {
        DB( Synchronizer, TRC, "StringStream::~StringStream(this="
                << reinterpret_cast<int *>(this) << ", _buffer="
                << reinterpret_cast<int *>(_buffer) << ")" << endl )

        delete _buffer;
    }

    const char * const buffer() const {
        return _buffer;
    }

    StringStream & operator<<(const StringStream & stream) {
        OStream_Base<StringStream>::print(stream.buffer());
        return *this;
    }
    StringStream & operator<<(const StringStream * stream) {
        OStream_Base<StringStream>::print(stream->buffer());
        return *this;
    }

    static void print(StringStream* that, const char* string) {
        DB( Synchronizer, TRC, "StringStream::print(this="
                << reinterpret_cast<int *>(that)
                << "), string=" << string << ", " )

        unsigned int string_size = strlen(string);
        unsigned int total_size = string_size + that->_last_position;

        DB( Synchronizer, TRC, "string_size=" << string_size << ", "
                << "total_size=" << total_size )

        // https://linux.die.net/man/3/strncpy
        if( total_size >= that->_buffer_size ) {
            total_size = that->_buffer_size - 1;

            strncpy(&that->_buffer[that->_last_position],
                    string, total_size - that->_last_position);

            that->_buffer[total_size] = '\0';
        }
        else {
            strcpy(&that->_buffer[that->_last_position], string);
        }

        that->_last_position = total_size;
        DB( Synchronizer, TRC, ", _last_position=" << that->_last_position
                << ", _buffer=" << that->_buffer << endl )
    }

public:
    StringStream & operator<<(const Begl & begl) {
        return *this;
    }

    StringStream & operator<<(const Endl & endl) {
        OStream_Base<StringStream>::print("\n");
        _set_base(10);
        return *this;
    }

    using OStream_Base<StringStream>::operator<<;
};

// EPOS Semaphore Component Test Program
#define DEBUG_SYNC

#include <utility/stringstream.h>
using namespace EPOS;

int main()
{
    LOG( endl )
    LOG( "Welcome to the `stringstream.h` test program" << endl )

    StringStream stream48chars{50};
    StringStream stream49chars{50};
    StringStream stream50chars{50};
    StringStream stream51chars{50};

    stream48chars << "666666666666666666666666666666666666666666660048";
    stream49chars << "6666666666666666666666666666666666666666666600049";
    stream50chars << "66666666666666666666666666666666666666666666000050";
    stream51chars << "666666666666666666666666666666666666666666660000051";

    LOG( &stream48chars << endl )
    LOG( &stream49chars << endl )
    LOG( &stream50chars << endl )
    LOG( &stream51chars << endl << endl )

    StringStream base23chars{50};
    StringStream stream48chars2{50};
    StringStream stream49chars2{50};
    StringStream stream50chars2{50};
    StringStream stream51chars2{50};

    base23chars    << "77777777777777777777777";
    stream48chars2 << base23chars << "8888888888888888888880048";
    stream49chars2 << base23chars << "88888888888888888888800049";
    stream50chars2 << base23chars << "888888888888888888888000050";
    stream51chars2 << base23chars << "8888888888888888888880000051";

    LOG( &stream48chars2 << endl )
    LOG( &stream49chars2 << endl )
    LOG( &stream50chars2 << endl )
    LOG( &stream51chars2 << endl )

    return 0;
}

Welcome to the `stringstream.h` test program
666666666666666666666666666666666666666666660048
6666666666666666666666666666666666666666666600049
6666666666666666666666666666666666666666666600005
6666666666666666666666666666666666666666666600000

777777777777777777777778888888888888888888880048
7777777777777777777777788888888888888888888800049
7777777777777777777777788888888888888888888800005
7777777777777777777777788888888888888888888800000

# How can I write a makefile to auto-detect and parallelize the build with GNU Make?
# https://stackoverflow.com/questions/2527496/how-can-i-write-a-makefile-to-auto
ifeq ($J,)
    ifeq ($(OS),Windows_NT)
        NPROCS := $(NUMBER_OF_PROCESSORS)
    else
        ifeq ($(UNAME),Darwin)
          NPROCS := $(shell sysctl -n hw.ncpu)
        else
          NPROCS := $(shell grep -c ^processor /proc/cpuinfo)
        endif
    endif
else
  NPROCS := ""
endif
all:
    ${MAKE} all_multithread -j$(NPROCS)
all_multithread: $(SUBDIRS)

clean:
    ${MAKE} clean_multithread -j$(NPROCS)
clean_multithread:

(cd app && make --print-directory)
make[2]: Entering directory '/Epos2x86/app'
/Epos2x86/bin/eposcc -Wa,--32 -c -ansi -O2  -o guard_semaphore_test.o guard_semaphore_test.cc
/Epos2x86/bin/eposcc --library --gc-sections --nmagic -o guard_semaphore_test guard_semaphore_test.o
/Epos2x86/lib/pc_init_system.o: In function `global constructors keyed to _ZN4EPOS1S11init_systemE':
init_system.cc:(.text._GLOBAL__I__ZN4EPOS1S11init_systemE+0xe5): undefined reference to `EPOS::S::System::init()'
makefile:8: recipe for target 'guard_semaphore_test' failed
make[2]: Leaving directory '/Epos2x86/app'
make[2]: *** [guard_semaphore_test] Error 1
makefile:17: recipe for target 'app' failed
make[1]: Leaving directory '/home/linux/OperatingSystems/Epos2x86'
make[1]: *** [app] Error 2
makefile:23: recipe for target 'run' failed
make: *** [run] Error 2

// Somewhere on the new operator, it is being called enable() and disable() CPU interrupt
if(Traits<MMU>::colorful && color != WHITE)
    _stack = new (color) char[stack_size];
else
    _stack = new (SYSTEM) char[stack_size];

static void int_enable()
{
    if( int_disabled() )
    {
        if( _not_reenable == 0 ) {
            ASM("sti");
        }
        else {
            _not_reenable -= 1;
        }
    }
}

static void int_disable()
{
    if( int_enabled() ) {
        ASM("cli");
    }
    else {
        _not_reenable += 1;
    }
}

Date:   Tue Nov 13 16:55:14 2018 -0200
    Enabled asserts on config.h

diff --git a/include/system/config.h b/include/system/config.h
index 23e2476..83b045b 100644
--- a/include/system/config.h
+++ b/include/system/config.h
@@ -71,8 +71,8 @@ namespace EPOS {
 //============================================================================
 // ASSERT (for pre and post conditions)
 //============================================================================
-//#define assert(expr)    ((expr) ? static_cast<void>(0) : Assert::fail (#expr, __FILE__, __LINE__, __PRETTY_FUNCTION__))
-#define assert(expr)    (static_cast<void>(0))
+#define assert(expr)    ((expr) ? static_cast<void>(0) : Assert::fail (#expr, __FILE__, __LINE__, __PRETTY_FUNCTION__))
+// #define assert(expr)    (static_cast<void>(0))

 //============================================================================
 // CONFIGURATION


Date:   Tue Nov 13 16:55:03 2018 -0200
    Make the debug.h assert messages more visible

diff --git a/include/utility/debug.h b/include/utility/debug.h
index 6508d48..ade97f7 100644
--- a/include/utility/debug.h
+++ b/include/utility/debug.h
@@ -116,7 +116,7 @@ class Assert
 {
 public:
     static void fail(const char * __assertion, const char * __file, unsigned int __line, const char * __function) {
-        db<void>(ERR) << "Assertion fail: " << __assertion << ", function=" << __function << ", file=" << __file << ", line=" << __line << endl;
+        db<void>(ERR) << endl << endl << "Assertion fail: " << __assertion << ", function=" << __function << ", file=" << __file << ", line=" << __line << endl << endl;
     }
 };


Date:   Tue Nov 13 16:51:29 2018 -0200
    Fixed tstp.h:1255: error: incomplete type 'EPOS::S::Cipher' used in
    nested name specifier.

diff --git a/include/tstp.h b/include/tstp.h
index cd593d1..8cbfbc3 100644
--- a/include/tstp.h
+++ b/include/tstp.h
@@ -1251,7 +1251,8 @@ public:

             db<TSTP>(INF) << "Node ID: " << _id << endl;

-            assert(Cipher::KEY_SIZE == sizeof(Node_ID));
+            // There is not cipher.h header
+            // assert(Cipher::KEY_SIZE == sizeof(Node_ID));
             _cipher.encrypt(_id, _id, _auth);
         }
         ~Security();


Date:   Tue Nov 13 16:20:05 2018 -0200
    Fixed ic.h:503: error: array subscript is above array bounds

diff --git a/include/machine/pc/ic.h b/include/machine/pc/ic.h
index 49c8f00..4aabea4 100644
--- a/include/machine/pc/ic.h
+++ b/include/machine/pc/ic.h
@@ -499,8 +499,11 @@ public:
     static void int_vector(const Interrupt_Id & i, const Interrupt_Handler & h) {
         db<IC>(TRC) << "IC::int_vector(int=" << i << ",h=" << reinterpret_cast<void *>(h) <<")" << endl;
         assert(i < INTS);
+        // When enabling the asserts expressions, the compiler keeps complaining about
         // WARNING: in static member function 'static void EPOS::S::FPGA::init()': error: array subscript is above array bounds
-        _int_vector[i] = h;
+        // Then, do some hack to overrule it  and let the above assert() do its thing on runtime.
+        unsigned int index = i >= INTS ? INTS - 1 : i;
+        _int_vector[index] = h;
     }

     static void enable() {


Date:   Tue Nov 13 16:14:31 2018 -0200
    Fixed pmu.h:602: assert error: comparison between signed and unsigned
    integer expressions

diff --git a/include/architecture/ia32/pmu.h b/include/architecture/ia32/pmu.h
index e8f7cc7..7184c17 100644
--- a/include/architecture/ia32/pmu.h
+++ b/include/architecture/ia32/pmu.h
@@ -599,7 +599,7 @@ public:
     Intel_Sandy_Bridge_PMU() {}

     static bool config(const Channel & channel, const Event & event, const Flags & flags = NONE) {
-        assert((channel < CHANNELS) && (event < EVENTS));
+        assert((channel < CHANNELS) && (static_cast<unsigned int>(event) < EVENTS));
         db<PMU>(TRC) << "PMU::config(c=" << channel << ",e=" << event << ",f=" << flags << ")" << endl;

         if(((channel == 0) && (event != INSTRUCTION)) || ((channel == 1) && (event != DVS_CLOCK)) || ((channel == 2) && (event != CLOCK))) {


Date:   Tue Nov 13 16:11:18 2018 -0200
    Fixed assert error: 'i' was not declared in this scope on ic.h

diff --git a/include/machine/pc/ic.h b/include/machine/pc/ic.h
index a85fbcb..49c8f00 100644
--- a/include/machine/pc/ic.h
+++ b/include/machine/pc/ic.h
@@ -505,7 +505,7 @@ public:

     static void enable() {
         db<IC>(TRC) << "IC::enable()" << endl;
-        assert(i < INTS);
+        // assert(i < INTS);
         Engine::enable();
     }

@@ -517,7 +517,7 @@ public:

     static void disable() {
         db<IC>(TRC) << "IC::disable()" << endl;
-        assert(i < INTS);
+        // assert(i < INTS);
         Engine::disable();
     }


Date:   Thu Nov 15 16:01:15 2018 -0200
    Fixed the thread.cc constructor not being atomic while building
    EPOS with multiple CPUs.
diff --git a/include/architecture/ia32/cpu.h b/include/architecture/ia32/cpu.h
index d6d51d2..1ced73e 100644
--- a/include/architecture/ia32/cpu.h
+++ b/include/architecture/ia32/cpu.h
@@ -313,8 +313,29 @@ public:
     static Hertz clock() { return _cpu_clock; }
     static Hertz bus_clock() { return _bus_clock; }

-    static void int_enable() { ASM("sti"); }
-    static void int_disable() { ASM("cli"); }
+    static void int_enable()
+    {
+        if( int_disabled() )
+        {
+            if( _not_reenable == 0 ) {
+                ASM("sti");
+            }
+            else {
+                _not_reenable -= 1;
+            }
+        }
+    }
+
+    static void int_disable()
+    {
+        if( int_enabled() ) {
+            ASM("cli");
+        }
+        else {
+            _not_reenable += 1;
+        }
+    }
+
     static bool int_enabled() { return (flags() & FLAG_IF); }
     static bool int_disabled() { return !int_enabled(); }

@@ -624,6 +645,7 @@ private:
     static void init();

 private:
+    static int _not_reenable;
     static unsigned int _cpu_clock;
     static unsigned int _bus_clock;
 };
diff --git a/src/architecture/ia32/cpu.cc b/src/architecture/ia32/cpu.cc
index 8357fa0..e712aa2 100644
--- a/src/architecture/ia32/cpu.cc
+++ b/src/architecture/ia32/cpu.cc
@@ -8,6 +8,7 @@ extern "C" { void _exec(void *); }
 __BEGIN_SYS

 // Class attributes
+int CPU::_not_reenable = 0;
 unsigned int CPU::_cpu_clock;
 unsigned int CPU::_bus_clock;

diff --git a/src/component/thread.cc b/src/component/thread.cc
index 9495641..27dd942 100644
--- a/src/component/thread.cc
+++ b/src/component/thread.cc
@@ -26,6 +26,7 @@ void Thread::constructor_prologue(const Color & color, unsigned int stack_size)
     _thread_count++;
     _scheduler.insert(this);

+    // Somewhere on the new operator, it is being called enable() and disable() CPU interrupt
     if(Traits<MMU>::colorful && color != WHITE)
         _stack = new (color) char[stack_size];
     else
@@ -50,10 +51,14 @@ void Thread::constructor_epilogue(const Log_Addr & entry, unsigned int stack_siz
     if((_state != READY) && (_state != RUNNING))
         _scheduler.suspend(this);

-    if(preemptive && (_state == READY) && (_link.rank() != IDLE))
+    if(preemptive && (_state == READY) && (_link.rank() != IDLE)) {
+        db<Scheduler<Thread> >(TRC) << "Thread::constructor_epilogue(locked=" << locked() << ")" << endl;
+        assert(locked());
         reschedule(_link.rank().queue());
-    else
+    }
+    else {
         unlock();
+    }
 }


@@ -124,6 +129,9 @@ void Thread::priority(const Priority & c)
     }

     if(preemptive) {
+        db<Scheduler<Thread> >(TRC) << "Thread::priority(locked=" << locked() << ")" << endl;
+        assert(locked());
+
         reschedule(old_cpu);
         if(smp) {
             lock();
@@ -312,6 +320,7 @@ void Thread::wakeup_all(Queue * q)
 void Thread::reschedule()
 {
     db<Scheduler<Thread> >(TRC) << "Thread::reschedule()" << endl;
+    db<Scheduler<Thread> >(TRC) << "Thread::reschedule(locked=" << locked() << ")" << endl;

     // lock() must be called before entering this method
     assert(locked());
@@ -325,6 +334,10 @@ void Thread::reschedule()

 void Thread::reschedule(unsigned int cpu)
 {
+    db<Scheduler<Thread> >(TRC) << "Thread::reschedule(cpu=" << cpu << ")" << endl;
+    db<Scheduler<Thread> >(TRC) << "Thread::reschedule(locked=" << locked() << ")" << endl;
+    assert(locked());
+
     if(!smp || (cpu == Machine::cpu_id()))
         reschedule();
     else {
@@ -338,6 +351,8 @@ void Thread::reschedule(unsigned int cpu)
 void Thread::rescheduler(const IC::Interrupt_Id & interrupt)
 {
     lock();
+    // if( Traits<IC>::dispatch_debugged )
+    db<Synchronizer>(TRC) << "Thread::rescheduler(interrupt=" << interrupt << ")" << endl;

     reschedule();
 }

// EPOS Guard Component Declarations

#ifndef __future_h
#define __future_h

#include <semaphore.h>
#include <condition.h>
#include <utility/debug_sync.h>

__BEGIN_UTIL

template<typename FutureType>
class Future
{
public:
    Future(): _is_resolved(false), _condition()  {
        DB( Synchronizer, TRC, "Future(_is_resolved=" << _is_resolved
                << ", _condition=" << _condition.size()
                << ") => " << this << endl )
    }

    ~Future() {
        DB( Synchronizer, TRC, "~Future(this=" << this << ")" << endl );
    }

    FutureType get_value() {
        DB( Synchronizer, TRC, "Future::get_value(this=" << this
                << " _is_resolved=" << _is_resolved
                << " _condition=" << _condition.size()
                <<  ")" << endl )
        // Optimization once _is_resolved is set true, we do not need lock anymore
        if( _is_resolved ) {
            return _value;
        }

        // If _is_resolved is not set to true, lock and double check _is_resolved
        Thread::lock();
        if( !_is_resolved ) {
            _condition.wait(); // implicit Thread::unlock()
        }
        else {
            Thread::unlock();
        }
        return _value;
    }

    void resolve(FutureType value) {
        DB( Synchronizer, TRC, "Future::resolve(this=" << this
                << " _is_resolved=" << _is_resolved
                << " _condition=" << _condition.size()
                <<  ")" << endl )
        Thread::lock();
        assert( !_is_resolved );
        // If the instruction pointer got until here, and the thread is unscheduled,
        // and another thread call `resolve()`, then, the `assert` will not work,
        // if the whole resolve() call is not atomic.
        _value = value;
        _is_resolved = true;
        _condition.broadcast(); // implicit Thread::unlock()
    }

private:
    volatile bool _is_resolved;

    Condition _condition;
    FutureType _value;
};

__END_UTIL

#endif

// EPOS Synchronizer Component Test Program
#define DEBUG_SYNC

#include <thread.h>
#include <utility/future.h>
#include <alarm.h>

using namespace EPOS;

int producerFunction(Future<int>* future) {
    LOG( "producerFunction ()" << endl )
    Delay thinking(1000000);
    future->resolve(10);

    LOG( "producerFunction (resolving future=" << future << " to 10)" << endl )
    return 0;
}

int consumerFunction(Future<int>* future) {
    LOG( "consumerFunction ()" << endl )

    auto value = future->get_value();
    LOG( "consumerFunction (result=" << value << ")" << endl )

    value = future->get_value();
    LOG( "consumerFunction (result=" << value << ")" << endl )
    return 0;
}

int main()
{
    LOG( endl )
    LOG( "Starting main application..." << endl )
    Future<int>* future = new Future<int>();

    Thread* consumer = new Thread(&consumerFunction, future);
    Thread* producer = new Thread(&producerFunction, future);

    consumer->join();
    producer->join();

    LOG( "Exiting main application..." << endl )
    return 0;
}

Starting main application...
Future(_is_resolved=0, _condition=0) => 0x00097f5c
consumerFunction ()
Future::get_value(this=0x00097f5c _is_resolved=0 _condition=0)
producerFunction ()
Future::resolve(this=0x00097f5c _is_resolved=0 _condition=1)
consumerFunction (result=10)
Future::get_value(this=0x00097f5c _is_resolved=1 _condition=0)
consumerFunction (result=10)
producerFunction (resolving future=0x00097f5c to 10)
Exiting main application...

// EPOS Synchronizer Component Test Program
#define DEBUG_SYNC

#include <thread.h>
#include <utility/guard.h>
#include <utility/future.h>
#include <alarm.h>

using namespace EPOS;
static volatile int counter = 0;

Guard guard;

void increment_counter(Future<int>* future) {
    Delay thinking(1000000);
    counter = counter + 1;

    LOG( "increment_counter (counter=" << counter << ")" << endl )
    future->resolve(counter);
}

int functionA() {
    LOG( "functionA ()" << endl )
    Future<int>* future = new Future<int>();

    guard.submit(&increment_counter, future);
    auto value = future->get_value();

    LOG( "functionA (result=" << value << ")" << endl )
    return 0;
}

int functionB() {
    LOG( "functionB ()" << endl )
    Future<int>* future = new Future<int>();

    guard.submit(&increment_counter, future);
    auto value = future->get_value();

    LOG( "functionB (result=" << value << ")" << endl )
    return 0;
}

int main()
{
    LOG( endl )
    LOG( "Starting main application..." << endl )

    Thread* producer = new Thread(&functionA);
    Thread* consumer = new Thread(&functionB);

    consumer->join();
    producer->join();

    LOG( "Exiting main application..." << endl )
    return 0;
}

Starting main application...
functionA ()
Future(_is_resolved=0, _condition=0) => 0x0008fef4
functionB ()
Future(_is_resolved=0, _condition=0) => 0x0008feb4
Future::get_value(this=0x0008feb4 _is_resolved=0 _condition=0)
increment_counter (counter=1)
Future::resolve(this=0x0008fef4 _is_resolved=0 _condition=0)
increment_counter (counter=2)
Future::resolve(this=0x0008feb4 _is_resolved=0 _condition=1)
functionB (result=2)
Future::get_value(this=0x0008fef4 _is_resolved=1 _condition=0)
functionA (result=1)
Exiting main application...

class Critical_Section_Base
{
    /// The Guard class requires access to our the _next private attribute
    friend class Guard;

public:
    Critical_Section_Base(): _next(this) {
        DB( Synchronizer, TRC, "Critical_Section_Base(_next=" << &_next
                << ") => " << this << endl )
    }

    /// This must to be virtual otherwise the derived classes objects destructor
    /// method would not be called when accessed by a base class pointer.
    virtual ~Critical_Section_Base() {
        DB( Synchronizer, TRC, "~Critical_Section_Base(this=" << this
                << " _next=" << &_next << ")" << endl )
    }

    /// Returns void because the base class Critical_Section_Base() cannot be a
    /// template class, as it is general interface for all Closures used on the
    /// Guard algorithm. Also, it does not make sense to return something from
    /// the closure when in its code is ran by the sequencer on another thread,
    /// detached from the original code.
    ///
    /// This must to be virtual otherwise the derived classes objects run()
    /// method would not be called when accessed by a base class pointer.
    virtual void start() = 0;

private:
    // Inspired by the thread code
    Critical_Section_Base* _next;
};

template<typename... Tn>
class Critical_Section: public Critical_Section_Base, private Closure<void( Tn... )>
{
    using Closure<void( Tn... )>::run;

public:
    Critical_Section(void(*_entry)(Tn ...), Tn ... an) :
            Closure<void( Tn... )>::Closure( _entry, an ... )
    {
        DB( Synchronizer, TRC, "Critical_Section(_entry="
                << reinterpret_cast<void *>(_entry) << ") => " << this << endl )
    }

    inline void start() {
        run();
    }
};

template<int ...>
struct MetaSequenceOfIntegers { };

template<int AccumulatedSize, typename Tn, int... GeneratedSequence>
struct GeneratorOfIntegerSequence;

template<
            int AccumulatedSize,
            typename Grouper,
            typename Head,
            typename... Tail,
            int... GeneratedSequence
        >
struct GeneratorOfIntegerSequence<
        AccumulatedSize, Grouper( Head, Tail... ), GeneratedSequence... >
{
    typedef typename GeneratorOfIntegerSequence
            <
                AccumulatedSize + sizeof(Head),
                Grouper( Tail... ),
                GeneratedSequence...,
                AccumulatedSize
            >::type type;
};

template<int AccumulatedSize, typename Grouper, int... GeneratedSequence>
struct GeneratorOfIntegerSequence<AccumulatedSize, Grouper(), GeneratedSequence...>
{
  typedef MetaSequenceOfIntegers<GeneratedSequence...> type;
};

$ clang++ -Xclang -ast-print -fsyntax-only \
  parameter_pack_sequencer_size_generator.cpp > expanded.cpp

template<> struct GeneratorOfIntegerSequence<
            0, int (char, int, char), <>>
{
    typedef typename GeneratorOfIntegerSequence<
            0 + sizeof(char), int (int, char), 0>::type type;
};

template<> struct GeneratorOfIntegerSequence<1, int (int, char), <0>>
{
    typedef typename GeneratorOfIntegerSequence<
            1 + sizeof(int), int (char), 0, 1>::type type;
};

template<> struct GeneratorOfIntegerSequence<5, int (char), <0, 1>>
{
    typedef typename GeneratorOfIntegerSequence<
            5 + sizeof(char), int (), 0, 1, 5>::type type;
};

template<> struct GeneratorOfIntegerSequence<6, int (), <0, 1, 5>>
{
    typedef MetaSequenceOfIntegers<0, 1, 5> type;
};

// https://stackoverflow.com/questions/34957810/variadic-templates-parameter-pack
template<typename Tn>
class Closure;

template<typename ReturnType, typename... Tn>
class Closure<ReturnType( Tn... )>
{
public:
    typedef ReturnType(*Function)(Tn ...);
    static const unsigned int PARAMETERS_COUNT = sizeof...( Tn );
    static const unsigned int PARAMETERS_LENGTH = SIZEOF<Tn ...>::Result;

private:
    Function _entry;
    char* _parameters;

public:
    Closure(Function _entry, Tn ... an): _entry(_entry)
    {
        DB( Synchronizer, TRC, "Closure(_entry=" << reinterpret_cast<void *>(_entry)
                << ", PARAMETERS_COUNT=" << PARAMETERS_COUNT
                << ", PARAMETERS_LENGTH=" << PARAMETERS_LENGTH
                << ", sizeof=" << sizeof(*this) << ") => " << this << endl )

        if(PARAMETERS_LENGTH)
            _parameters = new char[PARAMETERS_LENGTH];

        pack_helper( _parameters, an ... );
    }

    ~Closure() {
        DB( Synchronizer, TRC, "~Closure(this=" << this
                << ", _entry=" << reinterpret_cast<void *>(_entry)
                << ", PARAMETERS_COUNT=" << PARAMETERS_COUNT
                << ", PARAMETERS_LENGTH=" << PARAMETERS_LENGTH
                << ", sizeof=" << sizeof(*this) << ")" << endl )

        if(PARAMETERS_LENGTH)
            delete _parameters;
    }

    inline ReturnType run() {
        return operator()();
    }

    inline ReturnType operator()() {
        return _unpack_and_run(
                typename GeneratorOfIntegerSequence< 0, int(Tn...) >::type() );
    }

private:
    template<int ...Sequence>
    inline ReturnType _unpack_and_run(MetaSequenceOfIntegers<Sequence...>)
    {
        DB( Synchronizer, TRC, "Closure::_unpack_and_run(this=" << this << ")" << endl )
        return _entry( unpack_helper<Sequence, Tn>()... );
    }

    template<const int position, typename T>
    inline T unpack_helper()
    {
        DB( Synchronizer, TRC, "Closure::unpack_helper(Head=" << sizeof( T )
                << ", address=" << reinterpret_cast<int *>(_parameters + position)
                << "(" << reinterpret_cast<int *>(_parameters) << ")"
                << ", position=" << position << ")" << endl )

        return *reinterpret_cast<T *>( _parameters + position );
    }

public:
    template<typename Head, typename ... Tail>
    static void pack_helper(char* pointer_address, Head head, Tail ... tail)
    {
        DB( Synchronizer, TRC, "Closure::pack_helper(Head=" << sizeof( Head )
                << ", address=" << reinterpret_cast<int *>(pointer_address)
                << ")" << endl )

        *reinterpret_cast<Head *>(pointer_address) = head;
        pack_helper(pointer_address + sizeof( Head ), tail ...);
    }

    static void pack_helper(char* pointer_address) {}
};

class Closure<funcReturntype(char, …, int), char, …, int>{
  ...
}

// EPOS Synchronizer Component Test Program
#define DEBUG_SYNC

#include <utility/closure.h>
using namespace EPOS;

template<typename ReturnType, typename ... Tn>
Closure< ReturnType(Tn ...) > create_closure( ReturnType(*_entry)( Tn ... ), Tn ... an )
{
    auto closure = new Closure< ReturnType(Tn ...) >( _entry, an ... );
    LOG( "create_closure " << closure << endl )
    return *closure;
}

template<typename ... Tn>
void test_closure(Tn ... an) {
    auto closure = create_closure(an ...);
    closure();
    LOG( "    void" << endl << endl )
}

template<typename ... Tn>
void test_closure_with_return(Tn ... an) {
    auto closure = create_closure(an ...);
    auto return_value = closure();
    LOG( "    " << return_value << endl << endl )
}

char test_function1(char arg1, int arg2, bool arg3) {
    LOG( "test_function1 " << arg1 << ", " <<  arg2 << ", " << arg3 << endl )
    return 'A';
}

char test_function2(const char* arg1, const char* arg2, char arg3) {
    LOG( "test_function2 " << arg1 << ", " <<  arg2 << ", " << arg3 << endl )
    return 'B';
}

char test_function3() {
    LOG( "test_function3 " << endl )
    return 'C';
}

void test_function4() {
    LOG( "test_function4 " << endl )
}

void test_function5(const char* arg1) {
    LOG( "test_function5 " << arg1 << endl )
}

int main()
{
    LOG( endl )
    LOG( "main: begin()" << endl )

    test_closure_with_return( &test_function1, 'a', 10, false );
    test_closure_with_return( &test_function2, "test1", "test2", 'b' );
    test_closure_with_return( &test_function3 );

    test_closure( &test_function4 );
    test_closure( &test_function5, "Testa 3" );
    test_closure( &test_function5, "Testa 4" );

    LOG( "main: exiting()" << endl )
    return 0;
}

main: begin()
Closure::Closure(_entry=0x0009ff78,
        PARAMETERS_COUNT=3, PARAMETERS_LENGTH=6, sizeof=8) => 0x00097f64
Closure::pack_helper(Head=1, address=0x00097f54)
Closure::pack_helper(Head=4, address=0x00097f55)
Closure::pack_helper(Head=1, address=0x00097f59)
create_closure 0x00097f64
Closure::_unpack_and_run(this=0x0009fef4)
Closure::unpack_helper(Head=1, address=0x00097f59(0x00097f54), position=5)
Closure::unpack_helper(Head=4, address=0x00097f55(0x00097f54), position=1)
Closure::unpack_helper(Head=1, address=0x00097f54(0x00097f54), position=0)
test_function1 a, 10, 0
    A

Closure::~Closure(this=0x0009fef4,
        _entry=0x0009fef4, PARAMETERS_COUNT=3, PARAMETERS_LENGTH=6, sizeof=8)
Closure::Closure(_entry=0x0009ff74,
        PARAMETERS_COUNT=3, PARAMETERS_LENGTH=9, sizeof=8) => 0x00097f54
Closure::pack_helper(Head=4, address=0x00097f44)
Closure::pack_helper(Head=4, address=0x00097f48)
Closure::pack_helper(Head=1, address=0x00097f4c)
create_closure 0x00097f54
Closure::_unpack_and_run(this=0x0009ff34)
Closure::unpack_helper(Head=1, address=0x00097f4c(0x00097f44), position=8)
Closure::unpack_helper(Head=4, address=0x00097f48(0x00097f44), position=4)
Closure::unpack_helper(Head=4, address=0x00097f44(0x00097f44), position=0)
test_function2 test1, test2, b
    B

Closure::~Closure(this=0x0009ff34,
        _entry=0x0009ff34, PARAMETERS_COUNT=3, PARAMETERS_LENGTH=9, sizeof=8)
Closure::Closure(_entry=0x0009fe8c,
        PARAMETERS_COUNT=0, PARAMETERS_LENGTH=0, sizeof=8) => 0x00097f44
create_closure 0x00097f44
Closure::_unpack_and_run(this=0x0009fe84)
test_function3
    C

Closure::~Closure(this=0x0009fe84,
        _entry=0x0009fe84, PARAMETERS_COUNT=0, PARAMETERS_LENGTH=0, sizeof=8)
Closure::Closure(_entry=0x0009fe8c,
        PARAMETERS_COUNT=0, PARAMETERS_LENGTH=0, sizeof=8) => 0x00097f34
create_closure 0x00097f34
Closure::_unpack_and_run(this=0x0009fe84)
test_function4
    void

Closure::~Closure(this=0x0009fe84,
        _entry=0x0009fe84, PARAMETERS_COUNT=0, PARAMETERS_LENGTH=0, sizeof=8)
Closure::Closure(_entry=0x0009fe8c,
        PARAMETERS_COUNT=1, PARAMETERS_LENGTH=4, sizeof=8) => 0x00097f24
Closure::pack_helper(Head=4, address=0x00097f14)
create_closure 0x00097f24
Closure::_unpack_and_run(this=0x0009fe84)
Closure::unpack_helper(Head=4, address=0x00097f14(0x00097f14), position=0)
test_function5 Testa 3
    void

Closure::~Closure(this=0x0009fe84,
        _entry=0x0009fe84, PARAMETERS_COUNT=1, PARAMETERS_LENGTH=4, sizeof=8)
Closure::Closure(_entry=0x0009fe8c,
        PARAMETERS_COUNT=1, PARAMETERS_LENGTH=4, sizeof=8) => 0x00097f14
Closure::pack_helper(Head=4, address=0x00097f04)
create_closure 0x00097f14
Closure::_unpack_and_run(this=0x0009fe84)
Closure::unpack_helper(Head=4, address=0x00097f04(0x00097f04), position=0)
test_function5 Testa 4
    void

Closure::~Closure(this=0x0009fe84,
        _entry=0x0009fe84, PARAMETERS_COUNT=1, PARAMETERS_LENGTH=4, sizeof=8)
main: exiting()

$ clang++ -Xclang -ast-print -fsyntax-only closure_test.cpp > expanded.cpp

template<> class Closure<char (const char *, const char *, char)>
{
public:
    typedef char (*Function)(const char *, const char *, char);

    static const unsigned int PARAMETERS_COUNT = sizeof...(Tn);
    static const unsigned int PARAMETERS_LENGTH = SIZEOF<
            const char *, const char *, char>::Result;

    Closure<char (const char *, const char *, char)>::Function _entry;
    char *_parameters;

    Closure(Closure<char (const char *, const char *, char)>::Function _entry,
            const char *an, const char *an, char an) : _entry(_entry)
    {
        this->_parameters = new char [PARAMETERS_LENGTH];
        pack_helper(this->_parameters, an, an, an);
    }

    ~Closure<char (const char *, const char *, char)>()
    {
        delete this->_parameters;
    }

    char operator()()
    {
        return this->_run(typename GeneratorOfIntegerSequence<
                0, int (const char *, const char *, char)>::type());
    }

private:
    template<> char _run<<0, 8, 16>>(MetaSequenceOfIntegers<0, 8, 16>)
    {
        return this->_entry(
            this->unpack_helper<0, const char *>(),
            this->unpack_helper<8, const char *>(),
            this->unpack_helper<16, char>()
        );
    }

    template<> const char *unpack_helper<0, const char *>()
    {
        return *reinterpret_cast<const char **>(this->_parameters + 0);
    }

    template<> const char *unpack_helper<8, const char *>()
    {
        return *reinterpret_cast<const char **>(this->_parameters + 8);
    }

    template<> char unpack_helper<16, char>()
    {
        return *reinterpret_cast<char *>(this->_parameters + 16);
    }

public:
    template<> static void pack_helper<const char *, <const char *, char>>(
                char *pointer_address, const char *head, const char *tail, char tail)
    {
        *reinterpret_cast<const char **>(pointer_address) = head;
        pack_helper(pointer_address + sizeof(const char *), tail, tail);
    }

    template<> static void pack_helper<const char *, <char>>(char *pointer_address,
                const char *head, char tail)
    {
        *reinterpret_cast<const char **>(pointer_address) = head;
        pack_helper(pointer_address + sizeof(const char *), tail);
    }

    template<> static void pack_helper<char, <>>(char *pointer_address, char head)
    {
        *reinterpret_cast<char *>(pointer_address) = head;
        pack_helper(pointer_address + sizeof(char));
    }

    static void pack_helper(char *pointer_address)
    {
    }
}

class Guard
{
    int _size;
    Thread* _sequencer;

    Critical_Section_Base * _head;
    Critical_Section_Base * _tail;

    static const int NULL = 0;
    static const int DONE = 1;

public:
    Guard();
    ~Guard();

    template<typename ... Tn>
    void submit( void(*entry)( Tn ... ), Tn ... an )
    {
        // Creates a closure with the critical section parameters
        Critical_Section<Tn ...>* cs = new Critical_Section<Tn ...>(entry, an ...);

        Critical_Section_Base * cur = vouch(cs);
        if (cur != reinterpret_cast<Critical_Section_Base *>(NULL)) do {
            _sequencer = Thread::self();
            cur->start();
            cur = clear();
        } while (cur != reinterpret_cast<Critical_Section_Base *>(NULL));
    }

    Critical_Section_Base * vouch(Critical_Section_Base * item);
    Critical_Section_Base * clear();
};

Guard::Guard(): _size(0), _sequencer(0), _head(0), _tail(0) {
    DB( Synchronizer, TRC, "Guard(head=" << _head << ", tail=" << _tail
            << ") => " << this << endl )
}

Guard::~Guard() {
    DB( Synchronizer, TRC, "~Guard(this=" << this << ")" << endl )
}

Critical_Section_Base* Guard::vouch(Critical_Section_Base * item)
{
    DB( Synchronizer, TRC, "Guard::vouch(this=" << this
            << " head=" << _head
            << " tail=" << _tail
            << " thread=" << Thread::self()
            << " sequencer=" << _sequencer
            << " size=" << _size + 1
            << " item=" << item )
    CPU::finc(_size);

    item->_next = reinterpret_cast<Critical_Section_Base *>(NULL);
    Critical_Section_Base * last = CPU::fas(_tail, item);
    DB( Synchronizer, TRC, " last=" << last << ")" << endl )

    if( last ) {
        if( CPU::cas( last->_next, reinterpret_cast<Critical_Section_Base *>(NULL), item )
                    == reinterpret_cast<Critical_Section_Base *>(NULL) )

            return reinterpret_cast<Critical_Section_Base *>(NULL);
        delete last;
    }
    _head = item;
    return item;
}

Critical_Section_Base* Guard::clear()
{
    DB( Synchronizer, TRC, "Guard::clear(this=" << this
            << " head=" << _head
            << " tail=" << _tail
            << " thread=" << Thread::self()
            << " sequencer=" << _sequencer
            << " size=" << _size - 1 )
    CPU::fdec(_size);

    Critical_Section_Base * item = _head;
    Critical_Section_Base * next = CPU::fas( item->_next,
            reinterpret_cast<Critical_Section_Base *>(DONE) );

    DB( Synchronizer, TRC, " next=" << next << ")" << endl )
    bool mine = true;

    if( !next ) {
        mine = CPU::cas( _tail, item, reinterpret_cast<
                Critical_Section_Base *> (NULL) ) == item;
    }

    CPU::cas( _head, item, next );
    if( mine ) {
        delete item;
    }
    return next;
}

// EPOS Synchronizer Component Test Program
#define DEBUG_SYNC

#include <thread.h>
#include <machine.h>
#include <utility/guard.h>
#include <utility/debug_sync.h>
#include <alarm.h>

using namespace EPOS;
Guard counter_guard;

void show(char char1, const char* text1, const char* text2,
            bool bool1, bool bool2, const char* text3, int int1) {
    LOG( "    char1=" << char1 << ", text1=" << text1
        << ", text2=" << text2 << ", bool1=" << bool1 << ", bool2=" << bool2
        << ", text3=" << text3 << ", int1="  << int1  << endl )
}

int main()
{
    LOG( endl )
    LOG( "main: begin()" << endl )
    counter_guard.submit(&show, 'A', "Test 1", "Test 2", true, false, "Test 3", 10);
    counter_guard.submit(&show, 'B', "Test 4", "Test 5", false, false, "Test 6", 20);

    LOG( "main: exiting()" << endl )
    return 0;
}

main: begin()
Closure::Closure(_entry=0x0009ff5c,
        PARAMETERS_COUNT=7, PARAMETERS_LENGTH=19, sizeof=8) => 0x00097f68
Closure::pack_helper(Head=1, address=0x00097f45)
Closure::pack_helper(Head=4, address=0x00097f46)
Closure::pack_helper(Head=4, address=0x00097f4a)
Closure::pack_helper(Head=1, address=0x00097f4e)
Closure::pack_helper(Head=1, address=0x00097f4f)
Closure::pack_helper(Head=4, address=0x00097f50)
Closure::pack_helper(Head=4, address=0x00097f54)
Closure::_unpack_and_run(this=0x00097f68)
Closure::unpack_helper(Head=4, address=0x00097f54(0x00097f45), position=15)
Closure::unpack_helper(Head=4, address=0x00097f50(0x00097f45), position=11)
Closure::unpack_helper(Head=1, address=0x00097f4f(0x00097f45), position=10)
Closure::unpack_helper(Head=1, address=0x00097f4e(0x00097f45), position=9)
Closure::unpack_helper(Head=4, address=0x00097f4a(0x00097f45), position=5)
Closure::unpack_helper(Head=4, address=0x00097f46(0x00097f45), position=1)
Closure::unpack_helper(Head=1, address=0x00097f45(0x00097f45), position=0)
    char1=A, text1=Test 1, text2=Test 2, bool1=1, bool2=0, text3=Test 3, int1=10

Closure::~Closure(this=0x00097f68,
        _entry=0x00097f68, PARAMETERS_COUNT=7, PARAMETERS_LENGTH=19, sizeof=8)
Closure::Closure(_entry=0x0009ff5c,
        PARAMETERS_COUNT=7, PARAMETERS_LENGTH=19, sizeof=8) => 0x00097f68
Closure::pack_helper(Head=1, address=0x00097f45)
Closure::pack_helper(Head=4, address=0x00097f46)
Closure::pack_helper(Head=4, address=0x00097f4a)
Closure::pack_helper(Head=1, address=0x00097f4e)
Closure::pack_helper(Head=1, address=0x00097f4f)
Closure::pack_helper(Head=4, address=0x00097f50)
Closure::pack_helper(Head=4, address=0x00097f54)
Closure::_unpack_and_run(this=0x00097f68)
Closure::unpack_helper(Head=4, address=0x00097f54(0x00097f45), position=15)
Closure::unpack_helper(Head=4, address=0x00097f50(0x00097f45), position=11)
Closure::unpack_helper(Head=1, address=0x00097f4f(0x00097f45), position=10)
Closure::unpack_helper(Head=1, address=0x00097f4e(0x00097f45), position=9)
Closure::unpack_helper(Head=4, address=0x00097f4a(0x00097f45), position=5)
Closure::unpack_helper(Head=4, address=0x00097f46(0x00097f45), position=1)
Closure::unpack_helper(Head=1, address=0x00097f45(0x00097f45), position=0)
    char1=B, text1=Test 4, text2=Test 5, bool1=0, bool2=0, text3=Test 6, int1=20

Closure::~Closure(this=0x00097f68,
        _entry=0x00097f68, PARAMETERS_COUNT=7, PARAMETERS_LENGTH=19, sizeof=8)
main: exiting()

#include <mutex>
#include <atomic>
#include <cassert>

#include <iomanip>
#include <iostream>
#include <condition_variable>

#define ASM __asm__ __volatile__


// You can define it anywhere before including this file
// #define DEBUG

#ifdef DEBUG
    std::recursive_mutex _debug_syncronized_semaphore_lock;

    #define DB(...) do { \
        _debug_syncronized_semaphore_lock.lock(); \
            std::cout << __VA_ARGS__ << std::flush; \
        _debug_syncronized_semaphore_lock.unlock(); } while(0);

    #define LOG(...) DB(__VA_ARGS__)

#else
    #define DB(...)
    #define LOG(...) std::cout << __VA_ARGS__ << std::flush;

#endif


template<typename T>
static T fas(T volatile & value, T replacement)
{
    ASM("lock xchgl %1, %2"
            : "=r"(replacement)
            : "r"(replacement), "m"(value)
            : "memory");
    return replacement;
}

template<typename T>
static T cas(T volatile & value, T compare, T replacement)
{
    ASM("lock cmpxchgl %2, %3\n"
            : "=a"(compare)
            : "a"(compare), "r"(replacement), "m"(value)
            : "memory");
    return compare;
}


class Display
{
private:
    static const int LINES = 25;
    static const int COLUMNS = 8000;
    static const int TAB_SIZE = 8;

    // Special characters
    enum {
        ESC  = 0x1b,
        CR   = 0x0d,
        LF   = 0x0a,
        TAB  = 0x09,
    };

public:
    Display() {}

    static void clear() {
        _line = 0;
        _column = 0;
        escape();
        put('2');
        put('J');
    };

    static void putc(char c) {
        switch(c) {
        case '\n':
            scroll();
            _line++;
            break;
        case '\t':
            put(TAB);
            _column += TAB_SIZE;
            break;
        default:
            _column++;
            put(c);
            if(_column >= COLUMNS) scroll();
        }
    };

    static void puts(const char * s) {
        while(*s != '\0')
            putc(*s++);
    }

    static void geometry(int * lines, int * columns) {
        *lines = LINES;
        *columns = COLUMNS;
    }

    static void position(int * line, int * column) {
        *line = _line;
        *column = _column;
    }
    static void position(int line, int column) {
        _line = line;
        _column = column;
        escape();
        puti(_line);
        put(';');
        puti(_column);
        put('H');
    }

private:
    static void put(char c) {
        std::cout << c;
    }

    static void escape() {
        put(ESC);
        put('[');
    }

    static void puti(unsigned char value) {
        unsigned char digit = '0';
        while(value >= 100) {
            digit++;
            value -= 100;
        }
        put(digit);

        digit = '0';
        while(value >= 10) {
            digit++;
            value -= 10;
        }
        put(digit);

        put('0' + value);
    }

    static void scroll() {
        put(CR);
        put(LF);
        _column = 0;
    }

    static void init() {
        _line = 0;
        _column = 0;
    }

private:
    static int _line;
    static int _column;
};

int Display::_line;
int Display::_column;


template<typename FutureType>
class Future
{
public:
    Future(): _size(0), _is_resolved(false) {
        DB( "Future(_is_resolved=" << _is_resolved
                << ", _condition=" << _size
                << ") => " << this << std::endl )
    }

    ~Future() {
        DB( "~Future(this=" << this << ")" << std::endl );
    }

    FutureType get_value() {
        DB( "Future::get_value(this=" << this
                << " _is_resolved=" << _is_resolved
                << " _condition=" << _size
                <<  ")" << std::endl )
        // Optimization once _is_resolved is set true, we do not need lock anymore
        if( _is_resolved ) {
            return _value;
        }

        // If _is_resolved is not set to true, lock and double check _is_resolved
        std::unique_lock<std::mutex> lock(_lock);
        if(!_is_resolved) {
            ++_size;

            // We cannot call _lock.unlock(); before _condition.wait(lock); because
            // 1. It would allow this thread to be preempted
            // 2. Then, some other thread could call resolve()
            // Once this other thread completes the resolve() call, and this
            // thread is rescheduled, we would finally call _condition.wait(lock);
            // but doing so, would cause this thread to be locked indefinitely
            // because we will never call resolve() anymore
            _condition.wait(lock);
        }
        return _value;
    }

    void resolve(FutureType value) {
        DB( "Future::resolve(this=" << this
                << " _is_resolved=" << _is_resolved
                << " _condition=" << _size
                <<  ")" << std::endl )
        _lock.lock();
        assert(!_is_resolved);
        // If the instruction pointer got until here, and the thread is unscheduled,
        // and another thread call `resolve()`, then, the `assert` will not work,
        // if the whole resolve() call is not atomic.
        _value = value;
        _is_resolved = true;
        _lock.unlock();
        _condition.notify_all();
    }

private:
    FutureType _value;
    std::atomic<int> _size;
    volatile std::atomic<bool> _is_resolved;

    std::mutex _lock;
    std::condition_variable _condition;
};


// SIZEOF Type Package
template<typename ... Tn>
struct SIZEOF
{ static const unsigned int Result = 0; };

template<typename T1, typename ... Tn>
struct SIZEOF<T1, Tn ...>
{ static const unsigned int Result = sizeof(T1) + SIZEOF<Tn ...>::Result ; };

// https://stackoverflow.com/questions/7858817/unpacking-a-tuple-to-call-a-matching-function
template<int ...>
struct MetaSequenceOfIntegers { };

template<int AccumulatedSize, typename Tn, int... GeneratedSequence>
struct GeneratorOfIntegerSequence;

template<
            int AccumulatedSize,
            typename Grouper,
            typename Head,
            typename... Tail,
            int... GeneratedSequence
        >
struct GeneratorOfIntegerSequence<
        AccumulatedSize, Grouper( Head, Tail... ), GeneratedSequence... >
{
    typedef typename GeneratorOfIntegerSequence
            <
                AccumulatedSize + sizeof(Head),
                Grouper( Tail... ),
                GeneratedSequence...,
                AccumulatedSize
            >::type type;
};

template<int AccumulatedSize, typename Grouper, int... GeneratedSequence>
struct GeneratorOfIntegerSequence<AccumulatedSize, Grouper(), GeneratedSequence...>
{
  typedef MetaSequenceOfIntegers<GeneratedSequence...> type;
};


// https://stackoverflow.com/questions/34957810/variadic-templates-parameter-pack-and-its
template<typename Tn>
class Closure;

template<typename ReturnType, typename... Tn>
class Closure<ReturnType( Tn... )>
{
public:
    typedef ReturnType(*Function)(Tn ...);
    static const unsigned int PARAMETERS_COUNT = sizeof...( Tn );
    static const unsigned int PARAMETERS_LENGTH = SIZEOF<Tn ...>::Result;

private:
    Function _entry;
    char* _parameters;

public:
    Closure(Function _entry, Tn ... an): _entry(_entry)
    {
        DB( "Closure(_entry=" << reinterpret_cast<void *>(_entry)
                << ", PARAMETERS_COUNT=" << PARAMETERS_COUNT
                << ", PARAMETERS_LENGTH=" << PARAMETERS_LENGTH
                << ", sizeof=" << sizeof(*this) << ") => " << this << std::endl )

        if(PARAMETERS_LENGTH)
            _parameters = new char[PARAMETERS_LENGTH];

        pack_helper( _parameters, an ... );
    }

    ~Closure() {
        DB( "~Closure(this=" << this
                << ", _entry=" << reinterpret_cast<void *>(_entry)
                << ", PARAMETERS_COUNT=" << PARAMETERS_COUNT
                << ", PARAMETERS_LENGTH=" << PARAMETERS_LENGTH
                << ", sizeof=" << sizeof(*this) << ")" << std::endl )

        if(PARAMETERS_LENGTH)
            delete _parameters;
    }

    inline ReturnType run() {
        return operator()();
    }

    inline ReturnType operator()() {
        return _unpack_and_run(
                typename GeneratorOfIntegerSequence< 0, int(Tn...) >::type() );
    }

private:
    template<int ...Sequence>
    inline ReturnType _unpack_and_run(MetaSequenceOfIntegers<Sequence...>)
    {
        DB( "Closure::_unpack_and_run(this=" << this << ")" << std::endl )
        return _entry( unpack_helper<Sequence, Tn>()... );
    }

    template<const int position, typename T>
    inline T unpack_helper()
    {
        DB( "Closure::unpack_helper(Head=" << sizeof( T )
                << ", address=" << reinterpret_cast<int *>(_parameters + position)
                << "(" << reinterpret_cast<int *>(_parameters) << ")"
                << ", position=" << position << ")" << std::endl )

        return *reinterpret_cast<T *>( _parameters + position );
    }

public:
    template<typename Head, typename ... Tail>
    static void pack_helper(char* pointer_address, Head head, Tail ... tail)
    {
        DB( "Closure::pack_helper(Head=" << sizeof( Head )
                << ", address=" << reinterpret_cast<int *>(pointer_address)
                << ")" << std::endl )

        *reinterpret_cast<Head *>(pointer_address) = head;
        pack_helper(pointer_address + sizeof( Head ), tail ...);
    }

    static void pack_helper(char* pointer_address) {}
};


class Critical_Section_Base
{
    friend class Guard;
    Critical_Section_Base* _next;

public:
    Critical_Section_Base(): _next(this) {
        DB( "Critical_Section_Base(_next=" << _next
                << ") => " << this << std::endl )
    }

    virtual ~Critical_Section_Base() {
        DB( "~Critical_Section_Base(this=" << this
                << " _next=" << _next << ")" << std::endl )
    }

    virtual void start() = 0;
};

template<typename... Tn>
class Critical_Section: public Critical_Section_Base, private Closure<void( Tn... )>
{
    using Closure<void( Tn... )>::run;

public:
    Critical_Section(void(*_entry)(Tn ...), Tn ... an) :
            Closure<void( Tn... )>::Closure( _entry, an ... )
    {
        DB( "Critical_Section(_entry="
                << reinterpret_cast<void *>(_entry) << ") => " << this << std::endl )
    }

    inline void start() {
        run();
    }
};


class Guard
{
    std::atomic<int> _size;
    void* _sequencer;

    Critical_Section_Base* _head;
    Critical_Section_Base* _tail;

    // static const unsigned int NULL = 0;
    static const unsigned int DONE = 1;

public:
    Guard() : _size(0), _sequencer(0), _head(0), _tail(0)
    {
        DB( "Guard(head=" << _head << ", tail=" << _tail
                << ") => " << this << std::endl )
    }

    ~Guard() {
        DB( "~Guard(this=" << this << ")" << std::endl )
    }

    template<typename ... Tn>
    void submit( void(*entry)( Tn ... ), Tn ... an )
    {
        // Creates a closure with the critical section parameters
        Critical_Section<Tn ...>* cs = new Critical_Section<Tn ...>(entry, an ...);

        Critical_Section_Base * cur = vouch(cs);
        if (cur != reinterpret_cast<Critical_Section_Base *>(NULL)) do {
            _sequencer = get_thread_id();
            cur->start();
            cur = clear();
        } while (cur != reinterpret_cast<Critical_Section_Base *>(NULL));
    }

    Critical_Section_Base* vouch(Critical_Section_Base * item)
    {
        DB( "Guard::vouch(this=" << this
                << " head=" << _head
                << " tail=" << _tail
                << " thread=" << get_thread_id()
                << " sequencer=" << _sequencer
                << " size=" << _size + 1
                << " item=" << item )
        ++_size;

        item->_next = reinterpret_cast<Critical_Section_Base *>(NULL);
        Critical_Section_Base * last = fas( _tail, item );
        DB( " last=" << last << ")" << std::endl )

        if( last ) {
            if( cas( last->_next, reinterpret_cast<Critical_Section_Base *>(NULL), item )
                        == reinterpret_cast<Critical_Section_Base *>(NULL) )

                return reinterpret_cast<Critical_Section_Base *>(NULL);
            delete last;
        }
        _head = item;
        return item;
    }

    Critical_Section_Base * clear()
    {
        DB( "Guard::clear(this=" << this
                << " head=" << _head
                << " tail=" << _tail
                << " thread=" << get_thread_id()
                << " sequencer=" << _sequencer
                << " size=" << _size - 1 )
        --_size;

        Critical_Section_Base * item = _head;
        Critical_Section_Base * next = fas( item->_next,
                reinterpret_cast<Critical_Section_Base *>(DONE) );
        DB( " next=" << next << ")" << std::endl )

        bool mine = true;
        if( !next ) {
            mine = cas( _tail, item, reinterpret_cast<
                    Critical_Section_Base *> (NULL) ) == item;
        }

        cas( _head, item, next) ;
        if( mine ) {
            delete item;
        }
        return next;
    }

    static void* get_thread_id() {
        std::stringstream ss;
        ss << std::this_thread::get_id();
        return reinterpret_cast<void *>( std::stoull( ss.str() ) );
    }
};

// EPOS Synchronizer Component Test Program
#define DEBUG_SYNC

#include <utility/ostream.h>
#include <utility/debug_sync.h>
#include <thread.h>
#include <cpu.h>

using namespace EPOS;
static const int iterations = 1e5;

int old = 0;
int current = 10;
int next = 11;

#define check(thread, name) \
    LOG( thread << name \
            << ", old=" << old \
            << ", current=" << current \
            << ", next=" << next \
            << endl )

int myThread1() {
    check("Thread 1", ", begin")

    for (int i = 0; i < iterations; i++)
    {
        old = CPU::fas(current, next);
        current = CPU::fas(next, old);
        next = CPU::fas(old, current);
        // check("Thread 1", ", now")
    }

    check("Thread 1", ", result")
    return 0;
}

int myThread2() {
    check("Thread 2", ", begin")

    for (int i = 0; i < iterations; i++) {
        old = CPU::fas(current, next);
        current = CPU::fas(next, old);
        next = CPU::fas(old, current);
        // check("Thread 2", ", now")
    }

    check("Thread 2", ", result")
    return 0;
}

int main()
{
    LOG( endl )
    LOG( "iterations=" << iterations << endl )
    Thread p1(&myThread1);
    Thread p2(&myThread2);

    check("Thread 0", ", main")
    p1.join();
    p2.join();

    check("Thread 0", ", end")
    return 0;
}

<1>: MMU is disabled! :<1>
<2>: MMU is disabled! :<2>
<3>: MMU is disabled! :<3>
<0>: iterations=100000 :<0>
<0>: Thread 0, main, old=0, current=10, next=11 :<0>
<2>: Thread 1, begin, old=0, current=10, next=11 :<2>
<1>: Thread 2, begin, old=10, current=10, next=11 :<1>
<2>: Thread 1, result, old=10, current=10, next=11 :<2>
<1>: Thread 2, result, old=10, current=10, next=11 :<1>
<1>: Thread 0, end, old=10, current=10, next=11 :<1>
<0>: The last thread has exited! :<0>
<0>: Rebooting the machine ... :<0>

// EPOS Synchronizer Component Test Program
#define DEBUG_SYNC

#include <thread.h>
#include <machine.h>
#include <utility/guard.h>
#include <alarm.h>

using namespace EPOS;

static volatile int counter = 0;
static const int iterations = 1e3;

Guard counter_guard;
Guard display_guard;
Thread * pool[5];

void show(char arg, const char * type) {
    LOG( arg << ": " << type << " (counter=" << counter << ")" << endl )
}

void increment_counter() {
    counter = counter + 1;
    LOG( "increment_counter (counter=" << counter << ")" << endl )
}

int mythread(char arg) {
    display_guard.submit(&show, arg, "begin");

    for (int i = iterations; i > 0 ; i--) {
        counter_guard.submit(&increment_counter);
        // Delay label(1000);
    }

    display_guard.submit(&show, arg, "end");
    return 0;
}

int main()
{
    LOG( endl )
    LOG( "main: begin (counter=" << counter << ")" << endl )

    pool[0] = new Thread(&mythread, 'A');
    pool[1] = new Thread(&mythread, 'B');
    pool[2] = new Thread(&mythread, 'C');
    pool[3] = new Thread(&mythread, 'D');
    pool[4] = new Thread(&mythread, 'E');

    LOG( "main: start joining the threads (counter=" << counter << ")" << endl )
    pool[0]->join();
    pool[1]->join();
    pool[2]->join();
    pool[3]->join();
    pool[4]->join();

    LOG( "main: done with both (counter=" << counter << ")" << endl )
    delete pool[0];
    delete pool[1];
    delete pool[2];
    delete pool[3];
    delete pool[4];

    LOG( "main: exiting (counter=" << counter << ")" << endl )
    return 0;
}

<1>: MMU is disabled! :<1>
<2>: MMU is disabled! :<2>
<3>: MMU is disabled! :<3>
<0>:  :<0>
main: begin (counter=0)
<0>: main: start joining the threads (counter=0) :<0>
<0>: A: begin (counter=0) :<0>
<1>: B: begin (counter=1476) :<1>
<1>: C: begin (counter=7900) :<1>
<3>: D: begin (counter=11002) :<3>
<2>: C: end (counter=12407) :<2>
<2>: E: begin (counter=18387) :<2>
<2>: A: end (counter=25320) :<2>
<3>: D: end (counter=27383) :<3>
<2>: E: end (counter=33451) :<2>
<2>: B: end (counter=50000) :<2>
<2>: main: done with both (counter=50000) :<2>
<2>: main: exiting (counter=50000) :<2>
<0>:  :<0>
The last thread has exited!
<0>: Rebooting the machine ... :<0>

// EPOS Synchronizer Component Test Program
#define DEBUG_SYNC

#include <semaphore.h>
#include <utility/debug_sync.h>
#include <thread.h>
#include <machine.h>
#include <alarm.h>

using namespace EPOS;
int counter = 0;

// mythread()
// Simply adds 1 to counter repeatedly, in a loop
// No, this is not how you would add 10,000,000 to
// a counter, but it shows the problem nicely.
int mythread(char arg) {
    LOG( arg << ": begin : " << endl)

    for (int i = 0; i < 1e6; i++) {
        if (counter%100000 == 0){
            LOG( arg << " : " << counter << endl )
        }
        counter = counter + 1;
        // LOG( "Counting " << counter << endl )
    }

    LOG( arg << ": done" << endl )
    return 0;
}

// main()
// Just launches two threads (pthread_create)
// and then waits for them (pthread_join)
int main()
{
    LOG( endl )
    LOG( "main: begin (counter = " << counter << ")" << endl )

    Thread * p1 = new Thread(&mythread, 'A');
    Thread * p2 = new Thread(&mythread, 'B');
    Thread * p3 = new Thread(&mythread, 'C');
    Thread * p4 = new Thread(&mythread, 'D');
    Thread * p5 = new Thread(&mythread, 'E');
    Thread * p6 = new Thread(&mythread, 'F');

    // join waits for the threads to finish
    p1->join();
    p2->join();
    p3->join();
    p4->join();
    p5->join();
    p6->join();

    LOG( "main: done with both (counter = " << counter << ")"<< endl )
    return 0;
}

<1>: MMU is disabled! :<1>
<2>: MMU is disabled! :<2>
<3>: MMU is disabled! :<3>
<0>: main: begin (counter = 0) :<0>
<2>: A: begin :  :<2>
<2>: A : 0 :<2>
<1>: B: begin :  :<1>
<3>: C: begin :  :<3>
<0>: D: begin :  :<0>
<2>: E: begin :  :<2>
<1>: F: begin :  :<1>
<1>: F : 100000 :<1>
<2>: E : 100000 :<2>
<3>: A : 100000 :<3>
<0>: B : 100000 :<0>
<2>: C : 100000 :<2>
<1>: D : 100000 :<1>
<0>: F : 200000 :<0>
<3>: C : 200000 :<3>
<2>: E : 200000 :<2>
<3>: A : 200000 :<3>
<0>: B : 200000 :<0>
<1>: D : 200000 :<1>
<3>: E : 300000 :<3>
<0>: F : 300000 :<0>
<2>: A : 300000 :<2>
<2>: A : 300000 :<2>
<3>: C : 300000 :<3>
<2>: E : 400000 :<2>
<1>: F : 400000 :<1>
<1>: D : 345974 :<1>
<1>: B : 400000 :<1>
<3>: D : 346916 :<3>
<0>: F : 385967 :<0>
<0>: E : 393666 :<0>
<2>: A : 400000 :<2>
<1>: C : 477901 :<1>
<0>: F : 498945 :<0>
<3>: D : 446608 :<3>
<1>: E : 476901 :<1>
<0>: B : 484604 :<0>
<3>: C : 500000 :<3>
<1>: E : 528187 :<1>
<0>: D : 525792 :<0>
<2>: A : 571028 :<2>
<2>: F : 600000 :<2>
<1>: E : 567826 :<1>
<3>: A : 654100 :<3>
<1>: B : 588204 :<1>
<1>: E : 600000 :<1>
<3>: D : 689233 :<3>
<0>: B : 700000 :<0>
<0>: A : 600000 :<0>
<0>: D : 646539 :<0>
<3>: F : 658486 :<3>
<1>: C : 691064 :<1>
<0>: D : 700000 :<0>
<0>: D : 700000 :<0>
<1>: C : 700000 :<1>
<3>: F : 700000 :<3>
<2>: A : 700000 :<2>
<3>: B : 700000 :<3>
<0>: E : 700000 :<0>
<0>: C : 800000 :<0>
<3>: A : 800000 :<3>
<0>: D : 800000 :<0>
<1>: F : 817259 :<1>
<2>: B : 800000 :<2>
<2>: D : 900000 :<2>
<2>: D : 800000 :<2>
<3>: E : 800000 :<3>
<0>: C : 900000 :<0>
<2>: A : 900000 :<2>
<3>: F : 900000 :<3>
<2>: B : 900000 :<2>
<0>: D : 900000 :<0>
<3>: C : 1000000 :<3>
<2>: F : 1000000 :<2>
<3>: E : 900000 :<3>
<1>: A : 1000000 :<1>
<1>: A : 1000000 :<1>
<0>: B : 1000000 :<0>
<3>: F : 1100000 :<3>
<3>: C : 1100000 :<3>
<0>: D : 1000000 :<0>
<1>: E : 1000000 :<1>
<2>: B : 1100000 :<2>
<3>: C : 1100000 :<3>
<0>: A: done :<0>
<1>: F: done :<1>
<3>: B: done :<3>
<0>: C: done :<0>
<1>: E: done :<1>
<2>: D : 1100000 :<2>
<2>: D: done :<2>
<2>: main: done with both (counter = 1106138) :<2>
<0>: The last thread has exited! :<0>
<0>: Rebooting the machine ... :<0>

// EPOS Synchronizer Component Test Program
#define DEBUG_SYNC

#include <utility/debug_sync.h>
#include <semaphore.h>
#include <thread.h>
#include <machine.h>

using namespace EPOS;
static volatile int counter = 0;

Semaphore counter_lock;

// mythread()
// Simply adds 1 to counter repeatedly, in a loop
// No, this is not how you would add 10,000,000 to
// a counter, but it shows the problem nicely.
int mythread(char arg) {
    LOG( arg << ": begin" << endl )
    for (int i = 0; i < 1e4; i++) {
        counter_lock.p();
        counter = counter + 1;
        counter_lock.v();
    }

    LOG( arg << ": done" << endl )
    return 0;
}

// main()
// Just launches two threads (pthread_create)
// and then waits for them (pthread_join)
int main()
{
    LOG( endl )
    LOG( "main: begin (counter = " << counter << ")" << endl )

    Thread p1(&mythread, 'A');
    Thread p2(&mythread, 'B');

    // join waits for the threads to finish
    p1.join();
    p2.join();

    LOG( "main: done with both (counter = " << counter << ")"<< endl )
    return 0;
}

<1>: MMU is disabled! :<1>
<2>: MMU is disabled! :<2>
<3>: MMU is disabled! :<3>
<0>: main: begin (counter = 0) :<0>
<0>: A: begin :<0>
<0>: B: begin :<0>
<3>: B: done :<3>
<3>: A: done :<3>
<3>: main: done with both (counter = 20000) :<3>
<0>: The last thread has exited! :<0>
<0>: Rebooting the machine ... :<0>

// EPOS Semaphore Component Test Program
#define DEBUG_SYNC

#include <utility/ostream.h>
#include <utility/stringstream.h>
#include <utility/guard.h>
#include <utility/future.h>
#include <thread.h>
#include <alarm.h>
#include <display.h>

#if !defined(nullptr)
    #define nullptr 0
#endif

using namespace EPOS;

// #define CONSOLE_MODE
const int iterations = 10;

Guard table;

OStream cout;
Thread * phil[5];

bool is_chopstick_free[5];
Future<int>* locked_futures[5];

#ifdef CONSOLE_MODE
    #define LVL WRN
#else
    #define LVL FFF
#endif

void show_message(const char * message, int line, int column) {
#ifdef CONSOLE_MODE
    DB( Synchronizer, LVL, message << "(" << line << ")" << endl )
#else
    Display::position( line, column );
    cout << message;
#endif
}

void show_message(StringStream * message, int line, int column) {
#ifdef CONSOLE_MODE
    DB( Synchronizer, LVL, message )
#else
    Display::position( line, column );
    cout << message;
#endif
    delete message;
}

void release_chopstick(int philosopher_index, int chopstick_index,
        Future<int>* future_chopstick, const char* which_chopstick)
{
    DB( Synchronizer, LVL, "Philosopher=" << philosopher_index
            << ", release chopstick=" << chopstick_index
            << ", is_chopstick_free=" << is_chopstick_free[chopstick_index]
            << ", future_chopstick=" << future_chopstick
            << ", locked_futures=" << locked_futures[chopstick_index]
            << ", " << which_chopstick )

    is_chopstick_free[chopstick_index] = true;
    delete future_chopstick;

    if( locked_futures[chopstick_index] ) {
        DB( Synchronizer, LVL, endl )

        auto old = locked_futures[chopstick_index];
        locked_futures[chopstick_index] = nullptr;
        old->resolve(1);
    }
    else {
        assert( locked_futures[chopstick_index] == nullptr );
        DB( Synchronizer, LVL, endl )
    }
}

void get_chopstick(int philosopher_index, int chopstick_index,
        Future<int>* future_chopstick, const char* which_chopstick)
{
    DB( Synchronizer, LVL, "Philosopher=" << philosopher_index
            << ", getting chopstick=" << chopstick_index
            << ", is_chopstick_free=" << is_chopstick_free[chopstick_index]
            << ", " << which_chopstick )

    if( is_chopstick_free[chopstick_index] ) {
        is_chopstick_free[chopstick_index] = false;

        DB( Synchronizer, LVL, ", future_chopstick=" << future_chopstick << endl )
        future_chopstick->resolve(1);
    }
    else {
        assert( locked_futures[chopstick_index] == nullptr );
        locked_futures[chopstick_index] = future_chopstick;

        DB( Synchronizer, LVL, ", locked_futures="
                << locked_futures[chopstick_index] << endl )
    }
}

int philosopher(int philosopher_index, int line, int column)
{
    int first = (philosopher_index < 4)? philosopher_index : 0;
    int second = (philosopher_index < 4)? philosopher_index + 1 : 4;

#ifdef CONSOLE_MODE
    line = philosopher_index;
#endif

    for(int i = iterations; i > 0; i--)
    {
        table.submit( &show_message, "    thinking", line, column );
        Delay thinking(2000000);

        // Get the first chopstick
        Future<int>* chopstick1 = new Future<int>();
        table.submit( &get_chopstick, philosopher_index, first, chopstick1, "FIRST " );
        chopstick1->get_value();

        // Get the second chopstick
        Future<int>* chopstick2 = new Future<int>();
        table.submit( &get_chopstick, philosopher_index, second, chopstick2, "SECOND" );
        chopstick2->get_value();

    #ifdef CONSOLE_MODE
        StringStream* stream1 = new StringStream{100};
        *stream1 << "Philosopher=" << philosopher_index
                << ", got     the first=" << first
                << " and second=" << second << " chopstick\n";
        table.submit( &show_message, stream1, line, column );
    #endif

        table.submit( &show_message, "    eating  ", line, column );
        Delay eating(1000000);

        // Release the chopsticks
        table.submit( &release_chopstick, philosopher_index, second, chopstick2, "SECOND" );
        table.submit( &release_chopstick, philosopher_index, first, chopstick1, "FIRST " );

    #ifdef CONSOLE_MODE
        StringStream* stream2 = new StringStream{100};
        *stream2 << "Philosopher=" << philosopher_index
                << ", release the first=" << first
                << " and second=" << second << " chopstick\n";
        table.submit( &show_message, stream2, line, column );
    #endif
    }

    table.submit( &show_message, "    done    ", line, column );
    return iterations;
}

void setup_program()
{
    Display::clear();
    Display::position(0, 0);
    cout << "The Philosopher's Dinner:" << endl;

    for(int i = 0; i < 5; i++)
    {
        is_chopstick_free[i] = true;
        locked_futures[i] = nullptr;
    }

    phil[0] = new Thread(&philosopher, 0,  5, 32);
    phil[1] = new Thread(&philosopher, 1, 10, 44);
    phil[2] = new Thread(&philosopher, 2, 16, 39);
    phil[3] = new Thread(&philosopher, 3, 16, 24);
    phil[4] = new Thread(&philosopher, 4, 10, 20);

    cout << "Philosophers are alive and hungry!" << endl;

    Display::position(7, 44);
    cout << '/';
    Display::position(13, 44);
    cout << '\\';
    Display::position(16, 35);
    cout << '|';
    Display::position(13, 27);
    cout << '/';
    Display::position(7, 27);
    cout << '\\';
    Display::position(19, 0);

    cout << "The dinner is served ..." << endl;
}

int main()
{
    table.submit( &setup_program );

    for(int i = 0; i < 5; i++) {
        int ret = phil[i]->join();
        StringStream* stream = new StringStream(100);

        *stream << "Philosopher " << i << " ate " << ret << " times\n";
        table.submit( &show_message, stream, 20 + i, 0 );
    }

    for(int i = 0; i < 5; i++)
        delete phil[i];

    cout << "The end!" << endl;
    return 0;
}

The Philosopher's Dinner:
Philosophers are alive and hungry!


                                   done

                          \                /


                       done                    done


                          /                \


                           done           done


The dinner is served ...
Philosopher 0 ate 10 times
Philosopher 1 ate 10 times
Philosopher 2 ate 10 times
Philosopher 3 ate 10 times
Philosopher 4 ate 10 times
The end!

The Philosopher's Dinner:
Philosophers are alive and hungry!




                          \                /





                          /                \


                                  |


The dinner is served ...
    thinking(0)
    thinking(1)
    thinking(2)
    thinking(3)
    thinking(4)
Philosopher=0, getting chopstick=0, is_chopstick_free=1, FIRST , future_chopstick=0x00083e30
Philosopher=0, getting chopstick=1, is_chopstick_free=1, SECOND, future_chopstick=0x00083e08
Philosopher=0, got     the first=0 and second=1 chopstick
    eating  (0)
Philosopher=1, getting chopstick=1, is_chopstick_free=0, FIRST , locked_futures=0x00083de0
Philosopher=2, getting chopstick=2, is_chopstick_free=1, FIRST , future_chopstick=0x00083db8
Philosopher=2, getting chopstick=3, is_chopstick_free=1, SECOND, future_chopstick=0x00083d90
Philosopher=2, got     the first=2 and second=3 chopstick
    eating  (2)
Philosopher=3, getting chopstick=3, is_chopstick_free=0, FIRST , locked_futures=0x00083d68
Philosopher=4, getting chopstick=0, is_chopstick_free=0, FIRST , locked_futures=0x00083d40
Philosopher=0, release chopstick=1, is_chopstick_free=0, future_chopstick=0x00083e08, locked_futures=0x00083de0, SECOND
Philosopher=1, getting chopstick=2, is_chopstick_free=0, SECOND, locked_futures=0x00083cec
Philosopher=0, release chopstick=0, is_chopstick_free=0, future_chopstick=0x00083e30, locked_futures=0x00083d40, FIRST
Philosopher=4, getting chopstick=4, is_chopstick_free=1, SECOND, future_chopstick=0x00083c98
Philosopher=4, got     the first=0 and second=4 chopstick
    eating  (4)
Philosopher=0, release the first=0 and second=1 chopstick
    thinking(0)
Philosopher=2, release chopstick=3, is_chopstick_free=0, future_chopstick=0x00083d90, locked_futures=0x00083d68, SECOND
Philosopher=3, getting chopstick=4, is_chopstick_free=0, SECOND, locked_futures=0x00083c44
Philosopher=2, release chopstick=2, is_chopstick_free=0, future_chopstick=0x00083db8, locked_futures=0x00083cec, FIRST
Philosopher=1, got     the first=1 and second=2 chopstick
    eating  (1)
Philosopher=2, release the first=2 and second=3 chopstick
    thinking(2)
Philosopher=4, release chopstick=4, is_chopstick_free=0, future_chopstick=0x00083c98, locked_futures=0x00083c44, SECOND
Philosopher=3, got     the first=3 and second=4 chopstick
    eating  (3)
Philosopher=4, release chopstick=0, is_chopstick_free=1, future_chopstick=0x00083d40, locked_futures=0x00000000, FIRST
Philosopher=4, release the first=0 and second=4 chopstick
    thinking(4)
Philosopher=1, release chopstick=2, is_chopstick_free=1, future_chopstick=0x00083cec, locked_futures=0x00000000, SECOND
Philosopher=1, release chopstick=1, is_chopstick_free=1, future_chopstick=0x00083de0, locked_futures=0x00000000, FIRST
Philosopher=1, release the first=1 and second=2 chopstick
    thinking(1)
Philosopher=0, getting chopstick=0, is_chopstick_free=1, FIRST , future_chopstick=0x00083c1c
Philosopher=0, getting chopstick=1, is_chopstick_free=1, SECOND, future_chopstick=0x00083bf4
Philosopher=0, got     the first=0 and second=1 chopstick
    eating  (0)
Philosopher=3, release chopstick=4, is_chopstick_free=1, future_chopstick=0x00083c44, locked_futures=0x00000000, SECOND
Philosopher=3, release chopstick=3, is_chopstick_free=1, future_chopstick=0x00083d68, locked_futures=0x00000000, FIRST
Philosopher=3, release the first=3 and second=4 chopstick
    thinking(3)
Philosopher=2, getting chopstick=2, is_chopstick_free=1, FIRST , future_chopstick=0x00083bcc
Philosopher=2, getting chopstick=3, is_chopstick_free=1, SECOND, future_chopstick=0x00083ba4
Philosopher=2, got     the first=2 and second=3 chopstick
    eating  (2)
Philosopher=4, getting chopstick=0, is_chopstick_free=0, FIRST , locked_futures=0x00083b7c
Philosopher=0, release chopstick=1, is_chopstick_free=0, future_chopstick=0x00083bf4, locked_futures=0x00000000, SECOND
Philosopher=0, release chopstick=0, is_chopstick_free=0, future_chopstick=0x00083c1c, locked_futures=0x00083b7c, FIRST
Philosopher=4, getting chopstick=4, is_chopstick_free=1, SECOND, future_chopstick=0x00083b28
Philosopher=4, got     the first=0 and second=4 chopstick
    eating  (4)
Philosopher=0, release the first=0 and second=1 chopstick
    thinking(0)
Philosopher=1, getting chopstick=1, is_chopstick_free=1, FIRST , future_chopstick=0x00083b00
Philosopher=1, getting chopstick=2, is_chopstick_free=0, SECOND, locked_futures=0x00083ad8
Philosopher=2, release chopstick=3, is_chopstick_free=0, future_chopstick=0x00083ba4, locked_futures=0x00000000, SECOND
Philosopher=2, release chopstick=2, is_chopstick_free=0, future_chopstick=0x00083bcc, locked_futures=0x00083ad8, FIRST
Philosopher=1, got     the first=1 and second=2 chopstick
    eating  (1)
Philosopher=2, release the first=2 and second=3 chopstick
    thinking(2)
Philosopher=3, getting chopstick=3, is_chopstick_free=1, FIRST , future_chopstick=0x00083ab0
Philosopher=3, getting chopstick=4, is_chopstick_free=0, SECOND, locked_futures=0x00083a88
Philosopher=4, release chopstick=4, is_chopstick_free=0, future_chopstick=0x00083b28, locked_futures=0x00083a88, SECOND
Philosopher=3, got     the first=3 and second=4 chopstick
    eating  (3)
Philosopher=4, release chopstick=0, is_chopstick_free=1, future_chopstick=0x00083b7c, locked_futures=0x00000000, FIRST
Philosopher=4, release the first=0 and second=4 chopstick
    thinking(4)
Philosopher=1, release chopstick=2, is_chopstick_free=1, future_chopstick=0x00083ad8, locked_futures=0x00000000, SECOND
Philosopher=1, release chopstick=1, is_chopstick_free=0, future_chopstick=0x00083b00, locked_futures=0x00000000, FIRST
Philosopher=1, release the first=1 and second=2 chopstick
    thinking(1)
Philosopher=0, getting chopstick=0, is_chopstick_free=1, FIRST , future_chopstick=0x00083a60
Philosopher=0, getting chopstick=1, is_chopstick_free=1, SECOND, future_chopstick=0x00083a38
Philosopher=0, got     the first=0 and second=1 chopstick
    eating  (0)
Philosopher=3, release chopstick=4, is_chopstick_free=1, future_chopstick=0x00083a88, locked_futures=0x00000000, SECOND
Philosopher=3, release chopstick=3, is_chopstick_free=0, future_chopstick=0x00083ab0, locked_futures=0x00000000, FIRST
Philosopher=3, release the first=3 and second=4 chopstick
    thinking(3)
Philosopher=2, getting chopstick=2, is_chopstick_free=1, FIRST , future_chopstick=0x00083a10
Philosopher=2, getting chopstick=3, is_chopstick_free=1, SECOND, future_chopstick=0x000839e8
Philosopher=2, got     the first=2 and second=3 chopstick
    eating  (2)
Philosopher=0, release chopstick=1, is_chopstick_free=0, future_chopstick=0x00083a38, locked_futures=0x00000000, SECOND
Philosopher=0, release chopstick=0, is_chopstick_free=0, future_chopstick=0x00083a60, locked_futures=0x00000000, FIRST
Philosopher=0, release the first=0 and second=1 chopstick
    thinking(0)
Philosopher=4, getting chopstick=0, is_chopstick_free=1, FIRST , future_chopstick=0x000839c0
Philosopher=4, getting chopstick=4, is_chopstick_free=1, SECOND, future_chopstick=0x00083998
Philosopher=4, got     the first=0 and second=4 chopstick
    eating  (4)
Philosopher=1, getting chopstick=1, is_chopstick_free=1, FIRST , future_chopstick=0x00083970
Philosopher=1, getting chopstick=2, is_chopstick_free=0, SECOND, locked_futures=0x00083948
Philosopher=2, release chopstick=3, is_chopstick_free=0, future_chopstick=0x000839e8, locked_futures=0x00000000, SECOND
Philosopher=2, release chopstick=2, is_chopstick_free=0, future_chopstick=0x00083a10, locked_futures=0x00083948, FIRST
Philosopher=1, got     the first=1 and second=2 chopstick
    eating  (1)
Philosopher=2, release the first=2 and second=3 chopstick
    thinking(2)
Philosopher=3, getting chopstick=3, is_chopstick_free=1, FIRST , future_chopstick=0x00083920
Philosopher=3, getting chopstick=4, is_chopstick_free=0, SECOND, locked_futures=0x000838f8
Philosopher=4, release chopstick=4, is_chopstick_free=0, future_chopstick=0x00083998, locked_futures=0x000838f8, SECOND
Philosopher=3, got     the first=3 and second=4 chopstick
    eating  (3)
Philosopher=4, release chopstick=0, is_chopstick_free=0, future_chopstick=0x000839c0, locked_futures=0x00000000, FIRST
Philosopher=4, release the first=0 and second=4 chopstick
    thinking(4)
Philosopher=1, release chopstick=2, is_chopstick_free=1, future_chopstick=0x00083948, locked_futures=0x00000000, SECOND
Philosopher=1, release chopstick=1, is_chopstick_free=0, future_chopstick=0x00083970, locked_futures=0x00000000, FIRST
Philosopher=1, release the first=1 and second=2 chopstick
    thinking(1)
Philosopher=0, getting chopstick=0, is_chopstick_free=1, FIRST , future_chopstick=0x000838d0
Philosopher=0, getting chopstick=1, is_chopstick_free=1, SECOND, future_chopstick=0x000838a8
Philosopher=0, got     the first=0 and second=1 chopstick
    eating  (0)
Philosopher=3, release chopstick=4, is_chopstick_free=1, future_chopstick=0x000838f8, locked_futures=0x00000000, SECOND
Philosopher=3, release chopstick=3, is_chopstick_free=0, future_chopstick=0x00083920, locked_futures=0x00000000, FIRST
Philosopher=3, release the first=3 and second=4 chopstick
    thinking(3)
Philosopher=2, getting chopstick=2, is_chopstick_free=1, FIRST , future_chopstick=0x00083880
Philosopher=2, getting chopstick=3, is_chopstick_free=1, SECOND, future_chopstick=0x00083858
Philosopher=2, got     the first=2 and second=3 chopstick
    eating  (2)
Philosopher=0, release chopstick=1, is_chopstick_free=0, future_chopstick=0x000838a8, locked_futures=0x00000000, SECOND
Philosopher=0, release chopstick=0, is_chopstick_free=0, future_chopstick=0x000838d0, locked_futures=0x00000000, FIRST
Philosopher=0, release the first=0 and second=1 chopstick
    thinking(0)
Philosopher=4, getting chopstick=0, is_chopstick_free=1, FIRST , future_chopstick=0x00083830
Philosopher=4, getting chopstick=4, is_chopstick_free=1, SECOND, future_chopstick=0x00083808
Philosopher=4, got     the first=0 and second=4 chopstick
    eating  (4)
Philosopher=1, getting chopstick=1, is_chopstick_free=1, FIRST , future_chopstick=0x000837e0
Philosopher=1, getting chopstick=2, is_chopstick_free=0, SECOND, locked_futures=0x000837b8
Philosopher=2, release chopstick=3, is_chopstick_free=0, future_chopstick=0x00083858, locked_futures=0x00000000, SECOND
Philosopher=2, release chopstick=2, is_chopstick_free=0, future_chopstick=0x00083880, locked_futures=0x000837b8, FIRST
Philosopher=1, got     the first=1 and second=2 chopstick
    eating  (1)
Philosopher=2, release the first=2 and second=3 chopstick
    thinking(2)
Philosopher=3, getting chopstick=3, is_chopstick_free=1, FIRST , future_chopstick=0x00083790
Philosopher=3, getting chopstick=4, is_chopstick_free=0, SECOND, locked_futures=0x00083768
Philosopher=4, release chopstick=4, is_chopstick_free=0, future_chopstick=0x00083808, locked_futures=0x00083768, SECOND
Philosopher=3, got     the first=3 and second=4 chopstick
    eating  (3)
Philosopher=4, release chopstick=0, is_chopstick_free=0, future_chopstick=0x00083830, locked_futures=0x00000000, FIRST
Philosopher=4, release the first=0 and second=4 chopstick
    thinking(4)
Philosopher=1, release chopstick=2, is_chopstick_free=1, future_chopstick=0x000837b8, locked_futures=0x00000000, SECOND
Philosopher=1, release chopstick=1, is_chopstick_free=0, future_chopstick=0x000837e0, locked_futures=0x00000000, FIRST
Philosopher=1, release the first=1 and second=2 chopstick
    thinking(1)
Philosopher=0, getting chopstick=0, is_chopstick_free=1, FIRST , future_chopstick=0x00083740
Philosopher=0, getting chopstick=1, is_chopstick_free=1, SECOND, future_chopstick=0x00083718
Philosopher=0, got     the first=0 and second=1 chopstick
    eating  (0)
Philosopher=3, release chopstick=4, is_chopstick_free=1, future_chopstick=0x00083768, locked_futures=0x00000000, SECOND
Philosopher=3, release chopstick=3, is_chopstick_free=0, future_chopstick=0x00083790, locked_futures=0x00000000, FIRST
Philosopher=3, release the first=3 and second=4 chopstick
    thinking(3)
Philosopher=2, getting chopstick=2, is_chopstick_free=1, FIRST , future_chopstick=0x000836f0
Philosopher=2, getting chopstick=3, is_chopstick_free=1, SECOND, future_chopstick=0x000836c8
Philosopher=2, got     the first=2 and second=3 chopstick
    eating  (2)
Philosopher=0, release chopstick=1, is_chopstick_free=0, future_chopstick=0x00083718, locked_futures=0x00000000, SECOND
Philosopher=0, release chopstick=0, is_chopstick_free=0, future_chopstick=0x00083740, locked_futures=0x00000000, FIRST
Philosopher=0, release the first=0 and second=1 chopstick
    thinking(0)
Philosopher=4, getting chopstick=0, is_chopstick_free=1, FIRST , future_chopstick=0x000836a0
Philosopher=4, getting chopstick=4, is_chopstick_free=1, SECOND, future_chopstick=0x00083678
Philosopher=4, got     the first=0 and second=4 chopstick
    eating  (4)
Philosopher=1, getting chopstick=1, is_chopstick_free=1, FIRST , future_chopstick=0x00083650
Philosopher=1, getting chopstick=2, is_chopstick_free=0, SECOND, locked_futures=0x00083628
Philosopher=2, release chopstick=3, is_chopstick_free=0, future_chopstick=0x000836c8, locked_futures=0x00000000, SECOND
Philosopher=2, release chopstick=2, is_chopstick_free=0, future_chopstick=0x000836f0, locked_futures=0x00083628, FIRST
Philosopher=1, got     the first=1 and second=2 chopstick
    eating  (1)
Philosopher=2, release the first=2 and second=3 chopstick
    thinking(2)
Philosopher=3, getting chopstick=3, is_chopstick_free=1, FIRST , future_chopstick=0x00083600
Philosopher=3, getting chopstick=4, is_chopstick_free=0, SECOND, locked_futures=0x000835d8
Philosopher=4, release chopstick=4, is_chopstick_free=0, future_chopstick=0x00083678, locked_futures=0x000835d8, SECOND
Philosopher=3, got     the first=3 and second=4 chopstick
    eating  (3)
Philosopher=4, release chopstick=0, is_chopstick_free=0, future_chopstick=0x000836a0, locked_futures=0x00000000, FIRST
Philosopher=4, release the first=0 and second=4 chopstick
    thinking(4)
Philosopher=1, release chopstick=2, is_chopstick_free=1, future_chopstick=0x00083628, locked_futures=0x00000000, SECOND
Philosopher=1, release chopstick=1, is_chopstick_free=0, future_chopstick=0x00083650, locked_futures=0x00000000, FIRST
Philosopher=1, release the first=1 and second=2 chopstick
    thinking(1)
Philosopher=0, getting chopstick=0, is_chopstick_free=1, FIRST , future_chopstick=0x000835b0
Philosopher=0, getting chopstick=1, is_chopstick_free=1, SECOND, future_chopstick=0x00083588
Philosopher=0, got     the first=0 and second=1 chopstick
    eating  (0)
Philosopher=3, release chopstick=4, is_chopstick_free=1, future_chopstick=0x000835d8, locked_futures=0x00000000, SECOND
Philosopher=3, release chopstick=3, is_chopstick_free=0, future_chopstick=0x00083600, locked_futures=0x00000000, FIRST
Philosopher=3, release the first=3 and second=4 chopstick
    thinking(3)
Philosopher=2, getting chopstick=2, is_chopstick_free=1, FIRST , future_chopstick=0x00083560
Philosopher=2, getting chopstick=3, is_chopstick_free=1, SECOND, future_chopstick=0x00083538
Philosopher=2, got     the first=2 and second=3 chopstick
    eating  (2)
Philosopher=0, release chopstick=1, is_chopstick_free=0, future_chopstick=0x00083588, locked_futures=0x00000000, SECOND
Philosopher=0, release chopstick=0, is_chopstick_free=0, future_chopstick=0x000835b0, locked_futures=0x00000000, FIRST
Philosopher=0, release the first=0 and second=1 chopstick
    thinking(0)
Philosopher=4, getting chopstick=0, is_chopstick_free=1, FIRST , future_chopstick=0x00083510
Philosopher=4, getting chopstick=4, is_chopstick_free=1, SECOND, future_chopstick=0x000834e8
Philosopher=4, got     the first=0 and second=4 chopstick
    eating  (4)
Philosopher=1, getting chopstick=1, is_chopstick_free=1, FIRST , future_chopstick=0x000834c0
Philosopher=1, getting chopstick=2, is_chopstick_free=0, SECOND, locked_futures=0x00083498
Philosopher=2, release chopstick=3, is_chopstick_free=0, future_chopstick=0x00083538, locked_futures=0x00000000, SECOND
Philosopher=2, release chopstick=2, is_chopstick_free=0, future_chopstick=0x00083560, locked_futures=0x00083498, FIRST
Philosopher=1, got     the first=1 and second=2 chopstick
    eating  (1)
Philosopher=2, release the first=2 and second=3 chopstick
    thinking(2)
Philosopher=3, getting chopstick=3, is_chopstick_free=1, FIRST , future_chopstick=0x00083470
Philosopher=3, getting chopstick=4, is_chopstick_free=0, SECOND, locked_futures=0x00083448
Philosopher=4, release chopstick=4, is_chopstick_free=0, future_chopstick=0x000834e8, locked_futures=0x00083448, SECOND
Philosopher=3, got     the first=3 and second=4 chopstick
    eating  (3)
Philosopher=4, release chopstick=0, is_chopstick_free=0, future_chopstick=0x00083510, locked_futures=0x00000000, FIRST
Philosopher=4, release the first=0 and second=4 chopstick
    thinking(4)
Philosopher=1, release chopstick=2, is_chopstick_free=1, future_chopstick=0x00083498, locked_futures=0x00000000, SECOND
Philosopher=1, release chopstick=1, is_chopstick_free=0, future_chopstick=0x000834c0, locked_futures=0x00000000, FIRST
Philosopher=1, release the first=1 and second=2 chopstick
    thinking(1)
Philosopher=0, getting chopstick=0, is_chopstick_free=1, FIRST , future_chopstick=0x00083420
Philosopher=0, getting chopstick=1, is_chopstick_free=1, SECOND, future_chopstick=0x000833f8
Philosopher=0, got     the first=0 and second=1 chopstick
    eating  (0)
Philosopher=3, release chopstick=4, is_chopstick_free=1, future_chopstick=0x00083448, locked_futures=0x00000000, SECOND
Philosopher=3, release chopstick=3, is_chopstick_free=0, future_chopstick=0x00083470, locked_futures=0x00000000, FIRST
Philosopher=3, release the first=3 and second=4 chopstick
    thinking(3)
Philosopher=2, getting chopstick=2, is_chopstick_free=1, FIRST , future_chopstick=0x000833d0
Philosopher=2, getting chopstick=3, is_chopstick_free=1, SECOND, future_chopstick=0x000833a8
Philosopher=2, got     the first=2 and second=3 chopstick
    eating  (2)
Philosopher=0, release chopstick=1, is_chopstick_free=0, future_chopstick=0x000833f8, locked_futures=0x00000000, SECOND
Philosopher=0, release chopstick=0, is_chopstick_free=0, future_chopstick=0x00083420, locked_futures=0x00000000, FIRST
Philosopher=0, release the first=0 and second=1 chopstick
    thinking(0)
Philosopher=4, getting chopstick=0, is_chopstick_free=1, FIRST , future_chopstick=0x00083380
Philosopher=4, getting chopstick=4, is_chopstick_free=1, SECOND, future_chopstick=0x00083358
Philosopher=4, got     the first=0 and second=4 chopstick
    eating  (4)
Philosopher=1, getting chopstick=1, is_chopstick_free=1, FIRST , future_chopstick=0x00083330
Philosopher=1, getting chopstick=2, is_chopstick_free=0, SECOND, locked_futures=0x00083308
Philosopher=2, release chopstick=3, is_chopstick_free=0, future_chopstick=0x000833a8, locked_futures=0x00000000, SECOND
Philosopher=2, release chopstick=2, is_chopstick_free=0, future_chopstick=0x000833d0, locked_futures=0x00083308, FIRST
Philosopher=1, got     the first=1 and second=2 chopstick
    eating  (1)
Philosopher=2, release the first=2 and second=3 chopstick
    thinking(2)
Philosopher=3, getting chopstick=3, is_chopstick_free=1, FIRST , future_chopstick=0x000832e0
Philosopher=3, getting chopstick=4, is_chopstick_free=0, SECOND, locked_futures=0x000832b8
Philosopher=4, release chopstick=4, is_chopstick_free=0, future_chopstick=0x00083358, locked_futures=0x000832b8, SECOND
Philosopher=3, got     the first=3 and second=4 chopstick
    eating  (3)
Philosopher=4, release chopstick=0, is_chopstick_free=0, future_chopstick=0x00083380, locked_futures=0x00000000, FIRST
Philosopher=4, release the first=0 and second=4 chopstick
    thinking(4)
Philosopher=1, release chopstick=2, is_chopstick_free=1, future_chopstick=0x00083308, locked_futures=0x00000000, SECOND
Philosopher=1, release chopstick=1, is_chopstick_free=0, future_chopstick=0x00083330, locked_futures=0x00000000, FIRST
Philosopher=1, release the first=1 and second=2 chopstick
    thinking(1)
Philosopher=0, getting chopstick=0, is_chopstick_free=1, FIRST , future_chopstick=0x00083290
Philosopher=0, getting chopstick=1, is_chopstick_free=1, SECOND, future_chopstick=0x00083268
Philosopher=0, got     the first=0 and second=1 chopstick
    eating  (0)
Philosopher=3, release chopstick=4, is_chopstick_free=1, future_chopstick=0x000832b8, locked_futures=0x00000000, SECOND
Philosopher=3, release chopstick=3, is_chopstick_free=0, future_chopstick=0x000832e0, locked_futures=0x00000000, FIRST
Philosopher=3, release the first=3 and second=4 chopstick
    thinking(3)
Philosopher=2, getting chopstick=2, is_chopstick_free=1, FIRST , future_chopstick=0x00083240
Philosopher=2, getting chopstick=3, is_chopstick_free=1, SECOND, future_chopstick=0x00083218
Philosopher=2, got     the first=2 and second=3 chopstick
    eating  (2)
Philosopher=0, release chopstick=1, is_chopstick_free=0, future_chopstick=0x00083268, locked_futures=0x00000000, SECOND
Philosopher=0, release chopstick=0, is_chopstick_free=0, future_chopstick=0x00083290, locked_futures=0x00000000, FIRST
Philosopher=0, release the first=0 and second=1 chopstick
    thinking(0)
Philosopher=4, getting chopstick=0, is_chopstick_free=1, FIRST , future_chopstick=0x000831f0
Philosopher=4, getting chopstick=4, is_chopstick_free=1, SECOND, future_chopstick=0x000831c8
Philosopher=4, got     the first=0 and second=4 chopstick
    eating  (4)
Philosopher=1, getting chopstick=1, is_chopstick_free=1, FIRST , future_chopstick=0x000831a0
Philosopher=1, getting chopstick=2, is_chopstick_free=0, SECOND, locked_futures=0x00083178
Philosopher=2, release chopstick=3, is_chopstick_free=0, future_chopstick=0x00083218, locked_futures=0x00000000, SECOND
Philosopher=2, release chopstick=2, is_chopstick_free=0, future_chopstick=0x00083240, locked_futures=0x00083178, FIRST
Philosopher=1, got     the first=1 and second=2 chopstick
    eating  (1)
Philosopher=2, release the first=2 and second=3 chopstick
    thinking(2)
Philosopher=3, getting chopstick=3, is_chopstick_free=1, FIRST , future_chopstick=0x00083150
Philosopher=3, getting chopstick=4, is_chopstick_free=0, SECOND, locked_futures=0x00083128
Philosopher=4, release chopstick=4, is_chopstick_free=0, future_chopstick=0x000831c8, locked_futures=0x00083128, SECOND
Philosopher=3, got     the first=3 and second=4 chopstick
    eating  (3)
Philosopher=4, release chopstick=0, is_chopstick_free=0, future_chopstick=0x000831f0, locked_futures=0x00000000, FIRST
Philosopher=4, release the first=0 and second=4 chopstick
    thinking(4)
Philosopher=1, release chopstick=2, is_chopstick_free=1, future_chopstick=0x00083178, locked_futures=0x00000000, SECOND
Philosopher=1, release chopstick=1, is_chopstick_free=0, future_chopstick=0x000831a0, locked_futures=0x00000000, FIRST
Philosopher=1, release the first=1 and second=2 chopstick
    thinking(1)
Philosopher=0, getting chopstick=0, is_chopstick_free=1, FIRST , future_chopstick=0x00083100
Philosopher=0, getting chopstick=1, is_chopstick_free=1, SECOND, future_chopstick=0x000830d8
Philosopher=0, got     the first=0 and second=1 chopstick
    eating  (0)
Philosopher=3, release chopstick=4, is_chopstick_free=1, future_chopstick=0x00083128, locked_futures=0x00000000, SECOND
Philosopher=3, release chopstick=3, is_chopstick_free=0, future_chopstick=0x00083150, locked_futures=0x00000000, FIRST
Philosopher=3, release the first=3 and second=4 chopstick
    thinking(3)
Philosopher=2, getting chopstick=2, is_chopstick_free=1, FIRST , future_chopstick=0x000830b0
Philosopher=2, getting chopstick=3, is_chopstick_free=1, SECOND, future_chopstick=0x00083088
Philosopher=2, got     the first=2 and second=3 chopstick
    eating  (2)
Philosopher=0, release chopstick=1, is_chopstick_free=0, future_chopstick=0x000830d8, locked_futures=0x00000000, SECOND
Philosopher=0, release chopstick=0, is_chopstick_free=0, future_chopstick=0x00083100, locked_futures=0x00000000, FIRST
Philosopher=0, release the first=0 and second=1 chopstick
    thinking(0)
Philosopher=4, getting chopstick=0, is_chopstick_free=1, FIRST , future_chopstick=0x00083060
Philosopher=4, getting chopstick=4, is_chopstick_free=1, SECOND, future_chopstick=0x00083038
Philosopher=4, got     the first=0 and second=4 chopstick
    eating  (4)
Philosopher=1, getting chopstick=1, is_chopstick_free=1, FIRST , future_chopstick=0x00083010
Philosopher=1, getting chopstick=2, is_chopstick_free=0, SECOND, locked_futures=0x00082fe8
Philosopher=2, release chopstick=3, is_chopstick_free=0, future_chopstick=0x00083088, locked_futures=0x00000000, SECOND
Philosopher=2, release chopstick=2, is_chopstick_free=0, future_chopstick=0x000830b0, locked_futures=0x00082fe8, FIRST
Philosopher=1, got     the first=1 and second=2 chopstick
    eating  (1)
Philosopher=2, release the first=2 and second=3 chopstick
    thinking(2)
Philosopher=3, getting chopstick=3, is_chopstick_free=1, FIRST , future_chopstick=0x00082fc0
Philosopher=3, getting chopstick=4, is_chopstick_free=0, SECOND, locked_futures=0x00082f98
Philosopher=4, release chopstick=4, is_chopstick_free=0, future_chopstick=0x00083038, locked_futures=0x00082f98, SECOND
Philosopher=3, got     the first=3 and second=4 chopstick
    eating  (3)
Philosopher=4, release chopstick=0, is_chopstick_free=0, future_chopstick=0x00083060, locked_futures=0x00000000, FIRST
Philosopher=4, release the first=0 and second=4 chopstick
    thinking(4)
Philosopher=1, release chopstick=2, is_chopstick_free=1, future_chopstick=0x00082fe8, locked_futures=0x00000000, SECOND
Philosopher=1, release chopstick=1, is_chopstick_free=0, future_chopstick=0x00083010, locked_futures=0x00000000, FIRST
Philosopher=1, release the first=1 and second=2 chopstick
    thinking(1)
Philosopher=0, getting chopstick=0, is_chopstick_free=1, FIRST , future_chopstick=0x00082f70
Philosopher=0, getting chopstick=1, is_chopstick_free=1, SECOND, future_chopstick=0x00082f48
Philosopher=0, got     the first=0 and second=1 chopstick
    eating  (0)
Philosopher=3, release chopstick=4, is_chopstick_free=1, future_chopstick=0x00082f98, locked_futures=0x00000000, SECOND
Philosopher=3, release chopstick=3, is_chopstick_free=0, future_chopstick=0x00082fc0, locked_futures=0x00000000, FIRST
Philosopher=3, release the first=3 and second=4 chopstick
    thinking(3)
Philosopher=2, getting chopstick=2, is_chopstick_free=1, FIRST , future_chopstick=0x00082f20
Philosopher=2, getting chopstick=3, is_chopstick_free=1, SECOND, future_chopstick=0x00082ef8
Philosopher=2, got     the first=2 and second=3 chopstick
    eating  (2)
Philosopher=0, release chopstick=1, is_chopstick_free=0, future_chopstick=0x00082f48, locked_futures=0x00000000, SECOND
Philosopher=0, release chopstick=0, is_chopstick_free=0, future_chopstick=0x00082f70, locked_futures=0x00000000, FIRST
Philosopher=0, release the first=0 and second=1 chopstick
    done    (0)
Philosopher 0 ate 10 times
Philosopher=4, getting chopstick=0, is_chopstick_free=1, FIRST , future_chopstick=0x00082ed0
Philosopher=4, getting chopstick=4, is_chopstick_free=1, SECOND, future_chopstick=0x00082ea8
Philosopher=4, got     the first=0 and second=4 chopstick
    eating  (4)
Philosopher=1, getting chopstick=1, is_chopstick_free=1, FIRST , future_chopstick=0x00082e80
Philosopher=1, getting chopstick=2, is_chopstick_free=0, SECOND, locked_futures=0x00082e58
Philosopher=2, release chopstick=3, is_chopstick_free=0, future_chopstick=0x00082ef8, locked_futures=0x00000000, SECOND
Philosopher=2, release chopstick=2, is_chopstick_free=0, future_chopstick=0x00082f20, locked_futures=0x00082e58, FIRST
Philosopher=1, got     the first=1 and second=2 chopstick
    eating  (1)
Philosopher=2, release the first=2 and second=3 chopstick
    done    (2)
Philosopher=3, getting chopstick=3, is_chopstick_free=1, FIRST , future_chopstick=0x00082e30
Philosopher=3, getting chopstick=4, is_chopstick_free=0, SECOND, locked_futures=0x00082e08
Philosopher=4, release chopstick=4, is_chopstick_free=0, future_chopstick=0x00082ea8, locked_futures=0x00082e08, SECOND
Philosopher=3, got     the first=3 and second=4 chopstick
    eating  (3)
Philosopher=4, release chopstick=0, is_chopstick_free=0, future_chopstick=0x00082ed0, locked_futures=0x00000000, FIRST
Philosopher=4, release the first=0 and second=4 chopstick
    done    (4)
Philosopher=1, release chopstick=2, is_chopstick_free=1, future_chopstick=0x00082e58, locked_futures=0x00000000, SECOND
Philosopher=1, release chopstick=1, is_chopstick_free=0, future_chopstick=0x00082e80, locked_futures=0x00000000, FIRST
Philosopher=1, release the first=1 and second=2 chopstick
    done    (1)
Philosopher 1 ate 10 times
Philosopher 2 ate 10 times
Philosopher=3, release chopstick=4, is_chopstick_free=1, future_chopstick=0x00082e08, locked_futures=0x00000000, SECOND
Philosopher=3, release chopstick=3, is_chopstick_free=0, future_chopstick=0x00082e30, locked_futures=0x00000000, FIRST
Philosopher=3, release the first=3 and second=4 chopstick
    done    (3)
Philosopher 3 ate 10 times
Philosopher 4 ate 10 times
The end!

// EPOS Scheduler Test Program
// #define DEBUG_SYNC

#include <utility/ostream.h>
#include <utility/stringstream.h>
#include <utility/guard.h>
#include <utility/future.h>
#include <machine.h>
#include <display.h>
#include <thread.h>

using namespace EPOS;

#if !defined(nullptr)
    #define nullptr 0
#endif

// #define CONSOLE_MODE
const int iterations = 10;
OStream cout;

Guard table;
Thread * phil[5];

bool is_chopstick_free[5];
Future<int>* locked_futures[5];

int philosopher(int n, int l, int c);
void think(unsigned long long n);
void eat(unsigned long long n);
unsigned long long busy_wait(unsigned long long n);

// Fix `error: undefined reference to endl` when compiling with hysterically_debugged = true
EPOS::S::U::OStream::Endl EPOS::S::U::endl;

#ifdef CONSOLE_MODE
    #define LVL WRN
    #define EXTRA(arg) arg
#else
    #define LVL FFF
    #define EXTRA(arg)
#endif

void show_message(const char * message, int line, int column) {
#ifdef CONSOLE_MODE
    DB( Synchronizer, LVL, message << "(" << line << ")" << endl )
#else
    Display::position( line, column );
    cout << message;
#endif
}

void show_message(StringStream * message, int line, int column) {
#ifdef CONSOLE_MODE
    DB( Synchronizer, LVL, message )
#else
    Display::position( line, column );
    cout << message;
#endif
    delete message;
}

void setup_program()
{
    Display::clear();
    Display::position(0, 0);
    cout << "The Philosopher's Dinner:" << endl;

    for(int i = 0; i < 5; i++)
    {
        is_chopstick_free[i] = true;
        locked_futures[i] = nullptr;
    }

    phil[0] = new Thread(&philosopher, 0,  5, 30);
    phil[1] = new Thread(&philosopher, 1, 10, 44);
    phil[2] = new Thread(&philosopher, 2, 16, 39);
    phil[3] = new Thread(&philosopher, 3, 16, 21);
    phil[4] = new Thread(&philosopher, 4, 10, 17);

    cout << "Philosophers are alive and hungry!" << endl;

    Display::position(7, 44);
    cout << '/';
    Display::position(13, 44);
    cout << '\\';
    Display::position(16, 35);
    cout << '|';
    Display::position(13, 27);
    cout << '/';
    Display::position(7, 27);
    cout << '\\';
    Display::position(19, 0);

    cout << "The dinner is served ..." << endl;
}

// Regular expression for plugin: https://github.com/evandroforks/HighlightWords
// /\) => (\dx[a-f\d]{8,8})/ /Philosopher=\d/ \bGuard::vouch\b \bGuard::clear\b
int main()
{
    table.submit( &setup_program );

    for(int i = 0; i < 5; i++) {
        int ret = phil[i]->join();
        StringStream* stream = new StringStream{100};

        *stream << "Philosopher " << i << " ate " << ret << " times\n";
        table.submit( &show_message, stream, 20 + i, 0 );
    }

    for(int i = 0; i < 5; i++)
        delete phil[i];

    cout << "The end!" << endl;
    return 0;
}

void release_chopstick(int philosopher_index, int chopstick_index,
        Future<int>* future_chopstick, const char* which_chopstick)
{
    DB( Synchronizer, LVL, "Philosopher=" << philosopher_index
            << ", release chopstick=" << chopstick_index
            << ", is_chopstick_free=" << is_chopstick_free[chopstick_index]
            << ", future_chopstick=" << future_chopstick
            << ", locked_futures=" << locked_futures[chopstick_index]
            << ", " << which_chopstick )

    is_chopstick_free[chopstick_index] = true;
    delete future_chopstick;

    if( locked_futures[chopstick_index] ) {
        DB( Synchronizer, LVL, endl )

        auto old = locked_futures[chopstick_index];
        locked_futures[chopstick_index] = nullptr;
        old->resolve(1);
    }
    else {
        assert( locked_futures[chopstick_index] == nullptr );
        DB( Synchronizer, LVL, endl )
    }
}

void get_chopstick(int philosopher_index, int chopstick_index,
        Future<int>* future_chopstick, const char* which_chopstick)
{
    DB( Synchronizer, LVL, "Philosopher=" << philosopher_index
            << ", getting chopstick=" << chopstick_index
            << ", is_chopstick_free=" << is_chopstick_free[chopstick_index]
            << ", " << which_chopstick )

    if( is_chopstick_free[chopstick_index] ) {
        is_chopstick_free[chopstick_index] = false;

        DB( Synchronizer, LVL, ", future_chopstick=" << future_chopstick << endl )
        future_chopstick->resolve(1);
    }
    else {
        assert( locked_futures[chopstick_index] == nullptr );
        locked_futures[chopstick_index] = future_chopstick;

        DB( Synchronizer, LVL, ", locked_futures="
                << locked_futures[chopstick_index] << endl )
    }
}

int philosopher(int philosopher_index, int line, int column)
{
    int first = (philosopher_index < 4)? philosopher_index : 0;
    int second = (philosopher_index < 4)? philosopher_index + 1 : 4;

#ifdef CONSOLE_MODE
    line = philosopher_index;
#endif

    for(int i = iterations; i > 0; i--) {
        StringStream* stream1 = new StringStream{101};
        *stream1 << "thinking[" << Machine::cpu_id() << "]"
                EXTRA( << " (" << line << ")" << "\n" );
        table.submit( &show_message, stream1, line, column );
        think(1000000);

        StringStream* stream2 = new StringStream{102};
        *stream2 << "  hungry[" << Machine::cpu_id() << "]"
                EXTRA( << " (" << line << ")" << "\n" );
        table.submit( &show_message, stream2, line, column );

        // Get the first chopstick
        Future<int>* chopstick1 = new Future<int>();
        table.submit( &get_chopstick, philosopher_index, first, chopstick1, "FIRST " );
        chopstick1->get_value();

        // Get the second chopstick
        Future<int>* chopstick2 = new Future<int>();
        table.submit( &get_chopstick, philosopher_index, second, chopstick2, "SECOND" );
        chopstick2->get_value();

    #ifdef CONSOLE_MODE
        StringStream* stream6 = new StringStream{103};
        *stream6 << "Philosopher=" << philosopher_index
                << ", got     the first=" << first
                << " and second=" << second << " chopstick" << "\n";
        table.submit( &show_message, stream6, line, column );
    #endif

        StringStream* stream3 = new StringStream{104};
        *stream3 << " eating[" << Machine::cpu_id() << "] " EXTRA( << "\n" );
        table.submit( &show_message, stream3, line, column );

        eat(500000);

        StringStream* stream4 = new StringStream{105};
        *stream4 << "    ate[" << Machine::cpu_id() << "]"
                EXTRA( << " (" << line << ")" << "\n" );
        table.submit( &show_message, stream4, line, column );

        // Release the chopsticks
        table.submit( &release_chopstick, philosopher_index, first, chopstick1, "FIRST " );
        table.submit( &release_chopstick, philosopher_index, second, chopstick2, "SECOND" );

    #ifdef CONSOLE_MODE
        StringStream* stream7 = new StringStream{106};
        *stream7 << "Philosopher=" << philosopher_index
                << ", release the first=" << first
                << " and second=" << second << " chopstick" << "\n";
        table.submit( &show_message, stream7, line, column );
    #endif
    }

    StringStream* stream5 = new StringStream{107};
    *stream5 << "  done[" << Machine::cpu_id() << "]  "
            EXTRA( << " (" << line << ")" << "\n" );
    table.submit( &show_message, stream5, line, column );

    return iterations;
}

void eat(unsigned long long n) {
    static unsigned long long v;
    v = busy_wait(n);
}

void think(unsigned long long n) {
    static unsigned long long v;
    v = busy_wait(n);
}

unsigned long long busy_wait(unsigned long long n)
{
    volatile unsigned long long v;
    for(long long int j = 0; j < 20 * n; j++)
        v &= 2 ^ j;
    return v;
}

1088: <1>: ~Closure(this=0x0007fd85, _entry=0x00006030, PARAMETERS_COUNT=3, PARAMETERS_LENGTH=12, sizeof=8) :<1>
1089: <1>: Heap::free(this=0x004000b4,ptr=0x0007fd65,bytes=16) :<1>
1090: <1>: Grouping_List::insert_merging(e=0x0007fd65) :<1>
1091: <1>: ~Critical_Section_Base(this=0x0007fd79 _link=0x0007fd7d) :<1>
1092: <1>: Heap::free(this=0x004000b4,ptr=0x0007fd75,bytes=24) :<1>
1093: <1>: Grouping_List::insert_merging(e=0x0007fd75) :<1>
1094: <1>: List::remove(e=0x0007fd8d) => {p=0x00093f24,o=0x0007fd8d,n=0x00000000} :<1>
1095: <1>: List[0x004000b4]::head=0x0001d000 => {p=0x00000000,o=0x0001d<0>: Spin::acquire[SPIN=0x004000c8,ID=0x0008febc]() => {owner=589500,level=1} :<0>
1096: <0>: Heap::alloc(this=0x004000b4,bytes=16Grouping_List::search_decrementing(s=20) :<0>
1097: <0>: List[0x004000b4]::head=0x0001d000 => {p=0x00000000,o=0x0001d000,n=0x00100000} :<0>
1098: <0>: List[0x004000b4]::tail=0x0007fd8d => {p=0x00093f24,o=0x0007fd8d,n=0x00000000} :<0>
1099: <0>: ) => 0x0007fd65 :<0>
1100: <0>: Spin::release[SPIN=0x004000c8,ID=589500]() => {owner=0,level=0} :<0>
1101: <0>: StringStream(_buffer_size=102) => 0x0007fd65 :<0>
1102: <0>: Spin::acquire[SPIN=0x004000c8,ID=0x0008febc]() => {owner=589500,level=1} :<0>
1103: <0>: Heap::alloc(this=0x004000b4,bytes=103Grouping_List::search_decrementing(s=107) :<0>
1104: <0>: List[0x004000b4]::head=0x0001d000 => {p=0x00000000,o=0x0001d000,n=0x00100000} :<0>
1105: <0>: List[0x004000b4]::tail=0x0007fd8d => {p=0x00093f24,o=0x0007fd8d,n=0x00000000} :<0>
1106: <0>: ) => 0x0007fcfa :<0>
1107: <0>: Spin::release[SPIN=0x004000c8,ID=589500]() => {owner=0,level=0} :<0>
1108: <0>: StringStream::print(this=0x0007fd65), string=  hungry[, string_size=9, total_size=9, _last_position=9, _buffer=  hungry[ :<0>
1109: <0>: StringStream::print(this=0x0007fd65), string=0, string_size=1, total_size=10, _last_position=10, _buffer=  hungry[0 :<0>
1110: <0>: StringStream::print(this=0x0007fd65), 000,n=0x00100000} :<1>
1111: <1>: List[0x004000b4]::tail=0x0007fd8d => {p=0x00093f24,o=0x0007fd8d,n=0x00000000} :<1>
1112: <1>: List::remove_tail() :<1>
1113: <1>: List[0x004000b4]::head=0x0001d000 => {p=0x00000000,o=0x0001d000,n=0x00100000} :<1>
1114: <1>: List[0x004000b4]::tail=0x0007fd8d => {p=0x00093f24,o=0x0007fd8d,n=0x00000000} :<1>
1115: <1>: List[0x004000b4]::head=0x0001d000 => {p=0x00000000,o=0x0001d000,n=0x00100000} :<1>
1116: <1>: List[0x004000b4]::tail=0x00093f24 => {p=0x00401000,o=0x00093f24,n=0x00000000} :<1>
1117: <1>: List[0x004000b4]::head=0x0001d000 => {p=0x00000000,o=0x0001d000,n=0x00100000} :<1>
1118: <1>: List[0x004000b4]::tail=0x00093f24 => {p=0x00401000,o=0x00093f24,n=0x00000000} :<1>
1119: <1>: Spin::acquire[SPIN=0x004000c8,ID=0x0008be84]() => {owner=573060,level=1} :<1>
1120: <1>: Heap::alloc(this=0x004000b4,bytes=20Grouping_List::search_decrementing(s=24) :<1>
1121: <1>: List[0x004000b4]::head=0x0001d000 => {p=0x00000000,o=0x0001d000,n=0x00100000} :<1>
1122: <1>: List[0x004000b4]::tail=0x00093f24 => {p=0x00401000,o=0x00093f24,n=0x00000000} :<1>
1123: <1>: ) => 0x0007fd79 :<1>
1124: <1>: Spin::release[SPIN=0x004000c8,ID=573060]() => {owner=0,level=0} :<1>
1125: <1>: Condition(<0>: Alarm::lock(size=0) :<0>
1126: <0>: Thread::lock(this=0x0008febc, level=0, owner=0) :<0>
1127: <0>: Spin::acquire[SPIN=0x00400120,ID=0x0008febc]() => {owner=589500,level=1} :<0>
1128: <0>: Alarm::unlock(size=0) :<0>
1129: <0>: Thread::unlock(this=0x0008febc, level=1, owner=589500) :<0>
1130: <0>: Spin::release[SPIN=0x00400120,ID=589500]() => {owner=0,level=0} :<0>
1131: string=], <0>: string_size=1, total_size=11, _last_position=11, _buffer=  hungry[0] :<0>
1132: <0>: StringStream::print(this=0x0007fd65), string= (, string_size=2, total_size=13, _last_position=13, _buffer=  hungry[0] ( :<0>
1133: <0>: StringStream::print(this=0x0007fd65), string=1, string_size=1, total_size=14, _last_position=14, _buffer=  hungry[0] (1 :<0>
1134: <0>: StringStream::print(this=0x0007fd65), string=), string_size=1, total_size=15, _last_position=15, _buffer=  hungry[0] (1) :<0>
1135: <0>: StringStream::print(this=0x0007fd65), string=
1136: , string_size=1, total_size=16, _last_position=16, _buffer=  hungry[0] (1)
1137:  :<0>
1138: <0>: Spin::acquire[SPIN=0x004000c8,ID=0x0008febc]() => {owner=589500,level=1} :<0>
1139: <0>: Heap::alloc(this=0x004000b4,bytes=20Grouping_List::search_decrementing(s=24) :<0>
1140: <0>: List[0x004000b4]::head=0x0001d000 => {p=0x00000000,o=0x0001d000,n=0x00100000} :<0>
1141: <0>: List[0x004000b4]::tail=0x00093f24 => {p=0x00401000,o=0x00093f24,n=0x00000000} :<0>
1142: <0>: ) => 0x0007fd61 :<0>
1143: <0>: Spin::release[SPIN=0x004000c8,ID=589500]() => {owner=0,level=0} :<0>
1144: <0>: Critical_Section_Base(_link=0x0007fd65) => 0x0007fd61 :<0>
1145: <0>: Closure(_entry=0x00006030, PARAMETERS_COUNT=3, PARAMETERS_LENGTH=12, sizeof=8) => 0x0007fd6d :<0>
1146: <0>: Spin::acquire[SPIN=0x004000c8,ID=0x0008febc]() => {owner=589500,level=1} :<0>
1147: <0>: Heap::alloc(this=0x004000b4,bytes=12Grouping_List::search_decrementing(s=16) :<0>
1148: <0>: List[0x004000b4]::head=0x0001d000 => {p=0x00000000,o=0x0001d000,n=0x00100000} :<0>
1149: <0>: List[0x004000b4]::tail=0x00093f24 => {p=0x00401000,o=0x00093f24,n=0x00000000} :<0>
1150: <0>: ) => 0x0007fd51 :<0>
1151: <0>: Spin::release[SPIN=0x004000c8,ID=589500]() => {owner=0,level=0} :<0>
1152: <0>: Closure::pack_helper(Head=4, address=0x0007fd51) :<0>
1153: <0>: Closure::pack_helper(Head=4, address=0x0007fd55) :<0>
1154: <0>: Closure::pack_helper(Head=4, address=0x0007fd59) :<0>
1155: <0>: Critical_Section(_entry=0x00006030) => 0x0007fd61 :<0>
1156: <0>: Guard::vouch(this=0x00400050 head=0x00000000 tail=0x00000000 item=0x0007fd65, size=1) => 0x0007fd7d :<1>
1157: <1>: Future(_is_resolved=0, _condition=0) => 0x0007fd79 :<1>

// Scheduler Test Program
// #define DEBUG

#include <thread>
#include <chrono>
#include <sstream>

#include <sched.h>
#include "guard.h"

// #define CONSOLE_MODE
const int iterations = 10;

Guard table;
std::thread* philosophers[5];
Future<int>* philosophers_result[5];

bool is_chopstick_free[5];
Future<int>* locked_futures[5];

void philosopher(int n, int l, int c, Future<int>* r);
void think(unsigned long long n);
void eat(unsigned long long n);
unsigned long long busy_wait(unsigned long long n);

#ifdef CONSOLE_MODE
    #define EXTRA(arg) arg
#else
    #define EXTRA(arg)
#endif

void show_message(const char * message, int line, int column) {
#ifdef CONSOLE_MODE
    LOG( message << "(" << line << ")" << std::endl )
#else
    Display::position( line, column );
    LOG( message )
#endif
}

void show_message(std::stringstream * message, int line, int column) {
#ifndef CONSOLE_MODE
    Display::position( line, column );
#endif
    LOG( message->str() )
    delete message;
}

void setup_program()
{
    Display::clear();
    Display::position(0, 0);
    LOG( "The Philosopher's Dinner:" << std::endl )

    for(int i = 0; i < 5; i++)
    {
        is_chopstick_free[i] = true;
        philosophers_result[i] = new Future<int>();
        locked_futures[i] = nullptr;
    }

    philosophers[0] = new std::thread(&philosopher, 0,  5, 30, philosophers_result[0]);
    philosophers[1] = new std::thread(&philosopher, 1, 10, 44, philosophers_result[1]);
    philosophers[2] = new std::thread(&philosopher, 2, 16, 39, philosophers_result[2]);
    philosophers[3] = new std::thread(&philosopher, 3, 16, 21, philosophers_result[3]);
    philosophers[4] = new std::thread(&philosopher, 4, 10, 17, philosophers_result[4]);

    LOG( "Philosophers are alive and hungry!" << std::endl )

    Display::position(7, 44);
    LOG( '/' )
    Display::position(13, 44);
    LOG( '\\' )
    Display::position(16, 35);
    LOG( '|' )
    Display::position(13, 27);
    LOG( '/' )
    Display::position(7, 27);
    LOG( '\\' )
    Display::position(19, 0);

    LOG( "The dinner is served ..." << std::endl )
}

// g++ -ggdb -O0 -o test application.cpp -m32 --std=c++11 -lpthread && ./test;
// Regular expression for plugin: https://github.com/evandroforks/HighlightWords
// /\) => (\dx[a-f\d]{8,8})/ /Philosopher=\d/ \bGuard::vouch\b \bGuard::clear\b
int main()
{
    DB( "main() => " << Guard::get_thread_id() << std::endl )
    table.submit( &setup_program );

    for(int i = 0; i < 5; i++) {
        philosophers[i]->join();
        int ret = philosophers_result[i]->get_value();
        std::stringstream* stream = new std::stringstream();

        *stream << "Philosopher " << i << " ate " << ret << " times\n";
        table.submit( &show_message, stream, 20 + i, 0 );
    }

    for(int i = 0; i < 5; i++) {
        delete philosophers[i];
        delete philosophers_result[i];
    }

    LOG( "The end!" << std::endl )
    return 0;
}

void release_chopstick(int philosopher_index, int chopstick_index,
        Future<int>* future_chopstick, const char* which_chopstick)
{
    DB( "Philosopher=" << philosopher_index
            << ", release chopstick=" << chopstick_index
            << ", is_chopstick_free=" << is_chopstick_free[chopstick_index]
            << ", future_chopstick=" << future_chopstick
            << ", locked_futures=" << locked_futures[chopstick_index]
            << ", " << which_chopstick )

    is_chopstick_free[chopstick_index] = true;
    delete future_chopstick;

    if( locked_futures[chopstick_index] ) {
        DB( std::endl )

        auto old = locked_futures[chopstick_index];
        locked_futures[chopstick_index] = nullptr;
        old->resolve(1);
    }
    else {
        assert( locked_futures[chopstick_index] == nullptr );
        DB( std::endl )
    }
}

void get_chopstick(int philosopher_index, int chopstick_index,
        Future<int>* future_chopstick, const char* which_chopstick)
{
    DB( "Philosopher=" << philosopher_index
            << ", getting chopstick=" << chopstick_index
            << ", is_chopstick_free=" << is_chopstick_free[chopstick_index]
            << ", " << which_chopstick )

    if( is_chopstick_free[chopstick_index] ) {
        is_chopstick_free[chopstick_index] = false;

        DB( ", future_chopstick=" << future_chopstick << std::endl )
        future_chopstick->resolve(1);
    }
    else {
        assert( locked_futures[chopstick_index] == nullptr );
        locked_futures[chopstick_index] = future_chopstick;

        DB( ", locked_futures="
                << locked_futures[chopstick_index] << std::endl )
    }
}

void philosopher(int philosopher_index, int line, int column, Future<int>* result)
{
    DB( "philosopher(index=" << philosopher_index << ") => "
            << Guard::get_thread_id() << std::endl )

    int first = (philosopher_index < 4)? philosopher_index : 0;
    int second = (philosopher_index < 4)? philosopher_index + 1 : 4;

#ifdef CONSOLE_MODE
    line = philosopher_index;
#endif

    for(int i = iterations; i > 0; i--) {
        std::stringstream* stream1 = new std::stringstream();
        *stream1 << "thinking[" << sched_getcpu() << "]"
                EXTRA( << " (" << line << ")" << "\n" );
        table.submit( &show_message, stream1, line, column );
        think(1000000);

        std::stringstream* stream2 = new std::stringstream();
        *stream2 << "  hungry[" << sched_getcpu() << "]"
                EXTRA( << " (" << line << ")" << "\n" );
        table.submit( &show_message, stream2, line, column );

        // Get the first chopstick
        Future<int>* chopstick1 = new Future<int>();
        table.submit( &get_chopstick, philosopher_index, first, chopstick1, "FIRST " );
        chopstick1->get_value();

        // Get the second chopstick
        Future<int>* chopstick2 = new Future<int>();
        table.submit( &get_chopstick, philosopher_index, second, chopstick2, "SECOND" );
        chopstick2->get_value();

    #ifdef CONSOLE_MODE
        std::stringstream* stream6 = new std::stringstream();
        *stream6 << "Philosopher=" << philosopher_index
                << ", got     the first=" << first
                << " and second=" << second << " chopstick" << "\n";
        table.submit( &show_message, stream6, line, column );
    #endif

        std::stringstream* stream3 = new std::stringstream();
        *stream3 << " eating[" << sched_getcpu() << "] " EXTRA( << "\n" );
        table.submit( &show_message, stream3, line, column );

        eat(500000);

        std::stringstream* stream4 = new std::stringstream();
        *stream4 << "    ate[" << sched_getcpu() << "]"
                EXTRA( << " (" << line << ")" << "\n" );
        table.submit( &show_message, stream4, line, column );

        // Release the chopsticks
        table.submit( &release_chopstick, philosopher_index, first, chopstick1, "FIRST " );
        table.submit( &release_chopstick, philosopher_index, second, chopstick2, "SECOND" );

    #ifdef CONSOLE_MODE
        std::stringstream* stream7 = new std::stringstream();
        *stream7 << "Philosopher=" << philosopher_index
                << ", release the first=" << first
                << " and second=" << second << " chopstick" << "\n";
        table.submit( &show_message, stream7, line, column );
    #endif
    }

    std::stringstream* stream5 = new std::stringstream();
    *stream5 << "  done[" << sched_getcpu() << "]  "
            EXTRA( << " (" << line << ")" << "\n" );
    table.submit( &show_message, stream5, line, column );

    result->resolve(iterations);
}

void eat(unsigned long long n) {
    static unsigned long long v;
    v = busy_wait(n);
}

void think(unsigned long long n) {
    static unsigned long long v;
    v = busy_wait(n);
}

unsigned long long busy_wait(unsigned long long n)
{
    volatile unsigned long long v;
    // for(long long int j = 0; j < 120 * n; j++) v &= 2 ^ j;
    std::this_thread::sleep_for(std::chrono::milliseconds(n/400));
    return v;
}

The Philosopher's Dinner:
Philosophers are alive and hungry!


                               done[2]

                          \                /


                  done[0]                    done[3]


                          /                \


                      done[3]     |     done[2]


The dinner is served ...
Philosopher 0 ate 10 times
Philosopher 1 ate 10 times
Philosopher 2 ate 10 times
Philosopher 3 ate 10 times
Philosopher 4 ate 10 times
The end!

Running the command: g++ -ggdb -O0 -o test \
        count_sync_guard/guard_scheduler_cpu_affinity.cpp \
        -m32 --std=c++11 -lpthread && ./test;
The Philosopher's Dinner:
Philosophers are alive and hungry!




                          \                /





                          /                \


                                  |


The dinner is served ...
thinking[1] (1)
thinking[0] (0)
thinking[1] (2)
thinking[2] (3)
thinking[2] (4)
  hungry[1] (1)
  hungry[0] (0)
  hungry[2] (3)
  hungry[3] (4)
  hungry[1] (2)
Philosopher=3, got     the first=3 and second=4 chopstick
 eating[1]
Philosopher=0, got     the first=0 and second=1 chopstick
 eating[0]
    ate[1] (3)
    ate[0] (0)
Philosopher=0, release the first=0 and second=1 chopstick
thinking[0] (0)
Philosopher=3, release the first=3 and second=4 chopstick
thinking[1] (3)
Philosopher=2, got     the first=2 and second=3 chopstick
 eating[0]
Philosopher=4, got     the first=0 and second=4 chopstick
 eating[0]
    ate[0] (2)
Philosopher=2, release the first=2 and second=3 chopstick
thinking[0] (2)
Philosopher=1, got     the first=1 and second=2 chopstick
 eating[0]
    ate[1] (4)
Philosopher=4, release the first=0 and second=4 chopstick
thinking[1] (4)
  hungry[0] (0)
  hungry[1] (3)
Philosopher=0, got     the first=0 and second=1 chopstick
 eating[0]
Philosopher=3, got     the first=3 and second=4 chopstick
    ate[0] (1)
Philosopher=1, release the first=1 and second=2 chopstick
thinking[0] (1)
 eating[1]
  hungry[1] (4)
    ate[0] (0)
Philosopher=0, release the first=0 and second=1 chopstick
thinking[0] (0)
    ate[0] (3)
Philosopher=3, release the first=3 and second=4 chopstick
thinking[0] (3)
  hungry[0] (2)
Philosopher=4, got     the first=0 and second=4 chopstick
 eating[1]
Philosopher=2, got     the first=2 and second=3 chopstick
 eating[0]
  hungry[0] (1)
    ate[1] (4)
    ate[0] (2)
Philosopher=2, release the first=2 and second=3 chopstick
thinking[0] (2)
Philosopher=1, got     the first=1 and second=2 chopstick
 eating[0]
Philosopher=4, release the first=0 and second=4 chopstick
thinking[1] (4)
  hungry[0] (0)
  hungry[1] (3)
Philosopher=3, got     the first=3 and second=4 chopstick
 eating[1]
    ate[0] (1)
Philosopher=1, release the first=1 and second=2 chopstick
thinking[0] (1)
Philosopher=0, got     the first=0 and second=1 chopstick
 eating[1]
    ate[1] (3)
  hungry[0] (2)
Philosopher=3, release the first=3 and second=4 chopstick
Philosopher=2, got     the first=2 and second=3 chopstick
 eating[0]
    ate[0] (0)
thinking[1] (3)
Philosopher=0, release the first=0 and second=1 chopstick
thinking[0] (0)
  hungry[0] (4)
Philosopher=4, got     the first=0 and second=4 chopstick
 eating[0]
  hungry[0] (1)
    ate[0] (2)
    ate[1] (4)
Philosopher=2, release the first=2 and second=3 chopstick
thinking[0] (2)
Philosopher=4, release the first=0 and second=4 chopstick
thinking[1] (4)
Philosopher=1, got     the first=1 and second=2 chopstick
 eating[1]
  hungry[1] (3)
Philosopher=3, got     the first=3 and second=4 chopstick
 eating[1]
  hungry[0] (0)
    ate[1] (1)
Philosopher=1, release the first=1 and second=2 chopstick
thinking[1] (1)
Philosopher=0, got     the first=0 and second=1 chopstick
 eating[1]
    ate[1] (3)
  hungry[0] (2)
Philosopher=3, release the first=3 and second=4 chopstick
thinking[1] (3)
  hungry[1] (4)
Philosopher=2, got     the first=2 and second=3 chopstick
 eating[0]
    ate[1] (0)
Philosopher=0, release the first=0 and second=1 chopstick
thinking[1] (0)
Philosopher=4, got     the first=0 and second=4 chopstick
 eating[1]
  hungry[1] (1)
    ate[0] (2)
Philosopher=2, release the first=2 and second=3 chopstick
thinking[0] (2)
Philosopher=1, got     the first=1 and second=2 chopstick
 eating[1]
    ate[1] (4)
Philosopher=4, release the first=0 and second=4 chopstick
thinking[1] (4)
  hungry[1] (3)
Philosopher=3, got     the first=3 and second=4 chopstick
 eating[1]
    ate[1] (1)
Philosopher=1, release the first=1 and second=2 chopstick
thinking[1] (1)
  hungry[1] (0)
Philosopher=0, got     the first=0 and second=1 chopstick
 eating[1]
  hungry[0] (2)
    ate[0] (3)
Philosopher=3, release the first=3 and second=4 chopstick
thinking[0] (3)
Philosopher=2, got     the first=2 and second=3 chopstick
 eating[0]
  hungry[0] (4)
    ate[0] (0)
Philosopher=0, release the first=0 and second=1 chopstick
thinking[0] (0)
Philosopher=4, got     the first=0 and second=4 chopstick
 eating[0]
  hungry[1] (1)
    ate[1] (2)
Philosopher=2, release the first=2 and second=3 chopstick
thinking[1] (2)
Philosopher=1, got     the first=1 and second=2 chopstick
 eating[1]
    ate[1] (4)
Philosopher=4, release the first=0 and second=4 chopstick
thinking[1] (4)
  hungry[0] (3)
Philosopher=3, got     the first=3 and second=4 chopstick
 eating[0]
  hungry[0] (0)
    ate[1] (1)
Philosopher=0, got     the first=0 and second=1 chopstick
 eating[1]
Philosopher=1, release the first=1 and second=2 chopstick
thinking[1] (1)
    ate[0] (3)
  hungry[1] (2)
Philosopher=3, release the first=3 and second=4 chopstick
thinking[0] (3)
Philosopher=2, got     the first=2 and second=3 chopstick
 eating[0]
  hungry[0] (4)
    ate[0] (0)
Philosopher=0, release the first=0 and second=1 chopstick
thinking[0] (0)
Philosopher=4, got     the first=0 and second=4 chopstick
 eating[0]
    ate[0] (2)
Philosopher=2, release the first=2 and second=3 chopstick
thinking[0] (2)
  hungry[1] (1)
Philosopher=1, got     the first=1 and second=2 chopstick
 eating[1]
    ate[1] (4)
Philosopher=4, release the first=0 and second=4 chopstick
thinking[1] (4)
  hungry[1] (0)
  hungry[0] (3)
Philosopher=3, got     the first=3 and second=4 chopstick
 eating[1]
    ate[1] (1)
Philosopher=0, got     the first=0 and second=1 chopstick
 eating[1]
Philosopher=1, release the first=1 and second=2 chopstick
thinking[1] (1)
  hungry[0] (2)
    ate[1] (0)
Philosopher=0, release the first=0 and second=1 chopstick
  hungry[0] (4)
    ate[0] (3)
Philosopher=3, release the first=3 and second=4 chopstick
thinking[0] (3)
Philosopher=2, got     the first=2 and second=3 chopstick
 eating[0]
thinking[1] (0)
Philosopher=4, got     the first=0 and second=4 chopstick
 eating[0]
  hungry[1] (1)
    ate[0] (2)
Philosopher=2, release the first=2 and second=3 chopstick
thinking[0] (2)
Philosopher=1, got     the first=1 and second=2 chopstick
    ate[0] (4)
Philosopher=4, release the first=0 and second=4 chopstick
thinking[0] (4)
 eating[1]
  hungry[0] (3)
  hungry[1] (0)
Philosopher=3, got     the first=3 and second=4 chopstick
 eating[0]
    ate[0] (1)
Philosopher=0, got     the first=0 and second=1 chopstick
 eating[0]
Philosopher=1, release the first=1 and second=2 chopstick
thinking[0] (1)
    ate[0] (3)
Philosopher=3, release the first=3 and second=4 chopstick
thinking[0] (3)
  hungry[0] (4)
  hungry[1] (2)
Philosopher=2, got     the first=2 and second=3 chopstick
 eating[1]
    ate[1] (0)
Philosopher=0, release the first=0 and second=1 chopstick
thinking[1] (0)
Philosopher=4, got     the first=0 and second=4 chopstick
 eating[1]
    ate[1] (2)
  hungry[0] (1)
Philosopher=2, release the first=2 and second=3 chopstick
thinking[1] (2)
Philosopher=1, got     the first=1 and second=2 chopstick
 eating[1]
    ate[1] (4)
Philosopher=4, release the first=0 and second=4 chopstick
thinking[1] (4)
  hungry[0] (3)
Philosopher=3, got     the first=3 and second=4 chopstick
 eating[0]
  hungry[1] (0)
    ate[0] (1)
Philosopher=1, release the first=1 and second=2 chopstick
thinking[0] (1)
Philosopher=0, got     the first=0 and second=1 chopstick
 eating[1]
    ate[0] (3)
Philosopher=3, release the first=3 and second=4 chopstick
thinking[0] (3)
    ate[1] (0)
Philosopher=0, release the first=0 and second=1 chopstick
thinking[1] (0)
  hungry[1] (2)
  hungry[1] (4)
Philosopher=4, got     the first=0 and second=4 chopstick
 eating[0]
Philosopher=2, got     the first=2 and second=3 chopstick
 eating[1]
  hungry[0] (1)
    ate[0] (4)
Philosopher=4, release the first=0 and second=4 chopstick
thinking[0] (4)
    ate[0] (2)
Philosopher=2, release the first=2 and second=3 chopstick
thinking[0] (2)
Philosopher=1, got     the first=1 and second=2 chopstick
 eating[0]
  hungry[1] (0)
  hungry[1] (3)
Philosopher=3, got     the first=3 and second=4 chopstick
 eating[1]
    ate[1] (1)
Philosopher=0, got     the first=0 and second=1 chopstick
 eating[1]
Philosopher=1, release the first=1 and second=2 chopstick
thinking[1] (1)
    ate[1] (0)
  hungry[0] (2)
  hungry[0] (4)
    ate[1] (3)
Philosopher=3, release the first=3 and second=4 chopstick
  done[1]   (3)
Philosopher=0, release the first=0 and second=1 chopstick
  done[1]   (0)
Philosopher 0 ate 10 times
Philosopher=2, got     the first=2 and second=3 chopstick
 eating[1]
Philosopher=4, got     the first=0 and second=4 chopstick
 eating[3]
  hungry[1] (1)
    ate[1] (2)
    ate[3] (4)
Philosopher=4, release the first=0 and second=4 chopstick
  done[3]   (4)
Philosopher=2, release the first=2 and second=3 chopstick
  done[1]   (2)
Philosopher=1, got     the first=1 and second=2 chopstick
 eating[3]
    ate[3] (1)
Philosopher=1, release the first=1 and second=2 chopstick
  done[3]   (1)
Philosopher 1 ate 10 times
Philosopher 2 ate 10 times
Philosopher 3 ate 10 times
Philosopher 4 ate 10 times
The end!

// EPOS Synchronizer Component Test Program

#include <utility/ostream.h>
#include <utility/guard.h>
#include <utility/future.h>
#include <utility/debug_sync.h>
#include <utility/list.h>
#include <thread.h>
#include <alarm.h>

#if !defined(nullptr)
    #define nullptr 0
#endif

using namespace EPOS;

#define CONSOLE_MODE
const int iterations = 10;

Guard table;
OStream cout;

const int BUF_SIZE = 16;
char buffer[BUF_SIZE];

int full = 0;
int empty = BUF_SIZE;

Simple_List<Future<bool>*> pending_consume_futures;
Simple_List<Future<bool>*> pending_produce_futures;

#ifdef CONSOLE_MODE
    #define EXTRA(arg)
#else
    #define EXTRA
#endif

void consume() {
    EXTRA( LOG( "consume(empty=" << empty ) )

    Simple_List<Future<bool>*>::Element* element
            = pending_consume_futures.remove_tail();

    EXTRA( LOG( " element=" << element ) )
    EXTRA( LOG( ")" << endl ) )

    if( element )
    {
        Future<bool>* future = *element->object();
        future->resolve(true);
    }

    ++empty;
}

void can_consume(Future<bool>* can_consume) {
    EXTRA( LOG( "can_consume(full=" << full << ")" << endl ) )

    if(full > 0) {
        --full;
        can_consume->resolve(true);
    }
    else {
        Simple_List<Future<bool>*>::Element* element =
                new Simple_List<Future<bool>*>::Element(&can_consume);
        pending_consume_futures.insert(element);
    }
}

int consumer() {
    EXTRA( LOG( "consumer(this=" << Thread::self() << ")" << endl ) )

    int out = 0;
    for(int i = 0; i < iterations; i++)
    {
        // full.p();
        Future<bool>* future = new Future<bool>();
        table.submit(can_consume, future);
        future->get_value();

        cout << "C<-" << buffer[out] << "\t";
        out = (out + 1) % BUF_SIZE;
        Alarm::delay(5000);

        // empty.v();
        table.submit(consume);
    }

    return 0;
}

void can_produce(Future<bool>* can_consume) {
    EXTRA( LOG( "can_produce(empty=" << empty << ")" << endl ) )

    if(empty > 0) {
        --empty;
        can_consume->resolve(true);
    }
    else {
        Simple_List<Future<bool>*>::Element* element =
                new Simple_List<Future<bool>*>::Element(&can_consume);
        pending_produce_futures.insert(element);
    }
}

void produce() {
    EXTRA( LOG( "produce(full=" << full ) )

    Simple_List<Future<bool>*>::Element* element
            = pending_produce_futures.remove_tail();

    EXTRA( LOG( " element=" << element ) )
    EXTRA( LOG( ")" << endl ) )

    if( element )
    {
        Future<bool>* future = *element->object();
        future->resolve(true);
    }

    ++full;
}

int main() {
    Thread * cons = new Thread(&consumer);

    // producer
    int in = 0;
    for(int i = 0; i < iterations; i++) {
        // empty.p();
        Future<bool>* future = new Future<bool>();
        table.submit(can_produce, future);
        future->get_value();

        Alarm::delay(5000);
        buffer[in] = 'a' + in;
        cout << "P->" << buffer[in] << "\t";
        in = (in + 1) % BUF_SIZE;

        // full.v();
        table.submit(produce);
    }

    cons->join();
    cout << "The end!" << endl;

    delete cons;
    return 0;
}

can_produce(empty=16)
consumer(this=0x00097f44)
can_consume(full=0)
P->a    produce(full=0 element=0x00000000)
can_produce(empty=15)
P->b    produce(full=1 element=0x00000000)
can_produce(empty=14)
P->c    produce(full=2 element=0x00000000)
can_produce(empty=13)
P->d    produce(full=3 element=0x00000000)
can_produce(empty=12)
P->e    produce(full=4 element=0x00000000)
can_produce(empty=11)
P->f    produce(full=5 element=0x00000000)
can_produce(empty=10)
P->g    produce(full=6 element=0x00000000)
can_produce(empty=9)
P->h    produce(full=7 element=0x00000000)
can_produce(empty=8)
P->i    produce(full=8 element=0x00000000)
can_produce(empty=7)
P->j    produce(full=9 element=0x00000000)

// EPOS Synchronizer Component Test Program

#include <utility/ostream.h>
#include <thread.h>
#include <alarm.h>
#include <utility/guard.h>
#include <utility/future.h>
#include <condition.h>
#include <clock.h>
#include <utility/random.h>

using namespace EPOS;

const int iterations = 100;

OStream cout;
Clock clock;

Guard buffer_guard;
Condition full;
Condition empty;
const int BUF_SIZE = 16;
char buffer[BUF_SIZE];
int buffer_count = 0;
int total_count = 0;
int out = 0;
int in = 0;

void check_load(Future<bool> * wait){
    if(buffer_count > 0){ // checking whether the buffer IS empty
        wait->resolve(false);
    } else {
        wait->resolve(true);
    }
}

void load(Future<char> * item)
{
    item->resolve(buffer[out]);
    cout << "C<-" << buffer[out] << "\t";
    total_count++;
    if (total_count > 10){
        cout << "\n";
        total_count = 0;
    }
    out = (out + 1) % BUF_SIZE;
    buffer_count--;
    if (buffer_count == BUF_SIZE-1){
        //cout << "Some Producer Wakeup"  << "\n";
        full.signal(); // wakeup waiting producer
    }
}

void check_store(Future<bool> * wait){
    if(buffer_count >= BUF_SIZE) // checking whether the buffer IS full
        wait->resolve(true);
    else
        wait->resolve(false);
}

void store(char item)
{
    buffer[in] = item;
    cout << "P->" << item << "\t";
    total_count++;
    if (total_count > 10){
        cout << "\n";
        total_count = 0;
    }
    in = (in + 1) % BUF_SIZE;
    buffer_count++;
    if (buffer_count == 1){
        //cout << "Some Consumer Wakeup"  << "\n";
        empty.signal(); // wakeup waiting consumer
    }
}

int consumer()
{
    for(int i = 0; i < iterations; i++) {
        Future<char> item{};
        Future<bool> wait{};
        buffer_guard.submit(check_load, &wait); // checking whether wait is necessary
        if (wait.get_value()){
            empty.wait(); // wait somehow
        }
        buffer_guard.submit(load, &item); // load item from buffer
        item.get_value();  // consume - part1
        unsigned long int delay_rand = Random::random();
        unsigned long int true_rand = (delay_rand > 9999) ? delay_rand / 10000 : delay_rand;
        Alarm::delay(true_rand/5); // consume - part3
    }
    return 0;
}

int producer()
{
    for(int i = 0; i < iterations; i++) {
        unsigned long int delay_rand = Random::random();
        unsigned long int true_rand = (delay_rand > 9999) ? delay_rand / 1000 : delay_rand;
        Alarm::delay(true_rand/20); // consume - part3
        char item = 'a' + in;  // produce - part2
        Future<bool> wait{};
        buffer_guard.submit(check_store, &wait); // checking whether wait is necessary
        if(wait.get_value()){
            //cout << "Producer Waiting"  << "\n";
            full.wait();
            //cout << "Producer Awaking"  << "\n";
        }
        buffer_guard.submit(store, item); // store item on buffer
    }
    return 0;
}

int main()
{
    cout << "Main started!" << endl;

    unsigned long int ini = clock.now();
    Random::seed(ini);

    Thread * prod = new Thread(&producer);
    Thread * cons = new Thread(&consumer);

    cons->join();
    prod->join();

    cout << "The end!" << endl;

    delete cons;
    delete prod;

    return 0;
}

Main started!
P->a    C<-a    P->b    C<-b    P->c    C<-c    P->d    C<-d    P->e    C<-e    P->f
C<-f    P->g    C<-g    P->h    C<-h    P->i    C<-i    P->j    C<-j    P->k    C<-k
P->l    C<-l    P->m    C<-m    P->n    C<-n    P->o    C<-o    P->p    C<-p    P->a
C<-a    P->b    C<-b    P->c    C<-c    P->d    P->e    C<-d    C<-e    P->f    C<-f
P->g    C<-g    P->h    C<-h    P->i    C<-i    P->j    C<-j    P->k    C<-k    P->l
C<-l    P->m    C<-m    P->n    C<-n    P->o    C<-o    P->p    C<-p    P->a    C<-a
P->b    C<-b    P->c    C<-c    P->d    C<-d    P->e    C<-e    P->f    C<-f    P->g
C<-g    P->h    C<-h    P->i    C<-i    P->j    C<-j    P->k    C<-k    P->l    C<-l
P->m    C<-m    P->n    C<-n    P->o    C<-o    P->p    C<-p    P->a    C<-a    P->b
C<-b    P->c    C<-c    P->d    C<-d    P->e    C<-e    P->f    C<-f    P->g    C<-g
P->h    C<-h    P->i    C<-i    P->j    C<-j    P->k    C<-k    P->l    C<-l    P->m
C<-m    P->n    C<-n    P->o    C<-o    P->p    C<-p    P->a    C<-a    P->b    C<-b
P->c    C<-c    P->d    P->e    C<-d    P->f    C<-e    P->g    C<-f    C<-g    P->h
C<-h    P->i    C<-i    P->j    C<-j    P->k    C<-k    P->l    C<-l    P->m    C<-m
P->n    C<-n    P->o    C<-o    P->p    C<-p    P->a    C<-a    P->b    C<-b    P->c
C<-c    P->d    C<-d    P->e    C<-e    P->f    C<-f    P->g    C<-g    P->h    C<-h
P->i    C<-i    P->j    C<-j    P->k    C<-k    P->l    C<-l    P->m    C<-m    P->n
C<-n    P->o    C<-o    P->p    C<-p    P->a    C<-a    P->b    C<-b    P->c    C<-c
P->d    C<-d    The end!