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;
}
}
}
static void demand_bound_function_prime(const Task &tsk,
const integral_t &t,
integral_t &db)
// carry-in scenario
{
db = t;
db /= tsk.get_period();
db *= tsk.get_wcet();
db += min(integral_t(tsk.get_wcet()), integral_t(t % tsk.get_period()));
}
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);
}
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.
}
int baseline_wcrt (const Task& tk, const std::vector<Task>& hps, const std::vector<int>& wcrts, const int m) {
int ck = tk.get_wcet();
if ( hps.size() < m) return ck;
int dk = tk.get_dline();
int wcrt = dk + 1;
for ( int ck1 = 0; ck1 <= ck; ck1 ++) {
int ck2 = ck - ck1; // for each pair of (ck1, ck2)
// To compute the upper bound on the 1st level response time
Task copy_tk(tk);
copy_tk.set_wcet(ck1);
int Rk1 = RTA_LC(copy_tk, hps, wcrts, m);
if ( Rk1 + ck2 > dk) break;
int res = FIk(ck1, ck2, Rk1, tk, hps, wcrts, m);
if ( res < wcrt) wcrt = res;
}
return wcrt;
}
int NCW(const Task& t_i, const int x) {
int p = t_i.get_period();
int c = t_i.get_wcet();
int n = x / p;
int n_ = x % p;
return n * c + fmin(c, n_);
}
int NCI(const Task& t_i, const Task& t_k, const int x) {
int w = NCW(t_i, x);
int c_k = t_k.get_wcet();
return fmin(w, x-c_k);
//return fmin(w, x-c_k+1);
}
int CII(const Task& t_i, const Task& t_k, const int x, const int wcrt_i) {
int w = CIW(t_i, x, wcrt_i);
int c_k = t_k.get_wcet();
return fmin(w, x-c_k);
//return fmin(w, x-c_k+1);
}
record:: record( const record &r)
{
index_Pipe=r.index_Pipe;
const Task t= r.get_Task();
task = new Task(t.get_wcet(), t.get_dline(), t.get_period()) ;
index_Task_In_Pipe=r.index_Task_In_Pipe;
}
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;
}
int CIW(const Task& t_i, const int x, const int wcrt_i) {
int p = t_i.get_period();
int c = t_i.get_wcet();
int xp = c + p - wcrt_i;
int w = NCW(t_i, fmax(x-xp, 0));
w += fmin(c, x);
return w;
}
int RTA_LC (const Task& tk, const std::vector<Task>& hps, const std::vector<int>& wcrts, const int m) {
if ( hps.size() < m) return tk.get_wcet();
int L = tk.get_wcet();
while (true) {
vector<int> ncis, diffs;
int i = 0, totI = 0;
for ( auto & x : hps) {
int nci = NCI(x, tk, L);
int cii = CII(x, tk, L, wcrts[i++]);
totI += nci;
diffs.push_back(cii-nci);
}
sort(diffs.begin(), diffs.end(),
[](const int a, const int b) {return a > b;}
);
for ( i = 0; i < m-1; i++) // at most m-1 CI tasks
totI += diffs[i];
if ( totI < m*(L-tk.get_wcet())) return L;
int Y = ceil( totI*1.0 / m) + tk.get_wcet();
if ( Y > L) L = Y;
else L ++;
if ( L > tk.get_dline()) return L;
}
}
record& record::operator=(const record &r)
{
index_Pipe=r.index_Pipe;
if(index_Pipe!=-1)
{
const Task t= r.get_Task();
task->set_period( t.get_period());
task->set_wcet( t.get_wcet());
task->set_dline(t.get_dline() ) ;
}
index_Task_In_Pipe=r.index_Task_In_Pipe;
return *this;
}
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;
}
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;
}
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();
}
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();
}
record::record(Task&t, int i, int j): index_Pipe(i),index_Task_In_Pipe(j)
{
task = new Task(t.get_wcet(), t.get_dline(), t.get_period());
}
v2.push_back(FPTask_ptr( new FPTask(1, 5, 5)));
v2.push_back(FPTask_ptr( new FPTask(2, 10, 10)));
v2.push_back(FPTask_ptr( new FPTask(4, 30, 30)));
v2.push_back(FPTask_ptr( new FPTask(7, 40, 40)));
v2.push_back(FPTask_ptr( new FPTask(10, 100, 100)));
v3.push_back(FPTask_ptr( new FPTask( 1, 4, 4)));
v3.push_back(FPTask_ptr( new FPTask( 2, 10, 10)));
v3.push_back(FPTask_ptr( new FPTask( 3, 30, 30)));
v3.push_back(FPTask_ptr( new FPTask( 5, 15, 15)));
v3.push_back(FPTask_ptr( new FPTask(10,100,100)));
int i=5;
for (auto c : v3)
c->set_priority(i--);
}
};
TEST_CASE_METHOD(TestFPPtrFix, "FP Conversion")
{
FPTask_ptr t( new FPTask(2, 5, 10));
t->set_priority(3);
REQUIRE(3 == t->get_priority());
Task t2 = *t;
REQUIRE(t->get_wcet() == t2.get_wcet());
Task t3;
t3 = *t;
REQUIRE(t->get_dline() == t3.get_dline());
REQUIRE(t2.get_period() == t3.get_period());
}
