proxygen: proxygen::HTTP2PriorityQueue Class Reference

#include <HTTP2PriorityQueue.h>

Inheritance diagram for proxygen::HTTP2PriorityQueue:

Classes
class	Node

Public Types
using	NextEgressResult = std::vector< std::pair< HTTPTransaction *, double >>

Public Types inherited from proxygen::HTTP2PriorityQueueBase
using	Handle = BaseNode *

Public Member Functions
	HTTP2PriorityQueue ()

	HTTP2PriorityQueue (const WheelTimerInstance &timeout)

void	attachThreadLocals (const WheelTimerInstance &timeout)
	class HTTP2PriorityQueue More...

void	detachThreadLocals ()

void	setMaxVirtualNodes (uint32_t maxVirtualNodes)

void	signalPendingEgress (Handle h) override

void	clearPendingEgress (Handle h) override

void	addPriorityNode (HTTPCodec::StreamID id, HTTPCodec::StreamID parent) override

void	addOrUpdatePriorityNode (HTTPCodec::StreamID id, http2::PriorityUpdate pri)

void	dropPriorityNodes ()

Handle	addTransaction (HTTPCodec::StreamID id, http2::PriorityUpdate pri, HTTPTransaction txn, bool permanent=false, uint64_t depth=nullptr) override

Handle	updatePriority (Handle handle, http2::PriorityUpdate pri, uint64_t *depth=nullptr) override

void	removeTransaction (Handle handle) override

bool	empty () const

uint64_t	numPendingEgress () const

uint64_t	numVirtualNodes () const

void	iterate (const std::function< bool(HTTPCodec::StreamID, HTTPTransaction *, double)> &fn, const std::function< bool()> &stopFn, bool all)

void	iterateBFS (const std::function< bool(HTTP2PriorityQueue &, HTTPCodec::StreamID, HTTPTransaction *, double)> &fn, const std::function< bool()> &stopFn, bool all)

void	nextEgress (NextEgressResult &result, bool spdyMode=false)

void	rebuildTree ()
	Error handling code. More...

uint32_t	getRebuildCount () const

bool	isRebuilt () const

Public Member Functions inherited from proxygen::HTTPCodec::PriorityQueue
virtual	~PriorityQueue ()

Static Public Member Functions
static void	setNodeLifetime (std::chrono::milliseconds lifetime)

Private Types
using	NodeMap = boost::intrusive::unordered_set< Node, boost::intrusive::constant_time_size< false >>

typedef boost::intrusive::link_mode< boost::intrusive::auto_unlink >	link_mode

Private Member Functions
Node *	find (HTTPCodec::StreamID id, uint64_t *depth=nullptr)

Node *	findInternal (HTTPCodec::StreamID id)

bool	allowDanglingNodes () const

void	scheduleNodeExpiration (Node *node)

void	updateEnqueuedWeight ()

Static Private Member Functions
static bool	nextEgressResult (HTTP2PriorityQueue &queue, HTTPCodec::StreamID id, HTTPTransaction *txn, double r)

Private Attributes
NodeMap::bucket_type	nodeBuckets_ [kNumBuckets]

NodeMap	nodes_

Node	root_ {*this, nullptr, 0, 1, nullptr}

uint32_t	rebuildCount_ {0}

uint64_t	activeCount_ {0}

uint32_t	maxVirtualNodes_ {50}

uint32_t	numVirtualNodes_ {0}

bool	pendingWeightChange_ {false}

WheelTimerInstance	timeout_

NextEgressResult *	nextEgressResults_ {nullptr}

Static Private Attributes
static const size_t	kNumBuckets = 100

static uint32_t	kMaxRebuilds_ = 3

static std::chrono::milliseconds	kNodeLifetime_

Detailed Description

Definition at line 59 of file HTTP2PriorityQueue.h.

Member Typedef Documentation

typedef boost::intrusive::link_mode<boost::intrusive::auto_unlink> proxygen::HTTP2PriorityQueue::link_mode

private

Definition at line 194 of file HTTP2PriorityQueue.h.

using proxygen::HTTP2PriorityQueue::NextEgressResult = std::vector<std::pair<HTTPTransaction*, double>>

