[flang] Add default implementation for SYSTEM_CLOCK

[rovka]

Summary

Add an implementation for the runtime functions related to SYSTEM_CLOCK.
As with CPU_TIME, this is based on std::clock(), which should be
available everywhere, but it is highly recommended to add
platform-specific implementations for systems where std::clock() behaves
poorly (e.g. POSIX).

The documentation for std::clock() doesn't specify a maximum value and
in fact wrap around behaviour is non-conforming. Therefore, this
implementation of SYSTEM_CLOCK is not guaranteed to wrap around either,
and after std::clock reaches its maximum value we will likely just
return failure rather than wrap around. If this happens often on your
system, please add a new platform-specific implementation.

We define COUNT_MAX as either the maximum value that can be stored in
a std::clock_t or in a 64-bit integer (whichever is smaller), and
COUNT_RATE as CLOCKS_PER_SEC. For POSIX systems, the value of
CLOCKS_PER_SEC is hardcoded to 10^6 and irrelevant for the values
returned by std::clock.

[rovka]

Fix else-after-return warning.

[klausler]

flang/runtime/time-intrinsic.cpp

80

We capitalize function names in the runtime.

89

This could be if constexpr, with the rest of the function residing in its else part.

96

This could be static constexpr and used in the expression of the previous if statement.

We prefer modern braced initialization in runtime.

[rovka]

Addressed review comments.

[jeanPerier]

LGTM

[kiranchandramohan]

Please audit all usage of std::clock_t. std::clock_t can be unsigned on some platforms. This has led to a couple of failures like the one mentioned inline and https://reviews.llvm.org/D107972.

Similar issue shows up in the pre-merge windows build.
https://buildkite.com/llvm-project/premerge-checks/builds/49678#f1b2ab40-9d77-411f-bd63-4cd425c5ab17

flang/runtime/time-intrinsic.cpp

107

In some systems like MacOS, std::clock_t is defined as unsigned long whereas count_t can be long long. This can lead to compilation errors.

flang/runtime/time-intrinsic.cpp:106:10: error: no matching function for call to 'min'
  return std::min(std::numeric_limits<std::clock_t>::max(),
         ^~~~~~~~
/Applications/Xcode_12.4.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/algorithm:2560:1: note: candidate template ignored: deduced conflicting types for parameter '_Tp' ('unsigned long' vs. 'long long')
min(const _Tp& __a, const _Tp& __b)

[rovka]

In D105969#2945245, @kiranchandramohan wrote:

Please audit all usage of std::clock_t. std::clock_t can be unsigned on some platforms. This has led to a couple of failures like the one mentioned inline and https://reviews.llvm.org/D107972.

Similar issue shows up in the pre-merge windows build.
https://buildkite.com/llvm-project/premerge-checks/builds/49678#f1b2ab40-9d77-411f-bd63-4cd425c5ab17

Thanks for reporting this, I'll look into it!

[rovka]

Replaced std::min with a constexpr if (which imo is easier to read/reason about than a std::min with casts). This should fix windows & mac.

I also fixed a typo from my previous diff where I ended up comparing the maximum of count_t with itself instead of the maximum of clock_t.

[kiranchandramohan]

Thanks @rovka for the update. Can you check why the pre-merge build on Linux failed and also address the clang-tidy warnings?

[rovka]

In D105969#2946982, @kiranchandramohan wrote:

Thanks @rovka for the update. Can you check why the pre-merge build on Linux failed and also address the clang-tidy warnings?

Sorry, had to leave before the build finished :D It was just the clang-tidy warnings.

[kiranchandramohan]

LGTM.

flang/runtime/time-intrinsic.cpp

 //===-- runtime/time-intrinsic.cpp ----------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // Implements time-related intrinsic subroutines.
 
 #include "time-intrinsic.h"
 
 #include <ctime>
 
 // CPU_TIME (Fortran 2018 16.9.57)
+// SYSTEM_CLOCK (Fortran 2018 16.9.168)
+//
 // We can use std::clock() from the <ctime> header as a fallback implementation
 // that should be available everywhere. This may not provide the best resolution
 // and is particularly troublesome on (some?) POSIX systems where CLOCKS_PER_SEC
 // is defined as 10^6 regardless of the actual precision of std::clock().
 // Therefore, we will usually prefer platform-specific alternatives when they
 // are available.
 //
 // We can use SFINAE to choose a platform-specific alternative. To do so, we
#endif
   struct timespec tspec;
   if (clock_gettime(CLOCKID, &tspec) == 0) {
     return tspec.tv_nsec * 1.0e-9 + tspec.tv_sec;
   }
 
   // Return some negative value to represent failure.
   return -1.0;
 }
