Teh first one
[mldemos:kalians-mldemos.git] / _AlgorithmsPlugins / KernelMethods / dlib / memory_manager / memory_manager_kernel_2.h
1 // Copyright (C) 2004  Davis E. King (davis@dlib.net)\r
2 // License: Boost Software License   See LICENSE.txt for the full license.\r
3 #ifndef DLIB_MEMORY_MANAGER_KERNEl_2_\r
4 #define DLIB_MEMORY_MANAGER_KERNEl_2_\r
5 \r
6 #include "../algs.h"\r
7 #include "memory_manager_kernel_abstract.h"\r
8 #include "../assert.h"\r
9 #include <new>\r
10 \r
11 namespace dlib\r
12 {\r
13 \r
14     template <\r
15         typename T,\r
16         unsigned long chunk_size\r
17         >\r
18     class memory_manager_kernel_2\r
19     {\r
20         /*!            \r
21             INITIAL VALUE\r
22                 allocations == 0\r
23                 next == 0\r
24                 first_chunk == 0\r
25 \r
26             REQUIREMENTS ON chunk_size\r
27                 chunk_size is the number of items of type T we will allocate at a time. so\r
28                 it must be > 0.\r
29 \r
30             CONVENTION\r
31                 This memory manager implementation allocates memory in blocks of chunk_size*sizeof(T)\r
32                 bytes.  All the sizeof(T) subblocks are kept in a linked list of free memory blocks\r
33                 and are given out whenever an allocation request occurs.  Also, memory is not freed\r
34                 until this object is destructed.  \r
35 \r
36                 Note that array allocations are not memory managed.\r
37                 \r
38 \r
39 \r
40                 allocations == get_number_of_allocations()\r
41 \r
42                 - if (next != 0) then\r
43                     - next == the next pointer to return from allocate()\r
44                       and next == pointer to the first node in a linked list.  each node\r
45                       is one item in the memory pool.    \r
46                     - the last node in the linked list has next set to 0\r
47                 - else\r
48                     - we need to call new to get the next pointer to return from allocate()\r
49 \r
50 \r
51                 - if (first_chunk != 0) then\r
52                     - first_chunk == the first node in a linked list that contains pointers \r
53                       to all the chunks we have ever allocated.  The last link in the list\r
54                       has its next pointer set to 0.\r
55         !*/\r
56 \r
57         union node\r
58         {\r
59             node* next;\r
60             char item[sizeof(T)];\r
61         };\r
62 \r
63         struct chunk_node\r
64         {\r
65             node* chunk;\r
66             chunk_node* next;\r
67         };\r
68 \r
69     public:\r
70 \r
71         typedef T type;\r
72 \r
73         template <typename U>\r
74         struct rebind {\r
75             typedef memory_manager_kernel_2<U,chunk_size> other;\r
76         };\r
77 \r
78 \r
79         memory_manager_kernel_2(\r
80         ) :\r
81             allocations(0),\r
82             next(0),\r
83             first_chunk(0)\r
84         {\r
85             // You FOOL!  You can't have a zero chunk_size.\r
86             COMPILE_TIME_ASSERT(chunk_size > 0);\r
87         }\r
88 \r
89         virtual ~memory_manager_kernel_2(\r
90         )\r
91         {\r
92             if (allocations == 0)\r
93             {\r
94                 while (first_chunk != 0)\r
95                 {\r
96                     chunk_node* temp = first_chunk;\r
97                     first_chunk = first_chunk->next;\r
98                     // delete the memory chunk \r
99                     ::operator delete ( reinterpret_cast<void*>(temp->chunk));\r
100                     // delete the chunk_node\r
101                     delete temp;\r
102                 }\r
103             }\r
104         }\r
105 \r
106         unsigned long get_number_of_allocations (\r
107         ) const { return allocations; }\r
108 \r
109         T* allocate_array (\r
110             unsigned long size\r
111         )\r
112         {\r
113             T* temp = new T[size];\r
114             ++allocations;\r
115             return temp;\r
116         }\r
117 \r
118         void deallocate_array (\r
119             T* item\r
120         )\r
121         {\r
122             --allocations;\r
123             delete [] item;\r
124         }\r
125 \r
126         T* allocate (\r
127         ) \r
128         {              \r
129             T* temp = 0;\r
130             if (next != 0)\r
131             {\r
132                 temp = reinterpret_cast<T*>(next);\r
133                 node* n = next->next;\r
134 \r
135                 try\r
136                 {\r
137                     // construct this new T object with placement new.\r
138                     new (reinterpret_cast<void*>(temp))T();\r
139                 }\r
140                 catch (...)\r
141                 {\r
142                     next->next = n;\r
143                     throw;\r
144                 }\r
145 \r
146                 next = n;\r
147             }\r
148             else\r
149             {\r
150                 // the linked list is empty so we need to allocate some more memory\r
151                 node* block = 0;\r
152                 block = reinterpret_cast<node*>(::operator new (sizeof(node)*chunk_size));\r
153 \r
154                 // the first part of this block can be our new object\r
155                 temp = reinterpret_cast<T*>(block);\r
156 \r
157                 try\r
158                 {\r
159                     // construct this new T object with placement new.\r
160                     new (reinterpret_cast<void*>(temp))T();\r
161                 }\r
162                 catch (...)\r
163                 {\r
164                     // construction of the new object threw so delete the block of memory\r
165                     ::operator delete ( reinterpret_cast<void*>(block));\r
166                     throw;\r
167                 }\r
168 \r
169                 // allocate a new chunk_node\r
170                 chunk_node* chunk;\r
171                 try {chunk = new chunk_node; }\r
172                 catch (...) \r
173                 { \r
174                     temp->~T();\r
175                     ::operator delete ( reinterpret_cast<void*>(block));\r
176                     throw;\r
177                 }\r
178 \r
179                 // add this block into the chunk list\r
180                 chunk->chunk = block;\r
181                 chunk->next = first_chunk;\r
182                 first_chunk = chunk;\r
183 \r
184 \r
185                 ++block;\r
186                 // now add the rest of the block into the linked list of free nodes.\r
187                 for (unsigned long i = 0; i < chunk_size-1; ++i)\r
188                 {\r
189                     block->next = next;\r
190                     next = block;\r
191                     ++block;\r
192                 }\r
193 \r
194             }\r
195 \r
196 \r
197             ++allocations;\r
198             return temp;\r
199         }\r
200 \r
201         void deallocate (\r
202             T* item\r
203         ) \r
204         { \r
205             --allocations;  \r
206             item->~T();\r
207 \r
208             // add this memory into our linked list.\r
209             node* temp = reinterpret_cast<node*>(item);\r
210             temp->next = next;\r
211             next = temp;                \r
212         }\r
213 \r
214         void swap (\r
215             memory_manager_kernel_2& item\r
216         ) \r
217         { \r
218             exchange(allocations,item.allocations); \r
219             exchange(next,item.next); \r
220             exchange(first_chunk,item.first_chunk);\r
221         }\r
222 \r
223     private:\r
224 \r
225         // data members\r
226         unsigned long allocations;\r
227         node* next;\r
228 \r
229         chunk_node* first_chunk;\r
230 \r
231 \r
232 \r
233 \r
234         // restricted functions\r
235         memory_manager_kernel_2(memory_manager_kernel_2&);        // copy constructor\r
236         memory_manager_kernel_2& operator=(memory_manager_kernel_2&);    // assignment operator\r
237     };\r
238 \r
239     template <\r
240         typename T,\r
241         unsigned long chunk_size\r
242         >\r
243     inline void swap (\r
244         memory_manager_kernel_2<T,chunk_size>& a, \r
245         memory_manager_kernel_2<T,chunk_size>& b \r
246     ) { a.swap(b); }   \r
247 \r
248 // ----------------------------------------------------------------------------------------\r
249 \r
250 }\r
251 \r
252 #endif // DLIB_MEMORY_MANAGER_KERNEl_2_\r
253 \r