Definition at line 148 of file HTTP2PriorityQueue.h.

using proxygen::HTTP2PriorityQueue::NodeMap = boost::intrusive::unordered_set< Node, boost::intrusive::constant_time_size<false>>

private

Definition at line 64 of file HTTP2PriorityQueue.h.

Constructor & Destructor Documentation

proxygen::HTTP2PriorityQueue::HTTP2PriorityQueue ( )

inline

Definition at line 70 of file HTTP2PriorityQueue.h.

       : nodes_(NodeMap::bucket_traits(nodeBuckets_, kNumBuckets)) {
     root_.setPermanent();
   }

proxygen::HTTP2PriorityQueue::HTTP2PriorityQueue ( const WheelTimerInstance & timeout )

inlineexplicit

Definition at line 75 of file HTTP2PriorityQueue.h.

       : nodes_(NodeMap::bucket_traits(nodeBuckets_, kNumBuckets)),
         timeout_(timeout) {
     root_.setPermanent();
   }

Member Function Documentation

void proxygen::HTTP2PriorityQueue::addOrUpdatePriorityNode	(	HTTPCodec::StreamID	id,
		http2::PriorityUpdate	pri
	)

Definition at line 444 of file HTTP2PriorityQueue.cpp.

References addTransaction(), find(), and updatePriority().

Referenced by proxygen::HTTPSession::onPriority(), and proxygen::HTTPSession::sendPriority().

                                                                      {
   auto handle = find(id);
   if (handle) {
     // already added
     CHECK(handle->getTransaction() == nullptr);
     updatePriority(handle, pri);
   } else {
     // brand new
     addTransaction(id, pri, nullptr, false /* not permanent */);
   }
 }

void proxygen::HTTP2PriorityQueue::addPriorityNode	(	HTTPCodec::StreamID	id,
		HTTPCodec::StreamID	parent
	)

inlineoverridevirtual

Implements proxygen::HTTPCodec::PriorityQueue.

Definition at line 95 of file HTTP2PriorityQueue.h.

References proxygen::HTTP2PriorityQueueBase::addTransaction(), and uint32_t.

                                                          {
     addTransaction(id, {(uint32_t)parent, false, 0}, nullptr, true);
   }

HTTP2PriorityQueue::Handle proxygen::HTTP2PriorityQueue::addTransaction	(	HTTPCodec::StreamID	id,
		http2::PriorityUpdate	pri,
		HTTPTransaction *	txn,
		bool	permanent = `false`,
		uint64_t *	depth = `nullptr`
	)

overridevirtual

Implements proxygen::HTTP2PriorityQueueBase.

Definition at line 458 of file HTTP2PriorityQueue.cpp.

References proxygen::HTTP2PriorityQueue::Node::convertVirtualNode(), proxygen::http2::DefaultPriority, proxygen::http2::PriorityUpdate::exclusive, find(), proxygen::HTTP2PriorityQueue::Node::getID(), maxVirtualNodes_, folly::gen::move, numVirtualNodes_, parent, pendingWeightChange_, root_, scheduleNodeExpiration(), proxygen::http2::PriorityUpdate::streamDependency, uint16_t, updatePriority(), and proxygen::http2::PriorityUpdate::weight.

