[llvm-branch-commits] [libcxx] [libc++][chrono] implements UTC clock. (PR #90393)
@@ -0,0 +1,1004 @@
+//===--===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM
Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===--===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// TODO FMT This test should not require std::to_chars(floating-point)
+// XFAIL: availability-fp_to_chars-missing
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+//
+
+// template
+// struct formatter, charT>;
+
+#include
+#include
+
+#include
+#include
+#include
+#include
+#include
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "test_macros.h"
+
+template
+static void test_no_chrono_specs() {
+ using namespace std::literals::chrono_literals;
+
+ std::locale::global(std::locale(LOCALE_fr_FR_UTF_8));
+
+ // Non localized output
+
+ // [time.syn]
+ // using nanoseconds = duration;
+ // using microseconds = duration;
+ // using milliseconds = duration;
+ // using seconds = duration;
+ // using minutes = duration>;
+ // using hours= duration>;
+ check(SV("1425-08-04 22:06:56"), SV("{}"),
std::chrono::utc_seconds(-17'179'869'184s)); // Minimum value for 35 bits.
+ check(SV("1901-12-13 20:45:52"), SV("{}"),
std::chrono::utc_seconds(-2'147'483'648s));
+
+ check(SV("1969-12-31 00:00:00"), SV("{}"), std::chrono::utc_seconds(-24h));
+ check(SV("1969-12-31 06:00:00"), SV("{}"), std::chrono::utc_seconds(-18h));
+ check(SV("1969-12-31 12:00:00"), SV("{}"), std::chrono::utc_seconds(-12h));
+ check(SV("1969-12-31 18:00:00"), SV("{}"), std::chrono::utc_seconds(-6h));
+ check(SV("1969-12-31 23:59:59"), SV("{}"), std::chrono::utc_seconds(-1s));
+
+ check(SV("1970-01-01 00:00:00"), SV("{}"), std::chrono::utc_seconds(0s));
+ check(SV("2000-01-01 00:00:00"), SV("{}"),
std::chrono::utc_seconds(946'684'800s + 22s));
+ check(SV("2000-01-01 01:02:03"), SV("{}"),
std::chrono::utc_seconds(946'688'523s + 22s));
+
+ check(SV("2038-01-19 03:14:07"), SV("{}"),
std::chrono::utc_seconds(2'147'483'647s + 27s));
+ check(SV("2514-05-30 01:53:03"),
+SV("{}"),
+std::chrono::utc_seconds(17'179'869'183s + 27s)); // Maximum value for
35 bits.
+
+ check(SV("2000-01-01 01:02:03.123"),
+SV("{}"),
+std::chrono::utc_time(946'688'523'123ms +
22s));
+
+ std::locale::global(std::locale::classic());
+}
+
+template
+static void test_valid_values_year() {
+ using namespace std::literals::chrono_literals;
+
+ constexpr std::basic_string_view fmt =
+
SV("{:%%C='%C'%t%%EC='%EC'%t%%y='%y'%t%%Oy='%Oy'%t%%Ey='%Ey'%t%%Y='%Y'%t%%EY='%EY'%n}");
+ constexpr std::basic_string_view lfmt =
+
SV("{:L%%C='%C'%t%%EC='%EC'%t%%y='%y'%t%%Oy='%Oy'%t%%Ey='%Ey'%t%%Y='%Y'%t%%EY='%EY'%n}");
+
+ const std::locale loc(LOCALE_ja_JP_UTF_8);
+ std::locale::global(std::locale(LOCALE_fr_FR_UTF_8));
+
+ // Non localized output using C-locale
+
check(SV("%C='19'\t%EC='19'\t%y='70'\t%Oy='70'\t%Ey='70'\t%Y='1970'\t%EY='1970'\n"),
+fmt,
+std::chrono::utc_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+
check(SV("%C='20'\t%EC='20'\t%y='09'\t%Oy='09'\t%Ey='09'\t%Y='2009'\t%EY='2009'\n"),
+fmt,
+std::chrono::utc_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday,
13 February 2009
+
+ // Use the global locale (fr_FR)
+
check(SV("%C='19'\t%EC='19'\t%y='70'\t%Oy='70'\t%Ey='70'\t%Y='1970'\t%EY='1970'\n"),
+lfmt,
+std::chrono::utc_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+
check(SV("%C='20'\t%EC='20'\t%y='09'\t%Oy='09'\t%Ey='09'\t%Y='2009'\t%EY='2009'\n"),
+lfmt,
+std::chrono::utc_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday,
13 February 2009
+
+ // Use supplied locale (ja_JP). This locale has a different alternate.
+#if defined(_WIN32) || defined(__APPLE__) || defined(_AIX) ||
defined(__FreeBSD__)
+ check(loc,
+
SV("%C='19'\t%EC='19'\t%y='70'\t%Oy='70'\t%Ey='70'\t%Y='1970'\t%EY='1970'\n"),
+lfmt,
+std::chrono::utc_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+ check(loc,
+
SV("%C='20'\t%EC='20'\t%y='09'\t%Oy='09'\t%Ey='09'\t%Y='2009'\t%EY='2009'\n"),
+lfmt,
+std::chrono::utc_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday,
13 February 2009
+#else // defined(_WIN32) || defined(__APPLE__) ||
defined(_AIX)||defined(__FreeBSD__)
+ check(loc,
+
SV("%C='19'\t%EC='昭和'\t%y='70'\t%Oy='七十'\t%Ey='45'\t%Y='1970'\t%EY='昭和45年'\n"),
+lfmt,
+
[llvm-branch-commits] [libcxx] [libc++][chrono] implements UTC clock. (PR #90393)
@@ -0,0 +1,124 @@
+//===--===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM
Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===--===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+//
+//
+// class utc_clock;
+
+// template
+// leap_second_info get_leap_second_info(const utc_time& ut);
+
+#include
+#include
+#include
+#include
+#include
+
+#include "test_macros.h"
+#include "assert_macros.h"
+#include "concat_macros.h"
+#include "filesystem_test_helper.h"
+#include "test_tzdb.h"
+
+scoped_test_env env;
+[[maybe_unused]] const std::filesystem::path dir = env.create_dir("zoneinfo");
+const std::filesystem::path tzdata =
env.create_file("zoneinfo/tzdata.zi");
+const std::filesystem::path leap_seconds =
env.create_file("zoneinfo/leap-seconds.list");
+
+std::string_view std::chrono::__libcpp_tzdb_directory() {
+ static std::string result = dir.string();
+ return result;
+}
+
+static void write(std::string_view input) {
+ static int version = 0;
+
+ std::ofstream f{tzdata};
+ f << "# version " << version++ << '\n';
+ std::ofstream{leap_seconds}.write(input.data(), input.size());
+}
+
+template
+static void test_leap_second_info(
+std::chrono::time_point time, bool
is_leap_second, std::chrono::seconds elapsed) {
+ std::chrono::leap_second_info result =
std::chrono::get_leap_second_info(time);
+ TEST_REQUIRE(
+ result.is_leap_second == is_leap_second && result.elapsed == elapsed,
+ TEST_WRITE_CONCATENATED(
+ "\nExpected output [",
+ is_leap_second,
+ ", ",
+ elapsed,
+ "]\nActual output [",
+ result.is_leap_second,
+ ", ",
+ result.elapsed,
+ "]\n"));
+}
+
+// Note at the time of writing all leap seconds are positive. This test uses
+// fake data to test the behaviour of negative leap seconds.
+int main(int, const char**) {
+ using namespace std::literals::chrono_literals;
+
+ // Use small values for simplicity. The dates are seconds since 1.1.1900.
+ write(
+ R"(
+1 10
+60 11
+120 12
+180 11
+240 12
+300 13
+360 12
+)");
+
+ // Transitions from the start of UTC.
+ auto test_transition = [](std::chrono::utc_seconds time,
std::chrono::seconds elapsed, bool positive) {
+if (positive) {
+ // Every transition has the following tests
+ // - 1ns before the start of the transition is_leap_second -> false,
elapsed -> elapsed
+ // - at the start of the transition is_leap_second -> true,
elapsed -> elapsed + 1
+ // - 1ns after the start of the transition is_leap_second -> true,
elapsed -> elapsed + 1
+ // - 1ns before the end of the transition is_leap_second -> true,
elapsed -> elapsed + 1
+ // - at the end of the transition is_leap_second -> false,
elapsed -> elapsed + 1
+
+ test_leap_second_info(time - 1ns, false, elapsed);
+ test_leap_second_info(time, true, elapsed + 1s);
+ test_leap_second_info(time + 1ns, true, elapsed + 1s);
+ test_leap_second_info(time + 1s - 1ns, true, elapsed + 1s);
+ test_leap_second_info(time + 1s, false, elapsed + 1s);
+} else {
+ // Every transition has the following tests
+ // - 1ns before the transition is_leap_second -> false, elapsed ->
elapsed
+ // - at the transition is_leap_second -> false elapsed ->
elapsed - 1
+ // - 1ns after the transition is_leap_second -> false, elapsed ->
elapsed - 1
+ test_leap_second_info(time - 1ns, false, elapsed);
+ test_leap_second_info(time, false, elapsed - 1s);
+ test_leap_second_info(time + 1ns, false, elapsed - 1s);
+}
+ };
+
+ std::chrono::utc_seconds epoch{std::chrono::sys_days{std::chrono::January /
1 / 1900}.time_since_epoch()};
+ test_leap_second_info(epoch, false, 0s);
+
+ // The UTC times are:
+ // epoch + transition time in the database + leap seconds before the
transition.
+ test_transition(epoch + 60s + 0s, 0s, true);
+ test_transition(epoch + 120s + 1s, 1s, true);
+ test_transition(epoch + 180s + 2s, 2s, false);
MattStephanson wrote:
Paul Eggert, currently one of the official TZ Coordinators, has [this
message](https://mm.icann.org/pipermail/tz/2021-September/030385.html) on the
tz mailing list concerning negative leap seconds. It contains a sample
leap-seconds.list file. You can see that the NTP timestamps all end in "00",
suggesting they refer to 00:00:00, and indeed they are all multiples of 86,400.
https://github.com/llvm/llvm-project/pull/90393
___
[llvm-branch-commits] [libcxx] [libc++][chrono] implements UTC clock. (PR #90393)
https://github.com/mordante edited https://github.com/llvm/llvm-project/pull/90393 ___ llvm-branch-commits mailing list llvm-branch-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
[llvm-branch-commits] [libcxx] [libc++][chrono] implements UTC clock. (PR #90393)
https://github.com/mordante commented: Thanks for your review comments. https://github.com/llvm/llvm-project/pull/90393 ___ llvm-branch-commits mailing list llvm-branch-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
[llvm-branch-commits] [libcxx] [libc++][chrono] implements UTC clock. (PR #90393)
@@ -0,0 +1,124 @@
+//===--===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM
Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===--===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+//
+//
+// class utc_clock;
+
+// template
+// leap_second_info get_leap_second_info(const utc_time& ut);
+
+#include
+#include
+#include
+#include
+#include
+
+#include "test_macros.h"
+#include "assert_macros.h"
+#include "concat_macros.h"
+#include "filesystem_test_helper.h"
+#include "test_tzdb.h"
+
+scoped_test_env env;
+[[maybe_unused]] const std::filesystem::path dir = env.create_dir("zoneinfo");
+const std::filesystem::path tzdata =
env.create_file("zoneinfo/tzdata.zi");
+const std::filesystem::path leap_seconds =
env.create_file("zoneinfo/leap-seconds.list");
+
+std::string_view std::chrono::__libcpp_tzdb_directory() {
+ static std::string result = dir.string();
+ return result;
+}
+
+static void write(std::string_view input) {
+ static int version = 0;
+
+ std::ofstream f{tzdata};
+ f << "# version " << version++ << '\n';
+ std::ofstream{leap_seconds}.write(input.data(), input.size());
+}
+
+template
+static void test_leap_second_info(
+std::chrono::time_point time, bool
is_leap_second, std::chrono::seconds elapsed) {
+ std::chrono::leap_second_info result =
std::chrono::get_leap_second_info(time);
+ TEST_REQUIRE(
+ result.is_leap_second == is_leap_second && result.elapsed == elapsed,
+ TEST_WRITE_CONCATENATED(
+ "\nExpected output [",
+ is_leap_second,
+ ", ",
+ elapsed,
+ "]\nActual output [",
+ result.is_leap_second,
+ ", ",
+ result.elapsed,
+ "]\n"));
+}
+
+// Note at the time of writing all leap seconds are positive. This test uses
+// fake data to test the behaviour of negative leap seconds.
+int main(int, const char**) {
+ using namespace std::literals::chrono_literals;
+
+ // Use small values for simplicity. The dates are seconds since 1.1.1900.
+ write(
+ R"(
+1 10
+60 11
+120 12
+180 11
+240 12
+300 13
+360 12
+)");
+
+ // Transitions from the start of UTC.
+ auto test_transition = [](std::chrono::utc_seconds time,
std::chrono::seconds elapsed, bool positive) {
+if (positive) {
+ // Every transition has the following tests
+ // - 1ns before the start of the transition is_leap_second -> false,
elapsed -> elapsed
+ // - at the start of the transition is_leap_second -> true,
elapsed -> elapsed + 1
+ // - 1ns after the start of the transition is_leap_second -> true,
elapsed -> elapsed + 1
+ // - 1ns before the end of the transition is_leap_second -> true,
elapsed -> elapsed + 1
+ // - at the end of the transition is_leap_second -> false,
elapsed -> elapsed + 1
+
+ test_leap_second_info(time - 1ns, false, elapsed);
+ test_leap_second_info(time, true, elapsed + 1s);
+ test_leap_second_info(time + 1ns, true, elapsed + 1s);
+ test_leap_second_info(time + 1s - 1ns, true, elapsed + 1s);
+ test_leap_second_info(time + 1s, false, elapsed + 1s);
+} else {
+ // Every transition has the following tests
+ // - 1ns before the transition is_leap_second -> false, elapsed ->
elapsed
+ // - at the transition is_leap_second -> false elapsed ->
elapsed - 1
+ // - 1ns after the transition is_leap_second -> false, elapsed ->
elapsed - 1
+ test_leap_second_info(time - 1ns, false, elapsed);
+ test_leap_second_info(time, false, elapsed - 1s);
+ test_leap_second_info(time + 1ns, false, elapsed - 1s);
+}
+ };
+
+ std::chrono::utc_seconds epoch{std::chrono::sys_days{std::chrono::January /
1 / 1900}.time_since_epoch()};
+ test_leap_second_info(epoch, false, 0s);
+
+ // The UTC times are:
+ // epoch + transition time in the database + leap seconds before the
transition.
+ test_transition(epoch + 60s + 0s, 0s, true);
+ test_transition(epoch + 120s + 1s, 1s, true);
+ test_transition(epoch + 180s + 2s, 2s, false);
mordante wrote:
Not having negative leap seconds indeed makes it hard to determine their proper
behaviour. The Standard also is quite silent on them; I can imagine why. I'll
consider your point and maybe search for other references.
https://github.com/llvm/llvm-project/pull/90393
___
llvm-branch-commits mailing list
llvm-branch-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
[llvm-branch-commits] [libcxx] [libc++][chrono] implements UTC clock. (PR #90393)
@@ -0,0 +1,155 @@
+// -*- C++ -*-
+//===--===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM
Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===--===//
+
+#ifndef _LIBCPP___CHRONO_UTC_CLOCK_H
+#define _LIBCPP___CHRONO_UTC_CLOCK_H
+
+#include
+// Enable the contents of the header only when libc++ was built with
experimental features enabled.
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_TZDB)
+
+# include <__chrono/duration.h>
+# include <__chrono/system_clock.h>
+# include <__chrono/time_point.h>
+# include <__chrono/tzdb.h>
+# include <__chrono/tzdb_list.h>
+# include <__config>
+# include <__type_traits/common_type.h>
+
+# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+# endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+# if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) &&
!defined(_LIBCPP_HAS_NO_FILESYSTEM) && \
+ !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+namespace chrono {
+
+class utc_clock;
+
+template
+using utc_time= time_point;
+using utc_seconds = utc_time;
+
+class utc_clock {
+public:
+ using rep = system_clock::rep;
+ using period= system_clock::period;
+ using duration = chrono::duration;
+ using time_point= chrono::time_point;
+ static constexpr bool is_steady = false; // The system_clock is not steady.
+
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static time_point now() { return
from_sys(system_clock::now()); }
+
+ template
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static sys_time>
+ to_sys(const utc_time<_Duration>& __time);
+
+ template
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static utc_time>
+ from_sys(const sys_time<_Duration>& __time) {
+using _Rp = utc_time>;
+// TODO TZDB investigate optimizations.
+//
+// The leap second database stores all transitions, this mean to calculate
+// the current number of leap seconds the code needs to iterate over all
+// leap seconds to accumulate the sum. Then the sum can be used to
determine
+// the sys_time. Accessing the database involves acquiring a mutex.
+//
+// The historic entries in the database are immutable. Hard-coding these
+// values in a table would allow:
+// - To store the sum, allowing a binary search on the data.
+// - Avoid acquiring a mutex.
+// The disadvantage are:
+// - A slightly larger code size.
+//
+// There are two optimization directions
+// - hard-code the database and do a linear search for future entries. This
+// search can start at the back, and should probably contain very few
+// entries. (Adding leap seconds is quite rare and new release of libc++
+// can add the new entries; they are announced half a year before they
are
+// added.)
+// - During parsing the leap seconds store an additional database in the
+// dylib with the list of the sum of the leap seconds. In that case there
+// can be a private function __get_utc_to_sys_table that returns the
+// table.
+//
+// Note for to_sys there are no optimizations to be done; it uses
+// get_leap_second_info. The function get_leap_second_info could benefit
+// from optimizations as described above; again both options apply.
+
+// Both UTC and the system clock use the same epoch. The Standard
+// specifies from 1970-01-01 even when UTC starts at
+// 1972-01-01 00:00:10 TAI. So when the sys_time is before epoch we can be
+// sure there both clocks return the same value.
+
+const tzdb& __tzdb = chrono::get_tzdb();
+_Rp __result{__time.time_since_epoch()};
+for (const auto& __leap_second : __tzdb.leap_seconds) {
+ if (__time < __leap_second)
+return __result;
+
+ __result += __leap_second.value();
+}
+return __result;
+ }
+};
+
+struct leap_second_info {
+ bool is_leap_second;
+ seconds elapsed;
+};
+
+template
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI leap_second_info
get_leap_second_info(const utc_time<_Duration>& __time) {
+ const tzdb& __tzdb = chrono::get_tzdb();
+ if (__tzdb.leap_seconds.empty())
+return {false, chrono::seconds{0}};
+
+ sys_seconds __sys{chrono::floor(__time).time_since_epoch()};
+ seconds __elapsed{0};
+ for (const auto& __leap_second : __tzdb.leap_seconds) {
+if (__sys == __leap_second.date() + __elapsed)
+ return {__leap_second.value() > 0s, // only positive leap seconds are
considered leap seconds
+ __elapsed + __leap_second.value()};
+
+if (__sys < __leap_second.date() + __elapsed)
+ return {false, __elapsed};
+
+__elapsed += __leap_second.value();
+ }
+
+ return {false, __elapsed};
+}
+
+template
[llvm-branch-commits] [libcxx] [libc++][chrono] implements UTC clock. (PR #90393)
@@ -0,0 +1,155 @@
+// -*- C++ -*-
+//===--===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM
Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===--===//
+
+#ifndef _LIBCPP___CHRONO_UTC_CLOCK_H
+#define _LIBCPP___CHRONO_UTC_CLOCK_H
+
+#include
+// Enable the contents of the header only when libc++ was built with
experimental features enabled.
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_TZDB)
+
+# include <__chrono/duration.h>
+# include <__chrono/system_clock.h>
+# include <__chrono/time_point.h>
+# include <__chrono/tzdb.h>
+# include <__chrono/tzdb_list.h>
+# include <__config>
+# include <__type_traits/common_type.h>
+
+# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+# endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+# if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) &&
!defined(_LIBCPP_HAS_NO_FILESYSTEM) && \
+ !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+namespace chrono {
+
+class utc_clock;
+
+template
+using utc_time= time_point;
+using utc_seconds = utc_time;
+
+class utc_clock {
+public:
+ using rep = system_clock::rep;
+ using period= system_clock::period;
+ using duration = chrono::duration;
+ using time_point= chrono::time_point;
+ static constexpr bool is_steady = false; // The system_clock is not steady.
+
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static time_point now() { return
from_sys(system_clock::now()); }
+
+ template
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static sys_time>
+ to_sys(const utc_time<_Duration>& __time);
+
+ template
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static utc_time>
+ from_sys(const sys_time<_Duration>& __time) {
+using _Rp = utc_time>;
+// TODO TZDB investigate optimizations.
+//
+// The leap second database stores all transitions, this mean to calculate
+// the current number of leap seconds the code needs to iterate over all
+// leap seconds to accumulate the sum. Then the sum can be used to
determine
+// the sys_time. Accessing the database involves acquiring a mutex.
+//
+// The historic entries in the database are immutable. Hard-coding these
+// values in a table would allow:
+// - To store the sum, allowing a binary search on the data.
+// - Avoid acquiring a mutex.
+// The disadvantage are:
+// - A slightly larger code size.
+//
+// There are two optimization directions
+// - hard-code the database and do a linear search for future entries. This
+// search can start at the back, and should probably contain very few
+// entries. (Adding leap seconds is quite rare and new release of libc++
+// can add the new entries; they are announced half a year before they
are
+// added.)
+// - During parsing the leap seconds store an additional database in the
+// dylib with the list of the sum of the leap seconds. In that case there
+// can be a private function __get_utc_to_sys_table that returns the
+// table.
+//
+// Note for to_sys there are no optimizations to be done; it uses
+// get_leap_second_info. The function get_leap_second_info could benefit
+// from optimizations as described above; again both options apply.
+
+// Both UTC and the system clock use the same epoch. The Standard
+// specifies from 1970-01-01 even when UTC starts at
+// 1972-01-01 00:00:10 TAI. So when the sys_time is before epoch we can be
+// sure there both clocks return the same value.
+
+const tzdb& __tzdb = chrono::get_tzdb();
+_Rp __result{__time.time_since_epoch()};
+for (const auto& __leap_second : __tzdb.leap_seconds) {
+ if (__time < __leap_second)
+return __result;
+
+ __result += __leap_second.value();
+}
+return __result;
+ }
+};
+
+struct leap_second_info {
+ bool is_leap_second;
+ seconds elapsed;
+};
+
+template
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI leap_second_info
get_leap_second_info(const utc_time<_Duration>& __time) {
+ const tzdb& __tzdb = chrono::get_tzdb();
+ if (__tzdb.leap_seconds.empty())
+return {false, chrono::seconds{0}};
+
+ sys_seconds __sys{chrono::floor(__time).time_since_epoch()};
+ seconds __elapsed{0};
+ for (const auto& __leap_second : __tzdb.leap_seconds) {
+if (__sys == __leap_second.date() + __elapsed)
+ return {__leap_second.value() > 0s, // only positive leap seconds are
considered leap seconds
+ __elapsed + __leap_second.value()};
+
+if (__sys < __leap_second.date() + __elapsed)
+ return {false, __elapsed};
+
+__elapsed += __leap_second.value();
+ }
+
+ return {false, __elapsed};
+}
+
+template
[llvm-branch-commits] [libcxx] [libc++][chrono] implements UTC clock. (PR #90393)
@@ -0,0 +1,124 @@
+//===--===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM
Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===--===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+//
+//
+// class utc_clock;
+
+// template
+// leap_second_info get_leap_second_info(const utc_time& ut);
+
+#include
+#include
+#include
+#include
+#include
+
+#include "test_macros.h"
+#include "assert_macros.h"
+#include "concat_macros.h"
+#include "filesystem_test_helper.h"
+#include "test_tzdb.h"
+
+scoped_test_env env;
+[[maybe_unused]] const std::filesystem::path dir = env.create_dir("zoneinfo");
+const std::filesystem::path tzdata =
env.create_file("zoneinfo/tzdata.zi");
+const std::filesystem::path leap_seconds =
env.create_file("zoneinfo/leap-seconds.list");
+
+std::string_view std::chrono::__libcpp_tzdb_directory() {
+ static std::string result = dir.string();
+ return result;
+}
+
+static void write(std::string_view input) {
+ static int version = 0;
+
+ std::ofstream f{tzdata};
+ f << "# version " << version++ << '\n';
+ std::ofstream{leap_seconds}.write(input.data(), input.size());
+}
+
+template
+static void test_leap_second_info(
+std::chrono::time_point time, bool
is_leap_second, std::chrono::seconds elapsed) {
+ std::chrono::leap_second_info result =
std::chrono::get_leap_second_info(time);
+ TEST_REQUIRE(
+ result.is_leap_second == is_leap_second && result.elapsed == elapsed,
+ TEST_WRITE_CONCATENATED(
+ "\nExpected output [",
+ is_leap_second,
+ ", ",
+ elapsed,
+ "]\nActual output [",
+ result.is_leap_second,
+ ", ",
+ result.elapsed,
+ "]\n"));
+}
+
+// Note at the time of writing all leap seconds are positive. This test uses
+// fake data to test the behaviour of negative leap seconds.
+int main(int, const char**) {
+ using namespace std::literals::chrono_literals;
+
+ // Use small values for simplicity. The dates are seconds since 1.1.1900.
+ write(
+ R"(
+1 10
+60 11
+120 12
+180 11
+240 12
+300 13
+360 12
+)");
+
+ // Transitions from the start of UTC.
+ auto test_transition = [](std::chrono::utc_seconds time,
std::chrono::seconds elapsed, bool positive) {
+if (positive) {
+ // Every transition has the following tests
+ // - 1ns before the start of the transition is_leap_second -> false,
elapsed -> elapsed
+ // - at the start of the transition is_leap_second -> true,
elapsed -> elapsed + 1
+ // - 1ns after the start of the transition is_leap_second -> true,
elapsed -> elapsed + 1
+ // - 1ns before the end of the transition is_leap_second -> true,
elapsed -> elapsed + 1
+ // - at the end of the transition is_leap_second -> false,
elapsed -> elapsed + 1
+
+ test_leap_second_info(time - 1ns, false, elapsed);
+ test_leap_second_info(time, true, elapsed + 1s);
+ test_leap_second_info(time + 1ns, true, elapsed + 1s);
+ test_leap_second_info(time + 1s - 1ns, true, elapsed + 1s);
+ test_leap_second_info(time + 1s, false, elapsed + 1s);
+} else {
+ // Every transition has the following tests
+ // - 1ns before the transition is_leap_second -> false, elapsed ->
elapsed
+ // - at the transition is_leap_second -> false elapsed ->
elapsed - 1
+ // - 1ns after the transition is_leap_second -> false, elapsed ->
elapsed - 1
+ test_leap_second_info(time - 1ns, false, elapsed);
+ test_leap_second_info(time, false, elapsed - 1s);
+ test_leap_second_info(time + 1ns, false, elapsed - 1s);
+}
+ };
+
+ std::chrono::utc_seconds epoch{std::chrono::sys_days{std::chrono::January /
1 / 1900}.time_since_epoch()};
+ test_leap_second_info(epoch, false, 0s);
+
+ // The UTC times are:
+ // epoch + transition time in the database + leap seconds before the
transition.
+ test_transition(epoch + 60s + 0s, 0s, true);
+ test_transition(epoch + 120s + 1s, 1s, true);
+ test_transition(epoch + 180s + 2s, 2s, false);
MattStephanson wrote:
I don't think this test is quite right. But since we don't have any historical
practice with negative leap seconds, my reasoning is based on an assumption:
the IANA db contains the earliest time after a leap second is fully inserted.
I'm basing this on the fact that positive leap seconds are inserted at 11:59:60
PM on 30 June/31 December, but the db contains 12:00:00 AM on 1 July/1 January.
For a positive leap second, the `utc_time` when insertion begins is this
`sys_time` plus
[llvm-branch-commits] [libcxx] [libc++][chrono] implements UTC clock. (PR #90393)
@@ -0,0 +1,1004 @@
+//===--===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM
Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===--===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem, no-localization, no-tzdb
+// UNSUPPORTED: GCC-ALWAYS_INLINE-FIXME
+
+// TODO FMT This test should not require std::to_chars(floating-point)
+// XFAIL: availability-fp_to_chars-missing
+
+// XFAIL: libcpp-has-no-incomplete-tzdb
+// XFAIL: availability-tzdb-missing
+
+// REQUIRES: locale.fr_FR.UTF-8
+// REQUIRES: locale.ja_JP.UTF-8
+
+//
+
+// template
+// struct formatter, charT>;
+
+#include
+#include
+
+#include
+#include
+#include
+#include
+#include
+
+#include "formatter_tests.h"
+#include "make_string.h"
+#include "platform_support.h" // locale name macros
+#include "test_macros.h"
+
+template
+static void test_no_chrono_specs() {
+ using namespace std::literals::chrono_literals;
+
+ std::locale::global(std::locale(LOCALE_fr_FR_UTF_8));
+
+ // Non localized output
+
+ // [time.syn]
+ // using nanoseconds = duration;
+ // using microseconds = duration;
+ // using milliseconds = duration;
+ // using seconds = duration;
+ // using minutes = duration>;
+ // using hours= duration>;
+ check(SV("1425-08-04 22:06:56"), SV("{}"),
std::chrono::utc_seconds(-17'179'869'184s)); // Minimum value for 35 bits.
+ check(SV("1901-12-13 20:45:52"), SV("{}"),
std::chrono::utc_seconds(-2'147'483'648s));
+
+ check(SV("1969-12-31 00:00:00"), SV("{}"), std::chrono::utc_seconds(-24h));
+ check(SV("1969-12-31 06:00:00"), SV("{}"), std::chrono::utc_seconds(-18h));
+ check(SV("1969-12-31 12:00:00"), SV("{}"), std::chrono::utc_seconds(-12h));
+ check(SV("1969-12-31 18:00:00"), SV("{}"), std::chrono::utc_seconds(-6h));
+ check(SV("1969-12-31 23:59:59"), SV("{}"), std::chrono::utc_seconds(-1s));
+
+ check(SV("1970-01-01 00:00:00"), SV("{}"), std::chrono::utc_seconds(0s));
+ check(SV("2000-01-01 00:00:00"), SV("{}"),
std::chrono::utc_seconds(946'684'800s + 22s));
+ check(SV("2000-01-01 01:02:03"), SV("{}"),
std::chrono::utc_seconds(946'688'523s + 22s));
+
+ check(SV("2038-01-19 03:14:07"), SV("{}"),
std::chrono::utc_seconds(2'147'483'647s + 27s));
+ check(SV("2514-05-30 01:53:03"),
+SV("{}"),
+std::chrono::utc_seconds(17'179'869'183s + 27s)); // Maximum value for
35 bits.
+
+ check(SV("2000-01-01 01:02:03.123"),
+SV("{}"),
+std::chrono::utc_time(946'688'523'123ms +
22s));
+
+ std::locale::global(std::locale::classic());
+}
+
+template
+static void test_valid_values_year() {
+ using namespace std::literals::chrono_literals;
+
+ constexpr std::basic_string_view fmt =
+
SV("{:%%C='%C'%t%%EC='%EC'%t%%y='%y'%t%%Oy='%Oy'%t%%Ey='%Ey'%t%%Y='%Y'%t%%EY='%EY'%n}");
+ constexpr std::basic_string_view lfmt =
+
SV("{:L%%C='%C'%t%%EC='%EC'%t%%y='%y'%t%%Oy='%Oy'%t%%Ey='%Ey'%t%%Y='%Y'%t%%EY='%EY'%n}");
+
+ const std::locale loc(LOCALE_ja_JP_UTF_8);
+ std::locale::global(std::locale(LOCALE_fr_FR_UTF_8));
+
+ // Non localized output using C-locale
+
check(SV("%C='19'\t%EC='19'\t%y='70'\t%Oy='70'\t%Ey='70'\t%Y='1970'\t%EY='1970'\n"),
+fmt,
+std::chrono::utc_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+
check(SV("%C='20'\t%EC='20'\t%y='09'\t%Oy='09'\t%Ey='09'\t%Y='2009'\t%EY='2009'\n"),
+fmt,
+std::chrono::utc_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday,
13 February 2009
+
+ // Use the global locale (fr_FR)
+
check(SV("%C='19'\t%EC='19'\t%y='70'\t%Oy='70'\t%Ey='70'\t%Y='1970'\t%EY='1970'\n"),
+lfmt,
+std::chrono::utc_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+
check(SV("%C='20'\t%EC='20'\t%y='09'\t%Oy='09'\t%Ey='09'\t%Y='2009'\t%EY='2009'\n"),
+lfmt,
+std::chrono::utc_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday,
13 February 2009
+
+ // Use supplied locale (ja_JP). This locale has a different alternate.
+#if defined(_WIN32) || defined(__APPLE__) || defined(_AIX) ||
defined(__FreeBSD__)
+ check(loc,
+
SV("%C='19'\t%EC='19'\t%y='70'\t%Oy='70'\t%Ey='70'\t%Y='1970'\t%EY='1970'\n"),
+lfmt,
+std::chrono::utc_seconds(0s)); // 00:00:00 UTC Thursday, 1 January 1970
+
+ check(loc,
+
SV("%C='20'\t%EC='20'\t%y='09'\t%Oy='09'\t%Ey='09'\t%Y='2009'\t%EY='2009'\n"),
+lfmt,
+std::chrono::utc_seconds(1'234'567'890s)); // 23:31:30 UTC on Friday,
13 February 2009
+#else // defined(_WIN32) || defined(__APPLE__) ||
defined(_AIX)||defined(__FreeBSD__)
+ check(loc,
+
SV("%C='19'\t%EC='昭和'\t%y='70'\t%Oy='七十'\t%Ey='45'\t%Y='1970'\t%EY='昭和45年'\n"),
+lfmt,
+
[llvm-branch-commits] [libcxx] [libc++][chrono] implements UTC clock. (PR #90393)
llvmbot wrote:
@llvm/pr-subscribers-libcxx
Author: Mark de Wever (mordante)
Changes
While implementing this feature and its associated LWG issues it turns out
- LWG3316 Correctly define epoch for utc_clock / utc_timepoint only added
non-normative wording to the standard.
Implements parts of:
- P0355 Extending chrono to Calendars and Time Zones
- P1361 Integration of chrono with text formatting
- LWG3359 chrono leap second support should allow for negative leap
seconds
---
Patch is 115.96 KiB, truncated to 20.00 KiB below, full version:
https://github.com/llvm/llvm-project/pull/90393.diff
26 Files Affected:
- (modified) libcxx/benchmarks/CMakeLists.txt (+1)
- (added) libcxx/benchmarks/utc_clock.bench.cpp (+54)
- (modified) libcxx/docs/Status/Cxx20.rst (+1-1)
- (modified) libcxx/docs/Status/Cxx20Issues.csv (+1-1)
- (modified) libcxx/docs/Status/FormatPaper.csv (+1-1)
- (modified) libcxx/include/CMakeLists.txt (+1)
- (modified) libcxx/include/__chrono/convert_to_tm.h (+18)
- (modified) libcxx/include/__chrono/formatter.h (+18)
- (modified) libcxx/include/__chrono/ostream.h (+12)
- (added) libcxx/include/__chrono/utc_clock.h (+155)
- (modified) libcxx/include/chrono (+38)
- (modified) libcxx/include/module.modulemap (+4)
- (modified) libcxx/modules/std/chrono.inc (+10-2)
- (modified) libcxx/test/libcxx/diagnostics/chrono.nodiscard.verify.cpp (+14)
- (added)
libcxx/test/libcxx/time/time.clock/time.clock.utc/get_leap_second_info.pass.cpp
(+124)
- (added)
libcxx/test/libcxx/time/time.clock/time.clock.utc/time.clock.utc.members/from_sys.pass.cpp
(+106)
- (added)
libcxx/test/libcxx/time/time.clock/time.clock.utc/time.clock.utc.members/to_sys.pass.cpp
(+115)
- (added)
libcxx/test/std/time/time.clock/time.clock.utc/get_leap_second_info.pass.cpp
(+126)
- (added)
libcxx/test/std/time/time.clock/time.clock.utc/leap_second_info.members.pass.cpp
(+37)
- (added)
libcxx/test/std/time/time.clock/time.clock.utc/time.clock.utc.members/from_sys.pass.cpp
(+213)
- (added)
libcxx/test/std/time/time.clock/time.clock.utc/time.clock.utc.members/now.pass.cpp
(+30)
- (added)
libcxx/test/std/time/time.clock/time.clock.utc/time.clock.utc.members/to_sys.pass.cpp
(+147)
- (added) libcxx/test/std/time/time.clock/time.clock.utc/types.compile.pass.cpp
(+59)
- (added)
libcxx/test/std/time/time.clock/time.clock.utc/utc_time.ostream.pass.cpp (+165)
- (added) libcxx/test/std/time/time.syn/formatter.utc_time.pass.cpp (+1004)
- (modified)
libcxx/test/std/utilities/format/format.formattable/concept.formattable.compile.pass.cpp
(+1-1)
``diff
diff --git a/libcxx/benchmarks/CMakeLists.txt b/libcxx/benchmarks/CMakeLists.txt
index 527a2acf2d3b36..ea7ef6902f7266 100644
--- a/libcxx/benchmarks/CMakeLists.txt
+++ b/libcxx/benchmarks/CMakeLists.txt
@@ -229,6 +229,7 @@ set(BENCHMARK_TESTS
system_error.bench.cpp
to_chars.bench.cpp
unordered_set_operations.bench.cpp
+utc_clock.bench.cpp
util_smartptr.bench.cpp
variant_visit_1.bench.cpp
variant_visit_2.bench.cpp
diff --git a/libcxx/benchmarks/utc_clock.bench.cpp
b/libcxx/benchmarks/utc_clock.bench.cpp
new file mode 100644
index 00..255b1dde52aa67
--- /dev/null
+++ b/libcxx/benchmarks/utc_clock.bench.cpp
@@ -0,0 +1,54 @@
+//===--===//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM
Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===--===//
+
+#include
+
+#include "benchmark/benchmark.h"
+
+// Benchmarks the performance of the UTC <-> system time conversions. These
+// operations determine the sum of leap second insertions at a specific time.
+
+static void BM_from_sys(benchmark::State& state) {
+ std::chrono::sys_days date{std::chrono::July / 1 / state.range(0)};
+ for (auto _ : state)
+benchmark::DoNotOptimize(std::chrono::utc_clock::from_sys(date));
+}
+
+BENCHMARK(BM_from_sys)
+->Arg(1970) // before the first leap seconds
+->Arg(1979) // in the first half of inserted leap seconds
+->Arg(1993) // in the second half of inserted leap seconds
+->Arg(2100); // after the last leap second
+
+BENCHMARK(BM_from_sys)->Arg(1970)->Arg(1979)->Arg(1993)->Arg(2100)->Threads(4);
+BENCHMARK(BM_from_sys)->Arg(1970)->Arg(1979)->Arg(1993)->Arg(2100)->Threads(16);
+
+static void BM_to_sys(benchmark::State& state) {
+ // 59 sec offset means we pass th UTC offset for the leap second; assuming
+ // there won't be more than 59 leap seconds ever.
+ std::chrono::utc_seconds date{
+ std::chrono::sys_days{std::chrono::July / 1 /
state.range(0)}.time_since_epoch() + std::chrono::seconds{59}};
+ for (auto _ : state)
+benchmark::DoNotOptimize(std::chrono::utc_clock::to_sys(date));
+}
+
+BENCHMARK(BM_to_sys)
+->Arg(1970) // before
