Subversion Repositories openrisc

#ifndef CYGONCE_MEMALLOC_MFIXIMPL_INL

#define CYGONCE_MEMALLOC_MFIXIMPL_INL

//==========================================================================

//

//      mfiximpl.inl

//

//      Memory pool with fixed block class declarations

//

//==========================================================================

// ####ECOSGPLCOPYRIGHTBEGIN####

// -------------------------------------------

// This file is part of eCos, the Embedded Configurable Operating System.

// Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.

//

// eCos is free software; you can redistribute it and/or modify it under

// the terms of the GNU General Public License as published by the Free

// Software Foundation; either version 2 or (at your option) any later

// version.

//

// eCos is distributed in the hope that it will be useful, but WITHOUT

// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

// for more details.

//

// You should have received a copy of the GNU General Public License

// along with eCos; if not, write to the Free Software Foundation, Inc.,

// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

//

// As a special exception, if other files instantiate templates or use

// macros or inline functions from this file, or you compile this file

// and link it with other works to produce a work based on this file,

// this file does not by itself cause the resulting work to be covered by

// the GNU General Public License. However the source code for this file

// must still be made available in accordance with section (3) of the GNU

// General Public License v2.

//

// This exception does not invalidate any other reasons why a work based

// on this file might be covered by the GNU General Public License.

// -------------------------------------------

// ####ECOSGPLCOPYRIGHTEND####

//==========================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):    hmt

// Contributors: jlarmour

// Date:         2000-06-12

// Purpose:      Define Mfiximpl class interface

// Description:  Inline class for constructing a fixed block allocator

// Usage:        #include 

//

//

//####DESCRIPTIONEND####

//

//==========================================================================

#include 

#include           // HAL_LSBIT_INDEX magic asm code

#include 

// -------------------------------------------------------------------------

inline

Cyg_Mempool_Fixed_Implementation::Cyg_Mempool_Fixed_Implementation(

        cyg_uint8 *base,

        cyg_int32 size,

        CYG_ADDRWORD alloc_unit )

{

    cyg_int32 i;

    bitmap = (cyg_uint32 *)base;

    blocksize = alloc_unit;

    CYG_ASSERT( blocksize > 0, "Bad blocksize" );

    CYG_ASSERT( size > 2, "Bad blocksize" );

    CYG_ASSERT( blocksize < size, "blocksize, size bad" );

    numblocks = size / blocksize;

    top = base + size;

    CYG_ASSERT( numblocks >= 2, "numblocks bad" );

    i = (numblocks + 31)/32;        // number of words to map blocks

    while ( (i * 4 + numblocks * blocksize) > size ) {

        numblocks --;               // steal one block for admin

        i = (numblocks + 31)/32;    // number of words to map blocks

    }

    CYG_ASSERT( 0 < i, "Bad word count for bitmap after fitment" );

    CYG_ASSERT( 0 < numblocks, "Bad block count after fitment" );

    maptop = i;

    // this should leave space for the bitmap and maintain alignment

    mempool = top - (numblocks * blocksize);

    CYG_ASSERT( base < mempool && mempool < top, "mempool escaped" );

    CYG_ASSERT( (cyg_uint8 *)(&bitmap[ maptop ]) <= mempool,

                "mempool overwrites bitmap" );

    CYG_ASSERT( &mempool[ numblocks * blocksize ] <= top,

                "mempool overflows top" );

    freeblocks = numblocks;

    firstfree = 0;

    // clear out the bitmap; no blocks allocated yet

    for ( i = 0; i < maptop; i++ )

        bitmap[ i ] = 0;

    // apart from the non-existent ones at the top

    for ( i = ((numblocks-1)&31) + 1; i < 32; i++ )

        bitmap[ maptop - 1 ] |= ( 1 << i );

}

// -------------------------------------------------------------------------

inline

Cyg_Mempool_Fixed_Implementation::~Cyg_Mempool_Fixed_Implementation()

{

}

// -------------------------------------------------------------------------

inline cyg_uint8 *

Cyg_Mempool_Fixed_Implementation::try_alloc( cyg_int32 size )

