From 07cad60bb0865d95cfe4c5ce2ea08d7c8d33f34f Mon Sep 17 00:00:00 2001
From: Gabe Black <gabeblack@google.com>
Date: Wed, 26 Sep 2018 22:53:01 -0700
Subject: systemc: Implement the sc_time_tuple class.

This class is non-standard and is an implementation detail in
Accellera's implementation, but is referred to directly by the tests.
It does the same thing as the time printing function, so rather than
having duplicate code the printing function now uses the sc_time_tuple
class even though it was doing fine on its own already.

Change-Id: I69594ed0651f212ded6d979d60523bb3b0a789b1
Reviewed-on: https://gem5-review.googlesource.com/c/13189
Reviewed-by: Gabe Black <gabeblack@google.com>
Maintainer: Gabe Black <gabeblack@google.com>
---
 src/systemc/core/sc_time.cc     | 94 ++++++++++++++++++-----------------------
 src/systemc/ext/core/sc_time.hh |  4 +-
 2 files changed, 42 insertions(+), 56 deletions(-)

diff --git a/src/systemc/core/sc_time.cc b/src/systemc/core/sc_time.cc
index cb7cf4682..acc3c0805 100644
--- a/src/systemc/core/sc_time.cc
+++ b/src/systemc/core/sc_time.cc
@@ -264,40 +264,7 @@ sc_time::operator /= (double d)
 void
 sc_time::print(std::ostream &os) const
 {
-    if (val == 0) {
-        os << "0 s";
-    } else {
-        Tick frequency = SimClock::Frequency;
-
-        // Shrink the frequency by scaling down the time period, ie converting
-        // it from cycles per second to cycles per millisecond, etc.
-        sc_time_unit tu = SC_SEC;
-        while (tu > 1 && (frequency % 1000 == 0)) {
-            tu = (sc_time_unit)((int)tu - 1);
-            frequency /= 1000;
-        }
-
-        // Convert the frequency into a period.
-        Tick period;
-        if (frequency > 1) {
-            tu = (sc_time_unit)((int)tu - 1);
-            period = 1000 / frequency;
-        } else {
-            period = frequency;
-        }
-
-        // Scale our integer value by the period.
-        uint64_t scaled = val * period;
-
-        // Shrink the scaled time value by increasing the size of the units
-        // it's measured by, avoiding fractional parts.
-        while (tu < SC_SEC && (scaled % 1000) == 0) {
-            tu = (sc_time_unit)((int)tu + 1);
-            scaled /= 1000;
-        }
-
-        os << scaled << ' ' << sc_gem5::TimeUnitNames[tu];
-    }
+    os << sc_time_tuple(*this).to_string();
 }
 
 sc_time
@@ -485,44 +452,63 @@ sc_get_default_time_unit()
     return sc_time(defaultUnit, SC_SEC);
 }
 
-sc_time_tuple::sc_time_tuple(const sc_time &)
+sc_time_tuple::sc_time_tuple(const sc_time &t) :
+    _value(), _unit(SC_SEC), _set(true)
 {
-    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
+    if (!t.value())
+        return;
+
+    Tick frequency = SimClock::Frequency;
+
+    // Shrink the frequency by scaling down the time period, ie converting
+    // it from cycles per second to cycles per millisecond, etc.
+    while (_unit > 1 && (frequency % 1000 == 0)) {
+        _unit = (sc_time_unit)((int)_unit - 1);
+        frequency /= 1000;
+    }
+
+    // Convert the frequency into a period.
+    Tick period;
+    if (frequency > 1) {
+        _unit = (sc_time_unit)((int)_unit - 1);
+        period = 1000 / frequency;
+    } else {
+        period = frequency;
+    }
+
+    // Scale our integer value by the period.
+    _value = t.value() * period;
+
+    // Shrink the scaled time value by increasing the size of the units
+    // it's measured by, avoiding fractional parts.
+    while (_unit < SC_SEC && (_value % 1000) == 0) {
+        _unit = (sc_time_unit)((int)_unit + 1);
+        _value /= 1000;
+    }
 }
 
 bool
 sc_time_tuple::has_value() const
 {
-    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
-    return false;
+    return _set;
 }
 
-sc_dt::uint64
-sc_time_tuple::value() const
-{
-    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
-    return 0;
-}
+sc_dt::uint64 sc_time_tuple::value() const { return _value; }
 
 const char *
 sc_time_tuple::unit_symbol() const
 {
-    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
-    return "";
+    return sc_gem5::TimeUnitNames[_unit];
 }
 
-double
-sc_time_tuple::to_double() const
-{
-    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
-    return 0.0;
-}
+double sc_time_tuple::to_double() const { return static_cast<double>(_value); }
 
 std::string
 sc_time_tuple::to_string() const
 {
-    warn("%s not implemented.\n", __PRETTY_FUNCTION__);
-    return "";
+    std::ostringstream ss;
+    ss << _value << ' ' << unit_symbol();
+    return ss.str();
 }
 
 } // namespace sc_core
diff --git a/src/systemc/ext/core/sc_time.hh b/src/systemc/ext/core/sc_time.hh
index 014755522..0a31a655a 100644
--- a/src/systemc/ext/core/sc_time.hh
+++ b/src/systemc/ext/core/sc_time.hh
@@ -113,7 +113,7 @@ sc_time sc_get_default_time_unit();
 class sc_time_tuple
 {
   public:
-    sc_time_tuple() : _value(), _unit(SC_SEC), _offset(1) {}
+    sc_time_tuple() : _value(), _unit(SC_SEC), _set(false) {}
     sc_time_tuple(const sc_time &);
 
     bool has_value() const;
@@ -131,7 +131,7 @@ class sc_time_tuple
   private:
     sc_dt::uint64 _value;
     sc_time_unit _unit;
-    unsigned _offset;
+    bool _set;
 };
 
 } // namespace sc_core
-- 
cgit v1.2.3