proxygen::Window Class Reference

#include <Window.h>

Public Member Functions
	Window (uint32_t capacity)
int32_t	getSize () const
uint32_t	getNonNegativeSize () const
uint32_t	getCapacity () const
uint32_t	getOutstanding () const
bool	reserve (uint32_t amount, bool strict=true)
bool	free (uint32_t amount)
bool	setCapacity (uint32_t capacity)

Private Attributes
int32_t	outstanding_ {0}
int32_t	capacity_ {0}

Detailed Description

A class that implements SPDY & HTTP/2 window management. This class should be used for both connection and stream level flow control.

Definition at line 20 of file Window.h.

Constructor & Destructor Documentation

proxygen::Window::Window ( uint32_t  capacity )

explicit

Constructs a new Window.

Parameters

capacity

The initial capacity of this Window. The initial size will also be equal to this. This parameter must not be > 2^31 -1

Definition at line 19 of file Window.cpp.

References setCapacity().

                                {
  CHECK(setCapacity(capacity));
}

Member Function Documentation

bool proxygen::Window::free

(

uint32_t

amount

)

Increment the window size by amount. Decrease bytes outstanding by amount. The window size could become greater than the capacity here.

Definition at line 63 of file Window.cpp.

References capacity_, int32_t, max, min, and outstanding_.

Referenced by proxygen::FlowControlFilter::ingressBytesProcessed(), proxygen::FlowControlFilter::onBody(), proxygen::HTTPTransaction::onIngressBody(), proxygen::HTTPTransaction::onIngressWindowUpdate(), proxygen::FlowControlFilter::onWindowUpdate(), proxygen::HTTPTransaction::resumeIngress(), and TEST().

                                       {
  if (amount > std::numeric_limits<int32_t>::max()) {
    VLOG(3) << "Cannot expand window by more than 2^31 - 1. "
            << "Attempted increment of " << amount;
    return false;
  }
  const int32_t limit = std::numeric_limits<int32_t>::min() +
    static_cast<int32_t>(amount);
  if (outstanding_ < 0 && limit > outstanding_) {
    VLOG(3) << "Underflow detected. Window change failed.";
    return false;
  }
  const int32_t newOutstanding = outstanding_ - amount;
  if (newOutstanding < capacity_ - std::numeric_limits<int32_t>::max()) {
    VLOG(3) << "Window exceeded 2^31 - 1. Window change failed.";
    return false;
  }
  outstanding_ = newOutstanding;
  return true;
}

uint32_t proxygen::Window::getCapacity

(

)

const

Returns the size of the initial window. That is, the total number of bytes allowed to be outstanding on this window.

Definition at line 32 of file Window.cpp.

References capacity_, and uint32_t.

Referenced by proxygen::HTTPTransaction::flushWindowUpdate(), proxygen::FlowControlFilter::ingressBytesProcessed(), proxygen::HTTPTransaction::onIngressBody(), proxygen::HTTPTransaction::onIngressSetSendWindow(), proxygen::HTTPTransaction::onIngressWindowUpdate(), proxygen::HTTPTransaction::processIngressBody(), proxygen::HTTPTransaction::sendBodyNow(), proxygen::HTTPTransaction::setReceiveWindow(), proxygen::FlowControlFilter::setReceiveWindowSize(), and TEST().

                                   {
  // This conversion is safe since we always ensure capacity_ > 0
  return static_cast<uint32_t>(capacity_);
}

uint32_t proxygen::Window::getNonNegativeSize

(

)

const

Returns the number of bytes available to be consumed in this window. If that number went negative somehow, this function clamps the return value to zero.

Definition at line 27 of file Window.cpp.

References getSize(), and folly::size().

Referenced by proxygen::FlowControlFilter::generateBody(), proxygen::FlowControlFilter::getAvailableSend(), and proxygen::FlowControlFilter::onWindowUpdate().

                                          {
  auto size = getSize();
  return size > 0 ? size : 0;
}

uint32_t proxygen::Window::getOutstanding

(

)

const

Returns the number of bytes reserved in this window. If multiple calls to free() caused this number to go negative, this function returns 0.

Definition at line 37 of file Window.cpp.

References outstanding_.

