The Tor Browser: gfx/skia/trunk/src/gpu/GrAllocPool.cpp@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /*

     2  * Copyright 2010 Google Inc.

     3  *

     4  * Use of this source code is governed by a BSD-style license that can be

     5  * found in the LICENSE file.

     6  */

     8 #include "GrAllocPool.h"

    10 #include "GrTypes.h"

    12 #define GrAllocPool_MIN_BLOCK_SIZE      ((size_t)128)

    14 struct GrAllocPool::Block {

    15     Block*  fNext;

    16     char*   fPtr;

    17     size_t  fBytesFree;

    18     size_t  fBytesTotal;

    20     static Block* Create(size_t size, Block* next) {

    21         SkASSERT(size >= GrAllocPool_MIN_BLOCK_SIZE);

    23         Block* block = (Block*)sk_malloc_throw(sizeof(Block) + size);

    24         block->fNext = next;

    25         block->fPtr = (char*)block + sizeof(Block);

    26         block->fBytesFree = size;

    27         block->fBytesTotal = size;

    28         return block;

    29     }

    31     bool canAlloc(size_t bytes) const {

    32         return bytes <= fBytesFree;

    33     }

    35     void* alloc(size_t bytes) {

    36         SkASSERT(bytes <= fBytesFree);

    37         fBytesFree -= bytes;

    38         void* ptr = fPtr;

    39         fPtr += bytes;

    40         return ptr;

    41     }

    43     size_t release(size_t bytes) {

    44         SkASSERT(bytes > 0);

    45         size_t free = GrMin(bytes, fBytesTotal - fBytesFree);

    46         fBytesFree += free;

    47         fPtr -= free;

    48         return bytes - free;

    49     }

    51     bool empty() const { return fBytesTotal == fBytesFree; }

    52 };

    54 ///////////////////////////////////////////////////////////////////////////////

    56 GrAllocPool::GrAllocPool(size_t blockSize) {

    57     fBlock = NULL;

    58     fMinBlockSize = GrMax(blockSize, GrAllocPool_MIN_BLOCK_SIZE);

    59     SkDEBUGCODE(fBlocksAllocated = 0;)

    60 }

    62 GrAllocPool::~GrAllocPool() {

    63     this->reset();

    64 }

    66 void GrAllocPool::reset() {

    67     this->validate();

    69     Block* block = fBlock;

    70     while (block) {

    71         Block* next = block->fNext;

    72         sk_free(block);

    73         block = next;

    74     }

    75     fBlock = NULL;

    76     SkDEBUGCODE(fBlocksAllocated = 0;)

    77 }

    79 void* GrAllocPool::alloc(size_t size) {

    80     this->validate();

    82     if (!fBlock || !fBlock->canAlloc(size)) {

    83         size_t blockSize = GrMax(fMinBlockSize, size);

    84         fBlock = Block::Create(blockSize, fBlock);

    85         SkDEBUGCODE(fBlocksAllocated += 1;)

    86     }

    87     return fBlock->alloc(size);

    88 }

    90 void GrAllocPool::release(size_t bytes) {

    91     this->validate();

    93     while (bytes && NULL != fBlock) {

    94         bytes = fBlock->release(bytes);

    95         if (fBlock->empty()) {

    96             Block* next = fBlock->fNext;

    97             sk_free(fBlock);

    98             fBlock = next;

    99             SkDEBUGCODE(fBlocksAllocated -= 1;)

   100         }

   101     }

   102 }

   104 #ifdef SK_DEBUG

   106 void GrAllocPool::validate() const {

   107     Block* block = fBlock;

   108     int count = 0;

   109     while (block) {

   110         count += 1;

   111         block = block->fNext;

   112     }

   113     SkASSERT(fBlocksAllocated == count);

   114 }

   116 #endif

The Tor Browser / file revision