2010-05-18 17:58:33 +02:00
|
|
|
/*
|
2010-09-09 14:16:39 +02:00
|
|
|
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
|
2010-05-18 17:58:33 +02:00
|
|
|
*
|
2010-06-18 18:39:21 +02:00
|
|
|
* Use of this source code is governed by a BSD-style license
|
2010-06-04 22:19:40 +02:00
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
|
* tree. An additional intellectual property rights grant can be found
|
2010-06-18 18:39:21 +02:00
|
|
|
* in the file PATENTS. All contributing project authors may
|
2010-06-04 22:19:40 +02:00
|
|
|
* be found in the AUTHORS file in the root of the source tree.
|
2010-05-18 17:58:33 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#define __VPX_MEM_C__
|
|
|
|
|
|
|
|
#include "vpx_mem.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#ifndef CONFIG_MEM_MANAGER
|
|
|
|
# if defined(VXWORKS)
|
|
|
|
# define CONFIG_MEM_MANAGER 1 //include heap manager functionality,
|
|
|
|
//default: enabled on vxworks
|
|
|
|
# else
|
|
|
|
# define CONFIG_MEM_MANAGER 0 //include heap manager functionality
|
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef CONFIG_MEM_TRACKER
|
|
|
|
# define CONFIG_MEM_TRACKER 1 //include xvpx_* calls in the lib
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef CONFIG_MEM_CHECKS
|
|
|
|
# define CONFIG_MEM_CHECKS 0 //include some basic safety checks in
|
|
|
|
//vpx_memcpy, _memset, and _memmove
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef USE_GLOBAL_FUNCTION_POINTERS
|
|
|
|
# define USE_GLOBAL_FUNCTION_POINTERS 0 //use function pointers instead of compiled functions.
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if CONFIG_MEM_TRACKER
|
|
|
|
# include "vpx_mem_tracker.h"
|
|
|
|
# if VPX_MEM_TRACKER_VERSION_CHIEF != 2 || VPX_MEM_TRACKER_VERSION_MAJOR != 5
|
|
|
|
# error "vpx_mem requires memory tracker version 2.5 to track memory usage"
|
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define ADDRESS_STORAGE_SIZE sizeof(size_t)
|
|
|
|
|
|
|
|
#ifndef DEFAULT_ALIGNMENT
|
|
|
|
# if defined(VXWORKS)
|
|
|
|
# define DEFAULT_ALIGNMENT 32 //default addr alignment to use in
|
|
|
|
//calls to vpx_* functions other
|
|
|
|
//than vpx_memalign
|
|
|
|
# else
|
|
|
|
# define DEFAULT_ALIGNMENT 1
|
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if DEFAULT_ALIGNMENT < 1
|
|
|
|
# error "DEFAULT_ALIGNMENT must be >= 1!"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if CONFIG_MEM_TRACKER
|
|
|
|
# define TRY_BOUNDS_CHECK 1 //when set to 1 pads each allocation,
|
|
|
|
//integrity can be checked using
|
|
|
|
//vpx_memory_tracker_check_integrity
|
|
|
|
//or on free by defining
|
|
|
|
//TRY_BOUNDS_CHECK_ON_FREE
|
|
|
|
static unsigned long g_alloc_count = 0;
|
|
|
|
|
|
|
|
#else
|
|
|
|
# define TRY_BOUNDS_CHECK 0
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if TRY_BOUNDS_CHECK
|
|
|
|
# define TRY_BOUNDS_CHECK_ON_FREE 0 //checks mem integrity on every
|
|
|
|
//free, very expensive
|
|
|
|
# define BOUNDS_CHECK_VALUE 0xdeadbeef //value stored before/after ea.
|
|
|
|
//mem addr for bounds checking
|
|
|
|
# define BOUNDS_CHECK_PAD_SIZE 32 //size of the padding before and
|
|
|
|
//after ea allocation to be filled
|
|
|
|
//with BOUNDS_CHECK_VALUE.
|
|
|
|
//this should be a multiple of 4
|
|
|
|
#else
|
|
|
|
# define BOUNDS_CHECK_VALUE 0
|
|
|
|
# define BOUNDS_CHECK_PAD_SIZE 0
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if CONFIG_MEM_MANAGER
|
|
|
|
# include "heapmm.h"
|
|
|
|
# include "hmm_intrnl.h"
|
|
|
|
|
|
|
|
# define SHIFT_HMM_ADDR_ALIGN_UNIT 5
|
|
|
|
# define TOTAL_MEMORY_TO_ALLOCATE 20971520 // 20 * 1024 * 1024
|
|
|
|
|
|
|
|
# define MM_DYNAMIC_MEMORY 1
|
|
|
|
# if MM_DYNAMIC_MEMORY
|
|
|
|
static unsigned char *g_p_mng_memory_raw = NULL;
|
|
|
|
static unsigned char *g_p_mng_memory = NULL;
|
|
|
|
# else
|
|
|
|
static unsigned char g_p_mng_memory[TOTAL_MEMORY_TO_ALLOCATE];
|
|
|
|
# endif
|
|
|
|
|
|
|
|
static size_t g_mm_memory_size = TOTAL_MEMORY_TO_ALLOCATE;
|
|
|
|
|
|
|
|
static hmm_descriptor hmm_d;
|
|
|
|
static int g_mng_memory_allocated = 0;
|
|
|
|
|
|
|
|
static int vpx_mm_create_heap_memory();
|
|
|
|
static void *vpx_mm_realloc(void *memblk, size_t size);
|
|
|
|
#endif //CONFIG_MEM_MANAGER
|
|
|
|
|
|
|
|
#if USE_GLOBAL_FUNCTION_POINTERS
|
|
|
|
|
|
|
|
struct GLOBAL_FUNC_POINTERS
|
|
|
|
{
|
|
|
|
g_malloc_func g_malloc;
|
|
|
|
g_calloc_func g_calloc;
|
|
|
|
g_realloc_func g_realloc;
|
|
|
|
g_free_func g_free;
|
|
|
|
g_memcpy_func g_memcpy;
|
|
|
|
g_memset_func g_memset;
|
|
|
|
g_memmove_func g_memmove;
|
|
|
|
};
|
|
|
|
struct GLOBAL_FUNC_POINTERS *g_func = 0;
|
|
|
|
|
|
|
|
# define VPX_MALLOC_L g_func->g_malloc
|
|
|
|
# define VPX_REALLOC_L g_func->g_realloc
|
|
|
|
# define VPX_FREE_L g_func->g_free
|
|
|
|
# define VPX_MEMCPY_L g_func->g_memcpy
|
|
|
|
# define VPX_MEMSET_L g_func->g_memset
|
|
|
|
# define VPX_MEMMOVE_L g_func->g_memmove
|
|
|
|
|
|
|
|
#else
|
|
|
|
# define VPX_MALLOC_L malloc
|
|
|
|
# define VPX_REALLOC_L realloc
|
|
|
|
# define VPX_FREE_L free
|
|
|
|
# define VPX_MEMCPY_L memcpy
|
|
|
|
# define VPX_MEMSET_L memset
|
|
|
|
# define VPX_MEMMOVE_L memmove
|
|
|
|
#endif // USE_GLOBAL_FUNCTION_POINTERS
|
|
|
|
|
|
|
|
/* Should probably use a vpx_mem logger function. */
|
|
|
|
#define __REMOVE_PRINTFS
|
|
|
|
#ifdef __REMOVE_PRINTFS
|
|
|
|
#define _P(x)
|
|
|
|
#else
|
|
|
|
#define _P(x) x
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*returns an addr aligned to the byte boundary specified by align*/
|
|
|
|
#define align_addr(addr,align) \
|
|
|
|
(void*)(((size_t)(addr) + ((align) - 1)) & (size_t)-(align))
|
|
|
|
|
|
|
|
unsigned int vpx_mem_get_version()
|
|
|
|
{
|
|
|
|
unsigned int ver = ((unsigned int)(unsigned char)VPX_MEM_VERSION_CHIEF << 24 |
|
|
|
|
(unsigned int)(unsigned char)VPX_MEM_VERSION_MAJOR << 16 |
|
|
|
|
(unsigned int)(unsigned char)VPX_MEM_VERSION_MINOR << 8 |
|
|
|
|
(unsigned int)(unsigned char)VPX_MEM_VERSION_PATCH);
|
|
|
|
return ver;
|
|
|
|
}
|
|
|
|
|
|
|
|
int vpx_mem_set_heap_size(size_t size)
|
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
#if CONFIG_MEM_MANAGER
|
|
|
|
#if MM_DYNAMIC_MEMORY
|
|
|
|
|
|
|
|
if (!g_mng_memory_allocated && size)
|
|
|
|
{
|
|
|
|
g_mm_memory_size = size;
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ret = -3;
|
|
|
|
|
|
|
|
#else
|
|
|
|
ret = -2;
|
|
|
|
#endif
|
|
|
|
#else
|
|
|
|
(void)size;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void *vpx_memalign(size_t align, size_t size)
|
|
|
|
{
|
|
|
|
void *addr,
|
|
|
|
* x = NULL;
|
|
|
|
|
|
|
|
#if CONFIG_MEM_MANAGER
|
|
|
|
int number_aau;
|
|
|
|
|
|
|
|
if (vpx_mm_create_heap_memory() < 0)
|
|
|
|
{
|
|
|
|
_P(printf("[vpx][mm] ERROR vpx_memalign() Couldn't create memory for Heap.\n");)
|
|
|
|
}
|
|
|
|
|
|
|
|
number_aau = ((size + align - 1 + ADDRESS_STORAGE_SIZE) >>
|
|
|
|
SHIFT_HMM_ADDR_ALIGN_UNIT) + 1;
|
|
|
|
|
|
|
|
addr = hmm_alloc(&hmm_d, number_aau);
|
|
|
|
#else
|
|
|
|
addr = VPX_MALLOC_L(size + align - 1 + ADDRESS_STORAGE_SIZE);
|
|
|
|
#endif //CONFIG_MEM_MANAGER
|
|
|
|
|
|
|
|
if (addr)
|
|
|
|
{
|
|
|
|
x = align_addr((unsigned char *)addr + ADDRESS_STORAGE_SIZE, (int)align);
|
|
|
|
/* save the actual malloc address */
|
|
|
|
((size_t *)x)[-1] = (size_t)addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
|
|
|
void *vpx_malloc(size_t size)
|
|
|
|
{
|
|
|
|
return vpx_memalign(DEFAULT_ALIGNMENT, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void *vpx_calloc(size_t num, size_t size)
|
|
|
|
{
|
|
|
|
void *x;
|
|
|
|
|
|
|
|
x = vpx_memalign(DEFAULT_ALIGNMENT, num * size);
|
|
|
|
|
|
|
|
if (x)
|
|
|
|
VPX_MEMSET_L(x, 0, num * size);
|
|
|
|
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
|
|
|
void *vpx_realloc(void *memblk, size_t size)
|
|
|
|
{
|
|
|
|
void *addr,
|
|
|
|
* new_addr = NULL;
|
|
|
|
int align = DEFAULT_ALIGNMENT;
|
|
|
|
|
|
|
|
/*
|
|
|
|
The realloc() function changes the size of the object pointed to by
|
|
|
|
ptr to the size specified by size, and returns a pointer to the
|
|
|
|
possibly moved block. The contents are unchanged up to the lesser
|
|
|
|
of the new and old sizes. If ptr is null, realloc() behaves like
|
|
|
|
malloc() for the specified size. If size is zero (0) and ptr is
|
|
|
|
not a null pointer, the object pointed to is freed.
|
|
|
|
*/
|
|
|
|
if (!memblk)
|
|
|
|
new_addr = vpx_malloc(size);
|
|
|
|
else if (!size)
|
|
|
|
vpx_free(memblk);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
addr = (void *)(((size_t *)memblk)[-1]);
|
|
|
|
memblk = NULL;
|
|
|
|
|
|
|
|
#if CONFIG_MEM_MANAGER
|
|
|
|
new_addr = vpx_mm_realloc(addr, size + align + ADDRESS_STORAGE_SIZE);
|
|
|
|
#else
|
|
|
|
new_addr = VPX_REALLOC_L(addr, size + align + ADDRESS_STORAGE_SIZE);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (new_addr)
|
|
|
|
{
|
|
|
|
addr = new_addr;
|
|
|
|
new_addr = (void *)(((size_t)
|
|
|
|
((unsigned char *)new_addr + ADDRESS_STORAGE_SIZE) + (align - 1)) &
|
|
|
|
(size_t) - align);
|
|
|
|
/* save the actual malloc address */
|
|
|
|
((size_t *)new_addr)[-1] = (size_t)addr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return new_addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void vpx_free(void *memblk)
|
|
|
|
{
|
|
|
|
if (memblk)
|
|
|
|
{
|
|
|
|
void *addr = (void *)(((size_t *)memblk)[-1]);
|
|
|
|
#if CONFIG_MEM_MANAGER
|
|
|
|
hmm_free(&hmm_d, addr);
|
|
|
|
#else
|
|
|
|
VPX_FREE_L(addr);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void *vpx_mem_alloc(int id, size_t size, size_t align)
|
|
|
|
{
|
|
|
|
#if defined CHIP_DM642 || defined __uClinux__
|
|
|
|
void *mem = (void *)mem_alloc(id, size, align);
|
|
|
|
|
|
|
|
if (!mem)
|
|
|
|
{
|
|
|
|
_P(fprintf(stderr,
|
|
|
|
"\n"
|
|
|
|
"*********************************************************\n"
|
|
|
|
"WARNING: mem_alloc returned 0 for id=%p size=%u align=%u.\n"
|
|
|
|
"*********************************************************\n",
|
|
|
|
mem, size, align));
|
|
|
|
// should no longer need this. Softier says it's fixed. 2005-01-21 tjf
|
|
|
|
//#if defined __uClinux__
|
|
|
|
//while(1)usleep(1000000);
|
|
|
|
//#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined __uClinux__
|
|
|
|
else if (mem == (void *)0xFFFFFFFF)
|
|
|
|
{
|
|
|
|
// out of memory/error
|
|
|
|
mem = (void *)0;
|
|
|
|
|
|
|
|
_P(fprintf(stderr,
|
|
|
|
"\n"
|
|
|
|
"******************************************************\n"
|
|
|
|
"ERROR: mem_alloc id=%p size=%u align=%u OUT OF MEMORY.\n"
|
|
|
|
"******************************************************\n",
|
|
|
|
mem, size, align));
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // __uClinux__
|
|
|
|
|
|
|
|
return mem;
|
|
|
|
#else
|
|
|
|
(void)id;
|
|
|
|
(void)size;
|
|
|
|
(void)align;
|
|
|
|
return (void *)0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void vpx_mem_free(int id, void *mem, size_t size)
|
|
|
|
{
|
|
|
|
#if defined CHIP_DM642 || defined __uClinux__
|
|
|
|
|
|
|
|
if (!mem)
|
|
|
|
{
|
|
|
|
_P(fprintf(stderr,
|
|
|
|
"\n"
|
|
|
|
"**************************************\n"
|
|
|
|
"WARNING: 0 being free'd id=%p size=%u.\n"
|
|
|
|
"**************************************\n",
|
|
|
|
id, size));
|
|
|
|
|
|
|
|
// should no longer need this. Softier says it's fixed. 2005-01-21 tjf
|
|
|
|
//#if defined __uClinux__
|
|
|
|
//while(1)usleep(1000000);
|
|
|
|
//#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
mem_free(id, mem, size);
|
|
|
|
#else
|
|
|
|
(void)id;
|
|
|
|
(void)mem;
|
|
|
|
(void)size;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#if CONFIG_MEM_TRACKER
|
|
|
|
|
|
|
|
void *xvpx_mem_alloc(int id, size_t size, size_t align, char *file, int line)
|
|
|
|
{
|
|
|
|
void *mem = vpx_mem_alloc(id, size, align);
|
|
|
|
|
|
|
|
vpx_memory_tracker_add((size_t)mem, size, file, line, 0);
|
|
|
|
|
|
|
|
return mem;
|
|
|
|
}
|
|
|
|
|
|
|
|
void xvpx_mem_free(int id, void *mem, size_t size, char *file, int line)
|
|
|
|
{
|
|
|
|
if (vpx_memory_tracker_remove((size_t)mem) == -2)
|
|
|
|
{
|
|
|
|
#if REMOVE_PRINTFS
|
|
|
|
(void)file;
|
|
|
|
(void)line;
|
|
|
|
#endif
|
|
|
|
_P(fprintf(stderr, "[vpx_mem][xvpx_mem_free] addr: %p (id=%p size=%u) "
|
|
|
|
"not found in list; freed from file:%s"
|
|
|
|
" line:%d\n", mem, id, size, file, line));
|
|
|
|
}
|
|
|
|
|
|
|
|
vpx_mem_free(id, mem, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void *xvpx_memalign(size_t align, size_t size, char *file, int line)
|
|
|
|
{
|
|
|
|
#if TRY_BOUNDS_CHECK
|
|
|
|
unsigned char *x_bounds;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
void *x;
|
|
|
|
|
|
|
|
if (g_alloc_count == 0)
|
|
|
|
{
|
|
|
|
#if TRY_BOUNDS_CHECK
|
|
|
|
int i_rv = vpx_memory_tracker_init(BOUNDS_CHECK_PAD_SIZE, BOUNDS_CHECK_VALUE);
|
|
|
|
#else
|
|
|
|
int i_rv = vpx_memory_tracker_init(0, 0);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (i_rv < 0)
|
|
|
|
{
|
|
|
|
_P(printf("ERROR xvpx_malloc MEM_TRACK_USAGE error vpx_memory_tracker_init().\n");)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#if TRY_BOUNDS_CHECK
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
unsigned int tempme = BOUNDS_CHECK_VALUE;
|
|
|
|
|
|
|
|
x_bounds = vpx_memalign(align, size + (BOUNDS_CHECK_PAD_SIZE * 2));
|
|
|
|
|
|
|
|
if (x_bounds)
|
|
|
|
{
|
|
|
|
/*we're aligning the address twice here but to keep things
|
|
|
|
consistent we want to have the padding come before the stored
|
|
|
|
address so no matter what free function gets called we will
|
|
|
|
attempt to free the correct address*/
|
|
|
|
x_bounds = (unsigned char *)(((size_t *)x_bounds)[-1]);
|
|
|
|
x = align_addr(x_bounds + BOUNDS_CHECK_PAD_SIZE + ADDRESS_STORAGE_SIZE,
|
|
|
|
(int)align);
|
|
|
|
/* save the actual malloc address */
|
|
|
|
((size_t *)x)[-1] = (size_t)x_bounds;
|
|
|
|
|
|
|
|
for (i = 0; i < BOUNDS_CHECK_PAD_SIZE; i += sizeof(unsigned int))
|
|
|
|
{
|
|
|
|
VPX_MEMCPY_L(x_bounds + i, &tempme, sizeof(unsigned int));
|
|
|
|
VPX_MEMCPY_L((unsigned char *)x + size + i,
|
|
|
|
&tempme, sizeof(unsigned int));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
x = NULL;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
x = vpx_memalign(align, size);
|
|
|
|
#endif //TRY_BOUNDS_CHECK
|
|
|
|
|
|
|
|
g_alloc_count++;
|
|
|
|
|
|
|
|
vpx_memory_tracker_add((size_t)x, size, file, line, 1);
|
|
|
|
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
|
|
|
void *xvpx_malloc(size_t size, char *file, int line)
|
|
|
|
{
|
|
|
|
return xvpx_memalign(DEFAULT_ALIGNMENT, size, file, line);
|
|
|
|
}
|
|
|
|
|
|
|
|
void *xvpx_calloc(size_t num, size_t size, char *file, int line)
|
|
|
|
{
|
|
|
|
void *x = xvpx_memalign(DEFAULT_ALIGNMENT, num * size, file, line);
|
|
|
|
|
|
|
|
if (x)
|
|
|
|
VPX_MEMSET_L(x, 0, num * size);
|
|
|
|
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
|
|
|
void *xvpx_realloc(void *memblk, size_t size, char *file, int line)
|
|
|
|
{
|
|
|
|
struct mem_block *p = NULL;
|
|
|
|
int orig_size = 0,
|
|
|
|
orig_line = 0;
|
|
|
|
char *orig_file = NULL;
|
|
|
|
|
|
|
|
#if TRY_BOUNDS_CHECK
|
|
|
|
unsigned char *x_bounds = memblk ?
|
|
|
|
(unsigned char *)(((size_t *)memblk)[-1]) :
|
|
|
|
NULL;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
void *x;
|
|
|
|
|
|
|
|
if (g_alloc_count == 0)
|
|
|
|
{
|
|
|
|
#if TRY_BOUNDS_CHECK
|
|
|
|
|
|
|
|
if (!vpx_memory_tracker_init(BOUNDS_CHECK_PAD_SIZE, BOUNDS_CHECK_VALUE))
|
|
|
|
#else
|
|
|
|
if (!vpx_memory_tracker_init(0, 0))
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
_P(printf("ERROR xvpx_malloc MEM_TRACK_USAGE error vpx_memory_tracker_init().\n");)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (p = vpx_memory_tracker_find((size_t)memblk))
|
|
|
|
{
|
|
|
|
orig_size = p->size;
|
|
|
|
orig_file = p->file;
|
|
|
|
orig_line = p->line;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if TRY_BOUNDS_CHECK_ON_FREE
|
|
|
|
vpx_memory_tracker_check_integrity(file, line);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
//have to do this regardless of success, because
|
|
|
|
//the memory that does get realloc'd may change
|
|
|
|
//the bounds values of this block
|
|
|
|
vpx_memory_tracker_remove((size_t)memblk);
|
|
|
|
|
|
|
|
#if TRY_BOUNDS_CHECK
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
unsigned int tempme = BOUNDS_CHECK_VALUE;
|
|
|
|
|
|
|
|
x_bounds = vpx_realloc(memblk, size + (BOUNDS_CHECK_PAD_SIZE * 2));
|
|
|
|
|
|
|
|
if (x_bounds)
|
|
|
|
{
|
|
|
|
x_bounds = (unsigned char *)(((size_t *)x_bounds)[-1]);
|
|
|
|
x = align_addr(x_bounds + BOUNDS_CHECK_PAD_SIZE + ADDRESS_STORAGE_SIZE,
|
|
|
|
(int)DEFAULT_ALIGNMENT);
|
|
|
|
/* save the actual malloc address */
|
|
|
|
((size_t *)x)[-1] = (size_t)x_bounds;
|
|
|
|
|
|
|
|
for (i = 0; i < BOUNDS_CHECK_PAD_SIZE; i += sizeof(unsigned int))
|
|
|
|
{
|
|
|
|
VPX_MEMCPY_L(x_bounds + i, &tempme, sizeof(unsigned int));
|
|
|
|
VPX_MEMCPY_L((unsigned char *)x + size + i,
|
|
|
|
&tempme, sizeof(unsigned int));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
x = NULL;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
x = vpx_realloc(memblk, size);
|
|
|
|
#endif //TRY_BOUNDS_CHECK
|
|
|
|
|
|
|
|
if (x)
|
|
|
|
vpx_memory_tracker_add((size_t)x, size, file, line, 1);
|
|
|
|
else
|
|
|
|
vpx_memory_tracker_add((size_t)memblk, orig_size, orig_file, orig_line, 1);
|
|
|
|
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
|
|
|
void xvpx_free(void *p_address, char *file, int line)
|
|
|
|
{
|
|
|
|
#if TRY_BOUNDS_CHECK
|
|
|
|
unsigned char *p_bounds_address = (unsigned char *)p_address;
|
|
|
|
//p_bounds_address -= BOUNDS_CHECK_PAD_SIZE;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if !TRY_BOUNDS_CHECK_ON_FREE
|
|
|
|
(void)file;
|
|
|
|
(void)line;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (p_address)
|
|
|
|
{
|
|
|
|
#if TRY_BOUNDS_CHECK_ON_FREE
|
|
|
|
vpx_memory_tracker_check_integrity(file, line);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
//if the addr isn't found in the list, assume it was allocated via
|
|
|
|
//vpx_ calls not xvpx_, therefore it does not contain any padding
|
|
|
|
if (vpx_memory_tracker_remove((size_t)p_address) == -2)
|
|
|
|
{
|
|
|
|
p_bounds_address = p_address;
|
|
|
|
_P(fprintf(stderr, "[vpx_mem][xvpx_free] addr: %p not found in"
|
|
|
|
" list; freed from file:%s"
|
|
|
|
" line:%d\n", p_address, file, line));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
--g_alloc_count;
|
|
|
|
|
|
|
|
#if TRY_BOUNDS_CHECK
|
|
|
|
vpx_free(p_bounds_address);
|
|
|
|
#else
|
|
|
|
vpx_free(p_address);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (!g_alloc_count)
|
|
|
|
vpx_memory_tracker_destroy();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /*CONFIG_MEM_TRACKER*/
|
|
|
|
|
|
|
|
#if CONFIG_MEM_CHECKS
|
|
|
|
#if defined(VXWORKS)
|
|
|
|
#include <task_lib.h> //for task_delay()
|
|
|
|
/* This function is only used to get a stack trace of the player
|
|
|
|
object so we can se where we are having a problem. */
|
|
|
|
static int get_my_tt(int task)
|
|
|
|
{
|
|
|
|
tt(task);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vx_sleep(int msec)
|
|
|
|
{
|
|
|
|
int ticks_to_sleep = 0;
|
|
|
|
|
|
|
|
if (msec)
|
|
|
|
{
|
|
|
|
int msec_per_tick = 1000 / sys_clk_rate_get();
|
|
|
|
|
|
|
|
if (msec < msec_per_tick)
|
|
|
|
ticks_to_sleep++;
|
|
|
|
else
|
|
|
|
ticks_to_sleep = msec / msec_per_tick;
|
|
|
|
}
|
|
|
|
|
|
|
|
task_delay(ticks_to_sleep);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
void *vpx_memcpy(void *dest, const void *source, size_t length)
|
|
|
|
{
|
|
|
|
#if CONFIG_MEM_CHECKS
|
|
|
|
|
|
|
|
if (((int)dest < 0x4000) || ((int)source < 0x4000))
|
|
|
|
{
|
|
|
|
_P(printf("WARNING: vpx_memcpy dest:0x%x source:0x%x len:%d\n", (int)dest, (int)source, length);)
|
|
|
|
|
|
|
|
#if defined(VXWORKS)
|
|
|
|
sp(get_my_tt, task_id_self(), 0, 0, 0, 0, 0, 0, 0, 0);
|
|
|
|
|
|
|
|
vx_sleep(10000);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return VPX_MEMCPY_L(dest, source, length);
|
|
|
|
}
|
|
|
|
|
|
|
|
void *vpx_memset(void *dest, int val, size_t length)
|
|
|
|
{
|
|
|
|
#if CONFIG_MEM_CHECKS
|
|
|
|
|
|
|
|
if ((int)dest < 0x4000)
|
|
|
|
{
|
|
|
|
_P(printf("WARNING: vpx_memset dest:0x%x val:%d len:%d\n", (int)dest, val, length);)
|
|
|
|
|
|
|
|
#if defined(VXWORKS)
|
|
|
|
sp(get_my_tt, task_id_self(), 0, 0, 0, 0, 0, 0, 0, 0);
|
|
|
|
|
|
|
|
vx_sleep(10000);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return VPX_MEMSET_L(dest, val, length);
|
|
|
|
}
|
|
|
|
|
|
|
|
void *vpx_memmove(void *dest, const void *src, size_t count)
|
|
|
|
{
|
|
|
|
#if CONFIG_MEM_CHECKS
|
|
|
|
|
|
|
|
if (((int)dest < 0x4000) || ((int)src < 0x4000))
|
|
|
|
{
|
|
|
|
_P(printf("WARNING: vpx_memmove dest:0x%x src:0x%x count:%d\n", (int)dest, (int)src, count);)
|
|
|
|
|
|
|
|
#if defined(VXWORKS)
|
|
|
|
sp(get_my_tt, task_id_self(), 0, 0, 0, 0, 0, 0, 0, 0);
|
|
|
|
|
|
|
|
vx_sleep(10000);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return VPX_MEMMOVE_L(dest, src, count);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if CONFIG_MEM_MANAGER
|
|
|
|
|
|
|
|
static int vpx_mm_create_heap_memory()
|
|
|
|
{
|
|
|
|
int i_rv = 0;
|
|
|
|
|
|
|
|
if (!g_mng_memory_allocated)
|
|
|
|
{
|
|
|
|
#if MM_DYNAMIC_MEMORY
|
|
|
|
g_p_mng_memory_raw =
|
|
|
|
(unsigned char *)malloc(g_mm_memory_size + HMM_ADDR_ALIGN_UNIT);
|
|
|
|
|
|
|
|
if (g_p_mng_memory_raw)
|
|
|
|
{
|
|
|
|
g_p_mng_memory = (unsigned char *)((((unsigned int)g_p_mng_memory_raw) +
|
|
|
|
HMM_ADDR_ALIGN_UNIT - 1) &
|
|
|
|
-(int)HMM_ADDR_ALIGN_UNIT);
|
|
|
|
|
|
|
|
_P(printf("[vpx][mm] total memory size:%d g_p_mng_memory_raw:0x%x g_p_mng_memory:0x%x\n"
|
|
|
|
, g_mm_memory_size + HMM_ADDR_ALIGN_UNIT
|
|
|
|
, (unsigned int)g_p_mng_memory_raw
|
|
|
|
, (unsigned int)g_p_mng_memory);)
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
_P(printf("[vpx][mm] Couldn't allocate memory:%d for vpx memory manager.\n"
|
|
|
|
, g_mm_memory_size);)
|
|
|
|
|
|
|
|
i_rv = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (g_p_mng_memory)
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
int chunk_size = 0;
|
|
|
|
|
|
|
|
g_mng_memory_allocated = 1;
|
|
|
|
|
|
|
|
hmm_init(&hmm_d);
|
|
|
|
|
|
|
|
chunk_size = g_mm_memory_size >> SHIFT_HMM_ADDR_ALIGN_UNIT;
|
|
|
|
|
|
|
|
chunk_size -= DUMMY_END_BLOCK_BAUS;
|
|
|
|
|
|
|
|
_P(printf("[vpx][mm] memory size:%d for vpx memory manager. g_p_mng_memory:0x%x chunk_size:%d\n"
|
|
|
|
, g_mm_memory_size
|
|
|
|
, (unsigned int)g_p_mng_memory
|
|
|
|
, chunk_size);)
|
|
|
|
|
|
|
|
hmm_new_chunk(&hmm_d, (void *)g_p_mng_memory, chunk_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if MM_DYNAMIC_MEMORY
|
|
|
|
else
|
|
|
|
{
|
|
|
|
_P(printf("[vpx][mm] Couldn't allocate memory:%d for vpx memory manager.\n"
|
|
|
|
, g_mm_memory_size);)
|
|
|
|
|
|
|
|
i_rv = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
return i_rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *vpx_mm_realloc(void *memblk, size_t size)
|
|
|
|
{
|
|
|
|
void *p_ret = NULL;
|
|
|
|
|
|
|
|
if (vpx_mm_create_heap_memory() < 0)
|
|
|
|
{
|
|
|
|
_P(printf("[vpx][mm] ERROR vpx_mm_realloc() Couldn't create memory for Heap.\n");)
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int i_rv = 0;
|
|
|
|
int old_num_aaus;
|
|
|
|
int new_num_aaus;
|
|
|
|
|
|
|
|
old_num_aaus = hmm_true_size(memblk);
|
|
|
|
new_num_aaus = (size >> SHIFT_HMM_ADDR_ALIGN_UNIT) + 1;
|
|
|
|
|
|
|
|
if (old_num_aaus == new_num_aaus)
|
|
|
|
{
|
|
|
|
p_ret = memblk;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
i_rv = hmm_resize(&hmm_d, memblk, new_num_aaus);
|
|
|
|
|
|
|
|
if (i_rv == 0)
|
|
|
|
{
|
|
|
|
p_ret = memblk;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Error. Try to malloc and then copy data. */
|
|
|
|
void *p_from_malloc;
|
|
|
|
|
|
|
|
new_num_aaus = (size >> SHIFT_HMM_ADDR_ALIGN_UNIT) + 1;
|
|
|
|
p_from_malloc = hmm_alloc(&hmm_d, new_num_aaus);
|
|
|
|
|
|
|
|
if (p_from_malloc)
|
|
|
|
{
|
|
|
|
vpx_memcpy(p_from_malloc, memblk, size);
|
|
|
|
hmm_free(&hmm_d, memblk);
|
|
|
|
|
|
|
|
p_ret = p_from_malloc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return p_ret;
|
|
|
|
}
|
|
|
|
#endif //CONFIG_MEM_MANAGER
|
|
|
|
|
|
|
|
#if USE_GLOBAL_FUNCTION_POINTERS
|
|
|
|
# if CONFIG_MEM_TRACKER
|
|
|
|
extern int vpx_memory_tracker_set_functions(g_malloc_func g_malloc_l
|
|
|
|
, g_calloc_func g_calloc_l
|
|
|
|
, g_realloc_func g_realloc_l
|
|
|
|
, g_free_func g_free_l
|
|
|
|
, g_memcpy_func g_memcpy_l
|
|
|
|
, g_memset_func g_memset_l
|
|
|
|
, g_memmove_func g_memmove_l);
|
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
int vpx_mem_set_functions(g_malloc_func g_malloc_l
|
|
|
|
, g_calloc_func g_calloc_l
|
|
|
|
, g_realloc_func g_realloc_l
|
|
|
|
, g_free_func g_free_l
|
|
|
|
, g_memcpy_func g_memcpy_l
|
|
|
|
, g_memset_func g_memset_l
|
|
|
|
, g_memmove_func g_memmove_l)
|
|
|
|
{
|
|
|
|
#if USE_GLOBAL_FUNCTION_POINTERS
|
|
|
|
|
|
|
|
/* If use global functions is turned on then the
|
|
|
|
application must set the global functions before
|
|
|
|
it does anything else or vpx_mem will have
|
|
|
|
unpredictable results. */
|
|
|
|
if (!g_func)
|
|
|
|
{
|
|
|
|
g_func = (struct GLOBAL_FUNC_POINTERS *)g_malloc_l(sizeof(struct GLOBAL_FUNC_POINTERS));
|
|
|
|
|
|
|
|
if (!g_func)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#if CONFIG_MEM_TRACKER
|
|
|
|
{
|
|
|
|
int rv = 0;
|
|
|
|
rv = vpx_memory_tracker_set_functions(g_malloc_l
|
|
|
|
, g_calloc_l
|
|
|
|
, g_realloc_l
|
|
|
|
, g_free_l
|
|
|
|
, g_memcpy_l
|
|
|
|
, g_memset_l
|
|
|
|
, g_memmove_l);
|
|
|
|
|
|
|
|
if (rv < 0)
|
|
|
|
{
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (g_malloc_l)
|
|
|
|
g_func->g_malloc = g_malloc_l;
|
|
|
|
else
|
|
|
|
g_func->g_malloc = 0;
|
|
|
|
|
|
|
|
if (g_calloc_l)
|
|
|
|
g_func->g_calloc = g_calloc_l;
|
|
|
|
else
|
|
|
|
g_func->g_calloc = 0;
|
|
|
|
|
|
|
|
if (g_realloc_l)
|
|
|
|
g_func->g_realloc = g_realloc_l;
|
|
|
|
else
|
|
|
|
g_func->g_realloc = 0;
|
|
|
|
|
|
|
|
if (g_free_l)
|
|
|
|
g_func->g_free = g_free_l;
|
|
|
|
else
|
|
|
|
g_func->g_free = 0;
|
|
|
|
|
|
|
|
if (g_memcpy_l)
|
|
|
|
g_func->g_memcpy = g_memcpy_l;
|
|
|
|
else
|
|
|
|
g_func->g_memcpy = 0;
|
|
|
|
|
|
|
|
if (g_memset_l)
|
|
|
|
g_func->g_memset = g_memset_l;
|
|
|
|
else
|
|
|
|
g_func->g_memset = 0;
|
|
|
|
|
|
|
|
if (g_memmove_l)
|
|
|
|
g_func->g_memmove = g_memmove_l;
|
|
|
|
else
|
|
|
|
g_func->g_memmove = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
#else
|
|
|
|
(void)g_malloc_l;
|
|
|
|
(void)g_calloc_l;
|
|
|
|
(void)g_realloc_l;
|
|
|
|
(void)g_free_l;
|
|
|
|
(void)g_memcpy_l;
|
|
|
|
(void)g_memset_l;
|
|
|
|
(void)g_memmove_l;
|
|
|
|
return -1;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
int vpx_mem_unset_functions()
|
|
|
|
{
|
|
|
|
#if USE_GLOBAL_FUNCTION_POINTERS
|
|
|
|
|
|
|
|
if (g_func)
|
|
|
|
{
|
|
|
|
g_free_func temp_free;
|
|
|
|
|
|
|
|
temp_free = g_func->g_free;
|
|
|
|
|
|
|
|
temp_free(g_func);
|
|
|
|
g_func = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef _INTEL_LINUX
|
|
|
|
void *_intel_fast_memcpy(void *dest, const void *src, size_t count)
|
|
|
|
{
|
|
|
|
|
|
|
|
//memcpy(dest, src, count);
|
|
|
|
char *dst8 = (char *)dest;
|
|
|
|
char *src8 = (char *)src;
|
|
|
|
|
|
|
|
while (count--)
|
|
|
|
{
|
|
|
|
*dst8++ = *src8++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return dest;
|
|
|
|
}
|
|
|
|
|
|
|
|
void *_intel_fast_memset(void *dest, int c, size_t count)
|
|
|
|
{
|
|
|
|
memset(dest, c, count);
|
|
|
|
return dest;
|
|
|
|
}
|
|
|
|
|
|
|
|
void *_VEC_memzero(void *dest, int c, size_t count)
|
|
|
|
{
|
|
|
|
memset(dest, 0, count);
|
|
|
|
return dest;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif //_ICC
|