grpc 1.76.0 → 1.78.0.pre1

data/src/core/ext/transport/chttp2/transport/flow_control.h

@@ -23,14 +23,12 @@
 #include <limits.h>
 #include <stdint.h>
 
+#include <algorithm>
 #include <iosfwd>
 #include <optional>
 #include <string>
 #include <utility>
 
-#include "absl/functional/function_ref.h"
-#include "absl/status/status.h"
-#include "absl/strings/string_view.h"
 #include "src/core/channelz/property_list.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings_manager.h"
@@ -39,12 +37,11 @@
 #include "src/core/lib/transport/bdp_estimator.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/time.h"
-
-namespace grpc {
-namespace testing {
-class TrickledCHTTP2;  // to make this a friend
-}  // namespace testing
-}  // namespace grpc
+#include "absl/functional/function_ref.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 namespace chttp2 {
@@ -59,11 +56,18 @@ static constexpr const uint32_t kMaxInitialWindowSize = (1u << 30);
 static constexpr const int64_t kMaxWindowDelta = (1u << 20);
 static constexpr const int kDefaultPreferredRxCryptoFrameSize = INT_MAX;
 
+// TODO(tjagtap) [PH2][P2][BDP] Remove this static sleep when the BDP code is
+// done. This needs to be dynamic.
+constexpr Duration kFlowControlPeriodicUpdateTimer = Duration::Seconds(8);
+
 class TransportFlowControl;
 class StreamFlowControl;
 
 enum class StallEdge { kNoChange, kStalled, kUnstalled };
 
+#define GRPC_HTTP2_FLOW_CONTROL_DLOG \
+  DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
+
 // Encapsulates a collections of actions the transport needs to take with
 // regard to flow control. Each action comes with urgencies that tell the
 // transport how quickly the action must take place.
