bmahler commented on code in PR #474:
URL: https://github.com/apache/mesos/pull/474#discussion_r1456453593
##########
include/mesos/mesos.proto:
##########
@@ -1888,6 +1888,33 @@ message ResourceStatistics {
optional uint64 net_tx_burst_rate_limit = 47;
optional uint64 net_tx_burst_size = 48;
+ message RatePercentiles {
+ optional uint64 min = 1;
+ optional uint64 max = 2;
+ optional uint64 p50 = 3;
+ optional uint64 p90 = 4;
+ optional uint64 p95 = 5;
+ optional uint64 p99 = 6;
+ optional uint64 p999 = 7;
+ optional uint64 p9999 = 8;
+ optional uint64 samples = 9;
+ }
+
+ message RateStatistics {
+ optional RatePercentiles rx_rate = 1;
+ optional RatePercentiles rx_packet_rate = 2;
+ optional RatePercentiles rx_drop_rate = 3;
+ optional RatePercentiles rx_error_rate = 4;
+ optional RatePercentiles tx_rate = 5;
+ optional RatePercentiles tx_packet_rate = 6;
+ optional RatePercentiles tx_drop_rate = 7;
+ optional RatePercentiles tx_error_rate = 8;
+ optional double sampling_window_secs = 9;
+ optional double sampling_interval_secs = 10;
+ }
+
+ optional RateStatistics net_rate_statistics = 51;
+
// The kernel keeps track of RTT (round-trip time) for its TCP
Review Comment:
yes!
##########
src/slave/containerizer/mesos/isolators/network/port_mapping.cpp:
##########
@@ -1431,6 +1431,279 @@ int PortMappingHTBConfig::execute()
}
+/////////////////////////////////////////////////
+// Implementation of RatesCollector.
+/////////////////////////////////////////////////
+
+PercentileRatesCollector::PercentileRatesCollector(
+ pid_t _executorPid,
+ const Duration& _window,
+ const Duration& _interval)
+ : link(veth(_executorPid))
+{
+ const size_t capacity = _window.secs() / _interval.secs();
+ rxRates = TimeSeries<uint64_t>(_window, capacity);
+ rxPackets = TimeSeries<uint64_t>(_window, capacity);
+ rxDrops = TimeSeries<uint64_t>(_window, capacity);
+ rxErrors = TimeSeries<uint64_t>(_window, capacity);
+ txRates = TimeSeries<uint64_t>(_window, capacity);
+ txPackets = TimeSeries<uint64_t>(_window, capacity);
+ txDrops = TimeSeries<uint64_t>(_window, capacity);
+ txErrors = TimeSeries<uint64_t>(_window, capacity);
+}
+
+
+Option<Statistics<uint64_t>> PercentileRatesCollector::rxRate() const
+{
+ return Statistics<uint64_t>::from(rxRates);
+}
+
+
+Option<Statistics<uint64_t>> PercentileRatesCollector::rxPacketRate() const
+{
+ return Statistics<uint64_t>::from(rxPackets);
+}
+
+
+Option<Statistics<uint64_t>> PercentileRatesCollector::rxDropRate() const
+{
+ return Statistics<uint64_t>::from(rxDrops);
+}
+
+
+Option<Statistics<uint64_t>> PercentileRatesCollector::rxErrorRate() const
+{
+ return Statistics<uint64_t>::from(rxErrors);
+}
+
+
+Option<Statistics<uint64_t>> PercentileRatesCollector::txRate() const
+{
+ return Statistics<uint64_t>::from(txRates);
+}
+
+
+Option<Statistics<uint64_t>> PercentileRatesCollector::txPacketRate() const
+{
+ return Statistics<uint64_t>::from(txPackets);
+}
+
+
+Option<Statistics<uint64_t>> PercentileRatesCollector::txDropRate() const
+{
+ return Statistics<uint64_t>::from(txDrops);
+}
+
+
+Option<Statistics<uint64_t>> PercentileRatesCollector::txErrorRate() const
+{
+ return Statistics<uint64_t>::from(txErrors);
+}
+
+
+void PercentileRatesCollector::sample()
+{
+ const Time ts = Clock::now();
+
+ Result<hashmap<string, uint64_t>> stats = link::statistics(link);
+ if (stats.isSome()) {
+ sample(ts, std::move(stats.get()));
+ }
+}
+
+
+void PercentileRatesCollector::sample(
+ const Time& ts, hashmap<string, uint64_t>&& statistics)
+{
+ if (previous.isSome() && previous.get() < ts) {
+ // We sample statistics on the host end of the veth pair, so we
+ // need to reverse RX and RX to get statistics inside the
Review Comment:
RX and TX
##########
src/slave/containerizer/mesos/isolators/network/port_mapping.hpp:
##########
@@ -152,6 +153,59 @@ Result<routing::queueing::htb::cls::Config>
recoverHTBConfig(
const std::string& eth0,
const Flags& flags);
+
+class PercentileRatesCollector final
+{
+public:
+ explicit PercentileRatesCollector(
+ pid_t _executorPid, const Duration& _window, const Duration& _interval);
+
+ Option<process::Statistics<uint64_t>> rxRate() const;
+ Option<process::Statistics<uint64_t>> rxPacketRate() const;
+ Option<process::Statistics<uint64_t>> rxDropRate() const;
+ Option<process::Statistics<uint64_t>> rxErrorRate() const;
+
+ Option<process::Statistics<uint64_t>> txRate() const;
+ Option<process::Statistics<uint64_t>> txPacketRate() const;
+ Option<process::Statistics<uint64_t>> txDropRate() const;
+ Option<process::Statistics<uint64_t>> txErrorRate() const;
+
+ // Sample statistics from the interface.
+ void sample();
+
+ // Register the statistics sample. Exposed for testing.
+ void sample(const process::Time& ts, hashmap<std::string, uint64_t>&& stats);
+
+private:
+ void sampleRate(
+ const hashmap<std::string, uint64_t>& statistics,
+ const std::string& metric,
+ const process::Time& timestamp,
+ double timeDelta,
+ process::TimeSeries<uint64_t>& rates);
+
+ // Name of the link to sample metrics from.
+ const std::string link;
+
+ process::TimeSeries<uint64_t> rxRates;
+ process::TimeSeries<uint64_t> rxPackets;
+ process::TimeSeries<uint64_t> rxDrops;
+ process::TimeSeries<uint64_t> rxErrors;
+
+ process::TimeSeries<uint64_t> txRates;
+ process::TimeSeries<uint64_t> txPackets;
+ process::TimeSeries<uint64_t> txDrops;
+ process::TimeSeries<uint64_t> txErrors;
+
+ // Previous sample and its timestamp for calculating rates.
+ Option<process::Time> previous;
+ hashmap<std::string, uint64_t> previousStatistics;
Review Comment:
Some follow-on optimizations: since in practice we're sampling every 50ms,
it's probably worth avoiding the string keyed map here and instead use an enum
indexed array like the library underneath us uses, which is significantly more
efficient.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
