summaryrefslogtreecommitdiff
path: root/firmware/test/memory
diff options
context:
space:
mode:
Diffstat (limited to 'firmware/test/memory')
-rw-r--r--firmware/test/memory/memory-block.c25
-rw-r--r--firmware/test/memory/memory-block.txt0
-rw-r--r--firmware/test/memory/memory-misc.c14
-rw-r--r--firmware/test/memory/memory-misc.txt0
-rw-r--r--firmware/test/memory/memory-page.c209
-rw-r--r--firmware/test/memory/memory-page.h59
-rw-r--r--firmware/test/memory/memory-page.txt0
-rw-r--r--firmware/test/memory/memory-slab.c111
-rw-r--r--firmware/test/memory/memory-slab.h62
-rw-r--r--firmware/test/memory/memory-slab.txt0
10 files changed, 273 insertions, 207 deletions
diff --git a/firmware/test/memory/memory-block.c b/firmware/test/memory/memory-block.c
index e4ffbfaf73..c5cf3ce9f8 100644
--- a/firmware/test/memory/memory-block.c
+++ b/firmware/test/memory/memory-block.c
@@ -16,13 +16,12 @@
16 * KIND, either express or implied. 16 * KIND, either express or implied.
17 * 17 *
18 ****************************************************************************/ 18 ****************************************************************************/
19#ifndef __LIBRARY_MEMORY_C__ 19#if 0
20# error "This header file must be included ONLY from memory.c." 20#include <memory.h>
21#endif 21#include "memory-page.h"
22#ifndef __LIBRARY_MEMORY_BLOCK_H__ 22#include "memory-slab.h"
23# define __LIBRARY_MEMORY_BLOCK_H__
24 23
25static struct memory_cache *free_block_cache[MEMORY_PAGE_MINIMAL_ORDER - 2]; 24static struct memory_cache *__memory_free_block_cache[MEMORY_PAGE_MINIMAL_ORDER - 2];
26 25
27/////////////////////////////////////////////////////////////////////////////// 26///////////////////////////////////////////////////////////////////////////////
28// MEMORY BLOCK : 27// MEMORY BLOCK :
@@ -32,15 +31,15 @@ static struct memory_cache *free_block_cache[MEMORY_PAGE_MINIMAL_ORDER - 2];
32// - memory_release_block : release a power-of-2-sized block (or a page) 31// - memory_release_block : release a power-of-2-sized block (or a page)
33// 32//
34 33
35static inline void *allocate_small_block (int order) 34static inline void *__memory_allocate_block (int order)
36 { 35 {
37 struct memory_cache *cache = free_block_cache[order - 2]; 36 struct memory_cache *cache = __memory_free_block_cache[order - 2];
38 do 37 do
39 { 38 {
40 if (cache) 39 if (cache)
41 return memory_cache_allocate (cache); 40 return memory_cache_allocate (cache);
42 } 41 }
43 while ((free_block_cache[order] = cache = memory_create_cache (size,0,0))); 42 while ((__memory_free_block_cache[order] = cache = memory_create_cache (size,0,0)));
44 return MEMORY_RETURN_FAILURE; 43 return MEMORY_RETURN_FAILURE;
45 } 44 }
46 45
@@ -49,15 +48,15 @@ void *memory_allocate_block (int order)
49 if (order < 2) 48 if (order < 2)
50 order = 2; 49 order = 2;
51 if (order < MEMORY_PAGE_MINIMAL_ORDER) 50 if (order < MEMORY_PAGE_MINIMAL_ORDER)
52 return allocate_small_block (order); 51 return __memory_allocate_block (order);
53 if (order < MEMORY_PAGE_MAXIMAL_ORDER) 52 if (order < MEMORY_PAGE_MAXIMAL_ORDER)
54 return memory_allocate_page (order); 53 return memory_allocate_page (order);
55 return MEMORY_RETURN_FAILURE; 54 return MEMORY_RETURN_FAILURE;
56 } 55 }
57 56
58static inline int release_block (int order,void *address) 57static inline int __memory_release_block (int order,void *address)
59 { 58 {
60 struct memory_cache *cache = free_block_cache[order - 2]; 59 struct memory_cache *cache = __memory_free_block_cache[order - 2];
61 if (cache) 60 if (cache)
62 return memory_cache_release (cache,address); 61 return memory_cache_release (cache,address);
63 return MEMORY_RETURN_FAILURE; 62 return MEMORY_RETURN_FAILURE;
@@ -68,7 +67,7 @@ int memory_release_block (int order,void *address)
68 if (order < 2) 67 if (order < 2)
69 order = 2; 68 order = 2;
70 if (order < MEMORY_PAGE_MINIMAL_ORDER) 69 if (order < MEMORY_PAGE_MINIMAL_ORDER)
71 return release_block (order); 70 return __memory_release_block (order);
72 if (order < MEMORY_PAGE_MAXIMAL_ORDER) 71 if (order < MEMORY_PAGE_MAXIMAL_ORDER)
73 return memory_release_page (address); 72 return memory_release_page (address);
74 return MEMORY_RETURN_FAILURE; 73 return MEMORY_RETURN_FAILURE;
diff --git a/firmware/test/memory/memory-block.txt b/firmware/test/memory/memory-block.txt
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/firmware/test/memory/memory-block.txt
diff --git a/firmware/test/memory/memory-misc.c b/firmware/test/memory/memory-misc.c
index 9a9e36c0da..765600765b 100644
--- a/firmware/test/memory/memory-misc.c
+++ b/firmware/test/memory/memory-misc.c
@@ -17,6 +17,10 @@
17 * 17 *
18 ****************************************************************************/ 18 ****************************************************************************/
19#include <memory.h> 19#include <memory.h>
20#include "memory-page.h"
21#if 0
22#include "memory-slab.h"
23#endif
20 24
21/* NOT VERY OPTIMIZED AT ALL BUT WE WILL DO IT WHEN PRIORITY COMES */ 25/* NOT VERY OPTIMIZED AT ALL BUT WE WILL DO IT WHEN PRIORITY COMES */
22void memory_copy (void *target,void const *source,unsigned int count) 26void memory_copy (void *target,void const *source,unsigned int count)
@@ -35,10 +39,10 @@ void memory_set (void *target,int byte,unsigned int count)
35void memory_setup (void) 39void memory_setup (void)
36 { 40 {
37#if 1 41#if 1
38 memory_set (free_page,0,MEMORY_TOTAL_BYTES); 42 memory_set (__memory_free_page,0,MEMORY_TOTAL_BYTES);
39 memory_set (free_page_bin,0,MEMORY_TOTAL_ORDERS *sizeof (struct memory_free_page *)); 43 memory_set (__memory_free_page_bin,0,MEMORY_TOTAL_ORDERS *sizeof (struct memory_free_page *));
40 memory_set (free_page_order + 1,0,MEMORY_TOTAL_PAGES); 44 memory_set (__memory_free_page_order + 1,0,MEMORY_TOTAL_PAGES);
41#endif 45#endif
42 free_page_order[0] = MEMORY_TOTAL_ORDERS - 1; 46 __memory_free_page_order[0] = MEMORY_TOTAL_ORDERS - 1;
43 free_page_bin[MEMORY_TOTAL_ORDERS - 1] = free_page; 47 __memory_free_page_bin[MEMORY_TOTAL_ORDERS - 1] = __memory_free_page;
44 } 48 }
diff --git a/firmware/test/memory/memory-misc.txt b/firmware/test/memory/memory-misc.txt
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/firmware/test/memory/memory-misc.txt
diff --git a/firmware/test/memory/memory-page.c b/firmware/test/memory/memory-page.c
index a9b9707fd9..1327cf57c9 100644
--- a/firmware/test/memory/memory-page.c
+++ b/firmware/test/memory/memory-page.c
@@ -16,86 +16,70 @@
16 * KIND, either express or implied. 16 * KIND, either express or implied.
17 * 17 *
18 ****************************************************************************/ 18 ****************************************************************************/
19#ifndef __LIBRARY_MEMORY_C__ 19#include <memory.h>
20# error "This header file must be included ONLY from memory.c." 20#include "memory-page.h"
21#if 0
22#include "memory-slab.h"
21#endif 23#endif
22#ifndef __LIBRARY_MEMORY_PAGE_H__
23# define __LIBRARY_MEMORY_PAGE_H__
24
25struct memory_free_page
26 {
27 struct memory_free_page
28 *less,*more;
29 char
30 reserved[MEMORY_PAGE_MINIMAL_SIZE - 2*sizeof (struct memory_free_page *)];
31 };
32
33#define LESS -1
34#define MORE +1
35 24
36#ifdef TEST 25#ifdef TEST
37 26
38struct memory_free_page free_page[MEMORY_TOTAL_PAGES];
39
40static inline unsigned int get_offset (int order)
41 {
42 return (2 << order);
43 }
44
45// IA32 has no problem with shift operation 27// IA32 has no problem with shift operation
46static inline unsigned int get_size (int order) 28static inline unsigned int __memory_get_size (int order)
47 { 29 {
48 return (MEMORY_PAGE_MINIMAL_SIZE << order); 30 return (MEMORY_PAGE_MINIMAL_SIZE << order);
49 } 31 }
50 32
51// Arghhhh ! I cannot align 'free_page' on 512-byte boundary (max is 16-byte for Cygwin) 33// Arghhhh ! I cannot align 'free_page' on 512-byte boundary (max is 16-byte for Cygwin)
52static inline struct memory_free_page *get_neighbour (struct memory_free_page *node,unsigned int size) 34static inline struct memory_free_page *__memory_get_neighbour (struct memory_free_page *node,unsigned int size)
53 { 35 {
54 return ((struct memory_free_page *)((unsigned)free_page + (((unsigned)node - (unsigned)free_page) ^ size))); 36 return ((struct memory_free_page *)((unsigned)__memory_free_page + (((unsigned)node - (unsigned)__memory_free_page) ^ size)));
55 } 37 }
56 38
57#else 39#else
58 40
59extern struct memory_free_page free_page[MEMORY_TOTAL_PAGES] asm("dram");
60
61static inline unsigned int get_offset (int order)
62 {
63 static unsigned short offset [MEMORY_TOTAL_ORDERS] =
64 { 2,4,8,16,32,64,128,256,512,1024,2048,4096,8192 };
65 return offset[order];
66 }
67
68// SH1 has very poor shift instructions (only <<1,>>1,<<2,>>2,<<8,>>8,<<16 and >>16). 41// SH1 has very poor shift instructions (only <<1,>>1,<<2,>>2,<<8,>>8,<<16 and >>16).
69// so we should use a lookup table to speedup. 42// so we should use a lookup table to speedup.
70static inline unsigned int get_size (int order) 43static inline unsigned int __memory_get_size (int order)
71 { 44 {
72 return (get_offset (order))<<8; 45 static unsigned short size [MEMORY_TOTAL_ORDERS] =
46 {
47 1<<MEMORY_PAGE_MINIMAL_ORDER,
48 2<<MEMORY_PAGE_MINIMAL_ORDER,
49 4<<MEMORY_PAGE_MINIMAL_ORDER,
50 8<<MEMORY_PAGE_MINIMAL_ORDER,
51 16<<MEMORY_PAGE_MINIMAL_ORDER,
52 32<<MEMORY_PAGE_MINIMAL_ORDER,
53 64<<MEMORY_PAGE_MINIMAL_ORDER,
54 128<<MEMORY_PAGE_MINIMAL_ORDER,
55 256<<MEMORY_PAGE_MINIMAL_ORDER,
56 512<<MEMORY_PAGE_MINIMAL_ORDER,
57 1024<<MEMORY_PAGE_MINIMAL_ORDER,
58 2048<<MEMORY_PAGE_MINIMAL_ORDER,
59 4096<<MEMORY_PAGE_MINIMAL_ORDER
60 };
61 return size[order];
73 } 62 }
74 63
75static inline struct memory_free_page *get_neighbour (struct memory_free_page *node,unsigned int size) 64static inline struct memory_free_page *__memory_get_neighbour (struct memory_free_page *node,unsigned int size)
76 { 65 {
77 return ((struct memory_free_page *)((unsigned)node ^ size)); 66 return ((struct memory_free_page *)((unsigned)node ^ size));
78 } 67 }
79 68
80#endif 69#endif
81 70
82static char free_page_order[MEMORY_TOTAL_PAGES]; 71static inline int __memory_get_order (struct memory_free_page *node)
83static struct memory_free_page *free_page_bin[MEMORY_TOTAL_ORDERS];
84
85static inline int get_order (struct memory_free_page *node)
86 { 72 {
87 return free_page_order[node - free_page]; 73 return __memory_free_page_order[node - __memory_free_page];
88 } 74 }
89static inline void set_order (struct memory_free_page *node,int order) 75static inline void __memory_set_order (struct memory_free_page *node,int order)
90 { 76 {
91 free_page_order[node - free_page] = order; 77 __memory_free_page_order[node - __memory_free_page] = order;
92 } 78 }
93 79
94#if MEMORY_PAGE_USE_SPLAY_TREE 80#if MEMORY_PAGE_USE_SPLAY_TREE
95 81
96# include <stdio.h> 82static struct memory_free_page *__memory_splay_page (struct memory_free_page *root,struct memory_free_page *node)
97
98static struct memory_free_page *splay_page (struct memory_free_page *root,struct memory_free_page *node)
99 { 83 {
100 struct memory_free_page *down; 84 struct memory_free_page *down;
101 struct memory_free_page *less; 85 struct memory_free_page *less;
@@ -153,15 +137,15 @@ static struct memory_free_page *splay_page (struct memory_free_page *root,struct
153 return root; 137 return root;
154 } 138 }
155 139
156static inline void insert_page (int order,struct memory_free_page *node) 140static inline void __memory_insert_page (int order,struct memory_free_page *node)
157 { 141 {
158 struct memory_free_page *root = free_page_bin[order]; 142 struct memory_free_page *root = __memory_free_page_bin[order];
159 if (!root) 143 if (!root)
160 { 144 {
161 node->less = 145 node->less =
162 node->more = 0; 146 node->more = 0;
163 } 147 }
164 else if (node < (root = splay_page (root,node))) 148 else if (node < (root = __memory_splay_page (root,node)))
165 { 149 {
166 node->less = root->less; 150 node->less = root->less;
167 node->more = root; 151 node->more = root;
@@ -173,91 +157,91 @@ static inline void insert_page (int order,struct memory_free_page *node)
173 node->more = root->more; 157 node->more = root->more;
174 node->more = 0; 158 node->more = 0;
175 } 159 }
176 free_page_bin[order] = node; 160 __memory_free_page_bin[order] = node;
177 set_order (node,order); 161 __memory_set_order (node,order);
178 return; 162 return;
179 } 163 }
180 164
181static inline struct memory_free_page *pop_page (int order,int want) 165static inline struct memory_free_page *__memory_pop_page (int order,int want)
182 { 166 {
183 struct memory_free_page *root = free_page_bin[order]; 167 struct memory_free_page *root = __memory_free_page_bin[order];
184 if (root) 168 if (root)
185 { 169 {
186 root = splay_page (root,free_page); 170 root = __memory_splay_page (root,__memory_free_page);
187 free_page_bin[order] = root->more; 171 __memory_free_page_bin[order] = root->more;
188 set_order (root,~want); 172 __memory_set_order (root,~want);
189 } 173 }
190 return root; 174 return root;
191 } 175 }
192 176
193static inline void remove_page (int order,struct memory_free_page *node) 177static inline void __memory_remove_page (int order,struct memory_free_page *node)
194 { 178 {
195 struct memory_free_page *root = free_page_bin[order]; 179 struct memory_free_page *root = __memory_free_page_bin[order];
196 root = splay_page (root,node); 180 root = __memory_splay_page (root,node);
197 if (root->less) 181 if (root->less)
198 { 182 {
199 node = splay_page (root->less,node); 183 node = __memory_splay_page (root->less,node);
200 node->more = root->more; 184 node->more = root->more;
201 } 185 }
202 else 186 else
203 node = root->more; 187 node = root->more;
204 free_page_bin[order] = node; 188 __memory_free_page_bin[order] = node;
205 } 189 }
206 190
207#else 191#else
208 192
209static inline void insert_page (int order,struct memory_free_page *node) 193static inline void __memory_insert_page (int order,struct memory_free_page *node)
210 { 194 {
211 struct memory_free_page *head = free_page_bin[order]; 195 struct memory_free_page *head = __memory_free_page_bin[order];
212 node->less = 0; 196 node->less = 0;
213 node->more = head; 197 node->more = head;
214 if (head) 198 if (head)
215 head->less = node; 199 head->less = node;
216 free_page_bin[order] = node; 200 __memory_free_page_bin[order] = node;
217 set_order (node,order); 201 __memory_set_order (node,order);
218 } 202 }
219 203
220static inline struct memory_free_page *pop_page (int order,int want) 204static inline struct memory_free_page *pop_page (int order,int want)
221 { 205 {
222 struct memory_free_page *node = free_page_bin[order]; 206 struct memory_free_page *node = __memory_free_page_bin[order];
223 if (node) 207 if (node)
224 { 208 {
225 free_page_bin[order] = node->more; 209 __memory_free_page_bin[order] = node->more;
226 if (node->more) 210 if (node->more)
227 node->more->less = 0; 211 node->more->less = 0;
228 set_order (node,~want); 212 __memory_set_order (node,~want);
229 } 213 }
230 return node; 214 return node;
231 } 215 }
232 216
233static inline void remove_page (int order,struct memory_free_page *node) 217static inline void __memory_remove_page (int order,struct memory_free_page *node)
234 { 218 {
235 if (node->less) 219 if (node->less)
236 node->less->more = node->more; 220 node->less->more = node->more;
237 else 221 else
238 free_page_bin[order] = node->more; 222 __memory_free_page_bin[order] = node->more;
239 if (node->more) 223 if (node->more)
240 node->more->less = node->less; 224 node->more->less = node->less;
241 } 225 }
242 226
243#endif 227#endif
244 228
245static inline void push_page (int order,struct memory_free_page *node) 229static inline void __memory_push_page (int order,struct memory_free_page *node)
246 { 230 {
247 node->less = 0; 231 node->less = 0;
248 node->more = 0; 232 node->more = 0;
249 free_page_bin[order] = node; 233 __memory_free_page_bin[order] = node;
250 set_order (node,order); 234 __memory_set_order (node,order);
251 } 235 }
252 236
253static struct memory_free_page *allocate_page (unsigned int size,int order) 237static struct memory_free_page *__memory_allocate_page (unsigned int size,int order)
254 { 238 {
255 struct memory_free_page *node; 239 struct memory_free_page *node;
256 int min = order; 240 int min = order;
257 while ((unsigned)order <= (MEMORY_TOTAL_ORDERS - 1)) 241 while ((unsigned)order <= (MEMORY_TOTAL_ORDERS - 1))
258 // order is valid ? 242 // order is valid ?
259 { 243 {
260 if (!(node = pop_page (order,min))) 244 if (!(node = __memory_pop_page (order,min)))
261 // no free page of this order ? 245 // no free page of this order ?
262 { 246 {
263 ++order; size <<= 1; 247 ++order; size <<= 1;
@@ -267,39 +251,39 @@ static struct memory_free_page *allocate_page (unsigned int size,int order)
267 // split our larger page in smaller pages 251 // split our larger page in smaller pages
268 { 252 {
269 --order; size >>= 1; 253 --order; size >>= 1;
270 push_page (order,(struct memory_free_page *)((unsigned int)node + size)); 254 __memory_push_page (order,(struct memory_free_page *)((unsigned int)node + size));
271 } 255 }
272 return node; 256 return node;
273 } 257 }
274 return MEMORY_RETURN_FAILURE; 258 return MEMORY_RETURN_FAILURE;
275 } 259 }
276 260
277static inline void release_page (struct memory_free_page *node,unsigned int size,int order) 261static inline void __memory_release_page (struct memory_free_page *node,unsigned int size,int order)
278 { 262 {
279 struct memory_free_page *neighbour; 263 struct memory_free_page *neighbour;
280 while ((order <= (MEMORY_TOTAL_ORDERS - 1)) && 264 while ((order <= (MEMORY_TOTAL_ORDERS - 1)) &&
281 ((neighbour = get_neighbour (node,size)), 265 ((neighbour = __memory_get_neighbour (node,size)),
282 (get_order (neighbour) == order))) 266 (__memory_get_order (neighbour) == order)))
283 // merge our released page with its contiguous page into a larger page 267 // merge our released page with its contiguous page into a larger page
284 { 268 {
285 remove_page (order,neighbour); 269 __memory_remove_page (order,neighbour);
286 ++order; size <<= 1; 270 ++order; size <<= 1;
287 if (neighbour < node) 271 if (neighbour < node)
288 node = neighbour; 272 node = neighbour;
289 } 273 }
290 insert_page (order,node); 274 __memory_insert_page (order,node);
291 } 275 }
292 276
293 277
294/*****************************************************************************/ 278/*****************************************************************************/
295/* PUBLIC FUNCTIONS */ 279/* PUBLIC FUNCTIONS */
296/*****************************************************************************/ 280/*****************************************************************************/
297 281
298void *memory_allocate_page (int order) 282void *memory_allocate_page (int order)
299 { 283 {
300 if (order < 0) 284 if (order < 0)
301 return MEMORY_RETURN_FAILURE; 285 return MEMORY_RETURN_FAILURE;
302 return allocate_page (get_size (order),order); 286 return __memory_allocate_page (__memory_get_size (order),order);
303 } 287 }
304 288
305// release a page : 289// release a page :
@@ -309,10 +293,10 @@ void *memory_allocate_page (int order)
309int memory_release_page (void *address) 293int memory_release_page (void *address)
310 { 294 {
311 struct memory_free_page *node = (struct memory_free_page *)address; 295 struct memory_free_page *node = (struct memory_free_page *)address;
312 int order = ~get_order (node); 296 int order = ~__memory_get_order (node);
313 if (order < 0) 297 if (order < 0)
314 return MEMORY_RETURN_FAILURE; 298 return MEMORY_RETURN_FAILURE;
315 release_page (node,get_size (order),order); 299 __memory_release_page (node,__memory_get_size (order),order);
316 return MEMORY_RETURN_SUCCESS; 300 return MEMORY_RETURN_SUCCESS;
317 } 301 }
318 302
@@ -322,58 +306,58 @@ int memory_release_page (void *address)
322# include <stdlib.h> 306# include <stdlib.h>
323# if MEMORY_PAGE_USE_SPLAY_TREE 307# if MEMORY_PAGE_USE_SPLAY_TREE
324 308
325static void dump_splay_node (struct memory_free_page *node,int level) 309void __memory_dump_splay_node (struct memory_free_page *node,int level)
326 { 310 {
327 if (!node) 311 if (!node)
328 return; 312 return;
329 dump_splay_node (node->less,level+1); 313 __memory_dump_splay_node (node->less,level+1);
330 printf ("\n%*s[%d-%d]",level,"",(node - free_page),(node - free_page) + (1 << get_order (node)) - 1); 314 printf ("\n%*s[%d-%d]",level,"",(node - __memory_free_page),(node - __memory_free_page) + (1 << __memory_get_order (node)) - 1);
331 dump_splay_node (node->more,level+1); 315 __memory_dump_splay_node (node->more,level+1);
332 } 316 }
333 317
334static void dump_splay_tree (struct memory_free_page *root) 318void __memory_dump_splay_tree (struct memory_free_page *root)
335 { 319 {
336 dump_splay_node (root,2); fflush (stdout); 320 __memory_dump_splay_node (root,2); fflush (stdout);
337 } 321 }
338 322
339# endif 323# endif
340 324
341void memory_spy_page (void *address) 325void __memory_spy_page (void *address)
342 { 326 {
343 struct memory_free_page *node = (struct memory_free_page *)address; 327 struct memory_free_page *node = (struct memory_free_page *)address;
344 int order,used; 328 int order,used;
345 if (node) 329 if (node)
346 { 330 {
347 order = get_order (node); 331 order = __memory_get_order (node);
348 used = order < 0; 332 used = order < 0;
349 if (used) 333 if (used)
350 order = ~order; 334 order = ~order;
351 printf("\n(%s,%2d,%7d)",(used ? "used" : "free"),order,get_size (order)); 335 printf("\n(%s,%2d,%7d)",(used ? "used" : "free"),order,__memory_get_size (order));
352 } 336 }
353 } 337 }
354 338
355void memory_dump (int order) 339void __memory_dump (int order)
356 { 340 {
357 struct memory_free_page *node = free_page_bin[order]; 341 struct memory_free_page *node = __memory_free_page_bin[order];
358 printf("\n(%s,%2d,%7d)",node ? "free" : "none",order,get_size (order)); 342 printf("\n(%s,%2d,%7d)",node ? "free" : "none",order,__memory_get_size (order));
359# if MEMORY_PAGE_USE_SPLAY_TREE 343# if MEMORY_PAGE_USE_SPLAY_TREE
360 dump_splay_tree (node); 344 __memory_dump_splay_tree (node);
361# else 345# else
362 while (node) 346 while (node)
363 { 347 {
364 printf("[%d-%d]",(node - free_page),(node - free_page) + (1<<order) - 1); 348 printf("[%d-%d]",(node - __memory_free_page),(node - __memory_free_page) + (1<<order) - 1);
365 node = node->more; 349 node = node->more;
366 } 350 }
367# endif 351# endif
368 352
369 } 353 }
370 354
371void memory_check (int order) 355void __memory_check (int order)
372 { 356 {
373 struct memory_free_page *node[4096],*swap; 357 struct memory_free_page *node[4096],*swap;
374 unsigned int i = 0,j = 0; 358 unsigned int i = 0,j = 0;
375 while (i <= 12) 359 while (i <= 12)
376 memory_dump (i++); 360 __memory_dump (i++);
377 i = 0; 361 i = 0;
378 printf ("\nallocating...\n"); 362 printf ("\nallocating...\n");
379 while (order >= 0) 363 while (order >= 0)
@@ -382,31 +366,31 @@ void memory_check (int order)
382 while ((swap = memory_allocate_page (j))) 366 while ((swap = memory_allocate_page (j)))
383 { 367 {
384 node[i++] = swap; 368 node[i++] = swap;
385 printf("[%d-%d]",(swap - free_page),(swap - free_page) + ((1 << j)-1)); 369 printf("[%d-%d]",(swap - __memory_free_page),(swap - __memory_free_page) + ((1 << j)-1));
386 for (j += (rand () & 15); j > (unsigned int)order; j -= order); 370 for (j += (rand () & 15); j > (unsigned int)order; j -= order);
387 } 371 }
388 --order; 372 --order;
389 } 373 }
390 node[i] = 0; 374 node[i] = 0;
391 while (j <= 12) 375 while (j <= 12)
392 memory_dump (j++); 376 __memory_dump (j++);
393 j = 0; 377 j = 0;
394 printf ("\nreleasing..."); 378 printf ("\nreleasing...");
395 --i; 379 --i;
396 while (i > 0) 380 while (i > 0)
397 { 381 {
398 unsigned int k = 0; 382 unsigned int k = 0;
399#if 0 383# if 0
400 printf ("\n"); 384 printf ("\n");
401#endif 385# endif
402 swap = node[k++]; 386 swap = node[k++];
403#if 0 387# if 0
404 while (swap) 388 while (swap)
405 { 389 {
406 printf("[%d-%d]",(swap - free_page),(swap - free_page) + ((1 << ~get_order (swap))-1)); 390 printf("[%d-%d]",(swap - __memory_free_page),(swap - __memory_free_page) + ((1 << ~__memory_get_order (swap))-1));
407 swap = node[k++]; 391 swap = node[k++];
408 } 392 }
409#endif 393# endif
410 for (j += 1 + (rand () & 15); j >= i; j -= i); 394 for (j += 1 + (rand () & 15); j >= i; j -= i);
411 swap = node[j]; 395 swap = node[j];
412 node[j] = node[i]; 396 node[j] = node[i];
@@ -417,9 +401,8 @@ void memory_check (int order)
417 memory_release_page (node[0]); 401 memory_release_page (node[0]);
418 i = 0; 402 i = 0;
419 while (i <= 12) 403 while (i <= 12)
420 memory_dump (i++); 404 __memory_dump (i++);
421 printf("\n\n%s !",(get_order (free_page) == 12) ? "SUCCESS" : "FAILURE"); 405 printf("\n\n%s !",(__memory_get_order (__memory_free_page) == 12) ? "SUCCESS" : "FAILURE");
422 } 406 }
423 407
424#endif 408#endif
425#endif
diff --git a/firmware/test/memory/memory-page.h b/firmware/test/memory/memory-page.h
new file mode 100644
index 0000000000..ab360447d7
--- /dev/null
+++ b/firmware/test/memory/memory-page.h
@@ -0,0 +1,59 @@
1/***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id:
9 *
10 * Copyright (C) 2002 by Alan Korr
11 *
12 * All files in this archive are subject to the GNU General Public License.
13 * See the file COPYING in the source tree root for full license agreement.
14 *
15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
16 * KIND, either express or implied.
17 *
18 ****************************************************************************/
19#ifndef __LIBRARY_MEMORY_PAGE_H__
20#define __LIBRARY_MEMORY_PAGE_H__
21
22struct memory_free_page
23 {
24 struct memory_free_page
25 *less,*more;
26 char
27 reserved[MEMORY_PAGE_MINIMAL_SIZE - 2*sizeof (struct memory_free_page *)];
28 };
29
30#define LESS -1
31#define MORE +1
32
33#ifdef TEST
34
35struct memory_free_page __memory_free_page[MEMORY_TOTAL_PAGES];
36
37#else
38
39extern struct memory_free_page __memory_free_page[MEMORY_TOTAL_PAGES] asm("dram");
40
41#endif
42
43char __memory_free_page_order[MEMORY_TOTAL_PAGES];
44struct memory_free_page *__memory_free_page_bin[MEMORY_TOTAL_ORDERS];
45
46#ifdef TEST
47# if MEMORY_PAGE_USE_SPLAY_TREE
48
49void __memory_dump_splay_node (struct memory_free_page *node,int level);
50void __memory_dump_splay_tree (struct memory_free_page *root);
51
52# endif
53
54void __memory_spy_page (void *address);
55void __memory_dump (int order);
56void __memory_check (int order);
57
58#endif
59#endif \ No newline at end of file
diff --git a/firmware/test/memory/memory-page.txt b/firmware/test/memory/memory-page.txt
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/firmware/test/memory/memory-page.txt
diff --git a/firmware/test/memory/memory-slab.c b/firmware/test/memory/memory-slab.c
index 2c9e1f231f..35ab96f787 100644
--- a/firmware/test/memory/memory-slab.c
+++ b/firmware/test/memory/memory-slab.c
@@ -16,17 +16,10 @@
16 * KIND, either express or implied. 16 * KIND, either express or implied.
17 * 17 *
18 ****************************************************************************/ 18 ****************************************************************************/
19#ifndef __LIBRARY_MEMORY_C__ 19#if 0
20# error "This header file must be included ONLY from memory.c." 20#include <memory.h>
21#endif 21#include "memory-page.h"
22#ifndef __LIBRARY_MEMORY_PAGE_H__ 22#include "memory-slab.h"
23# define __LIBRARY_MEMORY_PAGE_H__
24
25struct memory_free_block
26 {
27 struct memory_free_block
28 *link;
29 };
30 23
31/////////////////////////////////////////////////////////////////////////////// 24///////////////////////////////////////////////////////////////////////////////
32// MEMORY SLAB : 25// MEMORY SLAB :
@@ -34,17 +27,7 @@ struct memory_free_block
34// 27//
35// 28//
36 29
37struct memory_slab 30static inline struct memory_slab *__memory_push_slab (struct memory_slab *head,struct memory_slab *node)
38 {
39 struct memory_slab
40 *less,*more;
41 unsigned int // left == number of free blocks left
42 left;
43 struct memory_free_block
44 *free;
45 };
46
47static inline struct memory_slab *push_slab (struct memory_slab *head,struct memory_slab *node)
48 { 31 {
49 node->less = head; 32 node->less = head;
50 if (head) 33 if (head)
@@ -57,14 +40,14 @@ static inline struct memory_slab *push_slab (struct memory_slab *head,struct mem
57 return node; 40 return node;
58 } 41 }
59 42
60static inline struct memory_slab *pop_slab (struct memory_slab *head,struct memory_slab *node) 43static inline struct memory_slab *__memory_pop_slab (struct memory_slab *head,struct memory_slab *node)
61 { 44 {
62 if (head) 45 if (head)
63 head->more = node->more; 46 head->more = node->more;
64 return node->more; 47 return node->more;
65 } 48 }
66 49
67static inline struct memory_slab *move_slab (struct memory_slab **from,struct memory_slab **to) 50static inline struct memory_slab *__memory_move_slab (struct memory_slab **from,struct memory_slab **to)
68 { 51 {
69 struct memory_slab *head = *from; 52 struct memory_slab *head = *from;
70 *from = (*from)->more; 53 *from = (*from)->more;
@@ -87,33 +70,9 @@ static inline struct memory_slab *move_slab (struct memory_slab **from,struct me
87// 70//
88// 71//
89 72
90struct memory_cache
91 {
92 struct memory_cache
93 *less,*more,*same;
94 unsigned int
95 left; // number of free slabs
96 struct memory_slab
97 *used;
98 struct memory_slab
99 *free;
100 struct memory_slab
101 *reap;
102 unsigned int
103 size,original_size;
104 unsigned int
105 page_size;
106 unsigned int
107 blocks_per_slab;
108 int
109 page_order;
110 unsigned int
111 flags;
112 };
113
114static struct memory_cache *cache_tree; 73static struct memory_cache *cache_tree;
115 74
116static inline int get_order (unsigned size) 75static inline int __memory_get_order (unsigned size)
117 { 76 {
118 int order = 0; 77 int order = 0;
119 size = (size + sizeof(struct memory_free_block) - 1) & - sizeof(struct memory_free_block); 78 size = (size + sizeof(struct memory_free_block) - 1) & - sizeof(struct memory_free_block);
@@ -124,7 +83,7 @@ static inline int get_order (unsigned size)
124 return order; 83 return order;
125 } 84 }
126 85
127static inline struct memory_slab *get_slab (struct memory_cache *cache,void *address) 86static inline struct memory_slab *__memory_get_slab (struct memory_cache *cache,void *address)
128 { 87 {
129#ifdef TEST 88#ifdef TEST
130 return (struct memory_slab *)((((unsigned)address + cache->page_size) & -cache->page_size) - sizeof (struct memory_slab)); 89 return (struct memory_slab *)((((unsigned)address + cache->page_size) & -cache->page_size) - sizeof (struct memory_slab));
@@ -133,7 +92,7 @@ static inline struct memory_slab *get_slab (struct memory_cache *cache,void *add
133#endif 92#endif
134 } 93 }
135 94
136static struct memory_cache *splay_cache (struct memory_cache *root,unsigned int left) 95static struct memory_cache *__memory_splay_cache (struct memory_cache *root,unsigned int left)
137 { 96 {
138 struct memory_cache *down; 97 struct memory_cache *down;
139 struct memory_cache *less; 98 struct memory_cache *less;
@@ -191,14 +150,14 @@ static struct memory_cache *splay_cache (struct memory_cache *root,unsigned int
191 return root; 150 return root;
192 } 151 }
193 152
194static inline struct memory_cache *insert_cache (struct memory_cache *root,struct memory_cache *node) 153static inline struct memory_cache *__memory_insert_cache (struct memory_cache *root,struct memory_cache *node)
195 { 154 {
196 node->less = 155 node->less =
197 node->more = 156 node->more =
198 node->same = 0; 157 node->same = 0;
199 if (root) 158 if (root)
200 { 159 {
201 if (node->left == ((root = splay_cache (root,node))->left)) 160 if (node->left == ((root = __memory_splay_cache (root,node))->left))
202 { 161 {
203 node->less = root.less; 162 node->less = root.less;
204 node->more = root.more; 163 node->more = root.more;
@@ -221,11 +180,11 @@ static inline struct memory_cache *insert_cache (struct memory_cache *root,struc
221 return node; 180 return node;
222 } 181 }
223 182
224static inline struct memory_cache *remove_cache (struct memory_cache *root,struct memory_cache *node) 183static inline struct memory_cache *__memory_remove_cache (struct memory_cache *root,struct memory_cache *node)
225 { 184 {
226 if (root) 185 if (root)
227 { 186 {
228 root = splay_cache (root,node); 187 root = __memory_splay_cache (root,node);
229 if (root != node) 188 if (root != node)
230 { 189 {
231 node->less->same = node->same; 190 node->less->same = node->same;
@@ -235,7 +194,7 @@ static inline struct memory_cache *remove_cache (struct memory_cache *root,struc
235 } 194 }
236 if (root->less) 195 if (root->less)
237 { 196 {
238 node = splay_page (root->less,node); 197 node = __memory_splay_page (root->less,node);
239 node->more = root->more; 198 node->more = root->more;
240 } 199 }
241 else 200 else
@@ -244,12 +203,12 @@ static inline struct memory_cache *remove_cache (struct memory_cache *root,struc
244 return root; 203 return root;
245 } 204 }
246 205
247static inline struct memory_cache *move_cache (struct memory_cache *root,struct memory_cache *node,int delta) 206static inline struct memory_cache *__memory_move_cache (struct memory_cache *root,struct memory_cache *node,int delta)
248 { 207 {
249 if ((root = remove_cache (root,node))) 208 if ((root = __memory_remove_cache (root,node)))
250 { 209 {
251 node->left += delta; 210 node->left += delta;
252 root = insert_cache (root,node); 211 root = __memory_insert_cache (root,node);
253 } 212 }
254 return root; 213 return root;
255 } 214 }
@@ -291,15 +250,15 @@ struct memory_slab *memory_grow_cache (struct memory_cache *cache)
291 } 250 }
292 *link = 0; 251 *link = 0;
293 cache->blocks_per_slab = slab->free; 252 cache->blocks_per_slab = slab->free;
294 cache->reap = push_slab (cache->reap,slab); 253 cache->reap = __memory_push_slab (cache->reap,slab);
295 cache_tree = move_cache (cache_tree,cache,+1); 254 cache_tree = __memory_move_cache (cache_tree,cache,+1);
296 return slab; 255 return slab;
297 } 256 }
298 } 257 }
299 return MEMORY_RETURN_FAILURE; 258 return MEMORY_RETURN_FAILURE;
300 } 259 }
301 260
302static int shrink_cache (struct memory_cache *cache,int all,int move) 261static int __memory_shrink_cache (struct memory_cache *cache,int all,int move)
303 { 262 {
304 struct memory_slab *slab; 263 struct memory_slab *slab;
305 unsigned int slabs = 0; 264 unsigned int slabs = 0;
@@ -308,12 +267,12 @@ static int shrink_cache (struct memory_cache *cache,int all,int move)
308 while ((slab = cache->reap)) 267 while ((slab = cache->reap))
309 { 268 {
310 ++slabs; 269 ++slabs;
311 cache->reap = pop_slab (cache->reap,slab); 270 cache->reap = __memory_pop_slab (cache->reap,slab);
312 memory_release_page ((void *)slab); 271 memory_release_page ((void *)slab);
313 if (all) 272 if (all)
314 continue; 273 continue;
315 if (move) 274 if (move)
316 cache_tree = move_cache (cache_tree,cache,-slabs); 275 cache_tree = __memory_move_cache (cache_tree,cache,-slabs);
317 return MEMORY_RETURN_SUCCESS; 276 return MEMORY_RETURN_SUCCESS;
318 } 277 }
319 } 278 }
@@ -322,7 +281,7 @@ static int shrink_cache (struct memory_cache *cache,int all,int move)
322 281
323int memory_shrink_cache (struct memory_cache *cache,int all) 282int memory_shrink_cache (struct memory_cache *cache,int all)
324 { 283 {
325 return shrink_cache (cache,all,1 /* move cache in cache_tree */); 284 return __memory_shrink_cache (cache,all,1 /* move cache in cache_tree */);
326 } 285 }
327 286
328struct memory_cache *memory_create_cache (unsigned int size,int align,int flags) 287struct memory_cache *memory_create_cache (unsigned int size,int align,int flags)
@@ -382,7 +341,7 @@ struct memory_cache *memory_create_cache (unsigned int size,int align,int flags)
382 cache->page_size = page_size; 341 cache->page_size = page_size;
383 cache->page_order = page_order; 342 cache->page_order = page_order;
384 343
385 cache_tree = insert_cache (cache_tree,cache); 344 cache_tree = __memory_insert_cache (cache_tree,cache);
386 345
387 return cache; 346 return cache;
388 } 347 }
@@ -392,8 +351,8 @@ int memory_destroy_cache (struct memory_cache *cache)
392 /* FIX ME : this function shouldn't be called if there are still used blocks */ 351 /* FIX ME : this function shouldn't be called if there are still used blocks */
393 if (cache && !cache->free && !cache->used) 352 if (cache && !cache->free && !cache->used)
394 { 353 {
395 cache_tree = remove_cache (cache_tree,cache); 354 cache_tree = __memory_remove_cache (cache_tree,cache);
396 if (shrink_cache (cache,1 /* release all free slabs */,0 /* don't move in cache_tree */)) 355 if (__memory_shrink_cache (cache,1 /* release all free slabs */,0 /* don't move in cache_tree */))
397 return memory_cache_release (&cache_cache,cache); 356 return memory_cache_release (&cache_cache,cache);
398 } 357 }
399 return MEMORY_RETURN_FAILURE; 358 return MEMORY_RETURN_FAILURE;
@@ -413,33 +372,33 @@ void *memory_cache_allocate (struct memory_cache *cache)
413ok: struct memory_free_block *block = slab->free; 372ok: struct memory_free_block *block = slab->free;
414 slab->free = block->link; 373 slab->free = block->link;
415 if (--slab->left == 0) 374 if (--slab->left == 0)
416 move_slab (&cache->free,&cache->used); 375 __memory_move_slab (&cache->free,&cache->used);
417 return block; 376 return block;
418 } 377 }
419 } 378 }
420 if (cache->reap) 379 if (cache->reap)
421 { 380 {
422 slab = move_slab (&cache->reap,&cache->free); 381 slab = __memory_move_slab (&cache->reap,&cache->free);
423 cache_tree = move_cache (cache_tree,cache,-1); 382 cache_tree = __memory_move_cache (cache_tree,cache,-1);
424 goto ok; 383 goto ok;
425 } 384 }
426 } 385 }
427 while (grow_cache (cache)); 386 while (__memory_grow_cache (cache));
428 } 387 }
429 return MEMORY_RETURN_FAILURE; 388 return MEMORY_RETURN_FAILURE;
430 } 389 }
431 390
432int memory_cache_release (struct memory_cache *cache,void *address) 391int memory_cache_release (struct memory_cache *cache,void *address)
433 { 392 {
434 struct memory_slab *slab = get_slab (cache,address); 393 struct memory_slab *slab = __memory_get_slab (cache,address);
435 ((struct memory_free_block *)address)->link = slab->free; 394 ((struct memory_free_block *)address)->link = slab->free;
436 slab->free = (struct memory_free_block *)address; 395 slab->free = (struct memory_free_block *)address;
437 if (slab->left++ == 0) 396 if (slab->left++ == 0)
438 move_slab (&cache->used,&cache->free); 397 __memory_move_slab (&cache->used,&cache->free);
439 else if (slab->left == cache->blocks_per_slab) 398 else if (slab->left == cache->blocks_per_slab)
440 { 399 {
441 move_slab (&cache->free,&cache->reap); 400 __memory_move_slab (&cache->free,&cache->reap);
442 cache_tree = move_cache (cache_tree,cache,+1); 401 cache_tree = __memory_move_cache (cache_tree,cache,+1);
443 } 402 }
444 return MEMORY_RETURN_SUCCESS; 403 return MEMORY_RETURN_SUCCESS;
445 } 404 }
diff --git a/firmware/test/memory/memory-slab.h b/firmware/test/memory/memory-slab.h
new file mode 100644
index 0000000000..f58897c3ec
--- /dev/null
+++ b/firmware/test/memory/memory-slab.h
@@ -0,0 +1,62 @@
1/***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id:
9 *
10 * Copyright (C) 2002 by Alan Korr
11 *
12 * All files in this archive are subject to the GNU General Public License.
13 * See the file COPYING in the source tree root for full license agreement.
14 *
15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
16 * KIND, either express or implied.
17 *
18 ****************************************************************************/
19#ifndef __LIBRARY_MEMORY_SLAB_H__
20#define __LIBRARY_MEMORY_SLAB_H__
21
22struct memory_free_block
23 {
24 struct memory_free_block
25 *link;
26 };
27
28struct memory_slab
29 {
30 struct memory_slab
31 *less,*more;
32 unsigned int // left == number of free blocks left
33 left;
34 struct memory_free_block
35 *free;
36 };
37
38struct memory_cache
39 {
40 struct memory_cache
41 *less,*more,*same;
42 unsigned int
43 left; // number of free slabs
44 struct memory_slab
45 *used;
46 struct memory_slab
47 *free;
48 struct memory_slab
49 *reap;
50 unsigned int
51 size,original_size;
52 unsigned int
53 page_size;
54 unsigned int
55 blocks_per_slab;
56 int
57 page_order;
58 unsigned int
59 flags;
60 };
61
62#endif
diff --git a/firmware/test/memory/memory-slab.txt b/firmware/test/memory/memory-slab.txt
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/firmware/test/memory/memory-slab.txt
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-24 11:13:19 +0000