Getting chrono time in a specific way

Question

I have a C code:

uint64_t combine(uint32_t const sec, uint32_t const usec){ return (uint64_t) sec << 32 | usec; }; uint64_t now3(){ struct timeval tv; gettimeofday(&tv, NULL); return combine((uint32_t) tv.tv_sec, (uint32_t) tv.tv_usec); } 

What this means is that it combines a 32-bit timestamp and a 32-bit "something", possibly micro / nanoseconds, into a single integer of 64 bits.

It is very difficult for me to rewrite it in C ++ 11 chrono.

This is what I have done so far, but I think this is the wrong way to do it.

 auto tse = std::chrono::system_clock::now().time_since_epoch(); auto dur = std::chrono::duration_cast<std::chrono::nanoseconds>( tse ).count(); uint64_t time = static_cast<uint64_t>( dur ); 

Important Note . I need the first 32 bits to be “valid” timestamps.

The second 32-bit "part" can be anything - nano or microseconds - everything is fine if two consecutive calls to this function give me another second "part".

Answer 1

I need seconds in one int, milliseconds in another.

Here is the code for this:

 #include <chrono> #include <iostream> int main() { auto now = std::chrono::system_clock::now().time_since_epoch(); std::cout << now.count() << '\n'; auto s = std::chrono::duration_cast<std::chrono::seconds>(now); now -= s; auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(now); int si = s.count(); int msi = ms.count(); std::cout << si << '\n'; std::cout << msi << '\n'; } 

This is just for me:

 1447109182307707 1447109182 307 

Answer 2

The chrono types of C ++ 11 use only one number to represent time from a given era, unlike the timeval (or timespec ) structure, which uses two numbers to represent time accurately. So, with C ++ 11 chrono you don't need the combine() method.

The contents of the timestamp returned by now() depends on the clock you use; There is a tree clock described at http://en.cppreference.com/w/cpp/chrono :

 system_clock wall clock time from the system-wide realtime clock steady_clock monotonic clock that will never be adjusted high_resolution_clock the clock with the shortest tick period available 

If you want consistent timestamps to always be different, use a constant clock:

 auto t1 = std::chrono::steady_clock::now(); ... auto t2 = std::chrono::steady_clock::now(); assert (t2 > t1); 

Edit: Reply to comment

 #include <iostream> #include <chrono> #include <cstdint> int main() { typedef std::chrono::duration< uint32_t, std::ratio<1> > s32_t; typedef std::chrono::duration< uint32_t, std::milli > ms32_t; s32_t first_part; ms32_t second_part; auto t1 = std::chrono::nanoseconds( 2500000000 ); // 2.5 secs first_part = std::chrono::duration_cast<s32_t>(t1); second_part = std::chrono::duration_cast<ms32_t>(t1-first_part); std::cout << "first part = " << first_part.count() << " s\n" << "seconds part = " << second_part.count() << " ms" << std::endl; auto t2 = std::chrono::nanoseconds( 2800000000 ); // 2.8 secs first_part = std::chrono::duration_cast<s32_t>(t2); second_part = std::chrono::duration_cast<ms32_t>(t2-first_part); std::cout << "first part = " << first_part.count() << " s\n" << "seconds part = " << second_part.count() << " ms" << std::endl; } 

Output:

 first part = 2 s seconds part = 500 ms first part = 2 s seconds part = 800 ms