src/core/SkRWBuffer.cpp - skia - Git at Google

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "include/core/SkRWBuffer.h"

 #include "include/core/SkStream.h"
 #include "include/private/SkMalloc.h"
 #include "include/private/SkTo.h"
 #include "src/core/SkMakeUnique.h"

 #include <atomic>
 #include <new>

 // Force small chunks to be a page's worth
 static const size_t kMinAllocSize = 4096;

 struct SkBufferBlock {
     SkBufferBlock*  fNext;      // updated by the writer
     size_t          fUsed;      // updated by the writer
     const size_t    fCapacity;

     SkBufferBlock(size_t capacity) : fNext(nullptr), fUsed(0), fCapacity(capacity) {}

     const void* startData() const { return this + 1; }

     size_t avail() const { return fCapacity - fUsed; }
     void* availData() { return (char*)this->startData() + fUsed; }

     static SkBufferBlock* Alloc(size_t length) {
         size_t capacity = LengthToCapacity(length);
         void* buffer = sk_malloc_throw(sizeof(SkBufferBlock) + capacity);
         return new (buffer) SkBufferBlock(capacity);
     }

     // Return number of bytes actually appended. Important that we always completely this block
     // before spilling into the next, since the reader uses fCapacity to know how many it can read.
     //
     size_t append(const void* src, size_t length) {
         this->validate();
         size_t amount = SkTMin(this->avail(), length);
         memcpy(this->availData(), src, amount);
         fUsed += amount;
         this->validate();
         return amount;
     }

     // Do not call in the reader thread, since the writer may be updating fUsed.
     // (The assertion is still true, but TSAN still may complain about its raciness.)
     void validate() const {
 #ifdef SK_DEBUG
         SkASSERT(fCapacity > 0);
         SkASSERT(fUsed <= fCapacity);
 #endif
     }

 private:
     static size_t LengthToCapacity(size_t length) {
         const size_t minSize = kMinAllocSize - sizeof(SkBufferBlock);
         return SkTMax(length, minSize);
     }
 };

 struct SkBufferHead {
     mutable std::atomic<int32_t> fRefCnt;
     SkBufferBlock   fBlock;

     SkBufferHead(size_t capacity) : fRefCnt(1), fBlock(capacity) {}

     static size_t LengthToCapacity(size_t length) {
         const size_t minSize = kMinAllocSize - sizeof(SkBufferHead);
         return SkTMax(length, minSize);
     }

     static SkBufferHead* Alloc(size_t length) {
         size_t capacity = LengthToCapacity(length);
         size_t size = sizeof(SkBufferHead) + capacity;
         void* buffer = sk_malloc_throw(size);
         return new (buffer) SkBufferHead(capacity);
     }

     void ref() const {
         SkAssertResult(fRefCnt.fetch_add(+1, std::memory_order_relaxed));
     }

     void unref() const {
         // A release here acts in place of all releases we "should" have been doing in ref().
         int32_t oldRefCnt = fRefCnt.fetch_add(-1, std::memory_order_acq_rel);
         SkASSERT(oldRefCnt);
         if (1 == oldRefCnt) {
             // Like unique(), the acquire is only needed on success.
             SkBufferBlock* block = fBlock.fNext;
             sk_free((void*)this);
             while (block) {
                 SkBufferBlock* next = block->fNext;
                 sk_free(block);
                 block = next;
             }
         }
     }

     void validate(size_t minUsed, const SkBufferBlock* tail = nullptr) const {
 #ifdef SK_DEBUG
         SkASSERT(fRefCnt.load(std::memory_order_relaxed) > 0);
         size_t totalUsed = 0;
         const SkBufferBlock* block = &fBlock;
         const SkBufferBlock* lastBlock = block;
         while (block) {
             block->validate();
             totalUsed += block->fUsed;
             lastBlock = block;
             block = block->fNext;
         }
         SkASSERT(minUsed <= totalUsed);
         if (tail) {
             SkASSERT(tail == lastBlock);
         }
 #endif
     }
 };

 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // The reader can only access block.fCapacity (which never changes), and cannot access
 // block.fUsed, which may be updated by the writer.
 //
 SkROBuffer::SkROBuffer(const SkBufferHead* head, size_t available, const SkBufferBlock* tail)
     : fHead(head), fAvailable(available), fTail(tail)
 {
     if (head) {
         fHead->ref();
         SkASSERT(available > 0);
         head->validate(available, tail);
     } else {
         SkASSERT(0 == available);
         SkASSERT(!tail);
     }
 }

 SkROBuffer::~SkROBuffer() {
     if (fHead) {
         fHead->unref();
     }
 }

 SkROBuffer::Iter::Iter(const SkROBuffer* buffer) {
     this->reset(buffer);
 }

 SkROBuffer::Iter::Iter(const sk_sp<SkROBuffer>& buffer) {
     this->reset(buffer.get());
 }

 void SkROBuffer::Iter::reset(const SkROBuffer* buffer) {
     fBuffer = buffer;
     if (buffer && buffer->fHead) {
         fBlock = &buffer->fHead->fBlock;
         fRemaining = buffer->fAvailable;
     } else {
         fBlock = nullptr;
         fRemaining = 0;
     }
 }

 const void* SkROBuffer::Iter::data() const {
     return fRemaining ? fBlock->startData() : nullptr;
 }

 size_t SkROBuffer::Iter::size() const {
     if (!fBlock) {
         return 0;
     }
     return SkTMin(fBlock->fCapacity, fRemaining);
 }

 bool SkROBuffer::Iter::next() {
     if (fRemaining) {
         fRemaining -= this->size();
         if (fBuffer->fTail == fBlock) {
             // There are more blocks, but fBuffer does not know about them.
             SkASSERT(0 == fRemaining);
             fBlock = nullptr;
         } else {
             fBlock = fBlock->fNext;
         }
     }
     return fRemaining != 0;
 }

 ///////////////////////////////////////////////////////////////////////////////////////////////////

 SkRWBuffer::SkRWBuffer(size_t initialCapacity) : fHead(nullptr), fTail(nullptr), fTotalUsed(0) {
     if (initialCapacity) {
         fHead = SkBufferHead::Alloc(initialCapacity);
         fTail = &fHead->fBlock;
     }
 }

 SkRWBuffer::~SkRWBuffer() {
     this->validate();
     if (fHead) {
         fHead->unref();
     }
 }

 // It is important that we always completely fill the current block before spilling over to the
 // next, since our reader will be using fCapacity (min'd against its total available) to know how
 // many bytes to read from a given block.
 //
 void SkRWBuffer::append(const void* src, size_t length, size_t reserve) {
     this->validate();
     if (0 == length) {
         return;
     }

     fTotalUsed += length;

     if (nullptr == fHead) {
         fHead = SkBufferHead::Alloc(length + reserve);
         fTail = &fHead->fBlock;
     }

     size_t written = fTail->append(src, length);
     SkASSERT(written <= length);
     src = (const char*)src + written;
     length -= written;

     if (length) {
         SkBufferBlock* block = SkBufferBlock::Alloc(length + reserve);
         fTail->fNext = block;
         fTail = block;
         written = fTail->append(src, length);
         SkASSERT(written == length);
     }
     this->validate();
 }

 #ifdef SK_DEBUG
 void SkRWBuffer::validate() const {
     if (fHead) {
         fHead->validate(fTotalUsed, fTail);
     } else {
         SkASSERT(nullptr == fTail);
         SkASSERT(0 == fTotalUsed);
     }
 }
 #endif

 ///////////////////////////////////////////////////////////////////////////////////////////////////

 class SkROBufferStreamAsset : public SkStreamAsset {
     void validate() const {
 #ifdef SK_DEBUG
         SkASSERT(fGlobalOffset <= fBuffer->size());
         SkASSERT(fLocalOffset <= fIter.size());
         SkASSERT(fLocalOffset <= fGlobalOffset);
 #endif
     }

 #ifdef SK_DEBUG
     class AutoValidate {
         SkROBufferStreamAsset* fStream;
     public:
         AutoValidate(SkROBufferStreamAsset* stream) : fStream(stream) { stream->validate(); }
         ~AutoValidate() { fStream->validate(); }
     };
     #define AUTO_VALIDATE   AutoValidate av(this);
 #else
     #define AUTO_VALIDATE
 #endif

 public:
     SkROBufferStreamAsset(sk_sp<SkROBuffer> buffer) : fBuffer(std::move(buffer)), fIter(fBuffer) {
         fGlobalOffset = fLocalOffset = 0;
     }

     size_t getLength() const override { return fBuffer->size(); }

     bool rewind() override {
         AUTO_VALIDATE
         fIter.reset(fBuffer.get());
         fGlobalOffset = fLocalOffset = 0;
         return true;
     }

     size_t read(void* dst, size_t request) override {
         AUTO_VALIDATE
         size_t bytesRead = 0;
         for (;;) {
             size_t size = fIter.size();
             SkASSERT(fLocalOffset <= size);
             size_t avail = SkTMin(size - fLocalOffset, request - bytesRead);
             if (dst) {
                 memcpy(dst, (const char*)fIter.data() + fLocalOffset, avail);
                 dst = (char*)dst + avail;
             }
             bytesRead += avail;
             fLocalOffset += avail;
             SkASSERT(bytesRead <= request);
             if (bytesRead == request) {
                 break;
             }
             // If we get here, we've exhausted the current iter
             SkASSERT(fLocalOffset == size);
             fLocalOffset = 0;
             if (!fIter.next()) {
                 break;   // ran out of data
             }
         }
         fGlobalOffset += bytesRead;
         SkASSERT(fGlobalOffset <= fBuffer->size());
         return bytesRead;
     }

     bool isAtEnd() const override {
         return fBuffer->size() == fGlobalOffset;
     }

     size_t getPosition() const override {
         return fGlobalOffset;
     }

     bool seek(size_t position) override {
         AUTO_VALIDATE
         if (position < fGlobalOffset) {
             this->rewind();
         }
         (void)this->skip(position - fGlobalOffset);
         return true;
     }

     bool move(long offset)  override{
         AUTO_VALIDATE
         offset += fGlobalOffset;
         if (offset <= 0) {
             this->rewind();
         } else {
             (void)this->seek(SkToSizeT(offset));
         }
         return true;
     }

 private:
     SkStreamAsset* onDuplicate() const override {
         return new SkROBufferStreamAsset(fBuffer);
     }

     SkStreamAsset* onFork() const override {
         auto clone = this->duplicate();
         clone->seek(this->getPosition());
         return clone.release();
     }

     sk_sp<SkROBuffer> fBuffer;
     SkROBuffer::Iter  fIter;
     size_t            fLocalOffset;
     size_t            fGlobalOffset;
 };

 std::unique_ptr<SkStreamAsset> SkRWBuffer::makeStreamSnapshot() const {
     return skstd::make_unique<SkROBufferStreamAsset>(this->makeROBufferSnapshot());
 }
	/*
	* Copyright 2015 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "include/core/SkRWBuffer.h"

	#include "include/core/SkStream.h"
	#include "include/private/SkMalloc.h"
	#include "include/private/SkTo.h"
	#include "src/core/SkMakeUnique.h"

	#include <atomic>
	#include <new>

	// Force small chunks to be a page's worth
	static const size_t kMinAllocSize = 4096;

	struct SkBufferBlock {
	SkBufferBlock* fNext; // updated by the writer
	size_t fUsed; // updated by the writer
	const size_t fCapacity;

	SkBufferBlock(size_t capacity) : fNext(nullptr), fUsed(0), fCapacity(capacity) {}

	const void* startData() const { return this + 1; }

	size_t avail() const { return fCapacity - fUsed; }
	void* availData() { return (char*)this->startData() + fUsed; }

	static SkBufferBlock* Alloc(size_t length) {
	size_t capacity = LengthToCapacity(length);
	void* buffer = sk_malloc_throw(sizeof(SkBufferBlock) + capacity);
	return new (buffer) SkBufferBlock(capacity);
	}

	// Return number of bytes actually appended. Important that we always completely this block
	// before spilling into the next, since the reader uses fCapacity to know how many it can read.
	//
	size_t append(const void* src, size_t length) {
	this->validate();
	size_t amount = SkTMin(this->avail(), length);
	memcpy(this->availData(), src, amount);
	fUsed += amount;
	this->validate();
	return amount;
	}

	// Do not call in the reader thread, since the writer may be updating fUsed.
	// (The assertion is still true, but TSAN still may complain about its raciness.)
	void validate() const {
	#ifdef SK_DEBUG
	SkASSERT(fCapacity > 0);
	SkASSERT(fUsed <= fCapacity);
	#endif
	}

	private:
	static size_t LengthToCapacity(size_t length) {
	const size_t minSize = kMinAllocSize - sizeof(SkBufferBlock);
	return SkTMax(length, minSize);
	}
	};

	struct SkBufferHead {
	mutable std::atomic<int32_t> fRefCnt;
	SkBufferBlock fBlock;

	SkBufferHead(size_t capacity) : fRefCnt(1), fBlock(capacity) {}

	static size_t LengthToCapacity(size_t length) {
	const size_t minSize = kMinAllocSize - sizeof(SkBufferHead);
	return SkTMax(length, minSize);
	}

	static SkBufferHead* Alloc(size_t length) {
	size_t capacity = LengthToCapacity(length);
	size_t size = sizeof(SkBufferHead) + capacity;
	void* buffer = sk_malloc_throw(size);
	return new (buffer) SkBufferHead(capacity);
	}

	void ref() const {
	SkAssertResult(fRefCnt.fetch_add(+1, std::memory_order_relaxed));
	}

	void unref() const {
	// A release here acts in place of all releases we "should" have been doing in ref().
	int32_t oldRefCnt = fRefCnt.fetch_add(-1, std::memory_order_acq_rel);
	SkASSERT(oldRefCnt);
	if (1 == oldRefCnt) {
	// Like unique(), the acquire is only needed on success.
	SkBufferBlock* block = fBlock.fNext;
	sk_free((void*)this);
	while (block) {
	SkBufferBlock* next = block->fNext;
	sk_free(block);
	block = next;
	}
	}
	}

	void validate(size_t minUsed, const SkBufferBlock* tail = nullptr) const {
	#ifdef SK_DEBUG
	SkASSERT(fRefCnt.load(std::memory_order_relaxed) > 0);
	size_t totalUsed = 0;
	const SkBufferBlock* block = &fBlock;
	const SkBufferBlock* lastBlock = block;
	while (block) {
	block->validate();
	totalUsed += block->fUsed;
	lastBlock = block;
	block = block->fNext;
	}
	SkASSERT(minUsed <= totalUsed);
	if (tail) {
	SkASSERT(tail == lastBlock);
	}
	#endif
	}
	};

	///////////////////////////////////////////////////////////////////////////////////////////////////
	// The reader can only access block.fCapacity (which never changes), and cannot access
	// block.fUsed, which may be updated by the writer.
	//
	SkROBuffer::SkROBuffer(const SkBufferHead* head, size_t available, const SkBufferBlock* tail)
	: fHead(head), fAvailable(available), fTail(tail)
	{
	if (head) {
	fHead->ref();
	SkASSERT(available > 0);
	head->validate(available, tail);
	} else {
	SkASSERT(0 == available);
	SkASSERT(!tail);
	}
	}

	SkROBuffer::~SkROBuffer() {
	if (fHead) {
	fHead->unref();
	}
	}

	SkROBuffer::Iter::Iter(const SkROBuffer* buffer) {
	this->reset(buffer);
	}

	SkROBuffer::Iter::Iter(const sk_sp<SkROBuffer>& buffer) {
	this->reset(buffer.get());
	}

	void SkROBuffer::Iter::reset(const SkROBuffer* buffer) {
	fBuffer = buffer;
	if (buffer && buffer->fHead) {
	fBlock = &buffer->fHead->fBlock;
	fRemaining = buffer->fAvailable;
	} else {
	fBlock = nullptr;
	fRemaining = 0;
	}
	}

	const void* SkROBuffer::Iter::data() const {
	return fRemaining ? fBlock->startData() : nullptr;
	}

	size_t SkROBuffer::Iter::size() const {
	if (!fBlock) {
	return 0;
	}
	return SkTMin(fBlock->fCapacity, fRemaining);
	}

	bool SkROBuffer::Iter::next() {
	if (fRemaining) {
	fRemaining -= this->size();
	if (fBuffer->fTail == fBlock) {
	// There are more blocks, but fBuffer does not know about them.
	SkASSERT(0 == fRemaining);
	fBlock = nullptr;
	} else {
	fBlock = fBlock->fNext;
	}
	}
	return fRemaining != 0;
	}

	///////////////////////////////////////////////////////////////////////////////////////////////////

	SkRWBuffer::SkRWBuffer(size_t initialCapacity) : fHead(nullptr), fTail(nullptr), fTotalUsed(0) {
	if (initialCapacity) {
	fHead = SkBufferHead::Alloc(initialCapacity);
	fTail = &fHead->fBlock;
	}
	}

	SkRWBuffer::~SkRWBuffer() {
	this->validate();
	if (fHead) {
	fHead->unref();
	}
	}

	// It is important that we always completely fill the current block before spilling over to the
	// next, since our reader will be using fCapacity (min'd against its total available) to know how
	// many bytes to read from a given block.
	//
	void SkRWBuffer::append(const void* src, size_t length, size_t reserve) {
	this->validate();
	if (0 == length) {
	return;
	}

	fTotalUsed += length;

	if (nullptr == fHead) {
	fHead = SkBufferHead::Alloc(length + reserve);
	fTail = &fHead->fBlock;
	}

	size_t written = fTail->append(src, length);
	SkASSERT(written <= length);
	src = (const char*)src + written;
	length -= written;

	if (length) {
	SkBufferBlock* block = SkBufferBlock::Alloc(length + reserve);
	fTail->fNext = block;
	fTail = block;
	written = fTail->append(src, length);
	SkASSERT(written == length);
	}
	this->validate();
	}

	#ifdef SK_DEBUG
	void SkRWBuffer::validate() const {
	if (fHead) {
	fHead->validate(fTotalUsed, fTail);
	} else {
	SkASSERT(nullptr == fTail);
	SkASSERT(0 == fTotalUsed);
	}
	}
	#endif

	///////////////////////////////////////////////////////////////////////////////////////////////////

	class SkROBufferStreamAsset : public SkStreamAsset {
	void validate() const {
	#ifdef SK_DEBUG
	SkASSERT(fGlobalOffset <= fBuffer->size());
	SkASSERT(fLocalOffset <= fIter.size());
	SkASSERT(fLocalOffset <= fGlobalOffset);
	#endif
	}

	#ifdef SK_DEBUG
	class AutoValidate {
	SkROBufferStreamAsset* fStream;
	public:
	AutoValidate(SkROBufferStreamAsset* stream) : fStream(stream) { stream->validate(); }
	~AutoValidate() { fStream->validate(); }
	};
	#define AUTO_VALIDATE AutoValidate av(this);
	#else
	#define AUTO_VALIDATE
	#endif

	public:
	SkROBufferStreamAsset(sk_sp<SkROBuffer> buffer) : fBuffer(std::move(buffer)), fIter(fBuffer) {
	fGlobalOffset = fLocalOffset = 0;
	}

	size_t getLength() const override { return fBuffer->size(); }

	bool rewind() override {
	AUTO_VALIDATE
	fIter.reset(fBuffer.get());
	fGlobalOffset = fLocalOffset = 0;
	return true;
	}

	size_t read(void* dst, size_t request) override {
	AUTO_VALIDATE
	size_t bytesRead = 0;
	for (;;) {
	size_t size = fIter.size();
	SkASSERT(fLocalOffset <= size);
	size_t avail = SkTMin(size - fLocalOffset, request - bytesRead);
	if (dst) {
	memcpy(dst, (const char*)fIter.data() + fLocalOffset, avail);
	dst = (char*)dst + avail;
	}
	bytesRead += avail;
	fLocalOffset += avail;
	SkASSERT(bytesRead <= request);
	if (bytesRead == request) {
	break;
	}
	// If we get here, we've exhausted the current iter
	SkASSERT(fLocalOffset == size);
	fLocalOffset = 0;
	if (!fIter.next()) {
	break; // ran out of data
	}
	}
	fGlobalOffset += bytesRead;
	SkASSERT(fGlobalOffset <= fBuffer->size());
	return bytesRead;
	}

	bool isAtEnd() const override {
	return fBuffer->size() == fGlobalOffset;
	}

	size_t getPosition() const override {
	return fGlobalOffset;
	}

	bool seek(size_t position) override {
	AUTO_VALIDATE
	if (position < fGlobalOffset) {
	this->rewind();
	}
	(void)this->skip(position - fGlobalOffset);
	return true;
	}

	bool move(long offset) override{
	AUTO_VALIDATE
	offset += fGlobalOffset;
	if (offset <= 0) {
	this->rewind();
	} else {
	(void)this->seek(SkToSizeT(offset));
	}
	return true;
	}

	private:
	SkStreamAsset* onDuplicate() const override {
	return new SkROBufferStreamAsset(fBuffer);
	}

	SkStreamAsset* onFork() const override {
	auto clone = this->duplicate();
	clone->seek(this->getPosition());
	return clone.release();
	}

	sk_sp<SkROBuffer> fBuffer;
	SkROBuffer::Iter fIter;
	size_t fLocalOffset;
	size_t fGlobalOffset;
	};

	std::unique_ptr<SkStreamAsset> SkRWBuffer::makeStreamSnapshot() const {
	return skstd::make_unique<SkROBufferStreamAsset>(this->makeROBufferSnapshot());
	}