summaryrefslogtreecommitdiffstats
path: root/apps/plugins/pdbox
diff options
context:
space:
mode:
authorPeter D'Hoye <peter.dhoye@gmail.com>2009-07-23 21:37:35 +0000
committerPeter D'Hoye <peter.dhoye@gmail.com>2009-07-23 21:37:35 +0000
commit840cd1069292e3f29d18e57f2274ec1e979f858b (patch)
tree0ee1d43fa3863de53c99432dc32001e625703d1c /apps/plugins/pdbox
parent0d9b7ec73e71188632a4fd584dfd745aeb7571b3 (diff)
downloadrockbox-840cd1069292e3f29d18e57f2274ec1e979f858b.tar.gz
rockbox-840cd1069292e3f29d18e57f2274ec1e979f858b.tar.bz2
rockbox-840cd1069292e3f29d18e57f2274ec1e979f858b.zip
Another pdbox patch by Wincent Balin (FS #10416): switch to using TLSF as memory allocator. Probably the last patch I commit for him, next changes are for him :)
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@22017 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'apps/plugins/pdbox')
-rw-r--r--apps/plugins/pdbox/SOURCES10
-rw-r--r--apps/plugins/pdbox/TLSF-2.4.4/src/tlsf.c12
-rw-r--r--apps/plugins/pdbox/dbestfit-3.3/CHANGES12
-rw-r--r--apps/plugins/pdbox/dbestfit-3.3/FILES15
-rw-r--r--apps/plugins/pdbox/dbestfit-3.3/Makefile38
-rw-r--r--apps/plugins/pdbox/dbestfit-3.3/Malloc.c200
-rw-r--r--apps/plugins/pdbox/dbestfit-3.3/README21
-rw-r--r--apps/plugins/pdbox/dbestfit-3.3/bmalloc.c371
-rw-r--r--apps/plugins/pdbox/dbestfit-3.3/bmalloc.h5
-rw-r--r--apps/plugins/pdbox/dbestfit-3.3/bysize.c428
-rw-r--r--apps/plugins/pdbox/dbestfit-3.3/bysize.h4
-rw-r--r--apps/plugins/pdbox/dbestfit-3.3/dmalloc.c711
-rw-r--r--apps/plugins/pdbox/dbestfit-3.3/dmalloc.h12
-rw-r--r--apps/plugins/pdbox/dbestfit-3.3/dmytest.c138
-rw-r--r--apps/plugins/pdbox/dbestfit-3.3/malloc.man95
-rw-r--r--apps/plugins/pdbox/dbestfit-3.3/mytest.c69
-rw-r--r--apps/plugins/pdbox/dbestfit-3.3/thoughts170
-rw-r--r--apps/plugins/pdbox/pdbox-func.c29
-rw-r--r--apps/plugins/pdbox/pdbox.c93
-rw-r--r--apps/plugins/pdbox/pdbox.h45
-rw-r--r--apps/plugins/pdbox/pdbox.make2
21 files changed, 124 insertions, 2356 deletions
diff --git a/apps/plugins/pdbox/SOURCES b/apps/plugins/pdbox/SOURCES
index 9f54273877..04cff3c601 100644
--- a/apps/plugins/pdbox/SOURCES
+++ b/apps/plugins/pdbox/SOURCES
@@ -2,13 +2,13 @@ pdbox.c
pdbox-net.c
pdbox-func.c
-dbestfit-3.3/bmalloc.c
-dbestfit-3.3/bysize.c
-dbestfit-3.3/dmalloc.c
+TLSF-2.4.4/src/tlsf.c
+/*
+wfirstfit.c
+*/
PDa/src/s_audio_rockbox.c
-
PDa/src/g_canvas.c
PDa/src/g_graph.c
PDa/src/g_text.c
@@ -130,7 +130,7 @@ PDa/intern/vline~.c
PDa/intern/vsnapshot~.c
PDa/intern/wrap~.c
-PDa/extra/OSCroute.c
+/* PDa/extra/OSCroute.c */
PDa/extra/bandpass.c
/* PDa/extra/dumpOSC.c Does not compile, file handling stuff */
PDa/extra/equalizer.c
diff --git a/apps/plugins/pdbox/TLSF-2.4.4/src/tlsf.c b/apps/plugins/pdbox/TLSF-2.4.4/src/tlsf.c
index 47b461bac5..35bdc70290 100644
--- a/apps/plugins/pdbox/TLSF-2.4.4/src/tlsf.c
+++ b/apps/plugins/pdbox/TLSF-2.4.4/src/tlsf.c
@@ -164,8 +164,14 @@
#define PAGE_SIZE (getpagesize())
#endif
+#if defined(ROCKBOX) && defined(SIMULATOR) || !defined(ROCKBOX)
+int printf(char*, ...);
#define PRINT_MSG(fmt, args...) printf(fmt, ## args)
#define ERROR_MSG(fmt, args...) printf(fmt, ## args)
+#else
+#define PRINT_MSG(fmt, args...)
+#define ERROR_MSG(fmt, args...)
+#endif
typedef unsigned int u32_t; /* NOTE: Make sure that this type is 4 bytes long on your computer */
typedef unsigned char u8_t; /* NOTE: Make sure that this type is 1 byte on your computer */
@@ -567,6 +573,9 @@ size_t get_used_size(void *mem_pool)
#if TLSF_STATISTIC
return ((tlsf_t *) mem_pool)->used_size;
#else
+#ifdef ROCKBOX
+ (void) mem_pool;
+#endif /* ROCKBOX */
return 0;
#endif
}
@@ -578,6 +587,9 @@ size_t get_max_size(void *mem_pool)
#if TLSF_STATISTIC
return ((tlsf_t *) mem_pool)->max_size;
#else
+#ifdef ROCKBOX
+ (void) mem_pool;
+#endif /* ROCKBOX */
return 0;
#endif
}
diff --git a/apps/plugins/pdbox/dbestfit-3.3/CHANGES b/apps/plugins/pdbox/dbestfit-3.3/CHANGES
deleted file mode 100644
index 7f63d384fa..0000000000
--- a/apps/plugins/pdbox/dbestfit-3.3/CHANGES
+++ /dev/null
@@ -1,12 +0,0 @@
-Changes
-
-* (March 30 2005) Daniel
-
- Linus Nielsen Feltzing provided a patch that corrected several minor problems
- that prevented dbestfit from working good. Linus also tested and timed
- dbestfit for real in a target where he replaced the pSOS-provided memory
- subsystem.
-
-* 3.2
-
- Made eons ago, all older changes have been forgotten.
diff --git a/apps/plugins/pdbox/dbestfit-3.3/FILES b/apps/plugins/pdbox/dbestfit-3.3/FILES
deleted file mode 100644
index 6076c5fe20..0000000000
--- a/apps/plugins/pdbox/dbestfit-3.3/FILES
+++ /dev/null
@@ -1,15 +0,0 @@
-/bysize.c
-/bysize.h
-/bmalloc.c
-/bmalloc.h
-/dmalloc.c
-/dmalloc.h
-/FILES
-/README
-/Makefile
-/Malloc.c
-/mytest.c
-/dmytest.c
-/thoughts
-/malloc.man
-/CHANGES
diff --git a/apps/plugins/pdbox/dbestfit-3.3/Makefile b/apps/plugins/pdbox/dbestfit-3.3/Makefile
deleted file mode 100644
index fc1e7e68d9..0000000000
--- a/apps/plugins/pdbox/dbestfit-3.3/Makefile
+++ /dev/null
@@ -1,38 +0,0 @@
-
-OBJS1 = bmalloc.o bysize.o mytest.o
-TARGET1 = mytest
-
-OBJS2 = dmalloc.o bmalloc.o bysize.o Malloc.o
-TARGET2 = mtest
-
-OBJS3 = dmalloc.o bmalloc.o bysize.o dmytest.o
-TARGET3 = dmytest
-
-CFLAGS = -g -DUNIX -DBMALLOC -Wall -pedantic -DDEBUG
-CC = gcc
-
-all: $(TARGET1) $(TARGET2) $(TARGET3)
-
-$(TARGET1): $(OBJS1)
- $(CC) -g -o $(TARGET1) $(OBJS1)
-
-$(TARGET2): $(OBJS2)
- $(CC) -g -o $(TARGET2) $(OBJS2)
-
-$(TARGET3): $(OBJS3)
- $(CC) -g -o $(TARGET3) $(OBJS3)
-
-bmalloc.o: bmalloc.c
-dmalloc.o: dmalloc.c
-mytest.o: mytest.c
-dmytest.o: dmytest.c
-Malloc.o : Malloc.c
-bysize.o : bysize.c
-
-tgz:
- @(dir=`pwd`;name=`basename $$dir`;echo Creates $$name.tar.gz; cd .. ; \
- tar -cf $$name.tar `cat $$name/FILES | sed "s:^/:$$name/:g"` ; \
- gzip $$name.tar ; chmod a+r $$name.tar.gz ; mv $$name.tar.gz $$name/)
-
-clean:
- rm -f *.o *~ $(TARGET1) $(TARGET2) $(TARGET3)
diff --git a/apps/plugins/pdbox/dbestfit-3.3/Malloc.c b/apps/plugins/pdbox/dbestfit-3.3/Malloc.c
deleted file mode 100644
index 10b02c94ec..0000000000
--- a/apps/plugins/pdbox/dbestfit-3.3/Malloc.c
+++ /dev/null
@@ -1,200 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-/* Storleken på allokeringen bestäms genom att först slumpas en position i
-"size_table" ut, sedan slumpas en storlek mellan den postionen och nästa värde
-i tabellen. Genom att ha tabellen koncentrerad med låga värden, så skapas
-flest såna. Rutinen håller på tills minnet en allokeringen nekas. Den kommer
-aldrig att ha mer än MAXIMAL_MEMORY_TO_ALLOCATE allokerat samtidigt. Maximalt
-har den MAX_ALLOCATIONS allokeringar samtidigt.
-
-Statistiskt sätt så kommer efter ett tag MAX_ALLOCATIONS/2 allokeringar finnas
-samtidigt, med varje allokering i median med värdet av halva "size_table".
-
-När minnet är slut (malloc()=NULL), frågas användaren om han ska fortsätta.
-
-Med jämna mellanrum skrivs statisktik ut på skärmen. (DISPLAY_WHEN)
-
-För att stressa systemet med fler små allokeringar, så kan man öka
-MAX_ALLOCATIONS. AMOUNT_OF_MEMORY bör få den att slå i taket fortare om man
-minskar det.
-
-Ingen initiering görs av slumptalen, så allt är upprepbart (men plocka bort
-kommentaren på srand() och det löser sig.
-
-*/
-
-/*#undef BMALLOC*/
-
-#ifdef BMALLOC
-#include "dmalloc.h"
-
-#include "bmalloc.h"
-#endif
-
-#define MAX_ALLOCATIONS 100000
-#define AMOUNT_OF_MEMORY 180000 /* bytes */
-#define MAXIMAL_MEMORY_TO_ALLOCATE 100000 /* Sätt den här högre än
- AMOUNT_OF_MEMORY, och malloc() bör
- returnera NULL förr eller senare */
-
-#define DISPLAY_WHEN (123456) /* When to display statistic */
-
-#define min(a, b) (((a) < (b)) ? (a) : (b))
-#define BOOL char
-#define TRUE 1
-#define FALSE 0
-
-typedef struct {
- char *memory;
- long size;
- char filled_with;
- long table_position;
-} MallocStruct;
-
-/*
-Skapar en lista med MAX_ALLOCATIONS storlek där det slumpvis allokeras
-eller reallokeras i.
-*/
-
-MallocStruct my_mallocs[MAX_ALLOCATIONS];
-
-long size_table[]={5,8,10,11,12,14,16,18,20,26,33,50,70,90,120,150,200,400,800,1000,2000,4000,8000,10000,11000,12000,13000,14000,15000,16000,17000,18000};
-#define TABLESIZE ((sizeof(size_table)-1)/sizeof(long))
-long size_allocs[TABLESIZE];
-
-int main(void)
-{
- int i;
- long count=-1;
- long count_free=0, count_malloc=0, count_realloc=0;
- long total_memory=0;
- BOOL out_of_memory=FALSE;
- unsigned int seed = time( NULL );
-
-#ifdef BMALLOC
- void *thisisourheap;
- thisisourheap = (malloc)(AMOUNT_OF_MEMORY);
- if(!thisisourheap)
- return -1; /* can't get memory */
- add_pool(thisisourheap, AMOUNT_OF_MEMORY);
-#endif
-
- seed = 1109323906;
-
- srand( seed ); /* Initialize randomize */
-
- printf("seed: %d\n", seed);
-
- while (!out_of_memory) {
- long number=rand()%MAX_ALLOCATIONS;
- long size;
- long table_position=rand()%TABLESIZE;
- char fill_with=rand()&255;
-
- count++;
-
- size=rand()%(size_table[table_position+1]-size_table[table_position])+size_table[table_position];
-
-/* fprintf(stderr, "number %d size %d\n", number, size); */
-
- if (my_mallocs[number].size) { /* Om allokering redan finns på den här
- positionen, så reallokerar vi eller
- friar. */
- long old_size=my_mallocs[number].size;
- if (my_mallocs[number].size && fill_with<40) {
- free(my_mallocs[number].memory);
- total_memory -= my_mallocs[number].size;
- count_free++;
- size_allocs[my_mallocs[number].table_position]--;
- size=0;
- my_mallocs[number].size = 0;
- my_mallocs[number].memory = NULL;
- } else {
- /*
- * realloc() part
- *
- */
- char *temp;
-#if 0
- if(my_mallocs[number].size > size) {
- printf("*** %d is realloc()ed to %d\n",
- my_mallocs[number].size, size);
- }
-#endif
- if (total_memory-old_size+size>MAXIMAL_MEMORY_TO_ALLOCATE)
- goto output; /* for-loop */
- temp = (char *)realloc(my_mallocs[number].memory, size);
- if (!temp)
- out_of_memory=TRUE;
- else {
- my_mallocs[number].memory = temp;
-
- my_mallocs[number].size=size;
- size_allocs[my_mallocs[number].table_position]--;
- size_allocs[table_position]++;
- total_memory -= old_size;
- total_memory += size;
- old_size=min(old_size, size);
- while (--old_size>0) {
- if (my_mallocs[number].memory[old_size]!=my_mallocs[number].filled_with)
- fprintf(stderr, "Wrong filling!\n");
- }
- count_realloc++;
- }
- }
- } else {
- if (total_memory+size>MAXIMAL_MEMORY_TO_ALLOCATE) {
- goto output; /* for-loop */
- }
- my_mallocs[number].memory=(char *)malloc(size); /* Allokera! */
- if (!my_mallocs[number].memory)
- out_of_memory=TRUE;
- else {
- size_allocs[table_position]++;
- count_malloc++;
- total_memory += size;
- }
- }
-
- if(!out_of_memory) {
- my_mallocs[number].table_position=table_position;
- my_mallocs[number].size=size;
- my_mallocs[number].filled_with=fill_with;
- memset(my_mallocs[number].memory, fill_with, size);
- }
- output:
- if (out_of_memory || !(count%DISPLAY_WHEN)) {
- printf("(%d) malloc %d, realloc %d, free %d, total size %d\n", count, count_malloc, count_realloc, count_free, total_memory);
- {
- int count;
- printf("[size bytes]=[number of allocations]\n");
- for (count=0; count<TABLESIZE; count++) {
- printf("%ld=%ld, ", size_table[count], size_allocs[count]);
- }
- printf("\n\n");
- }
- }
- if (out_of_memory) {
- fprintf(stderr, "Memory is out! Continue (y/n)");
- switch (getchar()) {
- case 'y':
- case 'Y':
- out_of_memory=FALSE;
- break;
- }
- fprintf(stderr, "\n");
- }
- }
- for(i = 0;i < MAX_ALLOCATIONS;i++) {
- if((my_mallocs[i].memory))
- free(my_mallocs[i].memory);
- }
-
- print_lists();
-
- printf("\n");
- return 0;
-}
diff --git a/apps/plugins/pdbox/dbestfit-3.3/README b/apps/plugins/pdbox/dbestfit-3.3/README
deleted file mode 100644
index 7452e36279..0000000000
--- a/apps/plugins/pdbox/dbestfit-3.3/README
+++ /dev/null
@@ -1,21 +0,0 @@
-Package: dbestfit - a dynamic memory allocator
-Date: March 30, 2005
-Version: 3.3
-Author: Daniel Stenberg <daniel@haxx.se>
-
- I wrote the dmalloc part for small allocation sizes to improve the behavior
-of the built-in (first-fit) allocator found in pSOS (around 1996).
-
- I wrote the bmalloc part (best-fit with splay-tree sorting) just for the fun
-of it and to see how good malloc() clone I could make. The quality of my
-implementation is still left to be judged in real-world tests.
-
-TODO:
- * Remove the final not-so-very-nice loop in dmalloc.c that checks for a block
- with free fragments (when the list gets longer too much time might be spent
- in that loop).
-
- * Add semaphore protection in bmalloc.
-
- * Make a separate application that samples the memory usage of a program
- and is capable of replaying it (in order to test properly).
diff --git a/apps/plugins/pdbox/dbestfit-3.3/bmalloc.c b/apps/plugins/pdbox/dbestfit-3.3/bmalloc.c
deleted file mode 100644
index f0ac7312a4..0000000000
--- a/apps/plugins/pdbox/dbestfit-3.3/bmalloc.c
+++ /dev/null
@@ -1,371 +0,0 @@
-/*****************************************************************************
- *
- * Big (best-fit) Memory Allocation
- *
- * Author: Daniel Stenberg
- * Date: March 5, 1997
- * Version: 2.0
- * Email: Daniel.Stenberg@sth.frontec.se
- *
- *
- * Read 'thoughts' for theories and details in implementation.
- *
- * Routines meant to replace the most low level functions of an Operting
- * System
- *
- * v2.0
- * - Made all size-routines get moved out from this file. This way, the size
- * functions can much more easily get replaced.
- * - Improved how new memory blocks get added to the size-sorted list. When
- * not adding new pools, there should never ever be any list traversing
- * since all information is dynamically gathered.
- *
- ****************************************************************************/
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "bysize.h"
-
-#ifndef TRUE
-#define TRUE 1
-#endif
-#ifndef FALSE
-#define FALSE 0
-#endif
-
-/* #define DEBUG */
-
-#define BMEM_ALIGN 64 /* resolution */
-
-#define BMEMERR_TOOSMALL -1
-
-/* this struct will be stored in all CHUNKS and AREAS */
-struct BlockInfo {
- struct BlockInfo *lower; /* previous block in memory (lower address) */
- struct BlockInfo *higher; /* next block in memory (higher address) */
- unsigned long info; /* 31 bits size: 1 bit free boolean */
-#define INFO_FREE 1
-#define INFO_SIZE (~ INFO_FREE) /* inverted FREE bit pattern */
-
- /* FREE+SIZE Could be written to use ordinary bitfields if using a smart
- (like gcc) compiler in a manner like:
- int size:31;
- int free:1;
-
- The 'higher' pointer COULD be removed completely if the size is used as
- an index to the higher one. This would then REQUIRE the entire memory
- pool to be contiguous and it needs a 'terminating' "node" or an extra
- flag that informs about the end of the list.
- */
-};
-
-/* the BLOCK list should be sorted in a lower to higher address order */
-struct BlockInfo *blockHead=NULL; /* nothing from the start */
-
-void print_lists(void);
-
-
-/***********************************************************************
- *
- * remove_block()
- *
- * Remove the block from the address-sorted list.
- *
- ***********************************************************************/
-
-void remove_block(struct BlockInfo *block)
-{
- if(block->lower)
- block->lower->higher = block->higher;
- else
- blockHead = block->higher;
- if(block->higher)
- block->higher->lower = block->lower;
-}
-
-/****************************************************************************
- *
- * add_blocktolists()
- *
- * Adds the specified block at the specified place in the address-sorted
- * list and at the appropriate place in the size-sorted.
- *
- ***************************************************************************/
-void add_blocktolists(struct BlockInfo *block,
- struct BlockInfo *newblock,
- size_t newsize)
-{
- struct BlockInfo *temp; /* temporary storage variable */
- if(block) {
- /* `block' is now a lower address than 'newblock' */
-
- /*
- * Check if the new CHUNK is wall-to-wall with the lower addressed
- * one (if *that* is free)
- */
- if(block->info&INFO_FREE) {
- if((char *)block + (block->info&INFO_SIZE) == (char *)newblock) {
- /* yes sir, this is our lower address neighbour, enlarge that one
- pick it out from the list and recursively add that chunk and
- then we escape */
-
- /* remove from size-sorted list: */
- remove_chunksize((char*)block+sizeof(struct BlockInfo));
-
- block->info += newsize; /* newsize is an even number and thus the FREE
- bit is untouched */
-
- remove_block(block); /* unlink the block address-wise */
-
- /* recursively check our lower friend(s) */
- add_blocktolists(block->lower, block, block->info&INFO_SIZE);
- return;
- }
- }
-
- temp = block->higher;
-
- block->higher = newblock;
- newblock->lower = block;
- newblock->higher = temp;
- if(newblock->higher)
- newblock->higher->lower = newblock;
- }
- else {
- /* this block should preceed the heading one */
- temp = blockHead;
-
- /* check if this is our higher addressed neighbour */
- if((char *)newblock + newsize == (char *)temp) {
-
- /* yes, we are wall-to-wall with the higher CHUNK */
- if(temp->info&INFO_FREE) {
- /* and the neighbour is even free, remove that one and enlarge
- ourselves, call add_pool() recursively and then escape */
-
- remove_block(temp); /* unlink 'temp' from list */
-
- /* remove from size-sorted list: */
- remove_chunksize((char*)temp+sizeof(struct BlockInfo) );
-
- /* add the upper block's size on ourselves */
- newsize += temp->info&INFO_SIZE;
-
- /* add the new, bigger block */
- add_blocktolists(block, newblock, newsize);
- return;
- }
- }
-
- blockHead = newblock;
- newblock->higher = temp;
- newblock->lower = NULL; /* there is no lower one */
- if(newblock->higher)
- newblock->higher->lower = newblock;
- }
-
- newblock->info = newsize | INFO_FREE; /* we do assume size isn't using the
- FREE bit */
- insert_bysize((char *)newblock+sizeof(struct BlockInfo), newsize);
-}
-
-/***********************************************************************
- *
- * findblockbyaddr()
- *
- * Find the block that is just before the input block in memory. Returns NULL
- * if none is.
- *
- ***********************************************************************/
-
-static struct BlockInfo *findblockbyaddr(struct BlockInfo *block)
-{
- struct BlockInfo *test = blockHead;
- struct BlockInfo *lower = NULL;
-
- while(test && (test < block)) {
- lower = test;
- test = test->higher;
- }
- return lower;
-}
-
-/***********************************************************************
- *
- * add_pool()
- *
- * This function should be the absolutely first function to call. It sets up
- * the memory bounds of the [first] CHUNK(s). It should be possible to call
- * this function several times to add more CHUNKs to the pool of free
- * memory. This allows the bmalloc system to deal with a non-contigous memory
- * area.
- *
- * Returns non-zero if an error occured. The memory was not added then.
- *
- ***********************************************************************/
-
-int add_pool(void *start,
- size_t size)
-{
- struct BlockInfo *newblock = (struct BlockInfo *)start;
- struct BlockInfo *block;
-
- if(size < BMEM_ALIGN)
- return BMEMERR_TOOSMALL;
-
- block = findblockbyaddr( newblock );
- /* `block' is now a lower address than 'newblock' or NULL */
-
- if(size&1)
- size--; /* only add even sizes */
-
- add_blocktolists(block, newblock, size);
-
- return 0;
-}
-
-
-#ifdef DEBUG
-static void bmalloc_failed(size_t size)
-{
- printf("*** " __FILE__ " Couldn't allocate %d bytes\n", size);
- print_lists();
-}
-#else
-#define bmalloc_failed(x)
-#endif
-
-#ifdef DEBUG
-void print_lists()
-{
- struct BlockInfo *block = blockHead;
-#if 1
- printf("List of BLOCKS (in address order):\n");
- while(block) {
- printf(" START %p END %p SIZE %ld FLAG %s\n",
- (char *)block,
- (char *)block+(block->info&INFO_SIZE), block->info&INFO_SIZE,
- (block->info&INFO_FREE)?"free":"used");
- block = block->higher;
- }
- printf("End of BLOCKS:\n");
-#endif
- print_sizes();
-}
-#endif /* DEBUG */
-
-void *bmalloc(size_t size)
-{
- void *mem;
-
-#ifdef DEBUG
- {
- static int count=0;
- int realsize = size + sizeof(struct BlockInfo);
- if(realsize%4096)
- realsize = ((size / BMEM_ALIGN)+1) * BMEM_ALIGN;
- printf("%d bmalloc(%d) [%d]\n", count++, size, realsize);
- }
-#endif
-
- size += sizeof(struct BlockInfo); /* add memory for our header */
-
- if(size&(BMEM_ALIGN-1)) /* a lot faster than %BMEM_ALIGN but this MUST be
- changed if the BLOCKSIZE is not 2^X ! */
- size = ((size / BMEM_ALIGN)+1) * BMEM_ALIGN; /* align like this */
-
- /* get a CHUNK from the list with this size */
- mem = obtainbysize ( size );
- if(mem) {
- /* the memory block we have got is the "best-fit" and it is already
- un-linked from the free list */
-
- /* now do the math to get the proper block pointer */
- struct BlockInfo *block= (struct BlockInfo *)
- ((char *)mem - sizeof(struct BlockInfo));
-
- block->info &= ~INFO_FREE;
- /* not free anymore */
-
- if( size != (block->info&INFO_SIZE)) {
- /* split this chunk into two pieces and return the one that fits us */
- size_t othersize = (block->info&INFO_SIZE) - size;
-
- if(othersize > BMEM_ALIGN) {
- /* prevent losing small pieces of memory due to weird alignments
- of the memory pool */
-
- block->info = size; /* set new size (leave FREE bit cleared) */
-
- /* Add the new chunk to the lists: */
- add_blocktolists(block,
- (struct BlockInfo *)((char *)block + size),
- othersize );
- }
- }
-
- /* Return the memory our parent may use: */
- return (char *)block+sizeof(struct BlockInfo);
- }
- else {
- bmalloc_failed(size);
- return NULL; /* can't find any memory, fail hard */
- }
- return NULL;
-}
-
-void bfree(void *ptr)
-{
- struct BlockInfo *block = (struct BlockInfo *)
- ((char *)ptr - sizeof(struct BlockInfo));
- size_t size;
-
- /* setup our initial higher and lower pointers */
- struct BlockInfo *lower = block->lower;
- struct BlockInfo *higher = block->higher;
-
-#ifdef DEBUG
- static int freecount=0;
- printf("%d bfree(%p)\n", freecount++, ptr);
-#endif
-
- /* bind together lower addressed FREE CHUNKS */
- if(lower && (lower->info&INFO_FREE) &&
- ((char *)lower + (lower->info&INFO_SIZE) == (char *)block)) {
- size = block->info&INFO_SIZE; /* original size */
-
- /* remove from size-link: */
- remove_chunksize((char *)lower+sizeof(struct BlockInfo));
-
- remove_block(block); /* unlink from address list */
- block = lower; /* new base area pointer */
- block->info += size; /* append the new size (the FREE bit
- will remain untouched) */
-
- lower = lower->lower; /* new lower pointer */
- }
- /* bind together higher addressed FREE CHUNKS */
- if(higher && (higher->info&INFO_FREE) &&
- ((char *)block + (block->info&INFO_SIZE) == (char *)higher)) {
- /* append higher size, the FREE bit won't be affected */
- block->info += (higher->info&INFO_SIZE);
-
- /* unlink from size list: */
- remove_chunksize((char *)higher+sizeof(struct BlockInfo));
- remove_block(higher); /* unlink from address list */
- higher = higher->higher; /* the new higher link */
- block->higher = higher; /* new higher link */
- }
- block->info |= INFO_FREE; /* consider this FREE! */
-
- block->lower = lower;
- block->higher = higher;
-
- insert_bysize((char *)block+sizeof(struct BlockInfo), block->info&INFO_SIZE);
-
-#ifdef DEBUG
- print_lists();
-#endif
-
-}
diff --git a/apps/plugins/pdbox/dbestfit-3.3/bmalloc.h b/apps/plugins/pdbox/dbestfit-3.3/bmalloc.h
deleted file mode 100644
index ab7215af0a..0000000000
--- a/apps/plugins/pdbox/dbestfit-3.3/bmalloc.h
+++ /dev/null
@@ -1,5 +0,0 @@
-int add_pool(void *start, size_t size);
-void print_lists(void);
-
-void *bmalloc(size_t size);
-void bfree(void *ptr);
diff --git a/apps/plugins/pdbox/dbestfit-3.3/bysize.c b/apps/plugins/pdbox/dbestfit-3.3/bysize.c
deleted file mode 100644
index 8728e247b9..0000000000
--- a/apps/plugins/pdbox/dbestfit-3.3/bysize.c
+++ /dev/null
@@ -1,428 +0,0 @@
-/*****************************************************************************
- *
- * Size-sorted list/tree functions.
- *
- * Author: Daniel Stenberg
- * Date: March 7, 1997
- * Version: 2.0
- * Email: Daniel.Stenberg@sth.frontec.se
- *
- *
- * v2.0
- * - Added SPLAY TREE functionality.
- *
- * Adds and removes CHUNKS from a list or tree.
- *
- ****************************************************************************/
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#define SPLAY /* we use the splay version as that is much faster */
-
-#ifndef TRUE
-#define TRUE 1
-#endif
-#ifndef FALSE
-#define FALSE 0
-#endif
-
-#ifndef SPLAY /* these routines are for the non-splay version */
-
-struct ChunkInfo {
- struct ChunkInfo *larger;
- struct ChunkInfo *smaller;
- size_t size;
-};
-
-/* the CHUNK list anchor */
-struct ChunkInfo *chunkHead=NULL;
-
-/***********************************************************************
-
- findchunkbysize()
-
- Find the chunk that is smaller than the input size. Returns
- NULL if none is.
-
- **********************************************************************/
-
-static struct ChunkInfo *findchunkbysize(size_t size)
-{
- struct ChunkInfo *test = chunkHead;
- struct ChunkInfo *smaller = NULL;
- while(test && (test->size < size)) {
- smaller = test;
- test = test->larger;
- }
- return smaller;
-}
-
-/***********************************************************************
-
- remove_chunksize()
-
- Remove the chunk from the size-sorted list.
- ***********************************************************************/
-
-void remove_chunksize(void *data)
-{
- struct ChunkInfo *chunk = (struct ChunkInfo *)data;
- if(chunk->smaller)
- chunk->smaller->larger = chunk->larger;
- else {
- /* if this has no smaller, this is the head */
- chunkHead = chunk->larger; /* new head */
- }
- if(chunk->larger)
- chunk->larger->smaller = chunk->smaller;
-}
-
-void insert_bysize(char *data, size_t size)
-{
- struct ChunkInfo *newchunk = (struct ChunkInfo *)data;
- struct ChunkInfo *chunk = findchunkbysize ( size );
-
- newchunk->size = size;
-
- if(chunk) {
- /* 'chunk' is smaller than size, append the new chunk ahead of this */
- newchunk->smaller = chunk;
- newchunk->larger = chunk->larger;
- if(chunk->larger)
- chunk->larger->smaller = newchunk;
- chunk->larger = newchunk;
- }
- else {
- /* smallest CHUNK around, append first in the list */
- newchunk->larger = chunkHead;
- newchunk->smaller = NULL;
-
- if(chunkHead)
- chunkHead->smaller = newchunk;
- chunkHead = newchunk;
- }
-}
-
-char *obtainbysize( size_t size)
-{
- struct ChunkInfo *chunk = findchunkbysize( size );
-
- if(!chunk) {
- if(size <= (chunkHead->size))
- /* there is no smaller CHUNK, use the first one (if we fit within that)
- */
- chunk = chunkHead;
- }
- else
- /* we're on the last CHUNK that is smaller than requested, step onto
- the bigger one */
- chunk = chunk->larger;
-
- if(chunk) {
- remove_chunksize( chunk ); /* unlink size-wise */
- return (char *)chunk;
- }
- else
- return NULL;
-}
-
-void print_sizes(void)
-{
- struct ChunkInfo *chunk = chunkHead;
- printf("List of CHUNKS (in size order):\n");
-#if 1
- while(chunk) {
- printf(" START %p END %p SIZE %d\n",
- chunk, (char *)chunk+chunk->size, chunk->size);
- chunk = chunk->larger;
- }
-#endif
- printf("End of CHUNKS:\n");
-}
-
-#else /* Here follows all routines dealing with the SPLAY TREES */
-
-typedef struct tree_node Tree;
-struct tree_node {
- Tree *smaller; /* smaller node */
- Tree *larger; /* larger node */
- Tree *same; /* points to a node with identical key */
- int key; /* the "sort" key */
-};
-
-Tree *chunkHead = NULL; /* the root */
-
-#define compare(i,j) ((i)-(j))
-
-/* Set this to a key value that will *NEVER* appear otherwise */
-#define KEY_NOTUSED -1
-
-/*
- * Splay using the key i (which may or may not be in the tree.) The starting
- * root is t. Weight fields are maintained.
- */
-Tree * splay (int i, Tree *t)
-{
- Tree N, *l, *r, *y;
- int comp;
-
- if (t == NULL)
- return t;
- N.smaller = N.larger = NULL;
- l = r = &N;
-
- for (;;) {
- comp = compare(i, t->key);
- if (comp < 0) {
- if (t->smaller == NULL)
- break;
- if (compare(i, t->smaller->key) < 0) {
- y = t->smaller; /* rotate smaller */
- t->smaller = y->larger;
- y->larger = t;
-
- t = y;
- if (t->smaller == NULL)
- break;
- }
- r->smaller = t; /* link smaller */
- r = t;
- t = t->smaller;
- }
- else if (comp > 0) {
- if (t->larger == NULL)
- break;
- if (compare(i, t->larger->key) > 0) {
- y = t->larger; /* rotate larger */
- t->larger = y->smaller;
- y->smaller = t;
- t = y;
- if (t->larger == NULL)
- break;
- }
- l->larger = t; /* link larger */
- l = t;
- t = t->larger;
- }
- else {
- break;
- }
- }
-
- l->larger = r->smaller = NULL;
-
- l->larger = t->smaller; /* assemble */
- r->smaller = t->larger;
- t->smaller = N.larger;
- t->larger = N.smaller;
-
- return t;
-}
-
-/* Insert key i into the tree t. Return a pointer to the resulting tree or
- NULL if something went wrong. */
-Tree *insert(int i, Tree *t, Tree *new)
-{
- if (new == NULL) {
- return t;
- }
-
- if (t != NULL) {
- t = splay(i,t);
- if (compare(i, t->key)==0) {
- /* it already exists one of this size */
-
- new->same = t;
- new->key = i;
- new->smaller = t->smaller;
- new->larger = t->larger;
-
- t->smaller = new;
- t->key = KEY_NOTUSED;
-
- return new; /* new root node */
- }
- }
-
- if (t == NULL) {
- new->smaller = new->larger = NULL;
- }
- else if (compare(i, t->key) < 0) {
- new->smaller = t->smaller;
- new->larger = t;
- t->smaller = NULL;
- }
- else {
- new->larger = t->larger;
- new->smaller = t;
- t->larger = NULL;
- }
- new->key = i;
-
- new->same = NULL; /* no identical node (yet) */
-
- return new;
-}
-
-/* Finds and deletes the best-fit node from the tree. Return a pointer to the
- resulting tree. best-fit means the smallest node that fits the requested
- size. */
-Tree *removebestfit(int i, Tree *t, Tree **removed)
-{
- Tree *x;
-
- if (t==NULL)
- return NULL;
- t = splay(i,t);
- if(compare(i, t->key) > 0) {
- /* too small node, try the larger chain */
- if(t->larger)
- t=splay(t->larger->key, t);
- else {
- /* fail */
- *removed = NULL;
- return t;
- }
- }
-
- if (compare(i, t->key) <= 0) { /* found it */
-
- /* FIRST! Check if there is a list with identical sizes */
- x = t->same;
- if(x) {
- /* there is, pick one from the list */
-
- /* 'x' is the new root node */
-
- x->key = t->key;
- x->larger = t->larger;
- x->smaller = t->smaller;
- *removed = t;
- return x; /* new root */
- }
-
- if (t->smaller == NULL) {
- x = t->larger;
- }
- else {
- x = splay(i, t->smaller);
- x->larger = t->larger;
- }
- *removed = t;
-
- return x;
- }
- else {
- *removed = NULL; /* no match */
- return t; /* It wasn't there */
- }
-}
-
-
-/* Deletes the node we point out from the tree if it's there. Return a pointer
- to the resulting tree. */
-Tree *removebyaddr(Tree *t, Tree *remove)
-{
- Tree *x;
-
- if (!t || !remove)
- return NULL;
-
- if(KEY_NOTUSED == remove->key) {
- /* just unlink ourselves nice and quickly: */
- remove->smaller->same = remove->same;
- if(remove->same)
- remove->same->smaller = remove->smaller;
- /* voila, we're done! */
- return t;
- }
-
- t = splay(remove->key,t);
-
- /* Check if there is a list with identical sizes */
-
- x = t->same;
- if(x) {
- /* 'x' is the new root node */
-
- x->key = t->key;
- x->larger = t->larger;
- x->smaller = t->smaller;
-
- return x; /* new root */
- }
-
- /* Remove the actualy root node: */
-
- if (t->smaller == NULL) {
- x = t->larger;
- }
- else {
- x = splay(remove->key, t->smaller);
- x->larger = t->larger;
- }
-
- return x;
-}
-
-#ifdef DEBUG
-int printtree(Tree * t, int d, char output)
-{
- int distance=0;
- Tree *node;
- int i;
- if (t == NULL)
- return 0;
- distance += printtree(t->larger, d+1, output);
- for (i=0; i<d; i++)
- if(output)
- printf(" ");
-
- if(output) {
- printf("%d[%d]", t->key, i);
- }
-
- for(node = t->same; node; node = node->same) {
- distance += i; /* this has the same "virtual" distance */
-
- if(output)
- printf(" [+]");
- }
- if(output)
- puts("");
-
- distance += i;
- distance += printtree(t->smaller, d+1, output);
- return distance;
-}
-#endif /* DEBUG */
-
-/* Here follow the look-alike interface so that the tree-function names are
- the same as the list-ones to enable easy interchange */
-
-void remove_chunksize(void *data)
-{
- chunkHead = removebyaddr(chunkHead, data);
-}
-
-void insert_bysize(char *data, size_t size)
-{
- chunkHead = insert(size, chunkHead, (Tree *)data);
-}
-
-char *obtainbysize( size_t size)
-{
- Tree *receive;
- chunkHead = removebestfit(size, chunkHead, &receive);
- return (char *)receive;
-}
-
-#ifdef DEBUG
-void print_sizes(void)
-{
- printtree(chunkHead, 0, 1);
-}
-#endif /* DEBUG */
-
-#endif
diff --git a/apps/plugins/pdbox/dbestfit-3.3/bysize.h b/apps/plugins/pdbox/dbestfit-3.3/bysize.h
deleted file mode 100644
index 877e2ea4c5..0000000000
--- a/apps/plugins/pdbox/dbestfit-3.3/bysize.h
+++ /dev/null
@@ -1,4 +0,0 @@
-void remove_chunksize(void *data);
-void insert_bysize(char *data, size_t size);
-char *obtainbysize( size_t size);
-void print_sizes(void);
diff --git a/apps/plugins/pdbox/dbestfit-3.3/dmalloc.c b/apps/plugins/pdbox/dbestfit-3.3/dmalloc.c
deleted file mode 100644
index b46d4af926..0000000000
--- a/apps/plugins/pdbox/dbestfit-3.3/dmalloc.c
+++ /dev/null
@@ -1,711 +0,0 @@
-/*****************************************************************************
- *
- * Dynamic Memory Allocation
- *
- * Author: Daniel Stenberg
- * Date: March 10, 1997
- * Version: 2.3
- * Email: Daniel.Stenberg@sth.frontec.se
- *
- *
- * Read 'thoughts' for theories and details of this implementation.
- *
- * v2.1
- * - I once again managed to gain some memory. BLOCK allocations now only use
- * a 4 bytes header (instead of previos 8) just as FRAGMENTS.
- *
- * v2.2
- * - Re-adjusted the fragment sizes to better fit into the somewhat larger
- * block.
- *
- * v2.3
- * - Made realloc(NULL, size) work as it should. Which is like a malloc(size)
- *
- *****************************************************************************/
-
-#ifdef ROCKBOX
-#include "plugin.h"
-#define memset rb->memset
-#define memcpy rb->memcpy
-#else /* ROCKBOX */
-#include <stdio.h>
-#include <string.h>
-#endif /* ROCKBOX */
-
-#ifdef DEBUG
-#include <stdarg.h>
-#endif
-
-#ifdef PSOS
-#include <psos.h>
-#define SEMAPHORE /* the PSOS routines use semaphore protection */
-#else
-#include <stdlib.h> /* makes the PSOS complain on the 'size_t' typedef */
-#endif
-
-#ifdef BMALLOC
-#include "bmalloc.h"
-#endif
-
-/* Each TOP takes care of a chain of BLOCKS */
-struct MemTop {
- struct MemBlock *chain; /* pointer to the BLOCK chain */
- long nfree; /* total number of free FRAGMENTS in the chain */
- short nmax; /* total number of FRAGMENTS in this kind of BLOCK */
- size_t fragsize; /* the size of each FRAGMENT */
-
-#ifdef SEMAPHORE /* if we're protecting the list with SEMAPHORES */
- long semaphore_id; /* semaphore used to lock this particular list */
-#endif
-
-};
-
-/* Each BLOCK takes care of an amount of FRAGMENTS */
-struct MemBlock {
- struct MemTop *top; /* our TOP struct */
- struct MemBlock *next; /* next BLOCK */
- struct MemBlock *prev; /* prev BLOCK */
-
- struct MemFrag *first; /* the first free FRAGMENT in this block */
-
- short nfree; /* number of free FRAGMENTS in this BLOCK */
-};
-
-/* This is the data kept in all _free_ FRAGMENTS */
-struct MemFrag {
- struct MemFrag *next; /* next free FRAGMENT */
- struct MemFrag *prev; /* prev free FRAGMENT */
-};
-
-/* This is the data kept in all _allocated_ FRAGMENTS and BLOCKS. We add this
- to the allocation size first thing in the ALLOC function to make room for
- this smoothly. */
-
-struct MemInfo {
- void *block;
- /* which BLOCK is our father, if BLOCK_BIT is set it means this is a
- stand-alone, large allocation and then the rest of the bits should be
- treated as the size of the block */
-#define BLOCK_BIT 1
-};
-
-/* ---------------------------------------------------------------------- */
-/* Defines */
-/* ---------------------------------------------------------------------- */
-
-#ifdef DEBUG
-#define MEMINCR(addr,x) memchange(addr, x)
-#define MEMDECR(addr,x) memchange(addr,-(x))
-#else
-#define MEMINCR(a,x)
-#define MEMDECR(a,x)
-#endif
-
-/* The low level functions used to get memory from the OS and to return memory
- to the OS, we may also define a stub that does the actual allocation and
- free, these are the defined function names used in the dmalloc system
- anyway: */
-#ifdef PSOS
-
-#ifdef DEBUG
-#define DMEM_OSALLOCMEM(size,pointer,type) pointer=(type)dbgmalloc(size)
-#define DMEM_OSFREEMEM(x) dbgfree(x)
-#else
-#define DMEM_OSALLOCMEM(size,pointer,type) rn_getseg(0,size,RN_NOWAIT,0,(void **)&pointer)
-/* Similar, but this returns the memory */
-#define DMEM_OSFREEMEM(x) rn_retseg(0, x)
-#endif
-
-/* Argument: <id> */
-#define SEMAPHOREOBTAIN(x) sm_p(x, SM_WAIT, 0)
-/* Argument: <id> */
-#define SEMAPHORERETURN(x) sm_v(x)
-/* Argument: <name> <id-variable name> */
-#define SEMAPHORECREATE(x,y) sm_create(x, 1, SM_FIFO, (ULONG *)&(y))
-
-#else
-#ifdef BMALLOC /* use our own big-memory-allocation system */
-#define DMEM_OSALLOCMEM(size,pointer,type) pointer=(type)bmalloc(size)
-#define DMEM_OSFREEMEM(x) bfree(x)
-#elif DEBUG
-#define DMEM_OSALLOCMEM(size,pointer,type) pointer=(type)dbgmalloc(size)
-#define DMEM_OSFREEMEM(x) dbgfree(x)
-#else
-#define DMEM_OSALLOCMEM(size,pointer,type) pointer=(type)malloc(size)
-#define DMEM_OSFREEMEM(x) free(x)
-#endif
-#endif
-
-
-/* the largest memory allocation that is made a FRAGMENT: (grab the highest
- number from the list below) */
-#define DMEM_LARGESTSIZE 2032
-
-/* The total size of a BLOCK used for FRAGMENTS
- In order to make this use only *1* even alignment from the big-block-
- allocation-system (possible the bmalloc() system also written by me)
- we need to subtract the [maximum] struct sizes that could get added all
- the way through to the grab from the memory. */
-#define DMEM_BLOCKSIZE 4064 /* (4096 - sizeof(struct MemBlock) - 12) */
-
-/* Since the blocksize isn't an even 2^X story anymore, we make a table with
- the FRAGMENT sizes and amounts that fills up a BLOCK nicely */
-
-/* a little 'bc' script that helps us maximize the usage:
- - for 32-bit aligned addresses (SPARC crashes otherwise):
- for(i=20; i<2040; i++) { a=4064/i; if(a*i >= 4060) { if(i%4==0) {i;} } }
-
-
- I try to approximate a double of each size, starting with ~20. We don't do
- ODD sizes since several CPU flavours dump core when accessing such
- addresses. We try to do 32-bit aligned to make ALL kinds of CPUs to remain
- happy with us.
- */
-
-#if defined(BIGBLOCKS) && BIGBLOCKS==4060 /* previously */
-#ifdef ROCKBOX
-unsigned
-#endif /* ROCKBOX */
-short qinfo[]= { 20, 28, 52, 116, 312, 580, 812, 2028 };
-#else
-#ifdef ROCKBOX
-unsigned
-#endif /* ROCKBOX */
-short qinfo[]= { 20, 28, 52, 116, 312, 580, 1016, 2032};
-/* 52 and 312 only make use of 4056 bytes, but without them there are too
- wide gaps */
-#endif
-
-#ifndef ROCKBOX
-#define MIN(x,y) ((x)<(y)?(x):(y))
-#endif /* ROCKBOX */
-
-/* ---------------------------------------------------------------------- */
-/* Globals */
-/* ---------------------------------------------------------------------- */
-
-/* keeper of the chain of BLOCKS */
-static struct MemTop top[ sizeof(qinfo)/sizeof(qinfo[0]) ];
-
-/* are we experienced? */
-static char initialized = 0;
-
-/* ---------------------------------------------------------------------- */
-/* Start of the real code */
-/* ---------------------------------------------------------------------- */
-
-#ifdef DEBUG
-/************
- * A few functions that are verbose and tells us about the current status
- * of the dmalloc system
- ***********/
-
-static void dmalloc_status()
-{
- int i;
- int used;
- int num;
- int totalfree=0;
- struct MemBlock *block;
- for(i=0; i<sizeof(qinfo)/sizeof(qinfo[0]);i++) {
- block = top[i].chain;
- used = 0;
- num = 0;
- while(block) {
- used += top[i].nmax-block->nfree;
- num++;
- block = block->next;
- }
- printf("Q %d (FRAG %4d), USED %4d FREE %4ld (SIZE %4ld) BLOCKS %d\n",
- i, top[i].fragsize, used, top[i].nfree,
- top[i].nfree*top[i].fragsize, num);
- totalfree += top[i].nfree*top[i].fragsize;
- }
- printf("Total unused memory stolen by dmalloc: %d\n", totalfree);
-}
-
-static void dmalloc_failed(size_t size)
-{
- printf("*** " __FILE__ " Couldn't allocate %d bytes\n", size);
- dmalloc_status();
-}
-#else
-#define dmalloc_failed(x)
-#endif
-
-#ifdef DEBUG
-
-#define BORDER 1200
-
-void *dbgmalloc(int size)
-{
- char *mem;
- size += BORDER;
-#ifdef PSOS
- rn_getseg(0,size,RN_NOWAIT,0,(void **)&mem);
-#else
- mem = malloc(size);
-#endif
- if(mem) {
- memset(mem, 0xaa, BORDER/2);
- memset(mem+BORDER/2, 0xbb, size -BORDER);
- memset(mem-BORDER/2+size, 0xcc, BORDER/2);
- *(long *)mem = size;
- mem += (BORDER/2);
- }
- printf("OSmalloc(%p)\n", mem);
- return (void *)mem;
-}
-
-void checkmem(char *ptr)
-{
- int i;
- long size;
- ptr -= BORDER/2;
-
- for(i=4; i<(BORDER/2); i++)
- if((unsigned char)ptr[i] != 0xaa) {
- printf("########### ALERT ALERT\n");
- break;
- }
- size = *(long *)ptr;
- for(i=size-1; i>=(size - BORDER/2); i--)
- if((unsigned char)ptr[i] != 0xcc) {
- printf("********* POST ALERT\n");
- break;
- }
-}
-
-void dbgfree(char *ptr)
-{
- long size;
- checkmem(ptr);
- ptr -= BORDER/2;
- size = *(long *)ptr;
-
- printf("OSfree(%ld)\n", size);
-#ifdef PSOS
- rn_retseg(0, ptr);
-#else
- free(ptr);
-#endif
-}
-
-
-#define DBG(x) syslog x
-
-void syslog(char *fmt, ...)
-{
- va_list ap;
- va_start(ap, fmt);
- vfprintf(stdout, fmt, ap);
- va_end(ap);
-}
-
-void memchange(void *a, int x)
-{
- static int memory=0;
- static int count=0;
- static int max=0;
- if(memory > max)
- max = memory;
- memory += x;
- DBG(("%d. PTR %p / %d TOTAL %d MAX %d\n", ++count, a, x, memory, max));
-}
-#else
-#define DBG(x)
-#endif
-
-/****************************************************************************
- *
- * FragBlock()
- *
- * This function makes FRAGMENTS of the BLOCK sent as argument.
- *
- ***************************************************************************/
-
-static void FragBlock(char *memp, int size)
-{
- struct MemFrag *frag=(struct MemFrag *)memp;
- struct MemFrag *prev=NULL; /* no previous in the first round */
- int count=0;
- while((count+size) <= DMEM_BLOCKSIZE) {
- memp += size;
- frag->next = (struct MemFrag *)memp;
- frag->prev = prev;
- prev = frag;
- frag = frag->next;
- count += size;
- }
- prev->next = NULL; /* the last one has no next struct */
-}
-
-/***************************************************************************
- *
- * initialize();
- *
- * Called in the first dmalloc(). Inits a few memory things.
- *
- **************************************************************************/
-static void initialize(void)
-{
-#ifdef ROCKBOX
- unsigned
-#endif /* ROCKBOX */
- int i;
- /* Setup the nmax and fragsize fields of the top structs */
- for(i=0; i< sizeof(qinfo)/sizeof(qinfo[0]); i++) {
- top[i].fragsize = qinfo[i];
- top[i].nmax = DMEM_BLOCKSIZE/qinfo[i];
-
-#ifdef PSOS
- /* for some reason, these aren't nulled from start: */
- top[i].chain = NULL; /* no BLOCKS */
- top[i].nfree = 0; /* no FRAGMENTS */
-#endif
-#ifdef SEMAPHORE
- {
- char name[7];
- sprintf(name, "MEM%d", i);
- SEMAPHORECREATE(name, top[i].semaphore_id);
- /* doesn't matter if it failed, we continue anyway ;-( */
- }
-#endif
- }
- initialized = 1;
-}
-
-/****************************************************************************
- *
- * FragFromBlock()
- *
- * This should return a fragment from the block and mark it as used
- * accordingly.
- *
- ***************************************************************************/
-
-static void *FragFromBlock(struct MemBlock *block)
-{
- /* make frag point to the first free FRAGMENT */
- struct MemFrag *frag = block->first;
- struct MemInfo *mem = (struct MemInfo *)frag;
-
- /*
- * Remove the FRAGMENT from the list and decrease the free counters.
- */
- block->first = frag->next; /* new first free FRAGMENT */
-
- block->nfree--; /* BLOCK counter */
- block->top->nfree--; /* TOP counter */
-
- /* heal the FRAGMENT list */
- if(frag->prev) {
- frag->prev->next = frag->next;
- }
- if(frag->next) {
- frag->next->prev = frag->prev;
- }
- mem->block = block; /* no block bit set here */
-
- return ((char *)mem)+sizeof(struct MemInfo);
-}
-
-/***************************************************************************
- *
- * dmalloc()
- *
- * This needs no explanation. A malloc() look-alike.
- *
- **************************************************************************/
-
-void *dmalloc(size_t size)
-{
- void *mem;
-
- DBG(("dmalloc(%d)\n", size));
-
- if(!initialized)
- initialize();
-
- /* First, we make room for the space needed in every allocation */
- size += sizeof(struct MemInfo);
-
- if(size < DMEM_LARGESTSIZE) {
- /* get a FRAGMENT */
-
- struct MemBlock *block=NULL; /* SAFE */
- struct MemBlock *newblock=NULL; /* SAFE */
- struct MemTop *memtop=NULL; /* SAFE */
-
- /* Determine which queue to use */
-#ifdef ROCKBOX
- unsigned
-#endif /* ROCKBOX */
- int queue;
-
- for(queue=0; size > qinfo[queue]; queue++)
- ;
- do {
- /* This is the head master of our chain: */
- memtop = &top[queue];
-
- DBG(("Top info: %p %d %d %d\n",
- memtop->chain,
- memtop->nfree,
- memtop->nmax,
- memtop->fragsize));
-
-#ifdef SEMAPHORE
- if(SEMAPHOREOBTAIN(memtop->semaphore_id))
- return NULL; /* failed somehow */
-#endif
-
- /* get the first BLOCK in the chain */
- block = memtop->chain;
-
- /* check if we have a free FRAGMENT */
- if(memtop->nfree) {
- /* there exists a free FRAGMENT in this chain */
-
- /* I WANT THIS LOOP OUT OF HERE! */
-
- /* search for the free FRAGMENT */
- while(!block->nfree)
- block = block->next; /* check next BLOCK */
-
- /*
- * Now 'block' is the first BLOCK with a free FRAGMENT
- */
-
- mem = FragFromBlock(block);
-
- }
- else {
- /* we do *not* have a free FRAGMENT but need to get us a new BLOCK */
-
- DMEM_OSALLOCMEM(DMEM_BLOCKSIZE + sizeof(struct MemBlock),
- newblock,
- struct MemBlock *);
- if(!newblock) {
- if(++queue < sizeof(qinfo)/sizeof(qinfo[0])) {
- /* There are queues for bigger FRAGMENTS that we should check
- before we fail this for real */
-#ifdef DEBUG
- printf("*** " __FILE__ " Trying a bigger Q: %d\n", queue);
-#endif
- mem = NULL;
- }
- else {
- dmalloc_failed(size- sizeof(struct MemInfo));
- return NULL; /* not enough memory */
- }
- }
- else {
- /* allocation of big BLOCK was successful */
-
- MEMINCR(newblock, DMEM_BLOCKSIZE + sizeof(struct MemBlock));
-
- memtop->chain = newblock; /* attach this BLOCK to the chain */
- newblock->next = block; /* point to the previous first BLOCK */
- if(block)
- block->prev = newblock; /* point back on this new BLOCK */
- newblock->prev = NULL; /* no previous */
- newblock->top = memtop; /* our head master */
-
- /* point to the new first FRAGMENT */
- newblock->first = (struct MemFrag *)
- ((char *)newblock+sizeof(struct MemBlock));
-
- /* create FRAGMENTS of the BLOCK: */
- FragBlock((char *)newblock->first, memtop->fragsize);
-
-#if defined(DEBUG) && !defined(BMALLOC)
- checkmem((char *)newblock);
-#endif
-
- /* fix the nfree counters */
- newblock->nfree = memtop->nmax;
- memtop->nfree += memtop->nmax;
-
- /* get a FRAGMENT from the BLOCK */
- mem = FragFromBlock(newblock);
- }
- }
-#ifdef SEMAPHORE
- SEMAPHORERETURN(memtop->semaphore_id); /* let it go */
-#endif
- } while(NULL == mem); /* if we should retry a larger FRAGMENT */
- }
- else {
- /* get a stand-alone BLOCK */
- struct MemInfo *meminfo;
-
- if(size&1)
- /* don't leave this with an odd size since we'll use that bit for
- information */
- size++;
-
- DMEM_OSALLOCMEM(size, meminfo, struct MemInfo *);
-
- if(meminfo) {
- MEMINCR(meminfo, size);
- meminfo->block = (void *)(size|BLOCK_BIT);
- mem = (char *)meminfo + sizeof(struct MemInfo);
- }
- else {
- dmalloc_failed(size);
- mem = NULL;
- }
- }
- return (void *)mem;
-}
-
-/***************************************************************************
- *
- * dfree()
- *
- * This needs no explanation. A free() look-alike.
- *
- **************************************************************************/
-
-void dfree(void *memp)
-{
- struct MemInfo *meminfo = (struct MemInfo *)
- ((char *)memp- sizeof(struct MemInfo));
-
- DBG(("dfree(%p)\n", memp));
-
- if(!((size_t)meminfo->block&BLOCK_BIT)) {
- /* this is a FRAGMENT we have to deal with */
-
- struct MemBlock *block=meminfo->block;
- struct MemTop *memtop = block->top;
-
-#ifdef SEMAPHORE
- SEMAPHOREOBTAIN(memtop->semaphore_id);
-#endif
-
- /* increase counters */
- block->nfree++;
- memtop->nfree++;
-
- /* is this BLOCK completely empty now? */
- if(block->nfree == memtop->nmax) {
- /* yes, return the BLOCK to the system */
- if(block->prev)
- block->prev->next = block->next;
- else
- memtop->chain = block->next;
- if(block->next)
- block->next->prev = block->prev;
-
- memtop->nfree -= memtop->nmax; /* total counter subtraction */
- MEMDECR(block, DMEM_BLOCKSIZE + sizeof(struct MemBlock));
- DMEM_OSFREEMEM((void *)block); /* return the whole block */
- }
- else {
- /* there are still used FRAGMENTS in the BLOCK, link this one
- into the chain of free ones */
- struct MemFrag *frag = (struct MemFrag *)meminfo;
- frag->prev = NULL;
- frag->next = block->first;
- if(block->first)
- block->first->prev = frag;
- block->first = frag;
- }
-#ifdef SEMAPHORE
- SEMAPHORERETURN(memtop->semaphore_id);
-#endif
- }
- else {
- /* big stand-alone block, just give it back to the OS: */
- MEMDECR(&meminfo->block, (size_t)meminfo->block&~BLOCK_BIT); /* clean BLOCK_BIT */
- DMEM_OSFREEMEM((void *)meminfo);
- }
-}
-
-/***************************************************************************
- *
- * drealloc()
- *
- * This needs no explanation. A realloc() look-alike.
- *
- **************************************************************************/
-
-void *drealloc(char *ptr, size_t size)
-{
- struct MemInfo *meminfo = (struct MemInfo *)
- ((char *)ptr- sizeof(struct MemInfo));
- /*
- * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- * NOTE: the ->size field of the meminfo will now contain the MemInfo
- * struct size too!
- * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- */
- void *mem=NULL; /* SAFE */
- size_t prevsize = 0;
-
- /* NOTE that this is only valid if BLOCK_BIT isn't set: */
- struct MemBlock *block;
-
- DBG(("drealloc(%p, %d)\n", ptr, size));
-
- if(NULL == ptr)
- return dmalloc( size );
-
- block = meminfo->block;
-
- if(!((size_t)meminfo->block&BLOCK_BIT) &&
- (size + sizeof(struct MemInfo) <
- (prevsize = block->top->fragsize) )) {
- /* This is a FRAGMENT and new size is possible to retain within the same
- FRAGMENT */
- if((prevsize > qinfo[0]) &&
- /* this is not the smallest memory Q */
- (size < (block->top-1)->fragsize))
- /* this fits in a smaller Q */
- ;
- else
- mem = ptr; /* Just return the same pointer as we got in. */
- }
- if(!mem) {
- /* This is a stand-alone BLOCK or a realloc that no longer fits within
- the same FRAGMENT */
-
- if((size_t)meminfo->block&BLOCK_BIT) {
- prevsize = ((size_t)meminfo->block&~BLOCK_BIT) -
- sizeof(struct MemInfo);
- }
- else
- prevsize -= sizeof(struct MemInfo);
-
- /* No tricks involved here, just grab a new bite of memory, copy the data
- * from the old place and free the old memory again. */
- mem = dmalloc(size);
- if(mem) {
- memcpy(mem, ptr, MIN(size, prevsize) );
- dfree(ptr);
- }
- }
- return mem;
-}
-
-/***************************************************************************
- *
- * dcalloc()
- *
- * This needs no explanation. A calloc() look-alike.
- *
- **************************************************************************/
-/* Allocate an array of NMEMB elements each SIZE bytes long.
- The entire array is initialized to zeros. */
-void *
-dcalloc (size_t nmemb, size_t size)
-{
- void *result = dmalloc (nmemb * size);
-
- if (result != NULL)
- memset (result, 0, nmemb * size);
-
- return result;
-}
diff --git a/apps/plugins/pdbox/dbestfit-3.3/dmalloc.h b/apps/plugins/pdbox/dbestfit-3.3/dmalloc.h
deleted file mode 100644
index 6a0c993815..0000000000
--- a/apps/plugins/pdbox/dbestfit-3.3/dmalloc.h
+++ /dev/null
@@ -1,12 +0,0 @@
-void *dmalloc(size_t);
-void dfree(void *);
-void *drealloc(void *, size_t);
-
-#define malloc(x) dmalloc(x)
-#define free(x) dfree(x)
-#define realloc(x,y) drealloc(x,y)
-
-#ifdef ROCKBOX
-void *dcalloc(size_t, size_t);
-#define calloc(x,y) dcalloc(x,y)
-#endif
diff --git a/apps/plugins/pdbox/dbestfit-3.3/dmytest.c b/apps/plugins/pdbox/dbestfit-3.3/dmytest.c
deleted file mode 100644
index ed12686b3d..0000000000
--- a/apps/plugins/pdbox/dbestfit-3.3/dmytest.c
+++ /dev/null
@@ -1,138 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "dmalloc.h"
-
-#define MAX 500
-#define MAX2 1000
-#define MAXC 2
-
-#define TESTA
-#define TESTB
-#define TESTC
-#define TESTD
-
-int main(int argc, char **argv)
-{
- int i;
- int memory = 0;
-
-#ifdef BMALLOC
-#define HEAP 10000
- void *heap = (malloc)(HEAP);
- if(!heap)
- return -1;
- add_pool(heap, HEAP);
-#endif
-
- {
-#define MAXK 100
- void *wow[MAXK];
- wow[0]=malloc(700);
- realloc(wow[0], 680);
- return 0;
-
- for(i=0; i<MAXK; i++)
- if(!(wow[i]=malloc(412))) {
- printf("*** Couldn't allocated memory, exiting\n");
- return -2;
- }
- for(i=MAXK-1; i>=0; i-=2)
- free(wow[i]);
- return 0;
- }
-
-
-#ifdef TESTD
- {
-#define MAXS 10
-#define MAXS1 0
- void *ptr[MAXS];
-
- for(i=MAXS1; i< MAXS; i++) {
- printf("%d malloc(%d)\n", i, i*55);
- ptr[i] = malloc (i*55);
- }
- for(i=MAXS1; i< MAXS; i++) {
- void *tmp;
- printf("%d realloc(%d)\n", i, i*155);
- tmp=realloc(ptr[i], i*155);
- if(tmp)
- ptr[i] = tmp;
- }
- for(i=MAXS1; i< MAXS; i++) {
- printf("%d free(%d)\n", i, i*155);
- free(ptr[i]);
- }
- }
-#endif
-
-#ifdef TESTC
- {
- void *ptr[MAXC];
- printf("This is test C:\n");
-
- for(i=0; i< MAXC; i++) {
- printf("%d malloc(100)\n", i+1);
- ptr[i] = malloc(100);
- printf(" ...returned %p\n", ptr[i]);
- }
-
- for(i=0; i< MAXC; i++) {
- printf("%d free()\n", i+1);
- free(ptr[i]);
- }
-
- printf("End of test C:\n");
- }
-#endif
-
-#ifdef TESTA
- {
- void *pointers[MAX];
- printf("This is test I:\n");
-
- for(i=0; i<MAX; i++) {
- printf("%d attempts malloc(%d)\n", i, i*6);
- pointers[i]=malloc(i*6);
- if(!pointers[i]) {
- printf("cant get more memory!");
- return(0);
- }
- memory += (i*6);
- }
- printf("\namount: %d\n", memory);
- memory = 0;
- for(i=0; i<MAX; i++) {
- printf("%d attempts realloc(%d)\n", i, i*7);
- pointers[i]=realloc(pointers[i], i*7);
- memory += i*7;
- }
- printf("\namount: %d\n", memory);
- for(i=0; i<MAX; i++) {
- printf("%d attempts free(%d)\n", i, i*7);
- free(pointers[i]);
- }
- printf("\nend of test 1\n");
- }
-#endif
-#ifdef TESTB
- {
- void *pointers2[MAX2];
- memory = 0;
- printf("\nTest II\n");
- for(i=0; i< MAX2; i++) {
-/* printf("%d attempts malloc(%d)\n", i, 7); */
- pointers2[i] = malloc(7);
- memory += 7;
- }
- printf("\namount: %d\n", memory);
- for(i=0; i< MAX2; i++) {
- free(pointers2[i]);
- }
- printf("\nend of test II\n");
-
- }
-#endif
- return 0;
-}
diff --git a/apps/plugins/pdbox/dbestfit-3.3/malloc.man b/apps/plugins/pdbox/dbestfit-3.3/malloc.man
deleted file mode 100644
index 8b6e3dbea5..0000000000
--- a/apps/plugins/pdbox/dbestfit-3.3/malloc.man
+++ /dev/null
@@ -1,95 +0,0 @@
-MALLOC(3V) C LIBRARY FUNCTIONS MALLOC(3V)
-
-
-NAME
- malloc, free, realloc, calloc
-
-SYNOPSIS
- #include <malloc.h>
-
- void *malloc(size)
- size_t size;
-
- void free(ptr)
- void *ptr;
-
- void *realloc(ptr, size)
- void *ptr;
- size_t size;
-
- void *calloc(nelem, elsize)
- size_t nelem;
- size_t elsize;
-
-DESCRIPTION
- These routines provide a general-purpose memory allocation
- package. They maintain a table of free blocks for efficient
- allocation and coalescing of free storage. When there is no
- suitable space already free, the allocation routines call
- rn_getseg() to get more memory from the system.
-
- Each of the allocation routines returns a pointer to space
- suitably aligned for storage of any type of object. Each
- returns a NULL pointer if the request cannot be completed
- (see DIAGNOSTICS).
-
- malloc() returns a pointer to a block of at least size
- bytes, which is appropriately aligned.
-
- free() releases a previously allocated block. Its argument
- is a pointer to a block previously allocated by malloc(),
- calloc() or realloc().
-
- realloc() changes the size of the block referenced by ptr to
- size bytes and returns a pointer to the (possibly moved)
- block. The contents will be unchanged up to the lesser of
- the new and old sizes. If unable to honor a reallocation
- request, realloc() leaves its first argument unaltered.
-
- **** DMALLOC DOES NOT COMPLY WITH THE PARAGRAPH BELOW ****
-
- For backwards compatibility, realloc() accepts a pointer to a
- block freed since the most recent call to malloc(), cal-
- loc() or realloc().
-
- Note: using realloc() with a block freed before the most recent
- call to malloc(), calloc() or realloc() is an error.
-
- calloc() uses malloc() to allocate space for an array of
- nelem elements of size elsize, initializes the space to
- zeros, and returns a pointer to the initialized block. The
- block should be freed with free().
-
-
- malloc() and realloc() return a non- NULL pointer if size is 0,
- and calloc() returns a non-NULL pointer if nelem or elsize is 0,
- but these pointers should not be dereferenced.
-
- Note: Always cast the value returned by malloc(), realloc() or
- calloc().
-
-
-RETURN VALUES On success, malloc(), calloc() and realloc() return a
- pointer to space suitably aligned for storage of any type of
- object. On failure, they return NULL.
-
- free() does not return a value.
-
-
-NOTES
- Because malloc() and realloc() return a non-NULL pointer if size
- is 0, and calloc() returns a non-NULL pointer if nelem or elsize
- is 0, a zero size need not be treated as a special case if it
- should be passed to these functions unpredictably. Also, the
- pointer returned by these functions may be passed to subsequent
- invocations of realloc().
-
-
-BUGS
-
- **** DMALLOC DOES NOT COMPLY WITH THE PARAGRAPH BELOW ****
-
- Since realloc() accepts a pointer to a block freed since the last
- call to malloc(), calloc() or realloc(), a degradation of
- performance results. The semantics of free() should be changed
- so that the contents of a previously freed block are undefined.
diff --git a/apps/plugins/pdbox/dbestfit-3.3/mytest.c b/apps/plugins/pdbox/dbestfit-3.3/mytest.c
deleted file mode 100644
index 80407dee00..0000000000
--- a/apps/plugins/pdbox/dbestfit-3.3/mytest.c
+++ /dev/null
@@ -1,69 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "bmalloc.h"
-
-int main(int argc, char **argv)
-{
- void *pointers[5];
- int i;
- void *area;
-
- for(i=0; i<5; i++)
- pointers[i] = malloc(8000);
-
- if(argc>1) {
- switch(argv[1][0]) {
- case '1':
- for(i=0; i<5; i++) {
- add_pool(pointers[i], 4000);
- add_pool((char *)pointers[i]+4000, 4000);
- }
- break;
- case '2':
- area = malloc(20000);
- add_pool(area, 3000);
- add_pool((char *)area+6000, 3000);
- add_pool((char *)area+3000, 3000);
- add_pool((char *)area+12000, 3000);
- add_pool((char *)area+9000, 3000);
- break;
- case '3':
- {
- void *ptr[10];
- area = malloc(20000);
- add_pool(area, 20000);
-
- printf(" ** TEST USAGE\n");
- for(i=0; i<9; i++)
- ptr[i]=bmalloc(200);
- print_lists();
- for(i=0; i<9; i++)
- bfree(ptr[i]);
- printf(" ** END OF TEST USAGE\n");
- }
-
- break;
- case '4':
- {
- void *ptr[10];
- area = malloc(20000);
- add_pool(area, 20000);
-
- ptr[0]=bmalloc(4080);
- print_lists();
- bfree(ptr[0]);
- printf(" ** END OF TEST USAGE\n");
- }
-
- break;
- }
- }
- else
- for(i=4; i>=0; i--)
- add_pool(pointers[i], 8000-i*100);
-
- print_lists();
-
- return 0;
-}
diff --git a/apps/plugins/pdbox/dbestfit-3.3/thoughts b/apps/plugins/pdbox/dbestfit-3.3/thoughts
deleted file mode 100644
index d509d36d2a..0000000000
--- a/apps/plugins/pdbox/dbestfit-3.3/thoughts
+++ /dev/null
@@ -1,170 +0,0 @@
- =====================================
- Memory Allocation Algorithm Theories.
- =====================================
-
-GOAL
- It is intended to be a 100% working memory allocation system. It should be
- capable of replacing an ordinary Operating System's own routines. It should
- work good in a multitasking, shared memory, non-virtual memory environment
- without clogging the memory. Primary aimed for small machines, CPUs and
- memory amounts.
-
- I use a best-fit algorithm with a slight overhead in order to increase speed
- a lot. It should remain scalable and work good with very large amount of
- memory and free/used memory blocks too.
-
-TERMINOLOGY
-
- FRAGMENT - small identically sized parts of a larger BLOCK, they are when
- travered in lists etc _not_ allocated.
- BLOCK - large memory area, if used for FRAGMENTS, they are linked in a
- lists. One list for each FRAGMENT size supported.
- TOP - head struct that holds information about and points to a chain
- of BLOCKS for a particular FRAGMENT size.
- CHUNK - a contiguous area of free memory
-
-MEMORY SYSTEM
-
- We split the system in two parts. One part allocates small memory amounts
- and one part allocates large memory amounts, but all allocations are done
- "through" the small-part-system. There is an option to use only the small
- system (and thus use the OS for large blocks) or the complete package.
-
-##############################################################################
- SMALL SIZE ALLOCATIONS
-##############################################################################
-
- Keywords for this system is 'Deferred Coalescing' and 'quick lists'.
-
- ALLOC
-
- * Small allocations are "aligned" upwards to a set of preset sizes. In the
- current implementation I use 20, 28, 52, 116, 312, 580, 812, 2028 bytes.
- Memory allocations of these sizes are refered to as FRAGMENTS.
- (The reason for these specific sizes is the requirement that they must be
- 32-bit aligned and fit as good as possible within 4060 bytes.)
-
- * Allocations larger than 2028 will get a BLOCK for that allocation only.
-
- * Each of these sizes has it's own TOP. When a FRAGMENT is requested, a
- larger BLOCK will be allocated and divided into many FRAGMENTS (all of the
- same size). TOP points to a list with BLOCKS that contains FRAGMENTS of
- the same size. Each BLOCK has a 'number of free FRAGMENTS' counter and so
- has each TOP (for the entire chain).
-
- * A BLOCK is around 4060 bytes plus the size of the information header. This
- size is adjusted to make the allocation of the big block not require more
- than 4096 bytes. (This might not be so easy to be sure of, if you don't
- know how the big-block system works, but the BMALLOC system uses an
- extra header of 12 bytes and the header for the FRAGMENT BLOCK is 20 bytes
- in a general 32-bit unix environment.)
-
- * In case the allocation of a BLOCK fails when a FRAGMENT is required, the
- next size of FRAGMENTS will be checked for a free FRAGMENT. First when the
- larger size lists have been tested without success it will fail for real.
-
- FREE
-
- * When FRAGMENTS are freed so that a BLOCK becomes non-used, it is returned
- to the system.
-
- * FREEing a fragment adds the buffer in a LIFO-order. That means that the
- next request for a fragment from the same list, the last freed buffer will
- be returned first.
-
- REALLOC
-
- * REALLOCATION of a FRAGMENT does first check if the new size would fit
- within the same FRAGMENT and if it would use the same FRAGMENT size. If it
- does and would, the same pointer is returned.
-
- OVERHEAD
-
- Yes, there is an overhead on small allocations (internal fragmentation).
- Yet, I do believe that small allocations more often than larger ones are
- used dynamically. I believe that a large overhead is not a big problem if it
- remains only for a while. The big gain is with the extreme speed we can GET
- and RETURN small allocations. This has yet to be proven. I am open to other
- systems of dealing with the small ones, but I don`t believe in using the
- same system for all sizes of allocations.
-
- IMPROVEMENT
-
- An addition to the above described algorithm is the `save-empty-BLOCKS-a-
- while-afterwards`. It will be used when the last used FRAGMENT within a
- BLOCK is freed. The BLOCK will then not get returned to the system until "a
- few more" FRAGMENTS have been freed in case the last [few] freed FRAGMENTS
- are allocated yet again (and thus prevent the huge overhead of making
- FRAGMENTS in a BLOCK). The "only" drawback of such a SEBAWA concept is
- that it would mean an even bigger overhead...
-
- HEADERS (in allocated data)
-
- FRAGMENTS - 32-bit pointer to its parent BLOCK (lowest bit must be 0)
- BLOCK - 32-bit size (lowest bit must be 1 to separate this from
- FRAGMENTS)
-
-##############################################################################
- LARGER ALLOCATIONS
-##############################################################################
-
- If the requested size is larger than the largest FRAGMENT size supported,
- the allocation will be made for this memory area alone, or if a BLOCK is
- allocated to fit lots of FRAGMENTS a large block is also desired.
-
- * We add memory to the "system" with the add_pool() function call. It
- specifies the start and size of the new block of memory that will be
- used in this memory allocation system. Several add_pool() calls are
- supported and they may or may not add contiguous memory.
-
- * Make all blocks get allocated aligned to BLOCKSIZE (sometimes referred to
- as 'grain size'), 64 bytes in my implementation. Reports tell us there is
- no real gain in increasing the size of the align.
-
- * We link *all* pieces of memory (AREAS), free or not free. We keep the list
- in address order and thus when a FREE() occurs we know instanstly if there
- are FREE CHUNKS wall-to-wall. No list "travels" needed. Requires some
- extra space in every allocated BLOCK. Still needs to put the new CHUNK in
- the right place in size-sorted list/tree. All memory areas, allocated or
- not, contain the following header:
- - size of this memory area
- - FREE status
- - pointer to the next AREA closest in memory
- - pointer to the prev AREA closest in memory
- (12 bytes)
-
- * Sort all FREE CHUNKS in size-order. We use a SPLAY TREE algorithm for
- maximum speed. Data/structs used for the size-sorting functions are kept
- in an abstraction layer away from this since it is really not changing
- anything (except executing speed).
-
- ALLOC (RSIZE - requested size, aligned properly)
-
- * Fetch a CHUNK that RSIZE fits within. If the found CHUNK is larger than
- RSIZE, split it and return the RSIZE to the caller. Link the new CHUNK
- into the list/tree.
-
- FREE (AREA - piece of memory that is returned to the system)
-
- * Since the allocated BLOCK has kept its link-pointers, we can without
- checking any list instantly see if there are any FREE CHUNKS that are
- wall-to-wall with the AREA (both sides). If the AREA *is* wall-to-wall
- with one or two CHUNKS that or they are unlinked from the lists, enlarged
- and re-linked into the lists.
-
- REALLOC
-
- * There IS NO realloc() of large blocks, they are performed in the higher
- layer (dmalloc).
-
-
-##############################################################################
- FURTHER READING
-##############################################################################
-
- * "Dynamic Storage Allocation: A Survey and Critical Review" (Paul R. Wilson,
- Mark S. Johnstone, Michael Neely, David Boles)
- ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps
-
- * "A Memory Allocator" (Doug Lea)
- http://g.oswego.edu/dl/html/malloc.html
diff --git a/apps/plugins/pdbox/pdbox-func.c b/apps/plugins/pdbox/pdbox-func.c
index d6a2ea750a..c5e81ed7b9 100644
--- a/apps/plugins/pdbox/pdbox-func.c
+++ b/apps/plugins/pdbox/pdbox-func.c
@@ -2319,12 +2319,12 @@ void glob_evalfile(t_pd *ignore, t_symbol *name, t_symbol *dir);
void openit(const char *dirname, const char *filename)
{
char* nameptr;
- char* dirbuf = getbytes(MAXPDSTRING);
+ char dirbuf[MAXPDSTRING];
/* Workaround: If the file resides in the root directory,
add a trailing slash to prevent directory part
of the filename from being removed -- W.B. */
- char* ffilename = getbytes(MAXPDSTRING);
+ char ffilename[MAXPDSTRING];
ffilename[0] = '/';
ffilename[1] = '\0';
strcat(ffilename, filename);
@@ -2338,10 +2338,6 @@ void openit(const char *dirname, const char *filename)
}
else
error("%s: can't open", filename);
-
- /* Clean up. */
- freebytes(dirbuf, MAXPDSTRING);
- freebytes(ffilename, MAXPDSTRING);
}
@@ -2374,14 +2370,14 @@ char* rb_getcwd(char* buf, ssize_t size)
extern t_namelist* sys_openlist;
void glob_initfromgui(void *dummy, t_symbol *s, int argc, t_atom *argv)
{
+ t_namelist *nl;
+ char cwd[MAXPDSTRING];
+
(void) dummy;
(void) s;
(void) argc;
(void) argv;
- t_namelist *nl;
- char* cwd = getbytes(MAXPDSTRING);
-
/* Get current working directory. */
rb_getcwd(cwd, MAXPDSTRING);
@@ -2391,9 +2387,6 @@ void glob_initfromgui(void *dummy, t_symbol *s, int argc, t_atom *argv)
namelist_free(sys_openlist);
sys_openlist = 0;
-
- /* Clean up. */
- freebytes(cwd, MAXPDSTRING);
}
/* Fake GUI start. Originally in s_inter.c */
@@ -2405,7 +2398,7 @@ int sys_startgui(const char *guidir)
{
unsigned int i;
t_atom zz[23];
- char* cmdbuf = getbytes(4*MAXPDSTRING);
+ char cmdbuf[4*MAXPDSTRING];
(void) guidir;
@@ -2420,9 +2413,6 @@ int sys_startgui(const char *guidir)
SETFLOAT(zz+22,0);
glob_initfromgui(0, 0, 23, zz);
- /* Clean up. */
- freebytes(cmdbuf, 4*MAXPDSTRING);
-
return 0;
}
@@ -2436,14 +2426,11 @@ int sys_getblksize(void)
/* Find library directory and set it. */
void sys_findlibdir(const char* filename)
{
- (void) filename;
+ char sbuf[MAXPDSTRING];
- char* sbuf = getbytes(MAXPDSTRING);
+ (void) filename;
/* Make current working directory the system library directory. */
rb_getcwd(sbuf, MAXPDSTRING);
sys_libdir = gensym(sbuf);
-
- /* Clean up. */
- freebytes(sbuf, MAXPDSTRING);
}
diff --git a/apps/plugins/pdbox/pdbox.c b/apps/plugins/pdbox/pdbox.c
index 38c12c279b..dd848deba2 100644
--- a/apps/plugins/pdbox/pdbox.c
+++ b/apps/plugins/pdbox/pdbox.c
@@ -58,14 +58,17 @@ rates we expect to see: 32000, 44100, 48000, 88200, 96000. */
/* Quit flag. */
bool quit = false;
+/* Stack sizes for threads. */
+#define CORESTACKSIZE (8 * 1024 * 1024)
+#define GUISTACKSIZE (512 * 1024)
+
+/* Thread stacks. */
+void* core_stack;
+void* gui_stack;
+
/* Thread IDs. */
+unsigned int core_thread_id;
unsigned int gui_thread_id;
-unsigned int time_thread_id;
-
-/* Stacks for threads. */
-#define STACK_SIZE 16384
-uint32_t gui_stack[STACK_SIZE / sizeof(uint32_t)];
-uint32_t time_stack[256 / sizeof(uint32_t)];
/* GUI thread */
@@ -102,20 +105,33 @@ void gui_thread(void)
rb->thread_exit();
}
-/* Running time thread. */
-void time_thread(void)
+/* Core thread */
+void core_thread(void)
{
+ /* Add the directory the called .pd resides in to lib directories. */
+ sys_findlibdir(filename);
+
+ /* Open the PD design file. */
+ sys_openlist = namelist_append(sys_openlist, filename);
+
+ /* Fake a GUI start. */
+ sys_startgui(NULL);
+
+ /* Core scheduler loop */
while(!quit)
{
- /* Add time slice in milliseconds. */
- runningtime += (1000 / HZ);
- rb->sleep(1);
+ /* Use sys_send_dacs() function as timer. */
+ while(sys_send_dacs() != SENDDACS_NO)
+ sched_tick(sys_time + sys_time_per_dsp_tick);
+
+ yield();
}
rb->thread_exit();
}
+
/* Plug-in entry point */
enum plugin_status plugin_start(const void* parameter)
{
@@ -133,14 +149,19 @@ enum plugin_status plugin_start(const void* parameter)
return PLUGIN_ERROR;
}
- /* Allocate memory; check it's size; add to the pool. */
+ /* Initialize memory pool. */
mem_pool = rb->plugin_get_audio_buffer(&mem_size);
if(mem_size < MIN_MEM_SIZE)
{
rb->splash(HZ, "Not enough memory!");
return PLUGIN_ERROR;
}
- add_pool(mem_pool, mem_size);
+#if 1
+ init_memory_pool(mem_size, mem_pool);
+#endif
+#if 0
+ set_memory_pool(mem_pool, mem_size);
+#endif
/* Initialize net. */
net_init();
@@ -164,36 +185,36 @@ enum plugin_status plugin_start(const void* parameter)
DEFAULTADVANCE, /* Scheduler advance */
1 /* Enable */);
- /* Add the directory the called .pd resides in to lib directories. */
- sys_findlibdir(filename);
-
- /* Open the parameter file. */
- sys_openlist = namelist_append(sys_openlist, filename);
-
- /* Fake a GUI start. */
- sys_startgui(NULL);
+ /* Create stacks for threads. */
+ core_stack = getbytes(CORESTACKSIZE);
+ gui_stack = getbytes(GUISTACKSIZE);
+ if(core_stack == NULL || gui_stack == NULL)
+ {
+ rb->splash(HZ, "Not enough memory!");
+ return PLUGIN_ERROR;
+ }
/* Start threads. */
- time_thread_id =
- rb->create_thread(&time_thread,
- time_stack,
- sizeof(time_stack),
+ core_thread_id =
+ rb->create_thread(&core_thread,
+ core_stack,
+ CORESTACKSIZE,
0, /* FIXME Which flags? */
- "PD running time"
+ "PD core"
IF_PRIO(, PRIORITY_REALTIME)
IF_COP(, COP));
gui_thread_id =
rb->create_thread(&gui_thread,
gui_stack,
- sizeof(gui_stack),
+ GUISTACKSIZE,
0, /* FIXME Which flags? */
"PD GUI"
IF_PRIO(, PRIORITY_USER_INTERFACE)
IF_COP(, CPU));
/* If having an error creating threads, bail out. */
- if(time_thread_id == 0 || gui_thread_id == 0)
+ if(core_thread_id == 0 || gui_thread_id == 0)
return PLUGIN_ERROR;
/* Initialize scheduler time variables. */
@@ -205,9 +226,8 @@ enum plugin_status plugin_start(const void* parameter)
/* Main loop. */
while(!quit)
{
- /* Use sys_send_dacs() function as timer. */
- while(sys_send_dacs() != SENDDACS_NO)
- sched_tick(sys_time + sys_time_per_dsp_tick);
+ /* Add time slice in milliseconds. */
+ runningtime += (1000 / HZ);
/* Sleep to the next time slice. */
rb->sleep(1);
@@ -215,7 +235,7 @@ enum plugin_status plugin_start(const void* parameter)
/* Wait for threads to complete. */
rb->thread_wait(gui_thread_id);
- rb->thread_wait(time_thread_id);
+ rb->thread_wait(core_thread_id);
/* Close audio subsystem. */
sys_close_audio();
@@ -223,6 +243,13 @@ enum plugin_status plugin_start(const void* parameter)
/* Destroy net. */
net_destroy();
+ /* Clear memory pool. */
+#if 1
+ destroy_memory_pool(mem_pool);
+#endif
+#if 0
+ clear_memory_pool();
+#endif
+
return PLUGIN_OK;
}
-
diff --git a/apps/plugins/pdbox/pdbox.h b/apps/plugins/pdbox/pdbox.h
index 2ca5bc8d4f..47aa2ec4d8 100644
--- a/apps/plugins/pdbox/pdbox.h
+++ b/apps/plugins/pdbox/pdbox.h
@@ -22,19 +22,50 @@
#ifndef PDBOX_H
#define PDBOX_H
-/* Use dbestfit. */
-#include "bmalloc.h"
-#include "dmalloc.h"
+
+#if 1
+/* Use TLSF. */
+#include "tlsf.h"
+#endif
/* Pure Data */
#include "m_pd.h"
-
-/* dbestfit declarations. */
-
/* Minimal memory size. */
#define MIN_MEM_SIZE (4 * 1024 * 1024)
+/* Memory prototypes. */
+
+#if 1
+/* Direct memory allocator functions to TLSF. */
+#define malloc(size) tlsf_malloc(size)
+#define free(ptr) tlsf_free(ptr)
+#define realloc(ptr, size) tlsf_realloc(ptr, size)
+#define calloc(elements, elem_size) tlsf_calloc(elements, elem_size)
+#endif
+
+#if 0
+extern void set_memory_pool(void* memory_pool, size_t memory_size);
+extern void clear_memory_pool(void);
+extern void* mcalloc(size_t nmemb, size_t size);
+extern void* mmalloc(size_t size);
+extern void mfree(void* ptr);
+extern void* mrealloc(void* ptr, size_t size);
+extern void print_memory_pool(void);
+
+#define malloc mmalloc
+#define free mfree
+#define realloc mrealloc
+#define calloc mcalloc
+#endif
+
+#if 0
+#include <stdlib.h>
+#define malloc malloc
+#define free free
+#define realloc realloc
+#define calloc calloc
+#endif
/* Audio declarations. */
#define PD_SAMPLERATE 22050
@@ -44,7 +75,7 @@
/* Audio buffer part. Contains data for one HZ period. */
#ifdef SIMULATOR
-#define AUDIOBUFSIZE (PD_SAMPLES_PER_HZ * PD_OUT_CHANNELS * 4)
+#define AUDIOBUFSIZE (PD_SAMPLES_PER_HZ * PD_OUT_CHANNELS * 32)
#else
#define AUDIOBUFSIZE (PD_SAMPLES_PER_HZ * PD_OUT_CHANNELS)
#endif
diff --git a/apps/plugins/pdbox/pdbox.make b/apps/plugins/pdbox/pdbox.make
index 83147bbbae..15d793f6ea 100644
--- a/apps/plugins/pdbox/pdbox.make
+++ b/apps/plugins/pdbox/pdbox.make
@@ -23,7 +23,7 @@ $(PDBOXBUILDDIR)/pdbox.rock: $(PDBOX_OBJ)
PDBOXFLAGS = $(PLUGINFLAGS) \
-DFIXEDPOINT -DSTATIC -DPD -DUSEAPI_ROCKBOX \
-I$(PDBOXSRCDIR) -I$(PDBOXSRCDIR)/PDa/src \
- -DBMALLOC -I$(PDBOXSRCDIR)/dbestfit-3.3
+ -I$(PDBOXSRCDIR)/TLSF-2.4.4/src
# Compile PDBox with extra flags (adapted from ZXBox)
$(PDBOXBUILDDIR)/%.o: $(PDBOXSRCDIR)/%.c $(PLUGINBITMAPLIB) $(PDBOXSRCDIR)/pdbox.make