Renaming rest camelCase-named identifiers according to underscore_named_value-naming.
This commit is contained in:
Ruben Ayrapetyan
+92
-92
@@ -41,114 +41,114 @@ static const uint8_t mem_pool_free_chunk_magic_num = 0x71;
|
||||
*/
|
||||
static const mword_t mem_bitmap_bits_in_block = sizeof (mword_t) * JERRY_BITSINBYTE;
|
||||
|
||||
static void mem_check_pool( mem_pool_state_t *pPool);
|
||||
static void mem_check_pool( mem_pool_state_t *pool_p);
|
||||
|
||||
/**
|
||||
* Initialization of memory pool.
|
||||
*
|
||||
* Pool will be located in the segment [poolStart; poolStart + poolSize).
|
||||
* Pool will be located in the segment [pool_start; pool_start + pool_size).
|
||||
* Part of pool space will be used for bitmap and the rest will store chunks.
|
||||
*
|
||||
* Warning:
|
||||
* it is incorrect to suppose, that chunk number = poolSize / chunkSize.
|
||||
* it is incorrect to suppose, that chunk number = pool_size / chunk_size.
|
||||
*/
|
||||
void
|
||||
mem_pool_init(mem_pool_state_t *pPool, /**< pool */
|
||||
size_t chunkSize, /**< size of one chunk */
|
||||
uint8_t *poolStart, /**< start of pool space */
|
||||
size_t poolSize) /**< pool space size */
|
||||
mem_pool_init(mem_pool_state_t *pool_p, /**< pool */
|
||||
size_t chunk_size, /**< size of one chunk */
|
||||
uint8_t *pool_start, /**< start of pool space */
|
||||
size_t pool_size) /**< pool space size */
|
||||
{
|
||||
JERRY_ASSERT( pPool != NULL );
|
||||
JERRY_ASSERT( (uintptr_t) poolStart % MEM_ALIGNMENT == 0);
|
||||
JERRY_ASSERT( chunkSize % MEM_ALIGNMENT == 0 );
|
||||
JERRY_ASSERT( pool_p != NULL );
|
||||
JERRY_ASSERT( (uintptr_t) pool_start % MEM_ALIGNMENT == 0);
|
||||
JERRY_ASSERT( chunk_size % MEM_ALIGNMENT == 0 );
|
||||
|
||||
pPool->pPoolStart = poolStart;
|
||||
pPool->PoolSize = poolSize;
|
||||
pPool->ChunkSize = chunkSize;
|
||||
pool_p->pool_start_p = pool_start;
|
||||
pool_p->pool_size = pool_size;
|
||||
pool_p->chunk_size = chunk_size;
|
||||
|
||||
const size_t bitsInByte = JERRY_BITSINBYTE;
|
||||
const size_t bitmapAreaSizeAlignment = JERRY_MAX( sizeof (mword_t), MEM_ALIGNMENT);
|
||||
const size_t bits_in_byte = JERRY_BITSINBYTE;
|
||||
const size_t bitmap_area_size_alignment = JERRY_MAX( sizeof (mword_t), MEM_ALIGNMENT);
|
||||
|
||||
/*
|
||||
* Calculation chunks number
|
||||
*/
|
||||
|
||||
size_t bitmapAreaSize = 0;
|
||||
size_t chunksAreaSize = JERRY_ALIGNDOWN( poolSize - bitmapAreaSize, chunkSize);
|
||||
size_t chunksNumber = chunksAreaSize / chunkSize;
|
||||
size_t bitmap_area_size = 0;
|
||||
size_t chunks_area_size = JERRY_ALIGNDOWN( pool_size - bitmap_area_size, chunk_size);
|
||||
size_t chunks_number = chunks_area_size / chunk_size;
|
||||
|
||||
/* while there is not enough area to hold state of all chunks*/
|
||||
while ( bitmapAreaSize * bitsInByte < chunksNumber )
|
||||
while ( bitmap_area_size * bits_in_byte < chunks_number )
|
||||
{
|
||||
JERRY_ASSERT( bitmapAreaSize + chunksAreaSize <= poolSize );
|
||||
JERRY_ASSERT( bitmap_area_size + chunks_area_size <= pool_size );
|
||||
|
||||
/* correct bitmap area's size and, accordingly, chunks' area's size*/
|
||||
|
||||
size_t newBitmapAreaSize = bitmapAreaSize + bitmapAreaSizeAlignment;
|
||||
size_t newChunksAreaSize = JERRY_ALIGNDOWN( poolSize - newBitmapAreaSize, chunkSize);
|
||||
size_t newChunksNumber = newChunksAreaSize / chunkSize;
|
||||
size_t new_bitmap_area_size = bitmap_area_size + bitmap_area_size_alignment;
|
||||
size_t new_chunks_area_size = JERRY_ALIGNDOWN( pool_size - new_bitmap_area_size, chunk_size);
|
||||
size_t new_chunks_number = new_chunks_area_size / chunk_size;
|
||||
|
||||
bitmapAreaSize = newBitmapAreaSize;
|
||||
chunksAreaSize = newChunksAreaSize;
|
||||
chunksNumber = newChunksNumber;
|
||||
bitmap_area_size = new_bitmap_area_size;
|
||||
chunks_area_size = new_chunks_area_size;
|
||||
chunks_number = new_chunks_number;
|
||||
}
|
||||
|
||||
/*
|
||||
* Final calculation checks
|
||||
*/
|
||||
JERRY_ASSERT( bitmapAreaSize * bitsInByte >= chunksNumber );
|
||||
JERRY_ASSERT( chunksAreaSize >= chunksNumber * chunkSize );
|
||||
JERRY_ASSERT( bitmapAreaSize + chunksAreaSize <= poolSize );
|
||||
JERRY_ASSERT( bitmap_area_size * bits_in_byte >= chunks_number );
|
||||
JERRY_ASSERT( chunks_area_size >= chunks_number * chunk_size );
|
||||
JERRY_ASSERT( bitmap_area_size + chunks_area_size <= pool_size );
|
||||
|
||||
pPool->pBitmap = (mword_t*) poolStart;
|
||||
pPool->pChunks = poolStart + bitmapAreaSize;
|
||||
pool_p->bitmap_p = (mword_t*) pool_start;
|
||||
pool_p->chunks_p = pool_start + bitmap_area_size;
|
||||
|
||||
JERRY_ASSERT( (uintptr_t) pPool->pChunks % MEM_ALIGNMENT == 0 );
|
||||
JERRY_ASSERT( (uintptr_t) pool_p->chunks_p % MEM_ALIGNMENT == 0 );
|
||||
|
||||
pPool->ChunksNumber = chunksNumber;
|
||||
pool_p->chunks_number = chunks_number;
|
||||
|
||||
/*
|
||||
* All chunks are free right after initialization
|
||||
*/
|
||||
pPool->FreeChunksNumber = chunksNumber;
|
||||
__memset( pPool->pBitmap, 0, bitmapAreaSize);
|
||||
pool_p->free_chunks_number = chunks_number;
|
||||
__memset( pool_p->bitmap_p, 0, bitmap_area_size);
|
||||
|
||||
#ifndef JERRY_NDEBUG
|
||||
__memset( pPool->pChunks, mem_pool_free_chunk_magic_num, chunksAreaSize);
|
||||
__memset( pool_p->chunks_p, mem_pool_free_chunk_magic_num, chunks_area_size);
|
||||
#endif /* JERRY_NDEBUG */
|
||||
|
||||
mem_check_pool( pPool);
|
||||
mem_check_pool( pool_p);
|
||||
} /* mem_pool_init */
|
||||
|
||||
/**
|
||||
* Allocate a chunk in the pool
|
||||
*/
|
||||
uint8_t*
|
||||
mem_pool_alloc_chunk(mem_pool_state_t *pPool) /**< pool */
|
||||
mem_pool_alloc_chunk(mem_pool_state_t *pool_p) /**< pool */
|
||||
{
|
||||
mem_check_pool( pPool);
|
||||
mem_check_pool( pool_p);
|
||||
|
||||
if ( pPool->FreeChunksNumber == 0 )
|
||||
if ( pool_p->free_chunks_number == 0 )
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
size_t chunkIndex = 0;
|
||||
size_t bitmapBlockIndex = 0;
|
||||
size_t chunk_index = 0;
|
||||
size_t bitmap_block_index = 0;
|
||||
|
||||
while ( chunkIndex < pPool->ChunksNumber )
|
||||
while ( chunk_index < pool_p->chunks_number )
|
||||
{
|
||||
if ( ~pPool->pBitmap[ bitmapBlockIndex ] != 0 )
|
||||
if ( ~pool_p->bitmap_p[ bitmap_block_index ] != 0 )
|
||||
{
|
||||
break;
|
||||
} else
|
||||
{
|
||||
bitmapBlockIndex++;
|
||||
chunkIndex += mem_bitmap_bits_in_block;
|
||||
bitmap_block_index++;
|
||||
chunk_index += mem_bitmap_bits_in_block;
|
||||
}
|
||||
}
|
||||
|
||||
if ( chunkIndex >= pPool->ChunksNumber )
|
||||
if ( chunk_index >= pool_p->chunks_number )
|
||||
{
|
||||
/* no free chunks */
|
||||
return NULL;
|
||||
@@ -157,21 +157,21 @@ mem_pool_alloc_chunk(mem_pool_state_t *pPool) /**< pool */
|
||||
/* found bitmap block with a zero bit */
|
||||
|
||||
mword_t bit = 1;
|
||||
for ( size_t bitIndex = 0;
|
||||
bitIndex < mem_bitmap_bits_in_block && chunkIndex < pPool->ChunksNumber;
|
||||
bitIndex++, chunkIndex++, bit <<= 1 )
|
||||
for ( size_t bit_index = 0;
|
||||
bit_index < mem_bitmap_bits_in_block && chunk_index < pool_p->chunks_number;
|
||||
bit_index++, chunk_index++, bit <<= 1 )
|
||||
{
|
||||
if ( ~pPool->pBitmap[ bitmapBlockIndex ] & bit )
|
||||
if ( ~pool_p->bitmap_p[ bitmap_block_index ] & bit )
|
||||
{
|
||||
/* found free chunk */
|
||||
pPool->pBitmap[ bitmapBlockIndex ] |= bit;
|
||||
pool_p->bitmap_p[ bitmap_block_index ] |= bit;
|
||||
|
||||
uint8_t *pChunk = &pPool->pChunks[ chunkIndex * pPool->ChunkSize ];
|
||||
pPool->FreeChunksNumber--;
|
||||
uint8_t *chunk_p = &pool_p->chunks_p[ chunk_index * pool_p->chunk_size ];
|
||||
pool_p->free_chunks_number--;
|
||||
|
||||
mem_check_pool( pPool);
|
||||
mem_check_pool( pool_p);
|
||||
|
||||
return pChunk;
|
||||
return chunk_p;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -183,71 +183,71 @@ mem_pool_alloc_chunk(mem_pool_state_t *pPool) /**< pool */
|
||||
* Free the chunk in the pool
|
||||
*/
|
||||
void
|
||||
mem_pool_free_chunk(mem_pool_state_t *pPool, /**< pool */
|
||||
uint8_t *pChunk) /**< chunk pointer */
|
||||
mem_pool_free_chunk(mem_pool_state_t *pool_p, /**< pool */
|
||||
uint8_t *chunk_p) /**< chunk pointer */
|
||||
{
|
||||
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 );
|
||||
JERRY_ASSERT( pool_p->free_chunks_number < pool_p->chunks_number );
|
||||
JERRY_ASSERT( chunk_p >= pool_p->chunks_p && chunk_p <= pool_p->chunks_p + pool_p->chunks_number * pool_p->chunk_size );
|
||||
JERRY_ASSERT( ( (uintptr_t) chunk_p - (uintptr_t) pool_p->chunks_p ) % pool_p->chunk_size == 0 );
|
||||
|
||||
mem_check_pool( pPool);
|
||||
mem_check_pool( pool_p);
|
||||
|
||||
size_t chunkIndex = (size_t) (pChunk - pPool->pChunks) / pPool->ChunkSize;
|
||||
size_t bitmapBlockIndex = chunkIndex / mem_bitmap_bits_in_block;
|
||||
size_t bitmapBitInBlock = chunkIndex % mem_bitmap_bits_in_block;
|
||||
mword_t bitMask = ( 1lu << bitmapBitInBlock );
|
||||
size_t chunk_index = (size_t) (chunk_p - pool_p->chunks_p) / pool_p->chunk_size;
|
||||
size_t bitmap_block_index = chunk_index / mem_bitmap_bits_in_block;
|
||||
size_t bitmap_bit_in_block = chunk_index % mem_bitmap_bits_in_block;
|
||||
mword_t bit_mask = ( 1lu << bitmap_bit_in_block );
|
||||
|
||||
#ifndef JERRY_NDEBUG
|
||||
__memset( (uint8_t*) pChunk, mem_pool_free_chunk_magic_num, pPool->ChunkSize);
|
||||
__memset( (uint8_t*) chunk_p, mem_pool_free_chunk_magic_num, pool_p->chunk_size);
|
||||
#endif /* JERRY_NDEBUG */
|
||||
JERRY_ASSERT( pPool->pBitmap[ bitmapBlockIndex ] & bitMask );
|
||||
JERRY_ASSERT( pool_p->bitmap_p[ bitmap_block_index ] & bit_mask );
|
||||
|
||||
pPool->pBitmap[ bitmapBlockIndex ] &= ~bitMask;
|
||||
pPool->FreeChunksNumber++;
|
||||
pool_p->bitmap_p[ bitmap_block_index ] &= ~bit_mask;
|
||||
pool_p->free_chunks_number++;
|
||||
|
||||
mem_check_pool( pPool);
|
||||
mem_check_pool( pool_p);
|
||||
} /* mem_pool_free_chunk */
|
||||
|
||||
/**
|
||||
* Check pool state consistency
|
||||
*/
|
||||
static void
|
||||
mem_check_pool( mem_pool_state_t __unused *pPool) /**< pool (unused #ifdef JERRY_NDEBUG) */
|
||||
mem_check_pool( mem_pool_state_t __unused *pool_p) /**< pool (unused #ifdef JERRY_NDEBUG) */
|
||||
{
|
||||
#ifndef JERRY_NDEBUG
|
||||
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 );
|
||||
JERRY_ASSERT( pool_p->chunks_number != 0 );
|
||||
JERRY_ASSERT( pool_p->free_chunks_number <= pool_p->chunks_number );
|
||||
JERRY_ASSERT( (uint8_t*) pool_p->bitmap_p == pool_p->pool_start_p );
|
||||
JERRY_ASSERT( (uint8_t*) pool_p->chunks_p > pool_p->pool_start_p );
|
||||
|
||||
uint8_t freeChunkTemplate[ pPool->ChunkSize ];
|
||||
__memset( &freeChunkTemplate, mem_pool_free_chunk_magic_num, sizeof (freeChunkTemplate));
|
||||
uint8_t free_chunk_template[ pool_p->chunk_size ];
|
||||
__memset( &free_chunk_template, mem_pool_free_chunk_magic_num, sizeof (free_chunk_template));
|
||||
|
||||
size_t metFreeChunksNumber = 0;
|
||||
size_t met_free_chunks_number = 0;
|
||||
|
||||
for ( size_t chunkIndex = 0, bitmapBlockIndex = 0;
|
||||
chunkIndex < pPool->ChunksNumber;
|
||||
bitmapBlockIndex++ )
|
||||
for ( size_t chunk_index = 0, bitmap_block_index = 0;
|
||||
chunk_index < pool_p->chunks_number;
|
||||
bitmap_block_index++ )
|
||||
{
|
||||
JERRY_ASSERT( (uint8_t*) & pPool->pBitmap[ bitmapBlockIndex ] < pPool->pChunks );
|
||||
JERRY_ASSERT( (uint8_t*) & pool_p->bitmap_p[ bitmap_block_index ] < pool_p->chunks_p );
|
||||
|
||||
mword_t bitmapBlock = pPool->pBitmap[ bitmapBlockIndex ];
|
||||
mword_t bitmap_block = pool_p->bitmap_p[ bitmap_block_index ];
|
||||
|
||||
mword_t bitMask = 1;
|
||||
for ( size_t bitmapBitInBlock = 0;
|
||||
chunkIndex < pPool->ChunksNumber && bitmapBitInBlock < mem_bitmap_bits_in_block;
|
||||
bitmapBitInBlock++, bitMask <<= 1, chunkIndex++ )
|
||||
mword_t bit_mask = 1;
|
||||
for ( size_t bitmap_bit_in_block = 0;
|
||||
chunk_index < pool_p->chunks_number && bitmap_bit_in_block < mem_bitmap_bits_in_block;
|
||||
bitmap_bit_in_block++, bit_mask <<= 1, chunk_index++ )
|
||||
{
|
||||
if ( ~bitmapBlock & bitMask )
|
||||
if ( ~bitmap_block & bit_mask )
|
||||
{
|
||||
metFreeChunksNumber++;
|
||||
met_free_chunks_number++;
|
||||
|
||||
JERRY_ASSERT( __memcmp( &pPool->pChunks[ chunkIndex * pPool->ChunkSize ], freeChunkTemplate, pPool->ChunkSize) == 0 );
|
||||
JERRY_ASSERT( __memcmp( &pool_p->chunks_p[ chunk_index * pool_p->chunk_size ], free_chunk_template, pool_p->chunk_size) == 0 );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
JERRY_ASSERT( metFreeChunksNumber == pPool->FreeChunksNumber );
|
||||
JERRY_ASSERT( met_free_chunks_number == pool_p->free_chunks_number );
|
||||
#endif /* !JERRY_NDEBUG */
|
||||
} /* mem_check_pool */
|
||||
|
||||
|
||||
Reference in New Issue
Block a user