thread.c

Go to the documentation of this file.

#include <stdbool.h>
#include <arch/thread.h>
#include <core/init.h>
#include <mm/mm.h>

static tid_t os_tid;


__thread unsigned int tid;


__thread unsigned int local_tid;


static unsigned int thread_counter = 0;


static void *__helper_create_thread(void *arg)
{

    struct _helper_thread *real_arg = (struct _helper_thread *)arg;

    // Get a unique local thread id...
    unsigned int old_counter;
    unsigned int _local_tid;

    while (true) {
        old_counter = thread_counter;
        _local_tid = old_counter + 1;
        if (iCAS(&thread_counter, old_counter, _local_tid)) {
            break;
        }
    }
    local_tid = _local_tid;

    // ...and make it globally unique
    tid = to_global_tid(kid, _local_tid);

    // Set the affinity on a CPU core, for increased performance
    if (likely(rootsim_config.core_binding))
        set_affinity(local_tid);

    // Now get into the real thread's entry point
    real_arg->start_routine(real_arg->arg);

    // Free arg and return (we don't really need any return value)
    rsfree(arg);
    return NULL;
}

void create_threads(unsigned short int n, void *(*start_routine)(void *), void *arg)
{
    int i;

    // We create our thread within our helper function, which accepts just
    // one parameter. We thus have to create one single parameter containing
    // the original pointer and the function to be used as real entry point.
    // This malloc'd array is free'd by the helper function.
    struct _helper_thread *new_arg = rsalloc(sizeof(struct _helper_thread));
    new_arg->start_routine = start_routine;
    new_arg->arg = arg;

    // n threads are created simply looping...
    for (i = 0; i < n; i++) {
        new_thread(__helper_create_thread, (void *)new_arg);
    }
}

void barrier_init(barrier_t * b, int t)
{
    b->num_threads = t;
    thread_barrier_reset(b);
}

bool thread_barrier(barrier_t * b)
{
    // Wait for the leader to finish resetting the barrier
    while (atomic_read(&b->barr) != -1) ;

    // Wait for all threads to synchronize
    atomic_dec(&b->c1);
    while (atomic_read(&b->c1)) ;

    // Leader election
    if (unlikely(atomic_inc_and_test(&b->barr))) {

        // I'm sync'ed!
        atomic_dec(&b->c2);

        // Wait all the other threads to leave the first part of the barrier
        while (atomic_read(&b->c2)) ;

        // Reset the barrier to its initial values
        thread_barrier_reset(b);

        return true;
    }
    // I'm sync'ed!
    atomic_dec(&b->c2);

    return false;
}