core.c

Go to the documentation of this file.

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <limits.h>
#include <signal.h>

#include <arch/thread.h>
#include <core/core.h>
#include <core/init.h>
#include <scheduler/process.h>
#include <scheduler/scheduler.h>
#include <statistics/statistics.h>
#include <gvt/gvt.h>
#include <mm/mm.h>

barrier_t all_thread_barrier;

unsigned int *kernel;

unsigned int kid;

unsigned int n_ker;

unsigned int n_cores;

unsigned int n_prc_tot;

unsigned int n_prc;

simulation_configuration rootsim_config;

static bool sim_error = false;

bool exit_silently_from_kernel = false;

static bool init_complete = false;

bool user_exit_flag = false;

void exit_from_simulation_model(void)
{

    if (likely(!init_complete))
        return;

    if (unlikely(!exit_silently_from_kernel)) {
        exit_silently_from_kernel = true;

        printf("Warning: exit() has been called from the model.\n"
               "The simulation will now halt, but its unlikely what you really wanted...\n"
               "You should use OnGVT() instead. See the manpages for an explanation.\n");

        simulation_shutdown(EXIT_FAILURE);
    }
}

inline bool user_requested_exit(void)
{
    return user_exit_flag;
}

static void handle_signal(int signum)
{
    if (signum == SIGINT) {
        user_exit_flag = true;
    }
}

void base_init(void)
{
    struct sigaction new_act = { 0 };

    barrier_init(&all_thread_barrier, n_cores);

    // complete the sigaction struct init
    new_act.sa_handler = handle_signal;
    // we set the signal action so that it auto disarms itself after the first invocation
    new_act.sa_flags = SA_RESETHAND;
    // register the signal handler
    sigaction(SIGINT, &new_act, NULL);
    // register the exit function
    atexit(exit_from_simulation_model);
}

void base_fini(void)
{
}

__attribute__((pure))
unsigned int find_kernel_by_gid(GID_t gid)
{
    // restituisce il kernel su cui si trova il processo identificato da gid
    return kernel[gid.to_int];
}

void simulation_shutdown(int code)
{

    exit_silently_from_kernel = true;

    statistics_stop(code);

    if (likely(rootsim_config.serial == false)) {

        thread_barrier(&all_thread_barrier);

        if (master_thread()) {
            statistics_fini();
            gvt_fini();
            communication_fini();
            scheduler_fini();
            base_fini();
        }

        thread_barrier(&all_thread_barrier);
    }

    exit(code);
}

inline bool simulation_error(void)
{
    return sim_error;
}

void _rootsim_error(bool fatal, const char *msg, ...)
{
    char buf[1024];
    va_list args;

    va_start(args, msg);
    vsnprintf(buf, 1024, msg, args);
    va_end(args);

    fprintf(stderr, (fatal ? "[FATAL ERROR] " : "[WARNING] "));

    fprintf(stderr, "%s", buf);
    fflush(stderr);

    if (fatal) {
        if (rootsim_config.serial) {
            exit(EXIT_FAILURE);
        } else {

            if (!init_complete) {
                exit(EXIT_FAILURE);
            }

            // Notify all KLT to shut down the simulation
            sim_error = true;

            // Bye bye main loop!
            longjmp(exit_jmp, 1);
        }
    }
}

void distribute_lps_on_kernels(void)
{
    register unsigned int i = 0;
    unsigned int j;
    unsigned int buf1;
    int offset;
    int block_leftover;

    // Sanity check on number of LPs
    if (n_prc_tot < n_ker) {
        rootsim_error(true, "Unable to allocate %d logical processes on %d kernels: must have at least %d LPs\n", n_prc_tot, n_ker, n_ker);
    }

    kernel = (unsigned int *)rsalloc(sizeof(unsigned int) * n_prc_tot);

    switch (rootsim_config.lps_distribution) {

    case LP_DISTRIBUTION_BLOCK:
        buf1 = (n_prc_tot / n_ker);
        block_leftover = n_prc_tot - buf1 * n_ker;

        // It is a hack to bypass the first check that set offset to 0
        if (block_leftover > 0)
            buf1++;

        offset = 0;
        while (i < n_prc_tot) {
            j = 0;
            while (j < buf1) {
                kernel[i] = offset;

                if (kernel[i] == kid)
                    n_prc++;

                i++;
                j++;
            }
            offset++;
            block_leftover--;
            if (block_leftover == 0)
                buf1--;
        }
        break;

    case LP_DISTRIBUTION_CIRCULAR:
        for (i = 0; i < n_prc_tot; i++) {
            kernel[i] = i % n_ker;

            if (kernel[i] == kid)
                n_prc++;
        }
        break;
    }
}

void initialization_complete(void)
{
    init_complete = true;
}