DLB.hpp

/*
 * DLB.hpp
 *
 *  Created on: Nov 20, 2015
 *      Author: Antonio Leo
 */
 
#ifndef SRC_DECOMPOSITION_DLB_HPP_
#define SRC_DECOMPOSITION_DLB_HPP_
 
struct Times
{
    size_t simulationStartTime = 0;
 
    size_t simulationEndTime;
 
    double timeStep = 0.1;
 
 
    size_t iterationStartTime;
 
    size_t iterationEndTime;
};
 
class DLB
{
public:
 
    enum Heuristic
    {
        SAR_HEURISTIC, UNBALANCE_THRLD
    };
 
    enum ThresholdLevel
    {
        THRLD_LOW = 5, THRLD_MEDIUM = 7, THRLD_HIGH = 10
    };
 
private:
 
    Vcluster<> & v_cl;
 
    Times timeInfo;
 
    float w_n = -1;
 
    float c_c = 5;
 
    size_t n_ts = 1;
 
    float i_time = 0;
 
    openfpm::vector<long> times;
 
    Heuristic heuristic = UNBALANCE_THRLD;
 
    float unbalance = -1;
 
    ThresholdLevel thl = THRLD_MEDIUM;
 
    inline bool SAR()
    {
        long t = timeInfo.iterationEndTime - timeInfo.iterationStartTime;
        float t_max = t, t_avg = t;
 
        // Exchange time informations through processors
        v_cl.max(t_max);
        v_cl.sum(t_avg);
        v_cl.execute();
 
        t_avg /= v_cl.getProcessingUnits();
 
        // add idle time to vector
        i_time += t_max - t_avg;
 
        // Compute Wn
        float nw_n = (i_time + c_c) / n_ts;
 
        if (w_n == -1)
            w_n = nw_n;
 
        if (nw_n > w_n)
        {
            i_time = 0;
            n_ts = 1;
            w_n = nw_n;
            return true;
        }
        else
        {
            ++n_ts;
            w_n = nw_n;
            return false;
        }
    }
 
    bool unbalanceThreshold()
    {
        if (unbalance == -1)
        {
            std::cerr << "Error: Un-balance value must be set before checking DLB.";
            return false;
        }
 
        if (unbalance > thl)
        {
            return true;
        }
 
        return false;
    }
 
public:
 
    DLB(Vcluster<> & v_cl) :
            v_cl(v_cl)
    {
    }
 
    void setHeurisitc(Heuristic h)
    {
        heuristic = h;
    }
 
    Heuristic getHeurisitc()
    {
        return heuristic;
    }
 
    bool rebalanceNeeded()
    {
        if (heuristic == SAR_HEURISTIC)
        {
            return SAR();
        }
        else
        {
            return unbalanceThreshold();
        }
    }
 
    void setSimulationStartTime(size_t t)
    {
        timeInfo.simulationStartTime = t;
    }
 
    size_t getSimulationStartTime()
    {
        return timeInfo.simulationStartTime;
    }
 
    void setSimulationEndTime(size_t t)
    {
        timeInfo.simulationEndTime = t;
    }
 
    size_t getSimulationEndTime()
    {
        return timeInfo.simulationEndTime;
    }
 
    void startIteration()
    {
        timeInfo.iterationStartTime = clock();
    }
 
    void startIteration(size_t t)
    {
        timeInfo.iterationStartTime = t;
    }
 
    void endIteration()
    {
        timeInfo.iterationEndTime = clock();
    }
 
    void endIteration(size_t t)
    {
        timeInfo.iterationEndTime = t;
    }
 
    void setTimeStep(double t)
    {
        timeInfo.timeStep = t;
    }
 
    void setComputationCost(size_t computation)
    {
        c_c = computation;
    }
 
    size_t getNTimeStepSinceDLB()
    {
        return n_ts;
    }
 
    void setUnbalance(float u)
    {
        unbalance = u;
    }
 
    void setThresholdLevel(ThresholdLevel t)
    {
        thl = t;
    }
 
};
 
#endif /* SRC_DECOMPOSITION_DLB_HPP_ */