diff options
author | Alan Korr <alkorr@rockbox.org> | 2002-04-17 15:00:28 +0000 |
---|---|---|
committer | Alan Korr <alkorr@rockbox.org> | 2002-04-17 15:00:28 +0000 |
commit | c25510f944553681d7898e5b9d8e132f6e3c431b (patch) | |
tree | 5665e58628f634374dada65da74b5b854a6e70b4 /firmware | |
parent | 454be44f8d0c7cc1a6f77c0e694c8a32f2cd6099 (diff) | |
download | rockbox-c25510f944553681d7898e5b9d8e132f6e3c431b.tar.gz rockbox-c25510f944553681d7898e5b9d8e132f6e3c431b.zip |
Now memory-page and memory-misc compile fine (others are in stage-development)
Conventions :
* Public headers :
memory.h,config.h,defines.h,inlines.h,types.h,functions.h
* Private headers :
memory-page.h,memory-slab.h (here you can find
prototypes functions or structures we want to share
only between memory-page.c, memory-slab.c,
memory-block.c, memory-misc.c).
* Public or private codes in :
memory-page.c,memory-slab.c,memory-block.c,memory-misc.c
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@126 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'firmware')
-rw-r--r-- | firmware/test/memory/memory-block.c | 25 | ||||
-rw-r--r-- | firmware/test/memory/memory-block.txt | 0 | ||||
-rw-r--r-- | firmware/test/memory/memory-misc.c | 14 | ||||
-rw-r--r-- | firmware/test/memory/memory-misc.txt | 0 | ||||
-rw-r--r-- | firmware/test/memory/memory-page.c | 209 | ||||
-rw-r--r-- | firmware/test/memory/memory-page.h | 59 | ||||
-rw-r--r-- | firmware/test/memory/memory-page.txt | 0 | ||||
-rw-r--r-- | firmware/test/memory/memory-slab.c | 111 | ||||
-rw-r--r-- | firmware/test/memory/memory-slab.h | 62 | ||||
-rw-r--r-- | firmware/test/memory/memory-slab.txt | 0 |
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 | ||
25 | static struct memory_cache *free_block_cache[MEMORY_PAGE_MINIMAL_ORDER - 2]; | 24 | static 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 | ||
35 | static inline void *allocate_small_block (int order) | 34 | static 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 | ||
58 | static inline int release_block (int order,void *address) | 57 | static 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 */ |
22 | void memory_copy (void *target,void const *source,unsigned int count) | 26 | void memory_copy (void *target,void const *source,unsigned int count) |
@@ -35,10 +39,10 @@ void memory_set (void *target,int byte,unsigned int count) | |||
35 | void memory_setup (void) | 39 | void 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 | |||
25 | struct 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 | ||
38 | struct memory_free_page free_page[MEMORY_TOTAL_PAGES]; | ||
39 | |||
40 | static 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 |
46 | static inline unsigned int get_size (int order) | 28 | static 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) |
52 | static inline struct memory_free_page *get_neighbour (struct memory_free_page *node,unsigned int size) | 34 | static 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 | ||
59 | extern struct memory_free_page free_page[MEMORY_TOTAL_PAGES] asm("dram"); | ||
60 | |||
61 | static 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. |
70 | static inline unsigned int get_size (int order) | 43 | static 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 | ||
75 | static inline struct memory_free_page *get_neighbour (struct memory_free_page *node,unsigned int size) | 64 | static 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 | ||
82 | static char free_page_order[MEMORY_TOTAL_PAGES]; | 71 | static inline int __memory_get_order (struct memory_free_page *node) |
83 | static struct memory_free_page *free_page_bin[MEMORY_TOTAL_ORDERS]; | ||
84 | |||
85 | static 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 | } |
89 | static inline void set_order (struct memory_free_page *node,int order) | 75 | static 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> | 82 | static struct memory_free_page *__memory_splay_page (struct memory_free_page *root,struct memory_free_page *node) |
97 | |||
98 | static 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 | ||
156 | static inline void insert_page (int order,struct memory_free_page *node) | 140 | static 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 | ||
181 | static inline struct memory_free_page *pop_page (int order,int want) | 165 | static 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 | ||
193 | static inline void remove_page (int order,struct memory_free_page *node) | 177 | static 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 | ||
209 | static inline void insert_page (int order,struct memory_free_page *node) | 193 | static 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 | ||
220 | static inline struct memory_free_page *pop_page (int order,int want) | 204 | static 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 | ||
233 | static inline void remove_page (int order,struct memory_free_page *node) | 217 | static 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 | ||
245 | static inline void push_page (int order,struct memory_free_page *node) | 229 | static 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 | ||
253 | static struct memory_free_page *allocate_page (unsigned int size,int order) | 237 | static 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 | ||
277 | static inline void release_page (struct memory_free_page *node,unsigned int size,int order) | 261 | static 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 | ||
298 | void *memory_allocate_page (int order) | 282 | void *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) | |||
309 | int memory_release_page (void *address) | 293 | int 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 | ||
325 | static void dump_splay_node (struct memory_free_page *node,int level) | 309 | void __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 | ||
334 | static void dump_splay_tree (struct memory_free_page *root) | 318 | void __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 | ||
341 | void memory_spy_page (void *address) | 325 | void __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 | ||
355 | void memory_dump (int order) | 339 | void __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 | ||
371 | void memory_check (int order) | 355 | void __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 | |||
22 | struct 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 | |||
35 | struct memory_free_page __memory_free_page[MEMORY_TOTAL_PAGES]; | ||
36 | |||
37 | #else | ||
38 | |||
39 | extern struct memory_free_page __memory_free_page[MEMORY_TOTAL_PAGES] asm("dram"); | ||
40 | |||
41 | #endif | ||
42 | |||
43 | char __memory_free_page_order[MEMORY_TOTAL_PAGES]; | ||
44 | struct memory_free_page *__memory_free_page_bin[MEMORY_TOTAL_ORDERS]; | ||
45 | |||
46 | #ifdef TEST | ||
47 | # if MEMORY_PAGE_USE_SPLAY_TREE | ||
48 | |||
49 | void __memory_dump_splay_node (struct memory_free_page *node,int level); | ||
50 | void __memory_dump_splay_tree (struct memory_free_page *root); | ||
51 | |||
52 | # endif | ||
53 | |||
54 | void __memory_spy_page (void *address); | ||
55 | void __memory_dump (int order); | ||
56 | void __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 | |||
25 | struct 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 | ||
37 | struct memory_slab | 30 | static 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 | |||
47 | static 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 | ||
60 | static inline struct memory_slab *pop_slab (struct memory_slab *head,struct memory_slab *node) | 43 | static 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 | ||
67 | static inline struct memory_slab *move_slab (struct memory_slab **from,struct memory_slab **to) | 50 | static 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 | ||
90 | struct 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 | |||
114 | static struct memory_cache *cache_tree; | 73 | static struct memory_cache *cache_tree; |
115 | 74 | ||
116 | static inline int get_order (unsigned size) | 75 | static 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 | ||
127 | static inline struct memory_slab *get_slab (struct memory_cache *cache,void *address) | 86 | static 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 | ||
136 | static struct memory_cache *splay_cache (struct memory_cache *root,unsigned int left) | 95 | static 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 | ||
194 | static inline struct memory_cache *insert_cache (struct memory_cache *root,struct memory_cache *node) | 153 | static 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 | ||
224 | static inline struct memory_cache *remove_cache (struct memory_cache *root,struct memory_cache *node) | 183 | static 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 | ||
247 | static inline struct memory_cache *move_cache (struct memory_cache *root,struct memory_cache *node,int delta) | 206 | static 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 | ||
302 | static int shrink_cache (struct memory_cache *cache,int all,int move) | 261 | static 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 | ||
323 | int memory_shrink_cache (struct memory_cache *cache,int all) | 282 | int 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 | ||
328 | struct memory_cache *memory_create_cache (unsigned int size,int align,int flags) | 287 | struct 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) | |||
413 | ok: struct memory_free_block *block = slab->free; | 372 | ok: 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 | ||
432 | int memory_cache_release (struct memory_cache *cache,void *address) | 391 | int 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 | |||
22 | struct memory_free_block | ||
23 | { | ||
24 | struct memory_free_block | ||
25 | *link; | ||
26 | }; | ||
27 | |||
28 | struct 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 | |||
38 | struct 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 | |||