proxygen: folly::IOBufQueue Class Reference

#include <IOBufQueue.h>

Classes
struct	Options

class	WritableRangeCache

struct	WritableRangeCacheData

Public Member Functions
	IOBufQueue (const Options &options=Options())

	~IOBufQueue ()

std::pair< void *, std::size_t >	headroom ()

void	markPrepended (std::size_t n)

void	prepend (const void *buf, std::size_t n)

void	append (std::unique_ptr< folly::IOBuf > &&buf, bool pack=false)

void	append (IOBufQueue &other, bool pack=false)

void	append (IOBufQueue &&other, bool pack=false)

void	append (const void *buf, size_t len)

void	append (StringPiece sp)

void	wrapBuffer (const void *buf, size_t len, std::size_t blockSize=(1U<< 31))

std::pair< void *, std::size_t >	preallocate (std::size_t min, std::size_t newAllocationSize, std::size_t max=std::numeric_limits< std::size_t >::max())

void	postallocate (std::size_t n)

void *	allocate (std::size_t n)

void *	writableTail () const

size_t	tailroom () const

std::unique_ptr< folly::IOBuf >	split (size_t n)

std::unique_ptr< folly::IOBuf >	splitAtMost (size_t n)

void	trimStart (size_t amount)

size_t	trimStartAtMost (size_t amount)

void	trimEnd (size_t amount)

size_t	trimEndAtMost (size_t amount)

std::unique_ptr< folly::IOBuf >	move ()

const folly::IOBuf *	front () const

std::unique_ptr< folly::IOBuf >	pop_front ()

size_t	chainLength () const

bool	empty () const

const Options &	options () const

void	clear ()

void	appendToString (std::string &out) const

void	gather (std::size_t maxLength)

	IOBufQueue (IOBufQueue &&) noexcept

IOBufQueue &	operator= (IOBufQueue &&)

Static Public Member Functions
static Options	cacheChainLength ()

Private Member Functions
auto	updateGuard ()

std::unique_ptr< folly::IOBuf >	split (size_t n, bool throwOnUnderflow)

	IOBufQueue (const IOBufQueue &)=delete

IOBufQueue &	operator= (const IOBufQueue &)=delete

void	dcheckCacheIntegrity () const

void	fillWritableRangeCache (WritableRangeCacheData &dest)

void	clearWritableRangeCache ()

void	flushCache () const

void	updateCacheRef (WritableRangeCacheData &newRef)

void	updateWritableTailCache ()

std::pair< void *, std::size_t >	preallocateSlow (std::size_t min, std::size_t newAllocationSize, std::size_t max)

Private Attributes
Options	options_

size_t	chainLength_ {0}

std::unique_ptr< folly::IOBuf >	head_

uint8_t *	tailStart_ {nullptr}

WritableRangeCacheData *	cachePtr_ {nullptr}

WritableRangeCacheData	localCache_

Static Private Attributes
static const size_t	kChainLengthNotCached = (size_t)-1

Detailed Description

An IOBufQueue encapsulates a chain of IOBufs and provides convenience functions to append data to the back of the chain and remove data from the front.

You may also prepend data into the headroom of the first buffer in the chain, if any.

Definition at line 35 of file IOBufQueue.h.

Constructor & Destructor Documentation

folly::IOBufQueue::IOBufQueue ( const Options & options = Options() )

explicit

Definition at line 67 of file IOBufQueue.cpp.

References folly::IOBufQueue::WritableRangeCacheData::attached, and localCache_.

Referenced by folly::IOBufQueue::WritableRangeCache::dcheckIntegrity(), and options().

     : options_(options), cachePtr_(&localCache_) {
   localCache_.attached = true;
 }

folly::IOBufQueue::~IOBufQueue ( )

Definition at line 72 of file IOBufQueue.cpp.

References clearWritableRangeCache().

Referenced by folly::IOBufQueue::WritableRangeCache::dcheckIntegrity().

                         {
   clearWritableRangeCache();
 }

folly::IOBufQueue::IOBufQueue ( IOBufQueue && other )

noexcept

Movable

Definition at line 76 of file IOBufQueue.cpp.

References chainLength_, head_, folly::gen::move, and tailStart_.

     : options_(other.options_), cachePtr_(&localCache_) {
   other.clearWritableRangeCache();
   head_ = std::move(other.head_);
   chainLength_ = other.chainLength_;
 
   tailStart_ = other.tailStart_;
   localCache_.cachedRange = other.localCache_.cachedRange;
   localCache_.attached = true;
 
   other.chainLength_ = 0;
   other.tailStart_ = nullptr;
   other.localCache_.cachedRange = {nullptr, nullptr};
 }

folly::IOBufQueue::IOBufQueue ( const IOBufQueue & )

privatedelete

Not copyable

Member Function Documentation

void* folly::IOBufQueue::allocate ( std::size_t n )

inline

Obtain a writable block of n contiguous bytes, allocating more space if necessary, and mark it as used. The caller can fill it later.

Definition at line 392 of file IOBufQueue.h.

References postallocate(), and preallocate().

                               {
     void* p = preallocate(n, n).first;
     postallocate(n);
     return p;
   }

void folly::IOBufQueue::append	(	std::unique_ptr< folly::IOBuf > &&	buf,
		bool	pack = `false`
	)

Add a buffer or buffer chain to the end of this queue. The queue takes ownership of buf.

If pack is true, we try to reduce wastage at the end of this queue by copying some data from the first buffers in the buf chain (and releasing the buffers), if possible. If pack is false, we leave the chain topology unchanged.

Definition at line 143 of file IOBufQueue.cpp.

References folly::IOBufQueue::Options::cacheChainLength, chainLength_, folly::gen::guard(), head_, folly::gen::move, options_, and updateGuard().

