1 // Copyright 2017 The Abseil Authors. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 // 15 16 // An optional absolute timeout, with nanosecond granularity, 17 // compatible with absl::Time. Suitable for in-register 18 // parameter-passing (e.g. syscalls.) 19 // Constructible from a absl::Time (for a timeout to be respected) or {} 20 // (for "no timeout".) 21 // This is a private low-level API for use by a handful of low-level 22 // components that are friends of this class. Higher-level components 23 // should build APIs based on absl::Time and absl::Duration. 24 25 #ifndef ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_ 26 #define ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_ 27 28 #include <time.h> 29 #include <algorithm> 30 #include <limits> 31 32 #include "absl/base/internal/raw_logging.h" 33 #include "absl/time/clock.h" 34 #include "absl/time/time.h" 35 36 namespace absl { 37 namespace synchronization_internal { 38 39 class Futex; 40 class Waiter; 41 42 class KernelTimeout { 43 public: 44 // A timeout that should expire at <t>. Any value, in the full 45 // InfinitePast() to InfiniteFuture() range, is valid here and will be 46 // respected. KernelTimeout(absl::Time t)47 explicit KernelTimeout(absl::Time t) : ns_(MakeNs(t)) {} 48 // No timeout. KernelTimeout()49 KernelTimeout() : ns_(0) {} 50 51 // A more explicit factory for those who prefer it. Equivalent to {}. Never()52 static KernelTimeout Never() { return {}; } 53 54 // We explicitly do not support other custom formats: timespec, int64_t nanos. 55 // Unify on this and absl::Time, please. has_timeout()56 bool has_timeout() const { return ns_ != 0; } 57 58 private: 59 // internal rep, not user visible: ns after unix epoch. 60 // zero = no timeout. 61 // Negative we treat as an unlikely (and certainly expired!) but valid 62 // timeout. 63 int64_t ns_; 64 MakeNs(absl::Time t)65 static int64_t MakeNs(absl::Time t) { 66 // optimization--InfiniteFuture is common "no timeout" value 67 // and cheaper to compare than convert. 68 if (t == absl::InfiniteFuture()) return 0; 69 int64_t x = ToUnixNanos(t); 70 71 // A timeout that lands exactly on the epoch (x=0) needs to be respected, 72 // so we alter it unnoticably to 1. Negative timeouts are in 73 // theory supported, but handled poorly by the kernel (long 74 // delays) so push them forward too; since all such times have 75 // already passed, it's indistinguishable. 76 if (x <= 0) x = 1; 77 // A time larger than what can be represented to the kernel is treated 78 // as no timeout. 79 if (x == std::numeric_limits<int64_t>::max()) x = 0; 80 return x; 81 } 82 83 // Convert to parameter for sem_timedwait/futex/similar. Only for approved 84 // users. Do not call if !has_timeout. MakeAbsTimespec()85 struct timespec MakeAbsTimespec() { 86 int64_t n = ns_; 87 static const int64_t kNanosPerSecond = 1000 * 1000 * 1000; 88 if (n == 0) { 89 ABSL_RAW_LOG( 90 ERROR, 91 "Tried to create a timespec from a non-timeout; never do this."); 92 // But we'll try to continue sanely. no-timeout ~= saturated timeout. 93 n = std::numeric_limits<int64_t>::max(); 94 } 95 96 // Kernel APIs validate timespecs as being at or after the epoch, 97 // despite the kernel time type being signed. However, no one can 98 // tell the difference between a timeout at or before the epoch (since 99 // all such timeouts have expired!) 100 if (n < 0) n = 0; 101 102 struct timespec abstime; 103 int64_t seconds = std::min(n / kNanosPerSecond, 104 int64_t{std::numeric_limits<time_t>::max()}); 105 abstime.tv_sec = static_cast<time_t>(seconds); 106 abstime.tv_nsec = 107 static_cast<decltype(abstime.tv_nsec)>(n % kNanosPerSecond); 108 return abstime; 109 } 110 111 #ifdef _WIN32 112 // Converts to milliseconds from now, or INFINITE when 113 // !has_timeout(). For use by SleepConditionVariableSRW on 114 // Windows. Callers should recognize that the return value is a 115 // relative duration (it should be recomputed by calling this method 116 // in the case of a spurious wakeup). 117 // This header file may be included transitively by public header files, 118 // so we define our own DWORD and INFINITE instead of getting them from 119 // <intsafe.h> and <WinBase.h>. 120 typedef unsigned long DWord; // NOLINT InMillisecondsFromNow()121 DWord InMillisecondsFromNow() const { 122 constexpr DWord kInfinite = std::numeric_limits<DWord>::max(); 123 if (!has_timeout()) { 124 return kInfinite; 125 } 126 // The use of absl::Now() to convert from absolute time to 127 // relative time means that absl::Now() cannot use anything that 128 // depends on KernelTimeout (for example, Mutex) on Windows. 129 int64_t now = ToUnixNanos(absl::Now()); 130 if (ns_ >= now) { 131 // Round up so that Now() + ms_from_now >= ns_. 132 constexpr uint64_t max_nanos = 133 std::numeric_limits<int64_t>::max() - 999999u; 134 uint64_t ms_from_now = 135 (std::min<uint64_t>(max_nanos, ns_ - now) + 999999u) / 1000000u; 136 if (ms_from_now > kInfinite) { 137 return kInfinite; 138 } 139 return static_cast<DWord>(ms_from_now); 140 } 141 return 0; 142 } 143 #endif 144 145 friend class Futex; 146 friend class Waiter; 147 }; 148 149 } // namespace synchronization_internal 150 } // namespace absl 151 #endif // ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_ 152