Referenced by addOrUpdatePriorityNode(), and updatePriority().

                                                     {
   CHECK_NE(id, 0);
   CHECK_NE(id, pri.streamDependency) << "Tried to create a loop in the tree";
   CHECK(!txn || !permanent);
   Node *existingNode = find(id, depth);
   if (existingNode) {
     CHECK(!permanent);
     existingNode->convertVirtualNode(CHECK_NOTNULL(txn));
     updatePriority(existingNode, pri);
     return existingNode;
   }
   if (!txn) {
     if (numVirtualNodes_ >= maxVirtualNodes_) {
       return nullptr;
     }
     numVirtualNodes_++;
   }
 
   Node* parent = &root_;
   if (depth) {
     *depth = 1;
   }
   if (pri.streamDependency != 0) {
     Node* dep = find(pri.streamDependency, depth);
     if (dep == nullptr) {
       // specified a missing parent (timed out an idle node)?
       VLOG(4) << "assigning default priority to txn=" << id;
       // No point to try to instantiate one more virtual node
       // if we already reached the virtual node limit
       if (numVirtualNodes_ < maxVirtualNodes_) {
         // The parent node hasn't arrived yet. For now setting
         // its priority fields to default.
         parent = dynamic_cast<Node*>(
             addTransaction(pri.streamDependency,
                            http2::DefaultPriority,
                            nullptr,
                            permanent,
                            depth));
         CHECK_NOTNULL(parent);
         if (depth) {
           *depth += 1;
         }
       } else {
         VLOG(4) << "Virtual node limit reached, ignoring stream dependency "
                 << pri.streamDependency << " for new node ID " << id;
       }
     } else {
       parent = dep;
       if (depth) {
         *depth += 1;
       }
     }
   }
   VLOG(4) << "Adding id=" << id << " with parent=" << parent->getID() <<
     " and weight=" << ((uint16_t)pri.weight + 1);
   auto node = std::make_unique<Node>(*this, parent, id, pri.weight, txn);
   if (permanent) {
     node->setPermanent();
   } else if (!txn) {
     scheduleNodeExpiration(node.get());
   }
   auto result = parent->emplaceNode(std::move(node), pri.exclusive);
   pendingWeightChange_ = true;
   return result;
 }

bool proxygen::HTTP2PriorityQueue::allowDanglingNodes ( ) const

inlineprivate

Definition at line 175 of file HTTP2PriorityQueue.h.

Referenced by removeTransaction().

                                   {
     return timeout_ && kNodeLifetime_.count() > 0;
   }

void proxygen::HTTP2PriorityQueue::attachThreadLocals ( const WheelTimerInstance & timeout )

class HTTP2PriorityQueue

Definition at line 433 of file HTTP2PriorityQueue.cpp.

References timeout_.

Referenced by proxygen::HTTPUpstreamSession::attachThreadLocals().

                                                                              {
   timeout_ = timeout;
 }

void proxygen::HTTP2PriorityQueue::clearPendingEgress ( Handle h )

overridevirtual

Implements proxygen::HTTP2PriorityQueueBase.

Definition at line 606 of file HTTP2PriorityQueue.cpp.

References activeCount_, and pendingWeightChange_.

                                                     {
   CHECK_GT(activeCount_, 0);
   // clear does a CHECK on handle->isEnqueued()
   CHECK_NOTNULL(dynamic_cast<HTTP2PriorityQueue::Node*>(handle))
     ->clearPendingEgress();
   activeCount_--;
   pendingWeightChange_ = true;
 }

void proxygen::HTTP2PriorityQueue::detachThreadLocals ( )

Definition at line 437 of file HTTP2PriorityQueue.cpp.

References proxygen::HTTP2PriorityQueue::Node::dropPriorityNodes(), and timeout_.

Referenced by proxygen::HTTPUpstreamSession::detachThreadLocals().

                                             {
   // a bit harsh, we could cancel and reschedule the timeout
   dropPriorityNodes();
   timeout_ = WheelTimerInstance();
 }

void proxygen::HTTP2PriorityQueue::dropPriorityNodes ( )

inline

Definition at line 103 of file HTTP2PriorityQueue.h.

References proxygen::HTTP2PriorityQueueBase::addTransaction(), proxygen::HTTP2PriorityQueueBase::removeTransaction(), uint64_t, and proxygen::HTTP2PriorityQueueBase::updatePriority().

Referenced by proxygen::HTTPSession::~HTTPSession().

                            {
     root_.dropPriorityNodes();
   }

bool proxygen::HTTP2PriorityQueue::empty ( ) const

inline

Definition at line 122 of file HTTP2PriorityQueue.h.

Referenced by proxygen::HTTPSession::getNextToSend(), proxygen::HTTPSession::hasMoreWrites(), proxygen::HTTPSession::onConnectionSendWindowClosed(), proxygen::HTTPSession::scheduleWrite(), and proxygen::HTTPSession::~HTTPSession().

                      {
     return activeCount_ == 0;
   }

