diff options
| -rw-r--r-- | firmware/test/alkorr/memory.c | 844 | ||||
| -rw-r--r-- | firmware/test/alkorr/memory.h | 113 |
2 files changed, 0 insertions, 957 deletions
diff --git a/firmware/test/alkorr/memory.c b/firmware/test/alkorr/memory.c deleted file mode 100644 index b58902f4d5..0000000000 --- a/firmware/test/alkorr/memory.c +++ /dev/null @@ -1,844 +0,0 @@ -/* -////////////////////////////////////////////////////////////////////////////////// -// __________ __ ___. // -// Open \______ \ ____ ____ | | _\_ |__ _______ ___ // -// Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / // -// Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < // -// Software |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ // -// \/ \/ \/ \/ \/ // -////////////////////////////////////////////////////////////////////////////////// -// -// $Id$ -// -///////////////////////////////////// -// Copyright (C) 2002 by Alan Korr // -///////////////////////////////////// -// -// All files in this archive are subject to the GNU General Public License. -// See the file COPYING in the source tree root for full license agreement. -// -// This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, -// either express or implied. -// -////////////////////////////////////////////////////////////////////////////////// -*/ - -#include "memory.h" - -#define MEMORY_PAGE_USE_SPLAY_TREE - -/* -///////////////////////////////////////////////////////////////////// -// MEMORY PAGE // -///////////////// -// -// -*/ - -struct __memory_free_page -{ - struct __memory_free_page *less,*more; - char reserved[MEMORY_PAGE_MINIMAL_SIZE - 2*sizeof (struct memory_free_page *)]; -}; - -#define LESS -1 -#define MORE +1 - -extern struct __memory_free_page __memory_free_page[MEMORY_TOTAL_PAGES] asm("dram"); - -char __memory_free_page_order[MEMORY_TOTAL_PAGES]; -struct __memory_free_page *__memory_free_page_bin[MEMORY_TOTAL_ORDERS]; - -static inline unsigned int __memory_get_size (int order) -/* - SH1 has very poor shift instructions (only <<1,>>1,<<2,>>2,<<8, - >>8,<<16 and >>16), so we should use a lookup table to speedup. -*/ -{ - return - ( - (unsigned short [MEMORY_TOTAL_ORDERS]) - { - 1<<MEMORY_PAGE_MINIMAL_ORDER, - 2<<MEMORY_PAGE_MINIMAL_ORDER, - 4<<MEMORY_PAGE_MINIMAL_ORDER, - 8<<MEMORY_PAGE_MINIMAL_ORDER, - 16<<MEMORY_PAGE_MINIMAL_ORDER, - 32<<MEMORY_PAGE_MINIMAL_ORDER, - 64<<MEMORY_PAGE_MINIMAL_ORDER, - 128<<MEMORY_PAGE_MINIMAL_ORDER, - 256<<MEMORY_PAGE_MINIMAL_ORDER, - 512<<MEMORY_PAGE_MINIMAL_ORDER, - 1024<<MEMORY_PAGE_MINIMAL_ORDER, - 2048<<MEMORY_PAGE_MINIMAL_ORDER, - 4096<<MEMORY_PAGE_MINIMAL_ORDER - } - )[order]; -} - -static inline struct __memory_free_page *__memory_get_neighbour (struct __memory_free_page *node,unsigned int size) -{ - return ((struct __memory_free_page *)((unsigned)node ^ size)); -} - -static inline int __memory_get_order (struct __memory_free_page *node) -{ - return __memory_free_page_order[node - __memory_free_page]; -} - -static inline void __memory_set_order (struct __memory_free_page *node,int order) -{ - __memory_free_page_order[node - __memory_free_page] = order; -} - -#ifdef MEMORY_PAGE_USE_SPLAY_TREE - -static struct __memory_free_page *__memory_splay_page (struct __memory_free_page *root,struct __memory_free_page *node) -{ - struct __memory_free_page *down; - struct __memory_free_page *less; - struct __memory_free_page *more; - struct __memory_free_page *head[2]; - ((struct __memory_free_page *)head)->less = - ((struct __memory_free_page *)head)->more = 0; - less = - more = &head; - while (1) - { - if (node < root) - { - if ((down = root->less)) - { - if (node < down) - { - root->less = down->more; - down->more = root; - root = down; - if (!root->less) - break; - } - more->less = root; - more = root; - root = root->less; - continue; - } - break; - } - if (root < node) - { - if ((down = root->more)) - { - if (root < node) - { - root->more = down->less; - down->less = root; - root = down; - if (!root->more) - break; - } - less->more = root; - less = root; - root = root->more; - continue; - } - } - break; - } - less->more = root->less; - more->less = root->more; - root->less = ((struct __memory_free_page *)head)->more; - root->more = ((struct __memory_free_page *)head)->less; - return root; -} - -static inline void __memory_insert_page (int order,struct __memory_free_page *node) -{ - struct __memory_free_page *root = __memory_free_page_bin[order]; - if (!root) - { - node->less = - node->more = 0; - } - else if (node < (root = __memory_splay_page (root,node))) - { - node->less = root->less; - node->more = root; - root->less = 0; - } - else if (node > root) - { - node->less = root; - node->more = root->more; - node->more = 0; - } - __memory_free_page_bin[order] = node; - __memory_set_order (node,order); - return; - } - -static inline struct __memory_free_page *__memory_pop_page (int order,int want) -{ - struct __memory_free_page *root = __memory_free_page_bin[order]; - if (root) - { - root = __memory_splay_page (root,__memory_free_page); - __memory_free_page_bin[order] = root->more; - __memory_set_order (root,~want); - } - return root; -} - -static inline void __memory_remove_page (int order,struct __memory_free_page *node) -{ - struct __memory_free_page *root = __memory_free_page_bin[order]; - root = __memory_splay_page (root,node); - if (root->less) - { - node = __memory_splay_page (root->less,node); - node->more = root->more; - } - else - node = root->more; - __memory_free_page_bin[order] = node; -} - -#else - -static inline void __memory_insert_page (int order,struct __memory_free_page *node) -{ - struct __memory_free_page *head = __memory_free_page_bin[order]; - node->less = 0; - node->more = head; - if (head) - head->less = node; - __memory_free_page_bin[order] = node; - __memory_set_order (node,order); -} - -static inline struct __memory_free_page *pop_page (int order,int want) -{ - struct __memory_free_page *node = __memory_free_page_bin[order]; - if (node) - { - __memory_free_page_bin[order] = node->more; - if (node->more) - node->more->less = 0; - __memory_set_order (node,~want); - } - return node; -} - -static inline void __memory_remove_page (int order,struct __memory_free_page *node) -{ - if (node->less) - node->less->more = node->more; - else - __memory_free_page_bin[order] = node->more; - if (node->more) - node->more->less = node->less; -} - -#endif - -static inline void __memory_push_page (int order,struct __memory_free_page *node) -{ - node->less = 0; - node->more = 0; - __memory_free_page_bin[order] = node; - __memory_set_order (node,order); -} - -static struct __memory_free_page *__memory_allocate_page (unsigned int size,int order) -{ - struct __memory_free_page *node; - int min = order; - while ((unsigned)order <= (MEMORY_TOTAL_ORDERS - 1)) - /* order is valid ? */ - { - if (!(node = __memory_pop_page (order,min))) - /* no free page of this order ? */ - { - ++order; size <<= 1; - continue; - } - while (order > min) - /* split our larger page in smaller pages */ - { - --order; size >>= 1; - __memory_push_page (order,(struct __memory_free_page *)((unsigned int)node + size)); - } - return node; - } - return MEMORY_RETURN_FAILURE; -} - -static inline void __memory_release_page (struct __memory_free_page *node,unsigned int size,int order) -{ - struct __memory_free_page *neighbour; - while ((order <= (MEMORY_TOTAL_ORDERS - 1)) && - ((neighbour = __memory_get_neighbour (node,size)), - (__memory_get_order (neighbour) == order))) - /* merge our released page with its contiguous page into a larger page */ - { - __memory_remove_page (order,neighbour); - ++order; size <<= 1; - if (neighbour < node) - node = neighbour; - } - __memory_insert_page (order,node); -} - -void *memory_page_allocate (int order) -{ - if ((unsigned)order < MEMORY_TOTAL_ORDERS) - return MEMORY_RETURN_FAILURE; - return __memory_allocate_page (__memory_get_size (order),order); -} - -int memory_page_release (void *address) -{ - struct __memory_free_page *node = (struct __memory_free_page *)address; - int order = ~__memory_get_order (node); - if ((unsigned)order < MEMORY_TOTAL_ORDERS) - return MEMORY_RETURN_FAILURE; - __memory_release_page (node,__memory_get_size (order),order); - return MEMORY_RETURN_SUCCESS; -} - -void memory_page_release_range (unsigned int start,unsigned int end) -{ - start = ((start + MEMORY_PAGE_MINIMAL_SIZE - 1) & -MEMORY_PAGE_MINIMAL_SIZE; - end = ((end ) & -MEMORY_PAGE_MINIMAL_SIZE; - /* release pages between _start_ and _end_ (each must be 512 bytes long) */ - for (; start < end; start += MEMORY_PAGE_MINIMAL_SIZE) - memory_page_release (start); -} - -static inline void __memory_page_setup (void) -{ -#if 0 - memory_set (__memory_free_page_bin,0,MEMORY_TOTAL_ORDERS *sizeof (struct memory_free_page *)); -#endif - /* all pages are marked as used (no free page) */ - memory_set (__memory_free_page_order,~0,MEMORY_TOTAL_PAGES); -} - -/* -// -// -///////////////////////////////////////////////////////////////////// - -///////////////////////////////////////////////////////////////////// -// MEMORY CACHE // -////////////////// -// -// -*/ - -#if 0 - - -#define MEMORY_MAX_PAGE_ORDER_PER_SLAB (5) -#define MEMORY_MAX_PAGE_SIZE_PER_SLAB (MEMORY_PAGE_MINIMAL_SIZE << MEMORY_MAX_PAGE_ORDER_PER_SLAB) -#define MEMORY_MIN_BLOCKS_PER_SLAB (4) - -struct __memory_free_block -{ - struct __memory_free_block *link; -}; - -struct __memory_slab -{ - struct __memory_slab *less,*more; - unsigned int free_blocks_left; - struct __memory_free_block *free_block_list; - }; - -#define WITH_NO_FREE_BLOCK 0 -#define WITH_SOME_FREE_BLOCKS 1 -#define WITH_ONLY_FREE_BLOCKS 2 - -struct memory_cache -{ - struct memory_cache *less; - struct memory_cache *more; - struct memory_cache *prev; - struct memory_cache *next; - struct __memory_slab *slab_list[3]; - unsigned int page_size; - unsigned int free_slabs_left; - unsigned short size; - unsigned short original_size; - int page_order; - unsigned int blocks_per_slab; - struct __memory_slab cache_slab; /* only used for __memory_cache_cache ! */ -}; - -static inline struct __memory_slab *__memory_push_slab (struct __memory_slab *head,struct __memory_slab *node) -{ - node->less = head; - if (head) - { - node->more = head->more; - head->more = node; - } - else - node->more = 0; - return node; -} - -static inline struct __memory_slab *__memory_pop_slab (struct __memory_slab *head,struct __memory_slab *node) -{ - if (head) - head->more = node->more; - return node->more; -} - -static inline struct __memory_slab *__memory_move_slab (struct memory_cache *cache,int from,int to) -{ - struct __memory_slab *head = cache->slab_list[from]; - cache->slab_list[from] = head->more; - if (head->more) - head->more->less = 0; - head->more = cache->slab_list[to]; - if (head->more) - head->more->prev = head; - cache->slab_list[to] = head; - return head; -} - -static struct memory_cache *__memory_cache_tree; -static struct memory_cache *__memory_cache_cache; - -static inline int __memory_get_order (unsigned size) -{ - int order = 0; - size = (size + MEMORY_PAGE_MINIMAL_SIZE - 1) & -MEMORY_PAGE_MINIMAL_SIZE; - while (size > MEMORY_PAGE_MINIMAL_SIZE) - { - ++order; size <<= 1; - } - return order; -} - -static inline struct __memory_slab *__memory_get_slab (struct memory_cache *cache,void *address) -{ - return (struct __memory_slab *)((((unsigned)address + cache->page_size) & -cache->page_size) - sizeof (struct __memory_slab)); -} - -static struct memory_cache *__memory_splay_cache (struct memory_cache *root,unsigned int left) -{ - struct memory_cache *down; - struct memory_cache *less; - struct memory_cache *more; - struct memory_cache *head[2]; - ((struct memory_cache *)head->less = - ((struct memory_cache *)head->more = 0; - less = - more = &head; - while (1) - { - if (left < root->free_slabs_left) - { - if ((down = root->less)) - { - if (left < down->free_slabs_left) - { - root->less = down->more; - down->more = root; - root = down; - if (!root->less) - break; - } - more->less = root; - more = root; - root = root->less; - continue; - } - break; - } - if (root->free_slabs_left < left) - { - if ((down = root->more)) - { - if (root->free_slabs_left < left) - { - root->more = down->less; - down->less = root; - root = down; - if (!root->more) - break; - } - less->more = root; - less = root; - root = root->more; - continue; - } - } - break; - } - less->more = root->less; - more->less = root->more; - root->less = ((struct memory_cache *)head->more; - root->more = ((struct memory_cache *)head->less; - return root; -} - -static inline struct memory_cache *__memory_insert_cache (struct memory_cache *root,struct memory_cache *node) -{ - node->less = - node->more = - node->prev = 0; - node->next = 0; - if (root) - { - if (node->free_slabs_left == ((root = __memory_splay_cache (root,node))->free_slabs_left)) - { - node->less = root.less; - node->more = root.more; - node->next = root; - root->prev = node; - } - else if (node < root) - { - node->less = root->less; - node->more = root; - root->less = 0; - } - else - { - node->less = root; - node->more = root->more; - node->more = 0; - } - } - return node; -} - -static inline struct memory_cache *__memory_remove_cache (struct memory_cache *root,struct memory_cache *node) -{ - if (root) - { - if (node->prev) - { - node->prev->next = node->next; - if (node->next) - node->next->prev = node->prev; - return node->prev; - } - root = __memory_splay_cache (root,node); - if (root->less) - { - node = __memory_splay_page (root->less,node); - node->more = root->more; - } - else - node = root->more; - } - return node; -} - -static inline struct memory_cache *__memory_move_cache (struct memory_cache *root,struct memory_cache *node,int delta) -{ - if ((root = __memory_remove_cache (root,node))) - { - node->free_slabs_left += delta; - root = __memory_insert_cache (root,node); - } - return root; -} - -static struct __memory_slab *__memory_grow_cache (struct memory_cache *cache) -{ - struct __memory_slab *slab; - unsigned int page; - if (cache) - { - page = (unsigned int)memory_allocate_page (cache->page_order); - if (page) - { - struct __memory_free_block *block,**link; - slab = (struct __memory_slab *)(page + cache->page_size - sizeof (struct __memory_slab)); - slab->free_blocks_left = 0; - link = &slab->free_block_list; - for ((unsigned int)block = page; - (unsigned int)block + cache->size < (unsigned int)slab; - (unsigned int)block += cache->size) - { - *link = block; - link = &block->link; - ++slab->free_blocks_left; - } - *link = 0; - cache->blocks_per_slab = slab->free_blocks_left; - cache->slab_list[WITH_ONLY_FREE_BLOCKS] = - __memory_push_slab (cache->slab_list[WITH_ONLY_FREE_BLOCKS],slab); - __memory_cache_tree = __memory_move_cache (__memory_cache_tree,cache,+1); - return slab; - } - } - return MEMORY_RETURN_FAILURE; -} - -static int __memory_shrink_cache (struct memory_cache *cache,int all,int move) -{ - struct __memory_slab *slab; - unsigned int slabs = 0; - if (cache) - { - while ((slab = cache->slab_list[WITH_ONLY_FREE_BLOCKS])) - { - ++slabs; - cache->slab_list[WITH_ONLY_FREE_BLOCKS] = - __memory_pop_slab (cache->slab_list[WITH_ONLY_FREE_BLOCKS],slab); - memory_release_page ((void *)((unsigned int)slab & -cache->page_size)); - if (all) - continue; - if (move) - __memory_cache_tree = __memory_move_cache (__memory_cache_tree,cache,-slabs); - return MEMORY_RETURN_SUCCESS; - } - } - return MEMORY_RETURN_FAILURE; -} - -struct memory_cache *memory_cache_create (unsigned int size,int align) -{ - struct memory_cache *cache; - unsigned int waste = 0,blocks_per_page; - int page_order; - unsigned int page_size; - unsigned int original_size = size; - - size = (align > 4) ? ((size + align - 1) & -align) : ((size + sizeof (int) - 1) & -sizeof (int)); - - if ((size >= MEMORY_MAX_PAGE_SIZE_PER_SLAB) || - (!(cache = memory_cache_allocate (__memory_cache_cache))) - return MEMORY_RETURN_FAILURE; - - cache->free_slabs_left = 0; - - cache->slab_list[ WITH_NO_FREE_BLOCK ] = - cache->slab_list[WITH_SOME_FREE_BLOCKS] = - cache->slab_list[WITH_ONLY_FREE_BLOCKS] = 0; - - cache->original_size = original_size; - cache->size = size; - - page_size = 0; - page_order = MEMORY_PAGE_MINIMAL_SIZE; - - for (;; ++order,(page_size <<= 1)) - { - if (page_order >= MEMORY_MAX_PAGE_ORDER_PER_SLAB) - break; - - waste = page_size; - waste -= sizeof (struct __memory_slab); - - blocks_per_slab = waste / size; - waste -= block_per_slab * size; - - if (blocks_per_slab < MEMORY_MIN_BLOCKS_PER_SLAB) - { - ++page_order; page_size <<= 1; - continue; - } - - /* below 5% of lost space is correct */ - if ((waste << 16) / page_size) < 3276) - break; - ++page_order; page_size <<= 1; - } - - cache->page_size = page_size; - cache->page_order = page_order; - - cache_tree = __memory_insert_cache (cache_tree,cache); - - return cache; -} - -int memory_cache_destroy (struct memory_cache *cache) -{ - /* this function shouldn't be called if there are still used blocks */ - if (cache && !cache->slab_list[WITH_NO_FREE_BLOCK] && !cache->slab_list[WITH_SOME_FREE_BLOCKS]) - { - __memory_cache_tree = __memory_remove_cache (__memory_cache_tree,cache); - if (__memory_shrink_cache (cache,1 /* release all free slabs */,0 /* don't move in cache_tree */)) - return memory_cache_release (__memory_cache_cache,cache); - } - return MEMORY_RETURN_FAILURE; -} - - -void *memory_cache_allocate (struct memory_cache *cache) -{ - if (cache) - { - do - { - struct __memory_slab *slab; - if ((slab = cache->slab_list[WITH_SOME_FREE_BLOCKS])) - { - if (slab->free_blocks_left > 0) - { -ok: struct __memory_free_block *block = slab->free_block_list; - slab->free_block_list = block->link; - if (--slab->free_blocks_left == 0) - __memory_move_slab (WITH_SOME_FREE_BLOCKS,WITH_NO_FREE_BLOCK); - return block; - } - } - if (cache->slab_list[WITH_FULL_FREE_BLOCKS]) - { - slab = __memory_move_slab (WITH_ONLY_FREE_BLOCKS,WITH_SOME_FREE_BLOCKS); - __memory_cache_tree = __memory_move_cache (__memory_cache_tree,cache,-1); - goto ok; - } - } - while (__memory_grow_cache (cache)); - } - return MEMORY_RETURN_FAILURE; -} - -int memory_cache_release (struct memory_cache *cache,void *address) - { - struct __memory_slab *slab = __memory_get_slab (cache,address); - ((struct __memory_free_block *)address)->link = slab->free_block_list; - slab->free_block_list = (struct __memory_free_block *)address; - if (slab->free_blocks_left++ == 0) - __memory_move_slab (WITH_NO_FREE_BLOCK,WITH_SOME_FREE_BLOCKS); - else if (slab->free_blocks_left == cache->blocks_per_slab) - { - __memory_move_slab (WITH_SOME_FREE_BLOCKS,WITH_ONLY_FREE_BLOCKS); - __memory_cache_tree = __memory_move_cache (__memory_cache_tree,cache,+1); - } - return MEMORY_RETURN_SUCCESS; - } - -static inline void __memory_cache_setup (void) -{ - struct memory_cache *cache; - struct __memory_slab *slab; - struct __memory_free_block *block,**link; - - cache = (struct memory_cache *)__memory_free_page; - cache->original_size = sizeof (*cache); - cache->size = sizeof (*cache); - cache->page_size = MEMORY_PAGE_MINIMAL_SIZE; - cache->page_order = MEMORY_PAGE_MINIMAL_ORDER; - cache->free_slabs_left = 0; - - slab = __memory_get_slab (cache,(void *)cache); - - cache->slab_list[ WITH_NO_FREE_BLOCK ] = - cache->slab_list[WITH_SOME_FREE_BLOCKS] = - cache->slab_list[WITH_ONLY_FREE_BLOCKS] = 0; - - link = &slab->free_block_list; - for ((unsigned int)block = (unsigned int)cache; - (unsigned int)block + sizeof (*cache) < (unsigned int)slab; - (unsigned int)block += sizeof (*cache)) - { - *link = block; - link = &block->link; - ++slab->free_blocks_left; - } - *link = 0; - cache->blocks_per_slab = slab->free_blocks_left + 1; - cache->slab_list[WITH_SOME_FREE_BLOCKS] = - __memory_push_slab (cache->slab_list[WITH_SOME_FREE_BLOCKS],slab); - - __memory_cache_tree = __memory_insert_cache (__memory_cache_tree,cache); -} - -/* -// -// -///////////////////////////////////////////////////////////////////// - -///////////////////////////////////////////////////////////////////// -// MEMORY BLOCK // -////////////////// -// -// -*/ - -static struct memory_cache *__memory_free_block_cache[MEMORY_PAGE_MINIMAL_ORDER - 2]; - -static inline void *__memory_allocate_block (int order) -{ - struct memory_cache *cache = __memory_free_block_cache[order - 2]; - do - { - if (cache) - return memory_cache_allocate (cache); - } - while ((__memory_free_block_cache[order] = cache = memory_create_cache (size,0,0))); - return MEMORY_RETURN_FAILURE; -} - -static inline int __memory_release_block (int order,void *address) -{ - struct memory_cache *cache = __memory_free_block_cache[order - 2]; - if (cache) - return memory_cache_release (cache,address); - return MEMORY_RETURN_FAILURE; -} - -void *memory_block_allocate (int order) -{ - if (order < 2) /* minimal size is 4 bytes */ - order = 2; - if (order < MEMORY_PAGE_MINIMAL_ORDER) - return __memory_allocate_block (order); - return MEMORY_RETURN_FAILURE; -} - -int memory_block_release (int order,void *address) -{ - if (order < 2) /* minimal size is 4 bytes */ - order = 2; - if (order < MEMORY_PAGE_MINIMAL_ORDER) - return __memory_release_block (order,address); - return MEMORY_RETURN_FAILURE; -} - -/* -// -// -///////////////////////////////////////////////////////////////////// - -///////////////////////////////////////////////////////////////////// -// MEMORY // -//////////// -// -// -*/ - -#endif - -#if 0 -/* NOT VERY OPTIMIZED AT ALL BUT WE WILL DO IT WHEN PRIORITY COMES */ -void memory_copy (void *target,void const *source,unsigned int count) -{ - while (count--) - *((char *)target)++ = *((char const *)source)++; -} - -/* NOT VERY OPTIMIZED AT ALL BUT WE WILL DO IT WHEN PRIORITY COMES */ -void memory_set (void *target,int byte,unsigned int count) -{ - while (count--) - *((char *)target)++ = (char)byte; -} -#endif - -void memory_setup (void) -{ - __memory_page_setup (); -#if 0 - __memory_cache_setup (); -#endif -} diff --git a/firmware/test/alkorr/memory.h b/firmware/test/alkorr/memory.h deleted file mode 100644 index 37ec4c8c14..0000000000 --- a/firmware/test/alkorr/memory.h +++ /dev/null @@ -1,113 +0,0 @@ -/* -////////////////////////////////////////////////////////////////////////////////// -// __________ __ ___. // -// Open \______ \ ____ ____ | | _\_ |__ _______ ___ // -// Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / // -// Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < // -// Software |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ // -// \/ \/ \/ \/ \/ // -////////////////////////////////////////////////////////////////////////////////// -// -// $Id$ -// -///////////////////////////////////// -// Copyright (C) 2002 by Alan Korr // -///////////////////////////////////// -// -// All files in this archive are subject to the GNU General Public License. -// See the file COPYING in the source tree root for full license agreement. -// -// This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, -// either express or implied. -// -////////////////////////////////////////////////////////////////////////////////// -*/ - -#ifndef __MEMORY_H__ -#define __MEMORY_H__ - -enum -{ - MEMORY_RETURN_SUCCESS = 1, - MEMORY_RETURN_FAILURE = 0 -}; - -/* -///////////////////////////////////////////////////////////////////// -// MEMORY PAGE // -///////////////// -// -// -*/ - -#define MEMORY_PAGE_MINIMAL_ORDER ( 9) /* 512 bytes by default */ -#define MEMORY_PAGE_MAXIMAL_ORDER (21) /* 2 Mbytes by default */ -#define MEMORY_PAGE_MINIMAL_SIZE (1 << MEMORY_PAGE_MINIMAL_ORDER) -#define MEMORY_PAGE_MAXIMAL_SIZE (1 << MEMORY_PAGE_MAXIMAL_ORDER) - -#define MEMORY_TOTAL_PAGES (MEMORY_PAGE_MAXIMAL_SIZE / MEMORY_PAGE_MINIMAL_SIZE) -#define MEMORY_TOTAL_ORDERS (1 + MEMORY_PAGE_MAXIMAL_ORDER - MEMORY_PAGE_MINIMAL_ORDER) - -extern void *memory_page_allocate (int order); -extern int memory_page_release (void *address); -extern void memory_page_release_range (unsigned int start,unsigned int end); - -/* -// -///////////////////////////////////////////////////////////////////// - -///////////////////////////////////////////////////////////////////// -// MEMORY CACHE // -////////////////// -// -// -*/ - -struct memory_cache; - -extern struct memory_cache *memory_cache_create (unsigned int size,int align); -extern int memory_cache_destroy (struct memory_cache *cache); -extern void *memory_cache_allocate (struct memory_cache *cache); -extern int memory_cache_release (struct memory_cache *cache,void *address); - -/* -// -// -///////////////////////////////////////////////////////////////////// - -///////////////////////////////////////////////////////////////////// -// MEMORY BLOCK // -////////////////// -// -// -*/ - -extern void *memory_block_allocate (int order); -extern int memory_block_release (int order,void *address); - -/* -// -// -///////////////////////////////////////////////////////////////////// - -///////////////////////////////////////////////////////////////////// -// MEMORY // -//////////// -// -// -*/ - -#define MEMORY_TOTAL_BYTES (MEMORY_PAGE_MAXIMAL_SIZE) - -extern void memory_copy (void *target,void const *source,unsigned int count); -extern void memory_set (void *target,int byte,unsigned int count); - -extern void memory_setup (void); - -/* -// -// -///////////////////////////////////////////////////////////////////// -*/ - -#endif |