proxygen: proxygen::ByteEventTracker Class Reference

#include <ByteEventTracker.h>

Inheritance diagram for proxygen::ByteEventTracker:

Classes
class	Callback

Public Member Functions
virtual	~ByteEventTracker ()

	ByteEventTracker (Callback *callback)

virtual void	absorb (ByteEventTracker &&other)

void	setCallback (Callback *callback)

virtual size_t	drainByteEvents ()

virtual bool	processByteEvents (std::shared_ptr< ByteEventTracker > self, uint64_t bytesWritten)

void	addPingByteEvent (size_t pingSize, TimePoint timestamp, uint64_t bytesScheduled)

void	addFirstBodyByteEvent (uint64_t offset, HTTPTransaction *txn)

virtual void	addFirstHeaderByteEvent (uint64_t offset, HTTPTransaction *txn)

virtual void	addLastByteEvent (HTTPTransaction *txn, uint64_t byteNo) noexcept

virtual void	addTrackedByteEvent (HTTPTransaction *txn, uint64_t byteNo) noexcept

virtual void	addAckByteEvent (uint64_t, HTTPTransaction *)

virtual uint64_t	preSend (bool , bool , uint64_t)

virtual void	setTTLBAStats (TTLBAStats *)

Protected Member Functions
virtual void	eomEventProcessed ()

Protected Attributes
folly::IntrusiveList< ByteEvent,&ByteEvent::listHook >	byteEvents_

Callback *	callback_

Detailed Description

ByteEventTracker can be used to fire application callbacks when a given byte of a transport stream has been processed. The primary usage is to fire the callbacks when the byte is accepted by the transport, not when the byte has been written on the wire, or acknowledged.

Subclasses may implement handling of acknowledgement timing.

Definition at line 29 of file ByteEventTracker.h.

Constructor & Destructor Documentation

proxygen::ByteEventTracker::~ByteEventTracker ( )

virtual

Definition at line 20 of file ByteEventTracker.cpp.

References drainByteEvents().

Referenced by proxygen::ByteEventTracker::Callback::~Callback().

                                     {
   drainByteEvents();
 }

proxygen::ByteEventTracker::ByteEventTracker ( Callback * callback )

inlineexplicit

Definition at line 41 of file ByteEventTracker.h.

References absorb().

41 : callback_(callback) {}

proxygen::ByteEventTracker::callback_

Callback * callback_

Definition: ByteEventTracker.h:104

Member Function Documentation

void proxygen::ByteEventTracker::absorb ( ByteEventTracker && other )

virtual

Assumes the byte events of another ByteEventTracker that this object is replacing.

Definition at line 24 of file ByteEventTracker.cpp.

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

Referenced by ByteEventTracker().

                                                       {
   byteEvents_ = std::move(other.byteEvents_);
 }

virtual void proxygen::ByteEventTracker::addAckByteEvent	(	uint64_t	,
		HTTPTransaction *
	)

inlinevirtual

The base ByteEventTracker cannot track acks.

Definition at line 81 of file ByteEventTracker.h.

81 {}

void proxygen::ByteEventTracker::addFirstBodyByteEvent	(	uint64_t	offset,
		HTTPTransaction *	txn
	)

Definition at line 136 of file ByteEventTracker.cpp.

References byteEvents_, and proxygen::ByteEvent::FIRST_BYTE.

Referenced by proxygen::MockByteEventTracker::MockByteEventTracker(), and setCallback().

                                                                    {
   byteEvents_.push_back(
       *new TransactionByteEvent(
           offset, ByteEvent::FIRST_BYTE,
           txn));
 }

void proxygen::ByteEventTracker::addFirstHeaderByteEvent	(	uint64_t	offset,
		HTTPTransaction *	txn
	)

virtual

Definition at line 144 of file ByteEventTracker.cpp.

References byteEvents_, and proxygen::ByteEvent::FIRST_HEADER_BYTE.

Referenced by proxygen::MockByteEventTracker::MockByteEventTracker(), and setCallback().

                                                                      {
   // onWriteSuccess() is called after the entire header has been written.
   // It does not catch partial write case.
   byteEvents_.push_back(
       *new TransactionByteEvent(offset,
                                 ByteEvent::FIRST_HEADER_BYTE,
                                 txn));
 }

void proxygen::ByteEventTracker::addLastByteEvent	(	HTTPTransaction *	txn,
		uint64_t	byteNo
	)

virtualnoexcept

Definition at line 89 of file ByteEventTracker.cpp.

References byteEvents_, and proxygen::ByteEvent::LAST_BYTE.

Referenced by proxygen::HTTPSessionBase::handleLastByteEvents(), proxygen::MockByteEventTracker::MockByteEventTracker(), and setCallback().

                               {
   VLOG(5) << " adding last byte event for " << byteNo;
   TransactionByteEvent* event = new TransactionByteEvent(
       byteNo, ByteEvent::LAST_BYTE, txn);
   byteEvents_.push_back(*event);
 }

void proxygen::ByteEventTracker::addPingByteEvent	(	size_t	pingSize,
		TimePoint	timestamp,
		uint64_t	bytesScheduled
	)

The following methods add byte events for tracking

Definition at line 107 of file ByteEventTracker.cpp.

References byteEvents_, i, and uint64_t.

