proxygen: proxygen::compress::QPACKScheme Class Reference

#include <QPACKScheme.h>

Inheritance diagram for proxygen::compress::QPACKScheme:

Classes
struct	QPACKAck

Public Member Functions
	QPACKScheme (CompressionSimulator *sim, uint32_t tableSize, uint32_t maxBlocking)

	~QPACKScheme ()

std::unique_ptr< Ack >	getAck (uint16_t seqn) override

void	recvAck (std::unique_ptr< Ack > ack) override

std::pair< FrameFlags, std::unique_ptr< folly::IOBuf > >	encode (bool, std::vector< compress::Header > allHeaders, SimStats &stats) override

void	decode (FrameFlags flags, std::unique_ptr< folly::IOBuf > encodedReq, SimStats &stats, SimStreamingCallback &callback) override

uint32_t	getHolBlockCount () const override

Public Member Functions inherited from proxygen::compress::CompressionScheme
	CompressionScheme (CompressionSimulator *sim)

virtual	~CompressionScheme ()

void	runLoopCallback () noexceptoverride

Public Member Functions inherited from folly::EventBase::LoopCallback
virtual	~LoopCallback ()=default

void	cancelLoopCallback ()

bool	isLoopCallbackScheduled () const

Public Attributes
QPACKCodec	client_

QPACKCodec	server_

std::map< uint16_t, std::unique_ptr< folly::IOBuf > >	controlQueue_

uint16_t	encodeControlIndex_ {0}

uint16_t	decodeControlIndex_ {0}

std::map< uint16_t, std::unique_ptr< folly::IOBuf > >	acks_

uint16_t	sendAck_ {1}

uint16_t	recvAck_ {1}

Public Attributes inherited from proxygen::compress::CompressionScheme
std::list< BlockInfo >	encodedBlocks

std::list< BlockInfo >	packetBlocks

size_t	index {0}

std::chrono::milliseconds	prev

size_t	packetBytes {0}

std::chrono::milliseconds	decodeDelay

std::list< uint16_t >	packetIndices

Additional Inherited Members
Public Types inherited from proxygen::compress::CompressionScheme
using	BlockInfo = std::tuple< FrameFlags, bool, std::unique_ptr< folly::IOBuf >, SimStreamingCallback * >

Detailed Description

Definition at line 18 of file QPACKScheme.h.

Constructor & Destructor Documentation

proxygen::compress::QPACKScheme::QPACKScheme	(	CompressionSimulator *	sim,
		uint32_t	tableSize,
		uint32_t	maxBlocking
	)

inlineexplicit

Definition at line 20 of file QPACKScheme.h.

References client_, proxygen::NoPathIndexingStrategy::getInstance(), server_, proxygen::QPACKCodec::setDecoderHeaderTableMaxSize(), proxygen::QPACKCodec::setEncoderHeaderTableSize(), proxygen::QPACKCodec::setHeaderIndexingStrategy(), proxygen::QPACKCodec::setMaxBlocking(), and proxygen::QPACKCodec::setMaxVulnerable().

       : CompressionScheme(sim) {
     client_.setHeaderIndexingStrategy(NoPathIndexingStrategy::getInstance());
     server_.setHeaderIndexingStrategy(NoPathIndexingStrategy::getInstance());
     client_.setEncoderHeaderTableSize(tableSize);
     server_.setDecoderHeaderTableMaxSize(tableSize);
     client_.setMaxVulnerable(maxBlocking);
     server_.setMaxBlocking(maxBlocking);
   }

proxygen::compress::QPACKScheme::~QPACKScheme ( )

inline

Definition at line 31 of file QPACKScheme.h.

References proxygen::QPACKCodec::getQueuedBytes(), and server_.

                  {
     CHECK_EQ(server_.getQueuedBytes(), 0);
   }

Member Function Documentation

void proxygen::compress::QPACKScheme::decode	(	FrameFlags	flags,
		std::unique_ptr< folly::IOBuf >	encodedReq,
		SimStats &	stats,
		SimStreamingCallback &	callback
	)

inlineoverridevirtual

Implements proxygen::compress::CompressionScheme.

Definition at line 115 of file QPACKScheme.h.