+
+using count_t =
+    Fortran::runtime::CppTypeFor<Fortran::common::TypeCategory::Integer, 8>;
+
+// This is the fallback implementation, which should work everywhere. Note that
+// in general we can't recover after std::clock has reached its maximum value.
+template <typename Unused = void>
+count_t GetSystemClockCount(fallback_implementation) {
+  std::clock_t timestamp{std::clock()};
+  if (timestamp == static_cast<std::clock_t>(-1)) {
+    // Return -HUGE() to represent failure.
+    return -std::numeric_limits<count_t>::max();
+  }
+
+  // If our return type is large enough to hold any value returned by
+  // std::clock, our work is done. Otherwise, we have to wrap around.
+  static constexpr auto max{std::numeric_limits<count_t>::max()};
+  if constexpr (std::numeric_limits<std::clock_t>::max() <= max) {
+    return static_cast<count_t>(timestamp);
+  } else {
+    // Since std::clock_t could be a floating point type, we can't just use the
+    // % operator, so we have to wrap around manually.
+    return static_cast<count_t>(timestamp - max * std::floor(timestamp / max));
+  }
+}
+
+template <typename Unused = void>
+count_t GetSystemClockCountRate(fallback_implementation) {
+  return CLOCKS_PER_SEC;
+}
+
+template <typename Unused = void>
+count_t GetSystemClockCountMax(fallback_implementation) {
+  static constexpr auto max_clock_t = std::numeric_limits<std::clock_t>::max();
+  static constexpr auto max_count_t = std::numeric_limits<count_t>::max();
+  if constexpr (max_clock_t < max_count_t) {
+    return static_cast<count_t>(max_clock_t);
+  } else {
+    return max_count_t;
+  }
+}
 } // anonymous namespace
 
 namespace Fortran::runtime {
 extern "C" {
 
 double RTNAME(CpuTime)() { return GetCpuTime(0); }
+
+CppTypeFor<TypeCategory::Integer, 8> RTNAME(SystemClockCount)() {
+  return GetSystemClockCount(0);
+}
+
+CppTypeFor<TypeCategory::Integer, 8> RTNAME(SystemClockCountRate)() {
+  return GetSystemClockCountRate(0);
+}
+
+CppTypeFor<TypeCategory::Integer, 8> RTNAME(SystemClockCountMax)() {
+  return GetSystemClockCountMax(0);
+}
 } // extern "C"
 } // namespace Fortran::runtime

flang/unittests/Runtime/Time.cpp

TEST(TimeIntrinsics, CpuTime) {
   // Loop until we get a different value from CpuTime. If we don't get one
   // before we time out, then we should probably look into an implementation
   // for CpuTime with a better timer resolution.
   for (double end = start; end == start; end = RTNAME(CpuTime)()) {
     ASSERT_GE(end, 0.0);
     ASSERT_GE(end, start);
   }
 }
+
+using count_t = CppTypeFor<TypeCategory::Integer, 8>;
+
+TEST(TimeIntrinsics, SystemClock) {
+  // We can't really test that we get the "right" result for SYSTEM_CLOCK, but
+  // we can have a smoke test to see that we get something reasonable on the
+  // platforms where we expect to support it.
+
+  // The value of the count rate and max will vary by platform, but they should
+  // always be strictly positive if we have a working implementation of
+  // SYSTEM_CLOCK.
+  EXPECT_GT(RTNAME(SystemClockCountRate)(), 0);
+
+  count_t max{RTNAME(SystemClockCountMax)()};
+  EXPECT_GT(max, 0);
+
+  count_t start{RTNAME(SystemClockCount)()};
+  EXPECT_GE(start, 0);
+  EXPECT_LE(start, max);
+
+  // Loop until we get a different value from SystemClockCount. If we don't get
+  // one before we time out, then we should probably look into an implementation
+  // for SystemClokcCount with a better timer resolution on this platform.
+  for (count_t end = start; end == start; end = RTNAME(SystemClockCount)()) {
+    EXPECT_GE(end, 0);
+    EXPECT_LE(end, max);
+
+    EXPECT_GE(end, start);
+  }
+}