YourWishes/jerryscript
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Renaming mem_* identifiers from 'camelCase' to 'underscore_naming'.

Browse Source
This commit is contained in:
Ruben Ayrapetyan
2014-07-23 12:21:07 +04:00
parent 2d4ed154ee
commit b3b4c74cbe
13 changed files with 307 additions and 307 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/liballocator/mem-heap.c
+155 -155
View File
@@ -36,18 +36,18 @@ typedef enum
{
MEM_MAGIC_NUM_OF_FREE_BLOCK = 0x31d7c809,
MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK = 0x59d75b46
} mem_MagicNumOfBlock_t;
} mem_magic_num_of_block_t;
/**
* State of the block to initialize (argument of mem_InitBlockHeader)
* State of the block to initialize (argument of mem_init_block_header)
*
* @see mem_InitBlockHeader
* @see mem_init_block_header
*/
typedef enum
{
MEM_BLOCK_FREE, /**< initializing free block */
MEM_BLOCK_ALLOCATED /**< initializing allocated block */
} mem_BlockState_t;
} mem_block_state_t;
/**
* Linked list direction descriptors
@@ -57,23 +57,23 @@ typedef enum
MEM_DIRECTION_PREV = 0, /**< direction from right to left */
MEM_DIRECTION_NEXT = 1, /**< direction from left to right */
MEM_DIRECTION_COUNT = 2 /**< count of possible directions */
} mem_Direction_t;
} mem_direction_t;
/**
* Description of heap memory block layout
*/
typedef struct mem_BlockHeader_t
typedef struct mem_block_header_t
{
mem_MagicNumOfBlock_t MagicNum; /**< magic number - MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK for allocated block
mem_magic_num_of_block_t MagicNum; /**< magic number - MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK for allocated block
and MEM_MAGIC_NUM_OF_FREE_BLOCK for free block */
struct mem_BlockHeader_t *Neighbours[ MEM_DIRECTION_COUNT ]; /**< neighbour blocks */
struct mem_block_header_t *Neighbours[ MEM_DIRECTION_COUNT ]; /**< neighbour blocks */
size_t allocated_bytes; /**< allocated area size - for allocated blocks; 0 - for free blocks */
} mem_BlockHeader_t;
} mem_block_header_t;
/**
* Chunk should have enough space for block header
*/
JERRY_STATIC_ASSERT( MEM_HEAP_CHUNK_SIZE >= sizeof (mem_BlockHeader_t) );
JERRY_STATIC_ASSERT( MEM_HEAP_CHUNK_SIZE >= sizeof (mem_block_header_t) );
/**
* Chunk size should satisfy the required alignment value
@@ -87,43 +87,43 @@ typedef struct
{
uint8_t* HeapStart; /**< first address of heap space */
size_t HeapSize; /**< heap space size */
mem_BlockHeader_t* pFirstBlock; /**< first block of the heap */
mem_BlockHeader_t* pLastBlock; /**< last block of the heap */
} mem_HeapState_t;
mem_block_header_t* pFirstBlock; /**< first block of the heap */
mem_block_header_t* pLastBlock; /**< last block of the heap */
} mem_heap_state_t;
/**
* Heap state
*/
mem_HeapState_t mem_Heap;
mem_heap_state_t mem_heap;
static size_t mem_get_block_chunks_count( const mem_BlockHeader_t *block_header_p);
static size_t mem_get_block_data_space_size( const mem_BlockHeader_t *block_header_p);
static size_t mem_get_block_chunks_count( const mem_block_header_t *block_header_p);
static size_t mem_get_block_data_space_size( const mem_block_header_t *block_header_p);
static size_t mem_get_block_chunks_count_from_data_size( size_t block_allocated_size);
static void mem_InitBlockHeader( uint8_t *pFirstChunk,
static void mem_init_block_header( uint8_t *pFirstChunk,
size_t sizeInChunks,
mem_BlockState_t blockState,
mem_BlockHeader_t *pPrevBlock,
mem_BlockHeader_t *pNextBlock);
static void mem_CheckHeap( void);
mem_block_state_t blockState,
mem_block_header_t *pPrevBlock,
mem_block_header_t *pNextBlock);
static void mem_check_heap( void);
#ifdef MEM_STATS
/**
* Heap's memory usage statistics
*/
static mem_HeapStats_t mem_HeapStats;
static mem_heap_stats_t mem_heap_stats;
static void mem_HeapStatInit( void);
static void mem_HeapStatAllocBlock( mem_BlockHeader_t *block_header_p);
static void mem_HeapStatFreeBlock( mem_BlockHeader_t *block_header_p);
static void mem_HeapStatFreeBlockSplit( void);
static void mem_HeapStatFreeBlockMerge( void);
static void mem_heap_stat_init( void);
static void mem_heap_stat_alloc_block( mem_block_header_t *block_header_p);
static void mem_heap_stat_free_block( mem_block_header_t *block_header_p);
static void mem_heap_stat_free_block_split( void);
static void mem_heap_stat_free_block_merge( void);
#else /* !MEM_STATS */
# define mem_HeapStatInit()
# define mem_HeapStatAllocBlock( v)
# define mem_HeapStatFreeBlock( v)
# define mem_HeapStatFreeBlockSplit()
# define mem_HeapStatFreeBlockMerge()
# define mem_heap_stat_init()
# define mem_heap_stat_alloc_block( v)
# define mem_heap_stat_free_block( v)
# define mem_heap_stat_free_block_split()
# define mem_heap_stat_free_block_merge()
#endif /* !MEM_STATS */
/**
@@ -132,22 +132,22 @@ static void mem_HeapStatFreeBlockMerge( void);
* @return chunks count
*/
static size_t
mem_get_block_chunks_count( const mem_BlockHeader_t *block_header_p) /**< block header */
mem_get_block_chunks_count( const mem_block_header_t *block_header_p) /**< block header */
{
JERRY_ASSERT( block_header_p != NULL );
const mem_BlockHeader_t *next_block_p = block_header_p->Neighbours[ MEM_DIRECTION_NEXT ];
const mem_block_header_t *next_block_p = block_header_p->Neighbours[ MEM_DIRECTION_NEXT ];
size_t dist_till_block_end;
if ( next_block_p == NULL )
{
dist_till_block_end = (size_t) ( mem_Heap.HeapStart + mem_Heap.HeapSize - (uint8_t*) block_header_p );
dist_till_block_end = (size_t) ( mem_heap.HeapStart + mem_heap.HeapSize - (uint8_t*) block_header_p );
} else
{
dist_till_block_end = (size_t) ( (uint8_t*) next_block_p - (uint8_t*) block_header_p );
}
JERRY_ASSERT( dist_till_block_end <= mem_Heap.HeapSize );
JERRY_ASSERT( dist_till_block_end <= mem_heap.HeapSize );
JERRY_ASSERT( dist_till_block_end % MEM_HEAP_CHUNK_SIZE == 0 );
return dist_till_block_end / MEM_HEAP_CHUNK_SIZE;
@@ -159,9 +159,9 @@ mem_get_block_chunks_count( const mem_BlockHeader_t *block_header_p) /**< block
* @return size of block area that can be used to store data
*/
static size_t
mem_get_block_data_space_size( const mem_BlockHeader_t *block_header_p) /**< block header */
mem_get_block_data_space_size( const mem_block_header_t *block_header_p) /**< block header */
{
return mem_get_block_chunks_count( block_header_p) * MEM_HEAP_CHUNK_SIZE - sizeof (mem_BlockHeader_t);
return mem_get_block_chunks_count( block_header_p) * MEM_HEAP_CHUNK_SIZE - sizeof (mem_block_header_t);
} /* mem_get_block_data_space_size */
/**
@@ -172,14 +172,14 @@ mem_get_block_data_space_size( const mem_BlockHeader_t *block_header_p) /**< blo
static size_t
mem_get_block_chunks_count_from_data_size( size_t block_allocated_size) /**< size of block's allocated area */
{
return JERRY_ALIGNUP( sizeof (mem_BlockHeader_t) + block_allocated_size, MEM_HEAP_CHUNK_SIZE) / MEM_HEAP_CHUNK_SIZE;
return JERRY_ALIGNUP( sizeof (mem_block_header_t) + block_allocated_size, MEM_HEAP_CHUNK_SIZE) / MEM_HEAP_CHUNK_SIZE;
} /* mem_get_block_chunks_count_from_data_size */
/**
* Startup initialization of heap
*/
void
mem_HeapInit(uint8_t *heapStart, /**< first address of heap space */
mem_heap_init(uint8_t *heapStart, /**< first address of heap space */
size_t heapSize) /**< heap space size */
{
JERRY_ASSERT( heapStart != NULL );
@@ -187,32 +187,32 @@ mem_HeapInit(uint8_t *heapStart, /**< first address of heap space */
JERRY_ASSERT( heapSize % MEM_HEAP_CHUNK_SIZE == 0 );
JERRY_ASSERT( (uintptr_t) heapStart % MEM_ALIGNMENT == 0);
mem_Heap.HeapStart = heapStart;
mem_Heap.HeapSize = heapSize;
mem_heap.HeapStart = heapStart;
mem_heap.HeapSize = heapSize;
mem_InitBlockHeader(mem_Heap.HeapStart,
mem_init_block_header(mem_heap.HeapStart,
0,
MEM_BLOCK_FREE,
NULL,
NULL);
mem_Heap.pFirstBlock = (mem_BlockHeader_t*) mem_Heap.HeapStart;
mem_Heap.pLastBlock = mem_Heap.pFirstBlock;
mem_heap.pFirstBlock = (mem_block_header_t*) mem_heap.HeapStart;
mem_heap.pLastBlock = mem_heap.pFirstBlock;
mem_HeapStatInit();
} /* mem_HeapInit */
mem_heap_stat_init();
} /* mem_heap_init */
/**
* Initialize block header
*/
static void
mem_InitBlockHeader( uint8_t *pFirstChunk, /**< address of the first chunk to use for the block */
mem_init_block_header( uint8_t *pFirstChunk, /**< address of the first chunk to use for the block */
size_t allocated_bytes, /**< size of block's allocated area */
mem_BlockState_t blockState, /**< state of the block (allocated or free) */
mem_BlockHeader_t *pPrevBlock, /**< previous block */
mem_BlockHeader_t *pNextBlock) /**< next block */
mem_block_state_t blockState, /**< state of the block (allocated or free) */
mem_block_header_t *pPrevBlock, /**< previous block */
mem_block_header_t *pNextBlock) /**< next block */
{
mem_BlockHeader_t *pBlockHeader = (mem_BlockHeader_t*) pFirstChunk;
mem_block_header_t *pBlockHeader = (mem_block_header_t*) pFirstChunk;
if ( blockState == MEM_BLOCK_FREE )
{
@@ -229,7 +229,7 @@ mem_InitBlockHeader( uint8_t *pFirstChunk, /**< address of the first chu
pBlockHeader->allocated_bytes = allocated_bytes;
JERRY_ASSERT( allocated_bytes <= mem_get_block_data_space_size( pBlockHeader) );
} /* mem_InitBlockHeader */
} /* mem_init_block_header */
/**
* Allocation of memory region.
@@ -245,21 +245,21 @@ mem_InitBlockHeader( uint8_t *pFirstChunk, /**< address of the first chu
* NULL - if there is not enough memory.
*/
uint8_t*
mem_HeapAllocBlock( size_t sizeInBytes, /**< size of region to allocate in bytes */
mem_HeapAllocTerm_t allocTerm) /**< expected allocation term */
mem_heap_alloc_block( size_t sizeInBytes, /**< size of region to allocate in bytes */
mem_heap_alloc_term_t allocTerm) /**< expected allocation term */
{
mem_BlockHeader_t *pBlock;
mem_Direction_t direction;
mem_block_header_t *pBlock;
mem_direction_t direction;
mem_CheckHeap();
mem_check_heap();
if ( allocTerm == MEM_HEAP_ALLOC_SHORT_TERM )
{
pBlock = mem_Heap.pFirstBlock;
pBlock = mem_heap.pFirstBlock;
direction = MEM_DIRECTION_NEXT;
} else
{
pBlock = mem_Heap.pLastBlock;
pBlock = mem_heap.pLastBlock;
direction = MEM_DIRECTION_PREV;
}
@@ -292,66 +292,66 @@ mem_HeapAllocBlock( size_t sizeInBytes, /**< size of region to allocat
JERRY_ASSERT( newBlockSizeInChunks <= foundBlockSizeInChunks );
mem_BlockHeader_t *pPrevBlock = pBlock->Neighbours[ MEM_DIRECTION_PREV ];
mem_BlockHeader_t *pNextBlock = pBlock->Neighbours[ MEM_DIRECTION_NEXT ];
mem_block_header_t *pPrevBlock = pBlock->Neighbours[ MEM_DIRECTION_PREV ];
mem_block_header_t *pNextBlock = pBlock->Neighbours[ MEM_DIRECTION_NEXT ];
if ( newBlockSizeInChunks < foundBlockSizeInChunks )
{
mem_HeapStatFreeBlockSplit();
mem_heap_stat_free_block_split();
uint8_t *pNewFreeBlockFirstChunk = (uint8_t*) pBlock + newBlockSizeInChunks * MEM_HEAP_CHUNK_SIZE;
mem_InitBlockHeader(pNewFreeBlockFirstChunk,
mem_init_block_header(pNewFreeBlockFirstChunk,
0,
MEM_BLOCK_FREE,
pBlock /* there we will place new allocated block */,
pNextBlock);
mem_BlockHeader_t *pNewFreeBlock = (mem_BlockHeader_t*) pNewFreeBlockFirstChunk;
mem_block_header_t *pNewFreeBlock = (mem_block_header_t*) pNewFreeBlockFirstChunk;
if ( pNextBlock == NULL )
{
mem_Heap.pLastBlock = pNewFreeBlock;
mem_heap.pLastBlock = pNewFreeBlock;
}
pNextBlock = pNewFreeBlock;
}
mem_InitBlockHeader((uint8_t*) pBlock,
mem_init_block_header((uint8_t*) pBlock,
sizeInBytes,
MEM_BLOCK_ALLOCATED,
pPrevBlock,
pNextBlock);
mem_HeapStatAllocBlock( pBlock);
mem_heap_stat_alloc_block( pBlock);
JERRY_ASSERT( mem_get_block_data_space_size( pBlock) >= sizeInBytes );
mem_CheckHeap();
mem_check_heap();
/* return data space beginning address */
uint8_t *pDataSpace = (uint8_t*) (pBlock + 1);
JERRY_ASSERT( (uintptr_t) pDataSpace % MEM_ALIGNMENT == 0);
return pDataSpace;
} /* mem_HeapAllocBlock */
} /* mem_heap_alloc_block */
/**
* Free the memory block.
*/
void
mem_HeapFreeBlock( uint8_t *ptr) /**< pointer to beginning of data space of the block */
mem_heap_free_block( uint8_t *ptr) /**< pointer to beginning of data space of the block */
{
/* checking that ptr points to the heap */
JERRY_ASSERT( ptr >= mem_Heap.HeapStart
&& ptr <= mem_Heap.HeapStart + mem_Heap.HeapSize );
JERRY_ASSERT( ptr >= mem_heap.HeapStart
&& ptr <= mem_heap.HeapStart + mem_heap.HeapSize );
mem_CheckHeap();
mem_check_heap();
mem_BlockHeader_t *pBlock = (mem_BlockHeader_t*) ptr - 1;
mem_BlockHeader_t *pPrevBlock = pBlock->Neighbours[ MEM_DIRECTION_PREV ];
mem_BlockHeader_t *pNextBlock = pBlock->Neighbours[ MEM_DIRECTION_NEXT ];
mem_block_header_t *pBlock = (mem_block_header_t*) ptr - 1;
mem_block_header_t *pPrevBlock = pBlock->Neighbours[ MEM_DIRECTION_PREV ];
mem_block_header_t *pNextBlock = pBlock->Neighbours[ MEM_DIRECTION_NEXT ];
mem_HeapStatFreeBlock( pBlock);
mem_heap_stat_free_block( pBlock);
/* checking magic nums that are neighbour to data space */
JERRY_ASSERT( pBlock->MagicNum == MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK );
@@ -367,7 +367,7 @@ mem_HeapFreeBlock( uint8_t *ptr) /**< pointer to beginning of data space of the
&& pNextBlock->MagicNum == MEM_MAGIC_NUM_OF_FREE_BLOCK )
{
/* merge with the next block */
mem_HeapStatFreeBlockMerge();
mem_heap_stat_free_block_merge();
pNextBlock = pNextBlock->Neighbours[ MEM_DIRECTION_NEXT ];
pBlock->Neighbours[ MEM_DIRECTION_NEXT ] = pNextBlock;
@@ -376,7 +376,7 @@ mem_HeapFreeBlock( uint8_t *ptr) /**< pointer to beginning of data space of the
pNextBlock->Neighbours[ MEM_DIRECTION_PREV ] = pBlock;
} else
{
mem_Heap.pLastBlock = pBlock;
mem_heap.pLastBlock = pBlock;
}
}
@@ -384,7 +384,7 @@ mem_HeapFreeBlock( uint8_t *ptr) /**< pointer to beginning of data space of the
&& pPrevBlock->MagicNum == MEM_MAGIC_NUM_OF_FREE_BLOCK )
{
/* merge with the previous block */
mem_HeapStatFreeBlockMerge();
mem_heap_stat_free_block_merge();
pPrevBlock->Neighbours[ MEM_DIRECTION_NEXT ] = pNextBlock;
if ( pNextBlock != NULL )
@@ -392,12 +392,12 @@ mem_HeapFreeBlock( uint8_t *ptr) /**< pointer to beginning of data space of the
pNextBlock->Neighbours[ MEM_DIRECTION_PREV ] = pBlock->Neighbours[ MEM_DIRECTION_PREV ];
} else
{
mem_Heap.pLastBlock = pPrevBlock;
mem_heap.pLastBlock = pPrevBlock;
}
}
mem_CheckHeap();
} /* mem_HeapFreeBlock */
mem_check_heap();
} /* mem_heap_free_block */
/**
* Recommend allocation size based on chunk size.
@@ -405,30 +405,30 @@ mem_HeapFreeBlock( uint8_t *ptr) /**< pointer to beginning of data space of the
* @return recommended allocation size
*/
size_t
mem_HeapRecommendAllocationSize( size_t minimumAllocationSize) /**< minimum allocation size */
mem_heap_recommend_allocation_size( size_t minimumAllocationSize) /**< minimum allocation size */
{
size_t minimumAllocationSizeWithBlockHeader = minimumAllocationSize + sizeof (mem_BlockHeader_t);
size_t minimumAllocationSizeWithBlockHeader = minimumAllocationSize + sizeof (mem_block_header_t);
size_t heapChunkAlignedAllocationSize = JERRY_ALIGNUP( minimumAllocationSizeWithBlockHeader, MEM_HEAP_CHUNK_SIZE);
return heapChunkAlignedAllocationSize - sizeof (mem_BlockHeader_t);
} /* mem_HeapRecommendAllocationSize */
return heapChunkAlignedAllocationSize - sizeof (mem_block_header_t);
} /* mem_heap_recommend_allocation_size */
/**
* Print heap
*/
void
mem_HeapPrint( bool dumpBlockData) /**< print block with data (true)
mem_heap_print( bool dumpBlockData) /**< print block with data (true)
or print only block header (false) */
{
mem_CheckHeap();
mem_check_heap();
__printf("Heap: start=%p size=%lu, first block->%p, last block->%p\n",
mem_Heap.HeapStart,
mem_Heap.HeapSize,
(void*) mem_Heap.pFirstBlock,
(void*) mem_Heap.pLastBlock);
mem_heap.HeapStart,
mem_heap.HeapSize,
(void*) mem_heap.pFirstBlock,
(void*) mem_heap.pLastBlock);
for ( mem_BlockHeader_t *pBlock = mem_Heap.pFirstBlock;
for ( mem_block_header_t *pBlock = mem_heap.pFirstBlock;
pBlock != NULL;
pBlock = pBlock->Neighbours[ MEM_DIRECTION_NEXT ] )
{
@@ -464,16 +464,16 @@ mem_HeapPrint( bool dumpBlockData) /**< print block with data (true)
" Peak allocated chunks count = %lu\n"
" Peak allocated bytes count = %lu\n"
" Peak waste bytes count = %lu\n",
mem_HeapStats.size,
mem_HeapStats.blocks,
mem_HeapStats.allocated_blocks,
mem_HeapStats.allocated_chunks,
mem_HeapStats.allocated_bytes,
mem_HeapStats.waste_bytes,
mem_HeapStats.peak_allocated_blocks,
mem_HeapStats.peak_allocated_chunks,
mem_HeapStats.peak_allocated_bytes,
mem_HeapStats.peak_waste_bytes);
mem_heap_stats.size,
mem_heap_stats.blocks,
mem_heap_stats.allocated_blocks,
mem_heap_stats.allocated_chunks,
mem_heap_stats.allocated_bytes,
mem_heap_stats.waste_bytes,
mem_heap_stats.peak_allocated_blocks,
mem_heap_stats.peak_allocated_chunks,
mem_heap_stats.peak_allocated_bytes,
mem_heap_stats.peak_waste_bytes);
#endif /* MEM_STATS */
__printf("\n");
@@ -483,14 +483,14 @@ mem_HeapPrint( bool dumpBlockData) /**< print block with data (true)
* Check heap consistency
*/
static void
mem_CheckHeap( void)
mem_check_heap( void)
{
#ifndef JERRY_NDEBUG
JERRY_ASSERT( (uint8_t*) mem_Heap.pFirstBlock == mem_Heap.HeapStart );
JERRY_ASSERT( mem_Heap.HeapSize % MEM_HEAP_CHUNK_SIZE == 0 );
JERRY_ASSERT( (uint8_t*) mem_heap.pFirstBlock == mem_heap.HeapStart );
JERRY_ASSERT( mem_heap.HeapSize % MEM_HEAP_CHUNK_SIZE == 0 );
bool isLastBlockWasMet = false;
for ( mem_BlockHeader_t *pBlock = mem_Heap.pFirstBlock;
for ( mem_block_header_t *pBlock = mem_heap.pFirstBlock;
pBlock != NULL;
pBlock = pBlock->Neighbours[ MEM_DIRECTION_NEXT ] )
{
@@ -498,8 +498,8 @@ mem_CheckHeap( void)
JERRY_ASSERT( pBlock->MagicNum == MEM_MAGIC_NUM_OF_FREE_BLOCK
|| pBlock->MagicNum == MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK );
mem_BlockHeader_t *pNextBlock = pBlock->Neighbours[ MEM_DIRECTION_NEXT ];
if ( pBlock == mem_Heap.pLastBlock )
mem_block_header_t *pNextBlock = pBlock->Neighbours[ MEM_DIRECTION_NEXT ];
if ( pBlock == mem_heap.pLastBlock )
{
isLastBlockWasMet = true;
@@ -512,35 +512,35 @@ mem_CheckHeap( void)
JERRY_ASSERT( isLastBlockWasMet );
#endif /* !JERRY_NDEBUG */
} /* mem_CheckHeap */
} /* mem_check_heap */
#ifdef MEM_STATS
/**
* Get heap memory usage statistics
*/
void
mem_HeapGetStats( mem_HeapStats_t *out_heap_stats_p) /**< out: heap stats */
mem_heap_get_stats( mem_heap_stats_t *out_heap_stats_p) /**< out: heap stats */
{
*out_heap_stats_p = mem_HeapStats;
} /* mem_HeapGetStats */
*out_heap_stats_p = mem_heap_stats;
} /* mem_heap_get_stats */
/**
* Initalize heap memory usage statistics account structure
*/
static void
mem_HeapStatInit()
mem_heap_stat_init()
{
__memset( &mem_HeapStats, 0, sizeof (mem_HeapStats));
__memset( &mem_heap_stats, 0, sizeof (mem_heap_stats));
mem_HeapStats.size = mem_Heap.HeapSize;
mem_HeapStats.blocks = 1;
mem_heap_stats.size = mem_heap.HeapSize;
mem_heap_stats.blocks = 1;
} /* mem_InitStats */
/**
* Account block allocation
*/
static void
mem_HeapStatAllocBlock( mem_BlockHeader_t *block_header_p) /**< allocated block */
mem_heap_stat_alloc_block( mem_block_header_t *block_header_p) /**< allocated block */
{
JERRY_ASSERT( block_header_p->MagicNum == MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK );
@@ -548,41 +548,41 @@ mem_HeapStatAllocBlock( mem_BlockHeader_t *block_header_p) /**< allocated block
const size_t bytes = block_header_p->allocated_bytes;
const size_t waste_bytes = chunks * MEM_HEAP_CHUNK_SIZE - bytes;
mem_HeapStats.allocated_blocks++;
mem_HeapStats.allocated_chunks += chunks;
mem_HeapStats.allocated_bytes += bytes;
mem_HeapStats.waste_bytes += waste_bytes;
mem_heap_stats.allocated_blocks++;
mem_heap_stats.allocated_chunks += chunks;
mem_heap_stats.allocated_bytes += bytes;
mem_heap_stats.waste_bytes += waste_bytes;
if ( mem_HeapStats.allocated_blocks > mem_HeapStats.peak_allocated_blocks )
if ( mem_heap_stats.allocated_blocks > mem_heap_stats.peak_allocated_blocks )
{
mem_HeapStats.peak_allocated_blocks = mem_HeapStats.allocated_blocks;
mem_heap_stats.peak_allocated_blocks = mem_heap_stats.allocated_blocks;
}
if ( mem_HeapStats.allocated_chunks > mem_HeapStats.peak_allocated_chunks )
if ( mem_heap_stats.allocated_chunks > mem_heap_stats.peak_allocated_chunks )
{
mem_HeapStats.peak_allocated_chunks = mem_HeapStats.allocated_chunks;
mem_heap_stats.peak_allocated_chunks = mem_heap_stats.allocated_chunks;
}
if ( mem_HeapStats.allocated_bytes > mem_HeapStats.peak_allocated_bytes )
if ( mem_heap_stats.allocated_bytes > mem_heap_stats.peak_allocated_bytes )
{
mem_HeapStats.peak_allocated_bytes = mem_HeapStats.allocated_bytes;
mem_heap_stats.peak_allocated_bytes = mem_heap_stats.allocated_bytes;
}
if ( mem_HeapStats.waste_bytes > mem_HeapStats.peak_waste_bytes )
if ( mem_heap_stats.waste_bytes > mem_heap_stats.peak_waste_bytes )
{
mem_HeapStats.peak_waste_bytes = mem_HeapStats.waste_bytes;
mem_heap_stats.peak_waste_bytes = mem_heap_stats.waste_bytes;
}
JERRY_ASSERT( mem_HeapStats.allocated_blocks <= mem_HeapStats.blocks );
JERRY_ASSERT( mem_HeapStats.allocated_bytes <= mem_HeapStats.size );
JERRY_ASSERT( mem_HeapStats.allocated_chunks <= mem_HeapStats.size / MEM_HEAP_CHUNK_SIZE );
} /* mem_HeapStatAllocBlock */
JERRY_ASSERT( mem_heap_stats.allocated_blocks <= mem_heap_stats.blocks );
JERRY_ASSERT( mem_heap_stats.allocated_bytes <= mem_heap_stats.size );
JERRY_ASSERT( mem_heap_stats.allocated_chunks <= mem_heap_stats.size / MEM_HEAP_CHUNK_SIZE );
} /* mem_heap_stat_alloc_block */
/**
* Account block freeing
*/
static void
mem_HeapStatFreeBlock( mem_BlockHeader_t *block_header_p) /**< block to be freed */
mem_heap_stat_free_block( mem_block_header_t *block_header_p) /**< block to be freed */
{
JERRY_ASSERT( block_header_p->MagicNum == MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK );
@@ -590,38 +590,38 @@ mem_HeapStatFreeBlock( mem_BlockHeader_t *block_header_p) /**< block to be freed
const size_t bytes = block_header_p->allocated_bytes;
const size_t waste_bytes = chunks * MEM_HEAP_CHUNK_SIZE - bytes;
JERRY_ASSERT( mem_HeapStats.allocated_blocks <= mem_HeapStats.blocks );
JERRY_ASSERT( mem_HeapStats.allocated_bytes <= mem_HeapStats.size );
JERRY_ASSERT( mem_HeapStats.allocated_chunks <= mem_HeapStats.size / MEM_HEAP_CHUNK_SIZE );
JERRY_ASSERT( mem_heap_stats.allocated_blocks <= mem_heap_stats.blocks );
JERRY_ASSERT( mem_heap_stats.allocated_bytes <= mem_heap_stats.size );
JERRY_ASSERT( mem_heap_stats.allocated_chunks <= mem_heap_stats.size / MEM_HEAP_CHUNK_SIZE );
JERRY_ASSERT( mem_HeapStats.allocated_blocks >= 1 );
JERRY_ASSERT( mem_HeapStats.allocated_chunks >= chunks );
JERRY_ASSERT( mem_HeapStats.allocated_bytes >= bytes );
JERRY_ASSERT( mem_HeapStats.waste_bytes >= waste_bytes );
JERRY_ASSERT( mem_heap_stats.allocated_blocks >= 1 );
JERRY_ASSERT( mem_heap_stats.allocated_chunks >= chunks );
JERRY_ASSERT( mem_heap_stats.allocated_bytes >= bytes );
JERRY_ASSERT( mem_heap_stats.waste_bytes >= waste_bytes );
mem_HeapStats.allocated_blocks--;
mem_HeapStats.allocated_chunks -= chunks;
mem_HeapStats.allocated_bytes -= bytes;
mem_HeapStats.waste_bytes -= waste_bytes;
} /* mem_HeapStatFreeBlock */
mem_heap_stats.allocated_blocks--;
mem_heap_stats.allocated_chunks -= chunks;
mem_heap_stats.allocated_bytes -= bytes;
mem_heap_stats.waste_bytes -= waste_bytes;
} /* mem_heap_stat_free_block */
/**
* Account free block split
*/
static void
mem_HeapStatFreeBlockSplit( void)
mem_heap_stat_free_block_split( void)
{
mem_HeapStats.blocks++;
} /* mem_HeapStatFreeBlockSplit */
mem_heap_stats.blocks++;
} /* mem_heap_stat_free_block_split */
/**
* Account free block merge
*/
static void
mem_HeapStatFreeBlockMerge( void)
mem_heap_stat_free_block_merge( void)
{
mem_HeapStats.blocks--;
} /* mem_HeapStatFreeBlockMerge */
mem_heap_stats.blocks--;
} /* mem_heap_stat_free_block_merge */
#endif /* MEM_STATS */
/**