OLD | NEW |
1 #include "SkVarAlloc.h" | 1 #include "SkVarAlloc.h" |
2 #include "SkScalar.h" | |
3 | 2 |
4 // 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. |
5 #if defined(SK_BUILD_FOR_MAC) | 4 #if defined(SK_BUILD_FOR_MAC) |
6 #include <malloc/malloc.h> | 5 #include <malloc/malloc.h> |
7 #elif defined(SK_BUILD_FOR_LINUX) | 6 #elif defined(SK_BUILD_FOR_LINUX) |
8 #include <malloc.h> | 7 #include <malloc.h> |
9 #endif | 8 #endif |
10 | 9 |
11 struct SkVarAlloc::Block { | 10 struct SkVarAlloc::Block { |
12 Block* prev; | 11 Block* prev; |
13 char* data() { return (char*)(this + 1); } | 12 char* data() { return (char*)(this + 1); } |
14 | 13 |
15 static Block* Alloc(Block* prev, size_t size, unsigned flags) { | 14 static Block* Alloc(Block* prev, size_t size, unsigned flags) { |
16 SkASSERT(size >= sizeof(Block)); | 15 SkASSERT(size >= sizeof(Block)); |
17 Block* b = (Block*)sk_malloc_flags(size, flags); | 16 Block* b = (Block*)sk_malloc_flags(size, flags); |
18 b->prev = prev; | 17 b->prev = prev; |
19 return b; | 18 return b; |
20 } | 19 } |
21 }; | 20 }; |
22 | 21 |
23 SkVarAlloc::SkVarAlloc(size_t smallest, float growth) | 22 SkVarAlloc::SkVarAlloc() |
24 : fByte(NULL) | 23 : fByte(NULL) |
25 , fLimit(NULL) | 24 , fRemaining(0) |
26 , fSmallest(SkToUInt(smallest)) | 25 , fLgMinSize(4) |
27 , fGrowth(growth) | |
28 , fBlock(NULL) {} | 26 , fBlock(NULL) {} |
29 | 27 |
30 SkVarAlloc::~SkVarAlloc() { | 28 SkVarAlloc::~SkVarAlloc() { |
31 Block* b = fBlock; | 29 Block* b = fBlock; |
32 while (b) { | 30 while (b) { |
33 Block* prev = b->prev; | 31 Block* prev = b->prev; |
34 sk_free(b); | 32 sk_free(b); |
35 b = prev; | 33 b = prev; |
36 } | 34 } |
37 } | 35 } |
38 | 36 |
39 void SkVarAlloc::makeSpace(size_t bytes, unsigned flags) { | 37 void SkVarAlloc::makeSpace(size_t bytes, unsigned flags) { |
40 SkASSERT(SkIsAlignPtr(bytes)); | 38 SkASSERT(SkIsAlignPtr(bytes)); |
41 | 39 |
42 size_t alloc = fSmallest; | 40 size_t alloc = 1<<(fLgMinSize++); |
43 while (alloc < bytes + sizeof(Block)) { | 41 while (alloc < bytes + sizeof(Block)) { |
44 alloc *= 2; | 42 alloc *= 2; |
45 } | 43 } |
46 fBlock = Block::Alloc(fBlock, alloc, flags); | 44 fBlock = Block::Alloc(fBlock, alloc, flags); |
47 fByte = fBlock->data(); | 45 fByte = fBlock->data(); |
48 fLimit = fByte + alloc - sizeof(Block); | 46 fRemaining = alloc - sizeof(Block); |
49 fSmallest = SkToUInt(SkScalarTruncToInt(fSmallest * fGrowth)); | |
50 | 47 |
51 #if defined(SK_BUILD_FOR_MAC) | 48 #if defined(SK_BUILD_FOR_MAC) |
52 SkASSERT(alloc == malloc_good_size(alloc)); | 49 SkASSERT(alloc == malloc_good_size(alloc)); |
53 #elif defined(SK_BUILD_FOR_LINUX) | 50 #elif defined(SK_BUILD_FOR_LINUX) |
54 SkASSERT(alloc == malloc_usable_size(fByte - sizeof(Block))); | 51 SkASSERT(alloc == malloc_usable_size(fByte - sizeof(Block))); |
55 #endif | 52 #endif |
56 } | 53 } |
OLD | NEW |