proxygen: proxygen::QPACKHeaderTable Class Reference

#include <QPACKHeaderTable.h>

Inheritance diagram for proxygen::QPACKHeaderTable:

Public Types
enum	{ UNACKED = std::numeric_limits<uint32_t>::max() }

Public Types inherited from proxygen::HeaderTable
using	names_map = std::unordered_map< HPACKHeaderName, std::list< uint32_t >>

Public Member Functions
	QPACKHeaderTable (uint32_t capacityVal, bool trackReferences)

	~QPACKHeaderTable ()

	QPACKHeaderTable (const QPACKHeaderTable &)=delete

QPACKHeaderTable &	operator= (const QPACKHeaderTable &)=delete

uint32_t	getBaseIndex () const

bool	isVulnerable (uint32_t absIndex) const

bool	canIndex (const HPACKHeader &header)

bool	isDraining (uint32_t relativeIndex)

std::pair< bool, uint32_t >	maybeDuplicate (uint32_t relativeIndex, bool allowVulnerable)

bool	add (HPACKHeader header) override

bool	setCapacity (uint32_t capacity) override

uint32_t	getIndex (const HPACKHeader &header, bool allowVulnerable=true) const

const HPACKHeader &	getHeader (uint32_t index, uint32_t base=0) const

bool	isValid (uint32_t index, uint32_t base=0) const

uint32_t	nameIndex (const HPACKHeaderName &headerName, bool allowVulnerable=true) const

bool	onTableStateSync (uint32_t inserts)

void	setMaxAcked (uint32_t maxAcked)

uint32_t	relativeToAbsolute (uint32_t relativeIndex) const

uint32_t	absoluteToRelative (uint32_t absIndex) const

void	addRef (uint32_t absIndex)

void	subRef (uint32_t absIndex)

Public Member Functions inherited from proxygen::HeaderTable
	HeaderTable (uint32_t capacityVal)

virtual	~HeaderTable ()

	HeaderTable (const HeaderTable &)=delete

HeaderTable &	operator= (const HeaderTable &)=delete

uint32_t	getIndex (const HPACKHeader &header) const

const HPACKHeader &	getHeader (uint32_t index) const

bool	isValid (uint32_t index) const

bool	hasName (const HPACKHeaderName &headerName)

const names_map &	names () const

uint32_t	nameIndex (const HPACKHeaderName &headerName) const

uint32_t	capacity () const

uint32_t	getMaxTableLength (uint32_t capacityVal)

uint32_t	size () const

uint32_t	bytes () const

size_t	length () const

bool	operator== (const HeaderTable &other) const

Private Member Functions
uint32_t	getIndexImpl (const HPACKHeaderName &header, const folly::fbstring &value, bool nameOnly, bool allowVulnerable=true) const

void	increaseTableLengthTo (uint32_t newLength) override

void	resizeTable (uint32_t newLength) override

void	updateResizedTable (uint32_t oldTail, uint32_t oldLength, uint32_t newLength) override

uint32_t	removeLast () override

bool	canEvict (uint32_t needed)

uint32_t	evict (uint32_t needed, uint32_t desiredCapacity) override

uint32_t	toInternal (uint32_t externalIndex, uint32_t base) const

uint32_t	internalToAbsolute (uint32_t internalIndex) const

uint32_t	absoluteToInternal (uint32_t absoluteIndex) const

Private Attributes
uint32_t	baseIndex_ {0}

uint32_t	drainedBytes_ {0}

uint32_t	minUsable_ {1}

uint32_t	maxAcked_ {0}

std::unique_ptr< std::vector< uint16_t > >	refCount_

uint32_t	minFree_ {0}

Additional Inherited Members
Static Public Member Functions inherited from proxygen::HeaderTable
static uint32_t	toExternal (uint32_t head, uint32_t length, uint32_t internalIndex)

static uint32_t	toInternal (uint32_t head, uint32_t length, uint32_t externalIndex)

Protected Member Functions inherited from proxygen::HeaderTable
void	init (uint32_t capacityVal)

void	reset ()

uint32_t	next (uint32_t i) const

uint32_t	tail () const

uint32_t	toExternal (uint32_t internalIndex) const

