/* | |
* Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies) | |
* | |
* Redistribution and use in source and binary forms, with or without | |
* modification, are permitted provided that the following conditions | |
* are met: | |
* | |
* 1. Redistributions of source code must retain the above copyright | |
* notice, this list of conditions and the following disclaimer. | |
* 2. Redistributions in binary form must reproduce the above copyright | |
* notice, this list of conditions and the following disclaimer in the | |
* documentation and/or other materials provided with the distribution. | |
* 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of | |
* its contributors may be used to endorse or promote products derived | |
* from this software without specific prior written permission. | |
* | |
* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY | |
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | |
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY | |
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | |
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | |
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF | |
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
*/ | |
#include "config.h" | |
#if OS(SYMBIAN) | |
#include "BlockAllocatorSymbian.h" | |
namespace WTF { | |
/** Efficiently allocates blocks of size blockSize with blockSize alignment. | |
* Primarly designed for JSC Collector's needs. | |
* Not thread-safe. | |
*/ | |
AlignedBlockAllocator::AlignedBlockAllocator(TUint32 reservationSize, TUint32 blockSize ) | |
: m_reservation(reservationSize), | |
m_blockSize(blockSize) | |
{ | |
// Get system's page size value. | |
SYMBIAN_PAGESIZE(m_pageSize); | |
// We only accept multiples of system page size for both initial reservation and the alignment/block size | |
m_reservation = SYMBIAN_ROUNDUPTOMULTIPLE(m_reservation, m_pageSize); | |
__ASSERT_ALWAYS(SYMBIAN_ROUNDUPTOMULTIPLE(m_blockSize, m_pageSize), User::Panic(_L("AlignedBlockAllocator1"), KErrArgument)); | |
// Calculate max. bit flags we need to carve a reservationSize range into blockSize-sized blocks | |
m_map.numBits = m_reservation / m_blockSize; | |
const TUint32 bitsPerWord = 8*sizeof(TUint32); | |
const TUint32 numWords = (m_map.numBits + bitsPerWord -1) / bitsPerWord; | |
m_map.bits = new TUint32[numWords]; | |
__ASSERT_ALWAYS(m_map.bits, User::Panic(_L("AlignedBlockAllocator2"), KErrNoMemory)); | |
m_map.clearAll(); | |
// Open a Symbian RChunk, and reserve requested virtual address range | |
// Any thread in this process can operate this rchunk due to EOwnerProcess access rights. | |
TInt ret = m_chunk.CreateDisconnectedLocal(0 , 0, (TInt)m_reservation , EOwnerProcess); | |
if (ret != KErrNone) | |
User::Panic(_L("AlignedBlockAllocator3"), ret); | |
// This is the offset to m_chunk.Base() required to make it m_blockSize-aligned | |
m_offset = SYMBIAN_ROUNDUPTOMULTIPLE(TUint32(m_chunk.Base()), m_blockSize) - TUint(m_chunk.Base()); | |
} | |
void* AlignedBlockAllocator::alloc() | |
{ | |
TInt freeRam = 0; | |
void* address = 0; | |
// Look up first free slot in bit map | |
const TInt freeIdx = m_map.findFree(); | |
// Pseudo OOM: We ate up the address space we reserved.. | |
// ..even though the device may have free RAM left | |
if (freeIdx < 0) | |
return 0; | |
TInt ret = m_chunk.Commit(m_offset + (m_blockSize * freeIdx), m_blockSize); | |
if (ret != KErrNone) | |
return 0; // True OOM: Device didn't have physical RAM to spare | |
// Updated bit to mark region as in use. | |
m_map.set(freeIdx); | |
// Calculate address of committed region (block) | |
address = (void*)( (m_chunk.Base() + m_offset) + (TUint)(m_blockSize * freeIdx) ); | |
return address; | |
} | |
void AlignedBlockAllocator::free(void* block) | |
{ | |
// Calculate index of block to be freed | |
TInt idx = TUint(static_cast<TUint8*>(block) - m_chunk.Base() - m_offset) / m_blockSize; | |
__ASSERT_DEBUG(idx >= 0 && idx < m_map.numBits, User::Panic(_L("AlignedBlockAllocator4"), KErrCorrupt)); // valid index check | |
__ASSERT_DEBUG(m_map.get(idx), User::Panic(_L("AlignedBlockAllocator5"), KErrCorrupt)); // in-use flag check | |
// Return committed region to system RAM pool (the physical RAM becomes usable by others) | |
TInt ret = m_chunk.Decommit(m_offset + m_blockSize * idx, m_blockSize); | |
// mark this available again | |
m_map.clear(idx); | |
} | |
void AlignedBlockAllocator::destroy() | |
{ | |
// release everything! | |
m_chunk.Decommit(0, m_chunk.MaxSize()); | |
m_map.clearAll(); | |
} | |
AlignedBlockAllocator::~AlignedBlockAllocator() | |
{ | |
destroy(); | |
m_chunk.Close(); | |
delete [] m_map.bits; | |
} | |
} // end of namespace | |
#endif // SYMBIAN |