source: tests/concurrency/suspend_then.cfa@ 0244ab6

#include <fstream.hfa>
#include <kernel.hfa>
#include <thread.hfa>
#include <time.hfa>
#include <stdlib.hfa>
#include <string.h>

#define __kick_rate 150000ul
#include "long_tests.hfa"

Duration default_preemption() {
        return 0;
}

#ifdef TEST_LONG
static const unsigned long N = 600_000ul;
#else
static const unsigned long N = 1_000ul;
#endif

#if ! defined(TEST_FOREVER)
        static inline void print(const char * const text ) {
                write( STDOUT_FILENO, text, strlen(text) );
        }
#else
        static inline void print( Printer & this, const char * const text ) {}
#endif

generator Coroutine { int i; };

volatile bool done = false;
Coroutine * volatile the_cor = 0p;

void store(Coroutine & cor) {
        __atomic_store_n( &the_cor, &cor, __ATOMIC_SEQ_CST );
}

Coroutine * take( void ) {
        Coroutine * val = 0p;
        Coroutine * ret = __atomic_exchange_n( &the_cor, val, __ATOMIC_SEQ_CST );
        assert( ! ret || ! the_cor );
        return ret;
}

void main( Coroutine & this ) with( this ) {
        suspend;
        for( i = 0; TEST( i < N ); i++ ) {
                print( "C - Suspending\n" );
                suspend{
                        print( "C - Publishing\n" );
                        assert( ! the_cor );
                        store( this );
                }
                assert( ! the_cor );
                print( "C - Back\n" );
                KICK_WATCHDOG;
                yield();
        }
        done = true;
        suspend;
}

thread Thread {};
void main( Thread & ) {
        Coroutine * mine = 0p;
        while ( ! done ) {
                yield();
                mine = take();
                if ( ! mine ) continue;

                print( "T - took\n" );
                resume( *mine );
        }
}


int main() {
        processor p[2];
        Coroutine c;
        resume( c ); // Prime the coroutine to avoid one of the threads being its starter

        #pragma GCC diagnostic push
        #pragma GCC diagnostic ignored "-Wdangling-pointer"     // this assignment is ok
        the_cor = &c;
        #pragma GCC diagnostic pop

        {
                Thread t[2];
        }
}