Example #1
0
unsigned long BCLGedf::max_jobs_contained(const Task &t_i, const Task &t_k)
{
    if (t_i.get_deadline() > t_k.get_deadline())
        return 0;
    else
        return 1 + (t_k.get_deadline() - t_i.get_deadline()) / t_i.get_period();
}
Example #2
0
static void ffdbf(const Task &t_i,
                  const fractional_t &time, const fractional_t &speed,
                  const integral_t &q_i, const fractional_t &r_i,
                  fractional_t &demand,
                  fractional_t &tmp)
{
    /* this is the cost in all three cases */
    demand += q_i * t_i.get_wcet();

    /* check for (a) and (b) cases */
    tmp  = 0;
    tmp -= t_i.get_wcet();
    tmp /= speed;
    tmp += t_i.get_deadline();
    if (r_i >= tmp)
    {
        // add one more cost charge
        demand += t_i.get_wcet();

        if (r_i <= t_i.get_deadline())
        {
            /* (b) class */
            tmp  = t_i.get_deadline();
            tmp -= r_i;
            tmp *= speed;
            demand -= tmp;
        }
    }
}
Example #3
0
static void interfering_workload(const Task &t_i,
                                 const Task &t_k,
                                 unsigned long slack,
                                 integral_t &inf)
{
    unsigned long njobs = t_k.get_deadline() / t_i.get_period();

    inf  = njobs;
    inf *= t_i.get_wcet();

    unsigned long tmp = slack + njobs * t_i.get_period();

    if (t_k.get_deadline() >= tmp)
        inf += min(t_i.get_wcet(), t_k.get_deadline() - tmp);
    //else inf += min(t.get_wcet(), 0) // always null by definition.
}
Example #4
0
static void edf_interfering_workload(const Task &t_i,
                                     const Task &t_k,
                                     unsigned long slack_i,
                                     integral_t &inf)
{
    /* implicit floor in integer division */
    unsigned long njobs = t_k.get_deadline() / t_i.get_period();

    inf  = njobs;
    inf *= t_i.get_wcet();

    unsigned long tmp = t_k.get_deadline() % t_i.get_period();
    if (tmp > slack_i)
        /* if tmp <= slack_i, then zero would be added */
        inf += min(t_i.get_wcet(), tmp - slack_i);
}
Example #5
0
void BCLGedf::beta(const Task &t_i, const Task &t_k, fractional_t &beta_i)
{
    unsigned long n = max_jobs_contained(t_i, t_k);

    integral_t c_i, tmp;

    c_i  = t_i.get_wcet();
    tmp  = t_i.get_period();
    tmp *= n;
    if (tmp < t_k.get_deadline())
        // no risk of overflow
        tmp = t_k.get_deadline() - n * t_i.get_period();
    else
        // test says zero is lower limit
        tmp = 0;

    beta_i  = n * c_i;
    beta_i += min(c_i, tmp);
    beta_i /= t_k.get_deadline();
}
Example #6
0
    void init(const Task& t_i,
              const fractional_t& speed,
              const fractional_t& min_time)
    {
        period = t_i.get_period();
        with_offset = t_i.get_wcet() / speed;
        if (with_offset > t_i.get_deadline())
            with_offset = t_i.get_deadline();
        with_offset *= -1;

        time = min_time;
        time /= period;
        // round down, i.e., floor()
        truncate_fraction(time);
        time *= period;
        time += t_i.get_deadline();

        with_offset += time;
        first_point = true;

        while (get_cur() <= min_time)
            next();
    }
Example #7
0
static void demand_bound_function(const Task &tsk,
                                  const integral_t &t,
                                  integral_t &db)
{
    db = t;
    db -= tsk.get_deadline();
    if (db >= 0)
    {
        db /= tsk.get_period();
        db += 1;
        db *= tsk.get_wcet();
    }
    else
        db = 0;
}
Example #8
0
int xxxmain(int argc, char** argv)
{
    cout << "GMP C++ test." << endl;

    integral_t a, b;

    a = "123123123123";
    b = "456456456456";

    cout << "a     : " << a << endl;
    cout << "b     : " << b << endl;
    cout << "a*b*10: " << a * b * 10 << endl;

    fractional_t q = a;

    q /= b;
    cout << "a/b   :" << q << endl;

    integral_t fact;
    fact = 1;
    for (int n = 2; n < 101; n++) {
	fact *= n;
    }
    cout << "Factorial is " << fact << endl;
    cout << "casted: " << fact.get_ui() << endl;

    Task t = Task(10, 100);

    cout << "wcet: " << t.get_wcet() << " period: " << t.get_period()
	 << " deadline: " << t.get_deadline() << endl;


    fractional_t lambda, bound;
    unsigned int m = 10;

    lambda = 3;
    lambda /= 10;
    bound = m * (1 - lambda) + lambda;

    cout << "lambda: " << lambda << " bound: " << bound << endl;

    test_baker();

    return 0;
}
Example #9
0
static void rta_interfering_workload(const Task &t_i,
                                     unsigned long response_time,
                                     unsigned long slack_i,
                                     integral_t &inf,
                                     integral_t &interval)
{
    interval = response_time;
    interval += t_i.get_deadline() - t_i.get_wcet();
    interval -= slack_i;

    inf  = t_i.get_wcet();
    inf *= interval / t_i.get_period();

    interval %= t_i.get_period();
    if (interval > t_i.get_wcet())
        inf += t_i.get_wcet();
    else
        inf += interval;
}
Example #10
0
 void init(const Task& tsk_i, const Task& tsk_k)
 {
     init(tsk_k.get_deadline(), tsk_i.get_deadline(), tsk_i.get_period());
 }