source: tests/concurrent/migrate.cfa @ b3d794fc

#include <fstream.hfa>
#include <kernel.hfa>
#include <thread.hfa>

#include <stdatomic.h>
#include <assert.h>

struct cluster_wrapper {
        cluster self;
        const uint64_t canary;
        struct {
                volatile uint64_t want;
                volatile uint64_t have;
        } checksum;
};

void ?{}( cluster_wrapper & this ) {
        (this.self){};
        (*(uint64_t *)&this.canary) = 0xDEAD2BADDEAD2BAD;
        this.checksum.want = 0;
        this.checksum.have = 0;
}

void ^?{}( cluster_wrapper & this ) {
        assert(this.canary == 0xDEAD2BADDEAD2BAD);
}

static cluster_wrapper * the_clusters;
static unsigned cluster_cnt;

thread MyThread {

};

void ?{}( MyThread & this ) {}

void checkcl( MyThread & this, cluster * cl) {
        if(((thread&)this).curr_cluster != cl) {
                abort | "Thread has unexpected cluster";
        }
}

void main( MyThread & this ) {
        waitfor( migrate : this ) {
                assert( ((thread&)this).curr_cluster == active_cluster() );
                assert( ((thread&)this).curr_cluster == active_processor()->cltr );
        }

        struct cluster_wrapper * curr = (struct cluster_wrapper *)&the_clusters[0];

        for(100) {
                unsigned idx = prng( this, cluster_cnt );

                struct cluster_wrapper * next = &the_clusters[ idx ];
                assert(next->canary == 0xDEAD2BADDEAD2BAD);

                // next->

                migrate( this, next->self );

                assert( active_cluster() == &next->self );
                assert( ((thread&)this).curr_cluster == active_cluster() );
                assert( ((thread&)this).curr_cluster == active_processor()->cltr );
        }
}

int main() {
        cluster_cnt = 3;
        cluster_wrapper cl[cluster_cnt];
        the_clusters = cl;

        {
                set_concurrency( cl[0].self, 2 );
                set_concurrency( cl[1].self, 2 );
                set_concurrency( cl[2].self, 1 );

                MyThread threads[17];
                for(i;17) {
                        migrate( threads[i], cl[0].self );
                }

        }
        // non-empty .expect file
        printf( "done\n" );
}