ccgs.c

Go to the documentation of this file.

#include <stdbool.h>
#include <core/core.h>
#include <core/init.h>
#include <mm/mm.h>
#include <mm/state.h>
#include <communication/communication.h>
#include <communication/mpi.h>
#include <gvt/ccgs.h>
#include <scheduler/scheduler.h>
#include <scheduler/process.h>

static bool ccgs_completed_simulation = false;

static bool *lps_termination;

inline bool ccgs_can_halt_simulation(void)
{
#ifdef HAVE_MPI
    return (ccgs_completed_simulation && all_kernels_terminated());
#else
    return ccgs_completed_simulation;
#endif
}

// Deve essere chiamata da un solo thread al GVT
void ccgs_reduce_termination(void)
{
    register unsigned int i;
    bool termination = true;

    /* Local termination:  all LPs need to be terminated */
    for (i = 0; i < n_prc; i++) {
        termination &= lps_termination[i];
    }

#ifdef HAVE_MPI
    /* If terminated locally check for global termination
     * All other kernel need to terminated
     */
    if (unlikely(!ccgs_completed_simulation && termination)) {
        broadcast_termination();
    }
#endif

    ccgs_completed_simulation = termination;
}

void ccgs_compute_snapshot(state_t * time_barrier_pointer[], simtime_t gvt)
{
    int i;
    bool check_res = true;
    state_t temporary_log;

    (void)gvt;      // This is used for state reconstruction which is currently commented out
    //msg_t *realignment_evt;

    i = -1;
    foreach_bound_lp(lp) {
        i++;

        // If termination detection is incremental, we skip the current LP
        if (rootsim_config.check_termination_mode == CKTRM_INCREMENTAL && lps_termination[lp->lid.to_int]) {
            continue;
        }

        if (time_barrier_pointer[i] == NULL)
            continue;

        // TODO: realign LogState and RestoreState to be compliant with the execution in the committed portion

        // Log the current state so that after we can restore it.
        current = lp;
        temporary_log.log = log_state(lp);
        temporary_log.state = lp->state;
        temporary_log.base_pointer = lp->current_base_pointer;

        // Restore the time barrier state
        log_restore(lp, time_barrier_pointer[i]);
        lp->state = time_barrier_pointer[i]->state;
        lp->current_base_pointer =
            time_barrier_pointer[i]->base_pointer;

/*
        // If the LP is not blocked, we can reconstruct the state exactly to the GVT
        if(!is_blocked_state(lp->state))  {
            // Realign the state to the current GVT value
            if(list_next(time_barrier_pointer[i]->last_event) != NULL) {
                realignment_evt = list_next(time_barrier_pointer[i]->last_event);
                while(realignment_evt != NULL && realignment_evt->timestamp < gvt) {
                    realignment_evt = list_next(realignment_evt);
                }
                realignment_evt = list_prev(realignment_evt);

                // TODO: LPS[lid]->current_base_pointer can be removed as a parameter
                silent_execution(lid, LPS(lid)->current_base_pointer, list_next(time_barrier_pointer[i]->last_event), realignment_evt);
            }
        }

*/
        // Call the application to check termination
        lps_termination[lp->lid.to_int] =
            lp->OnGVT(lp->gid.to_int, lp->current_base_pointer);
        check_res &= lps_termination[lp->lid.to_int];

        // Restore the current state
        lp->state = temporary_log.state;
        lp->current_base_pointer = temporary_log.base_pointer;
        log_restore(lp, &temporary_log);
        log_delete(temporary_log.log);

        // Early stop
        if (rootsim_config.check_termination_mode == CKTRM_INCREMENTAL && !check_res) {
            break;
        }

    }

    // No real LP is running now!
    current = NULL;
}

void ccgs_init(void)
{
    lps_termination = rsalloc(sizeof(bool) * n_prc);
    memset(lps_termination, 0, sizeof(bool) * n_prc);
}

void ccgs_fini(void)
{
    rsfree(lps_termination);
}