admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "Only process cross traffic simulation if added."

Browse Source 
This reverts commit 491d29448e4a0f501f1ea115b218ed5250fbd3dc.

Reason for revert: Breaks internal iOS waterfall

Original change's description:
> Only process cross traffic simulation if added.
> 
> This avoids extra processing overhead when there's no cross traffic
> simulation active. To allow the use of SendTask, GlobalTimeController
> is adjusted so it always overrides yield behavior.
> 
> Also adding sequence checkers to protect against races on
> read access.
> 
> Bug: webrtc:10365
> Change-Id: I55c6ceb22f36ec19a4fca48cff500905192d1a16
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/133167
> Reviewed-by: Niels Moller <nisse@webrtc.org>
> Reviewed-by: Artem Titov <titovartem@webrtc.org>
> Commit-Queue: Sebastian Jansson <srte@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#27658}

TBR=nisse@webrtc.org,srte@webrtc.org,titovartem@webrtc.org

Change-Id: I3b176b0ec202a047c4436e3c2136e8170faea41e
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: webrtc:10365
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/133482
Reviewed-by: Artem Titarenko <artit@google.com>
Commit-Queue: Artem Titarenko <artit@google.com>
Cr-Commit-Position: refs/heads/master@{#27669}
This commit is contained in:
Artem Titarenko 2019-04-17 15:38:55 +00:00 committed by Commit Bot
parent 40889f35fc
commit b4b53bd8cc
5 changed files with 51 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
test/scenario/network/BUILD.gn
View File

@ -46,7 +46,6 @@ rtc_source_set("emulated_network") {
"../../../rtc_base:rtc_task_queue",
"../../../rtc_base:safe_minmax",
"../../../rtc_base:task_queue_for_test",
"../../../rtc_base/synchronization:sequence_checker",
"../../../rtc_base/task_utils:repeating_task",
"../../../rtc_base/third_party/sigslot",
"../../../system_wrappers",

12
test/scenario/network/cross_traffic.cc
View File

@ -25,13 +25,10 @@ RandomWalkCrossTraffic::RandomWalkCrossTraffic(RandomWalkConfig config,
TrafficRoute* traffic_route)
: config_(config),
traffic_route_(traffic_route),
random_(config_.random_seed) {
sequence_checker_.Detach();
}
random_(config_.random_seed) {}
RandomWalkCrossTraffic::~RandomWalkCrossTraffic() = default;
void RandomWalkCrossTraffic::Process(Timestamp at_time) {
RTC_DCHECK_RUN_ON(&sequence_checker_);
if (last_process_time_.IsMinusInfinity()) {
last_process_time_ = at_time;
}
@ -55,7 +52,6 @@ void RandomWalkCrossTraffic::Process(Timestamp at_time) {
}
DataRate RandomWalkCrossTraffic::TrafficRate() const {
RTC_DCHECK_RUN_ON(&sequence_checker_);
return config_.peak_rate * intensity_;
}
@ -70,13 +66,10 @@ ColumnPrinter RandomWalkCrossTraffic::StatsPrinter() {
PulsedPeaksCrossTraffic::PulsedPeaksCrossTraffic(PulsedPeaksConfig config,
TrafficRoute* traffic_route)
: config_(config), traffic_route_(traffic_route) {
sequence_checker_.Detach();
}
: config_(config), traffic_route_(traffic_route) {}
PulsedPeaksCrossTraffic::~PulsedPeaksCrossTraffic() = default;
void PulsedPeaksCrossTraffic::Process(Timestamp at_time) {
RTC_DCHECK_RUN_ON(&sequence_checker_);
TimeDelta time_since_toggle = at_time - last_update_time_;
if (time_since_toggle.IsInfinite() ||
(sending_ && time_since_toggle >= config_.send_duration)) {
@ -101,7 +94,6 @@ void PulsedPeaksCrossTraffic::Process(Timestamp at_time) {
}
DataRate PulsedPeaksCrossTraffic::TrafficRate() const {
RTC_DCHECK_RUN_ON(&sequence_checker_);
return sending_ ? config_.peak_rate : DataRate::Zero();
}

34
test/scenario/network/cross_traffic.h
View File

@ -18,7 +18,6 @@
#include "api/units/time_delta.h"
#include "api/units/timestamp.h"
#include "rtc_base/random.h"
#include "rtc_base/synchronization/sequence_checker.h"
#include "test/scenario/column_printer.h"
#include "test/scenario/network/traffic_route.h"
@ -45,19 +44,15 @@ class RandomWalkCrossTraffic {
ColumnPrinter StatsPrinter();
private:
SequenceChecker sequence_checker_;
const RandomWalkConfig config_;
TrafficRoute* const traffic_route_ RTC_PT_GUARDED_BY(sequence_checker_);
webrtc::Random random_ RTC_GUARDED_BY(sequence_checker_);
RandomWalkConfig config_;
TrafficRoute* const traffic_route_;
webrtc::Random random_;
Timestamp last_process_time_ RTC_GUARDED_BY(sequence_checker_) =
Timestamp::MinusInfinity();
Timestamp last_update_time_ RTC_GUARDED_BY(sequence_checker_) =
Timestamp::MinusInfinity();
Timestamp last_send_time_ RTC_GUARDED_BY(sequence_checker_) =
Timestamp::MinusInfinity();
double intensity_ RTC_GUARDED_BY(sequence_checker_) = 0;
DataSize pending_size_ RTC_GUARDED_BY(sequence_checker_) = DataSize::Zero();
Timestamp last_process_time_ = Timestamp::MinusInfinity();
Timestamp last_update_time_ = Timestamp::MinusInfinity();
Timestamp last_send_time_ = Timestamp::MinusInfinity();
double intensity_ = 0;
DataSize pending_size_ = DataSize::Zero();
};
struct PulsedPeaksConfig {
@ -79,15 +74,12 @@ class PulsedPeaksCrossTraffic {
ColumnPrinter StatsPrinter();
private:
SequenceChecker sequence_checker_;
const PulsedPeaksConfig config_;
TrafficRoute* const traffic_route_ RTC_PT_GUARDED_BY(sequence_checker_);
PulsedPeaksConfig config_;
TrafficRoute* const traffic_route_;
Timestamp last_update_time_ RTC_GUARDED_BY(sequence_checker_) =
Timestamp::MinusInfinity();
Timestamp last_send_time_ RTC_GUARDED_BY(sequence_checker_) =
Timestamp::MinusInfinity();
bool sending_ RTC_GUARDED_BY(sequence_checker_) = false;
Timestamp last_update_time_ = Timestamp::MinusInfinity();
Timestamp last_send_time_ = Timestamp::MinusInfinity();
bool sending_ = false;
};
} // namespace test

84
test/scenario/network/network_emulation_manager.cc
View File

@ -23,33 +23,12 @@ namespace webrtc {
namespace test {
namespace {
constexpr int64_t kPacketProcessingIntervalMs = 1;
// uint32_t representation of 192.168.0.0 address
constexpr uint32_t kMinIPv4Address = 0xC0A80000;
// uint32_t representation of 192.168.255.255 address
constexpr uint32_t kMaxIPv4Address = 0xC0A8FFFF;
template <typename T, typename Closure>
class ResourceOwningTask final : public QueuedTask {
public:
ResourceOwningTask(T&& resource, Closure&& handler)
: resource_(std::move(resource)),
handler_(std::forward<Closure>(handler)) {}
bool Run() override {
handler_(std::move(resource_));
return true;
}
private:
T resource_;
Closure handler_;
};
template <typename T, typename Closure>
std::unique_ptr<QueuedTask> CreateResourceOwningTask(T resource,
Closure&& closure) {
return absl::make_unique<ResourceOwningTask<T, Closure>>(
std::forward<T>(resource), std::forward<Closure>(closure));
}
} // namespace
NetworkEmulationManagerImpl::NetworkEmulationManagerImpl()
@ -63,6 +42,10 @@ NetworkEmulationManagerImpl::NetworkEmulationManagerImpl(
task_queue_(time_controller->GetTaskQueueFactory()->CreateTaskQueue(
"NetworkEmulation",
TaskQueueFactory::Priority::NORMAL)) {
process_task_handle_ = RepeatingTaskHandle::Start(task_queue_.Get(), [this] {
ProcessNetworkPackets();
return TimeDelta::ms(kPacketProcessingIntervalMs);
});
}
// TODO(srte): Ensure that any pending task that must be run for consistency
@ -184,21 +167,17 @@ RandomWalkCrossTraffic*
NetworkEmulationManagerImpl::CreateRandomWalkCrossTraffic(
TrafficRoute* traffic_route,
RandomWalkConfig config) {
auto traffic =
absl::make_unique<RandomWalkCrossTraffic>(config, traffic_route);
auto traffic = absl::make_unique<RandomWalkCrossTraffic>(std::move(config),
traffic_route);
RandomWalkCrossTraffic* out = traffic.get();
task_queue_.PostTask(CreateResourceOwningTask(
std::move(traffic),
[this, config](std::unique_ptr<RandomWalkCrossTraffic> traffic) {
auto* traffic_ptr = traffic.get();
random_cross_traffics_.push_back(std::move(traffic));
RepeatingTaskHandle::Start(task_queue_.Get(),
[this, config, traffic_ptr] {
traffic_ptr->Process(Now());
return config.min_packet_interval;
});
}));
struct Closure {
void operator()() {
manager->random_cross_traffics_.push_back(std::move(traffic));
}
NetworkEmulationManagerImpl* manager;
std::unique_ptr<RandomWalkCrossTraffic> traffic;
};
task_queue_.PostTask(Closure{this, std::move(traffic)});
return out;
}
@ -206,20 +185,17 @@ PulsedPeaksCrossTraffic*
NetworkEmulationManagerImpl::CreatePulsedPeaksCrossTraffic(
TrafficRoute* traffic_route,
PulsedPeaksConfig config) {
auto traffic =
absl::make_unique<PulsedPeaksCrossTraffic>(config, traffic_route);
auto traffic = absl::make_unique<PulsedPeaksCrossTraffic>(std::move(config),
traffic_route);
PulsedPeaksCrossTraffic* out = traffic.get();
task_queue_.PostTask(CreateResourceOwningTask(
std::move(traffic),
[this, config](std::unique_ptr<PulsedPeaksCrossTraffic> traffic) {
auto* traffic_ptr = traffic.get();
pulsed_cross_traffics_.push_back(std::move(traffic));
RepeatingTaskHandle::Start(task_queue_.Get(),
[this, config, traffic_ptr] {
traffic_ptr->Process(Now());
return config.min_packet_interval;
});
}));
struct Closure {
void operator()() {
manager->pulsed_cross_traffics_.push_back(std::move(traffic));
}
NetworkEmulationManagerImpl* manager;
std::unique_ptr<PulsedPeaksCrossTraffic> traffic;
};
task_queue_.PostTask(Closure{this, std::move(traffic)});
return out;
}
@ -263,6 +239,16 @@ NetworkEmulationManagerImpl::GetNextIPv4Address() {
return absl::nullopt;
}
void NetworkEmulationManagerImpl::ProcessNetworkPackets() {
Timestamp current_time = Now();
for (auto& traffic : random_cross_traffics_) {
traffic->Process(current_time);
}
for (auto& traffic : pulsed_cross_traffics_) {
traffic->Process(current_time);
}
}
Timestamp NetworkEmulationManagerImpl::Now() const {
return Timestamp::us(clock_->TimeInMicroseconds());
}

1
test/scenario/network/network_emulation_manager.h
View File

@ -67,6 +67,7 @@ class NetworkEmulationManagerImpl : public NetworkEmulationManager {
private:
absl::optional<rtc::IPAddress> GetNextIPv4Address();
void ProcessNetworkPackets();
Timestamp Now() const;
Clock* const clock_;