HTTP2PriorityQueue::Node * proxygen::HTTP2PriorityQueue::find	(	HTTPCodec::StreamID	id,
		uint64_t *	depth = `nullptr`
	)

private

Definition at line 695 of file HTTP2PriorityQueue.cpp.

References nodes_.

Referenced by addOrUpdatePriorityNode(), addTransaction(), and updatePriority().

                                                               {
   if (id == 0) {
     return nullptr;
   }
   auto it = nodes_.find(id, Node::IdHash(), Node::IdNodeEqual());
   if (it == nodes_.end()) {
     return nullptr;
   }
   if (depth) {
     *depth = it->calculateDepth();
   }
   return &(*it);
 }

Node* proxygen::HTTP2PriorityQueue::findInternal ( HTTPCodec::StreamID id )

inlineprivate

Definition at line 168 of file HTTP2PriorityQueue.h.

Referenced by iterateBFS().

                                            {
     if (id == 0) {
       return &root_;
     }
     return find(id);
   }

uint32_t proxygen::HTTP2PriorityQueue::getRebuildCount ( ) const

inline

Definition at line 160 of file HTTP2PriorityQueue.h.

160 { return rebuildCount_; }

proxygen::HTTP2PriorityQueue::rebuildCount_

uint32_t rebuildCount_

Definition: HTTP2PriorityQueue.h:410

bool proxygen::HTTP2PriorityQueue::isRebuilt ( ) const

inline

Definition at line 161 of file HTTP2PriorityQueue.h.

References uint64_t.

161 { return rebuildCount_ > 0; }

proxygen::HTTP2PriorityQueue::rebuildCount_

uint32_t rebuildCount_

Definition: HTTP2PriorityQueue.h:410

void proxygen::HTTP2PriorityQueue::iterate	(	const std::function< bool(HTTPCodec::StreamID, HTTPTransaction *, double)> &	fn,
		const std::function< bool()> &	stopFn,
		bool	all
	)

inline

Definition at line 135 of file HTTP2PriorityQueue.h.

References folly::gen::all().

                                                             {
     updateEnqueuedWeight();
     root_.iterate(fn, stopFn, all);
   }

void proxygen::HTTP2PriorityQueue::iterateBFS	(	const std::function< bool(HTTP2PriorityQueue &, HTTPCodec::StreamID, HTTPTransaction *, double)> &	fn,
		const std::function< bool()> &	stopFn,
		bool	all
	)

Definition at line 616 of file HTTP2PriorityQueue.cpp.

References folly::gen::all(), findInternal(), root_, stop(), folly::f14::swap(), proxygen::HTTP2PriorityQueue::Node::updateEnqueuedWeight(), and proxygen::HTTP2PriorityQueue::Node::visitBFS().

Referenced by proxygen::HTTPSession::resumeTransactions().

                                                {
   Node::PendingList pendingNodes{{0, &root_, 1.0}};
   Node::PendingList newPendingNodes;
   bool stop = false;
 
   updateEnqueuedWeight();
   while (!stop && !stopFn() && !pendingNodes.empty()) {
     CHECK(newPendingNodes.empty());
     while (!stop && !pendingNodes.empty()) {
       Node* node = findInternal(pendingNodes.front().id);
       if (node) {
         stop = node->visitBFS(pendingNodes.front().ratio, fn, all,
                               newPendingNodes, false /* all children */);
       }
       pendingNodes.pop_front();
     }
     std::swap(pendingNodes, newPendingNodes);
   }
 }

void proxygen::HTTP2PriorityQueue::nextEgress	(	HTTP2PriorityQueue::NextEgressResult &	result,
		bool	spdyMode = `false`
	)

Definition at line 648 of file HTTP2PriorityQueue.cpp.

References activeCount_, nextEgressResult(), nextEgressResults_, root_, stop(), folly::f14::swap(), proxygen::HTTP2PriorityQueue::Node::updateEnqueuedWeight(), and proxygen::HTTP2PriorityQueue::Node::visitBFS().

