proxygen: folly::ZeroCopyTestAsyncSocket Class Reference

#include <ZeroCopy.h>

Classes
class	Callback

Public Member Functions
	ZeroCopyTestAsyncSocket (size_t counter, folly::EventBase evb, int numLoops, size_t bufferSize, bool zeroCopy)

	ZeroCopyTestAsyncSocket (size_t counter, folly::EventBase evb, int fd, int numLoops, size_t bufferSize, bool zeroCopy)

	~ZeroCopyTestAsyncSocket ()

void	connect (const folly::SocketAddress &remote)

bool	isZeroCopyWriteInProgress () const

Private Member Functions
void	setZeroCopy (bool enable)

void	setBufferSize (size_t bufferSize)

void	clearBuffers ()

void	getReadBuffer (void *bufReturn, size_t lenReturn)

void	readDataAvailable (size_t len) noexcept

void	onConnected ()

void	onDataReady ()

void	onDataFinish (folly::exception_wrapper)

bool	writeBuffer ()

Private Attributes
size_t *	counter_ {nullptr}

folly::EventBase *	evb_

int	numLoops_ {0}

int	currLoop_ {0}

bool	zeroCopy_ {false}

folly::AsyncSocket::UniquePtr	sock_

Callback	callback_

size_t	bufferSize_ {0}

size_t	readOffset_ {0}

char *	readBuffer_ {nullptr}

std::unique_ptr< folly::IOBuf >	writeBuffer_

bool	client_

Detailed Description

Definition at line 28 of file ZeroCopy.h.

Constructor & Destructor Documentation

folly::ZeroCopyTestAsyncSocket::ZeroCopyTestAsyncSocket	(	size_t *	counter,
		folly::EventBase *	evb,
		int	numLoops,
		size_t	bufferSize,
		bool	zeroCopy
	)

inlineexplicit

Definition at line 30 of file ZeroCopy.h.

References setBufferSize(), and setZeroCopy().

       : counter_(counter),
         evb_(evb),
         numLoops_(numLoops),
         sock_(new folly::AsyncSocket(evb)),
         callback_(this),
         client_(true) {
     setBufferSize(bufferSize);
     setZeroCopy(zeroCopy);
   }

folly::ZeroCopyTestAsyncSocket::ZeroCopyTestAsyncSocket	(	size_t *	counter,
		folly::EventBase *	evb,
		int	fd,
		int	numLoops,
		size_t	bufferSize,
		bool	zeroCopy
	)

inlineexplicit

Definition at line 46 of file ZeroCopy.h.

References callback_, setBufferSize(), setZeroCopy(), and sock_.

       : counter_(counter),
         evb_(evb),
         numLoops_(numLoops),
         sock_(new folly::AsyncSocket(evb, fd)),
         callback_(this),
         client_(false) {
     setBufferSize(bufferSize);
     setZeroCopy(zeroCopy);
     // enable reads
     if (sock_) {
       sock_->setReadCB(&callback_);
     }
   }

folly::ZeroCopyTestAsyncSocket::~ZeroCopyTestAsyncSocket ( )

inline

Definition at line 67 of file ZeroCopy.h.

References clearBuffers().

                              {
     clearBuffers();
   }

Member Function Documentation

void folly::ZeroCopyTestAsyncSocket::clearBuffers ( )

inlineprivate

Definition at line 131 of file ZeroCopy.h.

References readBuffer_.

Referenced by setBufferSize(), and ~ZeroCopyTestAsyncSocket().

                       {
     if (readBuffer_) {
       delete[] readBuffer_;
     }
   }

void folly::ZeroCopyTestAsyncSocket::connect ( const folly::SocketAddress & remote )

inline

Definition at line 71 of file ZeroCopy.h.

References callback_, and sock_.

                                                  {
     if (sock_) {
       sock_->connect(&callback_, remote);
     }
   }

void folly::ZeroCopyTestAsyncSocket::getReadBuffer	(	void **	bufReturn,
		size_t *	lenReturn
	)

inlineprivate

Definition at line 137 of file ZeroCopy.h.

References bufferSize_, readBuffer_, and readOffset_.

Referenced by folly::ZeroCopyTestAsyncSocket::Callback::getReadBuffer().

                                                           {
     *bufReturn = readBuffer_ + readOffset_;
     *lenReturn = bufferSize_ - readOffset_;
   }

