Skip to content
Snippets Groups Projects
Commit 7b9ca12a authored by Joan Vallvé Navarro's avatar Joan Vallvé Navarro
Browse files

new implementation

parent 5cfc52c4
No related branches found
No related tags found
1 merge request!209Time stamp
This commit is part of merge request !209. Comments created here will be created in the context of that merge request.
Hide whitespace changes
Inline Side-by-side
src/test/gtest_time_stamp.cpp
+ 89
− 3
View file @ 7b9ca12a
...@@ -39,7 +39,7 @@ TEST(WolfTestTimeStamp, TimeStampInitScalar) ...@@ -39,7 +39,7 @@ TEST(WolfTestTimeStamp, TimeStampInitScalar)
std::stringstream ss; std::stringstream ss;
start.print(ss); start.print(ss);
ASSERT_STREQ("101010.0000000000", ss.str().c_str()); ASSERT_STREQ("101010.000000000", ss.str().c_str());
// PRINTF("All good at WolfTestTimeStamp::TimeStampInitScalar !\n"); // PRINTF("All good at WolfTestTimeStamp::TimeStampInitScalar !\n");
} }
...@@ -61,11 +61,58 @@ TEST(WolfTestTimeStamp, TimeStampInitScalarSecNano) ...@@ -61,11 +61,58 @@ TEST(WolfTestTimeStamp, TimeStampInitScalarSecNano)
std::stringstream ss; std::stringstream ss;
start.print(ss); start.print(ss);
ASSERT_STREQ("101010.0002020200", ss.str().c_str()); ASSERT_STREQ("101010.000202020", ss.str().c_str());
// PRINTF("All good at WolfTestTimeStamp::TimeStampInitScalarSecNano !\n"); // PRINTF("All good at WolfTestTimeStamp::TimeStampInitScalarSecNano !\n");
} }
TEST(WolfTestTimeStamp, TimeStampSetNow)
{
wolf::TimeStamp t1;
wolf::TimeStamp t2(t1);
ASSERT_EQ(t1,t2);
// If we don't sleep, start == time_stamp sometimes.
// And sometimes start <= time_stamp ...
std::this_thread::sleep_for(std::chrono::microseconds(1));
t2.setToNow();
ASSERT_LT(t1,t2);
}
TEST(WolfTestTimeStamp, TimeStampSetScalar)
{
wolf::Scalar val(101010.000202020);
wolf::TimeStamp start;
start.set(val);
ASSERT_EQ(start.get(), val);
ASSERT_EQ(start.getSeconds(), 101010);
ASSERT_EQ(start.getNanoSeconds(), 202020);
std::stringstream ss;
start.print(ss);
ASSERT_STREQ("101010.000202020", ss.str().c_str());
}
TEST(WolfTestTimeStamp, TimeStampSetSecNano)
{
unsigned long int sec(101010);
unsigned long int nano(202020);
wolf::TimeStamp start;
start.set(sec,nano);
// start.get -> 101010.000202020004508
ASSERT_EQ(start.getSeconds(), sec);
ASSERT_EQ(start.getNanoSeconds(), nano);
}
TEST(WolfTestTimeStamp, TimeStampEquality) TEST(WolfTestTimeStamp, TimeStampEquality)
{ {
wolf::TimeStamp start; wolf::TimeStamp start;
...@@ -111,14 +158,40 @@ TEST(WolfTestTimeStamp, TimeStampInequality) ...@@ -111,14 +158,40 @@ TEST(WolfTestTimeStamp, TimeStampInequality)
// PRINTF("All good at WolfTestTimeStamp::TimeStampInequality !\n"); // PRINTF("All good at WolfTestTimeStamp::TimeStampInequality !\n");
} }
TEST(WolfTestTimeStamp, TimeStampSubstraction)
{
wolf::TimeStamp t1;
wolf::TimeStamp t2(t1);
wolf::Scalar dt(1e-5);
t2+=dt;
ASSERT_LT(t1, t2);
ASSERT_EQ(t2-t1, dt);
ASSERT_EQ(t1-t2, -dt);
}
TEST(WolfTestTimeStamp, TimeStampAdding)
{
wolf::TimeStamp t1,t3;
wolf::TimeStamp t2(t1);
wolf::Scalar dt(1e-5);
t2 +=dt;
t3 = t1+dt;
ASSERT_EQ(t2, t3);
}
TEST(WolfTestTimeStamp, TimeStampOperatorOstream) TEST(WolfTestTimeStamp, TimeStampOperatorOstream)
{ {
wolf::TimeStamp t(5); wolf::TimeStamp t(5);
wolf::Scalar dt = 1e-4; wolf::Scalar dt = 1e-4;
t+=dt; t+=dt;
std::ostringstream ss1, ss2; std::ostringstream ss1, ss2;
t.print(ss1);
ss1 << t.get();
ss2 << t; ss2 << t;
ASSERT_EQ(ss1.str(), ss2.str()); ASSERT_EQ(ss1.str(), ss2.str());
...@@ -126,6 +199,19 @@ TEST(WolfTestTimeStamp, TimeStampOperatorOstream) ...@@ -126,6 +199,19 @@ TEST(WolfTestTimeStamp, TimeStampOperatorOstream)
// PRINTF("All good at WolfTestTimeStamp::TimeStampOperatorOstream !\n"); // PRINTF("All good at WolfTestTimeStamp::TimeStampOperatorOstream !\n");
} }
TEST(WolfTestTimeStamp, TimeStampSecNanoSec)
{
unsigned long int sec = 5;
unsigned long int nano = 1e5;
wolf::TimeStamp t1(wolf::Scalar(sec)+wolf::Scalar(nano)*1e-9);
wolf::TimeStamp t2(sec,nano);
ASSERT_EQ(t1.getSeconds(),sec);
ASSERT_EQ(t2.getSeconds(),sec);
ASSERT_EQ(t1.getNanoSeconds(),nano);
ASSERT_EQ(t2.getNanoSeconds(),nano);
}
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
testing::InitGoogleTest(&argc, argv); testing::InitGoogleTest(&argc, argv);
......
src/time_stamp.cpp
+ 38
− 27
View file @ 7b9ca12a
...@@ -14,26 +14,35 @@ std::ostream& operator<<(std::ostream& os, const TimeStamp& _ts) ...@@ -14,26 +14,35 @@ std::ostream& operator<<(std::ostream& os, const TimeStamp& _ts)
// std::streamsize nn; // std::streamsize nn;
// nn = os.precision(TimeStamp::TIME_STAMP_DIGITS_); // nn = os.precision(TimeStamp::TIME_STAMP_DIGITS_);
os << _ts.getSeconds() << "." << _ts.getNanoSeconds(); // write obj to stream os << _ts.getSeconds() << "." << std::setfill('0') << std::setw(9) <<_ts.getNanoSeconds(); // write obj to stream
return os; return os;
} }
TimeStamp::TimeStamp() : TimeStamp::TimeStamp() :
time_stamp_(0) //time_stamp_(0)
time_stamp_nano_(0)
{ {
setToNow(); setToNow();
} }
TimeStamp::TimeStamp(const Scalar _ts) : TimeStamp::TimeStamp(const TimeStamp& _ts) :
time_stamp_(_ts) time_stamp_nano_(_ts.time_stamp_nano_)
{ {
// //
} }
TimeStamp::TimeStamp(const unsigned long int _sec, const unsigned long int _nsec) : TimeStamp::TimeStamp(const Scalar& _ts) :
time_stamp_((Scalar)_sec + (Scalar)_nsec/(Scalar)1e9) //time_stamp_(_ts)
time_stamp_nano_((unsigned long int)(_ts*1e9))
{
//
}
TimeStamp::TimeStamp(const unsigned long int& _sec, const unsigned long int& _nsec) :
//time_stamp_((Scalar)_sec + (Scalar)_nsec/(Scalar)1e9)
time_stamp_nano_(_sec*NANOSECS+_nsec)
{ {
// //
} }
...@@ -47,39 +56,41 @@ void TimeStamp::setToNow() ...@@ -47,39 +56,41 @@ void TimeStamp::setToNow()
{ {
timeval ts; timeval ts;
gettimeofday(&ts, NULL); gettimeofday(&ts, NULL);
time_stamp_ = (Scalar)((ts.tv_sec)) + (Scalar)((ts.tv_usec)) / 1e6; set(ts);
} }
unsigned long int TimeStamp::getSeconds() const TimeStamp TimeStamp::operator +(const Scalar& dt) const
{ {
unsigned long int ts; TimeStamp ts(*this);
ts = (unsigned long int)(((floor(time_stamp_)))); ts += dt;
return ts; return ts;
} }
unsigned long int TimeStamp::getNanoSeconds() const TimeStamp TimeStamp::operator -(const Scalar& dt) const
{ {
Scalar ts; TimeStamp ts(*this);
ts = (Scalar)(((floor(time_stamp_)))); ts -= dt;
return (unsigned long int)(((time_stamp_ - ts) * 1e9)); return ts;
} }
void TimeStamp::print(std::ostream & ost) const void TimeStamp::print(std::ostream & ost) const
{ {
std::streamsize nn; //std::streamsize nn;
std::ios_base::fmtflags fmtfl; //std::ios_base::fmtflags fmtfl;
//
//get/set ostream flags and precision digits ////get/set ostream flags and precision digits
fmtfl = ost.flags(std::ios::left); //fmtfl = ost.flags(std::ios::left);
ost.setf(std::ios::fixed, std::ios::floatfield); //ost.setf(std::ios::fixed, std::ios::floatfield);
nn = ost.precision(TIME_STAMP_DIGITS_); //nn = ost.precision(TIME_STAMP_DIGITS_);
//
//send to ostream ////send to ostream
ost << this->time_stamp_; //ost << this->time_stamp_;
//
////restore flags and precision
//ost.flags(fmtfl);
//ost.precision(nn);
//restore flags and precision ost << this->getSeconds() << "." << std::setfill('0') << std::setw(9) << this->getNanoSeconds();
ost.flags(fmtfl);
ost.precision(nn);
} }
} // namespace wolf } // namespace wolf
src/time_stamp.h
+ 86
− 34
View file @ 7b9ca12a
...@@ -8,7 +8,9 @@ ...@@ -8,7 +8,9 @@
//C, std //C, std
#include <sys/time.h> #include <sys/time.h>
#include <iostream> #include <iostream>
#include <iomanip>
static const unsigned int NANOSECS = 1000000000;
namespace wolf { namespace wolf {
...@@ -19,9 +21,10 @@ namespace wolf { ...@@ -19,9 +21,10 @@ namespace wolf {
*/ */
class TimeStamp class TimeStamp
{ {
private: protected:
Scalar time_stamp_; ///< Time stamp. Expressed in seconds from 1th jan 1970. unsigned long int time_stamp_nano_; ///< Time stamp. Expressed in nanoseconds from 1th jan 1970.
static const unsigned int TIME_STAMP_DIGITS_ = 10; ///< Number of digits to print time stamp values //Scalar time_stamp_; ///< Time stamp. Expressed in seconds from 1th jan 1970.
//static const unsigned int TIME_STAMP_DIGITS_ = 10; ///< Number of digits to print time stamp values
public: public:
/** \brief Constructor /** \brief Constructor
...@@ -31,19 +34,26 @@ class TimeStamp ...@@ -31,19 +34,26 @@ class TimeStamp
*/ */
TimeStamp(); TimeStamp();
/** \brief Copy constructor
*
* Copy constructor
*
*/
TimeStamp(const TimeStamp& _ts);
/** \brief Constructor with argument /** \brief Constructor with argument
* *
* Constructor with arguments * Constructor with arguments
* *
*/ */
TimeStamp(const Scalar _ts); TimeStamp(const Scalar& _ts);
/** \brief Constructor from sec and nsec /** \brief Constructor from sec and nsec
* *
* Constructor from sec and nsec * Constructor from sec and nsec
* *
*/ */
TimeStamp(const unsigned long int _sec, const unsigned long int _nsec); TimeStamp(const unsigned long int& _sec, const unsigned long int& _nsec);
/** \brief Destructor /** \brief Destructor
* *
...@@ -67,14 +77,14 @@ class TimeStamp ...@@ -67,14 +77,14 @@ class TimeStamp
* Sets time stamp to a given value passed as a two-integer (seconds and nanoseconds) * Sets time stamp to a given value passed as a two-integer (seconds and nanoseconds)
* *
*/ */
void set(const unsigned long int sec, const unsigned long int nanosec); void set(const unsigned long int& sec, const unsigned long int& nanosec);
/** \brief Set time stamp /** \brief Set time stamp
* *
* Sets time stamp to a given value passed as a scalar_t (seconds) * Sets time stamp to a given value passed as a scalar_t (seconds)
* *
*/ */
void set(const Scalar ts); void set(const Scalar& ts);
/** \brief Get time stamp /** \brief Get time stamp
* *
...@@ -129,13 +139,6 @@ class TimeStamp ...@@ -129,13 +139,6 @@ class TimeStamp
bool operator <=(const TimeStamp& ts) const; bool operator <=(const TimeStamp& ts) const;
bool operator >=(const TimeStamp& ts) const; bool operator >=(const TimeStamp& ts) const;
/** \brief difference operator
*
* difference operator that returns a scalar_t (seconds)
*
*/
Scalar operator -(const TimeStamp& ts) const;
/** \brief Add-assign operator given a scalar_t (seconds) /** \brief Add-assign operator given a scalar_t (seconds)
*/ */
void operator +=(const Scalar& dt); void operator +=(const Scalar& dt);
...@@ -144,6 +147,24 @@ class TimeStamp ...@@ -144,6 +147,24 @@ class TimeStamp
*/ */
TimeStamp operator +(const Scalar& dt) const; TimeStamp operator +(const Scalar& dt) const;
/** \brief Substraction-assign operator given a scalar_t (seconds)
*/
void operator -=(const Scalar& dt);
/** \brief difference operator
*
* difference operator that returns a scalar_t (seconds)
*
*/
TimeStamp operator -(const Scalar& ts) const;
/** \brief difference operator
*
* difference operator that returns a Timestamp (seconds)
*
*/
Scalar operator -(const TimeStamp& ts) const;
/** \brief Prints time stamp to a given ostream /** \brief Prints time stamp to a given ostream
* *
* Prints time stamp to a given ostream * Prints time stamp to a given ostream
...@@ -155,79 +176,110 @@ class TimeStamp ...@@ -155,79 +176,110 @@ class TimeStamp
}; };
inline void TimeStamp::set(const Scalar ts) inline void TimeStamp::set(const Scalar& ts)
{ {
time_stamp_ = ts; //time_stamp_ = ts;
time_stamp_nano_ = (unsigned long int)(ts*NANOSECS);
} }
inline void TimeStamp::set(const unsigned long int sec, const unsigned long int nanosec) inline void TimeStamp::set(const unsigned long int& sec, const unsigned long int& nanosec)
{ {
time_stamp_ = (Scalar)(sec) + (Scalar)(nanosec) / (Scalar)(1e9); //time_stamp_ = (Scalar)(sec) + (Scalar)(nanosec) / (Scalar)(1e9);
time_stamp_nano_ = sec*NANOSECS+nanosec;
} }
inline void TimeStamp::set(const timeval& ts) inline void TimeStamp::set(const timeval& ts)
{ {
time_stamp_ = (Scalar)(ts.tv_sec) + (Scalar)(ts.tv_usec) / 1e6; //time_stamp_ = (Scalar)(ts.tv_sec) + (Scalar)(ts.tv_usec) / 1e6;
time_stamp_nano_ = (unsigned long int)(ts.tv_sec*NANOSECS) + (unsigned long int)(ts.tv_usec*1000);
} }
inline Scalar TimeStamp::get() const inline Scalar TimeStamp::get() const
{ {
return time_stamp_; //return time_stamp_;
return ((Scalar)( time_stamp_nano_))*1e-9;
}
inline unsigned long int TimeStamp::getSeconds() const
{
//unsigned long int ts;
//ts = (unsigned long int)(((floor(time_stamp_))));
//return ts;
return time_stamp_nano_ / NANOSECS;
}
inline unsigned long int TimeStamp::getNanoSeconds() const
{
//Scalar ts;
//ts = (Scalar)((floor(time_stamp_)));
//return (unsigned long int)(((time_stamp_ - ts) * 1e9));
return time_stamp_nano_ % NANOSECS;
} }
inline void TimeStamp::operator =(const TimeStamp& ts) inline void TimeStamp::operator =(const TimeStamp& ts)
{ {
time_stamp_ = ts.get(); //time_stamp_ = ts.get();
time_stamp_nano_ = ts.time_stamp_nano_;
} }
inline void TimeStamp::operator =(const Scalar& ts) inline void TimeStamp::operator =(const Scalar& ts)
{ {
time_stamp_ = ts; //time_stamp_ = ts;
time_stamp_nano_ = (unsigned long int)(ts*NANOSECS);
} }
inline bool TimeStamp::operator ==(const TimeStamp& ts) const inline bool TimeStamp::operator ==(const TimeStamp& ts) const
{ {
return (time_stamp_ == ts.get()); //return (time_stamp_ == ts.get());
return (time_stamp_nano_ == ts.time_stamp_nano_);
} }
inline bool TimeStamp::operator !=(const TimeStamp& ts) const inline bool TimeStamp::operator !=(const TimeStamp& ts) const
{ {
return (time_stamp_ != ts.get()); //return (time_stamp_ != ts.get());
return (time_stamp_nano_ != ts.time_stamp_nano_);
} }
inline bool TimeStamp::operator <(const TimeStamp& ts) const inline bool TimeStamp::operator <(const TimeStamp& ts) const
{ {
return (time_stamp_ < ts.get()); //return (time_stamp_ < ts.get());
return (time_stamp_nano_ < ts.time_stamp_nano_);
} }
inline bool TimeStamp::operator >(const TimeStamp& ts) const inline bool TimeStamp::operator >(const TimeStamp& ts) const
{ {
return (time_stamp_ > ts.get()); //return (time_stamp_ > ts.get());
return (time_stamp_nano_ > ts.time_stamp_nano_);
} }
inline bool TimeStamp::operator <=(const TimeStamp& ts) const inline bool TimeStamp::operator <=(const TimeStamp& ts) const
{ {
return (time_stamp_ <= ts.get()); //return (time_stamp_ <= ts.get());
return (time_stamp_nano_ <= ts.time_stamp_nano_);
} }
inline bool TimeStamp::operator >=(const TimeStamp& ts) const inline bool TimeStamp::operator >=(const TimeStamp& ts) const
{ {
return (time_stamp_ >= ts.get()); //return (time_stamp_ >= ts.get());
return (time_stamp_nano_ >= ts.time_stamp_nano_);
} }
inline Scalar TimeStamp::operator -(const TimeStamp& ts) const inline void TimeStamp::operator +=(const Scalar& dt)
{ {
return (time_stamp_ - ts.get()); //time_stamp_ += dt;
time_stamp_nano_ += (unsigned long int)(dt*NANOSECS);
} }
inline void TimeStamp::operator +=(const Scalar& dt) inline void TimeStamp::operator -=(const Scalar& dt)
{ {
time_stamp_ += dt; //time_stamp_ -= dt;
time_stamp_nano_ -= (unsigned long int)(dt*NANOSECS);
} }
inline TimeStamp TimeStamp::operator +(const Scalar& dt) const inline Scalar TimeStamp::operator -(const TimeStamp& ts) const
{ {
return TimeStamp(time_stamp_ + dt); //return (time_stamp_ - ts.get());
return Scalar((long int)(time_stamp_nano_ - ts.time_stamp_nano_))*1e-9; // long int cast fix overflow in case of negative substraction result
} }
static const TimeStamp InvalidStamp(-1,-1); static const TimeStamp InvalidStamp(-1,-1);
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment