Add the QNX clock CLOCK_SOFTTIME

Also made the result of the clock testing clearer so that one can see
the result for each clock test when compiling the header file.

Signed-off-by: Ted Lyngmo <ted@lyncon.se>

Author: TedLyngmo

README.md

@@ -15,9 +15,9 @@ make
 static constexpr clockid_t clock_id;
 
 // If this clock can use TIMER_ABSTIME in clock_nanosleep:
-static constexpr bool can_sleep_until_abstime;
+static constexpr bool can_clock_nanosleep;
 ```
-While the "steadyness" of each clock is hardcoded in the recipe file, if the clock can sleep until an absolute time is determined while generating the header file. Drop-in replacement functions for `std::this_thread::sleep_for` and `std::this_thread::sleep_until` are available in `lyn::this_thread` that sleeps until an absolute time if the clock supports it. Note that `lyn::this_thread::sleep_for` has a `Clock` template parameter that can be used to specify what clock to use for sleeping.
+While the "steadyness" of each clock is hardcoded in the recipe file, if the clock can use `clock_nanosleep` is determined while generating the header file. Drop-in replacement functions for `std::this_thread::sleep_for` and `std::this_thread::sleep_until` are available in `lyn::this_thread` that sleeps until an absolute time if the clock supports `clock_nanosleep`. Note that `lyn::this_thread::sleep_for` has a `Clock` template parameter that can be used to specify what clock to use for sleeping.
 ```c++
 template<class Clock = std::chrono::steady_clock, class Rep, class Period>
 void sleep_for(const std::chrono::duration<Rep, Period>& dur);
@@ -26,7 +26,7 @@ template<class Clock, class Duration>
 void sleep_until(const std::chrono::time_point<Clock, Duration>& tp);
 ```
 
-**Note:** The header file will only function correctly when used on the platform where it was generated. Cross-compilation is not supported. Create the file on each individual platform where you want it.
+**Note:** The header file will only function correctly when used on the platform for which it was generated. Create the file for each individual platform where you want it. If your code is supposed to work on multiple platforms, select clocks that exists on all of them. Do not copy a generated `clocxx.hpp` file generated for one platform to another platform. Time as you know it may come to an end.
 
 ### Example clocks that may be generated:
 ```c++