References proxygen::compress::FrameFlags::allowOOO, folly::IOBufQueue::append(), controlQueue_, decodeControlIndex_, proxygen::QPACKCodec::decodeEncoderStream(), proxygen::QPACKCodec::decodeStreaming(), proxygen::QPACKCodec::getQueuedBytes(), proxygen::compress::SimStats::maxQueueBufferBytes, proxygen::compress::SimStreamingCallback::maybeMarkHolDelay(), folly::gen::move, folly::io::detail::CursorBase< Derived, BufType >::readBE(), proxygen::compress::SimStreamingCallback::requestIndex, proxygen::compress::QPACKScheme::QPACKAck::seqn, proxygen::compress::SimStreamingCallback::seqn, server_, uint16_t, and uint32_t.

                                                        {
     folly::io::Cursor cursor(encodedReq.get());
     auto toTrim = sizeof(uint16_t) * 3;
     auto len = cursor.readBE<uint16_t>();
     if (len > 0) {
       // check decode result
       auto controlIndex = cursor.readBE<uint16_t>();
       toTrim += sizeof(uint16_t);
       std::unique_ptr<folly::IOBuf> control;
       cursor.clone(control, len);
       if (controlIndex == decodeControlIndex_) {
         // next expected control block, decode
         VLOG(5) << "decode controlIndex=" << controlIndex;
         server_.decodeEncoderStream(std::move(control));
         decodeControlIndex_++;
         while (!controlQueue_.empty() &&
                controlQueue_.begin()->first == decodeControlIndex_) {
           // drain the queue
           VLOG(5) << "decode controlIndex=" << controlQueue_.begin()->first;
           auto it = controlQueue_.begin();
           server_.decodeEncoderStream(std::move(it->second));
           decodeControlIndex_++;
           controlQueue_.erase(it);
         }
       } else {
         // out of order control block, queue it
         controlQueue_.emplace(controlIndex, std::move(control));
       }
       toTrim += len;
     }
     auto seqn = cursor.readBE<uint16_t>();
     callback.seqn = seqn;
     VLOG(1) << "Decoding request=" << callback.requestIndex
             << " header seqn=" << seqn
             << " allowOOO=" << uint32_t(flags.allowOOO);
     len = cursor.readBE<uint16_t>();
     folly::IOBufQueue queue;
     queue.append(std::move(encodedReq));
     queue.trimStart(toTrim);
     server_.decodeStreaming(seqn, queue.move(), len, &callback);
     callback.maybeMarkHolDelay();
     if (server_.getQueuedBytes() > stats.maxQueueBufferBytes) {
       stats.maxQueueBufferBytes = server_.getQueuedBytes();
     }
   }

std::pair<FrameFlags, std::unique_ptr<folly::IOBuf> > proxygen::compress::QPACKScheme::encode	(	bool	,
		std::vector< compress::Header >	allHeaders,
		SimStats &	stats
	)

inlineoverridevirtual

Implements proxygen::compress::CompressionScheme.

Definition at line 81 of file QPACKScheme.h.

References client_, wangle::HTTPHeaderSize::compressed, proxygen::compress::SimStats::compressed, proxygen::QPACKCodec::encode(), encodeControlIndex_, proxygen::HeaderCodec::getEncodedSize(), proxygen::compress::CompressionScheme::index, folly::io::QueueAppender::insert(), folly::IOBufQueue::move(), folly::gen::move, uint16_t, uint32_t, proxygen::compress::SimStats::uncompressed, wangle::HTTPHeaderSize::uncompressed, and folly::io::detail::Writable< Derived >::writeBE().

                                 {
     index++;
     auto result = client_.encode(allHeaders, index);
     uint16_t len = 0;
     folly::IOBufQueue queue;
     static const uint32_t growth = 1400; // chosen arbitrarily
     folly::io::QueueAppender cursor(&queue, growth);
     if (result.control) {
       VLOG(5) << "Writing encodeControlIndex_=" << encodeControlIndex_;
       len = result.control->computeChainDataLength();
       cursor.writeBE<uint16_t>(len);
       cursor.writeBE<uint16_t>(encodeControlIndex_++);
       cursor.insert(std::move(result.control));
       // Don't count the framing against the compression ratio, for now
       // stats.compressed += 3 * sizeof(uint16_t);
     } else {
       cursor.writeBE<uint16_t>(0);
     }
     if (result.stream) {
       len = result.stream->computeChainDataLength();
     }
     cursor.writeBE<uint16_t>(index);
     cursor.writeBE<uint16_t>(len);
     cursor.insert(std::move(result.stream));
     stats.uncompressed += client_.getEncodedSize().uncompressed;
     stats.compressed += client_.getEncodedSize().compressed;
     // OOO is allowed if there has not been an eviction
     FrameFlags flags(false, false);
     return {flags, queue.move()};
   }

