MTK 使用数组模拟动态内存分配

 在MTK开发中，如果要进行大量的内存分配不是件容易的事情。因此，我们变通的使用这种方法来模拟。可以防止绝大多数的内存问题。已经在项目中实践，放心使用^_^

 #ifndef _DZD_MEMORY2_H_ #define _DZD_MEMORY2_H_ int DZD_mem_internal_init (void *mem, unsigned long memsize); void * DZD_mem_internal_malloc (unsigned long size); void DZD_mem_internal_free (void* mem); void DZD_mem_internal_free_all (void); unsigned long DZD_mem_get_size (void *mem); #endif

 

/***************************************************************************** * filename:　 DZD_mem.c * author: fulinhai * created date: 9/12, 2005 * description: use static array simulates dynamic allocation * * *****************************************************************************/ #include "kal_release.h" #include "stack_common.h" #include "stack_msgs.h" #include "stack_config.h" #include "custom_config.h" #include "kal_trace.h" #include "gv.h" #include "tst_def.h" #include "E3E_men.h" //#ifdef __KDZD_INTERNAL_MEMORY_MANAGE__ #define DZD_NUM_FREE_LISTS 10 #define DZD_CHUNKHEADERSIZE (2 * sizeof(unsigned long)) #define DZD_MINCHUNKSIZE sizeof(DZD_chunk_t) #define DZD_MALLOC_ALIGNMENT 4 #define DZD_MALLOC_ALIGN_MASK 3 #define DZD_MINBLOCKSIZE (12 * DZD_MINCHUNKSIZE) typedef struct DZD_chunk_st{ unsigned long prev_size; /* Size of previous chunk. */ unsigned long size; /* Size in bytes, including overhead, inuse bit is also stored here. */ struct DZD_chunk_st* fwd; /* Double links -- used only if free. */ struct DZD_chunk_st* bck; } DZD_chunk_t; typedef DZD_chunk_t* DZD_chunkptr; typedef struct { unsigned char *baseptr; DZD_chunkptr firstchunk; DZD_chunkptr lastchunk; DZD_chunkptr freelists[DZD_NUM_FREE_LISTS]; } DZD_mem_internal_t; DZD_mem_internal_t DZD_mem_internal; #define DZD_INT_GLOBAL_MEM_SIZE (1024*300) /* * We use segregated free lists, with separate lists for * chunks of different sizes. Currently, we use sizes that are * powers of two. * In list number n is kept all the free chunks whose size is * strictly less than maxsizes[n]. */ const static unsigned long maxsizes[DZD_NUM_FREE_LISTS] = { 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 0x8FFFFFFF }; /* * List operations. */ #define DZD_remove_from_list(p) / (p)->fwd->bck = (p)->bck; / (p)->bck->fwd = (p)->fwd; #define DZD_add_to_list(l, p) / (p)->fwd = (l)->fwd; / (p)->bck = l; / (l)->fwd->bck = p; / (l)->fwd = p; #define DZD_set_hd1(p, v) ((p)->prev_size = (unsigned long)(v)) #define DZD_set_hd2(p, v) ((p)->size = (unsigned long)(v)) #define DZD_request2size(req) / (((unsigned long)((req) + DZD_CHUNKHEADERSIZE + DZD_MALLOC_ALIGN_MASK) < / (unsigned long)(DZD_MINCHUNKSIZE + DZD_MALLOC_ALIGN_MASK)) ? DZD_MINCHUNKSIZE : / (unsigned long)(((req) + DZD_CHUNKHEADERSIZE + DZD_MALLOC_ALIGN_MASK) & ~(DZD_MALLOC_ALIGN_MASK))) #define DZD_chunksize(p) (((p)->size & ~0x01) >> 1) /* The next and previous links */ #define DZD_prevchunk(p) ((DZD_chunkptr)(((unsigned char *)(p)) - p->prev_size)) #define DZD_nextchunk(p) ((DZD_chunkptr)(((unsigned char *)(p)) + DZD_chunksize (p))) /* The IN USE bit */ #define DZD_chunk_isfree(p) ((((DZD_chunkptr)(p))->size & 0x01) == 0) #define DZD_chunk_inuse(p) ((((DZD_chunkptr)(p))->size & 0x01) == 1) /* Conversion from chunk headers to user pointers, and back */ #define DZD_chunk2mem(p) ((void*)((unsigned char *)(p) + DZD_CHUNKHEADERSIZE)) #define DZD_mem2chunk(mem) ((DZD_chunkptr)((unsigned char *)(mem) - DZD_CHUNKHEADERSIZE)) /* * Return the number of the list that a chunk of size "n" * belongs to. */ int DZD_list_idx (unsigned long n) { int l; for (l = 0; maxsizes[l] <= n; l++); return l; } /**************************************************************** * function name: DZD_mem_internal_init * parameter: * mem static memory * memsize size of the static memory * description: * Initialize the internal memory allocation library. * the memory library, the second is a pointer to a block * of memory and the third is the size of the memory area. * Returns 0 on success, and -1 otherwise. ****************************************************************/ int DZD_mem_internal_init (void *mem, unsigned long memsize) { DZD_mem_internal_t* mod_mem; DZD_chunkptr p; unsigned long size; short i; mod_mem = &DZD_mem_internal; /* Truncate to nearest multiple of the alignment. */ memsize &= ~DZD_MALLOC_ALIGN_MASK;//使内存以四对齐 if ((mem == NULL) || (memsize < DZD_MINBLOCKSIZE) || (memsize > 0x7FFFFFFF)) { mod_mem->baseptr = NULL; return -1; } mod_mem->baseptr = (unsigned char*)mem; /* For each of the lists of free chunks, we need one chunk to * serve as list header. We mark each one as "in use" to avoid * having it merged with an adjacent chunk on freeing. */ for (i = 0; i < DZD_NUM_FREE_LISTS; i++) { p = (DZD_chunkptr)(mod_mem->baseptr + i * DZD_MINCHUNKSIZE); DZD_set_hd1 (p, 0); DZD_set_hd2 (p, (DZD_MINCHUNKSIZE << 1) | 0x01); p->fwd = p; p->bck = p; mod_mem->freelists[i] = p; } /* This chunk starts out on the appropriate free list and * contains all of the available memory. */ mod_mem->firstchunk = (DZD_chunkptr)(mod_mem->baseptr + DZD_NUM_FREE_LISTS * DZD_MINCHUNKSIZE); DZD_set_hd1 (mod_mem->firstchunk, DZD_MINCHUNKSIZE); size = memsize - ((DZD_NUM_FREE_LISTS + 1) * DZD_MINCHUNKSIZE); DZD_set_hd2 (mod_mem->firstchunk, size << 1); DZD_add_to_list (mod_mem->freelists[DZD_list_idx (size)], mod_mem->firstchunk); /* The last chunk is never placed on any list; it is marked "in use", * and simply acts as a sentry element, when scanning all the chunks. */ mod_mem->lastchunk = (DZD_chunkptr)(((unsigned char *)(mod_mem->baseptr)) + memsize - DZD_MINCHUNKSIZE); DZD_set_hd1 (mod_mem->lastchunk, size); DZD_set_hd2 (mod_mem->lastchunk, (DZD_MINCHUNKSIZE << 1) | 0x01); return 0; }

 

