OLD | NEW |
1 #include "SkVarAlloc.h" | 1 #include "SkVarAlloc.h" |
2 | 2 |
3 // We use non-standard malloc diagnostic methods to make sure our allocations ar
e sized well. | 3 // We use non-standard malloc diagnostic methods to make sure our allocations ar
e sized well. |
4 #if defined(SK_BUILD_FOR_MAC) | 4 #if defined(SK_BUILD_FOR_MAC) |
5 #include <malloc/malloc.h> | 5 #include <malloc/malloc.h> |
6 #elif defined(SK_BUILD_FOR_UNIX) || defined(SK_BUILD_FOR_WIN32) | 6 #elif defined(SK_BUILD_FOR_UNIX) || defined(SK_BUILD_FOR_WIN32) |
7 #include <malloc.h> | 7 #include <malloc.h> |
8 #endif | 8 #endif |
9 | 9 |
10 enum { | |
11 kMinLgSize = 4, // The smallest block we'd ever want to allocate is 16B, | |
12 kMaxLgSize = 16, // and we see no benefit allocating blocks larger than 64K
. | |
13 }; | |
14 | |
15 struct SkVarAlloc::Block { | 10 struct SkVarAlloc::Block { |
16 Block* prev; | 11 Block* prev; |
17 char* data() { return (char*)(this + 1); } | 12 char* data() { return (char*)(this + 1); } |
18 | 13 |
19 static Block* Alloc(Block* prev, size_t size, unsigned flags) { | 14 static Block* Alloc(Block* prev, size_t size, unsigned flags) { |
20 SkASSERT(size >= sizeof(Block)); | 15 SkASSERT(size >= sizeof(Block)); |
21 Block* b = (Block*)sk_malloc_flags(size, flags); | 16 Block* b = (Block*)sk_malloc_flags(size, flags); |
22 b->prev = prev; | 17 b->prev = prev; |
23 return b; | 18 return b; |
24 } | 19 } |
25 }; | 20 }; |
26 | 21 |
27 SkVarAlloc::SkVarAlloc() | 22 SkVarAlloc::SkVarAlloc(size_t minLgSize) |
28 : fByte(NULL) | 23 : fByte(NULL) |
29 , fRemaining(0) | 24 , fRemaining(0) |
30 , fLgSize(kMinLgSize) | 25 , fLgSize(minLgSize) |
31 , fBlock(NULL) {} | 26 , fBlock(NULL) {} |
32 | 27 |
33 SkVarAlloc::~SkVarAlloc() { | 28 SkVarAlloc::~SkVarAlloc() { |
34 Block* b = fBlock; | 29 Block* b = fBlock; |
35 while (b) { | 30 while (b) { |
36 Block* prev = b->prev; | 31 Block* prev = b->prev; |
37 sk_free(b); | 32 sk_free(b); |
38 b = prev; | 33 b = prev; |
39 } | 34 } |
40 } | 35 } |
41 | 36 |
42 void SkVarAlloc::makeSpace(size_t bytes, unsigned flags) { | 37 void SkVarAlloc::makeSpace(size_t bytes, unsigned flags) { |
43 SkASSERT(SkIsAlignPtr(bytes)); | 38 SkASSERT(SkIsAlignPtr(bytes)); |
44 | 39 |
45 size_t alloc = 1<<fLgSize; | 40 size_t alloc = 1<<fLgSize++; |
46 while (alloc < bytes + sizeof(Block)) { | 41 while (alloc < bytes + sizeof(Block)) { |
47 alloc *= 2; | 42 alloc *= 2; |
48 } | 43 } |
49 fBlock = Block::Alloc(fBlock, alloc, flags); | 44 fBlock = Block::Alloc(fBlock, alloc, flags); |
50 fByte = fBlock->data(); | 45 fByte = fBlock->data(); |
51 fRemaining = alloc - sizeof(Block); | 46 fRemaining = alloc - sizeof(Block); |
52 | 47 |
53 if (fLgSize < kMaxLgSize) { | |
54 fLgSize++; | |
55 } | |
56 | |
57 #if defined(SK_BUILD_FOR_MAC) | 48 #if defined(SK_BUILD_FOR_MAC) |
58 SkASSERT(alloc == malloc_good_size(alloc)); | 49 SkASSERT(alloc == malloc_good_size(alloc)); |
59 #elif defined(SK_BUILD_FOR_UNIX) | 50 #elif defined(SK_BUILD_FOR_UNIX) |
60 // TODO(mtklein): tune so we can assert something like this | 51 // TODO(mtklein): tune so we can assert something like this |
61 //SkASSERT(alloc == malloc_usable_size(fBlock)); | 52 //SkASSERT(alloc == malloc_usable_size(fBlock)); |
62 #endif | 53 #endif |
63 } | 54 } |
64 | 55 |
65 static size_t heap_size(void* p) { | 56 static size_t heap_size(void* p) { |
66 #if defined(SK_BUILD_FOR_MAC) | 57 #if defined(SK_BUILD_FOR_MAC) |
67 return malloc_size(p); | 58 return malloc_size(p); |
68 #elif defined(SK_BUILD_FOR_UNIX) | 59 #elif defined(SK_BUILD_FOR_UNIX) |
69 return malloc_usable_size(p); | 60 return malloc_usable_size(p); |
70 #elif defined(SK_BUILD_FOR_WIN32) | 61 #elif defined(SK_BUILD_FOR_WIN32) |
71 return _msize(p); | 62 return _msize(p); |
72 #else | 63 #else |
73 return 0; // Tough luck. | 64 return 0; // Tough luck. |
74 #endif | 65 #endif |
75 } | 66 } |
76 | 67 |
77 size_t SkVarAlloc::approxBytesAllocated() const { | 68 size_t SkVarAlloc::approxBytesAllocated() const { |
78 size_t sum = 0; | 69 size_t sum = 0; |
79 for (Block* b = fBlock; b; b = b->prev) { | 70 for (Block* b = fBlock; b; b = b->prev) { |
80 sum += heap_size(b); | 71 sum += heap_size(b); |
81 } | 72 } |
82 return sum; | 73 return sum; |
83 } | 74 } |
OLD | NEW |