proxygen: folly::AsyncSocket::BytesWriteRequest Class Reference

Inheritance diagram for folly::AsyncSocket::BytesWriteRequest:

Public Member Functions
void	destroy () override

WriteResult	performWrite () override

bool	isComplete () override

void	consume () override

Public Member Functions inherited from folly::AsyncSocket::WriteRequest
	WriteRequest (AsyncSocket socket, WriteCallback callback)

virtual void	start ()

WriteRequest *	getNext () const

WriteCallback *	getCallback () const

uint32_t	getTotalBytesWritten () const

void	append (WriteRequest *next)

void	fail (const char *fn, const AsyncSocketException &ex)

void	bytesWritten (size_t count)

Static Public Member Functions
static BytesWriteRequest *	newRequest (AsyncSocket socket, WriteCallback callback, const iovec *ops, uint32_t opCount, uint32_t partialWritten, uint32_t bytesWritten, unique_ptr< IOBuf > &&ioBuf, WriteFlags flags)

Private Member Functions
	BytesWriteRequest (AsyncSocket socket, WriteCallback callback, const struct iovec *ops, uint32_t opCount, uint32_t partialBytes, uint32_t bytesWritten, unique_ptr< IOBuf > &&ioBuf, WriteFlags flags)

	~BytesWriteRequest () override=default

const struct iovec *	getOps () const

uint32_t	getOpCount () const

Private Attributes
uint32_t	opCount_
	number of entries in writeOps_ More...

uint32_t	opIndex_
	current index into writeOps_ More...

WriteFlags	flags_
	set for WriteFlags More...

unique_ptr< IOBuf >	ioBuf_
	underlying IOBuf, or nullptr if N/A More...

uint32_t	opsWritten_
	complete ops written More...

uint32_t	partialBytes_
	partial bytes of incomplete op written More...

ssize_t	bytesWritten_
	bytes written altogether More...

struct iovec	writeOps_ []
	write operation(s) list More...

Additional Inherited Members
Protected Member Functions inherited from folly::AsyncSocket::WriteRequest
virtual	~WriteRequest ()

Protected Attributes inherited from folly::AsyncSocket::WriteRequest
AsyncSocket *	socket_
	parent socket More...

WriteRequest *	next_ {nullptr}
	pointer to next WriteRequest More...

WriteCallback *	callback_
	completion callback More...

uint32_t	totalBytesWritten_ {0}
	total bytes written More...

Detailed Description

Definition at line 81 of file AsyncSocket.cpp.

Constructor & Destructor Documentation

folly::AsyncSocket::BytesWriteRequest::BytesWriteRequest	(	AsyncSocket *	socket,
		WriteCallback *	callback,
		const struct iovec *	ops,
		uint32_t	opCount,
		uint32_t	partialBytes,
		uint32_t	bytesWritten,
		unique_ptr< IOBuf > &&	ioBuf,
		WriteFlags	flags
	)

inlineprivate

Definition at line 179 of file AsyncSocket.cpp.

References opCount_, writeOps_, and ~BytesWriteRequest().

Referenced by newRequest().

       : AsyncSocket::WriteRequest(socket, callback),
         opCount_(opCount),
         opIndex_(0),
         flags_(flags),
         ioBuf_(std::move(ioBuf)),
         opsWritten_(0),
         partialBytes_(partialBytes),
         bytesWritten_(bytesWritten) {
     memcpy(writeOps_, ops, sizeof(*ops) * opCount_);
   }

folly::AsyncSocket::BytesWriteRequest::~BytesWriteRequest ( )

overrideprivatedefault

Referenced by BytesWriteRequest(), and destroy().

Member Function Documentation

void folly::AsyncSocket::BytesWriteRequest::consume ( )

inlineoverridevirtual

Implements folly::AsyncSocket::WriteRequest.

Definition at line 151 of file AsyncSocket.cpp.

References bytesWritten_, flags_, i, ioBuf_, folly::AsyncSocket::isZeroCopyRequest(), opCount_, opIndex_, opsWritten_, partialBytes_, folly::AsyncSocket::WriteRequest::socket_, folly::AsyncSocket::WriteRequest::totalBytesWritten_, uint32_t, uint8_t, and writeOps_.

                           {
     // Advance opIndex_ forward by opsWritten_
     opIndex_ += opsWritten_;
     assert(opIndex_ < opCount_);
 
     if (!socket_->isZeroCopyRequest(flags_)) {
       // If we've finished writing any IOBufs, release them
       if (ioBuf_) {
         for (uint32_t i = opsWritten_; i != 0; --i) {
           assert(ioBuf_);
           ioBuf_ = ioBuf_->pop();
         }
       }
     }
 
     // Move partialBytes_ forward into the current iovec buffer
     struct iovec* currentOp = writeOps_ + opIndex_;
     assert((partialBytes_ < currentOp->iov_len) || (currentOp->iov_len == 0));
     currentOp->iov_base =
         reinterpret_cast<uint8_t*>(currentOp->iov_base) + partialBytes_;
     currentOp->iov_len -= partialBytes_;
 
     // Increment the totalBytesWritten_ count by bytesWritten_;
     assert(bytesWritten_ >= 0);
     totalBytesWritten_ += uint32_t(bytesWritten_);
   }

void folly::AsyncSocket::BytesWriteRequest::destroy ( )

inlineoverridevirtual

Implements folly::AsyncSocket::WriteRequest.

Definition at line 112 of file AsyncSocket.cpp.

References bm::free(), and ~BytesWriteRequest().

                           {
     this->~BytesWriteRequest();
     free(this);
   }

uint32_t folly::AsyncSocket::BytesWriteRequest::getOpCount ( ) const

inlineprivate

Definition at line 207 of file AsyncSocket.cpp.

References opCount_, and opIndex_.

Referenced by isComplete(), and performWrite().

                               {
     assert(opCount_ > opIndex_);
     return opCount_ - opIndex_;
   }

const struct iovec* folly::AsyncSocket::BytesWriteRequest::getOps ( ) const

inlineprivate

Definition at line 202 of file AsyncSocket.cpp.

References opCount_, opIndex_, and writeOps_.

Referenced by performWrite().

                                      {
     assert(opCount_ > opIndex_);
     return writeOps_ + opIndex_;
   }

bool folly::AsyncSocket::BytesWriteRequest::isComplete ( )

inlineoverridevirtual

Implements folly::AsyncSocket::WriteRequest.

Definition at line 147 of file AsyncSocket.cpp.

References getOpCount(), and opsWritten_.

Referenced by performWrite().

                              {
     return opsWritten_ == getOpCount();
   }

static BytesWriteRequest* folly::AsyncSocket::BytesWriteRequest::newRequest	(	AsyncSocket *	socket,
		WriteCallback *	callback,
		const iovec *	ops,
		uint32_t	opCount,
		uint32_t	partialWritten,
		uint32_t	bytesWritten,
		unique_ptr< IOBuf > &&	ioBuf,
		WriteFlags	flags
	)

inlinestatic

Definition at line 83 of file AsyncSocket.cpp.

References BytesWriteRequest(), and folly::gen::move.

Referenced by folly::AsyncSocket::writeImpl().

                         {
     assert(opCount > 0);
     // Since we put a variable size iovec array at the end
     // of each BytesWriteRequest, we have to manually allocate the memory.
     void* buf =
         malloc(sizeof(BytesWriteRequest) + (opCount * sizeof(struct iovec)));
     if (buf == nullptr) {
       throw std::bad_alloc();
     }
 
     return new (buf) BytesWriteRequest(
         socket,
         callback,
         ops,
         opCount,
         partialWritten,
         bytesWritten,
         std::move(ioBuf),
         flags);
   }

WriteResult folly::AsyncSocket::BytesWriteRequest::performWrite ( )

inlineoverridevirtual

Implements folly::AsyncSocket::WriteRequest.

Definition at line 117 of file AsyncSocket.cpp.

                                       {
     WriteFlags writeFlags = flags_;
     if (getNext() != nullptr) {
       writeFlags |= WriteFlags::CORK;
     }
 
     socket_->adjustZeroCopyFlags(writeFlags);
 
     auto writeResult = socket_->performWrite(
         getOps(), getOpCount(), writeFlags, &opsWritten_, &partialBytes_);
     bytesWritten_ = writeResult.writeReturn > 0 ? writeResult.writeReturn : 0;
     if (bytesWritten_) {
       if (socket_->isZeroCopyRequest(writeFlags)) {
         if (isComplete()) {
           socket_->addZeroCopyBuf(std::move(ioBuf_));
         } else {
           socket_->addZeroCopyBuf(ioBuf_.get());
         }
       } else {
         // this happens if at least one of the prev requests were sent
         // with zero copy but not the last one
         if (isComplete() && socket_->getZeroCopy() &&
             socket_->containsZeroCopyBuf(ioBuf_.get())) {
           socket_->setZeroCopyBuf(std::move(ioBuf_));
         }
       }
     }
     return writeResult;
   }