The Tor Browser / file comparison
comparison: gfx/skia/trunk/src/core/SkChunkAlloc.cpp
gfx/skia/trunk/src/core/SkChunkAlloc.cpp
- branch
- TOR_BUG_3246
- changeset 7
- 129ffea94266
equal
deleted
inserted
replaced
| -1:000000000000 | 0:60ed8cfd966c |
|---|---|
| 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 | |
| 8 #include "SkChunkAlloc.h" | |
| 9 | |
| 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 | |
| 20 struct SkChunkAlloc::Block { | |
| 21 Block* fNext; | |
| 22 size_t fFreeSize; | |
| 23 char* fFreePtr; | |
| 24 // data[] follows | |
| 25 | |
| 26 char* startOfData() { | |
| 27 return reinterpret_cast<char*>(this + 1); | |
| 28 } | |
| 29 | |
| 30 static void FreeChain(Block* block) { | |
| 31 while (block) { | |
| 32 Block* next = block->fNext; | |
| 33 sk_free(block); | |
| 34 block = next; | |
| 35 } | |
| 36 }; | |
| 37 | |
| 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 } | |
| 42 }; | |
| 43 | |
| 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; | |
| 55 fTotalUsed = 0; | |
| 56 fBlockCount = 0; | |
| 57 } | |
| 58 | |
| 59 SkChunkAlloc::~SkChunkAlloc() { | |
| 60 this->reset(); | |
| 61 } | |
| 62 | |
| 63 void SkChunkAlloc::reset() { | |
| 64 Block::FreeChain(fBlock); | |
| 65 fBlock = NULL; | |
| 66 fChunkSize = fMinSize; // reset to our initial minSize | |
| 67 fTotalCapacity = 0; | |
| 68 fTotalUsed = 0; | |
| 69 fBlockCount = 0; | |
| 70 } | |
| 71 | |
| 72 SkChunkAlloc::Block* SkChunkAlloc::newBlock(size_t bytes, AllocFailType ftype) { | |
| 73 size_t size = bytes; | |
| 74 if (size < fChunkSize) { | |
| 75 size = fChunkSize; | |
| 76 } | |
| 77 | |
| 78 Block* block = (Block*)sk_malloc_flags(sizeof(Block) + size, | |
| 79 ftype == kThrow_AllocFailType ? SK_MALLOC_THROW : 0); | |
| 80 | |
| 81 if (block) { | |
| 82 // block->fNext = fBlock; | |
| 83 block->fFreeSize = size; | |
| 84 block->fFreePtr = block->startOfData(); | |
| 85 | |
| 86 fTotalCapacity += size; | |
| 87 fBlockCount += 1; | |
| 88 | |
| 89 fChunkSize = increase_next_size(fChunkSize); | |
| 90 } | |
| 91 return block; | |
| 92 } | |
| 93 | |
| 94 void* SkChunkAlloc::alloc(size_t bytes, AllocFailType ftype) { | |
| 95 fTotalUsed += bytes; | |
| 96 | |
| 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); | |
| 111 char* ptr = block->fFreePtr; | |
| 112 | |
| 113 block->fFreeSize -= bytes; | |
| 114 block->fFreePtr = ptr + bytes; | |
| 115 return ptr; | |
| 116 } | |
| 117 | |
| 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 | |
| 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 } |
