Add Chrono.h - std::chrono support header

[labath]

Summary

std::chrono mostly covers the functionality of llvm::sys::TimeValue and
lldb_private::TimeValue. This header adds additional utility functions, which
make the usage of the library and porting code from TimeValues easier:

• conversion between std::chrono types and legacy C types (time_t, struct timeval, struct timespec).
• string converision
• a TimePoint typedef which defines a system_clock timepoint with nanosecond precision.

Rationale behind some of the design decisions:

• precision of system_clock is implementation defined - using a well-defined precision helps maintain consistency between platforms, makes it interact better with existing TimeValue classes, and avoids cases there a time point is implicitly convertible to a specific precision on some platforms but not on others.
• system_clock::to_time_t only accepts time_points with the default system precision (even though time_t has only second precision on all platforms we support). To avoid the need for explicit casts, I have added a toTimeT() wrapper function. toTimePoint(time_t) was not strictly necessary, but I have added it for symmetry.
• the duration version of toTimeVal() only accepts durations with microsecond precision (forcing the user to explicitly cast if he has a nanosecond duration), but the time point version, casts away the precision implicitly. The rationalle behind that is that for time points the extra precision is not likely to be important, while one may concievably care about the extra precision for durations.

[zturner]

Did you forget Windows/Chrono.inc?

[labath]

