123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364 |
- /*
- * 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());
- }
|