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