zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removes clock from TransportFeedbackAdapter.

Browse Source 
Instead timestamps required for processing are provided explicitly.
This makes it easier to ensure correct usage in log processing
and simulation.

Bug: webrtc:10170
Change-Id: I724a6b9b94e83caa22b8e43b63ef4e6b46138e6a
Reviewed-on: https://webrtc-review.googlesource.com/c/118702
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26339}
This commit is contained in:
Sebastian Jansson
2019-01-21 13:07:47 +01:00
committed by Commit Bot
parent 805a27e134
commit 05acd2b76f
11 changed files with 85 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
call/rtp_transport_controller_send.cc
View File

@ -65,7 +65,6 @@ RtpTransportControllerSend::RtpTransportControllerSend(
bitrate_configurator_(bitrate_config),
process_thread_(ProcessThread::Create("SendControllerThread")),
observer_(nullptr),
transport_feedback_adapter_(clock_),
controller_factory_override_(controller_factory),
controller_factory_fallback_(
absl::make_unique<GoogCcNetworkControllerFactory>(event_log)),
@ -443,8 +442,9 @@ void RtpTransportControllerSend::AddPacket(uint32_t ssrc,
if (send_side_bwe_with_overhead_) {
length += transport_overhead_bytes_per_packet_;
}
transport_feedback_adapter_.AddPacket(ssrc, sequence_number, length,
pacing_info);
transport_feedback_adapter_.AddPacket(
ssrc, sequence_number, length, pacing_info,
Timestamp::ms(clock_->TimeInMilliseconds()));
}
void RtpTransportControllerSend::OnTransportFeedback(
@ -452,7 +452,8 @@ void RtpTransportControllerSend::OnTransportFeedback(
RTC_DCHECK_RUNS_SERIALIZED(&worker_race_);
absl::optional<TransportPacketsFeedback> feedback_msg =
transport_feedback_adapter_.ProcessTransportFeedback(feedback);
transport_feedback_adapter_.ProcessTransportFeedback(
feedback, Timestamp::ms(clock_->TimeInMilliseconds()));
if (feedback_msg) {
task_queue_.PostTask([this, feedback_msg]() {
RTC_DCHECK_RUN_ON(&task_queue_);

8
logging/rtc_event_log/rtc_event_log_parser.cc
View File

@ -1782,7 +1782,7 @@ const std::vector<MatchedSendArrivalTimes> GetNetworkTrace(
parsed_log.transport_feedbacks(kIncomingPacket);
SimulatedClock clock(0);
TransportFeedbackAdapter feedback_adapter(&clock);
TransportFeedbackAdapter feedback_adapter;
auto rtp_iterator = outgoing_rtp.begin();
auto rtcp_iterator = incoming_rtcp.begin();
@ -1814,7 +1814,8 @@ const std::vector<MatchedSendArrivalTimes> GetNetworkTrace(
feedback_adapter.AddPacket(
rtp_packet.rtp.header.ssrc,
rtp_packet.rtp.header.extension.transportSequenceNumber,
rtp_packet.rtp.total_length, PacedPacketInfo());
rtp_packet.rtp.total_length, PacedPacketInfo(),
Timestamp::ms(clock.TimeInMilliseconds()));
sent_packet.packet_id =
rtp_packet.rtp.header.extension.transportSequenceNumber;
sent_packet.info.included_in_feedback = true;
@ -1832,7 +1833,8 @@ const std::vector<MatchedSendArrivalTimes> GetNetworkTrace(
if (clock.TimeInMicroseconds() >= NextRtcpTime()) {
RTC_DCHECK_EQ(clock.TimeInMicroseconds(), NextRtcpTime());
feedback_adapter.ProcessTransportFeedback(
rtcp_iterator->transport_feedback);
rtcp_iterator->transport_feedback,
Timestamp::ms(clock.TimeInMilliseconds()));
std::vector<PacketFeedback> feedback =
feedback_adapter.GetTransportFeedbackVector();
SortPacketFeedbackVectorWithLoss(&feedback);

12
modules/congestion_controller/rtp/send_time_history.cc
View File

@ -16,21 +16,19 @@
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "system_wrappers/include/clock.h"
namespace webrtc {
SendTimeHistory::SendTimeHistory(const Clock* clock,
int64_t packet_age_limit_ms)
: clock_(clock), packet_age_limit_ms_(packet_age_limit_ms) {}
SendTimeHistory::SendTimeHistory(int64_t packet_age_limit_ms)
: packet_age_limit_ms_(packet_age_limit_ms) {}
SendTimeHistory::~SendTimeHistory() {}
void SendTimeHistory::AddAndRemoveOld(const PacketFeedback& packet) {
int64_t now_ms = clock_->TimeInMilliseconds();
void SendTimeHistory::AddAndRemoveOld(const PacketFeedback& packet,
int64_t at_time_ms) {
// Remove old.
while (!history_.empty() &&
now_ms - history_.begin()->second.creation_time_ms >
at_time_ms - history_.begin()->second.creation_time_ms >
packet_age_limit_ms_) {
// TODO(sprang): Warn if erasing (too many) old items?
RemovePacketBytes(history_.begin()->second);

6
modules/congestion_controller/rtp/send_time_history.h
View File

@ -19,16 +19,15 @@
#include "rtc_base/constructor_magic.h"
namespace webrtc {
class Clock;
struct PacketFeedback;
class SendTimeHistory {
public:
SendTimeHistory(const Clock* clock, int64_t packet_age_limit_ms);
explicit SendTimeHistory(int64_t packet_age_limit_ms);
~SendTimeHistory();
// Cleanup old entries, then add new packet info with provided parameters.
void AddAndRemoveOld(const PacketFeedback& packet);
void AddAndRemoveOld(const PacketFeedback& packet, int64_t at_time_ms);
void AddUntracked(size_t packet_size, int64_t send_time_ms);
@ -55,7 +54,6 @@ class SendTimeHistory {
void AddPacketBytes(const PacketFeedback& packet);
void RemovePacketBytes(const PacketFeedback& packet);
void UpdateAckedSeqNum(int64_t acked_seq_num);
const Clock* const clock_;
const int64_t packet_age_limit_ms_;
size_t pending_untracked_size_ = 0;
int64_t last_send_time_ms_ = -1;

9
modules/congestion_controller/rtp/send_time_history_unittest.cc
View File

@ -26,8 +26,7 @@ static const int kDefaultHistoryLengthMs = 1000;
class SendTimeHistoryTest : public ::testing::Test {
protected:
SendTimeHistoryTest()
: clock_(0), history_(&clock_, kDefaultHistoryLengthMs) {}
SendTimeHistoryTest() : clock_(0), history_(kDefaultHistoryLengthMs) {}
~SendTimeHistoryTest() {}
virtual void SetUp() {}
@ -40,7 +39,7 @@ class SendTimeHistoryTest : public ::testing::Test {
const PacedPacketInfo& pacing_info) {
PacketFeedback packet(clock_.TimeInMilliseconds(), sequence_number, length,
0, 0, pacing_info);
history_.AddAndRemoveOld(packet);
history_.AddAndRemoveOld(packet, clock_.TimeInMilliseconds());
history_.OnSentPacket(sequence_number, send_time_ms);
}
@ -54,7 +53,7 @@ TEST_F(SendTimeHistoryTest, SaveAndRestoreNetworkId) {
int64_t now_ms = clock_.TimeInMilliseconds();
for (int i = 1; i < 5; ++i) {
PacketFeedback packet(now_ms, sequence_number, 1000, i, i - 1, kPacingInfo);
history_.AddAndRemoveOld(packet);
history_.AddAndRemoveOld(packet, clock_.TimeInMilliseconds());
history_.OnSentPacket(sequence_number, now_ms);
PacketFeedback restored(now_ms, sequence_number);
EXPECT_TRUE(history_.GetFeedback(&restored, sequence_number++));
@ -139,7 +138,7 @@ TEST_F(SendTimeHistoryTest, AddThenRemoveOutOfOrder) {
PacketFeedback packet = sent_packets[i];
packet.arrival_time_ms = PacketFeedback::kNotReceived;
packet.send_time_ms = PacketFeedback::kNoSendTime;
history_.AddAndRemoveOld(packet);
history_.AddAndRemoveOld(packet, clock_.TimeInMilliseconds());
}
for (size_t i = 0; i < num_items; ++i)
history_.OnSentPacket(sent_packets[i].sequence_number,

51
modules/congestion_controller/rtp/transport_feedback_adapter.cc
View File

@ -49,9 +49,8 @@ const int64_t kBaseTimestampScaleFactor =
rtcp::TransportFeedback::kDeltaScaleFactor * (1 << 8);
const int64_t kBaseTimestampRangeSizeUs = kBaseTimestampScaleFactor * (1 << 24);
TransportFeedbackAdapter::TransportFeedbackAdapter(const Clock* clock)
: send_time_history_(clock, kSendTimeHistoryWindowMs),
clock_(clock),
TransportFeedbackAdapter::TransportFeedbackAdapter()
: send_time_history_(kSendTimeHistoryWindowMs),
current_offset_ms_(kNoTimestamp),
last_timestamp_us_(kNoTimestamp),
local_net_id_(0),
@ -82,13 +81,14 @@ void TransportFeedbackAdapter::DeRegisterPacketFeedbackObserver(
void TransportFeedbackAdapter::AddPacket(uint32_t ssrc,
uint16_t sequence_number,
size_t length,
const PacedPacketInfo& pacing_info) {
const PacedPacketInfo& pacing_info,
Timestamp creation_time) {
{
rtc::CritScope cs(&lock_);
const int64_t creation_time_ms = clock_->TimeInMilliseconds();
send_time_history_.AddAndRemoveOld(
PacketFeedback(creation_time_ms, sequence_number, length, local_net_id_,
remote_net_id_, pacing_info));
PacketFeedback(creation_time.ms(), sequence_number, length,
local_net_id_, remote_net_id_, pacing_info),
creation_time.ms());
}
{
@ -98,7 +98,6 @@ void TransportFeedbackAdapter::AddPacket(uint32_t ssrc,
}
}
}
absl::optional<SentPacket> TransportFeedbackAdapter::ProcessSentPacket(
const rtc::SentPacket& sent_packet) {
rtc::CritScope cs(&lock_);
@ -127,10 +126,19 @@ absl::optional<SentPacket> TransportFeedbackAdapter::ProcessSentPacket(
absl::optional<TransportPacketsFeedback>
TransportFeedbackAdapter::ProcessTransportFeedback(
const rtcp::TransportFeedback& feedback) {
int64_t feedback_time_ms = clock_->TimeInMilliseconds();
const rtcp::TransportFeedback& feedback,
Timestamp feedback_receive_time) {
DataSize prior_in_flight = GetOutstandingData();
OnTransportFeedback(feedback);
last_packet_feedback_vector_ =
GetPacketFeedbackVector(feedback, feedback_receive_time);
{
rtc::CritScope cs(&observers_lock_);
for (auto* observer : observers_) {
observer->OnPacketFeedbackVector(last_packet_feedback_vector_);
}
}
std::vector<PacketFeedback> feedback_vector = last_packet_feedback_vector_;
if (feedback_vector.empty())
return absl::nullopt;
@ -155,7 +163,7 @@ TransportFeedbackAdapter::ProcessTransportFeedback(
if (first_unacked_send_time_ms)
msg.first_unacked_send_time = Timestamp::ms(*first_unacked_send_time_ms);
}
msg.feedback_time = Timestamp::ms(feedback_time_ms);
msg.feedback_time = feedback_receive_time;
msg.prior_in_flight = prior_in_flight;
msg.data_in_flight = GetOutstandingData();
return msg;
@ -174,14 +182,15 @@ DataSize TransportFeedbackAdapter::GetOutstandingData() const {
}
std::vector<PacketFeedback> TransportFeedbackAdapter::GetPacketFeedbackVector(
const rtcp::TransportFeedback& feedback) {
const rtcp::TransportFeedback& feedback,
Timestamp feedback_time) {
int64_t timestamp_us = feedback.GetBaseTimeUs();
int64_t now_ms = clock_->TimeInMilliseconds();
// Add timestamp deltas to a local time base selected on first packet arrival.
// This won't be the true time base, but makes it easier to manually inspect
// time stamps.
if (last_timestamp_us_ == kNoTimestamp) {
current_offset_ms_ = now_ms;
current_offset_ms_ = feedback_time.ms();
} else {
int64_t delta = timestamp_us - last_timestamp_us_;
@ -246,19 +255,9 @@ std::vector<PacketFeedback> TransportFeedbackAdapter::GetPacketFeedbackVector(
return packet_feedback_vector;
}
void TransportFeedbackAdapter::OnTransportFeedback(
const rtcp::TransportFeedback& feedback) {
last_packet_feedback_vector_ = GetPacketFeedbackVector(feedback);
{
rtc::CritScope cs(&observers_lock_);
for (auto* observer : observers_) {
observer->OnPacketFeedbackVector(last_packet_feedback_vector_);
}
}
}
std::vector<PacketFeedback>
TransportFeedbackAdapter::GetTransportFeedbackVector() const {
return last_packet_feedback_vector_;
}
} // namespace webrtc

13
modules/congestion_controller/rtp/transport_feedback_adapter.h
View File

@ -20,7 +20,6 @@
#include "rtc_base/network/sent_packet.h"
#include "rtc_base/thread_annotations.h"
#include "rtc_base/thread_checker.h"
#include "system_wrappers/include/clock.h"
namespace webrtc {
@ -32,7 +31,7 @@ class TransportFeedback;
class TransportFeedbackAdapter {
public:
explicit TransportFeedbackAdapter(const Clock* clock);
TransportFeedbackAdapter();
virtual ~TransportFeedbackAdapter();
void RegisterPacketFeedbackObserver(PacketFeedbackObserver* observer);
@ -41,13 +40,15 @@ class TransportFeedbackAdapter {
void AddPacket(uint32_t ssrc,
uint16_t sequence_number,
size_t length,
const PacedPacketInfo& pacing_info);
const PacedPacketInfo& pacing_info,
Timestamp creation_time);
absl::optional<SentPacket> ProcessSentPacket(
const rtc::SentPacket& sent_packet);
absl::optional<TransportPacketsFeedback> ProcessTransportFeedback(
const rtcp::TransportFeedback& feedback);
const rtcp::TransportFeedback& feedback,
Timestamp feedback_time);
std::vector<PacketFeedback> GetTransportFeedbackVector() const;
@ -59,11 +60,11 @@ class TransportFeedbackAdapter {
void OnTransportFeedback(const rtcp::TransportFeedback& feedback);
std::vector<PacketFeedback> GetPacketFeedbackVector(
const rtcp::TransportFeedback& feedback);
const rtcp::TransportFeedback& feedback,
Timestamp feedback_time);
rtc::CriticalSection lock_;
SendTimeHistory send_time_history_ RTC_GUARDED_BY(&lock_);
const Clock* const clock_;
int64_t current_offset_ms_;
int64_t last_timestamp_us_;
std::vector<PacketFeedback> last_packet_feedback_vector_;

34
modules/congestion_controller/rtp/transport_feedback_adapter_unittest.cc
View File

@ -52,9 +52,7 @@ class TransportFeedbackAdapterTest : public ::testing::Test {
virtual ~TransportFeedbackAdapterTest() {}
virtual void SetUp() {
adapter_.reset(new TransportFeedbackAdapter(&clock_));
}
virtual void SetUp() { adapter_.reset(new TransportFeedbackAdapter()); }
virtual void TearDown() { adapter_.reset(); }
@ -68,7 +66,8 @@ class TransportFeedbackAdapterTest : public ::testing::Test {
void OnSentPacket(const PacketFeedback& packet_feedback) {
adapter_->AddPacket(kSsrc, packet_feedback.sequence_number,
packet_feedback.payload_size,
packet_feedback.pacing_info);
packet_feedback.pacing_info,
Timestamp::ms(clock_.TimeInMilliseconds()));
adapter_->ProcessSentPacket(rtc::SentPacket(packet_feedback.sequence_number,
packet_feedback.send_time_ms,
rtc::PacketInfo()));
@ -101,7 +100,8 @@ TEST_F(TransportFeedbackAdapterTest, ObserverSanity) {
}
EXPECT_CALL(mock, OnPacketFeedbackVector(_)).Times(1);
adapter_->ProcessTransportFeedback(feedback);
adapter_->ProcessTransportFeedback(
feedback, Timestamp::ms(clock_.TimeInMilliseconds()));
adapter_->DeRegisterPacketFeedbackObserver(&mock);
@ -116,7 +116,8 @@ TEST_F(TransportFeedbackAdapterTest, ObserverSanity) {
EXPECT_TRUE(feedback.AddReceivedPacket(new_packet.sequence_number,
new_packet.arrival_time_ms * 1000));
EXPECT_CALL(mock, OnPacketFeedbackVector(_)).Times(0);
adapter_->ProcessTransportFeedback(second_feedback);
adapter_->ProcessTransportFeedback(
second_feedback, Timestamp::ms(clock_.TimeInMilliseconds()));
}
#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
@ -157,7 +158,8 @@ TEST_F(TransportFeedbackAdapterTest, AdaptsFeedbackAndPopulatesSendTimes) {
feedback.Build();
adapter_->ProcessTransportFeedback(feedback);
adapter_->ProcessTransportFeedback(
feedback, Timestamp::ms(clock_.TimeInMilliseconds()));
ComparePacketFeedbackVectors(packets, adapter_->GetTransportFeedbackVector());
}
@ -190,7 +192,8 @@ TEST_F(TransportFeedbackAdapterTest, FeedbackVectorReportsUnreceived) {
feedback.Build();
adapter_->ProcessTransportFeedback(feedback);
adapter_->ProcessTransportFeedback(
feedback, Timestamp::ms(clock_.TimeInMilliseconds()));
ComparePacketFeedbackVectors(sent_packets,
adapter_->GetTransportFeedbackVector());
}
@ -234,7 +237,8 @@ TEST_F(TransportFeedbackAdapterTest, HandlesDroppedPackets) {
expected_packets[i].pacing_info = PacedPacketInfo();
}
adapter_->ProcessTransportFeedback(feedback);
adapter_->ProcessTransportFeedback(
feedback, Timestamp::ms(clock_.TimeInMilliseconds()));
ComparePacketFeedbackVectors(expected_packets,
adapter_->GetTransportFeedbackVector());
}
@ -270,7 +274,8 @@ TEST_F(TransportFeedbackAdapterTest, SendTimeWrapsBothWays) {
std::vector<PacketFeedback> expected_packets;
expected_packets.push_back(packets[i]);
adapter_->ProcessTransportFeedback(*feedback.get());
adapter_->ProcessTransportFeedback(
*feedback.get(), Timestamp::ms(clock_.TimeInMilliseconds()));
ComparePacketFeedbackVectors(expected_packets,
adapter_->GetTransportFeedbackVector());
}
@ -299,7 +304,8 @@ TEST_F(TransportFeedbackAdapterTest, HandlesArrivalReordering) {
// Adapter keeps the packets ordered by sequence number (which is itself
// assigned by the order of transmission). Reordering by some other criteria,
// eg. arrival time, is up to the observers.
adapter_->ProcessTransportFeedback(feedback);
adapter_->ProcessTransportFeedback(
feedback, Timestamp::ms(clock_.TimeInMilliseconds()));
ComparePacketFeedbackVectors(packets, adapter_->GetTransportFeedbackVector());
}
@ -363,7 +369,8 @@ TEST_F(TransportFeedbackAdapterTest, TimestampDeltas) {
std::vector<PacketFeedback> received_feedback;
EXPECT_TRUE(feedback.get() != nullptr);
adapter_->ProcessTransportFeedback(*feedback.get());
adapter_->ProcessTransportFeedback(
*feedback.get(), Timestamp::ms(clock_.TimeInMilliseconds()));
ComparePacketFeedbackVectors(sent_packets,
adapter_->GetTransportFeedbackVector());
@ -378,7 +385,8 @@ TEST_F(TransportFeedbackAdapterTest, TimestampDeltas) {
rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size());
EXPECT_TRUE(feedback.get() != nullptr);
adapter_->ProcessTransportFeedback(*feedback.get());
adapter_->ProcessTransportFeedback(
*feedback.get(), Timestamp::ms(clock_.TimeInMilliseconds()));
{
std::vector<PacketFeedback> expected_packets;
expected_packets.push_back(packet_feedback);

5
modules/congestion_controller/transport_feedback_adapter.cc
View File

@ -31,7 +31,7 @@ const int64_t kBaseTimestampRangeSizeUs = kBaseTimestampScaleFactor * (1 << 24);
LegacyTransportFeedbackAdapter::LegacyTransportFeedbackAdapter(
const Clock* clock)
: send_time_history_(clock, kSendTimeHistoryWindowMs),
: send_time_history_(kSendTimeHistoryWindowMs),
clock_(clock),
current_offset_ms_(kNoTimestamp),
last_timestamp_us_(kNoTimestamp),
@ -70,7 +70,8 @@ void LegacyTransportFeedbackAdapter::AddPacket(
const int64_t creation_time_ms = clock_->TimeInMilliseconds();
send_time_history_.AddAndRemoveOld(
PacketFeedback(creation_time_ms, sequence_number, length, local_net_id_,
remote_net_id_, pacing_info));
remote_net_id_, pacing_info),
creation_time_ms);
}
{

5
modules/remote_bitrate_estimator/test/estimators/send_side.cc
View File

@ -41,7 +41,7 @@ SendSideBweSender::SendSideBweSender(int kbps,
bwe_(new DelayBasedBwe(&field_trial_config_, nullptr)),
feedback_observer_(bitrate_controller_.get()),
clock_(clock),
send_time_history_(clock_, 10000),
send_time_history_(10000),
has_received_ack_(false),
last_acked_seq_num_(0),
last_log_time_ms_(0) {
@ -134,7 +134,8 @@ void SendSideBweSender::OnPacketsSent(const Packets& packets) {
PacketFeedback packet_feedback(
clock_->TimeInMilliseconds(), media_packet->header().sequenceNumber,
media_packet->payload_size(), 0, 0, PacedPacketInfo());
send_time_history_.AddAndRemoveOld(packet_feedback);
send_time_history_.AddAndRemoveOld(packet_feedback,
clock_->TimeInMilliseconds());
send_time_history_.OnSentPacket(media_packet->header().sequenceNumber,
media_packet->sender_timestamp_ms());
}

8
rtc_tools/event_log_visualizer/analyzer.cc
View File

@ -1076,7 +1076,7 @@ void EventLogAnalyzer::CreateSendSideBweSimulationGraph(Plot* plot) {
RtcEventLogNullImpl null_event_log;
PacketRouter packet_router;
PacedSender pacer(&clock, &packet_router, &null_event_log);
TransportFeedbackAdapter transport_feedback(&clock);
TransportFeedbackAdapter transport_feedback;
auto factory = GoogCcNetworkControllerFactory(&null_event_log);
TimeDelta process_interval = factory.GetProcessInterval();
// TODO(holmer): Log the call config and use that here instead.
@ -1144,7 +1144,8 @@ void EventLogAnalyzer::CreateSendSideBweSimulationGraph(Plot* plot) {
transport_feedback.AddPacket(
rtp_packet.rtp.header.ssrc,
rtp_packet.rtp.header.extension.transportSequenceNumber,
rtp_packet.rtp.total_length, PacedPacketInfo());
rtp_packet.rtp.total_length, PacedPacketInfo(),
Timestamp::us(rtp_packet.rtp.log_time_us()));
rtc::SentPacket sent_packet(
rtp_packet.rtp.header.extension.transportSequenceNumber,
rtp_packet.rtp.log_time_us() / 1000);
@ -1158,7 +1159,8 @@ void EventLogAnalyzer::CreateSendSideBweSimulationGraph(Plot* plot) {
RTC_DCHECK_EQ(clock.TimeInMicroseconds(), NextRtcpTime());
auto feedback_msg = transport_feedback.ProcessTransportFeedback(
rtcp_iterator->transport_feedback);
rtcp_iterator->transport_feedback,
Timestamp::ms(clock.TimeInMilliseconds()));
absl::optional<uint32_t> bitrate_bps;
if (feedback_msg) {
observer.Update(goog_cc->OnTransportPacketsFeedback(*feedback_msg));