chromium/third_party/grpc/src/src/core/lib/event_engine/posix_engine/timer.cc

//
//
// Copyright 2015 gRPC 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.
//
//

#include <grpc/support/port_platform.h>

#include "src/core/lib/event_engine/posix_engine/timer.h"

#include <algorithm>
#include <atomic>
#include <limits>
#include <utility>

#include <grpc/support/cpu.h>

#include "src/core/lib/event_engine/posix_engine/timer_heap.h"
#include "src/core/lib/gpr/useful.h"
#include "src/core/lib/gprpp/time.h"

namespace grpc_event_engine {
namespace experimental {

static const size_t kInvalidHeapIndex = …;
static const double kAddDeadlineScale = …;
static const double kMinQueueWindowDuration = …;
static const double kMaxQueueWindowDuration = …;

grpc_core::Timestamp TimerList::Shard::ComputeMinDeadline() { … }

TimerList::Shard::Shard() : … { … }

TimerList::TimerList(TimerListHost* host)
    : … { … }

namespace {
// returns true if the first element in the list
void ListJoin(Timer* head, Timer* timer) { … }

void ListRemove(Timer* timer) { … }
}  // namespace

void TimerList::SwapAdjacentShardsInQueue(uint32_t first_shard_queue_index) { … }

void TimerList::NoteDeadlineChange(Shard* shard) { … }

void TimerList::TimerInit(Timer* timer, grpc_core::Timestamp deadline,
                          experimental::EventEngine::Closure* closure) { … }

bool TimerList::TimerCancel(Timer* timer) { … }

// Rebalances the timer shard by computing a new 'queue_deadline_cap' and moving
// all relevant timers in shard->list (i.e timers with deadlines earlier than
// 'queue_deadline_cap') into into shard->heap.
// Returns 'true' if shard->heap has at least ONE element
bool TimerList::Shard::RefillHeap(grpc_core::Timestamp now) { … }

// This pops the next non-cancelled timer with deadline <= now from the
// queue, or returns NULL if there isn't one.
Timer* TimerList::Shard::PopOne(grpc_core::Timestamp now) { … }

void TimerList::Shard::PopTimers(
    grpc_core::Timestamp now, grpc_core::Timestamp* new_min_deadline,
    std::vector<experimental::EventEngine::Closure*>* out) { … }

std::vector<experimental::EventEngine::Closure*> TimerList::FindExpiredTimers(
    grpc_core::Timestamp now, grpc_core::Timestamp* next) { … }

absl::optional<std::vector<experimental::EventEngine::Closure*>>
TimerList::TimerCheck(grpc_core::Timestamp* next) { … }

}  // namespace experimental
}  // namespace grpc_event_engine