uint32_t	toInternal (uint32_t externalIndex) const

Protected Attributes inherited from proxygen::HeaderTable
uint32_t	capacity_ {0}

uint32_t	bytes_ {0}

std::vector< HPACKHeader >	table_

uint32_t	size_ {0}

uint32_t	head_ {0}

names_map	names_

Detailed Description

Data structure for maintaining indexed headers, based on a fixed-length ring with FIFO semantics. Externally it acts as an array.

Definition at line 22 of file QPACKHeaderTable.h.

Member Enumeration Documentation

anonymous enum

Enumerator
UNACKED

Definition at line 24 of file QPACKHeaderTable.h.

        {
     UNACKED = std::numeric_limits<uint32_t>::max()
   };

Constructor & Destructor Documentation

proxygen::QPACKHeaderTable::QPACKHeaderTable	(	uint32_t	capacityVal,
		bool	trackReferences
	)

Definition at line 39 of file QPACKHeaderTable.cpp.

References minFree_, refCount_, and proxygen::HeaderTable::table_.

Referenced by ~QPACKHeaderTable().

     : HeaderTable(capacityVal) {
   if (trackReferences) {
     refCount_ = std::make_unique<std::vector<uint16_t>>(table_.size(), 0);
     minFree_ = getMinFree(capacityVal);
   } else {
     minFree_ = 0;
   }
 }

proxygen::QPACKHeaderTable::~QPACKHeaderTable ( )

inline

Definition at line 30 of file QPACKHeaderTable.h.

References operator=(), and QPACKHeaderTable().

30 {}

proxygen::QPACKHeaderTable::QPACKHeaderTable ( const QPACKHeaderTable & )

delete

Member Function Documentation

uint32_t proxygen::QPACKHeaderTable::absoluteToInternal ( uint32_t absoluteIndex ) const

private

Definition at line 276 of file QPACKHeaderTable.cpp.

References absoluteToRelative(), and toInternal().

Referenced by absoluteToRelative(), add(), addRef(), and subRef().

                                 {
   return toInternal(absoluteToRelative(absoluteIndex), 0);
 }

uint32_t proxygen::QPACKHeaderTable::absoluteToRelative ( uint32_t absIndex ) const

inline

Convert an absolute index to a relative index

Definition at line 154 of file QPACKHeaderTable.h.

References absoluteToInternal(), addRef(), baseIndex_, canEvict(), evict(), getIndexImpl(), increaseTableLengthTo(), internalToAbsolute(), removeLast(), resizeTable(), subRef(), toInternal(), uint32_t, updateResizedTable(), and value.

Referenced by absoluteToInternal(), proxygen::QPACKEncoder::encodeHeaderQ(), proxygen::QPACKEncoder::getNameIndexQ(), and toInternal().

                                                        {
     CHECK_LE(absIndex, baseIndex_);
     return baseIndex_ - absIndex + 1;
   }

bool proxygen::QPACKHeaderTable::add ( HPACKHeader header )

overridevirtual

Add the header entry at the beginning of the table (index=1)

Returns: true if it was able to add the entry

Reimplemented from proxygen::HeaderTable.

Definition at line 49 of file QPACKHeaderTable.cpp.

References absoluteToInternal(), proxygen::HeaderTable::add(), baseIndex_, proxygen::HeaderTable::bytes(), proxygen::HeaderTable::bytes_, proxygen::HeaderTable::capacity_, drainedBytes_, proxygen::ERROR, proxygen::HeaderTable::head_, internalToAbsolute(), max, minFree_, minUsable_, folly::gen::move, refCount_, and proxygen::HeaderTable::table_.

