lib/mvfst
1
0
Fork 0
mirror of https://github.com/facebookincubator/mvfst.git synced 2025-08-08 09:42:06 +03:00
Code Activity

Move some maps/sets structures to F14 maps and sets.

Browse Source 
Summary:
F14 should be faster and have lower memory urilization for near-empty sets and maps. For most H3 connections these are mosotly going to be near-empty, so CPU wins will likely be minimal.

For usecases that have extremely high numbers of streams, there are likely going to be CPU wins.

Reviewed By: yangchi

Differential Revision: D18484047

fbshipit-source-id: 7f5616d6d6c8651ca5b03468d7d8895d1f51cb53
This commit is contained in:
Matt Joras
2019-11-18 10:27:38 -08:00
committed by Facebook Github Bot
parent 8155d1340d
commit 61004ba72c
8 changed files with 49 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
quic/api/QuicTransportBase.cpp
View File

@@ -2365,7 +2365,7 @@ void QuicTransportBase::cancelDeliveryCallbacks(
} }
void QuicTransportBase::cancelDeliveryCallbacks( void QuicTransportBase::cancelDeliveryCallbacks(
const std::unordered_map< const folly::F14FastMap<
StreamId, StreamId,
std::deque<std::pair<uint64_t, QuicSocket::DeliveryCallback*>>>& std::deque<std::pair<uint64_t, QuicSocket::DeliveryCallback*>>>&
deliveryCallbacks) { deliveryCallbacks) {

18
quic/api/QuicTransportBase.h
View File

@@ -246,7 +246,7 @@ class QuicTransportBase : public QuicSocket {
* callbacks of the transport, so there is no need to erase anything from it. * callbacks of the transport, so there is no need to erase anything from it.
*/ */
static void cancelDeliveryCallbacks( static void cancelDeliveryCallbacks(
const std::unordered_map< const folly::F14FastMap<
StreamId, StreamId,
std::deque<std::pair<uint64_t, QuicSocket::DeliveryCallback*>>>& std::deque<std::pair<uint64_t, QuicSocket::DeliveryCallback*>>>&
deliveryCallbacks); deliveryCallbacks);
@@ -588,15 +588,13 @@ class QuicTransportBase : public QuicSocket {
DataRejectedCallbackData(DataRejectedCallback* cb) : dataRejectedCb(cb) {} DataRejectedCallbackData(DataRejectedCallback* cb) : dataRejectedCb(cb) {}
}; };
// Map of streamID to tupl folly::F14FastMap<StreamId, ReadCallbackData> readCallbacks_;
std::unordered_map<StreamId, ReadCallbackData> readCallbacks_; folly::F14FastMap<StreamId, PeekCallbackData> peekCallbacks_;
std::unordered_map<StreamId, PeekCallbackData> peekCallbacks_; folly::
std::unordered_map< F14FastMap<StreamId, std::deque<std::pair<uint64_t, DeliveryCallback*>>>
StreamId, deliveryCallbacks_;
std::deque<std::pair<uint64_t, DeliveryCallback*>>> folly::F14FastMap<StreamId, DataExpiredCallbackData> dataExpiredCallbacks_;
deliveryCallbacks_; folly::F14FastMap<StreamId, DataRejectedCallbackData> dataRejectedCallbacks_;
std::unordered_map<StreamId, DataExpiredCallbackData> dataExpiredCallbacks_;
std::unordered_map<StreamId, DataRejectedCallbackData> dataRejectedCallbacks_;
PingCallback* pingCallback_; PingCallback* pingCallback_;
WriteCallback* connWriteCallback_{nullptr}; WriteCallback* connWriteCallback_{nullptr};

14
quic/api/test/QuicTransportBaseTest.cpp
View File

@@ -1077,7 +1077,7 @@ TEST_F(QuicTransportImplTest, CancelAllDeliveryCallbacksDeque) {
TEST_F(QuicTransportImplTest, CancelAllDeliveryCallbacksMap) { TEST_F(QuicTransportImplTest, CancelAllDeliveryCallbacksMap) {
MockDeliveryCallback mockedDeliveryCallback1, mockedDeliveryCallback2; MockDeliveryCallback mockedDeliveryCallback1, mockedDeliveryCallback2;
std::unordered_map< folly::F14FastMap<
StreamId, StreamId,
std::deque<std::pair<uint64_t, QuicSocket::DeliveryCallback*>>> std::deque<std::pair<uint64_t, QuicSocket::DeliveryCallback*>>>
callbacks; callbacks;
@@ -1137,8 +1137,6 @@ TEST_F(QuicTransportImplTest, DeliveryCallbackUnsetOne) {
} }
TEST_F(QuicTransportImplTest, DeliveryCallbackOnSendDataExpire) { TEST_F(QuicTransportImplTest, DeliveryCallbackOnSendDataExpire) {
InSequence enforceOrder;
transport->transportConn->partialReliabilityEnabled = true; transport->transportConn->partialReliabilityEnabled = true;
auto stream1 = transport->createBidirectionalStream().value(); auto stream1 = transport->createBidirectionalStream().value();
@@ -1165,8 +1163,6 @@ TEST_F(QuicTransportImplTest, DeliveryCallbackOnSendDataExpire) {
} }
TEST_F(QuicTransportImplTest, DeliveryCallbackOnSendDataExpireCallbacksLeft) { TEST_F(QuicTransportImplTest, DeliveryCallbackOnSendDataExpireCallbacksLeft) {
InSequence enforceOrder;
transport->transportConn->partialReliabilityEnabled = true; transport->transportConn->partialReliabilityEnabled = true;
auto stream1 = transport->createBidirectionalStream().value(); auto stream1 = transport->createBidirectionalStream().value();
@@ -1645,8 +1641,6 @@ TEST_F(QuicTransportImplTest, IsBidirectionalStream) {
} }
TEST_F(QuicTransportImplTest, PeekCallbackDataAvailable) { TEST_F(QuicTransportImplTest, PeekCallbackDataAvailable) {
InSequence enforceOrder;
auto stream1 = transport->createBidirectionalStream().value(); auto stream1 = transport->createBidirectionalStream().value();
auto stream2 = transport->createBidirectionalStream().value(); auto stream2 = transport->createBidirectionalStream().value();
@@ -2282,8 +2276,6 @@ TEST_F(QuicTransportImplTest, DataRejecteddCallbackDataAvailable) {
} }
TEST_F(QuicTransportImplTest, DataRejecteddCallbackWithDeliveryCallbacks) { TEST_F(QuicTransportImplTest, DataRejecteddCallbackWithDeliveryCallbacks) {
InSequence enforceOrder;
transport->transportConn->partialReliabilityEnabled = true; transport->transportConn->partialReliabilityEnabled = true;
auto stream1 = transport->createBidirectionalStream().value(); auto stream1 = transport->createBidirectionalStream().value();
@@ -2328,8 +2320,6 @@ TEST_F(QuicTransportImplTest, DataRejecteddCallbackWithDeliveryCallbacks) {
TEST_F( TEST_F(
QuicTransportImplTest, QuicTransportImplTest,
DataRejecteddCallbackWithDeliveryCallbacksSomeLeft) { DataRejecteddCallbackWithDeliveryCallbacksSomeLeft) {
InSequence enforceOrder;
transport->transportConn->partialReliabilityEnabled = true; transport->transportConn->partialReliabilityEnabled = true;
auto stream1 = transport->createBidirectionalStream().value(); auto stream1 = transport->createBidirectionalStream().value();
@@ -2368,8 +2358,8 @@ TEST_F(
Mock::VerifyAndClearExpectations(&dcb2); Mock::VerifyAndClearExpectations(&dcb2);
Mock::VerifyAndClearExpectations(&dataRejectedCb2); Mock::VerifyAndClearExpectations(&dataRejectedCb2);
EXPECT_CALL(dcb2, onCanceled(stream2, 29)).Times(1);
EXPECT_CALL(dcb1, onCanceled(stream1, 25)).Times(1); EXPECT_CALL(dcb1, onCanceled(stream1, 25)).Times(1);
EXPECT_CALL(dcb2, onCanceled(stream2, 29)).Times(1);
transport->close(folly::none); transport->close(folly::none);
} }

8
quic/client/test/QuicClientTransportTest.cpp
View File

@@ -95,15 +95,11 @@ class TestingQuicClientTransport : public QuicClientTransport {
return *dynamic_cast<QuicClientConnectionState*>(conn_.get()); return *dynamic_cast<QuicClientConnectionState*>(conn_.get());
} }
const std::unordered_map<StreamId, ReadCallbackData>& getReadCallbacks() const auto& getReadCallbacks() const {
const {
return readCallbacks_; return readCallbacks_;
} }
const std::unordered_map< const auto& getDeliveryCallbacks() const {
StreamId,
std::deque<std::pair<uint64_t, QuicSocket::DeliveryCallback*>>>&
getDeliveryCallbacks() const {
return deliveryCallbacks_; return deliveryCallbacks_;
} }

4
quic/state/QuicStreamManager.cpp
View File

@@ -432,10 +432,10 @@ void QuicStreamManager::removeClosedStream(StreamId streamId) {
} }
void QuicStreamManager::updateLossStreams(QuicStreamState& stream) { void QuicStreamManager::updateLossStreams(QuicStreamState& stream) {
auto it = std::find(lossStreams_.begin(), lossStreams_.end(), stream.id); auto it = lossStreams_.find(stream.id);
if (!stream.lossBuffer.empty()) { if (!stream.lossBuffer.empty()) {
if (it == lossStreams_.end()) { if (it == lossStreams_.end()) {
lossStreams_.push_back(stream.id); lossStreams_.insert(stream.id);
} }
} else if (it != lossStreams_.end()) { } else if (it != lossStreams_.end()) {
lossStreams_.erase(it); lossStreams_.erase(it);

62
quic/state/QuicStreamManager.h
View File

@@ -202,7 +202,7 @@ class QuicStreamManager {
} }
void addLoss(StreamId streamId) { void addLoss(StreamId streamId) {
lossStreams_.push_back(streamId); lossStreams_.insert(streamId);
} }
bool hasLoss() const { bool hasLoss() const {
@@ -750,47 +750,47 @@ class QuicStreamManager {
// A map of streams that are active. // A map of streams that are active.
folly::F14NodeMap<StreamId, QuicStreamState> streams_; folly::F14NodeMap<StreamId, QuicStreamState> streams_;
std::deque<StreamId> newPeerStreams_; std::vector<StreamId> newPeerStreams_;
// List of streams that have pending reads // Map of streams that were blocked
std::set<StreamId> readableStreams_; folly::F14FastMap<StreamId, StreamDataBlockedFrame> blockedStreams_;
// List of streams that have pending peeks // Map of streams where the peer was asked to stop sending
std::set<StreamId> peekableStreams_; folly::F14FastMap<StreamId, ApplicationErrorCode> stopSendingStreams_;
// List of !control streams that have writable data // Set of streams that have expired data
std::set<StreamId> writableStreams_; folly::F14FastSet<StreamId> dataExpiredStreams_;
// List of control streams that have writable data // Set of streams that have rejected data
std::set<StreamId> writableControlStreams_; folly::F14FastSet<StreamId> dataRejectedStreams_;
// List of streams that were blocked
std::unordered_map<StreamId, StreamDataBlockedFrame> blockedStreams_;
// List of streams where the peer was asked to stop sending
std::unordered_map<StreamId, ApplicationErrorCode> stopSendingStreams_;
// List of streams that have expired data
std::set<StreamId> dataExpiredStreams_;
// List of streams that have rejected data
std::set<StreamId> dataRejectedStreams_;
// Streams that may be able to callback DeliveryCallback
std::set<StreamId> deliverableStreams_;
// Streams that had their stream window change and potentially need a window // Streams that had their stream window change and potentially need a window
// update sent // update sent
std::unordered_set<StreamId> windowUpdates_; folly::F14FastSet<StreamId> windowUpdates_;
// Streams that had their flow control updated // Streams that had their flow control updated
std::set<StreamId> flowControlUpdated_; folly::F14FastSet<StreamId> flowControlUpdated_;
// Streams that are closed but we still have state for
std::set<StreamId> closedStreams_;
// Data structure to keep track of stream that have detected lost data // Data structure to keep track of stream that have detected lost data
std::vector<StreamId> lossStreams_; folly::F14FastSet<StreamId> lossStreams_;
// Set of streams that have pending reads
folly::F14FastSet<StreamId> readableStreams_;
// Set of streams that have pending peeks
folly::F14FastSet<StreamId> peekableStreams_;
// Set of !control streams that have writable data
std::set<StreamId> writableStreams_;
// Set of control streams that have writable data
std::set<StreamId> writableControlStreams_;
// Streams that may be able to callback DeliveryCallback
folly::F14FastSet<StreamId> deliverableStreams_;
// Streams that are closed but we still have state for
folly::F14FastSet<StreamId> closedStreams_;
// Record whether or not we are app-idle. // Record whether or not we are app-idle.
bool isAppIdle_{false}; bool isAppIdle_{false};

7
quic/state/StateData.h
View File

@@ -29,11 +29,8 @@
#include <quic/state/TransportSettings.h> #include <quic/state/TransportSettings.h>
#include <chrono> #include <chrono>
#include <list> #include <list>
#include <map>
#include <numeric> #include <numeric>
#include <queue> #include <queue>
#include <set>
#include <unordered_map>
namespace quic { namespace quic {
@@ -375,7 +372,7 @@ struct RstStreamEvent {
ApplicationErrorCode errorCode; ApplicationErrorCode errorCode;
}; };
using Resets = std::unordered_map<StreamId, RstStreamFrame>; using Resets = folly::F14FastMap<StreamId, RstStreamFrame>;
using FrameList = std::vector<QuicSimpleFrame>; using FrameList = std::vector<QuicSimpleFrame>;
@@ -489,7 +486,7 @@ struct QuicConnectionStateBase {
// associatedEvent or if it's not in this set, there is no need to process its // associatedEvent or if it's not in this set, there is no need to process its
// frames upon ack or loss. // frames upon ack or loss.
// TODO: Enforce only AppTraffic packets to be clonable // TODO: Enforce only AppTraffic packets to be clonable
std::set<PacketEvent> outstandingPacketEvents; folly::F14FastSet<PacketEvent> outstandingPacketEvents;
// Number of pure ack packets outstanding. // Number of pure ack packets outstanding.
uint64_t outstandingPureAckPacketsCount{0}; uint64_t outstandingPureAckPacketsCount{0};

2
quic/state/test/QuicStreamFunctionsTest.cpp
View File

@@ -1540,7 +1540,7 @@ TEST_F(QuicStreamFunctionsTest, RemovedClosedState) {
TEST_F(QuicServerStreamFunctionsTest, ServerGetClientQuicStream) { TEST_F(QuicServerStreamFunctionsTest, ServerGetClientQuicStream) {
StreamId clientStream = 0x10; StreamId clientStream = 0x10;
std::deque<StreamId> newStreams = {0x0, 0x4, 0x8, 0xc, 0x10}; std::vector<StreamId> newStreams = {0x0, 0x4, 0x8, 0xc, 0x10};
EXPECT_EQ(conn.streamManager->getStream(clientStream)->id, clientStream); EXPECT_EQ(conn.streamManager->getStream(clientStream)->id, clientStream);
EXPECT_EQ(conn.streamManager->streamCount(), 1); EXPECT_EQ(conn.streamManager->streamCount(), 1);
EXPECT_EQ(conn.streamManager->openBidirectionalPeerStreams().size(), 5); EXPECT_EQ(conn.streamManager->openBidirectionalPeerStreams().size(), 5);