import sys
from m5.util import warn
-tps = 1.0e12 # default to 1 THz (1 Tick == 1 ps)
-tps_fixed = False # once set to true, can't be changed
-
-# fix the global frequency and tell C++ about it
+# fix the global frequency
def fixGlobalFrequency():
import _m5.core
- global tps, tps_fixed
- if not tps_fixed:
- tps_fixed = True
- _m5.core.setClockFrequency(int(tps))
- print("Global frequency set at %d ticks per second" % int(tps))
+ _m5.core.fixClockFrequency()
def setGlobalFrequency(ticksPerSecond):
from m5.util import convert
-
- global tps, tps_fixed
-
- if tps_fixed:
- raise AttributeError, \
- "Global frequency already fixed at %f ticks/s." % tps
+ import _m5.core
if isinstance(ticksPerSecond, (int, long)):
tps = ticksPerSecond
else:
raise TypeError, \
"wrong type '%s' for ticksPerSecond" % type(ticksPerSecond)
+ _m5.core.setClockFrequency(tps)
# how big does a rounding error need to be before we warn about it?
frequency_tolerance = 0.001 # 0.1%
def fromSeconds(value):
+ import _m5.core
+
if not isinstance(value, float):
raise TypeError, "can't convert '%s' to type tick" % type(value)
# once someone needs to convert to seconds, the global frequency
# had better be fixed
- if not tps_fixed:
+ if not _m5.core.clockFrequencyFixed():
raise AttributeError, \
"In order to do conversions, the global frequency must be fixed"
return 0
# convert the value from time to ticks
- value *= tps
+ value *= _m5.core.getClockFrequency()
int_value = int(round(value))
err = (value - int_value) / value
.def("seedRandom", [](uint64_t seed) { random_mt.init(seed); })
+ .def("fixClockFrequency", &fixClockFrequency)
+ .def("clockFrequencyFixed", &clockFrequencyFixed)
+
.def("setClockFrequency", &setClockFrequency)
+ .def("getClockFrequency", &getClockFrequency)
.def("curTick", curTick)
;
#include <string>
#include "base/callback.hh"
+#include "base/cprintf.hh"
+#include "base/logging.hh"
#include "base/output.hh"
#include "sim/eventq.hh"
} // namespace SimClock
+namespace {
+
+bool _clockFrequencyFixed = false;
+
+// Default to 1 THz (1 Tick == 1 ps)
+Tick _ticksPerSecond = 1e12;
+
+} // anonymous namespace
+
void
-setClockFrequency(Tick ticksPerSecond)
+fixClockFrequency()
{
+ if (_clockFrequencyFixed)
+ return;
+
using namespace SimClock;
- Frequency = ticksPerSecond;
+ Frequency = _ticksPerSecond;
Float::s = static_cast<double>(Frequency);
Float::ms = Float::s / 1.0e3;
Float::us = Float::s / 1.0e6;
Int::ns = Int::us / 1000;
Int::ps = Int::ns / 1000;
+ cprintf("Global frequency set at %d ticks per second\n", _ticksPerSecond);
+
+ _clockFrequencyFixed = true;
+}
+bool clockFrequencyFixed() { return _clockFrequencyFixed; }
+
+void
+setClockFrequency(Tick tps)
+{
+ panic_if(_clockFrequencyFixed,
+ "Global frequency already fixed at %f ticks/s.", _ticksPerSecond);
+ _ticksPerSecond = tps;
}
+Tick getClockFrequency() { return _ticksPerSecond; }
void
setOutputDir(const string &dir)
} // namespace Int
} // namespace SimClock
/** @} */
+
+void fixClockFrequency();
+bool clockFrequencyFixed();
+
void setClockFrequency(Tick ticksPerSecond);
+Tick getClockFrequency(); // Ticks per second.
void setOutputDir(const std::string &dir);