Referenced by proxygen::QPACKDecoder::decodeEncoderStreamInstruction(), proxygen::QPACKDecoder::decodeLiteralHeaderQ(), proxygen::QPACKEncoder::encodeHeaderQ(), isDraining(), maybeDuplicate(), and proxygen::QPACKContext::seedHeaderTable().

                                              {
   if (baseIndex_ == std::numeric_limits<uint32_t>::max()) {
     LOG(ERROR) << "Cowardly refusing to add more entries since baseIndex_ "
       " would wrap";
     return false;
   }
 
   VLOG(6) << "Adding header=" << header;
   if (!HeaderTable::add(std::move(header))) {
     return false;
   }
   if (refCount_) {
     (*refCount_)[head_] = 0;
   }
   ++baseIndex_;
   DCHECK_EQ(internalToAbsolute(head_), baseIndex_);
   // Increase minUsable_ until the free space + drainedBytes is >= minFree.
   // For HPACK, minFree is 0 and this is a no-op.
   while (capacity_ - bytes_ + drainedBytes_ < minFree_ &&
          minUsable_ <= baseIndex_) {
     auto bytes = table_[absoluteToInternal(minUsable_)].bytes();
     VLOG(5) << "Draining absolute index " << minUsable_ << " bytes="
             << bytes << " drainedBytes_= " << (drainedBytes_ + bytes);
     drainedBytes_  += bytes;
     minUsable_++;
   }
   return true;
 }

void proxygen::QPACKHeaderTable::addRef ( uint32_t absIndex )

Add a reference for the given index. Entries with non-zero references cannot be evicted

Definition at line 254 of file QPACKHeaderTable.cpp.

References absoluteToInternal(), and refCount_.

Referenced by absoluteToRelative(), and proxygen::QPACKEncoder::trackReference().

                                                {
   // refCount is 16 bits.  It should really never get this big in practice,
   // unless a decoder is not sending HEADER_ACK in a timely way.
   CHECK(refCount_);
   (*refCount_)[absoluteToInternal(absIndex)]++;
 }

bool proxygen::QPACKHeaderTable::canEvict ( uint32_t needed )

private

Return true if the table can evict needed bytes

Definition at line 192 of file QPACKHeaderTable.cpp.

References proxygen::HeaderTable::capacity_, i, internalToAbsolute(), maxAcked_, proxygen::HeaderTable::next(), refCount_, proxygen::HeaderTable::size(), proxygen::HeaderTable::size_, proxygen::HeaderTable::table_, proxygen::HeaderTable::tail(), and uint32_t.

Referenced by absoluteToRelative(), canIndex(), and evict().

                                                {
   if (size_ == 0 || !refCount_) {
     return needed <= capacity_;
   }
   uint32_t freeable = 0;
   uint32_t i = tail();
   uint32_t nChecked = 0;
   while (nChecked++ < size() && freeable < needed && ((*refCount_)[i] == 0) &&
          internalToAbsolute(i) <= maxAcked_) { // don't evict unacked headers
     freeable += table_[i].bytes();
     i = next(i);
   }
   if (freeable < needed) {
     VLOG(5) << "header=" << table_[i].name << " blocked eviction, recount="
             << (*refCount_)[i];
     return false;
   }
   return true;
 }

bool proxygen::QPACKHeaderTable::canIndex ( const HPACKHeader & header )

inline

Returns true if the header can be added to the table. May be linear in the number of entries

Definition at line 53 of file QPACKHeaderTable.h.

References proxygen::HPACKHeader::bytes(), proxygen::HeaderTable::bytes_, canEvict(), proxygen::HeaderTable::capacity_, and minFree_.

Referenced by proxygen::QPACKEncoder::encodeHeaderQ(), and maybeDuplicate().

                                            {
     auto totalBytes = bytes_ + header.bytes();
     // Don't index headers that would immediately be drained
     return ((header.bytes() <= (capacity_ - minFree_)) &&
             (totalBytes <= capacity_ || canEvict(totalBytes - capacity_)));
   }

uint32_t proxygen::QPACKHeaderTable::evict	(	uint32_t	needed,
		uint32_t	desiredCapacity
	)

overrideprivatevirtual

Evict entries to make space for the needed amount of bytes.

Reimplemented from proxygen::HeaderTable.

Definition at line 184 of file QPACKHeaderTable.cpp.

References proxygen::HeaderTable::bytes_, canEvict(), and proxygen::HeaderTable::evict().

Referenced by absoluteToRelative().

                                                                           {
   if (bytes_ + needed < desiredCapacity ||
       !canEvict(bytes_ + needed - desiredCapacity)) {
     return 0;
   }
   return HeaderTable::evict(needed, desiredCapacity);
 }

