ns3::Time Class Reference
[Time]
keep track of time unit. More...
#include <nstime.h>
Classes | |
| struct | Information |
| struct | Resolution |
Public Types | |
| enum | Unit { S = 0, MS = 1, US = 2, NS = 3, PS = 4, FS = 5, LAST = 6 } |
Public Member Functions | |
| Time & | operator= (const Time &o) |
| Time (const Time &o) | |
| Time (const HighPrecision &data) | |
| Time (const std::string &s) | |
String constructor Construct Time object from common time expressions like "
1ms" or "10s". Supported units include:
| |
| bool | IsZero (void) const |
| bool | IsNegative (void) const |
| bool | IsPositive (void) const |
| bool | IsStrictlyNegative (void) const |
| bool | IsStrictlyPositive (void) const |
| int | Compare (const Time &o) const |
| HighPrecision const & | GetHighPrecision (void) const |
| HighPrecision * | PeekHighPrecision (void) |
| double | GetSeconds (void) const |
| int64_t | GetMilliSeconds (void) const |
| int64_t | GetMicroSeconds (void) const |
| int64_t | GetNanoSeconds (void) const |
| int64_t | GetPicoSeconds (void) const |
| int64_t | GetFemtoSeconds (void) const |
| int64_t | GetTimeStep (void) const |
Static Public Member Functions | |
| static void | SetResolution (enum Unit resolution) |
| static enum Unit | GetResolution (void) |
| static Time | FromInteger (uint64_t value, enum Unit timeUnit) |
| static Time | FromDouble (double value, enum Unit timeUnit) |
| static uint64_t | ToInteger (const Time &time, enum Unit timeUnit) |
| static double | ToDouble (const Time &time, enum Unit timeUnit) |
Detailed Description
keep track of time unit.
This template class is used to keep track of the value of a specific time unit: the type TimeUnit<1> is used to keep track of seconds, the type TimeUnit<2> is used to keep track of seconds squared, the type TimeUnit<-1> is used to keep track of 1/seconds, etc.
This base class defines all the functionality shared by all these time unit objects: it defines all the classic arithmetic operators +, -, *, /, and all the classic comparison operators: ==, !=, <, >, <=, >=. It is thus easy to add, substract, or multiply multiple TimeUnit objects. The return type of any such arithmetic expression is always a TimeUnit object.
The ns3::Scalar, ns3::Time, ns3::TimeSquare, and ns3::TimeInvert classes are aliases for the TimeUnit<0>, TimeUnit<1>, TimeUnit<2> and TimeUnit<-1> types respectively.
For example:
Time<1> t1 = Seconds (10.0); Time<1> t2 = Seconds (10.0); Time<2> t3 = t1 * t2; Time<0> t4 = t1 / t2; Time<3> t5 = t3 * t1; Time<-2> t6 = t1 / t5; TimeSquare t7 = t3; Scalar s = t4;
If you try to assign the result of an expression which does not match the type of the variable it is assigned to, you will get a compiler error. For example, the following will not compile:
You can also use the following non-member functions to manipulate any of these ns3::TimeUnit object:
- ns3-Time-Abs ns3::Abs
- ns3-Time-Max ns3::Max
- ns3-Time-Min ns3::Min
keep track of time values and allow control of global simulation resolution This class defines all the classic C++ arithmetic operators +, -, *, /, and all the classic comparison operators: ==, !=, <, >, <=, >=. It is thus easy to add, substract, or multiply multiple Time objects.
The ns3::Scalar, ns3::TimeSquare, and ns3::TimeInvert classes are backward-compatibility aliases for ns3::Time.
For example:
Time t1 = Seconds (10.0); Time t2 = Seconds (10.0); Time t3 = t1 * t2; Time t4 = t1 / t2; Time t5 = t3 * t1; Time t6 = t1 / t5; Time t7 = t3;
You can also use the following non-member functions to manipulate any of these ns3::Time object:
- ns3-Time-Abs ns3::Abs
- ns3-Time-Max ns3::Max
- ns3-Time-Min ns3::Min
This class also controls the resolution of the underlying time value . The default resolution is nanoseconds. That is, TimeStep (1).GetNanoSeconds () will return 1. It is possible to either increase or decrease the resolution and the code tries really hard to make this easy.
If your resolution is X (say, nanoseconds) and if you create Time objects with a lower resolution (say, picoseconds), don't expect that this code will return 1: PicoSeconds (1).GetPicoSeconds (). It will most likely return 0 because the Time object has only 64 bits of fractional precision which means that PicoSeconds (1) is stored as a 64-bit aproximation of 1/1000 in the Time object. If you later multiply it again by the exact value 1000, the result is unlikely to be 1 exactly. It will be close to 1 but not exactly 1.
In general, it is thus a really bad idea to try to use time objects of a resolution higher than the global resolution controlled through TimeBase::SetResolution. If you do need to use picoseconds, it's thus best to switch the global resolution to picoseconds to avoid nasty surprises.
Another important issue to keep in mind is that if you increase the global resolution, you also implicitely decrease the range of your simulation. i.e., the global simulation time is stored in a 64 bit integer whose interpretation will depend on the global resolution so, 2^64 picoseconds which is the maximum duration of your simulation if the global resolution is picoseconds is smaller than 2^64 nanoseconds which is the maximum duration of your simulation if the global resolution is nanoseconds.
Finally, don't even think about ever changing the global resolution after creating Time objects: all Time objects created before the call to SetResolution will contain values which are not updated to the new resolution. In practice, the default value for the attributes of many models is indeed calculated before the main function of the main program enters. Because of this, if you use one of these models (and it's likely), it's going to be hard to change the global simulation resolution in a way which gives reasonable results. This issue has been filed as bug 954 in the ns-3 bugzilla installation.
Member Enumeration Documentation
| enum ns3::Time::Unit |
The unit to use to interpret a number representing time
Constructor & Destructor Documentation
| ns3::Time::Time | ( | const std::string & | s | ) |
String constructor Construct Time object from common time expressions like " 1ms" or "10s". Supported units include:
- s (seconds)
- ms (milliseconds)
- us (microseconds)
- ns (nanoseconds)
- ps (picoseconds)
- fs (femtoseconds).
There can be no white space between the numerical portion and the units. Any otherwise malformed string causes a fatal error to occur.
- Parameters:
-
s The string to parse into a Time
Member Function Documentation
- Parameters:
-
value to convert into a Time object timeUnit the unit of the value to convert
- Returns:
- a new Time object
- See also:
- FromInteger, ToInteger, ToDouble
Referenced by ns3::Seconds().
- Parameters:
-
value to convert into a Time object timeUnit the unit of the value to convert
- Returns:
- a new Time object
This method interprets the input value according to the input unit and constructs a matching Time object.
- See also:
- FromDouble, ToDouble, ToInteger
Referenced by ns3::FemtoSeconds(), ns3::MicroSeconds(), ns3::MilliSeconds(), ns3::NanoSeconds(), and ns3::PicoSeconds().
| int64_t ns3::Time::GetFemtoSeconds | ( | void | ) | const [inline] |
- Returns:
- an approximation in femtoseconds of the time stored in this instance.
References ToInteger().
| HighPrecision const& ns3::Time::GetHighPrecision | ( | void | ) | const [inline] |
This is really an internal method exported for the needs of the implementation. Please, Do not try to use this method, ever.
- Returns:
- the ns3::HighPrecision object which holds the value stored in this instance of Time type.
| int64_t ns3::Time::GetMicroSeconds | ( | void | ) | const [inline] |
- Returns:
- an approximation in microseconds of the time stored in this instance.
References ToInteger().
| int64_t ns3::Time::GetMilliSeconds | ( | void | ) | const [inline] |
- Returns:
- an approximation in milliseconds of the time stored in this instance.
References ToInteger().
| int64_t ns3::Time::GetNanoSeconds | ( | void | ) | const [inline] |
- Returns:
- an approximation in nanoseconds of the time stored in this instance.
References ToInteger().
| int64_t ns3::Time::GetPicoSeconds | ( | void | ) | const [inline] |
- Returns:
- an approximation in picoseconds of the time stored in this instance.
References ToInteger().
| static enum Unit ns3::Time::GetResolution | ( | void | ) | [static] |
- Returns:
- the current global resolution.
| double ns3::Time::GetSeconds | ( | void | ) | const [inline] |
- Returns:
- an approximation in seconds of the time stored in this instance.
References ToDouble().
| int64_t ns3::Time::GetTimeStep | ( | void | ) | const [inline] |
- Returns:
- an approximation of the time stored in this instance in the units specified in m_tsPrecision.
| bool ns3::Time::IsNegative | ( | void | ) | const [inline] |
- Returns:
- true if the time is negative or zero, false otherwise.
| bool ns3::Time::IsPositive | ( | void | ) | const [inline] |
- Returns:
- true if the time is positive or zero, false otherwise.
| bool ns3::Time::IsStrictlyNegative | ( | void | ) | const [inline] |
- Returns:
- true if the time is strictly negative, false otherwise.
| bool ns3::Time::IsStrictlyPositive | ( | void | ) | const [inline] |
- Returns:
- true if the time is strictly positive, false otherwise.
| bool ns3::Time::IsZero | ( | void | ) | const [inline] |
- Returns:
- true if the time is zero, false otherwise.
| static void ns3::Time::SetResolution | ( | enum Unit | resolution | ) | [static] |
- Parameters:
-
time a Time object timeUnit the unit of the value to return
Convert the input time into a floating point value according to the requested time unit.
Referenced by GetSeconds().
- Parameters:
-
time a Time object timeUnit the unit of the value to return
Convert the input time into an integer value according to the requested time unit.
Referenced by GetFemtoSeconds(), GetMicroSeconds(), GetMilliSeconds(), GetNanoSeconds(), and GetPicoSeconds().
The documentation for this class was generated from the following file:
- src/simulator/nstime.h