I don't have that written yet :) - I'll do that on Tuesday when my hands on a windows machine (I also may need to adjust the includes a bit to make sure we have timespec and timeval defined on all platforms). The general interface should be complete and working (currently I'm testing on osx) though, and I'm looking for a first round of feedback.

[labath]

I am considering a somewhat different approach now. timespec does not seem to be defined on windows at all, and timeval only exists to support select() in the bsd socket emulation layer. I don't think llvm should be exposing such a platform-specific interface. A better solution would be to identify things in lldb which need these functions, lower them into llvm and wrap in a platform-independent interface which speaks std::chrono (then the conversion utilities can remain in unix-specific code). This will require more cleanups on the lldb side though.

I'd still like to commit this without the part that deals with the fancy conversions - even without them, this supersedes llvm and lldb TimeValue, and replacing TimeValue with it seems pretty easy (I am almost done with that locally).

[labath]

Summary of changes:

• remove code dealing with system types (timespec, timeval)
• Switch TimeValue to use TimePoint under the hood for some things to avoid duplication
• Add (still untested) windows implementation - I've removed the "old mingw" support code present in TimeValue - the last (unsuccessful) attempt at that was three years ago - we'll see if we have better luck this time. I've followed TimeValue's patter here, but the two implementations have a lot of code in common, and it might be worth refactoring it a bit.

[labath]

Sorry about the delay, I only got to check the windows version today. This
update actually makes it compile now. I've tested this on mac, osx, and windows
(with msvc) and the tests pass.

Could you take a look and let me know what you think?

[mehdi_amini]

Looks fine to me overall! Thanks.

unittests/Support/Chrono.cpp

36 ↗

(On Diff #74697)

I initially thought this test (StringConversion ) would be doing something else (TimePoint string conversion), but both are valuable so what do you think about another test like:

  auto Now = system_clock::now();
  
  std::string S1;
  {
    raw_string_ostream OS(S1);
    OS << system_clock::now();
   }

  TimePoint T(Now);
  std::string S2;
  {
    raw_string_ostream OS(S2);
    OS << T;
   }
   ASSERT_EQ(S1, S2);
}

(I don't think you added coverage for raw_ostream &operator<<(raw_ostream &OS, TimePoint TP) {, it is likely covered by the TimeValue tests (if any), but if we remove TimeValue at some point we may lose the coverage.

[labath]

unittests/Support/Chrono.cpp

36 ↗

(On Diff #74697)

TimePoint is just a typedef for a pre-existing STL type that is implicitly constructible from the result of system_clock::now(). So, OS << system_clock::now() will actually invoke the raw_ostream &operator<<(raw_ostream &OS, TimePoint TP). The only difference between OS << system_clock::now(), and OS << TimePoint(system_clock::now() is that in the latter, the conversion operation is explicit (i.e., the newly introduced operator<< will have coverage even when TimeValue is removed, which I plan to do soon).

I can add the test you mentioned, but I don't think it is that useful, as it will just compare two invocations of the same function. I can also add an explicit TimePoint cast to the existing test, if you think that will make things clearer.

[mehdi_amini]

unittests/Support/Chrono.cpp

36 ↗

(On Diff #74697)

I missed that the conversion was implicit here.

[zturner]

include/llvm/Support/Chrono.h

26–27 ↗

(On Diff #74697)

I'm not sure if it's appropriate to have a generic name like TimePoint (which indicates it should be used for any and all time calculations) be forced to a specific resolution. A couple of possibilities would be:

1. Call it TimePointNano
2. making it an alias template (e.g. template<typename R> using TimePoint = time_point<system_clock, T>)

30 ↗

(On Diff #74697)

Any reason this function shouldn't be templated to work with arbitrary resolutions?

Also, I would use LLVM_ATTRIBUTE_ALWAYS_INLINE instead of the inline keyword.

37 ↗

(On Diff #74697)

Same.

include/llvm/Support/TimeValue.h

117 ↗

(On Diff #74697)

I might be missing something, but PosixZeroTimeSeconds is defined in a cpp file but you're using it in a header file. And it's not forward declared anywhere?

lib/Support/Windows/Chrono.inc

23 ↗

(On Diff #74697)

The windows and non-windows versions appear identical except for the call to _localtime64_s vs localtime_r. This is a case where the implementations are similar enough that I think it does more harm than good to separate the files like this. I would put one function in Chrono.cpp with a preprocessor directive to select either _localtime64_s or localtime_r.

[labath]

Responses to comments inline. I will upload a new version of the code tomorrow.

include/llvm/Support/Chrono.h

26–27 ↗

(On Diff #74697)

I wanted to make the usage as frictionless as possible (and TimeValue already used nanoseconds precision and noone seemed to be bothered by that), but I do see your point. How about we go for the second option, but we have a default template parameter, so people don't have to specify precision unless they actually need to. I have two counter-proposals:

• template<typename D = nanoseconds> using TimePoint = time_point<system_clock, D>, with the usage being: TimePoint<std::chrono::microseconds>
• template<typename R = nano> using TimePoint = time_point<system_clock, duration<XXX, R>>, with the usage being TimePoint<std::micro>

I'd tend towards the second option as it is shorter if you don't import std::chrono namespace, but I don't care too much, as I don't anticipate much usage with a custom precision.

30 ↗

(On Diff #74697)

All (reasonable) time_points are implicitly convertible to a time_point with nanosecond precision, so this will already work with all of them, without the need for templating. The only difference I see is that a time_point with second precision will probably have higher range than the nanosecond one, but I don't think we ought to be relying on anywhere anyway.

37 ↗

(On Diff #74697)

I suppose we could return a time_point with second precision, as that is all that's stored in a time_t anyway. I don't think we need templates, because of implicit conversions.

include/llvm/Support/TimeValue.h

117 ↗

(On Diff #74697)

It's declared in this file, line 375.

lib/Support/Windows/Chrono.inc

23 ↗

(On Diff #74697)

Sounds like a good idea.

[zturner]

include/llvm/Support/Chrono.h

26–27 ↗

(On Diff #74697)

I agree, it might not ever be used, but who knows. The second usage looks fine to me.

37 ↗

(On Diff #74697)

Ok, as long as there are implicit conversions then no worries. Can you add a unit test that exercises one of the implicit conversions?

[labath]

Summary of changes:

• Made TimePoint a template. User can specify the desired precision, but the default will be nanoseconds. I decided to go with the first proposal as there is to typedef for std::ratio<1>. If one wants to override precision, he should use the duration types (std::chrono::seconds).
• Added tests that verify that: a) result of toTimePoint can be stored in any timepoint with less-than-second precision; b) toTimeT accepts timepoints with more-than-nanosecond precisions
• use LLVM_ATTRIBUTE_ALWAYS_INLINE for the tiny wrapper functions
• move Chrono.inc files back into Chrono.cpp

[labath]

• remove dead code I accidentaly left it
• Make the TimeValue conversion constructor a template. Otherwise the compiler would not find the implicit conversion sequence TimePoint<X> -> TimePoint<> -> TimeValue, and the only reason I am having that constructor is to make piecewise migration easier.

[zturner]

Feel free to commit after addressing the comments below.

lib/Support/Chrono.cpp

1 ↗

(On Diff #74993)

lib/Support/Chrono.h

28 ↗

(On Diff #74993)

I believe std::time_t still works here (and moreover that it's incorrect as written, in the case that _USE_32BIT_TIME_T is defined. This can probably be raised out of the #if

32–34 ↗

(On Diff #74993)

I would probably write this as:

#if defined(LLVM_ON_WIN32)
#else
#endif

llvm/trunk/include/llvm/Support/Chrono.h

+//===- llvm/Support/Chrono.h - Utilities for Timing Manipulation-*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_CHRONO_H
+#define LLVM_SUPPORT_CHRONO_H
+
+#include "llvm/Support/Compiler.h"
+
+#include <chrono>
+#include <ctime>
+
+namespace llvm {
+
+class raw_ostream;
+
+namespace sys {
+
+/// A time point on the system clock. This is provided for two reasons:
+/// - to insulate us agains subtle differences in behavoir to differences in
+///   system clock precision (which is implementation-defined and differs between
+///   platforms).
+/// - to shorten the type name
+/// The default precision is nanoseconds. If need a specific precision specify
+/// it explicitly. If unsure, use the default. If you need a time point on a
+/// clock other than the system_clock, use std::chrono directly.
+template <typename D = std::chrono::nanoseconds>
+using TimePoint = std::chrono::time_point<std::chrono::system_clock, D>;
+
+/// Convert a TimePoint to std::time_t
+LLVM_ATTRIBUTE_ALWAYS_INLINE inline std::time_t toTimeT(TimePoint<> TP) {
+  using namespace std::chrono;
+  return system_clock::to_time_t(
+      time_point_cast<system_clock::time_point::duration>(TP));
+}
+
+/// Convert a std::time_t to a TimePoint
+LLVM_ATTRIBUTE_ALWAYS_INLINE inline TimePoint<std::chrono::seconds>
+toTimePoint(std::time_t T) {
+  using namespace std::chrono;
+  return time_point_cast<seconds>(system_clock::from_time_t(T));
+}
+
+} // namespace sys
+
+raw_ostream &operator<<(raw_ostream &OS, sys::TimePoint<> TP);
+
+} // namespace llvm
+
+#endif // LLVM_SUPPORT_CHRONO_H

llvm/trunk/include/llvm/Support/TimeValue.h

 //===-- TimeValue.h - Declare OS TimeValue Concept --------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This header file declares the operating system TimeValue concept.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_TIMEVALUE_H
 #define LLVM_SUPPORT_TIMEVALUE_H
 
+#include "llvm/Support/Chrono.h"
 #include "llvm/Support/DataTypes.h"
 #include <string>
 
 namespace llvm {
 namespace sys {
   /// This class is used where a precise fixed point in time is required. The
   /// range of TimeValue spans many hundreds of billions of years both past and
   /// present.  The precision of TimeValue is to the nanosecond. However, the
explicit TimeValue( double new_time )
       : seconds_( 0 ) , nanos_ ( 0 ) {
       SecondsType integer_part = static_cast<SecondsType>( new_time );
       seconds_ = integer_part;
       nanos_ = static_cast<NanoSecondsType>( (new_time -
                static_cast<double>(integer_part)) * NANOSECONDS_PER_SECOND );
       this->normalize();
     }
 
+    template<typename D>
+    TimeValue(TimePoint<D> TP)
+        : seconds_(sys::toTimeT(TP) + PosixZeroTimeSeconds),
+          nanos_((TimePoint<>(TP).time_since_epoch() % std::chrono::seconds(1)).count()) {}
+
     /// This is a static constructor that returns a TimeValue that represents
     /// the current time.
     /// @brief Creates a TimeValue with the current time (UTC).
     static TimeValue now();
 
   /// @}
   /// @name Operators
   /// @{
   public:
+    operator TimePoint<>() const {
+      return toTimePoint(seconds_ - PosixZeroTimeSeconds) +
+             std::chrono::nanoseconds(nanos_);
+    }
+
     /// Add \p that to \p this.
     /// @returns this
     /// @brief Incrementing assignment operator.
     TimeValue& operator += (const TimeValue& that ) {
       this->seconds_ += that.seconds_  ;
       this->nanos_ += that.nanos_ ;
       this->normalize();
       return *this;

llvm/trunk/lib/Support/CMakeLists.txt

add_llvm_library(LLVMSupport
   APSInt.cpp
   ARMBuildAttrs.cpp
   ARMWinEH.cpp
   Allocator.cpp
   BlockFrequency.cpp
   BranchProbability.cpp
   CachePruning.cpp
   circular_raw_ostream.cpp
+  Chrono.cpp
   COM.cpp
   CommandLine.cpp
   Compression.cpp
   ConvertUTF.cpp
   ConvertUTFWrapper.cpp
   CrashRecoveryContext.cpp
   DataExtractor.cpp
   DataStream.cpp

llvm/trunk/lib/Support/Chrono.cpp

+//===- Support/Chrono.cpp - Utilities for Timing Manipulation ---*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/Chrono.h"
+#include "llvm/Config/config.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+
+using namespace sys;
+
+static inline struct tm getStructTM(TimePoint<> TP) {
+  struct tm Storage;
+  std::time_t OurTime = toTimeT(TP);
+
+#if defined(LLVM_ON_UNIX)
+  struct tm *LT = ::localtime_r(&OurTime, &Storage);
+  assert(LT);
+  (void)LT;
+#endif
+#if defined(LLVM_ON_WIN32)
+  int Error = ::_localtime64_s(&Storage, &OurTime);
+  assert(!Error);
+  (void)Error;
+#endif
+
+  return Storage;
+}
+
+raw_ostream &operator<<(raw_ostream &OS, TimePoint<> TP) {
+  struct tm LT = getStructTM(TP);
+  char Buffer[sizeof("YYYY-MM-DD HH:MM:SS")];
+  strftime(Buffer, sizeof(Buffer), "%Y-%m-%d %H:%M:%S", &LT);
+  return OS << Buffer << '.'
+            << format("%.9lu",
+                      long((TP.time_since_epoch() % std::chrono::seconds(1))
+                               .count()));
+}
+
+} // namespace llvm

llvm/trunk/lib/Support/TimeValue.cpp

 //===-- TimeValue.cpp - Implement OS TimeValue Concept ----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements the operating system TimeValue concept.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/TimeValue.h"
-#include "llvm/Config/config.h"
+#include "llvm/Support/Chrono.h"
+#include "llvm/Support/ScopedPrinter.h"
 
 namespace llvm {
 
 using namespace sys;
 
 const TimeValue::SecondsType
   TimeValue::PosixZeroTimeSeconds = -946684800;
 const TimeValue::SecondsType
if (seconds_ >= 1 && nanos_ < 0) {
     seconds_--;
     nanos_ += NANOSECONDS_PER_SECOND;
   } else if (seconds_ < 0 && nanos_ > 0) {
     seconds_++;
     nanos_ -= NANOSECONDS_PER_SECOND;
   }
 }
 
-} // namespace llvm
+std::string TimeValue::str() const { return to_string(TimePoint<>(*this)); }
+
+TimeValue TimeValue::now() {
+  return TimePoint<>(std::chrono::system_clock::now());
+}
 
-/// Include the platform-specific portion of TimeValue class
-#ifdef LLVM_ON_UNIX
-#include "Unix/TimeValue.inc"
-#endif
-#ifdef LLVM_ON_WIN32
-#include "Windows/TimeValue.inc"
-#endif
+} // namespace llvm

llvm/trunk/lib/Support/Unix/TimeValue.inc

-//===- Unix/TimeValue.cpp - Unix TimeValue Implementation -------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements the Unix specific portion of the TimeValue class.
-//
-//===----------------------------------------------------------------------===//
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only generic UNIX code that
-//===          is guaranteed to work on *all* UNIX variants.
-//===----------------------------------------------------------------------===//
-
-#include "Unix.h"
-
-namespace llvm {
-  using namespace sys;
-
-std::string TimeValue::str() const {
-  time_t OurTime = time_t(this->toEpochTime());
-  struct tm Storage;
-  struct tm *LT = ::localtime_r(&OurTime, &Storage);
-  assert(LT);
-  char Buffer1[sizeof("YYYY-MM-DD HH:MM:SS")];
-  strftime(Buffer1, sizeof(Buffer1), "%Y-%m-%d %H:%M:%S", LT);
-  char Buffer2[sizeof("YYYY-MM-DD HH:MM:SS.MMMUUUNNN")];
-  snprintf(Buffer2, sizeof(Buffer2), "%s.%.9u", Buffer1, this->nanoseconds());
-  return std::string(Buffer2);
-}
-
-TimeValue TimeValue::now() {
-  struct timeval the_time;
-  timerclear(&the_time);
-  if (0 != ::gettimeofday(&the_time,nullptr)) {
-    // This is *really* unlikely to occur because the only gettimeofday
-    // errors concern the timezone parameter which we're passing in as 0.
-    // In the unlikely case it does happen, just return MinTime, no error
-    // message needed.
-    return MinTime();
-  }
-
-  return TimeValue(
-    static_cast<TimeValue::SecondsType>( the_time.tv_sec +
-      PosixZeroTimeSeconds ),
-    static_cast<TimeValue::NanoSecondsType>( the_time.tv_usec *
-      NANOSECONDS_PER_MICROSECOND ) );
-}
-
-}

llvm/trunk/lib/Support/Windows/TimeValue.inc

-//===- Win32/TimeValue.cpp - Win32 TimeValue Implementation -----*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides the Win32 implementation of the TimeValue class.
-//
-//===----------------------------------------------------------------------===//
-
-#include "WindowsSupport.h"
-#include "llvm/Support/Format.h"
-#include "llvm/Support/raw_ostream.h"
-#include <cctype>
-#include <time.h>
-
-using namespace llvm;
-using namespace llvm::sys;
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only Win32 specific code.
-//===----------------------------------------------------------------------===//
-
-TimeValue TimeValue::now() {
-  uint64_t ft;
-  GetSystemTimeAsFileTime(reinterpret_cast<FILETIME *>(&ft));
-
-  TimeValue t(0, 0);
-  t.fromWin32Time(ft);
-  return t;
-}
-
-std::string TimeValue::str() const {
-  std::string S;
-  struct tm *LT;
-#ifdef __MINGW32__
-  // Old versions of mingw don't have _localtime64_s. Remove this once we drop support
-  // for them.
-  time_t OurTime = time_t(this->toEpochTime());
-  LT = ::localtime(&OurTime);
-  assert(LT);
-#else
-  struct tm Storage;
-  __time64_t OurTime = this->toEpochTime();
-  int Error = ::_localtime64_s(&Storage, &OurTime);
-  assert(!Error);
-  (void)Error;
-  LT = &Storage;
-#endif
-
-  char Buffer[sizeof("YYYY-MM-DD HH:MM:SS")];
-  strftime(Buffer, sizeof(Buffer), "%Y-%m-%d %H:%M:%S", LT);
-  raw_string_ostream OS(S);
-  OS << format("%s.%.9u", static_cast<const char *>(Buffer),
-               this->nanoseconds());
-  OS.flush();
-  return S;
-}

llvm/trunk/unittests/Support/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_llvm_unittest(SupportTests
   AlignOfTest.cpp
   AllocatorTest.cpp
   ArrayRecyclerTest.cpp
   BlockFrequencyTest.cpp
   BranchProbabilityTest.cpp
   Casting.cpp
+  Chrono.cpp
   CommandLineTest.cpp
   CompressionTest.cpp
   ConvertUTFTest.cpp
   DataExtractorTest.cpp
   DwarfTest.cpp
   EndianStreamTest.cpp
   EndianTest.cpp
   ErrorTest.cpp

llvm/trunk/unittests/Support/Chrono.cpp

+//===- llvm/unittest/Support/Chrono.cpp - Time utilities tests ------------===//
+//
+//           The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/Chrono.h"
+#include "llvm/ADT/SmallVector.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::sys;
+using namespace std::chrono;
+
+namespace {
+
+TEST(Chrono, TimeTConversion) {
+  EXPECT_EQ(time_t(0), toTimeT(toTimePoint(time_t(0))));
+  EXPECT_EQ(time_t(1), toTimeT(toTimePoint(time_t(1))));
+  EXPECT_EQ(time_t(47), toTimeT(toTimePoint(time_t(47))));
+
+  TimePoint<> TP;
+  EXPECT_EQ(TP, toTimePoint(toTimeT(TP)));
+  TP += seconds(1);
+  EXPECT_EQ(TP, toTimePoint(toTimeT(TP)));
+  TP += hours(47);
+  EXPECT_EQ(TP, toTimePoint(toTimeT(TP)));
+}
+
+TEST(Chrono, StringConversion) {
+  std::string S;
+  raw_string_ostream OS(S);
+  OS << system_clock::now();
+
+  // Do a basic sanity check on the output.
+  // The format we expect is YYYY-MM-DD HH:MM:SS.MMMUUUNNN
+  StringRef Date, Time;
+  std::tie(Date, Time) = StringRef(OS.str()).split(' ');
+
+  SmallVector<StringRef, 3> Components;
+  Date.split(Components, '-');
+  ASSERT_EQ(3u, Components.size());
+  EXPECT_EQ(4u, Components[0].size());
+  EXPECT_EQ(2u, Components[1].size());
+  EXPECT_EQ(2u, Components[2].size());
+
+  StringRef Sec, Nano;
+  std::tie(Sec, Nano) = Time.split('.');
+
+  Components.clear();
+  Sec.split(Components, ':');
+  ASSERT_EQ(3u, Components.size());
+  EXPECT_EQ(2u, Components[0].size());
+  EXPECT_EQ(2u, Components[1].size());
+  EXPECT_EQ(2u, Components[2].size());
+  EXPECT_EQ(9u, Nano.size());
+}
+
+// Test that toTimePoint and toTimeT can be called with a arguments with varying
+// precisions.
+TEST(Chrono, ImplicitConversions) {
+  std::time_t TimeT = 47;
+  TimePoint<seconds> Sec = toTimePoint(TimeT);
+  TimePoint<milliseconds> Milli = toTimePoint(TimeT);
+  TimePoint<microseconds> Micro = toTimePoint(TimeT);
+  TimePoint<nanoseconds> Nano = toTimePoint(TimeT);
+  EXPECT_EQ(Sec, Milli);
+  EXPECT_EQ(Sec, Micro);
+  EXPECT_EQ(Sec, Nano);
+  EXPECT_EQ(TimeT, toTimeT(Sec));
+  EXPECT_EQ(TimeT, toTimeT(Milli));
+  EXPECT_EQ(TimeT, toTimeT(Micro));
+  EXPECT_EQ(TimeT, toTimeT(Nano));
+}
+
+} // anonymous namespace

llvm/trunk/unittests/Support/TimeValueTest.cpp

TEST(TimeValue, Win32FILETIME) {
   // The "seconds" part in Posix time may be expected as zero.
   EXPECT_EQ(0u, epoch.toEpochTime());
   EXPECT_EQ(ns, static_cast<uint32_t>(epoch.nanoseconds()));
 
   // Confirm it reversible.
   EXPECT_EQ(ft1970, epoch.toWin32Time());
 }
 
+TEST(TimeValue, Chrono) {
+  sys::TimeValue TV;
+  TV.fromEpochTime(0);
+  sys::TimePoint<> TP = TV;
+  EXPECT_EQ(0u, sys::toTimeT(TP));
+
+  TP += std::chrono::seconds(47);
+  TV = TP;
+  EXPECT_EQ(47u, TV.toEpochTime());
+}
 }