uint32_t proxygen::QPACKHeaderTable::getBaseIndex ( ) const

inline

Return Base Index - the total number of headers inserted to this table, including evictions

Definition at line 38 of file QPACKHeaderTable.h.

References baseIndex_.

Referenced by proxygen::QPACKDecoder::decodeStreaming(), proxygen::QPACKDecoder::drainQueue(), proxygen::QPACKEncoder::encodeHeaderQ(), proxygen::QPACKEncoder::encodeQ(), proxygen::QPACKDecoder::encodeTableStateSync(), and proxygen::QPACKDecoder::enqueueHeaderBlock().

                                 {
     return baseIndex_;
   }

const HPACKHeader & proxygen::QPACKHeaderTable::getHeader	(	uint32_t	index,
		uint32_t	base = `0`
	)		const

Get the table entry at the given external index. If base is 0, index is relative to head/baseIndex. If base is non-zero, index is relative to base.

Returns: the header entry

Definition at line 129 of file QPACKHeaderTable.cpp.

References isValid(), proxygen::HeaderTable::table_, and toInternal().

Referenced by proxygen::QPACKContext::getHeader(), isDraining(), and maybeDuplicate().

                                                                     {
   CHECK(isValid(index, base));
   return table_[toInternal(index, base)];
 }

uint32_t proxygen::QPACKHeaderTable::getIndex	(	const HPACKHeader &	header,
		bool	allowVulnerable = `true`
	)		const

Get the index of the given header, if found. The index is relative to head/baseIndex. If allowVulnerable is true, the index returned may not have been acknowledged by the decoder.

Returns: 0 in case the header is not found

Definition at line 88 of file QPACKHeaderTable.cpp.

References getIndexImpl(), proxygen::HPACKHeader::name, and proxygen::HPACKHeader::value.

Referenced by proxygen::QPACKEncoder::encodeHeaderQ(), and isDraining().

                                                                 {
   return getIndexImpl(header.name, header.value, false, allowVulnerable);
 }

uint32_t proxygen::QPACKHeaderTable::getIndexImpl	(	const HPACKHeaderName &	header,
		const folly::fbstring &	value,
		bool	nameOnly,
		bool	allowVulnerable = `true`
	)		const

private

Definition at line 93 of file QPACKHeaderTable.cpp.

References i, internalToAbsolute(), maxAcked_, proxygen::HeaderTable::names_, proxygen::HeaderTable::table_, proxygen::HeaderTable::toExternal(), and UNACKED.

Referenced by absoluteToRelative(), getIndex(), and nameIndex().

                                                                     {
   auto it = names_.find(headerName);
   if (it == names_.end()) {
     return 0;
   }
   bool encoderHasUnackedEntry = false;
   // Searching backwards gives smallest index, but more likely vulnerable
   // Searching forwards least likely vulnerable but could prevent eviction
   for (auto indexIt = it->second.rbegin(); indexIt != it->second.rend();
        ++indexIt) {
     auto i = *indexIt;
     if (nameOnly || table_[i].value == value) {
       // allow vulnerable or not vulnerable
       if (allowVulnerable || internalToAbsolute(i) <= maxAcked_) {
         // index *may* be draining, caller has to check
         return toExternal(i);
       } else {
         encoderHasUnackedEntry = true;
       }
     }
   }
   if (encoderHasUnackedEntry) {
     return UNACKED;
   }
   return 0;
 }

void proxygen::QPACKHeaderTable::increaseTableLengthTo ( uint32_t newLength )

overrideprivatevirtual

Reimplemented from proxygen::HeaderTable.

Definition at line 159 of file QPACKHeaderTable.cpp.

References baseIndex_, proxygen::HeaderTable::head_, proxygen::HeaderTable::increaseTableLengthTo(), internalToAbsolute(), proxygen::HeaderTable::size_, and proxygen::HeaderTable::tail().

Referenced by absoluteToRelative().

                                                                {
   HeaderTable::increaseTableLengthTo(newLength);
   if (size_ > 0) {
     DCHECK_EQ(internalToAbsolute(head_), baseIndex_);
     DCHECK_EQ(internalToAbsolute(tail()), baseIndex_ - size_ + 1);
   }
 }

