e.gavrin
257 lines
7.6 KiB
C
257 lines
7.6 KiB
C
/* Copyright 2014 Samsung Electronics Co., Ltd.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/** \addtogroup mem Memory allocation
|
|
* @{
|
|
*
|
|
* \addtogroup pool Memory pool
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* Memory pool implementation
|
|
*/
|
|
|
|
#define JERRY_MEM_POOL_INTERNAL
|
|
|
|
#include "defs.h"
|
|
#include "jerry_libc.h"
|
|
#include "mem_allocator.h"
|
|
#include "mem_pool.h"
|
|
|
|
/**
|
|
* Magic number to fill free chunks in debug version
|
|
*/
|
|
static const uint8_t mem_PoolFreeChunkMagicNum = 0x71;
|
|
|
|
/**
|
|
* Number of bits in a single bitmap's bits' block.
|
|
*/
|
|
static const mword_t mem_BitmapBitsInBlock = sizeof (mword_t) * JERRY_BITSINBYTE;
|
|
|
|
static void mem_CheckPool( mem_PoolState_t *pPool);
|
|
|
|
/**
|
|
* Initialization of memory pool.
|
|
*
|
|
* Pool will be located in the segment [poolStart; poolStart + poolSize).
|
|
* 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.
|
|
*/
|
|
void
|
|
mem_PoolInit(mem_PoolState_t *pPool, /**< pool */
|
|
size_t chunkSize, /**< size of one chunk */
|
|
uint8_t *poolStart, /**< start of pool space */
|
|
size_t poolSize) /**< pool space size */
|
|
{
|
|
JERRY_ASSERT( pPool != NULL );
|
|
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;
|
|
|
|
const size_t bitsInByte = JERRY_BITSINBYTE;
|
|
const size_t bitmapAreaSizeAlignment = 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;
|
|
|
|
/* while there is not enough area to hold state of all chunks*/
|
|
while ( bitmapAreaSize * bitsInByte < chunksNumber )
|
|
{
|
|
JERRY_ASSERT( bitmapAreaSize + chunksAreaSize <= poolSize );
|
|
|
|
/* 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;
|
|
|
|
bitmapAreaSize = newBitmapAreaSize;
|
|
chunksAreaSize = newChunksAreaSize;
|
|
chunksNumber = newChunksNumber;
|
|
}
|
|
|
|
/*
|
|
* Final calculation checks
|
|
*/
|
|
JERRY_ASSERT( bitmapAreaSize * bitsInByte >= chunksNumber );
|
|
JERRY_ASSERT( chunksAreaSize >= chunksNumber * chunkSize );
|
|
JERRY_ASSERT( bitmapAreaSize + chunksAreaSize <= poolSize );
|
|
|
|
pPool->m_pBitmap = (mword_t*) poolStart;
|
|
pPool->m_pChunks = poolStart + bitmapAreaSize;
|
|
|
|
JERRY_ASSERT( (uintptr_t) pPool->m_pChunks % MEM_ALIGNMENT == 0 );
|
|
|
|
pPool->m_ChunksNumber = chunksNumber;
|
|
|
|
/*
|
|
* All chunks are free right after initialization
|
|
*/
|
|
pPool->m_FreeChunksNumber = chunksNumber;
|
|
libc_memset( pPool->m_pBitmap, 0, bitmapAreaSize);
|
|
|
|
#ifndef JERRY_NDEBUG
|
|
libc_memset( pPool->m_pChunks, mem_PoolFreeChunkMagicNum, chunksAreaSize);
|
|
#endif /* JERRY_NDEBUG */
|
|
|
|
mem_CheckPool( pPool);
|
|
} /* mem_PoolInit */
|
|
|
|
/**
|
|
* Allocate a chunk in the pool
|
|
*/
|
|
uint8_t*
|
|
mem_PoolAllocChunk(mem_PoolState_t *pPool) /**< pool */
|
|
{
|
|
mem_CheckPool( pPool);
|
|
|
|
if ( pPool->m_FreeChunksNumber == 0 )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
size_t chunkIndex = 0;
|
|
size_t bitmapBlockIndex = 0;
|
|
|
|
while ( chunkIndex < pPool->m_ChunksNumber )
|
|
{
|
|
if ( ~pPool->m_pBitmap[ bitmapBlockIndex ] != 0 )
|
|
{
|
|
break;
|
|
} else
|
|
{
|
|
bitmapBlockIndex++;
|
|
chunkIndex += mem_BitmapBitsInBlock;
|
|
}
|
|
}
|
|
|
|
if ( chunkIndex >= pPool->m_ChunksNumber )
|
|
{
|
|
/* no free chunks */
|
|
return NULL;
|
|
}
|
|
|
|
/* found bitmap block with a zero bit */
|
|
|
|
mword_t bit = 1;
|
|
for ( size_t bitIndex = 0;
|
|
bitIndex < mem_BitmapBitsInBlock && chunkIndex < pPool->m_ChunksNumber;
|
|
bitIndex++, chunkIndex++, bit <<= 1 )
|
|
{
|
|
if ( ~pPool->m_pBitmap[ bitmapBlockIndex ] & bit )
|
|
{
|
|
/* found free chunk */
|
|
pPool->m_pBitmap[ bitmapBlockIndex ] |= bit;
|
|
|
|
uint8_t *pChunk = &pPool->m_pChunks[ chunkIndex * pPool->m_ChunkSize ];
|
|
pPool->m_FreeChunksNumber--;
|
|
|
|
mem_CheckPool( pPool);
|
|
|
|
return pChunk;
|
|
}
|
|
}
|
|
|
|
/* that zero bit is at the end of the bitmap and doesn't correspond to any chunk */
|
|
return NULL;
|
|
} /* mem_PoolAllocChunk */
|
|
|
|
/**
|
|
* Free the chunk in the pool
|
|
*/
|
|
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 );
|
|
|
|
mem_CheckPool( pPool);
|
|
|
|
size_t chunkIndex = (size_t) (pChunk - pPool->m_pChunks) / pPool->m_ChunkSize;
|
|
size_t bitmapBlockIndex = chunkIndex / mem_BitmapBitsInBlock;
|
|
size_t bitmapBitInBlock = chunkIndex % mem_BitmapBitsInBlock;
|
|
mword_t bitMask = ( 1lu << bitmapBitInBlock );
|
|
|
|
#ifndef JERRY_NDEBUG
|
|
libc_memset( (uint8_t*) pChunk, mem_PoolFreeChunkMagicNum, pPool->m_ChunkSize);
|
|
#endif /* JERRY_NDEBUG */
|
|
JERRY_ASSERT( pPool->m_pBitmap[ bitmapBlockIndex ] & bitMask );
|
|
|
|
pPool->m_pBitmap[ bitmapBlockIndex ] &= ~bitMask;
|
|
pPool->m_FreeChunksNumber++;
|
|
|
|
mem_CheckPool( pPool);
|
|
} /* mem_PoolFreeChunk */
|
|
|
|
/**
|
|
* Check pool state consistency
|
|
*/
|
|
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 );
|
|
|
|
uint8_t freeChunkTemplate[ pPool->m_ChunkSize ];
|
|
libc_memset( &freeChunkTemplate, mem_PoolFreeChunkMagicNum, sizeof (freeChunkTemplate));
|
|
|
|
size_t metFreeChunksNumber = 0;
|
|
|
|
for ( size_t chunkIndex = 0, bitmapBlockIndex = 0;
|
|
chunkIndex < pPool->m_ChunksNumber;
|
|
bitmapBlockIndex++ )
|
|
{
|
|
JERRY_ASSERT( (uint8_t*) & pPool->m_pBitmap[ bitmapBlockIndex ] < pPool->m_pChunks );
|
|
|
|
mword_t bitmapBlock = pPool->m_pBitmap[ bitmapBlockIndex ];
|
|
|
|
mword_t bitMask = 1;
|
|
for ( size_t bitmapBitInBlock = 0;
|
|
chunkIndex < pPool->m_ChunksNumber && bitmapBitInBlock < mem_BitmapBitsInBlock;
|
|
bitmapBitInBlock++, bitMask <<= 1, chunkIndex++ )
|
|
{
|
|
if ( ~bitmapBlock & bitMask )
|
|
{
|
|
metFreeChunksNumber++;
|
|
|
|
JERRY_ASSERT( libc_memcmp( &pPool->m_pChunks[ chunkIndex * pPool->m_ChunkSize ], freeChunkTemplate, pPool->m_ChunkSize) == 0 );
|
|
}
|
|
}
|
|
}
|
|
|
|
JERRY_ASSERT( metFreeChunksNumber == pPool->m_FreeChunksNumber );
|
|
#endif /* !JERRY_NDEBUG */
|
|
} /* mem_CheckPool */
|
|
|
|
/**
|
|
* @}
|
|
* @}
|
|
*/ |