Referenced by proxygen::HPACKEncodeBuffer::addHeadroom(), append(), folly::AsyncSSLSocket::bioRead(), folly::io::test::compressSome(), folly::IOBufQueue::WritableRangeCache::dcheckIntegrity(), proxygen::compress::QPACKScheme::decode(), proxygen::QPACKEncoder::decodeDecoderStream(), proxygen::QPACKDecoder::decodeEncoderStream(), proxygen::QPACKDecoder::decodeStreaming(), fizz::sm::encodeAndAddBinders(), proxygen::fakeMockCodec(), proxygen::HTTP1xCodec::generateBody(), proxygen::HTTP2Codec::generateBody(), proxygen::HTTP2Codec::generateCertificate(), proxygen::HTTP1xCodec::generateChunkHeader(), proxygen::HTTP1xCodec::generateChunkTerminator(), proxygen::HTTP2Codec::generateConnectionPreface(), proxygen::SPDYCodec::generateDataFrame(), proxygen::SPDYCodec::generateSynReply(), proxygen::SPDYCodec::generateSynStream(), proxygen::HTTP2Codec::generateTrailers(), fizz::sm::getCertificateRequest(), MockCodecDownstreamTest::MockCodecDownstreamTest(), proxygen::ScopedHandler< HandlerType >::onBody(), proxygen::FakeHTTPCodecCallback::onBody(), proxygen::FakeHTTPCodecCallback::onCertificate(), proxygen::FakeHTTPCodecCallback::onCertificateRequest(), proxygen::FakeHTTPCodecCallback::onGoaway(), proxygen::RFC1867Codec::onIngress(), proxygen::HTTP2Codec::onIngressUpgradeMessage(), proxygen::HTTPSession::onPingRequest(), proxygen::parse(), proxygen::RFC1867Base::parse(), proxygen::HTTP2Codec::parseCertificate(), proxygen::HTTP2Codec::parseHeadersImpl(), proxygen::parseUnidirectional(), folly::AsyncSocket::performRead(), fizz::EncryptedReadRecordLayer::read(), fizz::AsyncFizzBase::readBufferAvailable(), proxygen::HTTPSession::readBufferAvailable(), fizz::ReadRecordLayer::readEvent(), fizz::test::LocalTransport::receiveData(), proxygen::HTTPTransaction::sendBody(), proxygen::HTTPSession::sendHeaders(), FlowControlFilterTest< initSize >::SetUp(), MockHTTPUpstreamTest::SetUp(), fizz::sm::setupSchedulerAndContext(), folly::io::test::CompressionTest::split(), TEST(), TEST_F(), MockCodecDownstreamTest::testConnFlowControlBlocked(), folly::bser::toBserIOBuf(), folly::io::test::uncompressSome(), wrapBuffer(), wangle::test::BytesReflector::write(), fizz::EncryptedWriteRecordLayer::write(), folly::AsyncPipeWriter::write(), proxygen::http2::writeCertificate(), and proxygen::http2::writeCertificateRequest().

                                                           {
   if (!buf) {
     return;
   }
   auto guard = updateGuard();
   if (options_.cacheChainLength) {
     chainLength_ += buf->computeChainDataLength();
   }
   appendToChain(head_, std::move(buf), pack);
 }

void folly::IOBufQueue::append	(	IOBufQueue &	other,
		bool	pack = `false`
	)

Add a queue to the end of this queue. The queue takes ownership of all buffers from the other queue.

Definition at line 154 of file IOBufQueue.cpp.

References folly::IOBufQueue::Options::cacheChainLength, chainLength_, folly::gen::guard(), head_, folly::gen::move, options_, and updateGuard().

                                                     {
   if (!other.head_) {
     return;
   }
   // We're going to chain other, thus we need to grab both guards.
   auto otherGuard = other.updateGuard();
   auto guard = updateGuard();
   if (options_.cacheChainLength) {
     if (other.options_.cacheChainLength) {
       chainLength_ += other.chainLength_;
     } else {
       chainLength_ += other.head_->computeChainDataLength();
     }
   }
   appendToChain(head_, std::move(other.head_), pack);
   other.chainLength_ = 0;
 }

void folly::IOBufQueue::append	(	IOBufQueue &&	other,
		bool	pack = `false`
	)

inline

Definition at line 301 of file IOBufQueue.h.

References append().

                                                      {
     append(other, pack); // call lvalue reference overload, above
   }

void folly::IOBufQueue::append	(	const void *	buf,
		size_t	len
	)

Copy len bytes, starting at buf, to the end of this queue. The caller retains ownership of the source data.

Definition at line 172 of file IOBufQueue.cpp.

References folly::IOBuf::append(), chainLength_, folly::IOBuf::create(), folly::gen::guard(), head_, max, min, folly::IOBuf::tailroom(), uint8_t, updateGuard(), and folly::IOBuf::writableTail().

                                                    {
   auto guard = updateGuard();
   auto src = static_cast<const uint8_t*>(buf);
   while (len != 0) {
     if ((head_ == nullptr) || head_->prev()->isSharedOne() ||
         (head_->prev()->tailroom() == 0)) {
       appendToChain(
           head_,
           IOBuf::create(
               std::max(MIN_ALLOC_SIZE, std::min(len, MAX_ALLOC_SIZE))),
           false);
     }
     IOBuf* last = head_->prev();
     std::size_t copyLen = std::min(len, (size_t)last->tailroom());
     memcpy(last->writableTail(), src, copyLen);
     src += copyLen;
     last->append(copyLen);
     chainLength_ += copyLen;
     len -= copyLen;
   }
 }

void folly::IOBufQueue::append ( StringPiece sp )

inline

Copy a string to the end of this queue. The caller retains ownership of the source data.

Definition at line 315 of file IOBufQueue.h.

References append(), folly::Range< Iter >::data(), folly::Range< Iter >::size(), and wrapBuffer().

                               {
     append(sp.data(), sp.size());
   }

void folly::IOBufQueue::appendToString ( std::string & out ) const

Append the queue to a std::string. Non-destructive.

Definition at line 340 of file IOBufQueue.cpp.

References folly::IOBufQueue::Options::cacheChainLength, folly::IOBufQueue::WritableRangeCacheData::cachedRange, cachePtr_, chainLength_, head_, options_, folly::range(), and tailStart_.