{

    // size parameter is not used

    CYG_UNUSED_PARAM( cyg_int32, size );

    if ( 0 >= freeblocks ) {

        CYG_MEMALLOC_FAIL(size);

        return NULL;

    }

    cyg_int32 i = firstfree;

    cyg_uint8 *p = NULL;

    do {

        if ( 0xffffffff != bitmap[ i ] ) {

            // then there is a free block in this bucket

            register cyg_uint32 j, k;

            k = ~bitmap[ i ];       // look for a 1 in complement

            HAL_LSBIT_INDEX( j, k );

            CYG_ASSERT( 0 <= j && j <= 31, "Bad bit index" );

            CYG_ASSERT( 0 == (bitmap[ i ] & (1 << j)), "Found bit not clear" );

            bitmap[ i ] |= (1 << j); // set it allocated

            firstfree = i;

            freeblocks--;

            CYG_ASSERT( freeblocks >= 0, "allocated too many" );

            p = &mempool[ ((32 * i) + j) * blocksize ];

            break;

        }

        if ( ++i >= maptop )

            i = 0;                  // wrap if at top

    } while ( i != firstfree );     // prevent hang if internal error

    CYG_ASSERT( NULL != p, "Should have a block here" );

    CYG_ASSERT( mempool <= p  && p <= top, "alloc mem escaped" );

    return p;

}

// -------------------------------------------------------------------------

// supposedly resize existing allocation. This is defined in the

// fixed block allocator purely for API consistency. It will return

// an error (false) for all values, except for the blocksize

// returns true on success

inline cyg_uint8 *

Cyg_Mempool_Fixed_Implementation::resize_alloc( cyg_uint8 *alloc_ptr,

                                                cyg_int32 newsize,

                                                cyg_int32 *oldsize )

{

    CYG_CHECK_DATA_PTRC( alloc_ptr );

    if ( NULL != oldsize )

        CYG_CHECK_DATA_PTRC( oldsize );

    CYG_ASSERT( alloc_ptr >= mempool && alloc_ptr < top,

                "alloc_ptr outside pool" );

    if ( NULL != oldsize )

        *oldsize = blocksize;

    if (newsize == blocksize)

        return alloc_ptr;

    else {

        CYG_MEMALLOC_FAIL(newsize);

        return NULL;

    }

} // resize_alloc()

// -------------------------------------------------------------------------

inline cyg_bool

Cyg_Mempool_Fixed_Implementation::free( cyg_uint8 *p, cyg_int32 size )

{

    // size parameter is not used

    CYG_UNUSED_PARAM( cyg_int32, size );

    if ( p < mempool || p >= top )

        return false;               // address way out of bounds

    cyg_int32 i = p - mempool;

    i = i / blocksize;

    if ( &mempool[ i * blocksize ] != p )

        return false;               // address not aligned

    cyg_int32 j = i / 32;

    CYG_ASSERT( 0 <= j && j < maptop, "map index escaped" );

    i = i - 32 * j;

    CYG_ASSERT( 0 <= i && i < 32, "map bit index escaped" );

    if ( ! ((1 << i) & bitmap[ j ] ) )

        return false;               // block was not allocated

    bitmap[ j ] &=~(1 << i);        // clear the bit

    freeblocks++;                   // count the block

    CYG_ASSERT( freeblocks <= numblocks, "freeblocks overflow" );

    return true;

}

// -------------------------------------------------------------------------

inline void

Cyg_Mempool_Fixed_Implementation::get_status(

    cyg_mempool_status_flag_t flags,

    Cyg_Mempool_Status &status )

{

// as quick or quicker to just set it, rather than test flag first

    status.arenabase = (const cyg_uint8 *)bitmap;

    if ( 0 != (flags & CYG_MEMPOOL_STAT_ARENASIZE) )

        status.arenasize = top - (cyg_uint8 *)bitmap;

    if ( 0 != (flags & CYG_MEMPOOL_STAT_FREEBLOCKS) )

        status.freeblocks = freeblocks;

    if ( 0 != (flags & CYG_MEMPOOL_STAT_TOTALALLOCATED) )

        status.totalallocated = blocksize * numblocks;

    if ( 0 != (flags & CYG_MEMPOOL_STAT_TOTALFREE) )

        status.totalfree = blocksize * freeblocks;

    if ( 0 != (flags & CYG_MEMPOOL_STAT_BLOCKSIZE) )

        status.blocksize = blocksize;

    if ( 0 != (flags & CYG_MEMPOOL_STAT_MAXFREE) ) {

        status.maxfree = freeblocks > 0 ? blocksize : 0;

    }

// as quick or quicker to just set it, rather than test flag first

    status.origbase = (const cyg_uint8 *)bitmap;

    if ( 0 != (flags & CYG_MEMPOOL_STAT_ORIGSIZE) )

        status.origsize = top - (cyg_uint8 *)bitmap;

// quicker to just set it, rather than test flag first

    status.maxoverhead = 0;

} // get_status()

// -------------------------------------------------------------------------

#endif // ifndef CYGONCE_MEMALLOC_MFIXIMPL_INL

// EOF mfiximpl.inl