Referenced by proxygen::HTTPSession::getNextToSend().

                                               {
   struct WeightCmp {
     bool operator()(const std::pair<HTTPTransaction*, double>& t1,
                     const std::pair<HTTPTransaction*, double>& t2) {
       return t1.second > t2.second;
     }
   };
 
   result.reserve(activeCount_);
   nextEgressResults_ = &result;
 
   updateEnqueuedWeight();
   Node::PendingList pendingNodes;
   Node::PendingList pendingNodesTmp;
   pendingNodes.emplace_back(0, &root_, 1.0);
   bool stop = false;
   do {
     while (!stop && !pendingNodes.empty()) {
       Node* node = pendingNodes.front().node;
       if (node) {
         stop = node->visitBFS(pendingNodes.front().ratio, nextEgressResult,
                               false, pendingNodesTmp,
                               true /* enqueued children */);
       }
       pendingNodes.pop_front();
     }
     // In SPDY mode, we stop as soon one level of the tree produces results,
     // then normalize the ratios.
     if (spdyMode && !result.empty() && !pendingNodesTmp.empty()) {
       double totalRatio = 0;
       for (auto &txnPair: result) {
         totalRatio += txnPair.second;
       }
       CHECK_GT(totalRatio, 0);
       for (auto &txnPair: result) {
         txnPair.second = txnPair.second / totalRatio;
       }
       break;
     }
     std::swap(pendingNodes, pendingNodesTmp);
   } while (!stop && !pendingNodes.empty());
   std::sort(result.begin(), result.end(), WeightCmp());
   nextEgressResults_ = nullptr;
 }

bool proxygen::HTTP2PriorityQueue::nextEgressResult	(	HTTP2PriorityQueue &	queue,
		HTTPCodec::StreamID	id,
		HTTPTransaction *	txn,
		double	r
	)

staticprivate

Definition at line 640 of file HTTP2PriorityQueue.cpp.

References nextEgressResults_.

Referenced by nextEgress().

                                                                      {
   queue.nextEgressResults_->emplace_back(txn, r);
   return false;
 }

uint64_t proxygen::HTTP2PriorityQueue::numPendingEgress ( ) const

inline

Definition at line 127 of file HTTP2PriorityQueue.h.

Referenced by proxygen::HTTPSession::runLoopCallback().

                                     {
     return activeCount_;
   }

uint64_t proxygen::HTTP2PriorityQueue::numVirtualNodes ( ) const

inline

Definition at line 131 of file HTTP2PriorityQueue.h.

                                    {
     return numVirtualNodes_;
   }

void proxygen::HTTP2PriorityQueue::rebuildTree ( )

Error handling code.

Definition at line 722 of file HTTP2PriorityQueue.cpp.

References proxygen::HTTP2PriorityQueue::Node::flattenSubtree(), kMaxRebuilds_, rebuildCount_, and root_.

                                 {
   CHECK_LE(rebuildCount_ + 1, kMaxRebuilds_);
   root_.flattenSubtree();
   rebuildCount_++;
 }

void proxygen::HTTP2PriorityQueue::removeTransaction ( HTTP2PriorityQueue::Handle handle )

overridevirtual

Implements proxygen::HTTP2PriorityQueueBase.

Definition at line 578 of file HTTP2PriorityQueue.cpp.

References allowDanglingNodes(), proxygen::HTTP2PriorityQueue::Node::clearPendingEgress(), proxygen::HTTP2PriorityQueue::Node::clearTransaction(), proxygen::HTTP2PriorityQueue::Node::getID(), proxygen::HTTP2PriorityQueue::Node::isEnqueued(), maxVirtualNodes_, numVirtualNodes_, pendingWeightChange_, proxygen::HTTP2PriorityQueue::Node::removeFromTree(), and scheduleNodeExpiration().

                                                                      {
   Node* node = CHECK_NOTNULL(dynamic_cast<HTTP2PriorityQueue::Node*>(handle));
   pendingWeightChange_ = true;
   // TODO: or require the node to do it?
   if (node->isEnqueued()) {
     clearPendingEgress(handle);
   }
   if (allowDanglingNodes() && numVirtualNodes_ < maxVirtualNodes_) {
     node->clearTransaction();
     numVirtualNodes_++;
     scheduleNodeExpiration(node);
   } else {
     VLOG(5) << "Deleting dangling node over max id=" << node->getID();
     node->removeFromTree();
   }
 }