Referenced by options(), and TEST().

                                                     {
   if (!head_) {
     return;
   }
   auto len = options_.cacheChainLength
       ? chainLength_ + (cachePtr_->cachedRange.first - tailStart_)
       : head_->computeChainDataLength() +
           (cachePtr_->cachedRange.first - tailStart_);
   out.reserve(out.size() + len);
 
   for (auto range : *head_) {
     out.append(reinterpret_cast<const char*>(range.data()), range.size());
   }
 
   if (tailStart_ != cachePtr_->cachedRange.first) {
     out.append(
         reinterpret_cast<const char*>(tailStart_),
         cachePtr_->cachedRange.first - tailStart_);
   }
 }

static Options folly::IOBufQueue::cacheChainLength ( )

inlinestatic

Commonly used Options, currently the only possible value other than the default.

Definition at line 83 of file IOBufQueue.h.

References folly::IOBufQueue::Options::cacheChainLength, and options().

Referenced by proxygen::SecondaryAuthManager::createAuthRequest(), TestPriorityMapBuilder::createVirtualStreams(), folly::io::StreamCodec::doUncompress(), HTTPUpstreamTest< SPDY3CodecPair >::enableExHeader(), fizz::sm::encodeAndAddBinders(), fizz::ExportedAuthenticator::getAuthenticatorContext(), getSynStream(), fizz::server::AeadCookieCipher< AeadType, HkdfType >::getTokenOrRetry(), proxygen::HTTPSession::onPingRequest(), proxygen::parse(), proxygen::parseUnidirectional(), fizz::sm::setupSchedulerAndContext(), TEST(), TEST_F(), TEST_P(), folly::bser::toBserIOBuf(), fizz::ExportedAuthenticator::validate(), and wangle::test::BytesReflector::write().

                                     {
     Options options;
     options.cacheChainLength = true;
     return options;
   }

size_t folly::IOBufQueue::chainLength ( ) const

inline

Total chain length, only valid if cacheLength was specified in the constructor.

Definition at line 492 of file IOBufQueue.h.

References folly::IOBufQueue::Options::cacheChainLength, folly::IOBufQueue::WritableRangeCacheData::cachedRange, cachePtr_, chainLength_, dcheckCacheIntegrity(), options_, tailStart_, and UNLIKELY.

Referenced by fizz::AsyncFizzBase::checkBufLen(), wangle::LineBasedFrameDecoder::decode(), wangle::FixedLengthFrameDecoder::decode(), ByteToStringDecoder::decode(), wangle::LengthFieldBasedFrameDecoder::decode(), proxygen::QPACKEncoder::decodeDecoderStream(), proxygen::QPACKDecoder::decodeEncoderStream(), fizz::ReadRecordLayer::decodeHandshakeMessage(), folly::io::StreamCodec::doUncompress(), fizz::sm::encodeAndAddBinders(), wangle::LineBasedFrameDecoder::findEndOfLine(), proxygen::HTTP2Codec::generateBody(), proxygen::HTTP2Codec::generateCertificate(), proxygen::HTTP2Codec::generateContinuation(), proxygen::SPDYCodec::generateGoaway(), proxygen::SPDYCodec::generatePingCommon(), proxygen::SPDYCodec::generateRstStream(), proxygen::SPDYCodec::generateSettings(), proxygen::HTTP2Codec::generateTrailers(), proxygen::SPDYCodec::generateWindowUpdate(), fizz::EncryptedReadRecordLayer::getDecryptedBuf(), proxygen::HTTPSession::getNextToSend(), proxygen::HTTPTransaction::markEgressComplete(), proxygen::HTTPTransaction::notifyTransportPendingEgress(), proxygen::HTTPSession::onPingRequest(), proxygen::parse(), proxygen::HTTP2Codec::parseCertificate(), proxygen::HTTP2Codec::parseFrame(), proxygen::HTTP2Codec::parseHeadersDecodeFrames(), NaiveRoutingDataHandler::parseRoutingData(), proxygen::parseUnidirectional(), fizz::PlaintextReadRecordLayer::read(), proxygen::HTTPTransaction::sendDeferredBody(), proxygen::HTTPTransaction::sendEOM(), proxygen::HTTPSession::sessionByteOffset(), fizz::sm::setupSchedulerAndContext(), TEST(), folly::bser::toBserIOBuf(), and proxygen::HTTPTransaction::updateHandlerPauseState().

                              {
     if (UNLIKELY(!options_.cacheChainLength)) {
       throw std::invalid_argument("IOBufQueue: chain length not cached");
     }
     dcheckCacheIntegrity();
     return chainLength_ + (cachePtr_->cachedRange.first - tailStart_);
   }

void folly::IOBufQueue::clear ( )

Clear the queue. Note that this does not release the buffers, it just sets their length to zero; useful if you want to reuse the same queue without reallocating.

Definition at line 327 of file IOBufQueue.cpp.

References chainLength_, folly::IOBuf::clear(), folly::gen::guard(), head_, folly::IOBuf::next(), and updateGuard().

Referenced by proxygen::HPACKEncodeBuffer::clear(), options(), proxygen::HTTP2Codec::parseCertificate(), TEST(), and TEST_F().

                        {
   if (!head_) {
     return;
   }
   auto guard = updateGuard();
   IOBuf* buf = head_.get();
   do {
     buf->clear();
     buf = buf->next();
   } while (buf != head_.get());
   chainLength_ = 0;
 }

void folly::IOBufQueue::clearWritableRangeCache ( )

inlineprivate

Clear current writable tail cache and reset it to localCache_

Definition at line 596 of file IOBufQueue.h.

References folly::IOBufQueue::WritableRangeCacheData::attached, cachePtr_, flushCache(), localCache_, and folly::gen::move.

Referenced by operator=(), and ~IOBufQueue().

                                  {
     flushCache();
 
     if (cachePtr_ != &localCache_) {
       localCache_ = std::move(*cachePtr_);
       cachePtr_ = &localCache_;
     }
 
     DCHECK(cachePtr_ == &localCache_ && localCache_.attached);
   }

void folly::IOBufQueue::dcheckCacheIntegrity ( ) const

inlineprivate