uint32_t proxygen::QPACKHeaderTable::internalToAbsolute ( uint32_t internalIndex ) const

private

Definition at line 270 of file QPACKHeaderTable.cpp.

References relativeToAbsolute(), and proxygen::HeaderTable::toExternal().

Referenced by absoluteToRelative(), add(), canEvict(), getIndexImpl(), increaseTableLengthTo(), and removeLast().

                                 {
   return relativeToAbsolute(toExternal(internalIndex));
 }

bool proxygen::QPACKHeaderTable::isDraining ( uint32_t relativeIndex )

inline

Returns true if the index should not be used so table space can be freed

Definition at line 63 of file QPACKHeaderTable.h.

References add(), proxygen::HeaderTable::capacity(), getHeader(), getIndex(), isValid(), maybeDuplicate(), minUsable_, nameIndex(), relativeToAbsolute(), setCapacity(), and uint32_t.

                                           {
     return relativeToAbsolute(relativeIndex) < minUsable_;
   }

bool proxygen::QPACKHeaderTable::isValid	(	uint32_t	index,
		uint32_t	base = `0`
	)		const

Checks if an external index is valid. If base is 0, index is relative to head/baseIndex. If base is non-zero, index is relative to base.

Definition at line 212 of file QPACKHeaderTable.cpp.

References baseIndex_, int64_t, and proxygen::HeaderTable::isValid().

Referenced by proxygen::QPACKEncoder::encodeHeaderQ(), getHeader(), isDraining(), proxygen::QPACKDecoder::isValid(), maybeDuplicate(), and relativeToAbsolute().

                                                                   {
   int64_t testIndex = index;
   if (base > 0) {
     auto baseOffset = ((int64_t)base - (int64_t)baseIndex_);
     // recompute relative to current baseIndex_.  testIndex may go negative
     // if this is a reference to an entry that hasn't arrived yet
     testIndex -= baseOffset;
   }
   return HeaderTable::isValid(testIndex);
 }

bool proxygen::QPACKHeaderTable::isVulnerable ( uint32_t absIndex ) const

inline

Returns true if the absolute index has not been ack'ed yet.

Definition at line 45 of file QPACKHeaderTable.h.

References maxAcked_.

Referenced by maybeDuplicate(), TEST(), and proxygen::QPACKEncoder::trackReference().

                                              {
     return (absIndex > maxAcked_);
   }

std::pair< bool, uint32_t > proxygen::QPACKHeaderTable::maybeDuplicate	(	uint32_t	relativeIndex,
		bool	allowVulnerable
	)

Returns the absolute index for a reference to the header at relativeIndex, along with a boolean indicating if the returned index is a duplicate. It may return 0 if the entry at relativeIndex was draining and could not be duplicated, or vulnerable references are not allowed.

Definition at line 228 of file QPACKHeaderTable.cpp.

References add(), baseIndex_, canIndex(), proxygen::HPACKHeader::copy(), getHeader(), isValid(), isVulnerable(), minUsable_, relativeToAbsolute(), uint32_t, and UNACKED.

Referenced by isDraining(), and proxygen::QPACKEncoder::maybeDuplicate().

                             {
   if (relativeIndex == UNACKED) {
     return {false, 0};
   }
   DCHECK(isValid(relativeIndex));
   uint32_t absIndex = relativeToAbsolute(relativeIndex);
   DCHECK(!isVulnerable(absIndex) || allowVulnerable);
   if (absIndex < minUsable_) {
     // draining
     const HPACKHeader& header = getHeader(relativeIndex);
     if (canIndex(header)) {
       CHECK(add(header.copy()));
       if (allowVulnerable) {
         return {true, baseIndex_};
       } else {
         return {true, 0};
       }
     } else {
       return {false, 0};
     }
   }
   return {false, absIndex};
 }

uint32_t proxygen::QPACKHeaderTable::nameIndex	(	const HPACKHeaderName &	headerName,
		bool	allowVulnerable = `true`
	)		const

Get any index of a header that has the given name. From all the headers with the given name we pick the last one added to the header table, but the way we pick the header can be arbitrary.

See getIndex for a description of base/allowVulnerable

Definition at line 123 of file QPACKHeaderTable.cpp.

