You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficserver.apache.org by ma...@apache.org on 2017/12/22 02:06:47 UTC
[trafficserver] branch quic-latest updated (ac2e13d -> c644c6c)
This is an automated email from the ASF dual-hosted git repository.
maskit pushed a change to branch quic-latest
in repository https://gitbox.apache.org/repos/asf/trafficserver.git.
from ac2e13d Wait whole client HTTP/0.9 request on read
new c61bbf1 Send ACK frames actively
new c644c6c Translate the pseudo code for congestion control to C++
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
iocore/net/P_QUICNetVConnection.h | 1 -
iocore/net/QUICNetVConnection.cc | 38 +++++++++-------
iocore/net/quic/QUICAckFrameCreator.cc | 16 +++++--
iocore/net/quic/QUICAckFrameCreator.h | 9 ++--
iocore/net/quic/QUICCongestionController.cc | 70 ++++++++++++++++-------------
iocore/net/quic/QUICCongestionController.h | 45 -------------------
iocore/net/quic/QUICFrameDispatcher.cc | 5 ---
iocore/net/quic/QUICFrameTransmitter.h | 2 +-
iocore/net/quic/QUICLossDetector.cc | 21 +++++----
iocore/net/quic/QUICLossDetector.h | 43 ++++++++++++------
10 files changed, 120 insertions(+), 130 deletions(-)
delete mode 100644 iocore/net/quic/QUICCongestionController.h
--
To stop receiving notification emails like this one, please contact
['"commits@trafficserver.apache.org" <co...@trafficserver.apache.org>'].
[trafficserver] 01/02: Send ACK frames actively
Posted by ma...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
maskit pushed a commit to branch quic-latest
in repository https://gitbox.apache.org/repos/asf/trafficserver.git
commit c61bbf1231c54c6654f98ab3a3a4b306d2686e9a
Author: Masakazu Kitajo <ma...@apache.org>
AuthorDate: Thu Dec 21 16:30:49 2017 +0900
Send ACK frames actively
---
iocore/net/QUICNetVConnection.cc | 37 ++++++++++++++++++++--------------
iocore/net/quic/QUICAckFrameCreator.cc | 16 +++++++++++----
iocore/net/quic/QUICAckFrameCreator.h | 9 ++++-----
iocore/net/quic/QUICFrameTransmitter.h | 2 +-
4 files changed, 39 insertions(+), 25 deletions(-)
diff --git a/iocore/net/QUICNetVConnection.cc b/iocore/net/QUICNetVConnection.cc
index b1be90f..1581332 100644
--- a/iocore/net/QUICNetVConnection.cc
+++ b/iocore/net/QUICNetVConnection.cc
@@ -279,20 +279,21 @@ QUICNetVConnection::push_packet(UDPPacket *packet)
void
QUICNetVConnection::_transmit_frame(QUICFrameUPtr frame)
{
- QUICConDebug("Frame Type=%s Size=%zu", QUICDebugNames::frame_type(frame->type()), frame->size());
-
SCOPED_MUTEX_LOCK(frame_transmitter_lock, this->_frame_transmitter_mutex, this_ethread());
- if (frame->type() == QUICFrameType::STREAM) {
- QUICStreamFrame &stream_frame = static_cast<QUICStreamFrame &>(*frame);
- // XXX: Stream 0 is exempt from the connection-level flow control window.
- if (stream_frame.stream_id() == STREAM_ID_FOR_HANDSHAKE) {
- this->_frame_send_queue.push(std::move(frame));
+ if (frame) {
+ QUICConDebug("Frame Type=%s Size=%zu", QUICDebugNames::frame_type(frame->type()), frame->size());
+ if (frame->type() == QUICFrameType::STREAM) {
+ QUICStreamFrame &stream_frame = static_cast<QUICStreamFrame &>(*frame);
+ // XXX: Stream 0 is exempt from the connection-level flow control window.
+ if (stream_frame.stream_id() == STREAM_ID_FOR_HANDSHAKE) {
+ this->_frame_send_queue.push(std::move(frame));
+ } else {
+ this->_stream_frame_send_queue.push(std::move(frame));
+ }
} else {
- this->_stream_frame_send_queue.push(std::move(frame));
+ this->_frame_send_queue.push(std::move(frame));
}
- } else {
- this->_frame_send_queue.push(std::move(frame));
}
}
@@ -770,6 +771,16 @@ QUICNetVConnection::_packetize_frames()
SCOPED_MUTEX_LOCK(frame_transmitter_lock, this->_frame_transmitter_mutex, this_ethread());
+ QUICFrameUPtr ack_frame = QUICFrameFactory::create_null_ack_frame();
+ if (this->_frame_send_queue.size() || this->_stream_frame_send_queue.size()) {
+ ack_frame = this->_ack_frame_creator.create();
+ } else {
+ ack_frame = this->_ack_frame_creator.create_if_needed();
+ }
+ if (ack_frame != nullptr) {
+ this->_store_frame(buf, len, retransmittable, current_packet_type, std::move(ack_frame));
+ }
+
while (this->_frame_send_queue.size() > 0) {
frame = std::move(this->_frame_send_queue.front());
this->_frame_send_queue.pop();
@@ -830,13 +841,9 @@ QUICNetVConnection::_recv_and_ack(const uint8_t *payload, uint16_t size, QUICPac
if (ret != 0) {
return QUICErrorUPtr(new QUICConnectionError(QUICTransErrorCode::FLOW_CONTROL_ERROR));
}
- // this->_local_flow_controller->forward_limit();
this->_ack_frame_creator.update(packet_num, should_send_ack);
- QUICFrameUPtr ack_frame = this->_ack_frame_creator.create_if_needed();
- if (ack_frame != nullptr) {
- this->transmit_frame(std::move(ack_frame));
- }
+ static_cast<QUICConnection *>(this)->transmit_frame();
return error;
}
diff --git a/iocore/net/quic/QUICAckFrameCreator.cc b/iocore/net/quic/QUICAckFrameCreator.cc
index 8c1dafb..4cdc27a 100644
--- a/iocore/net/quic/QUICAckFrameCreator.cc
+++ b/iocore/net/quic/QUICAckFrameCreator.cc
@@ -26,16 +26,20 @@
#include <algorithm>
int
-QUICAckFrameCreator::update(QUICPacketNumber packet_number, bool acknowledgable)
+QUICAckFrameCreator::update(QUICPacketNumber packet_number, bool should_send)
{
if (this->_packet_numbers.size() == MAXIMUM_PACKET_COUNT) {
return -1;
}
this->_packet_numbers.push_back(packet_number);
- if (acknowledgable && !this->_can_send) {
+
+ if (!this->_can_send) {
this->_can_send = true;
}
+ if (should_send) {
+ this->_should_send = true;
+ }
return 0;
}
@@ -47,6 +51,7 @@ QUICAckFrameCreator::create()
if (this->_can_send) {
ack_frame = this->_create_ack_frame();
this->_can_send = false;
+ this->_should_send = false;
this->_packet_count = 0;
this->_packet_numbers.clear();
}
@@ -56,8 +61,11 @@ QUICAckFrameCreator::create()
std::unique_ptr<QUICAckFrame, QUICFrameDeleterFunc>
QUICAckFrameCreator::create_if_needed()
{
- // TODO What would be criteria?
- return this->create();
+ std::unique_ptr<QUICAckFrame, QUICFrameDeleterFunc> ack_frame = QUICFrameFactory::create_null_ack_frame();
+ if (this->_should_send) {
+ ack_frame = this->create();
+ }
+ return ack_frame;
}
void
diff --git a/iocore/net/quic/QUICAckFrameCreator.h b/iocore/net/quic/QUICAckFrameCreator.h
index da59c5e..9dffb93 100644
--- a/iocore/net/quic/QUICAckFrameCreator.h
+++ b/iocore/net/quic/QUICAckFrameCreator.h
@@ -59,25 +59,24 @@ public:
* All packet numbers ATS received need to be passed to this method.
* Returns 0 if updated successfully.
*/
- int update(QUICPacketNumber packet_number, bool acknowledgable);
+ int update(QUICPacketNumber packet_number, bool should_send);
/*
* Returns QUICAckFrame only if ACK frame is able to be sent.
* Caller must send the ACK frame to the peer if it was returned.
- * Usually you should use create_if_needed() instead, but you may want to
- * call this when ATS receives PING frame.
*/
std::unique_ptr<QUICAckFrame, QUICFrameDeleterFunc> create();
/*
* Returns QUICAckFrame only if ACK frame need to be sent,
- * because sending an ACK frame per incoming ACK-able packet isn't sufficient.
+ * because sending an ACK only packet against an ACK only packet is prohibited.
* Caller must send the ACK frame to the peer if it was returned.
*/
std::unique_ptr<QUICAckFrame, QUICFrameDeleterFunc> create_if_needed();
private:
- bool _can_send = false;
+ bool _can_send = false;
+ bool _should_send = false;
QUICAckPacketNumbers _packet_numbers;
uint16_t _packet_count = 0;
diff --git a/iocore/net/quic/QUICFrameTransmitter.h b/iocore/net/quic/QUICFrameTransmitter.h
index 07d7825..e3143d1 100644
--- a/iocore/net/quic/QUICFrameTransmitter.h
+++ b/iocore/net/quic/QUICFrameTransmitter.h
@@ -33,6 +33,6 @@ public:
*
* This schedules QUIC_PACKET_WRITE_READY event.
*/
- virtual void transmit_frame(QUICFrameUPtr frame) = 0;
+ virtual void transmit_frame(QUICFrameUPtr frame = QUICFrameUPtr(nullptr, &QUICFrameDeleter::delete_null_frame)) = 0;
virtual uint32_t maximum_stream_frame_data_size() = 0;
};
--
To stop receiving notification emails like this one, please contact
"commits@trafficserver.apache.org" <co...@trafficserver.apache.org>.
[trafficserver] 02/02: Translate the pseudo code for congestion
control to C++
Posted by ma...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
maskit pushed a commit to branch quic-latest
in repository https://gitbox.apache.org/repos/asf/trafficserver.git
commit c644c6c1c46f7c5dd17ca89c7312260f9ef632f6
Author: Masakazu Kitajo <ma...@apache.org>
AuthorDate: Fri Dec 22 11:04:58 2017 +0900
Translate the pseudo code for congestion control to C++
---
iocore/net/P_QUICNetVConnection.h | 1 -
iocore/net/QUICNetVConnection.cc | 1 -
iocore/net/quic/QUICCongestionController.cc | 70 ++++++++++++++++-------------
iocore/net/quic/QUICCongestionController.h | 45 -------------------
iocore/net/quic/QUICFrameDispatcher.cc | 5 ---
iocore/net/quic/QUICLossDetector.cc | 21 +++++----
iocore/net/quic/QUICLossDetector.h | 43 ++++++++++++------
7 files changed, 81 insertions(+), 105 deletions(-)
diff --git a/iocore/net/P_QUICNetVConnection.h b/iocore/net/P_QUICNetVConnection.h
index 4f4ba37..3f9d1c2 100644
--- a/iocore/net/P_QUICNetVConnection.h
+++ b/iocore/net/P_QUICNetVConnection.h
@@ -54,7 +54,6 @@
#include "quic/QUICAckFrameCreator.h"
#include "quic/QUICLossDetector.h"
#include "quic/QUICStreamManager.h"
-#include "quic/QUICCongestionController.h"
#include "quic/QUICApplicationMap.h"
// These are included here because older OpenQUIC libraries don't have them.
diff --git a/iocore/net/QUICNetVConnection.cc b/iocore/net/QUICNetVConnection.cc
index 1581332..124a292 100644
--- a/iocore/net/QUICNetVConnection.cc
+++ b/iocore/net/QUICNetVConnection.cc
@@ -116,7 +116,6 @@ QUICNetVConnection::start(SSL_CTX *ssl_ctx)
this->_frame_dispatcher->add_handler(this);
this->_frame_dispatcher->add_handler(this->_stream_manager);
- this->_frame_dispatcher->add_handler(this->_congestion_controller);
this->_frame_dispatcher->add_handler(this->_loss_detector);
}
diff --git a/iocore/net/quic/QUICCongestionController.cc b/iocore/net/quic/QUICCongestionController.cc
index 3ce8e76..d06c090 100644
--- a/iocore/net/quic/QUICCongestionController.cc
+++ b/iocore/net/quic/QUICCongestionController.cc
@@ -22,55 +22,63 @@
*/
#include <ts/Diags.h>
-#include <QUICCongestionController.h>
+#include <QUICLossDetector.h>
-static constexpr char tag[] = "quic_congestion_controller";
+// 4.7.1. Constants of interest
+constexpr static uint16_t DEFAULT_MSS = 1460;
+constexpr static uint32_t INITIAL_WINDOW = 10 * DEFAULT_MSS;
+constexpr static uint32_t MINIMUM_WINDOW = 2 * DEFAULT_MSS;
+constexpr static double LOSS_REDUCTION_FACTOR = 0.5;
-std::vector<QUICFrameType>
-QUICCongestionController::interests()
+QUICCongestionController::QUICCongestionController()
{
- return {QUICFrameType::ACK, QUICFrameType::STREAM};
-}
-
-QUICErrorUPtr
-QUICCongestionController::handle_frame(std::shared_ptr<const QUICFrame> frame)
-{
- QUICErrorUPtr error = QUICErrorUPtr(new QUICNoError());
-
- switch (frame->type()) {
- case QUICFrameType::STREAM:
- case QUICFrameType::ACK:
- break;
- default:
- Debug(tag, "Unexpected frame type: %02x", static_cast<unsigned int>(frame->type()));
- ink_assert(false);
- break;
- }
-
- return error;
+ this->_congestion_window = INITIAL_WINDOW;
}
void
-QUICCongestionController::on_packet_sent(size_t sent_bytes)
+QUICCongestionController::on_packet_sent(size_t bytes_sent)
{
+ this->_bytes_in_flight += bytes_sent;
}
void
-QUICCongestionController::on_packet_acked(QUICPacketNumber acked_packet_number)
+QUICCongestionController::on_packet_acked(QUICPacketNumber acked_packet_number, size_t acked_packet_size)
{
+ // Remove from bytes_in_flight.
+ this->_bytes_in_flight -= acked_packet_size;
+ if (acked_packet_number < this->_end_of_recovery) {
+ // Do not increase congestion window in recovery period.
+ return;
+ }
+ if (this->_congestion_window < this->_ssthresh) {
+ // Slow start.
+ this->_congestion_window += acked_packet_size;
+ } else {
+ // Congestion avoidance.
+ this->_congestion_window += DEFAULT_MSS * acked_packet_size / this->_congestion_window;
+ }
}
void
-QUICCongestionController::on_packets_lost(std::set<QUICPacketNumber> packets)
+QUICCongestionController::on_packets_lost(std::map<QUICPacketNumber, PacketInfo &> lost_packets)
{
+ // Remove lost packets from bytes_in_flight.
+ for (auto &lost_packet : lost_packets) {
+ this->_bytes_in_flight -= lost_packet.second.bytes;
+ }
+ QUICPacketNumber largest_lost_packet = lost_packets.rbegin()->first;
+ // Start a new recovery epoch if the lost packet is larger
+ // than the end of the previous recovery epoch.
+ if (this->_end_of_recovery < largest_lost_packet) {
+ this->_end_of_recovery = largest_lost_packet;
+ this->_congestion_window *= LOSS_REDUCTION_FACTOR;
+ this->_congestion_window = std::max(this->_congestion_window, MINIMUM_WINDOW);
+ this->_ssthresh = this->_congestion_window;
+ }
}
void
QUICCongestionController::on_retransmission_timeout_verified()
{
-}
-
-void
-QUICCongestionController::on_rto_verified()
-{
+ this->_congestion_window = MINIMUM_WINDOW;
}
diff --git a/iocore/net/quic/QUICCongestionController.h b/iocore/net/quic/QUICCongestionController.h
deleted file mode 100644
index 79cb96a..0000000
--- a/iocore/net/quic/QUICCongestionController.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/** @file
- *
- * A brief file description
- *
- * @section license License
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you 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.
- */
-
-#pragma once
-
-#include <set>
-#include "QUICTypes.h"
-#include "QUICFrameHandler.h"
-
-// TODO Implement congestion controll.
-// Congestion controller will be required after the 2nd implementation draft.
-class QUICCongestionController : public QUICFrameHandler
-{
-public:
- virtual std::vector<QUICFrameType> interests() override;
- virtual QUICErrorUPtr handle_frame(std::shared_ptr<const QUICFrame>) override;
-
- void on_packet_sent(size_t sent_bytes);
- void on_packet_acked(QUICPacketNumber acked_packet_number);
- virtual void on_packets_lost(std::set<QUICPacketNumber> packets);
- void on_rto_verified();
- void on_retransmission_timeout_verified();
-
-private:
-};
diff --git a/iocore/net/quic/QUICFrameDispatcher.cc b/iocore/net/quic/QUICFrameDispatcher.cc
index c23fff1..b4582b9 100644
--- a/iocore/net/quic/QUICFrameDispatcher.cc
+++ b/iocore/net/quic/QUICFrameDispatcher.cc
@@ -22,11 +22,6 @@
*/
#include "QUICFrameDispatcher.h"
-#include "QUICConnection.h"
-#include "QUICStreamManager.h"
-#include "QUICCongestionController.h"
-#include "QUICLossDetector.h"
-#include "QUICEvents.h"
#include "QUICDebugNames.h"
static constexpr char tag[] = "quic_frame_handler";
diff --git a/iocore/net/quic/QUICLossDetector.cc b/iocore/net/quic/QUICLossDetector.cc
index 7edd181..f99fc32 100644
--- a/iocore/net/quic/QUICLossDetector.cc
+++ b/iocore/net/quic/QUICLossDetector.cc
@@ -169,7 +169,10 @@ QUICLossDetector::_on_ack_received(const std::shared_ptr<const QUICAckFrame> &ac
// Find all newly acked packets.
for (auto acked_packet_number : this->_determine_newly_acked_packets(*ack_frame)) {
- this->_on_packet_acked(acked_packet_number);
+ auto pi = this->_sent_packets.find(acked_packet_number);
+ if (pi != this->_sent_packets.end()) {
+ this->_on_packet_acked(pi->first, pi->second->bytes);
+ }
}
QUICLDDebug("Unacked packets %lu (retransmittable %u, includes %u handshake packets)", this->_sent_packets.size(),
@@ -208,11 +211,11 @@ QUICLossDetector::_update_rtt(ink_hrtime latest_rtt, ink_hrtime ack_delay, QUICP
}
void
-QUICLossDetector::_on_packet_acked(QUICPacketNumber acked_packet_number)
+QUICLossDetector::_on_packet_acked(QUICPacketNumber acked_packet_number, size_t acked_packet_size)
{
SCOPED_MUTEX_LOCK(lock, this->mutex, this_ethread());
- QUICLDDebug("Packet number %" PRIu64 " has been acked", acked_packet_number);
- this->_cc->on_packet_acked(acked_packet_number);
+ // QUICLDDebug("Packet number %" PRIu64 " has been acked", acked_packet_number);
+ this->_cc->on_packet_acked(acked_packet_number, acked_packet_size);
// If a packet sent prior to RTO was acked, then the RTO
// was spurious. Otherwise, inform congestion control.
if (this->_rto_count > 0 && acked_packet_number > this->_largest_sent_before_rto) {
@@ -309,7 +312,7 @@ QUICLossDetector::_detect_lost_packets(QUICPacketNumber largest_acked_packet_num
{
SCOPED_MUTEX_LOCK(lock, this->mutex, this_ethread());
this->_loss_time = 0;
- std::set<QUICPacketNumber> lost_packets;
+ std::map<QUICPacketNumber, PacketInfo &> lost_packets;
double delay_until_lost = INFINITY;
if (this->_time_loss_detection) {
@@ -326,9 +329,9 @@ QUICLossDetector::_detect_lost_packets(QUICPacketNumber largest_acked_packet_num
ink_hrtime time_since_sent = Thread::get_hrtime() - unacked.second->time;
uint64_t packet_delta = largest_acked_packet_number - unacked.second->packet_number;
if (time_since_sent > delay_until_lost) {
- lost_packets.insert(unacked.first);
+ lost_packets.insert({unacked.first, *unacked.second});
} else if (packet_delta > this->_reordering_threshold) {
- lost_packets.insert(unacked.first);
+ lost_packets.insert({unacked.first, *unacked.second});
} else if (this->_loss_time == 0 && delay_until_lost != INFINITY) {
this->_loss_time = Thread::get_hrtime() + delay_until_lost - time_since_sent;
}
@@ -338,8 +341,8 @@ QUICLossDetector::_detect_lost_packets(QUICPacketNumber largest_acked_packet_num
// lets it decide whether to retransmit immediately.
if (!lost_packets.empty()) {
this->_cc->on_packets_lost(lost_packets);
- for (auto packet_number : lost_packets) {
- this->_remove_from_sent_packet_list(packet_number);
+ for (auto lost_packet : lost_packets) {
+ this->_remove_from_sent_packet_list(lost_packet.first);
}
}
}
diff --git a/iocore/net/quic/QUICLossDetector.h b/iocore/net/quic/QUICLossDetector.h
index e67598b..94b707d 100644
--- a/iocore/net/quic/QUICLossDetector.h
+++ b/iocore/net/quic/QUICLossDetector.h
@@ -31,13 +31,39 @@
#include "../../eventsystem/I_Action.h"
#include "ts/ink_hrtime.h"
#include "I_VConnection.h"
-#include "P_Net.h"
#include "QUICTypes.h"
#include "QUICPacket.h"
#include "QUICFrame.h"
#include "QUICFrameHandler.h"
#include "QUICPacketTransmitter.h"
-#include "QUICCongestionController.h"
+
+struct PacketInfo {
+ QUICPacketNumber packet_number;
+ ink_hrtime time;
+ bool ack_only;
+ bool handshake;
+ size_t bytes;
+ QUICPacketUPtr packet;
+};
+
+class QUICCongestionController
+{
+public:
+ QUICCongestionController();
+ virtual ~QUICCongestionController() {}
+
+ void on_packet_sent(size_t bytes_sent);
+ void on_packet_acked(QUICPacketNumber acked_packet_number, size_t acked_packet_size);
+ virtual void on_packets_lost(std::map<QUICPacketNumber, PacketInfo &> packets);
+ void on_retransmission_timeout_verified();
+
+private:
+ // 4.7.2. Variables of interest
+ uint32_t _bytes_in_flight = 0;
+ uint32_t _congestion_window = 0;
+ QUICPacketNumber _end_of_recovery = 0;
+ uint32_t _ssthresh = UINT32_MAX;
+};
class QUICLossDetector : public Continuation, public QUICFrameHandler
{
@@ -54,16 +80,7 @@ public:
private:
QUICConnectionId _connection_id = 0;
- struct PacketInfo {
- QUICPacketNumber packet_number;
- ink_hrtime time;
- bool ack_only;
- bool handshake;
- size_t bytes;
- QUICPacketUPtr packet;
- };
-
- bool _time_loss_detection = false;
+ bool _time_loss_detection = true;
// TODO QUICCongestionController *cc = nullptr;
@@ -103,7 +120,7 @@ private:
void _on_packet_sent(QUICPacketNumber packet_number, bool is_ack_only, bool is_handshake, size_t sent_bytes,
QUICPacketUPtr packet);
void _on_ack_received(const std::shared_ptr<const QUICAckFrame> &ack_frame);
- void _on_packet_acked(QUICPacketNumber acked_packet_number);
+ void _on_packet_acked(QUICPacketNumber acked_packet_number, size_t acked_packet_size);
void _update_rtt(ink_hrtime latest_rtt, ink_hrtime ack_delay, QUICPacketNumber largest_acked);
void _detect_lost_packets(QUICPacketNumber largest_acked);
void _set_loss_detection_alarm();
--
To stop receiving notification emails like this one, please contact
"commits@trafficserver.apache.org" <co...@trafficserver.apache.org>.