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[])
{
    int i = -1;
    bool check_res = true;

    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;

        // Call the application to check termination
        lps_termination[lp->lid.to_int] = time_barrier_pointer[i]->simulation_completed;
        check_res &= lps_termination[lp->lid.to_int];

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

    }

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


bool ccgs_lp_can_halt(struct lp_struct *lp)
{
    bool ret;
    if (rootsim_config.check_termination_mode == CKTRM_INCREMENTAL && lps_termination[lp->lid.to_int]) {
        return true;
    }
    current = lp;
    ret = lp->OnGVT(lp->gid.to_int, lp->current_base_pointer);
    current = NULL;
    
    return ret;
}

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);
}