Referenced by proxygen::MockByteEventTracker::MockByteEventTracker(), and setCallback().

                                                                  {
   // register a byte event on ping reply sent, and adjust the byteOffset_
   // for others by one ping size
   uint64_t offset = bytesScheduled + pingSize;
   auto i = byteEvents_.rbegin();
   for (; i != byteEvents_.rend(); ++i) {
     if (i->byteOffset_ > bytesScheduled) {
       VLOG(5) << "pushing back ByteEvent from " << *i << " to "
               << ByteEvent(i->byteOffset_ + pingSize, i->eventType_);
       i->byteOffset_ += pingSize;
     } else {
       break; // the rest of the events are already scheduled
     }
   }
 
   ByteEvent* be = new PingByteEvent(offset, timestamp);
   if (i == byteEvents_.rend()) {
     byteEvents_.push_front(*be);
   } else if (i == byteEvents_.rbegin()) {
     byteEvents_.push_back(*be);
   } else {
     --i;
     CHECK_GT(i->byteOffset_, bytesScheduled);
     byteEvents_.insert(i.base(), *be);
   }
 }

void proxygen::ByteEventTracker::addTrackedByteEvent	(	HTTPTransaction *	txn,
		uint64_t	byteNo
	)

virtualnoexcept

Definition at line 98 of file ByteEventTracker.cpp.

References byteEvents_, and proxygen::ByteEvent::TRACKED_BYTE.

Referenced by proxygen::MockByteEventTracker::MockByteEventTracker(), and setCallback().

                               {
   VLOG(5) << " adding tracked byte event for " << byteNo;
   TransactionByteEvent* event = new TransactionByteEvent(
       byteNo, ByteEvent::TRACKED_BYTE, txn);
   byteEvents_.push_back(*event);
 }

size_t proxygen::ByteEventTracker::drainByteEvents ( )

virtual

drainByteEvents should be called to clear out any pending events holding transactions when processByteEvents will no longer be called

Definition at line 79 of file ByteEventTracker.cpp.

References byteEvents_.

Referenced by proxygen::MockByteEventTracker::MockByteEventTracker(), setCallback(), and ~ByteEventTracker().

                                          {
   size_t numEvents = 0;
   // everything is dead from here on, let's just drop all extra refs to txns
   while (!byteEvents_.empty()) {
     delete &byteEvents_.front();
     ++numEvents;
   }
   return numEvents;
 }

virtual void proxygen::ByteEventTracker::eomEventProcessed ( )

inlineprotectedvirtual

Definition at line 102 of file ByteEventTracker.h.

Referenced by processByteEvents().

102 {}

virtual uint64_t proxygen::ByteEventTracker::preSend	(	bool *	,
		bool *	,
		uint64_t
	)

inlinevirtual

HTTPSession uses preSend to truncate writes on an eom boundary. In Ack-tracking ByteEventTracker's, this should exmaine pending byte events and return the number of bytes until the next last byte event, or 0 if none are pending. If non-zero is returned then eom may be set to indicate ack tracking is requested.

Definition at line 91 of file ByteEventTracker.h.

Referenced by proxygen::MockByteEventTracker::MockByteEventTracker().

                                        {
     return 0;
   }

bool proxygen::ByteEventTracker::processByteEvents	(	std::shared_ptr< ByteEventTracker >	self,
		uint64_t	bytesWritten
	)

virtual

processByteEvents is called whenever the transport has accepted more bytes. bytesWritten is the number of bytes written to the transport over its lifetime.

Definition at line 31 of file ByteEventTracker.cpp.

References byteEvents_, callback_, eomEventProcessed(), proxygen::ByteEvent::FIRST_BYTE, proxygen::ByteEvent::FIRST_HEADER_BYTE, int64_t, proxygen::ByteEvent::LAST_BYTE, proxygen::ByteEventTracker::Callback::onLastByteEvent(), proxygen::ByteEventTracker::Callback::onPingReplyLatency(), proxygen::ByteEvent::PING_REPLY_SENT, and proxygen::ByteEvent::TRACKED_BYTE.

Referenced by proxygen::MockByteEventTracker::MockByteEventTracker(), and setCallback().

                                                                 {
   bool advanceEOM = false;
 
   while (!byteEvents_.empty() &&
          (byteEvents_.front().byteOffset_ <= bytesWritten)) {
     ByteEvent& event = byteEvents_.front();
     int64_t latency;
     auto txn = event.getTransaction();
 
     switch (event.eventType_) {
     case ByteEvent::FIRST_HEADER_BYTE:
       txn->onEgressHeaderFirstByte();
       break;
     case ByteEvent::FIRST_BYTE:
       txn->onEgressBodyFirstByte();
       break;
     case ByteEvent::LAST_BYTE:
       txn->onEgressBodyLastByte();
       if (callback_) {
         callback_->onLastByteEvent(txn, event.byteOffset_, event.eomTracked_);
       }
       advanceEOM = true;
       break;
     case ByteEvent::TRACKED_BYTE:
       txn->onEgressTrackedByte();
       break;
     case ByteEvent::PING_REPLY_SENT:
       latency = event.getLatency();
       if (callback_) {
         callback_->onPingReplyLatency(latency);
       }
       break;
     }
 
     VLOG(5) << " removing ByteEvent " << event;
     // explicitly remove from the list, in case delete event triggers a
     // callback that would absorb this ByteEventTracker.
     event.listHook.unlink();
     delete &event;
   }
 
   if (advanceEOM) {
     eomEventProcessed();
   }
   return self.use_count() == 1;
 }