Definition at line 559 of file IOBufQueue.h.

References folly::IOBufQueue::WritableRangeCacheData::attached, folly::IOBufQueue::WritableRangeCacheData::cachedRange, cachePtr_, folly::IOBuf::prev(), folly::IOBuf::tailroom(), tailStart_, and folly::IOBuf::writableTail().

Referenced by chainLength(), empty(), fillWritableRangeCache(), flushCache(), postallocate(), preallocate(), tailroom(), and writableTail().

                                     {
     // Tail start should always be less than tail end.
     DCHECK_LE((void*)tailStart_, (void*)cachePtr_->cachedRange.first);
     DCHECK_LE(
         (void*)cachePtr_->cachedRange.first,
         (void*)cachePtr_->cachedRange.second);
     DCHECK(
         cachePtr_->cachedRange.first != nullptr ||
         cachePtr_->cachedRange.second == nullptr);
 
     // There is always an attached cache instance.
     DCHECK(cachePtr_->attached);
 
     // Either cache is empty or it coincides with the tail.
     DCHECK(
         cachePtr_->cachedRange.first == nullptr ||
         (head_ != nullptr && tailStart_ == head_->prev()->writableTail() &&
          tailStart_ <= cachePtr_->cachedRange.first &&
          cachePtr_->cachedRange.first >= head_->prev()->writableTail() &&
          cachePtr_->cachedRange.second ==
              head_->prev()->writableTail() + head_->prev()->tailroom()));
   }

bool folly::IOBufQueue::empty ( ) const

inline

Returns true iff the IOBuf chain length is 0.

Definition at line 503 of file IOBufQueue.h.

References folly::IOBufQueue::WritableRangeCacheData::cachedRange, cachePtr_, dcheckCacheIntegrity(), head_, and tailStart_.

Referenced by folly::Subprocess::communicateIOBuf(), fizz::test::LocalTransport::deliverData(), fizz::sm::getCertificateRequest(), fizz::EncryptedReadRecordLayer::getDecryptedBuf(), proxygen::HTTPSession::getNextToSend(), folly::AsyncPipeWriter::handleWrite(), fizz::ReadRecordLayer::hasUnparsedHandshakeData(), fizz::server::looksLikeV2ClientHello(), proxygen::HTTP2Codec::parseCertificate(), fizz::PlaintextReadRecordLayer::read(), proxygen::HTTPSession::readEOF(), fizz::ReadRecordLayer::readEvent(), TEST(), and fizz::EncryptedWriteRecordLayer::write().

                      {
     dcheckCacheIntegrity();
     return !head_ ||
         (head_->empty() && cachePtr_->cachedRange.first == tailStart_);
   }

void folly::IOBufQueue::fillWritableRangeCache ( WritableRangeCacheData & dest )

inlineprivate

Populate dest with writable tail range cache.

Definition at line 585 of file IOBufQueue.h.

References cachePtr_, dcheckCacheIntegrity(), upload::dest, and folly::gen::move.

                                                             {
     dcheckCacheIntegrity();
     if (cachePtr_ != &dest) {
       dest = std::move(*cachePtr_);
       cachePtr_ = &dest;
     }
   }

void folly::IOBufQueue::flushCache ( ) const

inlineprivate

Commit any pending changes to the tail of the queue.

Definition at line 610 of file IOBufQueue.h.

References folly::IOBufQueue::WritableRangeCacheData::cachedRange, cachePtr_, chainLength_, dcheckCacheIntegrity(), folly::IOBuf::prev(), and tailStart_.

Referenced by clearWritableRangeCache(), front(), preallocateSlow(), and updateGuard().

                           {
     dcheckCacheIntegrity();
 
     if (tailStart_ != cachePtr_->cachedRange.first) {
       auto buf = head_->prev();
       DCHECK_EQ(
           (void*)(buf->writableTail() + buf->tailroom()),
           (void*)cachePtr_->cachedRange.second);
       auto len = cachePtr_->cachedRange.first - tailStart_;
       buf->append(len);
       chainLength_ += len;
       tailStart_ += len;
     }
   }

const folly::IOBuf* folly::IOBufQueue::front ( ) const

inline

Access the front IOBuf.

Note: caller will see the current state of the chain, but may not see future updates immediately, due to the presence of a tail cache. Note: the caller may potentially clone the chain, thus marking all buffers as shared. We may still continue writing to the tail of the last IOBuf without checking if it's shared, but this is fine, since the cloned IOBufs won't reference that data.

Definition at line 476 of file IOBufQueue.h.

References flushCache(), head_, and pop_front().

Referenced by proxygen::HPACKEncodeBuffer::addHeadroom(), wangle::LineBasedFrameDecoder::decode(), proxygen::QPACKEncoder::decodeDecoderStream(), proxygen::QPACKDecoder::decodeEncoderStream(), fizz::ReadRecordLayer::decodeHandshakeMessage(), HTTPParallelCodecTest::dumpToFile(), wangle::LineBasedFrameDecoder::findEndOfLine(), fizz::EncryptedWriteRecordLayer::getBufToEncrypt(), fizz::EncryptedReadRecordLayer::getDecryptedBuf(), wangle::LengthFieldBasedFrameDecoder::getUnadjustedFrameLength(), folly::AsyncPipeWriter::handleWrite(), proxygen::HTTPSession::hasMoreWrites(), fizz::server::looksLikeV2ClientHello(), proxygen::parse(), proxygen::HTTP2Codec::parseHeadersDecodeFrames(), proxygen::parseUnidirectional(), folly::Subprocess::pid(), proxygen::HTTPSession::processReadData(), fizz::PlaintextReadRecordLayer::read(), fizz::EncryptedReadRecordLayer::read(), proxygen::HTTPSession::scheduleWrite(), TEST(), TEST_F(), TEST_P(), and proxygen::HPACKEncodeBuffer::toBin().

                                   {
     flushCache();
     return head_.get();
   }

void folly::IOBufQueue::gather ( std::size_t maxLength )

Calls IOBuf::gather() on the head of the queue, if it exists.

