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.

8 files changed, 47 insertions, 38 deletions

diff --git a/native/include/edf/baker.h b/native/include/edf/baker.h
index c3716df..44493e5 100644
--- a/native/include/edf/baker.h
+++ b/native/include/edf/baker.h
@@ -8,8 +8,8 @@ class BakerGedf : public SchedulabilityTest
     unsigned int m;
 
  private:
-    void beta(const Task &t_i, const Task &t_k, const mpq_class &lambda_k,
-              mpq_class &beta_i);
+    void beta(const Task &t_i, const Task &t_k, const fractional_t &lambda_k,
+              fractional_t &beta_i);
     bool is_task_schedulable(unsigned int k, const TaskSet &ts);
 
  public:
diff --git a/native/include/edf/baruah.h b/native/include/edf/baruah.h
index c79b49d..f6f9217 100644
--- a/native/include/edf/baruah.h
+++ b/native/include/edf/baruah.h
@@ -9,14 +9,14 @@ private:
 
     bool 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);
-
-    void get_max_test_points(const TaskSet &ts, mpq_class& m_minus_u,
-                             mpz_class* maxp);
+                             const integral_t &ilen,
+                             integral_t &i1,
+                             integral_t &sum,
+                             integral_t *idiff,
+                             integral_t **ptr);
+
+    void get_max_test_points(const TaskSet &ts, fractional_t& m_minus_u,
+                             integral_t* maxp);
 
 public:
     BaruahGedf(unsigned int num_processors) : m(num_processors) {};
diff --git a/native/include/edf/bcl.h b/native/include/edf/bcl.h
index 31bf1e3..aa4d818 100644
--- a/native/include/edf/bcl.h
+++ b/native/include/edf/bcl.h
@@ -9,7 +9,7 @@ class BCLGedf : public SchedulabilityTest
 
  private:
     unsigned long max_jobs_contained(const Task &t_i, const Task &t_k);
-    void beta(const Task &t_i, const Task &t_k, mpq_class &beta_i);
+    void beta(const Task &t_i, const Task &t_k, fractional_t &beta_i);
     bool is_task_schedulable(unsigned int k, const TaskSet &ts);
 
  public:
diff --git a/native/include/edf/ffdbf.h b/native/include/edf/ffdbf.h
index 7e3dac6..a5fb834 100644
--- a/native/include/edf/ffdbf.h
+++ b/native/include/edf/ffdbf.h
@@ -6,12 +6,12 @@ class FFDBFGedf : public SchedulabilityTest
   private:
     const unsigned int m;
     const unsigned long epsilon_denom;
-    const mpq_class sigma_step;
+    const fractional_t sigma_step;
 
   private:
     bool 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);
 
   public:
     FFDBFGedf(unsigned int num_processors,
diff --git a/native/include/edf/load.h b/native/include/edf/load.h
index 36c8f5a..50d7850 100644
--- a/native/include/edf/load.h
+++ b/native/include/edf/load.h
@@ -5,7 +5,7 @@ class LoadGedf : public SchedulabilityTest
 {
  private:
     unsigned int m;
-    mpq_class epsilon;
+    fractional_t epsilon;
 
  public:
     LoadGedf(unsigned int num_processors,
diff --git a/native/include/math-helper.h b/native/include/math-helper.h
index 10c42c2..063558c 100644
--- a/native/include/math-helper.h
+++ b/native/include/math-helper.h
@@ -1,12 +1,6 @@
 #ifndef MATH_HELPER_H
 #define MATH_HELPER_H
 
-static inline void mpq_truncate(mpq_class &val)
-{
-    val.get_num() -= val.get_num() % val.get_den();
-    val.canonicalize();
-}
-
 static inline unsigned long divide_with_ceil(unsigned long numer,
                                              unsigned long denom)
 {
diff --git a/native/include/tasks.h b/native/include/tasks.h
index 175206a..dbba8d1 100644
--- a/native/include/tasks.h
+++ b/native/include/tasks.h
@@ -6,10 +6,10 @@
 #include <vector>
 #include <algorithm>
 
-#include <gmpxx.h>
-
 #include <math.h>
 
+#include "time-types.h"
+
 #endif
 
 class Task
@@ -43,8 +43,8 @@ class Task
     bool is_feasible() const;
 
 
-    void get_utilization(mpq_class &util) const;
-    void get_density(mpq_class &density) const;
+    void get_utilization(fractional_t &util) const;
+    void get_density(fractional_t &density) const;
 
     // Demand bound function (DBF) and LOAD support.
     // This implements Fisher, Baker, and Baruah's PTAS
@@ -64,7 +64,7 @@ class Task
         }
     }
 
-    void bound_demand(const mpz_class &time, mpz_class &demand) const
+    void bound_demand(const integral_t &time, integral_t &demand) const
     {
         if (time <= deadline)
             demand = 0;
@@ -79,9 +79,9 @@ class Task
         }
     }
 
-    void bound_load(const mpz_class &time, mpq_class &load) const
+    void bound_load(const integral_t &time, fractional_t &load) const
     {
-        mpz_class demand;
+        integral_t demand;
 
         if (time > 0)
         {
@@ -107,14 +107,14 @@ class Task
         }
     }
 
-    void approx_demand(const mpz_class &time, mpz_class &demand,
+    void approx_demand(const integral_t &time, integral_t &demand,
                        unsigned int k) const
     {
         if (time < k * period + deadline)
             bound_demand(time, demand);
         else
         {
-            mpz_class approx;
+            integral_t approx;
 
             approx = time;
             approx -= deadline;
@@ -126,10 +126,10 @@ class Task
         }
     }
 
-    void approx_load(const mpz_class &time, mpq_class &load,
+    void approx_load(const integral_t &time, fractional_t &load,
                      unsigned int k) const
     {
-        mpz_class demand;
+        integral_t demand;
 
         if (time > 0)
         {
@@ -148,8 +148,8 @@ class TaskSet
 {
   private:
     Tasks tasks;
-  
-    unsigned long k_for_epsilon(unsigned int idx, const mpq_class &epsilon) const;
+
+    unsigned long k_for_epsilon(unsigned int idx, const fractional_t &epsilon) const;
 
   public:
     TaskSet();
@@ -172,11 +172,11 @@ class TaskSet
     bool has_only_feasible_tasks() const;
     bool is_not_overutilized(unsigned int num_processors) const;
 
-    void get_utilization(mpq_class &util) const;
-    void get_density(mpq_class &density) const;
-    void get_max_density(mpq_class &max_density) const;
+    void get_utilization(fractional_t &util) const;
+    void get_density(fractional_t &density) const;
+    void get_max_density(fractional_t &max_density) const;
 
-    void approx_load(mpq_class &load, const mpq_class &epsilon = 0.1) const;
+    void approx_load(fractional_t &load, const fractional_t &epsilon = 0.1) const;
 
     /* wrapper for Python access */
     unsigned long get_period(unsigned int idx) const
diff --git a/native/include/time-types.h b/native/include/time-types.h
new file mode 100644
index 0000000..a2250d3
--- /dev/null
+++ b/native/include/time-types.h
@@ -0,0 +1,15 @@
+#ifndef TIME_TYPES_H
+#define TIME_TYPES_H
+
+#include <gmpxx.h>
+
+typedef mpz_class integral_t;
+typedef mpq_class fractional_t;
+
+static inline void truncate_fraction(fractional_t &val)
+{
+    val.get_num() -= val.get_num() % val.get_den();
+    val.canonicalize();
+}
+
+#endif