/**************************************************************** * function name: DZD_mem_internal_init * parameter: * mem static memory * memsize size of the static memory * description: * Allocate and return a pointer to a memory area of at least * the indicated size. The allocated block of memory will be aligned * on a 4-byte boundary. * Returns 0 if allocation fails. ****************************************************************/ void * DZD_mem_internal_malloc (unsigned long size) { DZD_mem_internal_t* mod_mem; DZD_chunkptr p = 0, ptmp; unsigned long nb; unsigned long sz = DZD_INT_GLOBAL_MEM_SIZE; unsigned long remsize; int i; mod_mem = &(DZD_mem_internal); if (mod_mem->baseptr == NULL) return 0; /* We add space for our overhead (4 bytes) plus round to nearest * larger multiple of 4, plus never allocate a chunk less than 8 bytes. */ nb = DZD_request2size (size); /* Check all relevant free lists, until a non-empty one is found. */ for (i = DZD_list_idx (nb); i < DZD_NUM_FREE_LISTS; i++) { DZD_chunkptr freelist = mod_mem->freelists[i]; /* Search the entire list, select chunk with closest fit */ for (ptmp = freelist->fwd; ptmp != freelist; ptmp = ptmp->fwd) { unsigned long tmpsz = DZD_chunksize (ptmp); if (tmpsz == nb) { /* Exact fit: no need to search any further. */ p = ptmp; sz = tmpsz; goto found; } else if (tmpsz > nb) { /* Chunk is large enough */ if (tmpsz < sz) { /* This is the best so far. */ p = ptmp; sz = tmpsz; } } } if (p != 0) goto found; } /* Searched all lists, but found no large enough chunk */ return 0; found: /* We have found a large enough chunk, namely "p" of size "sz". */ DZD_remove_from_list (p); remsize = sz - nb; if (remsize >= DZD_MINCHUNKSIZE) { /* The remainder is large enough to become a separate chunk */ DZD_chunkptr q, next; DZD_chunkptr l; sz = nb; /* "q" will be the new chunk */ q = (DZD_chunkptr)((unsigned char *)p + sz); DZD_set_hd2 (q, remsize << 1); DZD_set_hd1 (q, nb); next = DZD_nextchunk (q); next->prev_size = remsize; l = mod_mem->freelists[DZD_list_idx (remsize)]; DZD_add_to_list (l, q); } DZD_set_hd2 (p, (sz << 1) | 0x01); return DZD_chunk2mem (p); } /******************************************************************* * function name: DZD_mem_internal_free * parameter: * mem allocated memory * description: * Free a memory area previously allocated with msf_mem_internal_malloc. * Calling this routine with 'mem' equal to 0 has no effect. ******************************************************************/ void DZD_mem_internal_free (void* mem) { DZD_mem_internal_t* mod_mem; DZD_chunkptr p; /* chunk corresponding to mem */ unsigned long sz; /* its size */ DZD_chunkptr next; /* next adjacent chunk */ DZD_chunkptr prev; /* previous adjacent chunk */ DZD_chunkptr l; mod_mem = &(DZD_mem_internal); if (mem == 0 || mod_mem->baseptr == NULL) return; p = DZD_mem2chunk (mem); if (DZD_chunk_isfree (p)) return; sz = DZD_chunksize (p); prev = DZD_prevchunk (p); next = DZD_nextchunk (p); if (DZD_chunk_isfree (prev)) { /* Join with previous chunk */ sz += DZD_chunksize (prev); p = prev; DZD_remove_from_list (prev); } if (DZD_chunk_isfree (next)) { /* Join with next chunk */ sz += DZD_chunksize (next); DZD_remove_from_list (next); } DZD_set_hd2 (p, sz << 1); next = DZD_nextchunk (p); next->prev_size = sz; l = mod_mem->freelists [DZD_list_idx (sz)]; DZD_add_to_list (l, p); } /******************************************************************* * function name: DZD_mem_internal_free_all * parameter: * none * description: * Free all memory areas allocated by a module, by doing a new Initialize. ******************************************************************/ void DZD_mem_internal_free_all (void) { void* mem; unsigned long size = 0; mem = DZD_mem_internal.baseptr; // kal_prompt_trace(MOD_MMI, "Free All"); if (mem != NULL) { size = (unsigned long)(((unsigned char*)(DZD_mem_internal.lastchunk)) + DZD_MINCHUNKSIZE - (unsigned char*)mem); DZD_mem_internal_init (mem, size); } } /******************************************************************* * function name: DZD_mem_get_size * parameter: * none * description: * Return the size of an allocated memory area. * The reported size includes the overhead used by the memory allocation * system. ******************************************************************/ unsigned long DZD_mem_get_size (void *mem) { DZD_chunkptr p; /* chunk corresponding to mem */ unsigned long size; p = DZD_mem2chunk (mem); size = DZD_chunksize (p); //ASSERT(size < DZD_INT_GLOBAL_MEM_SIZE); return size; } //#endif

 

使用的时候很简单

p= (U16*)DZD_mem_internal_malloc(sizeof(U16)*MAX_COURSE_FILENAME_LEN);

......
DZD_mem_internal_free(p);