@@ -72,10 +76,10 @@ class GRPC_MUST_USE_RESULT FlowControlAction {
   enum class Urgency : uint8_t {
     // Nothing to be done.
     NO_ACTION_NEEDED = 0,
-    // Initiate a write to update the initial window immediately.
+    // Initiate a write to send updates immediately.
     UPDATE_IMMEDIATELY,
-    // Push the flow control update into a send buffer, to be sent
-    // out the next time a write is initiated.
+    // Queue the flow control update, to be sent out the next time a write is
+    // initiated.
     QUEUE_UPDATE,
   };
 
@@ -90,6 +94,8 @@ class GRPC_MUST_USE_RESULT FlowControlAction {
   Urgency preferred_rx_crypto_frame_size_update() const {
     return preferred_rx_crypto_frame_size_update_;
   }
+
+  // Returns true if any action has UPDATE_IMMEDIATELY urgency.
   bool AnyUpdateImmediately() const {
     return send_stream_update_ == Urgency::UPDATE_IMMEDIATELY ||
            send_transport_update_ == Urgency::UPDATE_IMMEDIATELY ||
@@ -99,12 +105,56 @@ class GRPC_MUST_USE_RESULT FlowControlAction {
                Urgency::UPDATE_IMMEDIATELY;
   }
 
+  std::string ImmediateUpdateReasons() const;
+
+  // Returns the value of SETTINGS_INITIAL_WINDOW_SIZE that we will send to the
+  // peer.
   uint32_t initial_window_size() const { return initial_window_size_; }
+  // Returns the value of SETTINGS_MAX_FRAME_SIZE that we will send to the peer.
   uint32_t max_frame_size() const { return max_frame_size_; }
+  // Returns the value of GRPC_PREFERRED_RECEIVE_CRYPTO_FRAME_SIZE that we will
+  // send to the peer.
   uint32_t preferred_rx_crypto_frame_size() const {
     return preferred_rx_crypto_frame_size_;
   }
 
+  FlowControlAction& test_only_set_send_initial_window_update(Urgency u,
+                                                              uint32_t update) {
+    return set_send_initial_window_update(u, update);
+  }
+  FlowControlAction& test_only_set_send_max_frame_size_update(Urgency u,
+                                                              uint32_t update) {
+    return set_send_max_frame_size_update(u, update);
+  }
+  FlowControlAction& test_only_set_preferred_rx_crypto_frame_size_update(
+      Urgency u, uint32_t update) {
+    return set_preferred_rx_crypto_frame_size_update(u, update);
+  }
+
+  static const char* UrgencyString(Urgency u);
+  std::string DebugString() const;
+
+  void AssertEmpty() { GRPC_CHECK(*this == FlowControlAction()); }
+
+  bool operator==(const FlowControlAction& other) const {
+    return send_stream_update_ == other.send_stream_update_ &&
+           send_transport_update_ == other.send_transport_update_ &&
+           send_initial_window_update_ == other.send_initial_window_update_ &&
+           send_max_frame_size_update_ == other.send_max_frame_size_update_ &&
+           (send_initial_window_update_ == Urgency::NO_ACTION_NEEDED ||
+            initial_window_size_ == other.initial_window_size_) &&
+           (send_max_frame_size_update_ == Urgency::NO_ACTION_NEEDED ||
+            max_frame_size_ == other.max_frame_size_) &&
+           (preferred_rx_crypto_frame_size_update_ ==
+                Urgency::NO_ACTION_NEEDED ||
+            preferred_rx_crypto_frame_size_ ==
+                other.preferred_rx_crypto_frame_size_);
+  }
+
+ private:
+  friend class StreamFlowControl;
+  friend class TransportFlowControl;
+
   FlowControlAction& set_send_stream_update(Urgency u) {
     send_stream_update_ = u;
     return *this;
@@ -132,27 +182,6 @@ class GRPC_MUST_USE_RESULT FlowControlAction {
     return *this;
   }
 
-  static const char* UrgencyString(Urgency u);
-  std::string DebugString() const;
-
-  void AssertEmpty() { GRPC_CHECK(*this == FlowControlAction()); }
-
-  bool operator==(const FlowControlAction& other) const {
-    return send_stream_update_ == other.send_stream_update_ &&
-           send_transport_update_ == other.send_transport_update_ &&
-           send_initial_window_update_ == other.send_initial_window_update_ &&
-           send_max_frame_size_update_ == other.send_max_frame_size_update_ &&
-           (send_initial_window_update_ == Urgency::NO_ACTION_NEEDED ||
-            initial_window_size_ == other.initial_window_size_) &&
-           (send_max_frame_size_update_ == Urgency::NO_ACTION_NEEDED ||
-            max_frame_size_ == other.max_frame_size_) &&
-           (preferred_rx_crypto_frame_size_update_ ==
-                Urgency::NO_ACTION_NEEDED ||
-            preferred_rx_crypto_frame_size_ ==
-                other.preferred_rx_crypto_frame_size_);
-  }
-
- private:
   Urgency send_stream_update_ = Urgency::NO_ACTION_NEEDED;
   Urgency send_transport_update_ = Urgency::NO_ACTION_NEEDED;
   Urgency send_initial_window_update_ = Urgency::NO_ACTION_NEEDED;
@@ -168,6 +197,7 @@ std::ostream& operator<<(std::ostream& out, const FlowControlAction& action);
 
 // Implementation of flow control that abides to HTTP/2 spec and attempts
 // to be as performant as possible.
+// This class manages the flow control at a connection level.
 class TransportFlowControl final {
  public:
   explicit TransportFlowControl(absl::string_view name, bool enable_bdp_probe,
@@ -176,16 +206,19 @@ class TransportFlowControl final {
 
   bool bdp_probe() const { return enable_bdp_probe_; }
 
-  // returns an announce if we should send a transport update to our peer,
-  // else returns zero; writing_anyway indicates if a write would happen
+  // Returns a non-zero announce if we should send a transport update to our
+  // peer, else returns zero; writing_anyway indicates if a write would happen
   // regardless of the send - if it is false and this function returns non-zero,
-  // this announce will cause a write to occur
+  // the caller can send a flow control update.
   uint32_t DesiredAnnounceSize(bool writing_anyway) const;
-  // notify that we've actually sent a stream window update
-  // (should be DesiredAnnounceSize())
+
+  // Call to update transport flow control state after sending a transport
+  // WINDOW_UPDATE with `announce` size. `announce` should be value returned
+  // by `DesiredAnnounceSize`.
   void SentUpdate(uint32_t announce);
 
-  // Older API: combines getting the DesiredAnnounceSize() with SentUpdate()
+  // Convenience method that combines `DesiredAnnounceSize` and `SentUpdate`.
+  // Call to get window increment and update state in one go.
   uint32_t MaybeSendUpdate(bool writing_anyway) {
     uint32_t n = DesiredAnnounceSize(writing_anyway);
     SentUpdate(n);
@@ -193,8 +226,8 @@ class TransportFlowControl final {
   }
 
   // Track an update to the incoming flow control counters - that is how many
-  // tokens we report to our peer that we're willing to accept.
-  // Instantiators *must* call MakeAction before destruction of this value.
+  // tokens we report to our peer for the data that we are willing to accept.
+  // Instantiators *must* call MakeAction before destruction of this object.
   class IncomingUpdateContext {
    public:
     explicit IncomingUpdateContext(TransportFlowControl* tfc) : tfc_(tfc) {}
@@ -202,19 +235,32 @@ class TransportFlowControl final {
 
     IncomingUpdateContext(const IncomingUpdateContext&) = delete;
     IncomingUpdateContext& operator=(const IncomingUpdateContext&) = delete;
+    IncomingUpdateContext(IncomingUpdateContext&&) = delete;
+    IncomingUpdateContext& operator=(IncomingUpdateContext&&) = delete;
 
     // Reads the flow control data and returns an actionable struct that will
-    // tell chttp2 exactly what it needs to do
+    // tell the transport exactly what it needs to do.
     FlowControlAction MakeAction() {
       return std::exchange(tfc_, nullptr)->UpdateAction(FlowControlAction());
     }
 
-    // Notify of data receipt. Returns OkStatus if the data was accepted,
-    // else an error status if the connection should be closed.
+    // We have received data from the wire.
+    // We check if this data is within our flow control limits or not.
+    // If it exceeds the limit, we send an error.
+    // RFC9113 : A receiver MAY respond with a stream error or connection
+    // error of type FLOW_CONTROL_ERROR if it is unable to accept a frame.
+    //
+    // This function updates transport window for received data.
+    // Call this ONLY IF stream is not available (e.g. already closed) AND
+    // transport window must be updated to remain in sync with peer.
+    // If stream IS available, call RecvData() on
+    // StreamFlowControl::IncomingUpdateContext instead.
     absl::Status RecvData(
         int64_t incoming_frame_size, absl::FunctionRef<absl::Status()> stream =
                                          []() { return absl::OkStatus(); });
 
+   private:
+    friend class StreamFlowControl;
     // Update a stream announce window delta, keeping track of how much total
     // positive delta is present on the transport.
     void UpdateAnnouncedWindowDelta(int64_t* delta, int64_t change) {
@@ -228,7 +274,6 @@ class TransportFlowControl final {
       }
     }
 
-   private:
     TransportFlowControl* tfc_;
   };
 
@@ -237,9 +282,14 @@ class TransportFlowControl final {
   class OutgoingUpdateContext {
    public:
     explicit OutgoingUpdateContext(TransportFlowControl* tfc) : tfc_(tfc) {}
-    void StreamSentData(int64_t size) { tfc_->remote_window_ -= size; }
 
-    // we have received a WINDOW_UPDATE frame for a transport
+    OutgoingUpdateContext(const OutgoingUpdateContext&) = delete;
+    OutgoingUpdateContext& operator=(const OutgoingUpdateContext&) = delete;
+    OutgoingUpdateContext(OutgoingUpdateContext&&) = delete;
+    OutgoingUpdateContext& operator=(OutgoingUpdateContext&&) = delete;
+
+    // Call this function when a transport-level WINDOW_UPDATE frame is received
+    // from peer to increase remote window.
     void RecvUpdate(uint32_t size) { tfc_->remote_window_ += size; }
 
     // Finish the update and check whether we became stalled or unstalled.
@@ -253,29 +303,37 @@ class TransportFlowControl final {
     }
 
    private:
+    friend class StreamFlowControl;
+    void StreamSentData(int64_t size) { tfc_->remote_window_ -= size; }
+
     TransportFlowControl* tfc_;
     const bool was_stalled_ = tfc_->remote_window_ <= 0;
   };
 
   // Call periodically (at a low-ish rate, 100ms - 10s makes sense)
   // to perform more complex flow control calculations and return an action
-  // to let chttp2 change its parameters
+  // to let the transport change its parameters.
+  // TODO(tjagtap) [PH2][P2] Plumb with PH2 flow control.
   FlowControlAction PeriodicUpdate();
 
-  int64_t target_window() const;
-  int64_t target_frame_size() const { return target_frame_size_; }
-  int64_t target_preferred_rx_crypto_frame_size() const {
-    return target_preferred_rx_crypto_frame_size_;
+  int64_t test_only_target_window() const { return target_window(); }
+  int64_t test_only_target_frame_size() const { return target_frame_size(); }
+  int64_t test_only_target_preferred_rx_crypto_frame_size() const {
+    return target_preferred_rx_crypto_frame_size();
   }
 
   BdpEstimator* bdp_estimator() { return &bdp_estimator_; }
 
-  uint32_t acked_init_window() const { return acked_init_window_; }
-  uint32_t queued_init_window() const { return target_initial_window_size_; }
-  uint32_t sent_init_window() const { return sent_init_window_; }
+  uint32_t test_only_acked_init_window() const { return acked_init_window(); }
+  uint32_t test_only_sent_init_window() const { return sent_init_window(); }
 
+  // Call after you prepare and queue a settings frame to send to the peer.
   void FlushedSettings() { sent_init_window_ = queued_init_window(); }
 
+  // Updates the initial window size that we have acknowledged from the peer.
+  // This affects stream-level flow control for data received from the peer.
+  // If the new value differs from target_initial_window_size_, we return an
+  // action to send an update to the peer with our target.
   FlowControlAction SetAckedInitialWindow(uint32_t value);
 
   void set_target_initial_window_size(uint32_t value) {
@@ -285,16 +343,10 @@ class TransportFlowControl final {
 
   // Getters
   int64_t remote_window() const { return remote_window_; }
-  int64_t announced_window() const { return announced_window_; }
-
-  int64_t announced_stream_total_over_incoming_window() const {
-    return announced_stream_total_over_incoming_window_;
-  }
+  int64_t test_only_announced_window() const { return announced_window(); }
 
-  void RemoveAnnouncedWindowDelta(int64_t delta) {
-    if (delta > 0) {
-      announced_stream_total_over_incoming_window_ -= delta;
-    }
+  int64_t test_only_announced_stream_total_over_incoming_window() const {
+    return announced_stream_total_over_incoming_window();
   }
 
   // A snapshot of the flow control stats to export.
@@ -353,7 +405,28 @@ class TransportFlowControl final {
   }
 
  private:
+  friend class StreamFlowControl;
+
+  void RemoveAnnouncedWindowDelta(int64_t delta) {
+    if (delta > 0) {
+      announced_stream_total_over_incoming_window_ -= delta;
+    }
+  }
+
   double TargetInitialWindowSizeBasedOnMemoryPressureAndBdp() const;
+  int64_t target_window() const;
+  int64_t target_frame_size() const { return target_frame_size_; }
+  int64_t target_preferred_rx_crypto_frame_size() const {
+    return target_preferred_rx_crypto_frame_size_;
+  }
+  uint32_t acked_init_window() const { return acked_init_window_; }
+  uint32_t queued_init_window() const { return target_initial_window_size_; }
+  uint32_t sent_init_window() const { return sent_init_window_; }
+  int64_t announced_window() const { return announced_window_; }
+  int64_t announced_stream_total_over_incoming_window() const {
+    return announced_stream_total_over_incoming_window_;
+  }
+
   static void UpdateSetting(absl::string_view name, int64_t* desired_value,
                             uint32_t new_desired_value,
                             FlowControlAction* action,
@@ -407,20 +480,50 @@ class StreamFlowControl final {
     explicit IncomingUpdateContext(StreamFlowControl* sfc)
         : tfc_upd_(sfc->tfc_), sfc_(sfc) {}
 
+    IncomingUpdateContext(const IncomingUpdateContext&) = delete;
+    IncomingUpdateContext& operator=(const IncomingUpdateContext&) = delete;
+    IncomingUpdateContext(IncomingUpdateContext&&) = delete;
+    IncomingUpdateContext& operator=(IncomingUpdateContext&&) = delete;
+
     FlowControlAction MakeAction() {
       return sfc_->UpdateAction(tfc_upd_.MakeAction());
     }
 
-    // we have received data from the wire
+    // We have received data from the wire.
+    // We check if this data is within our flow control limits or not.
+    // If it exceeds the limit, we send an error.
+    // RFC9113 : A receiver MAY respond with a stream error or connection
+    // error of type FLOW_CONTROL_ERROR if it is unable to accept a frame.
+    //
+    // Updates stream and transport window for received data on an active
+    // stream. Calling this updates BOTH windows; do not call
+    // TransportFlowControl::IncomingUpdateContext::RecvData() separately.
     absl::Status RecvData(int64_t incoming_frame_size);
 
-    // the application is asking for a certain amount of bytes
+    // Informs flow control that the application needs at least
+    // `min_progress_size` bytes to make progress on reading the current stream.
+    // An example usage of this would be, say we receive the first 1000 bytes of
+    // a 2000 byte gRPC message, we can call SetMinProgressSize(1000)
+    // TODO(tjagtap) [PH2][P2] Plumb with PH2 flow control.
     void SetMinProgressSize(int64_t min_progress_size) {
       sfc_->min_progress_size_ = min_progress_size;
     }
 
+    // Informs flow control that `pending_size` bytes are buffered and waiting
+    // for application to read. Call this when a complete message is assembled
+    // but not yet pulled by the application. This helps flow control decide
+    // whether to send a WINDOW_UPDATE to the peer.
+    // TODO(tjagtap) [PH2][P1] Plumb with PH2 flow control.
     void SetPendingSize(int64_t pending_size);
 
+    // This is a hack in place till SetPendingSize is fully plumbed. This hack
+    // function just pretends that the application needs more bytes. Since we
+    // dont actually know how many bytes the application needs, we just want to
+    // refill the used up tokens. The only way to refill used up tokens is to
+    // call this function for each DATA frame.
+    // TODO(tjagtap) [PH2][P1] Remove hack after SetPendingSize is plumbed.
+    void HackIncrementPendingSize(int64_t pending_size);
+
    private:
     TransportFlowControl::IncomingUpdateContext tfc_upd_;
     StreamFlowControl* const sfc_;
@@ -432,10 +535,18 @@ class StreamFlowControl final {
    public:
     explicit OutgoingUpdateContext(StreamFlowControl* sfc)
         : tfc_upd_(sfc->tfc_), sfc_(sfc) {}
-    // we have received a WINDOW_UPDATE frame for a stream
+
+    OutgoingUpdateContext(const OutgoingUpdateContext&) = delete;
+    OutgoingUpdateContext& operator=(const OutgoingUpdateContext&) = delete;
+    OutgoingUpdateContext(OutgoingUpdateContext&&) = delete;
+    OutgoingUpdateContext& operator=(OutgoingUpdateContext&&) = delete;
+
+    // Call this when a WINDOW_UPDATE frame is received from peer for this
+    // stream, to increase send window.
     void RecvUpdate(uint32_t size) { sfc_->remote_window_delta_ += size; }
-    // we have sent data on the wire, we must track this in our bookkeeping for
-    // the remote peer's flow control.
+
+    // Call this after sending a DATA frame for this stream, to decrease send
+    // window based on `outgoing_frame_size`.
     void SentData(int64_t outgoing_frame_size) {
       tfc_upd_.StreamSentData(outgoing_frame_size);
       sfc_->remote_window_delta_ -= outgoing_frame_size;
@@ -446,14 +557,17 @@ class StreamFlowControl final {
     StreamFlowControl* const sfc_;
   };
 
-  // returns an announce if we should send a stream update to our peer, else
-  // returns zero
+  // Returns a non-zero announce if we should send a stream update to our
+  // peer, else returns zero;
   uint32_t DesiredAnnounceSize() const;
-  // notify that we've actually sent a stream window update
-  // (should be DesiredAnnounceSize())
+
+  // Call after sending stream-level WINDOW_UPDATE to peer to update internal
+  // state. Argument should be value previously returned by
+  // `DesiredAnnounceSize`.
   void SentUpdate(uint32_t announce);
 
-  // Older API: combines getting the DesiredAnnounceSize() with SentUpdate()
+  // Convenience method that combines `DesiredAnnounceSize` and `SentUpdate`.
+  // Call to get window increment and update state in one go.
   uint32_t MaybeSendUpdate() {
     uint32_t n = DesiredAnnounceSize();
     SentUpdate(n);
@@ -461,8 +575,10 @@ class StreamFlowControl final {
   }
 
   int64_t remote_window_delta() const { return remote_window_delta_; }
-  int64_t announced_window_delta() const { return announced_window_delta_; }
-  int64_t min_progress_size() const { return min_progress_size_; }
+  int64_t test_only_announced_window_delta() const {
+    return announced_window_delta_;
+  }
+  int64_t test_only_min_progress_size() const { return min_progress_size_; }
 
   // A snapshot of the flow control stats to export.
   struct Stats {
@@ -476,13 +592,32 @@ class StreamFlowControl final {
 
   Stats stats() const {
     Stats stats;
-    stats.min_progress_size = min_progress_size();
+    stats.min_progress_size = min_progress_size_;
     stats.remote_window_delta = remote_window_delta();
-    stats.announced_window_delta = announced_window_delta();
+    stats.announced_window_delta = announced_window_delta_;
     stats.pending_size = pending_size_;
     return stats;
   }
 
+  void ReportIfStalled(bool is_client, uint32_t stream_id,
+                       const Http2Settings& peer_settings) const {
+    if (remote_window_delta() + peer_settings.initial_window_size() <= 0 ||
+        tfc_->remote_window_ == 0) {
+      GRPC_HTTP2_FLOW_CONTROL_DLOG
+          << "PH2 " << (is_client ? "CLIENT" : "SERVER")
+          << " Flow Control Stalled :"
+          << " Settings { peer initial window size="
+          << peer_settings.initial_window_size()
+          << "}, Transport {remote_window=" << tfc_->remote_window()
+          << ", transport announced_window=" << tfc_->announced_window()
+          << "}, Stream {stream_id=" << stream_id
+          << ", remote_window_delta=" << remote_window_delta()
+          << ", remote_window_delta() + peer_settings.initial_window_size() ="
+          << (remote_window_delta() + peer_settings.initial_window_size())
+          << " }";
+    }
+  }
+
  private:
   TransportFlowControl* const tfc_;
   int64_t min_progress_size_ = 0;

data/src/core/ext/transport/chttp2/transport/flow_control_manager.h

@@ -19,13 +19,15 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FLOW_CONTROL_MANAGER_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FLOW_CONTROL_MANAGER_H
 
+#include <algorithm>
 #include <cstdint>
 #include <vector>
 
-#include "absl/container/flat_hash_map.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/container/flat_hash_map.h"
 
 namespace grpc_core {
 namespace http2 {
@@ -34,6 +36,10 @@ constexpr chttp2::FlowControlAction::Urgency kNoActionNeeded =
     chttp2::FlowControlAction::Urgency::NO_ACTION_NEEDED;
 constexpr chttp2::FlowControlAction::Urgency kUpdateImmediately =
     chttp2::FlowControlAction::Urgency::UPDATE_IMMEDIATELY;
+constexpr int64_t kZero = 0;
+
+#define GRPC_HTTP2_FLOW_CONTROL_HELPERS \
+  DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
 
 // Function to update local settings based on FlowControlAction.
 // This function does the settings related tasks equivalent to
@@ -54,6 +60,45 @@ inline void ActOnFlowControlActionSettings(
   }
 }
 
+// RFC9113 : A sender MUST NOT allow a flow-control window to exceed ((2^31)-1)
+// octets. If a sender receives a WINDOW_UPDATE that causes a flow-control
+// window to exceed this maximum, it MUST terminate either the stream or the
+// connection, as appropriate.
+// While the return value is int64_t for compatibility with CHTTP2 flow control,
+// we dont expect this value to exceed ((2^31)-1) i.e kMaxSize31Bit
+inline int64_t GetStreamFlowControlTokens(
+    chttp2::StreamFlowControl& stream_flow_control,
+    const Http2Settings& peer_settings) {
+  GRPC_DCHECK(stream_flow_control.remote_window_delta() +
+                  peer_settings.initial_window_size() <=
+              RFC9113::kMaxSize31Bit);
+  return std::max(kZero, stream_flow_control.remote_window_delta() +
+                             peer_settings.initial_window_size());
+}
+
+inline uint32_t GetMaxPermittedDequeue(
+    chttp2::TransportFlowControl& transport_flow_control,
+    chttp2::StreamFlowControl& stream_flow_control, const size_t upper_limit,
+    const Http2Settings& peer_settings) {
+  const int64_t flow_control_tokens =
+      std::min(transport_flow_control.remote_window(),
+               GetStreamFlowControlTokens(stream_flow_control, peer_settings));
+  uint32_t max_dequeue = 0;
+  if (flow_control_tokens > 0) {
+    max_dequeue = static_cast<uint32_t>(
+        std::min({static_cast<size_t>(flow_control_tokens), upper_limit,
+                  static_cast<size_t>(RFC9113::kMaxSize31Bit - 1)}));
+  }
+  GRPC_HTTP2_FLOW_CONTROL_HELPERS
+      << "GetFlowControlTokens flow_control_tokens = " << flow_control_tokens
+      << " upper_limit = " << upper_limit << " max_dequeue = " << max_dequeue;
+  return max_dequeue;
+}
+
+// TODO(tjagtap) [PH2][P4] : Ensure that the total transport flow control window
+// or stream flow control window does not exceed the max permitted limit of
+// 2^31-1
+
 }  // namespace http2
 }  // namespace grpc_core