1 
2 /*
3  * Copyright 2006 The Android Open Source Project
4  *
5  * Use of this source code is governed by a BSD-style license that can be
6  * found in the LICENSE file.
7  */
8 
9 
10 #ifndef SkChunkAlloc_DEFINED
11 #define SkChunkAlloc_DEFINED
12 
13 #include "SkTypes.h"
14 
15 class SkChunkAlloc : SkNoncopyable {
16 public:
17     SkChunkAlloc(size_t minSize);
18     ~SkChunkAlloc();
19 
20     /**
21      *  Free up all allocated blocks. This invalidates all returned
22      *  pointers.
23      */
24     void reset();
25     /**
26      *  Reset to 0 used bytes preserving as much memory as possible.
27      *  This invalidates all returned pointers.
28      */
29     void rewind();
30 
31     enum AllocFailType {
32         kReturnNil_AllocFailType,
33         kThrow_AllocFailType
34     };
35 
36     /**
37      *  Allocates a memory block of size bytes.
38      *  On success: returns a pointer to beginning of memory block that is
39      *  8 byte aligned. The content of allocated block is not initialized.
40      *  On failure: calls abort() if called with kThrow_AllocFailType,
41      *  otherwise returns NULL pointer.
42      */
43     void* alloc(size_t bytes, AllocFailType);
44 
45     /**
46      *  Shortcut for calling alloc with kThrow_AllocFailType.
47      */
allocThrow(size_t bytes)48     void* allocThrow(size_t bytes) {
49         return this->alloc(bytes, kThrow_AllocFailType);
50     }
51 
52     /** Call this to unalloc the most-recently allocated ptr by alloc(). On
53         success, the number of bytes freed is returned, or 0 if the block could
54         not be unallocated. This is a hint to the underlying allocator that
55         the previous allocation may be reused, but the implementation is free
56         to ignore this call (and return 0).
57      */
58     size_t unalloc(void* ptr);
59 
totalCapacity()60     size_t totalCapacity() const { return fTotalCapacity; }
totalUsed()61     size_t totalUsed() const { return fTotalUsed; }
62     SkDEBUGCODE(int blockCount() const { return fBlockCount; })
63     SkDEBUGCODE(size_t totalLost() const { return fTotalLost; })
64 
65     /**
66      *  Returns true if the specified address is within one of the chunks, and
67      *  has at least 1-byte following the address (i.e. if addr points to the
68      *  end of a chunk, then contains() will return false).
69      */
70     bool contains(const void* addr) const;
71 
72 private:
73     struct Block;
74 
75     Block*  fBlock;
76     size_t  fMinSize;
77     size_t  fChunkSize;
78     size_t  fTotalCapacity;
79     size_t  fTotalUsed;     // will be <= fTotalCapacity
80     SkDEBUGCODE(int     fBlockCount;)
81     SkDEBUGCODE(size_t  fTotalLost;)     // will be <= fTotalCapacity
82 
83     Block* newBlock(size_t bytes, AllocFailType ftype);
84     Block* addBlockIfNecessary(size_t bytes, AllocFailType ftype);
85 
86     SkDEBUGCODE(void validate();)
87 };
88 
89 #endif
90