bool folly::ZeroCopyTestAsyncSocket::isZeroCopyWriteInProgress ( ) const

inline

Definition at line 77 of file ZeroCopy.h.

References sock_.

                                          {
     return sock_->isZeroCopyWriteInProgress();
   }

void folly::ZeroCopyTestAsyncSocket::onConnected ( )

inlineprivate

Definition at line 150 of file ZeroCopy.h.

References setZeroCopy(), writeBuffer(), and zeroCopy_.

Referenced by folly::ZeroCopyTestAsyncSocket::Callback::connectSuccess().

                      {
     setZeroCopy(zeroCopy_);
     writeBuffer();
   }

void folly::ZeroCopyTestAsyncSocket::onDataFinish ( folly::exception_wrapper )

inlineprivate

Definition at line 170 of file ZeroCopy.h.

References client_, counter_, evb_, and folly::EventBase::terminateLoopSoon().

Referenced by folly::ZeroCopyTestAsyncSocket::Callback::connectErr(), folly::ZeroCopyTestAsyncSocket::Callback::readEOF(), and folly::ZeroCopyTestAsyncSocket::Callback::readErr().

                                             {
     if (client_) {
       if (counter_ && (0 == --(*counter_))) {
         evb_->terminateLoopSoon();
       }
     }
   }

void folly::ZeroCopyTestAsyncSocket::onDataReady ( )

inlineprivate

Definition at line 155 of file ZeroCopy.h.

References client_, counter_, currLoop_, evb_, numLoops_, folly::EventBase::runInLoop(), folly::EventBase::terminateLoopSoon(), and writeBuffer().

Referenced by readDataAvailable().

                      {
     currLoop_++;
     if (client_ && currLoop_ >= numLoops_) {
       evb_->runInLoop(
           [this] {
             if (counter_ && (0 == --(*counter_))) {
               evb_->terminateLoopSoon();
             }
           },
           false /*thisIteration*/);
       return;
     }
     writeBuffer();
   }

void folly::ZeroCopyTestAsyncSocket::readDataAvailable ( size_t len )

inlineprivatenoexcept

Definition at line 142 of file ZeroCopy.h.

References bufferSize_, onDataReady(), and readOffset_.

Referenced by folly::ZeroCopyTestAsyncSocket::Callback::readDataAvailable().

                                               {
     readOffset_ += len;
     if (readOffset_ == bufferSize_) {
       readOffset_ = 0;
       onDataReady();
     }
   }

void folly::ZeroCopyTestAsyncSocket::setBufferSize ( size_t bufferSize )

inlineprivate

Definition at line 89 of file ZeroCopy.h.

References bufferSize_, clearBuffers(), and readBuffer_.

Referenced by ZeroCopyTestAsyncSocket().

                                         {
     clearBuffers();
     bufferSize_ = bufferSize;
 
     readBuffer_ = new char[bufferSize_];
   }

void folly::ZeroCopyTestAsyncSocket::setZeroCopy ( bool enable )

inlineprivate

Definition at line 82 of file ZeroCopy.h.

References sock_, and zeroCopy_.

Referenced by onConnected(), and ZeroCopyTestAsyncSocket().

                                 {
     zeroCopy_ = enable;
     if (sock_) {
       sock_->setZeroCopy(zeroCopy_);
     }
   }

bool folly::ZeroCopyTestAsyncSocket::writeBuffer ( )

inlineprivate

Definition at line 178 of file ZeroCopy.h.

References bufferSize_, folly::gen::move, folly::NONE, sock_, folly::IOBuf::takeOwnership(), folly::WRITE_MSG_ZEROCOPY, writeBuffer_, and zeroCopy_.

Referenced by onConnected(), and onDataReady().

                      {
     // use calloc to make sure the memory is touched
     // if the memory is just malloc'd, running the zeroCopyOn
     // and the zeroCopyOff back to back on a system that does not support
     // zerocopy leads to the second test being much slower
     writeBuffer_ =
         folly::IOBuf::takeOwnership(::calloc(1, bufferSize_), bufferSize_);
 
     if (sock_ && writeBuffer_) {
       sock_->writeChain(
           nullptr,
           std::move(writeBuffer_),
           zeroCopy_ ? WriteFlags::WRITE_MSG_ZEROCOPY : WriteFlags::NONE);
     }
 
     return true;
   }