References getIndexImpl(), and value.

Referenced by proxygen::QPACKEncoder::getNameIndexQ(), and isDraining().

                                                                  {
   folly::fbstring value;
   return getIndexImpl(headerName, value, true /* name only */, allowVulnerable);
 }

bool proxygen::QPACKHeaderTable::onTableStateSync ( uint32_t inserts )

inline

Definition at line 121 of file QPACKHeaderTable.h.

References baseIndex_, proxygen::ERROR, and maxAcked_.

Referenced by proxygen::QPACKEncoder::onTableStateSync().

                                           {
     // compare this way to avoid overflow
     if (inserts > baseIndex_ ||
         maxAcked_ > baseIndex_ - inserts) {
       LOG(ERROR) << "Decoder ack'd too much maxAcked_="
                  << maxAcked_ << " baseIndex_=" << baseIndex_
                  << " inserts=" << inserts;
       return false;
     }
     maxAcked_ += inserts;
     CHECK_LE(maxAcked_, baseIndex_);
     return true;
   }

QPACKHeaderTable& proxygen::QPACKHeaderTable::operator= ( const QPACKHeaderTable & )

delete

Referenced by ~QPACKHeaderTable().

uint32_t proxygen::QPACKHeaderTable::relativeToAbsolute ( uint32_t relativeIndex ) const

inline

Convert a relative index to an absolute index

Definition at line 146 of file QPACKHeaderTable.h.

References baseIndex_, and isValid().

Referenced by internalToAbsolute(), isDraining(), and maybeDuplicate().

                                                             {
     DCHECK(isValid(relativeIndex, 0));
     return baseIndex_ - relativeIndex + 1;
   }

uint32_t proxygen::QPACKHeaderTable::removeLast ( )

overrideprivatevirtual

Removes one header entry from the beginning of the header table.

Reimplemented from proxygen::HeaderTable.

Definition at line 135 of file QPACKHeaderTable.cpp.

References baseIndex_, drainedBytes_, int32_t, internalToAbsolute(), minUsable_, refCount_, proxygen::HeaderTable::removeLast(), proxygen::HeaderTable::size(), and proxygen::HeaderTable::tail().

Referenced by absoluteToRelative().

                                       {
   auto idx = tail();
   if (refCount_) {
     CHECK_EQ((*refCount_)[idx], 0) << "Removed header with nonzero references";
   }
   auto removedBytes = HeaderTable::removeLast();
   // Only non-zero when minUsable_ > baseIndex_ - size_.
   if (drainedBytes_ > 0) {
     VLOG(5) << "Removing draining entry=" << idx << " size=" << removedBytes
             << " drainedBytes_=" << drainedBytes_ << " new drainedBytes_="
             << (int32_t(drainedBytes_) - removedBytes);
     CHECK_GE(drainedBytes_, removedBytes);
     drainedBytes_ -= removedBytes;
   } else {
       // Keep minUsable_ as a valid index when evicting an undrained header
     if (size() > 0) {
       minUsable_ = internalToAbsolute(tail());
     } else {
       minUsable_ = baseIndex_ + 1;
     }
   }
   return removedBytes;
 }

void proxygen::QPACKHeaderTable::resizeTable ( uint32_t newLength )

overrideprivatevirtual

Reimplemented from proxygen::HeaderTable.

Definition at line 167 of file QPACKHeaderTable.cpp.

References refCount_, and proxygen::HeaderTable::resizeTable().

Referenced by absoluteToRelative().

                                                      {
   HeaderTable::resizeTable(newLength);
   if (refCount_) {
     refCount_->resize(newLength);
   }
 }

bool proxygen::QPACKHeaderTable::setCapacity ( uint32_t capacity )

overridevirtual

Sets the current capacity of the header table, and evicts entries if needed. Returns false if eviction failed.

Reimplemented from proxygen::HeaderTable.

Definition at line 78 of file QPACKHeaderTable.cpp.

References minFree_, refCount_, and proxygen::HeaderTable::setCapacity().

Referenced by isDraining().

                                                     {
   if (!HeaderTable::setCapacity(capacity)) {
     return false;
   }
   if (refCount_) {
     minFree_ = getMinFree(capacity);
   } // else minFree is always 0
   return true;
 }