std::unique_ptr<Ack> proxygen::compress::QPACKScheme::getAck ( uint16_t seqn )

inlineoverridevirtual

Implements proxygen::compress::CompressionScheme.

Definition at line 51 of file QPACKScheme.h.

References proxygen::QPACKCodec::encodeHeaderAck(), proxygen::QPACKCodec::encodeTableStateSync(), folly::gen::move, sendAck_, proxygen::compress::QPACKScheme::QPACKAck::seqn, and server_.

                                                     {
     VLOG(4) << "Sending ack for seqn=" << seqn;
     auto res = std::make_unique<QPACKAck>(seqn, sendAck_++,
                                           server_.encodeHeaderAck(seqn),
                                           server_.encodeTableStateSync());
     return std::move(res);
   }

uint32_t proxygen::compress::QPACKScheme::getHolBlockCount ( ) const

inlineoverridevirtual

Implements proxygen::compress::CompressionScheme.

Definition at line 164 of file QPACKScheme.h.

References proxygen::QPACKCodec::getHolBlockCount(), and server_.

                                              {
     return server_.getHolBlockCount();
   }

void proxygen::compress::QPACKScheme::recvAck ( std::unique_ptr< Ack > ack )

inlineoverridevirtual

Implements proxygen::compress::CompressionScheme.

Definition at line 58 of file QPACKScheme.h.

References acks_, client_, proxygen::QPACKCodec::decodeDecoderStream(), folly::gen::move, proxygen::HPACK::NONE, and recvAck_.

                                                 {
     CHECK(ack);
     auto qpackAck = dynamic_cast<QPACKAck*>(ack.get());
     CHECK_NOTNULL(qpackAck);
     VLOG(4) << "Received ack for seqn=" << qpackAck->seqn;
     CHECK(qpackAck->headerAck);
     if (qpackAck->controlAck) {
       qpackAck->headerAck->prependChain(std::move(qpackAck->controlAck));
     }
     // The decoder stream must be processed in order
     acks_.emplace(qpackAck->ackSeqn, std::move(qpackAck->headerAck));
     do {
       auto it = acks_.begin();
       if (it->first != recvAck_) {
         break;
       }
       CHECK_EQ(client_.decodeDecoderStream(std::move(it->second)),
                HPACK::DecodeError::NONE);
       recvAck_++;
       acks_.erase(it);
     } while (!acks_.empty());
   }

Member Data Documentation

std::map<uint16_t, std::unique_ptr<folly::IOBuf> > proxygen::compress::QPACKScheme::acks_

Definition at line 173 of file QPACKScheme.h.

Referenced by recvAck().

QPACKCodec proxygen::compress::QPACKScheme::client_

Definition at line 168 of file QPACKScheme.h.

Referenced by encode(), QPACKScheme(), and recvAck().

std::map<uint16_t, std::unique_ptr<folly::IOBuf> > proxygen::compress::QPACKScheme::controlQueue_

Definition at line 170 of file QPACKScheme.h.

Referenced by decode().

uint16_t proxygen::compress::QPACKScheme::decodeControlIndex_ {0}

Definition at line 172 of file QPACKScheme.h.

Referenced by decode().

uint16_t proxygen::compress::QPACKScheme::encodeControlIndex_ {0}

Definition at line 171 of file QPACKScheme.h.

Referenced by encode().

uint16_t proxygen::compress::QPACKScheme::recvAck_ {1}

Definition at line 175 of file QPACKScheme.h.

Referenced by recvAck().

uint16_t proxygen::compress::QPACKScheme::sendAck_ {1}

Definition at line 174 of file QPACKScheme.h.

Referenced by getAck().

QPACKCodec proxygen::compress::QPACKScheme::server_

Definition at line 169 of file QPACKScheme.h.

Referenced by decode(), getAck(), getHolBlockCount(), QPACKScheme(), and ~QPACKScheme().

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

proxygen/lib/http/codec/compress/experimental/simulator/QPACKScheme.h

Classes

Public Member Functions

Public Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation