[flang-rt] Runtime implementation of extended intrinsic function SECNDS()

flang-rt/lib/runtime/extensions.cpp

@@ -18,6 +18,7 @@
 #include "flang/Runtime/entry-names.h"
 #include "flang/Runtime/io-api.h"
 #include "flang/Runtime/iostat-consts.h"
+#include <atomic>
 #include <chrono>
 #include <cstdio>
 #include <cstring>
@@ -303,6 +304,67 @@ void FORTRAN_PROCEDURE_NAME(qsort)(int *array, int *len, int *isize,
 // PERROR(STRING)
 void RTNAME(Perror)(const char *str) { perror(str); }
 
+// GNU extension function SECNDS(refTime)
+float FORTRAN_PROCEDURE_NAME(secnds)(float *refTime) {
+  constexpr float FAIL_SECNDS{-1.0f}; // Failure code for this function
+  // Failure code for time functions that return std::time_t
+  constexpr std::time_t FAIL_TIME{std::time_t{-1}};
+  constexpr std::time_t TIME_UNINITIALIZED{std::time_t{0}};
+  constexpr std::time_t TIME_INITIALIZING{std::time_t{1}};
+  if (!refTime) {
+    return FAIL_SECNDS;
+  }
+  std::time_t now{std::time(nullptr)};
+  if (now == FAIL_TIME) {
+    return FAIL_SECNDS;
+  }
+  // In float result, we can only precisely store 2^24 seconds, which
+  // comes out to about 194 days. Thus, need to pick a starting point.
+  // Given the description of this function, midnight of the current
+  // day is the best starting point.
+  static std::atomic<std::time_t> startingPoint{TIME_UNINITIALIZED};
+  std::time_t expected{TIME_UNINITIALIZED};
+  std::time_t localStartingPoint{TIME_UNINITIALIZED};
+  if (startingPoint.compare_exchange_strong(expected, TIME_INITIALIZING)) {
+    // This thread is doing initialization of startingPoint
+    struct tm timeInfo;
+#ifdef _WIN32
+    if (localtime_s(&timeInfo, &now)) {
+      return FAIL_SECNDS;
+    }
+#else
+    if (!localtime_r(&now, &timeInfo)) {
+      return FAIL_SECNDS;
+    }
+#endif
+    // Back to midnight
+    timeInfo.tm_hour = 0;
+    timeInfo.tm_min = 0;
+    timeInfo.tm_sec = 0;
+    std::time_t midnight = std::mktime(&timeInfo);
+    if (midnight == FAIL_TIME) {
+      return FAIL_SECNDS;
+    }
+    localStartingPoint = midnight;
+    startingPoint.store(midnight, std::memory_order_release);
+  } else {
+    // This thread is not doing initialization of startingPoint, need to wait
+    // for initialization to complete.
+    while ((localStartingPoint = startingPoint.load(
+                std::memory_order_acquire)) <= TIME_INITIALIZING) {
+      std::this_thread::yield();
+    }
+  }
+  double diffStartingPoint{std::difftime(now, localStartingPoint)};
+  return static_cast<float>(diffStartingPoint) - *refTime;
+}
+
+float RTNAME(Secnds)(float *refTime, const char *sourceFile, int line) {
+  Terminator terminator{sourceFile, line};
+  RUNTIME_CHECK(terminator, refTime != nullptr);
+  return FORTRAN_PROCEDURE_NAME(secnds)(refTime);
+}
+
 // GNU extension function TIME()
 std::int64_t RTNAME(time)() { return time(nullptr); }
 

flang/include/flang/Runtime/command.h

@@ -67,6 +67,8 @@ std::int32_t RTNAME(Hostnm)(
 std::int32_t RTNAME(PutEnv)(
     const char *str, size_t str_length, const char *sourceFile, int line);
 
+float RTNAME(Secnds)(float *refTime, const char *sourceFile, int line);
+
 // Calls unlink()
 std::int32_t RTNAME(Unlink)(
     const char *path, size_t pathLength, const char *sourceFile, int line);

flang/include/flang/Runtime/extensions.h

@@ -90,5 +90,8 @@ void RTNAME(Perror)(const char *str);
 // MCLOCK -- returns accumulated time in ticks
 int FORTRAN_PROCEDURE_NAME(mclock)();
 
+// GNU extension subroutine SECNDS(refTime)
+float FORTRAN_PROCEDURE_NAME(secnds)(float *refTime);
+
 } // extern "C"
 #endif // FORTRAN_RUNTIME_EXTENSIONS_H_