Referenced by proxygen::HTTPTransaction::onDelayedDestroy(), proxygen::HTTPTransaction::onIngressBody(), proxygen::HTTPTransaction::onIngressSetSendWindow(), proxygen::HTTPTransaction::onIngressWindowUpdate(), proxygen::FlowControlFilter::onWindowUpdate(), and TEST().

                                      {
  return outstanding_ < 0 ? 0 : outstanding_;
}

int32_t proxygen::Window::getSize

(

)

const

Returns the number of bytes available to be consumed in this window. This could become a negative number if the initial window is set to a smaller number.

Definition at line 23 of file Window.cpp.

References capacity_, and outstanding_.

Referenced by proxygen::HTTPTransaction::flushWindowUpdate(), proxygen::FlowControlFilter::generateBody(), getNonNegativeSize(), proxygen::HTTPTransaction::isExpectingWindowUpdate(), proxygen::HTTPTransaction::notifyTransportPendingEgress(), proxygen::FlowControlFilter::onBody(), proxygen::FlowControlFilter::onWindowUpdate(), proxygen::HTTPTransaction::sendBodyNow(), proxygen::HTTPTransaction::sendDeferredBody(), setCapacity(), TEST(), and proxygen::HTTPTransaction::updateHandlerPauseState().

                              {
  return capacity_ - outstanding_;
}

bool proxygen::Window::reserve	(	uint32_t	amount,
		bool	strict = true
	)

Parameters

amount	The amount to reduce the window size by. Increases bytes outstanding by amount.
strict	If true, reserve() will return false if there is no space remaining in the window. If false, reserve() will return true until the integer overflows.

Definition at line 41 of file Window.cpp.

References capacity_, int32_t, max, and outstanding_.

Referenced by proxygen::FlowControlFilter::generateBody(), proxygen::FlowControlFilter::onBody(), proxygen::HTTPTransaction::onIngressBody(), proxygen::HTTPTransaction::sendBodyNow(), and TEST().

                                                       {
  if (amount > std::numeric_limits<int32_t>::max()) {
    VLOG(3) << "Cannot shrink window by more than 2^31 - 1. "
            << "Attempted decrement of " << amount;
    return false;
  }
  const int32_t limit = std::numeric_limits<int32_t>::max() -
    static_cast<int32_t>(amount);
  if (outstanding_ > 0 && limit < outstanding_) {
    VLOG(3) << "Overflow detected. Window change failed.";
    return false;
  }
  const int32_t newOutstanding = outstanding_ + amount;
  if (strict && newOutstanding > capacity_) {
    VLOG(3) << "Outstanding bytes (" << newOutstanding << ") exceeded "
            << "window capacity (" << capacity_ << ")";
    return false;
  }
  outstanding_ = newOutstanding;
  return true;
}

bool proxygen::Window::setCapacity

(

uint32_t

capacity

)

Sets a new initial window size. This will also apply the delta between the current window size and the new window size. Returns false iff applying the new initial window fails.

Definition at line 84 of file Window.cpp.

References capacity_, diff(), getSize(), int32_t, max, and folly::size().

Referenced by proxygen::FlowControlFilter::FlowControlFilter(), proxygen::HTTPTransaction::onIngressSetSendWindow(), proxygen::HTTPTransaction::reset(), proxygen::HTTPTransaction::setReceiveWindow(), proxygen::FlowControlFilter::setReceiveWindowSize(), TEST(), and Window().

                                                {
  if (capacity > std::numeric_limits<int32_t>::max()) {
    VLOG(3) << "Cannot set initial window > 2^31 -1.";
    return false;
  }

  const int32_t diff = static_cast<int32_t>(capacity) - capacity_;
  if (diff > 0) {
    const int32_t size = getSize();
    if (size > 0 && diff > (std::numeric_limits<int32_t>::max() - size)) {
      VLOG(3) << "Increasing the capacity overflowed the window";
      return false;
    }
  }

  capacity_ = static_cast<int32_t>(capacity);
  return true;
}

Member Data Documentation

int32_t proxygen::Window::capacity_ {0}

private

Definition at line 81 of file Window.h.

Referenced by free(), getCapacity(), getSize(), reserve(), and setCapacity().

int32_t proxygen::Window::outstanding_ {0}

private

Definition at line 80 of file Window.h.

Referenced by free(), getOutstanding(), getSize(), and reserve().

---

The documentation for this class was generated from the following files:

• proxygen/lib/http/Window.h
• proxygen/lib/http/Window.cpp