1 //===- Support/Chrono.cpp - Utilities for Timing Manipulation ---*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "llvm/Support/Chrono.h"
10 #include "llvm/Config/llvm-config.h"
11 #include "llvm/Support/Format.h"
12 #include "llvm/Support/raw_ostream.h"
13
14 namespace llvm {
15
16 using namespace sys;
17
18 const char llvm::detail::unit<std::ratio<3600>>::value[] = "h";
19 const char llvm::detail::unit<std::ratio<60>>::value[] = "m";
20 const char llvm::detail::unit<std::ratio<1>>::value[] = "s";
21 const char llvm::detail::unit<std::milli>::value[] = "ms";
22 const char llvm::detail::unit<std::micro>::value[] = "us";
23 const char llvm::detail::unit<std::nano>::value[] = "ns";
24
getStructTM(TimePoint<> TP)25 static inline struct tm getStructTM(TimePoint<> TP) {
26 struct tm Storage;
27 std::time_t OurTime = toTimeT(TP);
28
29 #if defined(LLVM_ON_UNIX)
30 struct tm *LT = ::localtime_r(&OurTime, &Storage);
31 assert(LT);
32 (void)LT;
33 #endif
34 #if defined(_WIN32)
35 int Error = ::localtime_s(&Storage, &OurTime);
36 assert(!Error);
37 (void)Error;
38 #endif
39
40 return Storage;
41 }
42
getStructTMUtc(UtcTime<> TP)43 static inline struct tm getStructTMUtc(UtcTime<> TP) {
44 struct tm Storage;
45 std::time_t OurTime = toTimeT(TP);
46
47 #if defined(LLVM_ON_UNIX)
48 struct tm *LT = ::gmtime_r(&OurTime, &Storage);
49 assert(LT);
50 (void)LT;
51 #endif
52 #if defined(_WIN32)
53 int Error = ::gmtime_s(&Storage, &OurTime);
54 assert(!Error);
55 (void)Error;
56 #endif
57
58 return Storage;
59 }
60
operator <<(raw_ostream & OS,TimePoint<> TP)61 raw_ostream &operator<<(raw_ostream &OS, TimePoint<> TP) {
62 struct tm LT = getStructTM(TP);
63 char Buffer[sizeof("YYYY-MM-DD HH:MM:SS")];
64 strftime(Buffer, sizeof(Buffer), "%Y-%m-%d %H:%M:%S", <);
65 return OS << Buffer << '.'
66 << format("%.9lu",
67 long((TP.time_since_epoch() % std::chrono::seconds(1))
68 .count()));
69 }
70
71 template <class T>
format(const T & Fractional,struct tm & LT,raw_ostream & OS,StringRef Style)72 static void format(const T &Fractional, struct tm <, raw_ostream &OS,
73 StringRef Style) {
74 using namespace std::chrono;
75 // Handle extensions first. strftime mangles unknown %x on some platforms.
76 if (Style.empty()) Style = "%Y-%m-%d %H:%M:%S.%N";
77 std::string Format;
78 raw_string_ostream FStream(Format);
79 for (unsigned I = 0; I < Style.size(); ++I) {
80 if (Style[I] == '%' && Style.size() > I + 1) switch (Style[I + 1]) {
81 case 'L': // Milliseconds, from Ruby.
82 FStream << llvm::format(
83 "%.3lu", (long)duration_cast<milliseconds>(Fractional).count());
84 ++I;
85 continue;
86 case 'f': // Microseconds, from Python.
87 FStream << llvm::format(
88 "%.6lu", (long)duration_cast<microseconds>(Fractional).count());
89 ++I;
90 continue;
91 case 'N': // Nanoseconds, from date(1).
92 FStream << llvm::format(
93 "%.9lu", (long)duration_cast<nanoseconds>(Fractional).count());
94 ++I;
95 continue;
96 case '%': // Consume %%, so %%f parses as (%%)f not %(%f)
97 FStream << "%%";
98 ++I;
99 continue;
100 }
101 FStream << Style[I];
102 }
103 FStream.flush();
104 char Buffer[256]; // Should be enough for anywhen.
105 size_t Len = strftime(Buffer, sizeof(Buffer), Format.c_str(), <);
106 OS << (Len ? Buffer : "BAD-DATE-FORMAT");
107 }
108
format(const UtcTime<std::chrono::seconds> & T,raw_ostream & OS,StringRef Style)109 void format_provider<UtcTime<std::chrono::seconds>>::format(
110 const UtcTime<std::chrono::seconds> &T, raw_ostream &OS, StringRef Style) {
111 using namespace std::chrono;
112 UtcTime<seconds> Truncated =
113 UtcTime<seconds>(duration_cast<seconds>(T.time_since_epoch()));
114 auto Fractional = T - Truncated;
115 struct tm LT = getStructTMUtc(Truncated);
116 llvm::format(Fractional, LT, OS, Style);
117 }
118
format(const TimePoint<> & T,raw_ostream & OS,StringRef Style)119 void format_provider<TimePoint<>>::format(const TimePoint<> &T, raw_ostream &OS,
120 StringRef Style) {
121 using namespace std::chrono;
122 TimePoint<seconds> Truncated = time_point_cast<seconds>(T);
123 auto Fractional = T - Truncated;
124 struct tm LT = getStructTM(Truncated);
125 llvm::format(Fractional, LT, OS, Style);
126 }
127
128 } // namespace llvm
129