THUAI6/CAPI/cpp/grpc/include/absl/synchronization/internal/kernel_timeout.h

// 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
//
//      https://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_

#include <time.h>

#include <algorithm>
#include <limits>

#include "absl/base/internal/raw_logging.h"
#include "absl/time/clock.h"
#include "absl/time/time.h"

namespace absl
{
    ABSL_NAMESPACE_BEGIN
    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;
            }

            // Convert to parameter for sem_timedwait/futex/similar.  Only for approved
            // users.  Do not call if !has_timeout.
            struct timespec MakeAbsTimespec();

        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;
            }

#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).
            // This header file may be included transitively by public header files,
            // so we define our own DWORD and INFINITE instead of getting them from
            // <intsafe.h> and <WinBase.h>.
            typedef unsigned long DWord;  // NOLINT
            DWord InMillisecondsFromNow() const
            {
                constexpr DWord kInfinite = (std::numeric_limits<DWord>::max)();
                if (!has_timeout())
                {
                    return kInfinite;
                }
                // 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 > kInfinite)
                    {
                        return kInfinite;
                    }
                    return static_cast<DWord>(ms_from_now);
                }
                return 0;
            }
#endif

            friend class Futex;
            friend class Waiter;
        };

        inline struct timespec KernelTimeout::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;
        }

    }  // namespace synchronization_internal
    ABSL_NAMESPACE_END
}  // namespace absl

#endif  // ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_