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 get_q_r(const Task &t_i, const fractional_t &time,
integral_t &q_i, fractional_t &r_i)
{
// compute q_i -- floor(time / period)
// r_i -- time % period
r_i = time / t_i.get_period();
q_i = r_i; // truncate, i.e. implicit floor
r_i = time;
r_i -= q_i * t_i.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);
}
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();
}
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 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_);
}
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;
}
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();
}
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;
}
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 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());
}
void init(const Task& tsk_i, const Task& tsk_k)
{
init(tsk_k.get_deadline(), tsk_i.get_deadline(), tsk_i.get_period());
}