@@ -53,7 +53,7 @@ struct monotonic_raw_clock :
 All clocks share the same base implementation:
 ```c++
 namespace detail {
-    template<class Clock, bool IsSteady, bool CanClockUseAbsTime, clockid_t CLOCK_ID>
+    template<class Clock, bool IsSteady, bool CanClockNanoSleep, clockid_t CLOCK_ID>
     struct clock_base {
         using duration = std::chrono::nanoseconds;
         using rep = duration::rep;
@@ -62,7 +62,7 @@ namespace detail {
         static constexpr bool is_steady = IsSteady;
 
         static constexpr clockid_t clock_id = CLOCK_ID;
-        static constexpr bool can_sleep_until_abstime = CanClockUseAbsTime;
+        static constexpr bool can_clock_nanosleep = CanClockNanoSleep;
 
         static time_point now() noexcept {
             using namespace std;

base.hpp

@@ -39,16 +39,16 @@ For more information, please refer to <https://unlicense.org>
 namespace lyn {
 namespace chrono {
     template<class Clock>
-    struct can_sleep_until_abstime {
+    struct can_clock_nanosleep {
         static std::false_type test(...);
 
         template<class C>
-        static auto test(C) -> std::bool_constant<C::can_sleep_until_abstime>;
+        static auto test(C) -> std::bool_constant<C::can_clock_nanosleep>;
 
         static constexpr bool value = decltype(test(std::declval<Clock>()))::value;
     };
     template<class Clock>
-    static constexpr bool can_sleep_until_abstime_v = can_sleep_until_abstime<Clock>::value;
+    static constexpr bool can_clock_nanosleep_v = can_clock_nanosleep<Clock>::value;
 }
 
 namespace this_thread {
@@ -58,7 +58,7 @@ namespace this_thread {
     template<class Clock = std::chrono::steady_clock, class Rep, class Period>
     void sleep_for(const std::chrono::duration<Rep, Period>& dur) {
         if(dur <= dur.zero()) return;
-        if constexpr(chrono::can_sleep_until_abstime_v<Clock>) {
+        if constexpr(chrono::can_clock_nanosleep_v<Clock>) {
             sleep_until(Clock::now() + dur);
         } else {
             auto s = std::chrono::duration_cast<std::chrono::seconds>(dur);
@@ -71,7 +71,7 @@ namespace this_thread {
 
     template<class Clock, class Duration>
     void sleep_until(const std::chrono::time_point<Clock, Duration>& tp) {
-        if constexpr(chrono::can_sleep_until_abstime_v<Clock>) {
+        if constexpr(chrono::can_clock_nanosleep_v<Clock>) {
             auto dur = tp.time_since_epoch();
             auto s = std::chrono::duration_cast<std::chrono::seconds>(dur);
             auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(dur - s);
@@ -87,7 +87,7 @@ namespace this_thread {
 
 namespace chrono {
     namespace detail {
-        template<class Clock, bool IsSteady, bool CanClockUseAbsTime, clockid_t CLOCK_ID>
+        template<class Clock, bool IsSteady, bool CanClockNanoSleep, clockid_t CLOCK_ID>
         struct clock_base {
             using duration = std::chrono::nanoseconds;
             using rep = duration::rep;
@@ -96,7 +96,7 @@ namespace chrono {
             static constexpr bool is_steady = IsSteady;
 
             static constexpr clockid_t clock_id = CLOCK_ID;
-            static constexpr bool can_sleep_until_abstime = CanClockUseAbsTime;
+            static constexpr bool can_clock_nanosleep = CanClockNanoSleep;
 
             static time_point now() noexcept {
                 using namespace std;

mkclocxx.cpp

@@ -12,9 +12,11 @@
 #include <filesystem>
 #include <fstream>
 #include <iostream>
+#include <iterator>
 #include <optional>
 #include <sstream>
 #include <string>
+#include <vector>
 
 // #macro, steady(true/false), description
 struct clockdef {
@@ -40,13 +42,13 @@ enum result { UNSUPP, CLOCK_GETTIME, CLOCK_NANOSLEEP };
 std::ostream& operator<<(std::ostream& os, result r) {
     switch(r) {
     case UNSUPP:
-        os << "UNSUPP";
+        os << "UNSUPPORTED";
         break;
     case CLOCK_GETTIME:
-        os << "CLOCK_GETTIME";
+        os << "Exists - Can clock_nanosleep(): NO";
         break;
     case CLOCK_NANOSLEEP:
-        os << "CLOCK_NANOSLEEP";
+        os << "Exists - Can clock_nanosleep(): YES";
         break;
     }
     return os;
@@ -71,8 +73,8 @@ std::optional<pres> command(std::string command) {
     return pres{::pclose(pip), std::move(buf)};
 }
 
-result test(const clockdef& cd) {
-    std::cout << "Clock under test: " << cd.macro << '\n';
+result test(const clockdef& cd, int width) {
+    std::cout << "Clock under test: " << std::setw(width) << cd.macro;
     auto res = command("make clock_test_driver CLOCK_TO_TEST=" + cd.macro);
     if(not res || (*res).exitstatus) return UNSUPP;
 
@@ -92,25 +94,35 @@ std::string mkname(std::string macro) {
 }
 
 int createit() {
+    auto& seen_file = "seen_clockid_t";
     std::cout << std::boolalpha;
-    std::ifstream cids("seen_clockid_t");
+    std::ifstream cids(seen_file);
     if(not cids) {
-        std::cerr << std::strerror(errno) << '\n';
+        std::cerr << seen_file << ": " << std::strerror(errno) << '\n';
         return 1;
     }
+    std::vector<clockdef> cds(std::istream_iterator<clockdef>(cids), std::istream_iterator<clockdef>{});
+    if(cds.empty()) {
+        std::cerr << seen_file << ": No valid clock definitions read\n";
+        return 1;
+    }
+    int maxwidth = std::max_element(cds.begin(), cds.end(), [](const clockdef& lhs, const clockdef& rhs) {
+        return lhs.macro.size() < rhs.macro.size();
+    })->macro.size();
 
     std::filesystem::copy("base.hpp", "clocxx.hpp", std::filesystem::copy_options::overwrite_existing);
 
-    std::ofstream ofs("clocxx.hpp", std::ios::app);
+    auto& target = "clocxx.hpp";
+    std::ofstream ofs(target, std::ios::app);
     if(not ofs) {
-        std::cerr << std::strerror(errno) << '\n';
+        std::cerr << target << ": " << std::strerror(errno) << '\n';
         return 1;
     }
     ofs << std::boolalpha;
 
-    clockdef cd;
-    while(cids >> cd) {
-        auto rv = test(cd);
+    for(auto& cd : cds) {
+        auto rv = test(cd, maxwidth);
+        std::cout << ": " << rv << '\n';
         if(rv != UNSUPP) {
             auto clname = mkname(cd.macro);
             ofs << "/*\n * " << clname << " - " << cd.description << "\n */\n";

seen_clockid_t

@@ -21,3 +21,5 @@ CLOCK_BOOTTIME_ALARM, true, Like CLOCK_BOOTTIME. See timer_create(2) for further
 CLOCK_PROCESS_CPUTIME_ID, true, This is a clock that measures CPU time consumed by this process (i.e., CPU time consumed by all threads in the process). On Linux, this clock is not settable.
 
 CLOCK_THREAD_CPUTIME_ID, true, This is a clock that measures CPU time consumed by this thread. On Linux, this clock is not settable.
+
+CLOCK_SOFTTIME, false, This clock (a QNX Neutrino extension) is active only when the processor isn't in a power-saving mode. For example, an application using a CLOCK_SOFTTIME timer to sleep wouldn't wake up the processor when the application was due to wake up. This will allow the processor to enter a power-saving mode.