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

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

quic/api/QuicTransportBase.cpp

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

quic/api/QuicTransportBase.h

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

quic/api/test/QuicTransportBaseTest.cpp

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

quic/client/test/QuicClientTransportTest.cpp

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

quic/state/QuicStreamManager.cpp

@@ -432,10 +432,10 @@ void QuicStreamManager::removeClosedStream(StreamId streamId) {
 }
 
 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 (it == lossStreams_.end()) {
-      lossStreams_.push_back(stream.id);
+      lossStreams_.insert(stream.id);
     }
   } else if (it != lossStreams_.end()) {
     lossStreams_.erase(it);

quic/state/QuicStreamManager.h

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

quic/state/StateData.h

@@ -29,11 +29,8 @@
 #include <quic/state/TransportSettings.h>
 #include <chrono>
 #include <list>
-#include <map>
 #include <numeric>
 #include <queue>
-#include <set>
-#include <unordered_map>
 
 namespace quic {
 
@@ -375,7 +372,7 @@ struct RstStreamEvent {
   ApplicationErrorCode errorCode;
 };
 
-using Resets = std::unordered_map<StreamId, RstStreamFrame>;
+using Resets = folly::F14FastMap<StreamId, RstStreamFrame>;
 
 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
   // frames upon ack or loss.
   // TODO: Enforce only AppTraffic packets to be clonable
-  std::set<PacketEvent> outstandingPacketEvents;
+  folly::F14FastSet<PacketEvent> outstandingPacketEvents;
 
   // Number of pure ack packets outstanding.
   uint64_t outstandingPureAckPacketsCount{0};

quic/state/test/QuicStreamFunctionsTest.cpp

@@ -1540,7 +1540,7 @@ TEST_F(QuicStreamFunctionsTest, RemovedClosedState) {
 
 TEST_F(QuicServerStreamFunctionsTest, ServerGetClientQuicStream) {
   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->streamCount(), 1);
   EXPECT_EQ(conn.streamManager->openBidirectionalPeerStreams().size(), 5);