void proxygen::HTTP2PriorityQueue::scheduleNodeExpiration ( Node * node )

inlineprivate

Definition at line 179 of file HTTP2PriorityQueue.h.

References proxygen::HTTP2PriorityQueue::Node::getID().

Referenced by addTransaction(), proxygen::HTTP2PriorityQueue::Node::detachChild(), and removeTransaction().

                                           {
     if (timeout_) {
       VLOG(5) << "scheduling expiration for node=" << node->getID();
       DCHECK_GT(kNodeLifetime_.count(), 0);
       timeout_.scheduleTimeout(node, kNodeLifetime_);
     }
   }

void proxygen::HTTP2PriorityQueue::setMaxVirtualNodes ( uint32_t maxVirtualNodes )

inline

Definition at line 85 of file HTTP2PriorityQueue.h.

References proxygen::HTTP2PriorityQueueBase::clearPendingEgress(), h, and proxygen::HTTP2PriorityQueueBase::signalPendingEgress().

                                                     {
     maxVirtualNodes_ = maxVirtualNodes;
   }

static void proxygen::HTTP2PriorityQueue::setNodeLifetime ( std::chrono::milliseconds lifetime )

inlinestatic

Definition at line 152 of file HTTP2PriorityQueue.h.

                                                               {
     kNodeLifetime_ = lifetime;
   }

void proxygen::HTTP2PriorityQueue::signalPendingEgress ( Handle h )

overridevirtual

Implements proxygen::HTTP2PriorityQueueBase.

Definition at line 596 of file HTTP2PriorityQueue.cpp.

References activeCount_, proxygen::HTTP2PriorityQueueBase::BaseNode::isEnqueued(), and pendingWeightChange_.

                                                      {
   if (!handle->isEnqueued()) {
     CHECK_NOTNULL(dynamic_cast<HTTP2PriorityQueue::Node*>(handle))
       ->signalPendingEgress();
     activeCount_++;
     pendingWeightChange_ = true;
   }
 }

void proxygen::HTTP2PriorityQueue::updateEnqueuedWeight ( )

private

Definition at line 710 of file HTTP2PriorityQueue.cpp.

References activeCount_, pendingWeightChange_, root_, and proxygen::HTTP2PriorityQueue::Node::updateEnqueuedWeight().

                                          {
 #ifndef NDEBUG
   if (pendingWeightChange_) {
     root_.updateEnqueuedWeight(activeCount_ > 0);
     pendingWeightChange_ = false;
   }
 #endif
 }

HTTP2PriorityQueue::Handle proxygen::HTTP2PriorityQueue::updatePriority	(	HTTP2PriorityQueue::Handle	handle,
		http2::PriorityUpdate	pri,
		uint64_t *	depth = `nullptr`
	)

overridevirtual

Implements proxygen::HTTP2PriorityQueueBase.

Definition at line 529 of file HTTP2PriorityQueue.cpp.

Referenced by addOrUpdatePriorityNode(), and addTransaction().

                                                     {
   Node* node = CHECK_NOTNULL(dynamic_cast<HTTP2PriorityQueue::Node*>(handle));
   pendingWeightChange_ = true;
   VLOG(4) << "Updating id=" << node->getID() << " with parent=" <<
     pri.streamDependency << " and weight=" << ((uint16_t)pri.weight + 1);
   node->updateWeight(pri.weight);
   CHECK_NE(pri.streamDependency, node->getID()) <<
     "Tried to create a loop in the tree";
   if (pri.streamDependency == node->parentID() && !pri.exclusive) {
     // no move
     if (depth) {
       *depth = handle->calculateDepth();
     }
     return handle;
   }
 
   Node* newParent = find(pri.streamDependency, depth);
   if (!newParent) {
     if (pri.streamDependency == 0 || numVirtualNodes_ >= maxVirtualNodes_) {
       newParent = &root_;
     } else {
       // allocate a virtual node for non-existing parent in my depenency tree
       // then do normal priority processing
       newParent = dynamic_cast<Node*>(
           addTransaction(pri.streamDependency,
                          http2::DefaultPriority,
                          nullptr,
                          false,
                          depth));
 
       CHECK_NOTNULL(newParent);
       VLOG(4) << "updatePriority missing parent, creating virtual parent="
               << newParent->getID() << " for txn=" << node->getID();
     }
   }
 
   if (newParent->isDescendantOf(node)) {
     newParent = newParent->reparent(node->getParent(), false);
   }
   node = node->reparent(newParent, pri.exclusive);
   if (depth) {
     *depth = node->calculateDepth();
   }
   return node;
 }