Definition at line 361 of file IOBufQueue.cpp.

References folly::gen::guard(), head_, and updateGuard().

Referenced by options(), and TEST().

                                            {
   auto guard = updateGuard();
   if (head_ != nullptr) {
     head_->gather(maxLength);
   }
 }

std::pair< void *, std::size_t > folly::IOBufQueue::headroom ( )

Return a space to prepend bytes and the amount of headroom available.

Definition at line 111 of file IOBufQueue.cpp.

References head_.

Referenced by folly::IOBufQueue::WritableRangeCache::dcheckIntegrity().

                                                {
   // Note, headroom is independent from the tail, so we don't need to flush the
   // cache.
   if (head_) {
     return std::make_pair(head_->writableBuffer(), head_->headroom());
   } else {
     return std::make_pair(nullptr, 0);
   }
 }

void folly::IOBufQueue::markPrepended ( std::size_t n )

Indicate that n bytes from the headroom have been used.

Definition at line 121 of file IOBufQueue.cpp.

References chainLength_, and head_.

Referenced by folly::IOBufQueue::WritableRangeCache::dcheckIntegrity().

                                           {
   if (n == 0) {
     return;
   }
   // Note, headroom is independent from the tail, so we don't need to flush the
   // cache.
   assert(head_);
   head_->prepend(n);
   chainLength_ += n;
 }

std::unique_ptr<folly::IOBuf> folly::IOBufQueue::move ( )

inline

Transfer ownership of the queue's entire IOBuf chain to the caller.

Definition at line 459 of file IOBufQueue.h.

References chainLength_, folly::gen::guard(), head_, folly::gen::move, and updateGuard().

Referenced by BENCHMARK(), folly::AsyncSSLSocket::bioRead(), folly::io::test::compressSome(), wangle::SimpleDecode::decode(), wangle::LineBasedFrameDecoder::decode(), ByteToStringDecoder::decode(), proxygen::QPACKDecoder::decodeStreaming(), fizz::test::LocalTransport::deliverData(), folly::io::StreamCodec::doUncompress(), proxygen::compress::QPACKScheme::encode(), fizz::sm::encodeAndAddBinders(), proxygen::HTTP2Codec::generateBody(), proxygen::HTTP2Codec::generateCertificate(), fizz::sm::getCertificateRequest(), proxygen::HTTPSession::getNextToSend(), getSynStream(), proxygen::HTTPTransaction::markEgressComplete(), proxygen::ScopedHandler< HandlerType >::onEOM(), proxygen::HTTPSession::onPingRequest(), proxygen::HTTP2Codec::parseCertificate(), proxygen::HTTP2Codec::parseHeadersDecodeFrames(), HTTPParallelCodecTest::parseImpl(), NaiveRoutingDataHandler::parseRoutingData(), proxygen::parseUnidirectional(), folly::AsyncSocket::performRead(), preallocate_postallocate_bench(), fizz::EncryptedReadRecordLayer::read(), ProxyBackendHandler::read(), ProxyService::ProxyHandler::readDataAvailable(), StaticService::StaticHandler::readFile(), proxygen::HPACKEncodeBuffer::release(), proxygen::FakeHTTPCodecCallback::reset(), runArithmeticBench(), runPushBenchmark(), proxygen::HTTPSession::sendHeaders(), fizz::sm::setupSchedulerAndContext(), HTTPParallelCodecTest::SetUpUpstreamTest(), proxygen::HTTPSession::shutdownTransportWithReset(), folly::io::test::CompressionTest::split(), TEST(), TEST_F(), folly::bser::toBserIOBuf(), and folly::io::test::uncompressSome().

                                    {
     auto guard = updateGuard();
     std::unique_ptr<folly::IOBuf> res = std::move(head_);
     chainLength_ = 0;
     return res;
   }

IOBufQueue & folly::IOBufQueue::operator= ( IOBufQueue && other )

Definition at line 91 of file IOBufQueue.cpp.

References folly::IOBufQueue::WritableRangeCacheData::attached, folly::IOBufQueue::WritableRangeCacheData::cachedRange, chainLength_, clearWritableRangeCache(), head_, localCache_, folly::gen::move, options_, and tailStart_.

                                                     {
   if (&other != this) {
     other.clearWritableRangeCache();
     clearWritableRangeCache();
 
     options_ = other.options_;
     head_ = std::move(other.head_);
     chainLength_ = other.chainLength_;
 
     tailStart_ = other.tailStart_;
     localCache_.cachedRange = other.localCache_.cachedRange;
     localCache_.attached = true;
 
     other.chainLength_ = 0;
     other.tailStart_ = nullptr;
     other.localCache_.cachedRange = {nullptr, nullptr};
   }
   return *this;
 }

IOBufQueue& folly::IOBufQueue::operator= ( const IOBufQueue & )

privatedelete

const Options& folly::IOBufQueue::options ( ) const

inline

Definition at line 509 of file IOBufQueue.h.

References appendToString(), clear(), gather(), IOBufQueue(), folly::pushmi::__adl::noexcept(), folly::IOBufQueue::WritableRangeCacheData::operator=(), options_, split(), and string.

Referenced by cacheChainLength(), and folly::IOBufQueue::WritableRangeCache::dcheckIntegrity().

                                  {
     return options_;
   }

std::unique_ptr< folly::IOBuf > folly::IOBufQueue::pop_front ( )

returns the first IOBuf in the chain and removes it from the chain

Returns: first IOBuf in the chain or nullptr if none.

Definition at line 316 of file IOBufQueue.cpp.

References chainLength_, folly::gen::guard(), head_, folly::gen::move, folly::IOBuf::pop(), and updateGuard().

Referenced by TestAsyncTransport::addReadEvent(), front(), fizz::EncryptedWriteRecordLayer::getBufToEncrypt(), proxygen::HTTPSession::processReadData(), and TEST().

                                                 {
   auto guard = updateGuard();
   if (!head_) {
     return nullptr;
   }
   chainLength_ -= head_->length();
   std::unique_ptr<folly::IOBuf> retBuf = std::move(head_);
   head_ = retBuf->pop();
   return retBuf;
 }