void proxygen::QPACKHeaderTable::setMaxAcked ( uint32_t maxAcked )

inline

Definition at line 135 of file QPACKHeaderTable.h.

References baseIndex_, and maxAcked_.

Referenced by proxygen::QPACKEncoder::onHeaderAck().

                                       {
     if (maxAcked < maxAcked_) {
       return;
     }
     CHECK_LE(maxAcked, baseIndex_);
     maxAcked_ = maxAcked;
   }

void proxygen::QPACKHeaderTable::subRef ( uint32_t absIndex )

Subtract a reference for the given index

Definition at line 261 of file QPACKHeaderTable.cpp.

References absoluteToInternal(), refCount_, and uint32_t.

Referenced by absoluteToRelative(), and proxygen::QPACKEncoder::onHeaderAck().

                                                {
   CHECK(refCount_);
   uint32_t index = absoluteToInternal(absIndex);
   CHECK_GT((*refCount_)[index], 0);
   (*refCount_)[index]--;
 }

uint32_t proxygen::QPACKHeaderTable::toInternal	(	uint32_t	externalIndex,
		uint32_t	base
	)		const

private

Translate external index to internal one.

Definition at line 281 of file QPACKHeaderTable.cpp.

References absoluteToRelative(), proxygen::HeaderTable::toInternal(), and uint32_t.

Referenced by absoluteToInternal(), absoluteToRelative(), and getHeader().

                                                  {
   if (base > 0) {
     uint32_t absIndex = base - externalIndex + 1;
     externalIndex = absoluteToRelative(absIndex);
   }
   return HeaderTable::toInternal(externalIndex);
 }

void proxygen::QPACKHeaderTable::updateResizedTable	(	uint32_t	oldTail,
		uint32_t	oldLength,
		uint32_t	newLength
	)

overrideprivatevirtual

Reimplemented from proxygen::HeaderTable.

Definition at line 174 of file QPACKHeaderTable.cpp.

References refCount_, and proxygen::HeaderTable::updateResizedTable().

Referenced by absoluteToRelative().

                                                               {
   HeaderTable::updateResizedTable(oldTail, oldLength, newLength);
   if (refCount_) {
     std::move_backward(refCount_->begin() + oldTail,
                        refCount_->begin() + oldLength,
                        refCount_->begin() + newLength);
   }
 }

Member Data Documentation

uint32_t proxygen::QPACKHeaderTable::baseIndex_ {0}

private

Definition at line 212 of file QPACKHeaderTable.h.

Referenced by absoluteToRelative(), add(), getBaseIndex(), increaseTableLengthTo(), isValid(), maybeDuplicate(), onTableStateSync(), relativeToAbsolute(), removeLast(), and setMaxAcked().

uint32_t proxygen::QPACKHeaderTable::drainedBytes_ {0}

private

Definition at line 213 of file QPACKHeaderTable.h.

Referenced by add(), and removeLast().

uint32_t proxygen::QPACKHeaderTable::maxAcked_ {0}

private

Definition at line 215 of file QPACKHeaderTable.h.

Referenced by canEvict(), getIndexImpl(), isVulnerable(), onTableStateSync(), and setMaxAcked().

uint32_t proxygen::QPACKHeaderTable::minFree_ {0}

private

Definition at line 217 of file QPACKHeaderTable.h.

Referenced by add(), canIndex(), QPACKHeaderTable(), and setCapacity().

uint32_t proxygen::QPACKHeaderTable::minUsable_ {1}

private

Definition at line 214 of file QPACKHeaderTable.h.

Referenced by add(), isDraining(), maybeDuplicate(), and removeLast().

std::unique_ptr<std::vector<uint16_t> > proxygen::QPACKHeaderTable::refCount_

private

Definition at line 216 of file QPACKHeaderTable.h.

Referenced by add(), addRef(), canEvict(), QPACKHeaderTable(), removeLast(), resizeTable(), setCapacity(), subRef(), and updateResizedTable().

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

proxygen/lib/http/codec/compress/QPACKHeaderTable.h
proxygen/lib/http/codec/compress/QPACKHeaderTable.cpp

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation