epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2006 The Android Open Source Project |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 8 | #include "SkChunkAlloc.h" |
| 9 | |
reed@google.com | ebd2496 | 2012-05-17 14:28:11 +0000 | [diff] [blame] | 10 | // Don't malloc any chunks smaller than this |
| 11 | #define MIN_CHUNKALLOC_BLOCK_SIZE 1024 |
| 12 | |
| 13 | // Return the new min blocksize given the current value |
| 14 | static size_t increase_next_size(size_t size) { |
| 15 | return size + (size >> 1); |
| 16 | } |
| 17 | |
| 18 | /////////////////////////////////////////////////////////////////////////////// |
| 19 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 20 | struct SkChunkAlloc::Block { |
| 21 | Block* fNext; |
| 22 | size_t fFreeSize; |
| 23 | char* fFreePtr; |
| 24 | // data[] follows |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 25 | |
reed@android.com | aefd2bc | 2009-03-30 21:02:14 +0000 | [diff] [blame] | 26 | char* startOfData() { |
| 27 | return reinterpret_cast<char*>(this + 1); |
| 28 | } |
| 29 | |
reed@google.com | ebd2496 | 2012-05-17 14:28:11 +0000 | [diff] [blame] | 30 | static void FreeChain(Block* block) { |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 31 | while (block) { |
| 32 | Block* next = block->fNext; |
| 33 | sk_free(block); |
| 34 | block = next; |
| 35 | } |
| 36 | }; |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 37 | |
reed@android.com | f2b98d6 | 2010-12-20 18:26:13 +0000 | [diff] [blame] | 38 | bool contains(const void* addr) const { |
| 39 | const char* ptr = reinterpret_cast<const char*>(addr); |
| 40 | return ptr >= (const char*)(this + 1) && ptr < fFreePtr; |
| 41 | } |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 42 | }; |
| 43 | |
reed@google.com | ebd2496 | 2012-05-17 14:28:11 +0000 | [diff] [blame] | 44 | /////////////////////////////////////////////////////////////////////////////// |
| 45 | |
| 46 | SkChunkAlloc::SkChunkAlloc(size_t minSize) { |
| 47 | if (minSize < MIN_CHUNKALLOC_BLOCK_SIZE) { |
| 48 | minSize = MIN_CHUNKALLOC_BLOCK_SIZE; |
| 49 | } |
| 50 | |
| 51 | fBlock = NULL; |
| 52 | fMinSize = minSize; |
| 53 | fChunkSize = fMinSize; |
| 54 | fTotalCapacity = 0; |
reed@google.com | 6757a3c | 2013-06-19 19:25:36 +0000 | [diff] [blame] | 55 | fTotalUsed = 0; |
reed@google.com | ebd2496 | 2012-05-17 14:28:11 +0000 | [diff] [blame] | 56 | fBlockCount = 0; |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 57 | } |
| 58 | |
| 59 | SkChunkAlloc::~SkChunkAlloc() { |
| 60 | this->reset(); |
| 61 | } |
| 62 | |
| 63 | void SkChunkAlloc::reset() { |
reed@google.com | ebd2496 | 2012-05-17 14:28:11 +0000 | [diff] [blame] | 64 | Block::FreeChain(fBlock); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 65 | fBlock = NULL; |
reed@google.com | ebd2496 | 2012-05-17 14:28:11 +0000 | [diff] [blame] | 66 | fChunkSize = fMinSize; // reset to our initial minSize |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 67 | fTotalCapacity = 0; |
reed@google.com | 6757a3c | 2013-06-19 19:25:36 +0000 | [diff] [blame] | 68 | fTotalUsed = 0; |
reed@google.com | ebd2496 | 2012-05-17 14:28:11 +0000 | [diff] [blame] | 69 | fBlockCount = 0; |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 70 | } |
| 71 | |
| 72 | SkChunkAlloc::Block* SkChunkAlloc::newBlock(size_t bytes, AllocFailType ftype) { |
reed@google.com | ebd2496 | 2012-05-17 14:28:11 +0000 | [diff] [blame] | 73 | size_t size = bytes; |
| 74 | if (size < fChunkSize) { |
| 75 | size = fChunkSize; |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 76 | } |
| 77 | |
reed@google.com | ebd2496 | 2012-05-17 14:28:11 +0000 | [diff] [blame] | 78 | Block* block = (Block*)sk_malloc_flags(sizeof(Block) + size, |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 79 | ftype == kThrow_AllocFailType ? SK_MALLOC_THROW : 0); |
| 80 | |
| 81 | if (block) { |
| 82 | // block->fNext = fBlock; |
| 83 | block->fFreeSize = size; |
reed@android.com | aefd2bc | 2009-03-30 21:02:14 +0000 | [diff] [blame] | 84 | block->fFreePtr = block->startOfData(); |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 85 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 86 | fTotalCapacity += size; |
reed@google.com | ebd2496 | 2012-05-17 14:28:11 +0000 | [diff] [blame] | 87 | fBlockCount += 1; |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 88 | |
reed@google.com | ebd2496 | 2012-05-17 14:28:11 +0000 | [diff] [blame] | 89 | fChunkSize = increase_next_size(fChunkSize); |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 90 | } |
| 91 | return block; |
| 92 | } |
| 93 | |
| 94 | void* SkChunkAlloc::alloc(size_t bytes, AllocFailType ftype) { |
reed@google.com | 6757a3c | 2013-06-19 19:25:36 +0000 | [diff] [blame] | 95 | fTotalUsed += bytes; |
skia.committer@gmail.com | 4d494f0 | 2013-06-20 07:00:59 +0000 | [diff] [blame] | 96 | |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 97 | bytes = SkAlign4(bytes); |
| 98 | |
| 99 | Block* block = fBlock; |
| 100 | |
| 101 | if (block == NULL || bytes > block->fFreeSize) { |
| 102 | block = this->newBlock(bytes, ftype); |
| 103 | if (NULL == block) { |
| 104 | return NULL; |
| 105 | } |
| 106 | block->fNext = fBlock; |
| 107 | fBlock = block; |
| 108 | } |
| 109 | |
| 110 | SkASSERT(block && bytes <= block->fFreeSize); |
reed@google.com | ebd2496 | 2012-05-17 14:28:11 +0000 | [diff] [blame] | 111 | char* ptr = block->fFreePtr; |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 112 | |
| 113 | block->fFreeSize -= bytes; |
reed@google.com | ebd2496 | 2012-05-17 14:28:11 +0000 | [diff] [blame] | 114 | block->fFreePtr = ptr + bytes; |
reed@android.com | 8a1c16f | 2008-12-17 15:59:43 +0000 | [diff] [blame] | 115 | return ptr; |
| 116 | } |
| 117 | |
reed@android.com | aefd2bc | 2009-03-30 21:02:14 +0000 | [diff] [blame] | 118 | size_t SkChunkAlloc::unalloc(void* ptr) { |
| 119 | size_t bytes = 0; |
| 120 | Block* block = fBlock; |
| 121 | if (block) { |
| 122 | char* cPtr = reinterpret_cast<char*>(ptr); |
| 123 | char* start = block->startOfData(); |
| 124 | if (start <= cPtr && cPtr < block->fFreePtr) { |
| 125 | bytes = block->fFreePtr - cPtr; |
| 126 | block->fFreeSize += bytes; |
| 127 | block->fFreePtr = cPtr; |
| 128 | } |
| 129 | } |
| 130 | return bytes; |
| 131 | } |
| 132 | |
reed@android.com | f2b98d6 | 2010-12-20 18:26:13 +0000 | [diff] [blame] | 133 | bool SkChunkAlloc::contains(const void* addr) const { |
| 134 | const Block* block = fBlock; |
| 135 | while (block) { |
| 136 | if (block->contains(addr)) { |
| 137 | return true; |
| 138 | } |
| 139 | block = block->fNext; |
| 140 | } |
| 141 | return false; |
| 142 | } |