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

Removing m_ prefix from identifiers (m_ValueType -> ValueType, ...).

Browse Source
This commit is contained in:
Ruben Ayrapetyan
2014-07-23 11:41:58 +04:00
parent 3ef9ee9eb4
commit 2d4ed154ee
14 changed files with 370 additions and 370 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/liballocator/mem-heap.c
+65 -65
View File
@@ -64,10 +64,10 @@ typedef enum
*/
typedef struct mem_BlockHeader_t
{
mem_MagicNumOfBlock_t m_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 *m_Neighbours[ MEM_DIRECTION_COUNT ]; /**< neighbour blocks */
size_t allocated_bytes; /**< allocated area size - for allocated blocks; 0 - for free blocks */
mem_MagicNumOfBlock_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 */
size_t allocated_bytes; /**< allocated area size - for allocated blocks; 0 - for free blocks */
} mem_BlockHeader_t;
/**
@@ -85,10 +85,10 @@ JERRY_STATIC_ASSERT( MEM_HEAP_CHUNK_SIZE % MEM_ALIGNMENT == 0 );
*/
typedef struct
{
uint8_t* m_HeapStart; /**< first address of heap space */
size_t m_HeapSize; /**< heap space size */
mem_BlockHeader_t* m_pFirstBlock; /**< first block of the heap */
mem_BlockHeader_t* m_pLastBlock; /**< last block of the heap */
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;
/**
@@ -136,18 +136,18 @@ mem_get_block_chunks_count( const mem_BlockHeader_t *block_header_p) /**< block
{
JERRY_ASSERT( block_header_p != NULL );
const mem_BlockHeader_t *next_block_p = block_header_p->m_Neighbours[ MEM_DIRECTION_NEXT ];
const mem_BlockHeader_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.m_HeapStart + mem_Heap.m_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.m_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;
@@ -187,17 +187,17 @@ 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.m_HeapStart = heapStart;
mem_Heap.m_HeapSize = heapSize;
mem_Heap.HeapStart = heapStart;
mem_Heap.HeapSize = heapSize;
mem_InitBlockHeader(mem_Heap.m_HeapStart,
mem_InitBlockHeader(mem_Heap.HeapStart,
0,
MEM_BLOCK_FREE,
NULL,
NULL);
mem_Heap.m_pFirstBlock = (mem_BlockHeader_t*) mem_Heap.m_HeapStart;
mem_Heap.m_pLastBlock = mem_Heap.m_pFirstBlock;
mem_Heap.pFirstBlock = (mem_BlockHeader_t*) mem_Heap.HeapStart;
mem_Heap.pLastBlock = mem_Heap.pFirstBlock;
mem_HeapStatInit();
} /* mem_HeapInit */
@@ -216,16 +216,16 @@ mem_InitBlockHeader( uint8_t *pFirstChunk, /**< address of the first chu
if ( blockState == MEM_BLOCK_FREE )
{
pBlockHeader->m_MagicNum = MEM_MAGIC_NUM_OF_FREE_BLOCK;
pBlockHeader->MagicNum = MEM_MAGIC_NUM_OF_FREE_BLOCK;
JERRY_ASSERT( allocated_bytes == 0 );
} else
{
pBlockHeader->m_MagicNum = MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK;
pBlockHeader->MagicNum = MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK;
}
pBlockHeader->m_Neighbours[ MEM_DIRECTION_PREV ] = pPrevBlock;
pBlockHeader->m_Neighbours[ MEM_DIRECTION_NEXT ] = pNextBlock;
pBlockHeader->Neighbours[ MEM_DIRECTION_PREV ] = pPrevBlock;
pBlockHeader->Neighbours[ MEM_DIRECTION_NEXT ] = pNextBlock;
pBlockHeader->allocated_bytes = allocated_bytes;
JERRY_ASSERT( allocated_bytes <= mem_get_block_data_space_size( pBlockHeader) );
@@ -255,18 +255,18 @@ mem_HeapAllocBlock( size_t sizeInBytes, /**< size of region to allocat
if ( allocTerm == MEM_HEAP_ALLOC_SHORT_TERM )
{
pBlock = mem_Heap.m_pFirstBlock;
pBlock = mem_Heap.pFirstBlock;
direction = MEM_DIRECTION_NEXT;
} else
{
pBlock = mem_Heap.m_pLastBlock;
pBlock = mem_Heap.pLastBlock;
direction = MEM_DIRECTION_PREV;
}
/* searching for appropriate block */
while ( pBlock != NULL )
{
if ( pBlock->m_MagicNum == MEM_MAGIC_NUM_OF_FREE_BLOCK )
if ( pBlock->MagicNum == MEM_MAGIC_NUM_OF_FREE_BLOCK )
{
if ( mem_get_block_data_space_size( pBlock) >= sizeInBytes )
{
@@ -274,10 +274,10 @@ mem_HeapAllocBlock( size_t sizeInBytes, /**< size of region to allocat
}
} else
{
JERRY_ASSERT( pBlock->m_MagicNum == MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK );
JERRY_ASSERT( pBlock->MagicNum == MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK );
}
pBlock = pBlock->m_Neighbours[ direction ];
pBlock = pBlock->Neighbours[ direction ];
}
if ( pBlock == NULL )
@@ -292,8 +292,8 @@ mem_HeapAllocBlock( size_t sizeInBytes, /**< size of region to allocat
JERRY_ASSERT( newBlockSizeInChunks <= foundBlockSizeInChunks );
mem_BlockHeader_t *pPrevBlock = pBlock->m_Neighbours[ MEM_DIRECTION_PREV ];
mem_BlockHeader_t *pNextBlock = pBlock->m_Neighbours[ MEM_DIRECTION_NEXT ];
mem_BlockHeader_t *pPrevBlock = pBlock->Neighbours[ MEM_DIRECTION_PREV ];
mem_BlockHeader_t *pNextBlock = pBlock->Neighbours[ MEM_DIRECTION_NEXT ];
if ( newBlockSizeInChunks < foundBlockSizeInChunks )
{
@@ -310,7 +310,7 @@ mem_HeapAllocBlock( size_t sizeInBytes, /**< size of region to allocat
if ( pNextBlock == NULL )
{
mem_Heap.m_pLastBlock = pNewFreeBlock;
mem_Heap.pLastBlock = pNewFreeBlock;
}
pNextBlock = pNewFreeBlock;
@@ -342,57 +342,57 @@ void
mem_HeapFreeBlock( uint8_t *ptr) /**< pointer to beginning of data space of the block */
{
/* checking that ptr points to the heap */
JERRY_ASSERT( ptr >= mem_Heap.m_HeapStart
&& ptr <= mem_Heap.m_HeapStart + mem_Heap.m_HeapSize );
JERRY_ASSERT( ptr >= mem_Heap.HeapStart
&& ptr <= mem_Heap.HeapStart + mem_Heap.HeapSize );
mem_CheckHeap();
mem_BlockHeader_t *pBlock = (mem_BlockHeader_t*) ptr - 1;
mem_BlockHeader_t *pPrevBlock = pBlock->m_Neighbours[ MEM_DIRECTION_PREV ];
mem_BlockHeader_t *pNextBlock = pBlock->m_Neighbours[ MEM_DIRECTION_NEXT ];
mem_BlockHeader_t *pPrevBlock = pBlock->Neighbours[ MEM_DIRECTION_PREV ];
mem_BlockHeader_t *pNextBlock = pBlock->Neighbours[ MEM_DIRECTION_NEXT ];
mem_HeapStatFreeBlock( pBlock);
/* checking magic nums that are neighbour to data space */
JERRY_ASSERT( pBlock->m_MagicNum == MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK );
JERRY_ASSERT( pBlock->MagicNum == MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK );
if ( pNextBlock != NULL )
{
JERRY_ASSERT( pNextBlock->m_MagicNum == MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK
|| pNextBlock->m_MagicNum == MEM_MAGIC_NUM_OF_FREE_BLOCK );
JERRY_ASSERT( pNextBlock->MagicNum == MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK
|| pNextBlock->MagicNum == MEM_MAGIC_NUM_OF_FREE_BLOCK );
}
pBlock->m_MagicNum = MEM_MAGIC_NUM_OF_FREE_BLOCK;
pBlock->MagicNum = MEM_MAGIC_NUM_OF_FREE_BLOCK;
if ( pNextBlock != NULL
&& pNextBlock->m_MagicNum == MEM_MAGIC_NUM_OF_FREE_BLOCK )
&& pNextBlock->MagicNum == MEM_MAGIC_NUM_OF_FREE_BLOCK )
{
/* merge with the next block */
mem_HeapStatFreeBlockMerge();
pNextBlock = pNextBlock->m_Neighbours[ MEM_DIRECTION_NEXT ];
pBlock->m_Neighbours[ MEM_DIRECTION_NEXT ] = pNextBlock;
pNextBlock = pNextBlock->Neighbours[ MEM_DIRECTION_NEXT ];
pBlock->Neighbours[ MEM_DIRECTION_NEXT ] = pNextBlock;
if ( pNextBlock != NULL )
{
pNextBlock->m_Neighbours[ MEM_DIRECTION_PREV ] = pBlock;
pNextBlock->Neighbours[ MEM_DIRECTION_PREV ] = pBlock;
} else
{
mem_Heap.m_pLastBlock = pBlock;
mem_Heap.pLastBlock = pBlock;
}
}
if ( pPrevBlock != NULL
&& pPrevBlock->m_MagicNum == MEM_MAGIC_NUM_OF_FREE_BLOCK )
&& pPrevBlock->MagicNum == MEM_MAGIC_NUM_OF_FREE_BLOCK )
{
/* merge with the previous block */
mem_HeapStatFreeBlockMerge();
pPrevBlock->m_Neighbours[ MEM_DIRECTION_NEXT ] = pNextBlock;
pPrevBlock->Neighbours[ MEM_DIRECTION_NEXT ] = pNextBlock;
if ( pNextBlock != NULL )
{
pNextBlock->m_Neighbours[ MEM_DIRECTION_PREV ] = pBlock->m_Neighbours[ MEM_DIRECTION_PREV ];
pNextBlock->Neighbours[ MEM_DIRECTION_PREV ] = pBlock->Neighbours[ MEM_DIRECTION_PREV ];
} else
{
mem_Heap.m_pLastBlock = pPrevBlock;
mem_Heap.pLastBlock = pPrevBlock;
}
}
@@ -423,21 +423,21 @@ mem_HeapPrint( bool dumpBlockData) /**< print block with data (true)
mem_CheckHeap();
__printf("Heap: start=%p size=%lu, first block->%p, last block->%p\n",
mem_Heap.m_HeapStart,
mem_Heap.m_HeapSize,
(void*) mem_Heap.m_pFirstBlock,
(void*) mem_Heap.m_pLastBlock);
mem_Heap.HeapStart,
mem_Heap.HeapSize,
(void*) mem_Heap.pFirstBlock,
(void*) mem_Heap.pLastBlock);
for ( mem_BlockHeader_t *pBlock = mem_Heap.m_pFirstBlock;
for ( mem_BlockHeader_t *pBlock = mem_Heap.pFirstBlock;
pBlock != NULL;
pBlock = pBlock->m_Neighbours[ MEM_DIRECTION_NEXT ] )
pBlock = pBlock->Neighbours[ MEM_DIRECTION_NEXT ] )
{
__printf("Block (%p): magic num=0x%08x, size in chunks=%lu, previous block->%p next block->%p\n",
(void*) pBlock,
pBlock->m_MagicNum,
pBlock->MagicNum,
mem_get_block_chunks_count( pBlock),
(void*) pBlock->m_Neighbours[ MEM_DIRECTION_PREV ],
(void*) pBlock->m_Neighbours[ MEM_DIRECTION_NEXT ]);
(void*) pBlock->Neighbours[ MEM_DIRECTION_PREV ],
(void*) pBlock->Neighbours[ MEM_DIRECTION_NEXT ]);
if ( dumpBlockData )
{
@@ -486,20 +486,20 @@ static void
mem_CheckHeap( void)
{
#ifndef JERRY_NDEBUG
JERRY_ASSERT( (uint8_t*) mem_Heap.m_pFirstBlock == mem_Heap.m_HeapStart );
JERRY_ASSERT( mem_Heap.m_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.m_pFirstBlock;
for ( mem_BlockHeader_t *pBlock = mem_Heap.pFirstBlock;
pBlock != NULL;
pBlock = pBlock->m_Neighbours[ MEM_DIRECTION_NEXT ] )
pBlock = pBlock->Neighbours[ MEM_DIRECTION_NEXT ] )
{
JERRY_ASSERT( pBlock != NULL );
JERRY_ASSERT( pBlock->m_MagicNum == MEM_MAGIC_NUM_OF_FREE_BLOCK
|| pBlock->m_MagicNum == MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK );
JERRY_ASSERT( pBlock->MagicNum == MEM_MAGIC_NUM_OF_FREE_BLOCK
|| pBlock->MagicNum == MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK );
mem_BlockHeader_t *pNextBlock = pBlock->m_Neighbours[ MEM_DIRECTION_NEXT ];
if ( pBlock == mem_Heap.m_pLastBlock )
mem_BlockHeader_t *pNextBlock = pBlock->Neighbours[ MEM_DIRECTION_NEXT ];
if ( pBlock == mem_Heap.pLastBlock )
{
isLastBlockWasMet = true;
@@ -532,7 +532,7 @@ mem_HeapStatInit()
{
__memset( &mem_HeapStats, 0, sizeof (mem_HeapStats));
mem_HeapStats.size = mem_Heap.m_HeapSize;
mem_HeapStats.size = mem_Heap.HeapSize;
mem_HeapStats.blocks = 1;
} /* mem_InitStats */
@@ -542,7 +542,7 @@ mem_HeapStatInit()
static void
mem_HeapStatAllocBlock( mem_BlockHeader_t *block_header_p) /**< allocated block */
{
JERRY_ASSERT( block_header_p->m_MagicNum == MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK );
JERRY_ASSERT( block_header_p->MagicNum == MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK );
const size_t chunks = mem_get_block_chunks_count( block_header_p);
const size_t bytes = block_header_p->allocated_bytes;
@@ -584,7 +584,7 @@ mem_HeapStatAllocBlock( mem_BlockHeader_t *block_header_p) /**< allocated block
static void
mem_HeapStatFreeBlock( mem_BlockHeader_t *block_header_p) /**< block to be freed */
{
JERRY_ASSERT( block_header_p->m_MagicNum == MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK );
JERRY_ASSERT( block_header_p->MagicNum == MEM_MAGIC_NUM_OF_ALLOCATED_BLOCK );
const size_t chunks = mem_get_block_chunks_count( block_header_p);
const size_t bytes = block_header_p->allocated_bytes;
src/liballocator/mem-pool.c
+38 -38
View File
@@ -62,9 +62,9 @@ mem_PoolInit(mem_PoolState_t *pPool, /**< pool */
JERRY_ASSERT( (uintptr_t) poolStart % MEM_ALIGNMENT == 0);
JERRY_ASSERT( chunkSize % MEM_ALIGNMENT == 0 );
pPool->m_pPoolStart = poolStart;
pPool->m_PoolSize = poolSize;
pPool->m_ChunkSize = chunkSize;
pPool->pPoolStart = poolStart;
pPool->PoolSize = poolSize;
pPool->ChunkSize = chunkSize;
const size_t bitsInByte = JERRY_BITSINBYTE;
const size_t bitmapAreaSizeAlignment = JERRY_MAX( sizeof (mword_t), MEM_ALIGNMENT);
@@ -100,21 +100,21 @@ mem_PoolInit(mem_PoolState_t *pPool, /**< pool */
JERRY_ASSERT( chunksAreaSize >= chunksNumber * chunkSize );
JERRY_ASSERT( bitmapAreaSize + chunksAreaSize <= poolSize );
pPool->m_pBitmap = (mword_t*) poolStart;
pPool->m_pChunks = poolStart + bitmapAreaSize;
pPool->pBitmap = (mword_t*) poolStart;
pPool->pChunks = poolStart + bitmapAreaSize;
JERRY_ASSERT( (uintptr_t) pPool->m_pChunks % MEM_ALIGNMENT == 0 );
JERRY_ASSERT( (uintptr_t) pPool->pChunks % MEM_ALIGNMENT == 0 );
pPool->m_ChunksNumber = chunksNumber;
pPool->ChunksNumber = chunksNumber;
/*
* All chunks are free right after initialization
*/
pPool->m_FreeChunksNumber = chunksNumber;
__memset( pPool->m_pBitmap, 0, bitmapAreaSize);
pPool->FreeChunksNumber = chunksNumber;
__memset( pPool->pBitmap, 0, bitmapAreaSize);
#ifndef JERRY_NDEBUG
__memset( pPool->m_pChunks, mem_PoolFreeChunkMagicNum, chunksAreaSize);
__memset( pPool->pChunks, mem_PoolFreeChunkMagicNum, chunksAreaSize);
#endif /* JERRY_NDEBUG */
mem_CheckPool( pPool);
@@ -128,7 +128,7 @@ mem_PoolAllocChunk(mem_PoolState_t *pPool) /**< pool */
{
mem_CheckPool( pPool);
if ( pPool->m_FreeChunksNumber == 0 )
if ( pPool->FreeChunksNumber == 0 )
{
return NULL;
}
@@ -136,9 +136,9 @@ mem_PoolAllocChunk(mem_PoolState_t *pPool) /**< pool */
size_t chunkIndex = 0;
size_t bitmapBlockIndex = 0;
while ( chunkIndex < pPool->m_ChunksNumber )
while ( chunkIndex < pPool->ChunksNumber )
{
if ( ~pPool->m_pBitmap[ bitmapBlockIndex ] != 0 )
if ( ~pPool->pBitmap[ bitmapBlockIndex ] != 0 )
{
break;
} else
@@ -148,7 +148,7 @@ mem_PoolAllocChunk(mem_PoolState_t *pPool) /**< pool */
}
}
if ( chunkIndex >= pPool->m_ChunksNumber )
if ( chunkIndex >= pPool->ChunksNumber )
{
/* no free chunks */
return NULL;
@@ -158,16 +158,16 @@ mem_PoolAllocChunk(mem_PoolState_t *pPool) /**< pool */
mword_t bit = 1;
for ( size_t bitIndex = 0;
bitIndex < mem_BitmapBitsInBlock && chunkIndex < pPool->m_ChunksNumber;
bitIndex < mem_BitmapBitsInBlock && chunkIndex < pPool->ChunksNumber;
bitIndex++, chunkIndex++, bit <<= 1 )
{
if ( ~pPool->m_pBitmap[ bitmapBlockIndex ] & bit )
if ( ~pPool->pBitmap[ bitmapBlockIndex ] & bit )
{
/* found free chunk */
pPool->m_pBitmap[ bitmapBlockIndex ] |= bit;
pPool->pBitmap[ bitmapBlockIndex ] |= bit;
uint8_t *pChunk = &pPool->m_pChunks[ chunkIndex * pPool->m_ChunkSize ];
pPool->m_FreeChunksNumber--;
uint8_t *pChunk = &pPool->pChunks[ chunkIndex * pPool->ChunkSize ];
pPool->FreeChunksNumber--;
mem_CheckPool( pPool);
@@ -186,24 +186,24 @@ void
mem_PoolFreeChunk(mem_PoolState_t *pPool, /**< pool */
uint8_t *pChunk) /**< chunk pointer */
{
JERRY_ASSERT( pPool->m_FreeChunksNumber < pPool->m_ChunksNumber );
JERRY_ASSERT( pChunk >= pPool->m_pChunks && pChunk <= pPool->m_pChunks + pPool->m_ChunksNumber * pPool->m_ChunkSize );
JERRY_ASSERT( ( (uintptr_t) pChunk - (uintptr_t) pPool->m_pChunks ) % pPool->m_ChunkSize == 0 );
JERRY_ASSERT( pPool->FreeChunksNumber < pPool->ChunksNumber );
JERRY_ASSERT( pChunk >= pPool->pChunks && pChunk <= pPool->pChunks + pPool->ChunksNumber * pPool->ChunkSize );
JERRY_ASSERT( ( (uintptr_t) pChunk - (uintptr_t) pPool->pChunks ) % pPool->ChunkSize == 0 );
mem_CheckPool( pPool);
size_t chunkIndex = (size_t) (pChunk - pPool->m_pChunks) / pPool->m_ChunkSize;
size_t chunkIndex = (size_t) (pChunk - pPool->pChunks) / pPool->ChunkSize;
size_t bitmapBlockIndex = chunkIndex / mem_BitmapBitsInBlock;
size_t bitmapBitInBlock = chunkIndex % mem_BitmapBitsInBlock;
mword_t bitMask = ( 1lu << bitmapBitInBlock );
#ifndef JERRY_NDEBUG
__memset( (uint8_t*) pChunk, mem_PoolFreeChunkMagicNum, pPool->m_ChunkSize);
__memset( (uint8_t*) pChunk, mem_PoolFreeChunkMagicNum, pPool->ChunkSize);
#endif /* JERRY_NDEBUG */
JERRY_ASSERT( pPool->m_pBitmap[ bitmapBlockIndex ] & bitMask );
JERRY_ASSERT( pPool->pBitmap[ bitmapBlockIndex ] & bitMask );
pPool->m_pBitmap[ bitmapBlockIndex ] &= ~bitMask;
pPool->m_FreeChunksNumber++;
pPool->pBitmap[ bitmapBlockIndex ] &= ~bitMask;
pPool->FreeChunksNumber++;
mem_CheckPool( pPool);
} /* mem_PoolFreeChunk */
@@ -215,39 +215,39 @@ static void
mem_CheckPool( mem_PoolState_t __unused *pPool) /**< pool (unused #ifdef JERRY_NDEBUG) */
{
#ifndef JERRY_NDEBUG
JERRY_ASSERT( pPool->m_ChunksNumber != 0 );
JERRY_ASSERT( pPool->m_FreeChunksNumber <= pPool->m_ChunksNumber );
JERRY_ASSERT( (uint8_t*) pPool->m_pBitmap == pPool->m_pPoolStart );
JERRY_ASSERT( (uint8_t*) pPool->m_pChunks > pPool->m_pPoolStart );
JERRY_ASSERT( pPool->ChunksNumber != 0 );
JERRY_ASSERT( pPool->FreeChunksNumber <= pPool->ChunksNumber );
JERRY_ASSERT( (uint8_t*) pPool->pBitmap == pPool->pPoolStart );
JERRY_ASSERT( (uint8_t*) pPool->pChunks > pPool->pPoolStart );
uint8_t freeChunkTemplate[ pPool->m_ChunkSize ];
uint8_t freeChunkTemplate[ pPool->ChunkSize ];
__memset( &freeChunkTemplate, mem_PoolFreeChunkMagicNum, sizeof (freeChunkTemplate));
size_t metFreeChunksNumber = 0;
for ( size_t chunkIndex = 0, bitmapBlockIndex = 0;
chunkIndex < pPool->m_ChunksNumber;
chunkIndex < pPool->ChunksNumber;
bitmapBlockIndex++ )
{
JERRY_ASSERT( (uint8_t*) & pPool->m_pBitmap[ bitmapBlockIndex ] < pPool->m_pChunks );
JERRY_ASSERT( (uint8_t*) & pPool->pBitmap[ bitmapBlockIndex ] < pPool->pChunks );
mword_t bitmapBlock = pPool->m_pBitmap[ bitmapBlockIndex ];
mword_t bitmapBlock = pPool->pBitmap[ bitmapBlockIndex ];
mword_t bitMask = 1;
for ( size_t bitmapBitInBlock = 0;
chunkIndex < pPool->m_ChunksNumber && bitmapBitInBlock < mem_BitmapBitsInBlock;
chunkIndex < pPool->ChunksNumber && bitmapBitInBlock < mem_BitmapBitsInBlock;
bitmapBitInBlock++, bitMask <<= 1, chunkIndex++ )
{
if ( ~bitmapBlock & bitMask )
{
metFreeChunksNumber++;
JERRY_ASSERT( __memcmp( &pPool->m_pChunks[ chunkIndex * pPool->m_ChunkSize ], freeChunkTemplate, pPool->m_ChunkSize) == 0 );
JERRY_ASSERT( __memcmp( &pPool->pChunks[ chunkIndex * pPool->ChunkSize ], freeChunkTemplate, pPool->ChunkSize) == 0 );
}
}
}
JERRY_ASSERT( metFreeChunksNumber == pPool->m_FreeChunksNumber );
JERRY_ASSERT( metFreeChunksNumber == pPool->FreeChunksNumber );
#endif /* !JERRY_NDEBUG */
} /* mem_CheckPool */
src/liballocator/mem-pool.h
+8 -8
View File
@@ -31,18 +31,18 @@
* Compact the struct
*/
typedef struct mem_PoolState_t {
uint8_t *m_pPoolStart; /**< first address of pool space */
size_t m_PoolSize; /**< pool space size */
uint8_t *pPoolStart; /**< first address of pool space */
size_t PoolSize; /**< pool space size */
size_t m_ChunkSize; /**< size of one chunk */
size_t ChunkSize; /**< size of one chunk */
mword_t *m_pBitmap; /**< bitmap - pool chunks' state */
uint8_t *m_pChunks; /**< chunks with data */
mword_t *pBitmap; /**< bitmap - pool chunks' state */
uint8_t *pChunks; /**< chunks with data */
size_t m_ChunksNumber; /**< number of chunks */
size_t m_FreeChunksNumber; /**< number of free chunks */
size_t ChunksNumber; /**< number of chunks */
size_t FreeChunksNumber; /**< number of free chunks */
struct mem_PoolState_t *m_pNextPool; /**< pointer to the next pool with same chunk size */
struct mem_PoolState_t *pNextPool; /**< pointer to the next pool with same chunk size */
} mem_PoolState_t;
extern void mem_PoolInit(mem_PoolState_t *pPool, size_t chunkSize, uint8_t *poolStart, size_t poolSize);
src/liballocator/mem-poolman.c
+12 -12
View File
@@ -171,10 +171,10 @@ mem_PoolsAlloc( mem_PoolChunkType_t chunkType) /**< chunk type */
poolSpace,
poolSpaceSize);
poolState->m_pNextPool = mem_Pools[ chunkType ];
poolState->pNextPool = mem_Pools[ chunkType ];
mem_Pools[ chunkType ] = poolState;
mem_FreeChunksNumber[ chunkType ] += poolState->m_FreeChunksNumber;
mem_FreeChunksNumber[ chunkType ] += poolState->FreeChunksNumber;
mem_PoolsStatAllocPool( chunkType);
}
@@ -186,9 +186,9 @@ mem_PoolsAlloc( mem_PoolChunkType_t chunkType) /**< chunk type */
*/
mem_PoolState_t *poolState = mem_Pools[ chunkType ];
while ( poolState->m_FreeChunksNumber == 0 )
while ( poolState->FreeChunksNumber == 0 )
{
poolState = poolState->m_pNextPool;
poolState = poolState->pNextPool;
JERRY_ASSERT( poolState != NULL );
}
@@ -215,11 +215,11 @@ mem_PoolsFree( mem_PoolChunkType_t chunkType, /**< the chunk type */
/**
* Search for the pool containing specified chunk.
*/
while ( !( pChunk >= poolState->m_pChunks
&& pChunk <= poolState->m_pPoolStart + poolState->m_PoolSize ) )
while ( !( pChunk >= poolState->pChunks
&& pChunk <= poolState->pPoolStart + poolState->PoolSize ) )
{
prevPoolState = poolState;
poolState = poolState->m_pNextPool;
poolState = poolState->pNextPool;
JERRY_ASSERT( poolState != NULL );
}
@@ -235,19 +235,19 @@ mem_PoolsFree( mem_PoolChunkType_t chunkType, /**< the chunk type */
/**
* If all chunks of the pool are free, free the pool itself.
*/
if ( poolState->m_FreeChunksNumber == poolState->m_ChunksNumber )
if ( poolState->FreeChunksNumber == poolState->ChunksNumber )
{
if ( prevPoolState != NULL )
{
prevPoolState->m_pNextPool = poolState->m_pNextPool;
prevPoolState->pNextPool = poolState->pNextPool;
} else
{
mem_Pools[ chunkType ] = poolState->m_pNextPool;
mem_Pools[ chunkType ] = poolState->pNextPool;
}
mem_FreeChunksNumber[ chunkType ] -= poolState->m_ChunksNumber;
mem_FreeChunksNumber[ chunkType ] -= poolState->ChunksNumber;
mem_HeapFreeBlock( poolState->m_pPoolStart);
mem_HeapFreeBlock( poolState->pPoolStart);
mem_PoolFreeChunk( &mem_PoolForPoolHeaders, (uint8_t*) poolState);