void folly::IOBufQueue::postallocate ( std::size_t n )

inline

Tell the queue that the caller has written data into the first n bytes provided by the previous preallocate() call.

Note: n should be less than or equal to the size returned by preallocate(). If n is zero, the caller may skip the call to postallocate(). If n is nonzero, the caller must not invoke any other non-const methods on this IOBufQueue between the call to preallocate and the call to postallocate().

Definition at line 380 of file IOBufQueue.h.

References folly::IOBufQueue::WritableRangeCacheData::cachedRange, cachePtr_, and dcheckCacheIntegrity().

Referenced by allocate(), folly::IOBufQueue::WritableRangeCache::appendSlow(), folly::io::StreamCodec::doUncompress(), proxygen::SPDYCodec::generateDataFrame(), proxygen::HTTP1xCodec::generateHeader(), folly::AsyncUDPServerSocket::onDataAvailable(), folly::Subprocess::pid(), preallocate_postallocate_bench(), ProxyService::ProxyHandler::readDataAvailable(), wangle::AsyncSocketHandler::readDataAvailable(), fizz::AsyncFizzBase::readDataAvailable(), proxygen::HTTPSession::readDataAvailable(), StaticService::StaticHandler::readFile(), and TEST().

                                  {
     dcheckCacheIntegrity();
     DCHECK_LE(
         (void*)(cachePtr_->cachedRange.first + n),
         (void*)cachePtr_->cachedRange.second);
     cachePtr_->cachedRange.first += n;
   }

std::pair<void*, std::size_t> folly::IOBufQueue::preallocate	(	std::size_t	min,
		std::size_t	newAllocationSize,
		std::size_t	max = `std::numeric_limits<std::size_t>::max()`
	)

inline

Obtain a writable block of contiguous bytes at the end of this queue, allocating more space if necessary. The amount of space reserved will be at least min. If min contiguous space is not available at the end of the queue, and IOBuf with size newAllocationSize is appended to the chain and returned. The actual available space may be larger than newAllocationSize, but will be truncated to max, if specified.

If the caller subsequently writes anything into the returned space, it must call the postallocate() method.

Returns: The starting address of the block and the length in bytes.

Note: The point of the preallocate()/postallocate() mechanism is to support I/O APIs such as Thrift's TAsyncSocket::ReadCallback that request a buffer from the application and then, in a later callback, tell the application how much of the buffer they've filled with data.

Definition at line 356 of file IOBufQueue.h.

References dcheckCacheIntegrity(), LIKELY, max, preallocateSlow(), tailroom(), and writableTail().

Referenced by allocate(), folly::io::StreamCodec::doUncompress(), proxygen::HTTP1xCodec::generateHeader(), ProxyService::ProxyHandler::getReadBuffer(), wangle::AsyncSocketHandler::getReadBuffer(), folly::AsyncUDPServerSocket::getReadBuffer(), fizz::AsyncFizzBase::getReadBuffer(), proxygen::HTTPSession::getReadBuffer(), folly::Subprocess::pid(), preallocate_postallocate_bench(), StaticService::StaticHandler::readFile(), TEST(), and TEST_F().

                                                          {
     dcheckCacheIntegrity();
 
     if (LIKELY(writableTail() != nullptr && tailroom() >= min)) {
       return std::make_pair(
           writableTail(), std::min<std::size_t>(max, tailroom()));
     }
 
     return preallocateSlow(min, newAllocationSize, max);
   }

pair< void *, std::size_t > folly::IOBufQueue::preallocateSlow	(	std::size_t	min,
		std::size_t	newAllocationSize,
		std::size_t	max
	)

private

Definition at line 207 of file IOBufQueue.cpp.

References folly::IOBufQueue::WritableRangeCacheData::cachedRange, cachePtr_, folly::IOBuf::create(), flushCache(), head_, max, folly::gen::move, tailroom(), tailStart_, and writableTail().

Referenced by preallocate(), and updateWritableTailCache().

                    {
   // Avoid grabbing update guard, since we're manually setting the cache ptrs.
   flushCache();
   // Allocate a new buffer of the requested max size.
   unique_ptr<IOBuf> newBuf(IOBuf::create(std::max(min, newAllocationSize)));
 
   tailStart_ = newBuf->writableTail();
   cachePtr_->cachedRange = std::pair<uint8_t*, uint8_t*>(
       tailStart_, tailStart_ + newBuf->tailroom());
   appendToChain(head_, std::move(newBuf), false);
   return make_pair(writableTail(), std::min<std::size_t>(max, tailroom()));
 }

void folly::IOBufQueue::prepend	(	const void *	buf,
		std::size_t	n
	)

Prepend an existing range; throws std::overflow_error if not enough room.

Definition at line 132 of file IOBufQueue.cpp.

References chainLength_, and head_.

Referenced by folly::IOBufQueue::WritableRangeCache::dcheckIntegrity(), TEST(), and folly::bser::toBserIOBuf().

                                                      {
   // We're not touching the tail, so we don't need to flush the cache.
   auto hroom = head_->headroom();
   if (!head_ || hroom < n) {
     throw std::overflow_error("Not enough room to prepend");
   }
   memcpy(head_->writableBuffer() + hroom - n, buf, n);
   head_->prepend(n);
   chainLength_ += n;
 }

std::unique_ptr<folly::IOBuf> folly::IOBufQueue::split ( size_t n )

inline

Split off the first n bytes of the queue into a separate IOBuf chain, and transfer ownership of the new chain to the caller. The IOBufQueue retains ownership of everything after the split point.

Warning: If the split point lies in the middle of some IOBuf within the chain, this function may, as an implementation detail, clone that IOBuf.

Exceptions

std::underflow_error if n exceeds the number of bytes in the queue.

Definition at line 420 of file IOBufQueue.h.

Referenced by wangle::LineBasedFrameDecoder::decode(), wangle::FixedLengthFrameDecoder::decode(), wangle::LengthFieldBasedFrameDecoder::decode(), fizz::ReadRecordLayer::decodeHandshakeMessage(), fizz::test::LocalTransport::deliverData(), fizz::sm::encodeAndAddBinders(), proxygen::HTTP2Codec::generateBody(), proxygen::HTTP2Codec::generateContinuation(), proxygen::HTTP2Codec::generateTrailers(), proxygen::HTTPSession::getNextToSend(), folly::AsyncUDPServerSocket::onDataAvailable(), options(), proxygen::parse(), proxygen::HTTPTransaction::sendDeferredBody(), fizz::sm::setupSchedulerAndContext(), splitAtMost(), and TEST().

                                             {
     return split(n, true);
   }

unique_ptr< IOBuf > folly::IOBufQueue::split	(	size_t	n,
		bool	throwOnUnderflow
	)

private

Definition at line 223 of file IOBufQueue.cpp.

References chainLength_, folly::IOBuf::create(), folly::gen::guard(), head_, folly::gen::move, UNLIKELY, and updateGuard().

                                                                    {
   auto guard = updateGuard();
   unique_ptr<IOBuf> result;
   while (n != 0) {
     if (head_ == nullptr) {
       if (throwOnUnderflow) {
         throw std::underflow_error(
             "Attempt to remove more bytes than are present in IOBufQueue");
       } else {
         break;
       }
     } else if (head_->length() <= n) {
       n -= head_->length();
       chainLength_ -= head_->length();
       unique_ptr<IOBuf> remainder = head_->pop();
       appendToChain(result, std::move(head_), false);
       head_ = std::move(remainder);
     } else {
       unique_ptr<IOBuf> clone = head_->cloneOne();
       clone->trimEnd(clone->length() - n);
       appendToChain(result, std::move(clone), false);
       head_->trimStart(n);
       chainLength_ -= n;
       break;
     }
   }
   if (UNLIKELY(result == nullptr)) {
     return IOBuf::create(0);
   }
   return result;
 }

std::unique_ptr<folly::IOBuf> folly::IOBufQueue::splitAtMost ( size_t n )

inline

Similar to split, but will return the entire queue instead of throwing if n exceeds the number of bytes in the queue.

Definition at line 428 of file IOBufQueue.h.

References split(), trimEnd(), trimEndAtMost(), trimStart(), and trimStartAtMost().

Referenced by proxygen::HTTP2Codec::generateCertificate(), fizz::EncryptedWriteRecordLayer::getBufToEncrypt(), fizz::sm::getCertificateRequest(), fizz::PlaintextReadRecordLayer::read(), and TEST().

                                                   {
     return split(n, false);
   }

size_t folly::IOBufQueue::tailroom ( ) const

inline

Definition at line 403 of file IOBufQueue.h.

References folly::IOBufQueue::WritableRangeCacheData::cachedRange, cachePtr_, and dcheckCacheIntegrity().

Referenced by proxygen::SPDYCodec::generateDataFrame(), preallocate(), preallocateSlow(), and folly::io::test::uncompressSome().

                           {
     dcheckCacheIntegrity();
     return cachePtr_->cachedRange.second - cachePtr_->cachedRange.first;
   }

void folly::IOBufQueue::trimEnd ( size_t amount )

Similar to IOBuf::trimEnd, but works on the whole queue. Will pop off buffers that have been completely trimmed.

Definition at line 283 of file IOBufQueue.cpp.

References trimEndAtMost().

Referenced by fizz::EncryptedReadRecordLayer::read(), splitAtMost(), and TEST().

                                       {
   auto trimmed = trimEndAtMost(amount);
   if (trimmed != amount) {
     throw std::underflow_error(
         "Attempt to trim more bytes than are present in IOBufQueue");
   }
 }

size_t folly::IOBufQueue::trimEndAtMost ( size_t amount )

Similar to trimEnd, but will trim at most amount bytes and returns the number of bytes trimmed.

Definition at line 291 of file IOBufQueue.cpp.

References chainLength_, folly::gen::guard(), head_, and updateGuard().

Referenced by splitAtMost(), TEST(), and trimEnd().

                                               {
   auto guard = updateGuard();
   auto original = amount;
   while (amount > 0) {
     if (!head_) {
       break;
     }
     if (head_->prev()->length() > amount) {
       head_->prev()->trimEnd(amount);
       chainLength_ -= amount;
       amount = 0;
       break;
     }
     amount -= head_->prev()->length();
     chainLength_ -= head_->prev()->length();
 
     if (head_->isChained()) {
       head_->prev()->unlink();
     } else {
       head_.reset();
     }
   }
   return original - amount;
 }

void folly::IOBufQueue::trimStart ( size_t amount )

Similar to IOBuf::trimStart, but works on the whole queue. Will pop off buffers that have been completely trimmed.

Definition at line 255 of file IOBufQueue.cpp.

References trimStartAtMost().

Referenced by folly::AsyncSSLSocket::bioRead(), wangle::LineBasedFrameDecoder::decode(), wangle::LengthFieldBasedFrameDecoder::decode(), proxygen::QPACKEncoder::decodeDecoderStream(), proxygen::QPACKDecoder::decodeEncoderStream(), proxygen::QPACKDecoder::decodeStreaming(), fizz::EncryptedReadRecordLayer::getDecryptedBuf(), folly::AsyncPipeWriter::handleWrite(), folly::AsyncSocket::performRead(), folly::Subprocess::pid(), proxygen::HTTPSession::processReadData(), fizz::PlaintextReadRecordLayer::read(), splitAtMost(), and TEST().

                                         {
   auto trimmed = trimStartAtMost(amount);
   if (trimmed != amount) {
     throw std::underflow_error(
         "Attempt to trim more bytes than are present in IOBufQueue");
   }
 }

size_t folly::IOBufQueue::trimStartAtMost ( size_t amount )

Similar to trimStart, but will trim at most amount bytes and returns the number of bytes trimmed.

Definition at line 263 of file IOBufQueue.cpp.

References chainLength_, folly::gen::guard(), head_, and updateGuard().

Referenced by wangle::LengthFieldBasedFrameDecoder::decode(), splitAtMost(), TEST(), and trimStart().

                                                 {
   auto guard = updateGuard();
   auto original = amount;
   while (amount > 0) {
     if (!head_) {
       break;
     }
     if (head_->length() > amount) {
       head_->trimStart(amount);
       chainLength_ -= amount;
       amount = 0;
       break;
     }
     amount -= head_->length();
     chainLength_ -= head_->length();
     head_ = head_->pop();
   }
   return original - amount;
 }

void folly::IOBufQueue::updateCacheRef ( WritableRangeCacheData & newRef )

inlineprivate

Definition at line 626 of file IOBufQueue.h.

References cachePtr_.

                                                       {
     cachePtr_ = &newRef;
   }

auto folly::IOBufQueue::updateGuard ( )

inlineprivate

This guard should be taken by any method that intends to do any changes to in data_ (e.g. appending to it).

It flushes the writable tail cache and refills it on destruction.

Definition at line 43 of file IOBufQueue.h.

References flushCache(), folly::makeGuard(), and updateWritableTailCache().

Referenced by append(), clear(), gather(), move(), pop_front(), split(), trimEndAtMost(), and trimStartAtMost().

                      {
     flushCache();
     return folly::makeGuard([this] { updateWritableTailCache(); });
   }

void folly::IOBufQueue::updateWritableTailCache ( )

inlineprivate

Update cached writable tail range. Called by updateGuard()

Definition at line 633 of file IOBufQueue.h.

References folly::IOBufQueue::WritableRangeCacheData::cachedRange, cachePtr_, folly::IOBuf::isSharedOne(), LIKELY, max, preallocateSlow(), folly::IOBuf::prev(), folly::IOBuf::tailroom(), tailStart_, and folly::IOBuf::writableTail().

Referenced by updateGuard().

                                  {
     if (LIKELY(head_ != nullptr)) {
       IOBuf* buf = head_->prev();
       if (LIKELY(!buf->isSharedOne())) {
         tailStart_ = buf->writableTail();
         cachePtr_->cachedRange = std::pair<uint8_t*, uint8_t*>(
             tailStart_, tailStart_ + buf->tailroom());
         return;
       }
     }
     tailStart_ = nullptr;
     cachePtr_->cachedRange = std::pair<uint8_t*, uint8_t*>();
   }

void folly::IOBufQueue::wrapBuffer	(	const void *	buf,
		size_t	len,
		std::size_t	blockSize = `(1U << 31)`
	)

Append a chain of IOBuf objects that point to consecutive regions within buf.

Just like IOBuf::wrapBuffer, this should only be used when the caller knows ahead of time and can ensure that all IOBuf objects that will point to this buffer will be destroyed before the buffer itself is destroyed; all other caveats from wrapBuffer also apply.

Every buffer except for the last will wrap exactly blockSize bytes. Importantly, this method may be used to wrap buffers larger than 4GB.

Definition at line 194 of file IOBufQueue.cpp.

References append(), min, uint8_t, and folly::IOBuf::wrapBuffer().

Referenced by append(), folly::Subprocess::communicate(), and TEST().

                          {
   auto src = static_cast<const uint8_t*>(buf);
   while (len != 0) {
     size_t n = std::min(len, size_t(blockSize));
     append(IOBuf::wrapBuffer(src, n));
     src += n;
     len -= n;
   }
 }

void* folly::IOBufQueue::writableTail ( ) const

inline

Definition at line 398 of file IOBufQueue.h.

References folly::IOBufQueue::WritableRangeCacheData::cachedRange, cachePtr_, and dcheckCacheIntegrity().

Referenced by preallocate(), and preallocateSlow().

                              {
     dcheckCacheIntegrity();
     return cachePtr_->cachedRange.first;
   }

Member Data Documentation

WritableRangeCacheData* folly::IOBufQueue::cachePtr_ {nullptr}

private

Definition at line 556 of file IOBufQueue.h.

Referenced by appendToString(), chainLength(), clearWritableRangeCache(), dcheckCacheIntegrity(), empty(), fillWritableRangeCache(), flushCache(), postallocate(), preallocateSlow(), tailroom(), updateCacheRef(), updateWritableTailCache(), and writableTail().

size_t folly::IOBufQueue::chainLength_ {0}

mutableprivate

Definition at line 547 of file IOBufQueue.h.

Referenced by append(), appendToString(), chainLength(), clear(), flushCache(), IOBufQueue(), markPrepended(), move(), operator=(), pop_front(), prepend(), split(), trimEndAtMost(), and trimStartAtMost().

std::unique_ptr<folly::IOBuf> folly::IOBufQueue::head_

private

Everything that has been appended but not yet discarded or moved out Note: anything that needs to operate on a tail should either call flushCache() or grab updateGuard() (it will flush the cache itself).

Definition at line 553 of file IOBufQueue.h.

Referenced by append(), appendToString(), clear(), folly::IOBufQueue::WritableRangeCache::dcheckIntegrity(), empty(), front(), gather(), headroom(), IOBufQueue(), markPrepended(), move(), operator=(), pop_front(), preallocateSlow(), prepend(), split(), trimEndAtMost(), and trimStartAtMost().

const size_t folly::IOBufQueue::kChainLengthNotCached = (size_t)-1

staticprivate

Definition at line 537 of file IOBufQueue.h.

WritableRangeCacheData folly::IOBufQueue::localCache_

private

Definition at line 557 of file IOBufQueue.h.

Referenced by clearWritableRangeCache(), IOBufQueue(), and operator=().

Options folly::IOBufQueue::options_

private

Definition at line 542 of file IOBufQueue.h.

Referenced by append(), appendToString(), chainLength(), operator=(), and options().

uint8_t* folly::IOBufQueue::tailStart_ {nullptr}

mutableprivate

Definition at line 555 of file IOBufQueue.h.

Referenced by appendToString(), chainLength(), dcheckCacheIntegrity(), empty(), flushCache(), IOBufQueue(), operator=(), preallocateSlow(), and updateWritableTailCache().

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

proxygen/folly/folly/io/IOBufQueue.h
proxygen/folly/folly/io/IOBufQueue.cpp

Classes

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation