text: // Copyright 2017 The Abseil Authors.
  //
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  //
  //      http://www.apache.org/licenses/LICENSE-2.0
  //
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  //
  
  // An optional absolute timeout, with nanosecond granularity,
  // compatible with absl::Time. Suitable for in-register
  // parameter-passing (e.g. syscalls.)
  // Constructible from a absl::Time (for a timeout to be respected) or {}
  // (for "no timeout".)
  // This is a private low-level API for use by a handful of low-level
  // components that are friends of this class. Higher-level components
  // should build APIs based on absl::Time and absl::Duration.
  
  #ifndef ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
  #define ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
  
  #ifdef _WIN32
  #include <intsafe.h>
  #endif
  #include <time.h>
  #include <algorithm>
  #include <limits>
  
  #include BOSS_ABSEILCPP_U_absl__base__internal__raw_logging_h //original-code:"absl/base/internal/raw_logging.h"
  #include BOSS_ABSEILCPP_U_absl__time__clock_h //original-code:"absl/time/clock.h"
  #include BOSS_ABSEILCPP_U_absl__time__time_h //original-code:"absl/time/time.h"
  
  namespace absl {
  inline namespace lts_2018_06_20 {
  namespace synchronization_internal {
  
  class Futex;
  class Waiter;
  
  class KernelTimeout {
   public:
    // A timeout that should expire at <t>.  Any value, in the full
    // InfinitePast() to InfiniteFuture() range, is valid here and will be
    // respected.
    explicit KernelTimeout(absl::Time t) : ns_(MakeNs(t)) {}
    // No timeout.
    KernelTimeout() : ns_(0) {}
  
    // A more explicit factory for those who prefer it.  Equivalent to {}.
    static KernelTimeout Never() { return {}; }
  
    // We explicitly do not support other custom formats: timespec, int64_t nanos.
    // Unify on this and absl::Time, please.
    bool has_timeout() const { return ns_ != 0; }
  
   private:
    // internal rep, not user visible: ns after unix epoch.
    // zero = no timeout.
    // Negative we treat as an unlikely (and certainly expired!) but valid
    // timeout.
    int64_t ns_;
  
    static int64_t MakeNs(absl::Time t) {
      // optimization--InfiniteFuture is common "no timeout" value
      // and cheaper to compare than convert.
      if (t == absl::InfiniteFuture()) return 0;
      int64_t x = ToUnixNanos(t);
  
      // A timeout that lands exactly on the epoch (x=0) needs to be respected,
      // so we alter it unnoticably to 1.  Negative timeouts are in
      // theory supported, but handled poorly by the kernel (long
      // delays) so push them forward too; since all such times have
      // already passed, it's indistinguishable.
      if (x <= 0) x = 1;
      // A time larger than what can be represented to the kernel is treated
      // as no timeout.
      if (x == std::numeric_limits<int64_t>::max()) x = 0;
      return x;
    }
  
    // Convert to parameter for sem_timedwait/futex/similar.  Only for approved
    // users.  Do not call if !has_timeout.
    struct timespec MakeAbsTimespec() {
      int64_t n = ns_;
      static const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
      if (n == 0) {
        ABSL_RAW_LOG(
            ERROR,
            "Tried to create a timespec from a non-timeout; never do this.");
        // But we'll try to continue sanely.  no-timeout ~= saturated timeout.
        n = std::numeric_limits<int64_t>::max();
      }
  
      // Kernel APIs validate timespecs as being at or after the epoch,
      // despite the kernel time type being signed.  However, no one can
      // tell the difference between a timeout at or before the epoch (since
      // all such timeouts have expired!)
      if (n < 0) n = 0;
  
      struct timespec abstime;
      int64_t seconds = std::min(n / kNanosPerSecond,
                               int64_t{std::numeric_limits<time_t>::max()});
      abstime.tv_sec = static_cast<time_t>(seconds);
      abstime.tv_nsec =
          static_cast<decltype(abstime.tv_nsec)>(n % kNanosPerSecond);
      return abstime;
    }
  
  #ifdef _WIN32
    // Converts to milliseconds from now, or INFINITE when
    // !has_timeout(). For use by SleepConditionVariableSRW on
    // Windows. Callers should recognize that the return value is a
    // relative duration (it should be recomputed by calling this method
    // in the case of a spurious wakeup).
    DWORD InMillisecondsFromNow() const {
      if (!has_timeout()) {
        return INFINITE;
      }
      // The use of absl::Now() to convert from absolute time to
      // relative time means that absl::Now() cannot use anything that
      // depends on KernelTimeout (for example, Mutex) on Windows.
      int64_t now = ToUnixNanos(absl::Now());
      if (ns_ >= now) {
        // Round up so that Now() + ms_from_now >= ns_.
        constexpr uint64_t max_nanos =
            std::numeric_limits<int64_t>::max() - 999999u;
        uint64_t ms_from_now =
            (std::min<uint64_t>(max_nanos, ns_ - now) + 999999u) / 1000000u;
        if (ms_from_now > std::numeric_limits<DWORD>::max()) {
          return INFINITE;
        }
        return static_cast<DWORD>(ms_from_now);
      }
      return 0;
    }
  #endif
  
    friend class Futex;
    friend class Waiter;
  };
  
  }  // namespace synchronization_internal
  }  // inline namespace lts_2018_06_20
  }  // namespace absl
  #endif  // ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
  