Member Data Documentation

uint64_t proxygen::HTTP2PriorityQueue::activeCount_ {0}

private

Definition at line 412 of file HTTP2PriorityQueue.h.

Referenced by clearPendingEgress(), nextEgress(), signalPendingEgress(), and updateEnqueuedWeight().

uint32_t proxygen::HTTP2PriorityQueue::kMaxRebuilds_ = 3

staticprivate

Definition at line 411 of file HTTP2PriorityQueue.h.

Referenced by rebuildTree().

std::chrono::milliseconds proxygen::HTTP2PriorityQueue::kNodeLifetime_

staticprivate

Initial value:

std::chrono::seconds(30)

Definition at line 419 of file HTTP2PriorityQueue.h.

const size_t proxygen::HTTP2PriorityQueue::kNumBuckets = 100

staticprivate

Definition at line 66 of file HTTP2PriorityQueue.h.

uint32_t proxygen::HTTP2PriorityQueue::maxVirtualNodes_ {50}

private

Definition at line 413 of file HTTP2PriorityQueue.h.

Referenced by addTransaction(), removeTransaction(), and updatePriority().

NextEgressResult* proxygen::HTTP2PriorityQueue::nextEgressResults_ {nullptr}

private

Definition at line 418 of file HTTP2PriorityQueue.h.

Referenced by nextEgress(), and nextEgressResult().

NodeMap::bucket_type proxygen::HTTP2PriorityQueue::nodeBuckets_[kNumBuckets]

private

Definition at line 407 of file HTTP2PriorityQueue.h.

NodeMap proxygen::HTTP2PriorityQueue::nodes_

private

Definition at line 408 of file HTTP2PriorityQueue.h.

Referenced by find(), and proxygen::HTTP2PriorityQueue::Node::Node().

uint32_t proxygen::HTTP2PriorityQueue::numVirtualNodes_ {0}

private

Definition at line 414 of file HTTP2PriorityQueue.h.

Referenced by addTransaction(), proxygen::HTTP2PriorityQueue::Node::convertVirtualNode(), removeTransaction(), updatePriority(), and proxygen::HTTP2PriorityQueue::Node::~Node().

bool proxygen::HTTP2PriorityQueue::pendingWeightChange_ {false}

private

Definition at line 415 of file HTTP2PriorityQueue.h.

Referenced by addTransaction(), clearPendingEgress(), removeTransaction(), signalPendingEgress(), updateEnqueuedWeight(), and updatePriority().

uint32_t proxygen::HTTP2PriorityQueue::rebuildCount_ {0}

private

Definition at line 410 of file HTTP2PriorityQueue.h.

Referenced by rebuildTree().

Node proxygen::HTTP2PriorityQueue::root_ {*this, nullptr, 0, 1, nullptr}

private

Definition at line 409 of file HTTP2PriorityQueue.h.

Referenced by addTransaction(), iterateBFS(), nextEgress(), rebuildTree(), updateEnqueuedWeight(), and updatePriority().

WheelTimerInstance proxygen::HTTP2PriorityQueue::timeout_

private

Definition at line 416 of file HTTP2PriorityQueue.h.

Referenced by attachThreadLocals(), and detachThreadLocals().

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

proxygen/lib/http/session/HTTP2PriorityQueue.h
proxygen/lib/http/session/HTTP2PriorityQueue.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation