folly::IOBufQueue::WritableRangeCache Class Reference

#include <IOBufQueue.h>

Public Member Functions
	WritableRangeCache (folly::IOBufQueue *q=nullptr)
	WritableRangeCache (WritableRangeCache &&other)
WritableRangeCache &	operator= (WritableRangeCache &&other)
	WritableRangeCache (const WritableRangeCache &other)
WritableRangeCache &	operator= (const WritableRangeCache &other)
	~WritableRangeCache ()
void	reset (IOBufQueue *q)
IOBufQueue *	queue ()
uint8_t *	writableData ()
size_t	length ()
void	append (size_t n)
void	appendUnsafe (size_t n)
void	fillCache ()

Private Member Functions
FOLLY_NOINLINE void	appendSlow (size_t n)
void	dcheckIntegrity ()

Private Attributes
WritableRangeCacheData	data_
IOBufQueue *	queue_

Detailed Description

WritableRangeCache represents a cache of current writable tail and provides cheap and simple interface to append to it that avoids paying the cost of preallocate/postallocate pair (i.e. indirections and checks).

The cache is flushed on destruction/copy/move and on non-const accesses to the underlying IOBufQueue.

Note: there can be only one active cache for a given IOBufQueue, i.e. when you fill a cache object it automatically invalidates other cache (if any).

Definition at line 101 of file IOBufQueue.h.

Constructor & Destructor Documentation

folly::IOBufQueue::WritableRangeCache::WritableRangeCache ( folly::IOBufQueue *  q = nullptr )

inlineexplicit

Definition at line 103 of file IOBufQueue.h.

                                                              : queue_(q) {
      if (queue_) {
        fillCache();
      }
    }

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

inline

Move constructor/assignment can move the cached range, but must update the reference in IOBufQueue.

Definition at line 113 of file IOBufQueue.h.

References data_.

        : data_(std::move(other.data_)), queue_(other.queue_) {
      if (data_.attached) {
        queue_->updateCacheRef(data_);
      }
    }

folly::IOBufQueue::WritableRangeCache::WritableRangeCache ( const WritableRangeCache &  other )

inline

Copy constructor/assignment cannot copy the cached range.

Definition at line 137 of file IOBufQueue.h.

        : queue_(other.queue_) {}

folly::IOBufQueue::WritableRangeCache::~WritableRangeCache ( )

inline

Definition at line 149 of file IOBufQueue.h.

References data_.

                          {
      if (data_.attached) {
        queue_->clearWritableRangeCache();
      }
    }

Member Function Documentation

void folly::IOBufQueue::WritableRangeCache::append ( size_t  n )

inline

Mark n bytes as occupied (e.g. postallocate).

Definition at line 200 of file IOBufQueue.h.

References data_, and LIKELY.

                          {
      dcheckIntegrity();
      // This can happen only if somebody is misusing the interface.
      // E.g. calling append after touching IOBufQueue or without checking
      // the length().
      if (LIKELY(data_.cachedRange.first != nullptr)) {
        DCHECK_LE(n, length());
        data_.cachedRange.first += n;
      } else {
        appendSlow(n);
      }
    }

FOLLY_NOINLINE void folly::IOBufQueue::WritableRangeCache::appendSlow ( size_t  n )

inlineprivate

Definition at line 233 of file IOBufQueue.h.

References folly::IOBufQueue::postallocate().

                                             {
      queue_->postallocate(n);
    }

void folly::IOBufQueue::WritableRangeCache::appendUnsafe ( size_t  n )

inline

Same as append(n), but avoids checking if there is a cache. The caller must guarantee that the cache is set (e.g. the caller just called fillCache or checked that it's not empty).

Definition at line 218 of file IOBufQueue.h.

References data_.

                                {
      data_.cachedRange.first += n;
    }

void folly::IOBufQueue::WritableRangeCache::dcheckIntegrity ( )

inlineprivate

Definition at line 237 of file IOBufQueue.h.

References folly::IOBufQueue::append(), folly::IOBufQueue::WritableRangeCacheData::attached, folly::IOBufQueue::WritableRangeCacheData::cachedRange, folly::IOBufQueue::head_, folly::IOBufQueue::headroom(), folly::IOBufQueue::IOBufQueue(), folly::IOBufQueue::markPrepended(), folly::IOBufQueue::options(), folly::IOBufQueue::prepend(), and folly::IOBufQueue::~IOBufQueue().

                           {
      // Tail start should always be less than tail end.
      DCHECK_LE(
          (void*)data_.cachedRange.first, (void*)data_.cachedRange.second);
      DCHECK(
          data_.cachedRange.first != nullptr ||
          data_.cachedRange.second == nullptr);

      // Cached range should be always empty if the cache is not attached.
      DCHECK(
          data_.attached ||
          (data_.cachedRange.first == nullptr &&
           data_.cachedRange.second == nullptr));

      // We cannot be in attached state if the queue_ is not set.
      DCHECK(queue_ != nullptr || !data_.attached);

      // If we're attached and the cache is not empty, then it should coincide
      // with the tail buffer.
      DCHECK(
          !data_.attached || data_.cachedRange.first == nullptr ||
          (queue_->head_ != nullptr &&
           data_.cachedRange.first >= queue_->head_->prev()->writableTail() &&
           data_.cachedRange.second ==
               queue_->head_->prev()->writableTail() +
                   queue_->head_->prev()->tailroom()));
    }

void folly::IOBufQueue::WritableRangeCache::fillCache ( )

inline

Fill the cache of writable tail from the underlying IOBufQueue.

Definition at line 225 of file IOBufQueue.h.

References data_.

                     {
      queue_->fillWritableRangeCache(data_);
    }

size_t folly::IOBufQueue::WritableRangeCache::length ( )

inline

Return a length of cached writable tail.

Note: doesn't populate cache.

Definition at line 192 of file IOBufQueue.h.

References data_.

                    {
      dcheckIntegrity();
      return data_.cachedRange.second - data_.cachedRange.first;
    }

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

inline

Definition at line 119 of file IOBufQueue.h.

References data_, and folly::gen::move.

                                                              {
      if (data_.attached) {
        queue_->clearWritableRangeCache();
      }

      data_ = std::move(other.data_);
      queue_ = other.queue_;

      if (data_.attached) {
        queue_->updateCacheRef(data_);
      }

      return *this;
    }

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

inline

Definition at line 139 of file IOBufQueue.h.

References data_, and queue_.

                                                                   {
      if (data_.attached) {
        queue_->clearWritableRangeCache();
      }

      queue_ = other.queue_;

      return *this;
    }

IOBufQueue* folly::IOBufQueue::WritableRangeCache::queue ( )

inline

Get a pointer to the underlying IOBufQueue object.

Definition at line 173 of file IOBufQueue.h.

                        {
      return queue_;
    }

void folly::IOBufQueue::WritableRangeCache::reset ( IOBufQueue *  q )

inline

Reset the underlying IOBufQueue, will flush current cache if present.

Definition at line 158 of file IOBufQueue.h.

References data_.

                              {
      if (data_.attached) {
        queue_->clearWritableRangeCache();
      }

      queue_ = q;

      if (queue_) {
        fillCache();
      }
    }

uint8_t* folly::IOBufQueue::WritableRangeCache::writableData ( )

inline

Return a pointer to the start of cached writable tail.

Note: doesn't populate cache.

Definition at line 182 of file IOBufQueue.h.

References data_.

                            {
      dcheckIntegrity();
      return data_.cachedRange.first;
    }

Member Data Documentation

WritableRangeCacheData folly::IOBufQueue::WritableRangeCache::data_

private

Definition at line 230 of file IOBufQueue.h.

IOBufQueue* folly::IOBufQueue::WritableRangeCache::queue_

private

Definition at line 231 of file IOBufQueue.h.

Referenced by operator=().

---

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

• proxygen/folly/folly/io/IOBufQueue.h