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_ */