VNMediaClientNET

json_batchallocator.h
1 #ifndef JSONCPP_BATCHALLOCATOR_H_INCLUDED
2 # define JSONCPP_BATCHALLOCATOR_H_INCLUDED
3
4 # include <stdlib.h>
5 # include <assert.h>
6
7 # ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION
8
9 namespace Json {
10
11 /* Fast memory allocator.
12 *
13 * This memory allocator allocates memory for a batch of object (specified by
14 * the page size, the number of object in each page).
15 *
16 * It does not allow the destruction of a single object. All the allocated objects
17 * can be destroyed at once. The memory can be either released or reused for future
18 * allocation.
19 *
20 * The in-place new operator must be used to construct the object using the pointer
21 * returned by allocate.
22 */
23 template<typename AllocatedType
24 ,const unsigned int objectPerAllocation>
25 class BatchAllocator
26 {
27 public:
28 typedef AllocatedType Type;
29
30 BatchAllocator( unsigned int objectsPerPage = 255 )
31 : freeHead_( 0 )
32 , objectsPerPage_( objectsPerPage )
33 {
34 // printf( "Size: %d => %s\n", sizeof(AllocatedType), typeid(AllocatedType).name() );
35 assert( sizeof(AllocatedType) * objectPerAllocation >= sizeof(AllocatedType *) ); // We must be able to store a slist in the object free space.
36 assert( objectsPerPage >= 16 );
37 batches_ = allocateBatch( 0 ); // allocated a dummy page
38 currentBatch_ = batches_;
39 }
40
41 ~BatchAllocator()
42 {
43 for ( BatchInfo *batch = batches_; batch; )
44 {
45 BatchInfo *nextBatch = batch->next_;
46 free( batch );
47 batch = nextBatch;
48 }
49 }
50
53 AllocatedType *allocate()
54 {
55 if ( freeHead_ ) // returns node from free list.
56 {
57 AllocatedType *object = freeHead_;
58 freeHead_ = *(AllocatedType **)object;
59 return object;
60 }
61 if ( currentBatch_->used_ == currentBatch_->end_ )
62 {
63 currentBatch_ = currentBatch_->next_;
64 while ( currentBatch_ && currentBatch_->used_ == currentBatch_->end_ )
65 currentBatch_ = currentBatch_->next_;
66
67 if ( !currentBatch_ ) // no free batch found, allocate a new one
68 {
69 currentBatch_ = allocateBatch( objectsPerPage_ );
70 currentBatch_->next_ = batches_; // insert at the head of the list
71 batches_ = currentBatch_;
72 }
73 }
74 AllocatedType *allocated = currentBatch_->used_;
75 currentBatch_->used_ += objectPerAllocation;
76 return allocated;
77 }
78
81 void release( AllocatedType *object )
82 {
83 assert( object != 0 );
84 *(AllocatedType **)object = freeHead_;
85 freeHead_ = object;
86 }
87
88 private:
89 struct BatchInfo
90 {
91 BatchInfo *next_;
92 AllocatedType *used_;
93 AllocatedType *end_;
94 AllocatedType buffer_[objectPerAllocation];
95 };
96
97 // disabled copy constructor and assignement operator.
98 BatchAllocator( const BatchAllocator & );
99 void operator =( const BatchAllocator &);
100
101 static BatchInfo *allocateBatch( unsigned int objectsPerPage )
102 {
103 const unsigned int mallocSize = sizeof(BatchInfo) - sizeof(AllocatedType)* objectPerAllocation
104 + sizeof(AllocatedType) * objectPerAllocation * objectsPerPage;
105 BatchInfo *batch = static_cast<BatchInfo*>( malloc( mallocSize ) );
106 batch->next_ = 0;
107 batch->used_ = batch->buffer_;
108 batch->end_ = batch->buffer_ + objectsPerPage;
109 return batch;
110 }
111
112 BatchInfo *batches_;
113 BatchInfo *currentBatch_;
115 AllocatedType *freeHead_;
116 unsigned int objectsPerPage_;
117 };
118
119
120 } // namespace Json
121
122 # endif // ifndef JSONCPP_DOC_INCLUDE_IMPLEMENTATION
123
124 #endif // JSONCPP_BATCHALLOCATOR_H_INCLUDED
125
Json::BatchAllocator::allocate
AllocatedType * allocate()
Definition: json_batchallocator.h:53
Json::BatchAllocator
Definition: json_batchallocator.h:26
Json::BatchAllocator::release
void release(AllocatedType *object)
Definition: json_batchallocator.h:81