Rename time types used in C++ schedulablity analysis

integral_t   == integral time units
fractional_t == fractions of integral time units

This is hopefully less of an eyesore than mpq_class and mpz_class.

9 files changed, 98 insertions, 98 deletions

diff --git a/native/src/edf/baker.cpp b/native/src/edf/baker.cpp
index ca2b8cc..3d13b2c 100644
--- a/native/src/edf/baker.cpp
+++ b/native/src/edf/baker.cpp
@@ -8,10 +8,10 @@
 using namespace std;
 
 void BakerGedf::beta(const Task &t_i, const Task &t_k,
-                     const mpq_class &lambda_k,
-                     mpq_class &beta_i)
+                     const fractional_t &lambda_k,
+                     fractional_t &beta_i)
 {
-    mpq_class u_i;
+    fractional_t u_i;
 
     // XXX: possible improvement would be to pre-compute u_i
     //      instead of incurring quadratic u_i computations.
@@ -24,7 +24,7 @@ void BakerGedf::beta(const Task &t_i, const Task &t_k,
 
     if (lambda_k < u_i)
     {
-        mpq_class tmp = t_i.get_wcet();
+        fractional_t tmp = t_i.get_wcet();
         tmp -= lambda_k * t_i.get_period();
         tmp /= t_k.get_deadline();
         beta_i += tmp;
@@ -33,8 +33,8 @@ void BakerGedf::beta(const Task &t_i, const Task &t_k,
 
 bool BakerGedf::is_task_schedulable(unsigned int k, const TaskSet &ts)
 {
-    mpq_class lambda, bound, beta_i, beta_sum = 0;
-    mpq_class one = 1;
+    fractional_t lambda, bound, beta_i, beta_sum = 0;
+    fractional_t one = 1;
 
     ts[k].get_density(lambda);
 
diff --git a/native/src/edf/baruah.cpp b/native/src/edf/baruah.cpp
index 1b82baa..d2699e5 100644
--- a/native/src/edf/baruah.cpp
+++ b/native/src/edf/baruah.cpp
@@ -18,8 +18,8 @@ const double BaruahGedf::MAX_RUNTIME = 5.0; /* seconds */
 
 
 static void demand_bound_function(const Task &tsk,
-                                  const mpz_class &t,
-                                  mpz_class &db)
+                                  const integral_t &t,
+                                  integral_t &db)
 {
     db = t;
     db -= tsk.get_deadline();
@@ -36,7 +36,7 @@ static void demand_bound_function(const Task &tsk,
 class DBFPointsOfChange
 {
 private:
-    mpz_class     cur;
+    integral_t     cur;
     unsigned long pi; // period
 
 public:
@@ -56,7 +56,7 @@ public:
             next();
     }
 
-    const mpz_class& get_cur() const
+    const integral_t& get_cur() const
     {
         return cur;
     }
@@ -84,11 +84,11 @@ class AllDBFPointsOfChange
 private:
     DBFPointsOfChange *dbf;
     DBFQueue           queue;
-    mpz_class          last;
-    mpz_class         *upper_bound;
+    integral_t          last;
+    integral_t         *upper_bound;
 
 public:
-    void init(const TaskSet &ts, int k, mpz_class* bound)
+    void init(const TaskSet &ts, int k, integral_t* bound)
     {
         last = -1;
         dbf = new DBFPointsOfChange[ts.get_task_count()];
@@ -105,7 +105,7 @@ public:
         delete[] dbf;
     }
 
-    bool get_next(mpz_class &t)
+    bool get_next(integral_t &t)
     {
         if (last > *upper_bound)
             return false;
@@ -127,49 +127,49 @@ public:
 
 static
 void interval1(unsigned int i, unsigned int k, const TaskSet &ts,
-               const mpz_class &ilen, mpz_class &i1)
+               const integral_t &ilen, integral_t &i1)
 {
-    mpz_class dbf, tmp;
+    integral_t dbf, tmp;
     tmp = ilen + ts[k].get_deadline();
     demand_bound_function(ts[i], tmp, dbf);
     if (i == k)
-        i1 = min(mpz_class(dbf - ts[k].get_wcet()), ilen);
+        i1 = min(integral_t(dbf - ts[k].get_wcet()), ilen);
     else
         i1 = min(dbf,
-                 mpz_class(ilen + ts[k].get_deadline() -
+                 integral_t(ilen + ts[k].get_deadline() -
                            (ts[k].get_wcet() - 1)));
 }
 
 
 static void demand_bound_function_prime(const Task &tsk,
-                                        const mpz_class &t,
-                                        mpz_class &db)
+                                        const integral_t &t,
+                                        integral_t &db)
 // carry-in scenario
 {
     db = t;
     db /= tsk.get_period();
     db *= tsk.get_wcet();
-    db += min(mpz_class(tsk.get_wcet()), mpz_class(t % tsk.get_period()));
+    db += min(integral_t(tsk.get_wcet()), integral_t(t % tsk.get_period()));
 }
 
 static void interval2(unsigned int i, unsigned int k, const TaskSet &ts,
-                       const mpz_class &ilen, mpz_class &i2)
+                       const integral_t &ilen, integral_t &i2)
 {
-    mpz_class dbf, tmp;
+    integral_t dbf, tmp;
 
     tmp = ilen + ts[k].get_deadline();
     demand_bound_function_prime(ts[i], tmp, dbf);
     if (i == k)
-        i2 = min(mpz_class(dbf - ts[k].get_wcet()), ilen);
+        i2 = min(integral_t(dbf - ts[k].get_wcet()), ilen);
     else
         i2 = min(dbf,
-                 mpz_class(ilen + ts[k].get_deadline() -
+                 integral_t(ilen + ts[k].get_deadline() -
                            (ts[k].get_wcet() - 1)));
 }
 
 class MPZComparator {
 public:
-    bool operator() (mpz_class *a, mpz_class *b)
+    bool operator() (integral_t *a, integral_t *b)
     {
         return *b < *a;
     }
@@ -177,13 +177,13 @@ public:
 
 bool BaruahGedf::is_task_schedulable(unsigned int k,
                                      const TaskSet &ts,
-                                     const mpz_class &ilen,
-                                     mpz_class &i1,
-                                     mpz_class &sum,
-                                     mpz_class *idiff,
-                                     mpz_class **ptr)
+                                     const integral_t &ilen,
+                                     integral_t &i1,
+                                     integral_t &sum,
+                                     integral_t *idiff,
+                                     integral_t **ptr)
 {
-    mpz_class bound;
+    integral_t bound;
     sum = 0;
 
     for (unsigned int i = 0; i < ts.get_task_count(); i++)
@@ -206,8 +206,8 @@ bool BaruahGedf::is_task_schedulable(unsigned int k,
 }
 
 void BaruahGedf::get_max_test_points(const TaskSet &ts,
-                                     mpq_class &m_minus_u,
-                                     mpz_class* maxp)
+                                     fractional_t &m_minus_u,
+                                     integral_t* maxp)
 {
     unsigned long* wcet = new unsigned long[ts.get_task_count()];
 
@@ -216,8 +216,8 @@ void BaruahGedf::get_max_test_points(const TaskSet &ts,
 
     sort(wcet, wcet + ts.get_task_count(), greater<unsigned long>());
 
-    mpq_class u, tdu_sum;
-    mpz_class csigma, mc;
+    fractional_t u, tdu_sum;
+    integral_t csigma, mc;
 
     csigma = 0;
     for (unsigned int i = 0; i < m - 1 && i < ts.get_task_count(); i++)
@@ -256,7 +256,7 @@ bool BaruahGedf::is_schedulable(const TaskSet &ts,
             return true;
     }
 
-    mpq_class m_minus_u;
+    fractional_t m_minus_u;
     ts.get_utilization(m_minus_u);
     m_minus_u *= -1;
     m_minus_u += m;
@@ -270,19 +270,19 @@ bool BaruahGedf::is_schedulable(const TaskSet &ts,
 
     double start_time = get_cpu_usage();
 
-    mpz_class i1, sum;
-    mpz_class *max_test_point, *idiff;
-    mpz_class** ptr; // indirect access to idiff
+    integral_t i1, sum;
+    integral_t *max_test_point, *idiff;
+    integral_t** ptr; // indirect access to idiff
 
-    idiff          = new mpz_class[ts.get_task_count()];
-    max_test_point = new mpz_class[ts.get_task_count()];
-    ptr            = new mpz_class*[ts.get_task_count()];
+    idiff          = new integral_t[ts.get_task_count()];
+    max_test_point = new integral_t[ts.get_task_count()];
+    ptr            = new integral_t*[ts.get_task_count()];
     for (unsigned int i = 0; i < ts.get_task_count(); i++)
         ptr[i] = idiff + i;
 
     get_max_test_points(ts, m_minus_u, max_test_point);
 
-    mpz_class ilen;
+    integral_t ilen;
     bool point_in_range = true;
     bool schedulable = true;
 
diff --git a/native/src/edf/bcl.cpp b/native/src/edf/bcl.cpp
index 8cc25d9..d7fa721 100644
--- a/native/src/edf/bcl.cpp
+++ b/native/src/edf/bcl.cpp
@@ -15,11 +15,11 @@ unsigned long BCLGedf::max_jobs_contained(const Task &t_i, const Task &t_k)
         return 1 + (t_k.get_deadline() - t_i.get_deadline()) / t_i.get_period();
 }
 
-void BCLGedf::beta(const Task &t_i, const Task &t_k, mpq_class &beta_i)
+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);
 
-    mpz_class c_i, tmp;
+    integral_t c_i, tmp;
 
     c_i  = t_i.get_wcet();
     tmp  = t_i.get_period();
@@ -38,8 +38,8 @@ void BCLGedf::beta(const Task &t_i, const Task &t_k, mpq_class &beta_i)
 
 bool BCLGedf::is_task_schedulable(unsigned int k, const TaskSet &ts)
 {
-    mpq_class beta_i, beta_sum = 0;
-    mpq_class lambda_term;
+    fractional_t beta_i, beta_sum = 0;
+    fractional_t lambda_term;
     bool small_beta_exists = false;
 
     ts[k].get_density(lambda_term);
diff --git a/native/src/edf/bcl_iterative.cpp b/native/src/edf/bcl_iterative.cpp
index e70c0c4..b8e58ef 100644
--- a/native/src/edf/bcl_iterative.cpp
+++ b/native/src/edf/bcl_iterative.cpp
@@ -11,7 +11,7 @@ using namespace std;
 static void interfering_workload(const Task &t_i,
                                  const Task &t_k,
                                  unsigned long slack,
-                                 mpz_class &inf)
+                                 integral_t &inf)
 {
     unsigned long njobs = t_k.get_deadline() / t_i.get_period();
 
@@ -30,9 +30,9 @@ bool BCLIterativeGedf::slack_update(unsigned int k,
                                     unsigned long *slack,
                                     bool &has_slack)
 {
-    mpz_class other_work = 0;
-    mpz_class inf;
-    mpz_class inf_bound = ts[k].get_deadline() - ts[k].get_wcet() + 1;
+    integral_t other_work = 0;
+    integral_t inf;
+    integral_t inf_bound = ts[k].get_deadline() - ts[k].get_wcet() + 1;
 
     for (unsigned int i = 0; i < ts.get_task_count(); i++)
         if (k != i)
diff --git a/native/src/edf/ffdbf.cpp b/native/src/edf/ffdbf.cpp
index a28ea38..fa64b96 100644
--- a/native/src/edf/ffdbf.cpp
+++ b/native/src/edf/ffdbf.cpp
@@ -13,8 +13,8 @@
 
 using namespace std;
 
-static void get_q_r(const Task &t_i, const mpq_class &time,
-                    mpz_class &q_i, mpq_class &r_i)
+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
@@ -26,18 +26,18 @@ static void get_q_r(const Task &t_i, const mpq_class &time,
     r_i -= q_i * t_i.get_period();
 }
 
-static void compute_q_r(const TaskSet &ts, const mpq_class &time,
-                        mpz_class q[], mpq_class r[])
+static void compute_q_r(const TaskSet &ts, const fractional_t &time,
+                        integral_t q[], fractional_t r[])
 {
     for (unsigned int i = 0; i < ts.get_task_count(); i++)
         get_q_r(ts[i], time, q[i], r[i]);
 }
 
 static void ffdbf(const Task &t_i,
-                  const mpq_class &time, const mpq_class &speed,
-                  const mpz_class &q_i, const mpq_class &r_i,
-                  mpq_class &demand,
-                  mpq_class &tmp)
+                  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();
@@ -64,9 +64,9 @@ static void ffdbf(const Task &t_i,
 }
 
 static void ffdbf_ts(const TaskSet &ts,
-                     const mpz_class q[], const mpq_class r[],
-                     const mpq_class &time, const mpq_class &speed,
-                     mpq_class &demand, mpq_class &tmp)
+                     const integral_t q[], const fractional_t r[],
+                     const fractional_t &time, const fractional_t &speed,
+                     fractional_t &demand, fractional_t &tmp)
 {
     demand = 0;
     for (unsigned int i = 0; i < ts.get_task_count(); i++)
@@ -77,15 +77,15 @@ static void ffdbf_ts(const TaskSet &ts,
 class TestPoints
 {
 private:
-    mpq_class     time;
-    mpq_class     with_offset;
+    fractional_t     time;
+    fractional_t     with_offset;
     unsigned long period;
     bool          first_point;
 
 public:
     void init(const Task& t_i,
-              const mpq_class& speed,
-              const mpq_class& min_time)
+              const fractional_t& speed,
+              const fractional_t& min_time)
     {
         period = t_i.get_period();
         with_offset = t_i.get_wcet() / speed;
@@ -96,7 +96,7 @@ public:
         time = min_time;
         time /= period;
         // round down, i.e., floor()
-        mpq_truncate(time);
+        truncate_fraction(time);
         time *= period;
         time += t_i.get_deadline();
 
@@ -107,7 +107,7 @@ public:
             next();
     }
 
-    const mpq_class& get_cur() const
+    const fractional_t& get_cur() const
     {
         if (first_point)
             return with_offset;
@@ -145,7 +145,7 @@ class AllTestPoints
 private:
     TestPoints *pts;
     TimeQueue   queue;
-    mpq_class   last;
+    fractional_t   last;
     TaskSet const &ts;
 
 public:
@@ -155,8 +155,8 @@ public:
         pts = new TestPoints[ts.get_task_count()];
     }
 
-    void init(const mpq_class &speed,
-              const mpq_class &min_time)
+    void init(const fractional_t &speed,
+              const fractional_t &min_time)
     {
         last = -1;
         // clean out queue
@@ -175,7 +175,7 @@ public:
         delete[] pts;
     }
 
-    void get_next(mpq_class &t)
+    void get_next(fractional_t &t)
     {
         TestPoints* pt;
         do // avoid duplicates
@@ -191,11 +191,11 @@ public:
 };
 
 bool FFDBFGedf::witness_condition(const TaskSet &ts,
-                                  const mpz_class q[], const mpq_class r[],
-                                  const mpq_class &time,
-                                  const mpq_class &speed)
+                                  const integral_t q[], const fractional_t r[],
+                                  const fractional_t &time,
+                                  const fractional_t &speed)
 {
-    mpq_class demand, bound;
+    fractional_t demand, bound;
 
     ffdbf_ts(ts, q, r, time, speed, demand, bound);
 
@@ -223,12 +223,12 @@ bool FFDBFGedf::is_schedulable(const TaskSet &ts,
 
     // allocate helpers
     AllTestPoints testing_set(ts);
-    mpz_class *q = new mpz_class[ts.get_task_count()];
-    mpq_class *r = new mpq_class[ts.get_task_count()];
+    integral_t *q = new integral_t[ts.get_task_count()];
+    fractional_t *r = new fractional_t[ts.get_task_count()];
 
-    mpq_class sigma_bound;
-    mpq_class time_bound;
-    mpq_class tmp(1, epsilon_denom);
+    fractional_t sigma_bound;
+    fractional_t time_bound;
+    fractional_t tmp(1, epsilon_denom);
 
     // compute sigma bound
     tmp = 1;
@@ -237,7 +237,7 @@ bool FFDBFGedf::is_schedulable(const TaskSet &ts,
     sigma_bound -= m;
     sigma_bound /= - ((int) (m - 1)); // neg. to flip sign
     sigma_bound -= tmp; // epsilon
-    sigma_bound = min(sigma_bound, mpq_class(1));
+    sigma_bound = min(sigma_bound, fractional_t(1));
 
     // compute time bound
     time_bound = 0;
@@ -245,8 +245,8 @@ bool FFDBFGedf::is_schedulable(const TaskSet &ts,
         time_bound += ts[i].get_wcet();
     time_bound /= tmp; // epsilon
 
-    mpq_class t_cur;
-    mpq_class sigma_cur, sigma_nxt;
+    fractional_t t_cur;
+    fractional_t sigma_cur, sigma_nxt;
     bool schedulable;
 
     t_cur = 0;
@@ -258,7 +258,7 @@ bool FFDBFGedf::is_schedulable(const TaskSet &ts,
 
     // setup brute force sigma value range
     sigma_nxt = sigma_cur / sigma_step;
-    mpq_truncate(sigma_nxt);
+    truncate_fraction(sigma_nxt);
     sigma_nxt += 1;
     sigma_nxt *= sigma_step;
 
diff --git a/native/src/edf/gedf.cpp b/native/src/edf/gedf.cpp
index 35f1847..e2a6bec 100644
--- a/native/src/edf/gedf.cpp
+++ b/native/src/edf/gedf.cpp
@@ -26,7 +26,7 @@ bool GlobalEDF::is_schedulable(const TaskSet &ts,
     // density bound on a uniprocessor.
     if (m == 1)
     {
-        mpq_class density;
+        fractional_t density;
         ts.get_density(density);
         if (density <= 1)
             return true;
diff --git a/native/src/edf/gfb.cpp b/native/src/edf/gfb.cpp
index 0aa90b8..822b97b 100644
--- a/native/src/edf/gfb.cpp
+++ b/native/src/edf/gfb.cpp
@@ -13,7 +13,7 @@ bool GFBGedf::is_schedulable(const TaskSet &ts, bool check_preconditions)
             return false;
     }
 
-    mpq_class total_density, max_density, bound;
+    fractional_t total_density, max_density, bound;
 
     ts.get_density(total_density);
     ts.get_max_density(max_density);
diff --git a/native/src/edf/load.cpp b/native/src/edf/load.cpp
index 38d3c55..db44d20 100644
--- a/native/src/edf/load.cpp
+++ b/native/src/edf/load.cpp
@@ -22,8 +22,8 @@ bool LoadGedf::is_schedulable(const TaskSet &ts, bool check_preconditions)
             return false;
     }
 
-    mpq_class load, max_density, mu, bound, cond1, cond2;
-    mpz_class mu_ceil;
+    fractional_t load, max_density, mu, bound, cond1, cond2;
+    integral_t mu_ceil;
 
     // get the load of the task set
     ts.approx_load(load, epsilon);
diff --git a/native/src/edf/rta.cpp b/native/src/edf/rta.cpp
index 68eafa6..4114467 100644
--- a/native/src/edf/rta.cpp
+++ b/native/src/edf/rta.cpp
@@ -15,8 +15,8 @@ using namespace std;
 static void rta_interfering_workload(const Task &t_i,
                                      unsigned long response_time,
                                      unsigned long slack_i,
-                                     mpz_class &inf,
-                                     mpz_class &interval)
+                                     integral_t &inf,
+                                     integral_t &interval)
 {
     interval = response_time;
     interval += t_i.get_deadline() - t_i.get_wcet();
@@ -36,7 +36,7 @@ static void rta_interfering_workload(const Task &t_i,
 static void edf_interfering_workload(const Task &t_i,
                                      const Task &t_k,
                                      unsigned long slack_i,
-                                     mpz_class &inf)
+                                     integral_t &inf)
 {
     /* implicit floor in integer division */
     unsigned long njobs = t_k.get_deadline() / t_i.get_period();
@@ -56,11 +56,11 @@ bool RTAGedf::response_estimate(unsigned int k,
                                 unsigned long response,
                                 unsigned long &new_response)
 {
-    mpz_class other_work = 0;
-    mpz_class inf_edf;
-    mpz_class inf_rta;
-    mpz_class inf_bound = response - ts[k].get_wcet() + 1;
-    mpz_class tmp;
+    integral_t other_work = 0;
+    integral_t inf_edf;
+    integral_t inf_rta;
+    integral_t inf_bound = response - ts[k].get_wcet() + 1;
+    integral_t tmp;
 
     for (unsigned int i = 0; i < ts.get_task_count(); i++)
         if (k != i)