blob: dcfd2dc526eb7700ad0a4607a6e8e4ef2ed055f5 [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "quic/test_tools/simulator/link.h"
#include "quic/test_tools/simulator/simulator.h"
#include "common/platform/api/quiche_str_cat.h"
namespace quic {
namespace simulator {
// Parameters for random noise delay.
const uint64_t kMaxRandomDelayUs = 10;
OneWayLink::OneWayLink(Simulator* simulator,
std::string name,
UnconstrainedPortInterface* sink,
QuicBandwidth bandwidth,
QuicTime::Delta propagation_delay)
: Actor(simulator, name),
sink_(sink),
bandwidth_(bandwidth),
propagation_delay_(propagation_delay),
next_write_at_(QuicTime::Zero()) {}
OneWayLink::~OneWayLink() {}
OneWayLink::QueuedPacket::QueuedPacket(std::unique_ptr<Packet> packet,
QuicTime dequeue_time)
: packet(std::move(packet)), dequeue_time(dequeue_time) {}
OneWayLink::QueuedPacket::QueuedPacket(QueuedPacket&& other) = default;
OneWayLink::QueuedPacket::~QueuedPacket() {}
void OneWayLink::AcceptPacket(std::unique_ptr<Packet> packet) {
DCHECK(TimeUntilAvailable().IsZero());
QuicTime::Delta transfer_time = bandwidth_.TransferTime(packet->size);
next_write_at_ = clock_->Now() + transfer_time;
packets_in_transit_.emplace_back(
std::move(packet),
// Ensure that packets are delivered in order.
std::max(
next_write_at_ + propagation_delay_ + GetRandomDelay(transfer_time),
packets_in_transit_.empty()
? QuicTime::Zero()
: packets_in_transit_.back().dequeue_time));
ScheduleNextPacketDeparture();
}
QuicTime::Delta OneWayLink::TimeUntilAvailable() {
const QuicTime now = clock_->Now();
if (next_write_at_ <= now) {
return QuicTime::Delta::Zero();
}
return next_write_at_ - now;
}
void OneWayLink::Act() {
DCHECK(!packets_in_transit_.empty());
DCHECK(packets_in_transit_.front().dequeue_time >= clock_->Now());
sink_->AcceptPacket(std::move(packets_in_transit_.front().packet));
packets_in_transit_.pop_front();
ScheduleNextPacketDeparture();
}
void OneWayLink::ScheduleNextPacketDeparture() {
if (packets_in_transit_.empty()) {
return;
}
Schedule(packets_in_transit_.front().dequeue_time);
}
QuicTime::Delta OneWayLink::GetRandomDelay(QuicTime::Delta transfer_time) {
if (!simulator_->enable_random_delays()) {
return QuicTime::Delta::Zero();
}
QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(
simulator_->GetRandomGenerator()->RandUint64() % (kMaxRandomDelayUs + 1));
// Have an upper bound on the delay to ensure packets do not go out of order.
delta = std::min(delta, transfer_time * 0.5);
return delta;
}
SymmetricLink::SymmetricLink(Simulator* simulator,
std::string name,
UnconstrainedPortInterface* sink_a,
UnconstrainedPortInterface* sink_b,
QuicBandwidth bandwidth,
QuicTime::Delta propagation_delay)
: a_to_b_link_(simulator,
quiche::QuicheStringPrintf("%s (A-to-B)", name.c_str()),
sink_b,
bandwidth,
propagation_delay),
b_to_a_link_(simulator,
quiche::QuicheStringPrintf("%s (B-to-A)", name.c_str()),
sink_a,
bandwidth,
propagation_delay) {}
SymmetricLink::SymmetricLink(Endpoint* endpoint_a,
Endpoint* endpoint_b,
QuicBandwidth bandwidth,
QuicTime::Delta propagation_delay)
: SymmetricLink(endpoint_a->simulator(),
quiche::QuicheStringPrintf("Link [%s]<->[%s]",
endpoint_a->name().c_str(),
endpoint_b->name().c_str()),
endpoint_a->GetRxPort(),
endpoint_b->GetRxPort(),
bandwidth,
propagation_delay) {
endpoint_a->SetTxPort(&a_to_b_link_);
endpoint_b->SetTxPort(&b_to_a_link_);
}
} // namespace simulator
} // namespace quic