mirror of
https://github.com/mollyim/webrtc.git
synced 2025-05-15 06:40:43 +01:00
6fa0cfa4dd
Timer is a high-level timer (in contrast to the low-level `Timeout` class). Timers are started and can be stopped or restarted. When a timer expires, the provided callback will be triggered. Timers can be configured to do e.g. exponential backoff when they expire and how many times they should be automatically restarted. Bug: webrtc:12614 Change-Id: Id5eddd58dd0af62184b10dd1f98e3e886e3f1d50 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/213350 Reviewed-by: Tommi <tommi@webrtc.org> Commit-Queue: Victor Boivie <boivie@webrtc.org> Cr-Commit-Position: refs/heads/master@{#33666}
120 lines
3.5 KiB
C++
120 lines
3.5 KiB
C++
/*
|
|
* Copyright (c) 2021 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
#include "net/dcsctp/timer/timer.h"
|
|
|
|
#include <cstdint>
|
|
#include <memory>
|
|
#include <unordered_map>
|
|
#include <utility>
|
|
|
|
#include "absl/memory/memory.h"
|
|
#include "absl/strings/string_view.h"
|
|
#include "net/dcsctp/public/timeout.h"
|
|
|
|
namespace dcsctp {
|
|
namespace {
|
|
TimeoutID MakeTimeoutId(uint32_t timer_id, uint32_t generation) {
|
|
return TimeoutID(static_cast<uint64_t>(timer_id) << 32 | generation);
|
|
}
|
|
|
|
DurationMs GetBackoffDuration(TimerBackoffAlgorithm algorithm,
|
|
DurationMs base_duration,
|
|
int expiration_count) {
|
|
switch (algorithm) {
|
|
case TimerBackoffAlgorithm::kFixed:
|
|
return base_duration;
|
|
case TimerBackoffAlgorithm::kExponential:
|
|
return DurationMs(*base_duration * (1 << expiration_count));
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
Timer::Timer(uint32_t id,
|
|
absl::string_view name,
|
|
OnExpired on_expired,
|
|
UnregisterHandler unregister_handler,
|
|
std::unique_ptr<Timeout> timeout,
|
|
const TimerOptions& options)
|
|
: id_(id),
|
|
name_(name),
|
|
options_(options),
|
|
on_expired_(std::move(on_expired)),
|
|
unregister_handler_(std::move(unregister_handler)),
|
|
timeout_(std::move(timeout)),
|
|
duration_(options.duration) {}
|
|
|
|
Timer::~Timer() {
|
|
Stop();
|
|
unregister_handler_();
|
|
}
|
|
|
|
void Timer::Start() {
|
|
expiration_count_ = 0;
|
|
if (!is_running()) {
|
|
is_running_ = true;
|
|
timeout_->Start(duration_, MakeTimeoutId(id_, ++generation_));
|
|
} else {
|
|
// Timer was running - stop and restart it, to make it expire in `duration_`
|
|
// from now.
|
|
timeout_->Restart(duration_, MakeTimeoutId(id_, ++generation_));
|
|
}
|
|
}
|
|
|
|
void Timer::Stop() {
|
|
if (is_running()) {
|
|
timeout_->Stop();
|
|
expiration_count_ = 0;
|
|
is_running_ = false;
|
|
}
|
|
}
|
|
|
|
void Timer::Trigger(uint32_t generation) {
|
|
if (is_running_ && generation == generation_) {
|
|
++expiration_count_;
|
|
if (options_.max_restarts >= 0 &&
|
|
expiration_count_ > options_.max_restarts) {
|
|
is_running_ = false;
|
|
}
|
|
|
|
absl::optional<DurationMs> new_duration = on_expired_();
|
|
if (new_duration.has_value()) {
|
|
duration_ = new_duration.value();
|
|
}
|
|
|
|
if (is_running_) {
|
|
// Restart it with new duration.
|
|
DurationMs duration = GetBackoffDuration(options_.backoff_algorithm,
|
|
duration_, expiration_count_);
|
|
timeout_->Start(duration, MakeTimeoutId(id_, ++generation_));
|
|
}
|
|
}
|
|
}
|
|
|
|
void TimerManager::HandleTimeout(TimeoutID timeout_id) {
|
|
uint32_t timer_id = *timeout_id >> 32;
|
|
uint32_t generation = *timeout_id;
|
|
auto it = timers_.find(timer_id);
|
|
if (it != timers_.end()) {
|
|
it->second->Trigger(generation);
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<Timer> TimerManager::CreateTimer(absl::string_view name,
|
|
Timer::OnExpired on_expired,
|
|
const TimerOptions& options) {
|
|
uint32_t id = ++next_id_;
|
|
auto timer = absl::WrapUnique(new Timer(
|
|
id, name, std::move(on_expired), [this, id]() { timers_.erase(id); },
|
|
create_timeout_(), options));
|
|
timers_[id] = timer.get();
|
|
return timer;
|
|
}
|
|
|
|
} // namespace dcsctp
|