packages/services/memalloc/common/v2_0/include/sepmetaimpl.hxx

   1 #ifndef CYGONCE_MEMALLOC_SEPMETAIMPL_HXX
   2 #define CYGONCE_MEMALLOC_SEPMETAIMPL_HXX
   3
   4 //==========================================================================
   5 //
   6 //      sepmetaimpl.hxx
   7 //
   8 //      Variable block memory pool with separate metadata class declarations
   9 //
  10 //==========================================================================
  11 //####ECOSGPLCOPYRIGHTBEGIN####
  12 // -------------------------------------------
  13 // This file is part of eCos, the Embedded Configurable Operating System.
  14 // Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
  15 //
  16 // eCos is free software; you can redistribute it and/or modify it under
  17 // the terms of the GNU General Public License as published by the Free
  18 // Software Foundation; either version 2 or (at your option) any later version.
  19 //
  20 // eCos is distributed in the hope that it will be useful, but WITHOUT ANY
  21 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  22 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  23 // for more details.
  24 //
  25 // You should have received a copy of the GNU General Public License along
  26 // with eCos; if not, write to the Free Software Foundation, Inc.,
  27 // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  28 //
  29 // As a special exception, if other files instantiate templates or use macros
  30 // or inline functions from this file, or you compile this file and link it
  31 // with other works to produce a work based on this file, this file does not
  32 // by itself cause the resulting work to be covered by the GNU General Public
  33 // License. However the source code for this file must still be made available
  34 // in accordance with section (3) of the GNU General Public License.
  35 //
  36 // This exception does not invalidate any other reasons why a work based on
  37 // this file might be covered by the GNU General Public License.
  38 //
  39 // Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
  40 // at http://sources.redhat.com/ecos/ecos-license/
  41 // -------------------------------------------
  42 //####ECOSGPLCOPYRIGHTEND####
  43 //==========================================================================
  44 //#####DESCRIPTIONBEGIN####
  45 //
  46 // Author(s):    jlarmour
  47 // Contributors:
  48 // Date:         2001-06-28
  49 // Purpose:      Define Sepmetaimpl class interface
  50 // Description:  Inline class for constructing a variable block allocator
  51 //               with separate metadata.
  52 // Usage:        #include <cyg/memalloc/sepmetaimpl.hxx>
  53 //
  54 //
  55 //####DESCRIPTIONEND####
  56 //
  57 //==========================================================================
  58
  59
  60 #include <cyg/infra/cyg_type.h>
  61 #include <pkgconf/memalloc.h>
  62 #include <cyg/memalloc/common.hxx>     // Common memory allocator infra
  63
  64 class Cyg_Mempool_Sepmeta_Implementation {
  65 protected:
  66     // these constructors are explicitly disallowed
  67     Cyg_Mempool_Sepmeta_Implementation() {};
  68 //    Cyg_Mempool_Sepmeta_Implementation( Cyg_Mempool_Sepmeta_Implementation &ref )
  69 //    {};
  70     Cyg_Mempool_Sepmeta_Implementation &
  71     operator=( Cyg_Mempool_Sepmeta_Implementation &ref )
  72     { return ref; };
  73
  74     struct memdq {
  75         struct memdq *prev, *next;       // prev/next alloced/free block
  76         struct memdq *memprev, *memnext; // prev/next block in memory
  77         cyg_uint8 *mem;           // memory address associated with this block
  78     };
  79
  80     struct memdq allocedhead;   // list of alloced memory
  81     struct memdq freehead;      // list of free memory
  82     struct memdq memhead;       // initial block on free list
  83     struct memdq memend;        // dummy memdq indicating the end
  84                                 // of memory, as if it were alloced
  85     struct memdq *freemetahead; // unused memdq's
  86     cyg_uint8  *obase;
  87     cyg_int32  osize;
  88     cyg_uint8  *metabase;
  89     cyg_int32  metasize;
  90     cyg_uint8  *bottom;
  91     cyg_uint8  *top;
  92     cyg_int32  alignment;
  93     cyg_int32  freemem;
  94
  95     // round up addresses according to required alignment of pool
  96     cyg_uint8 *
  97     alignup( cyg_uint8 *addr );
  98
  99     cyg_uint8 *
 100     aligndown( cyg_uint8 *addr );
 101
 102     // round up addresses according to required alignment of metadata
 103     cyg_uint8 *
 104     alignmetaup( cyg_uint8 *addr );
 105
 106     cyg_uint8 *
 107     alignmetadown( cyg_uint8 *addr );
 108
 109     // return the alloced dq at mem
 110     struct memdq *
 111     find_alloced_dq( cyg_uint8 *mem );
 112
 113     // returns a free dq of at least size, or NULL if none
 114     struct memdq *
 115     find_free_dq( cyg_int32 size );
 116
 117     // returns the free dq following mem
 118     struct memdq *
 119     find_free_dq_slot( cyg_uint8 *mem );
 120
 121     void
 122     insert_free_block( struct memdq *freedq );
 123
 124     static void
 125     copy_data( cyg_uint8 *dst, cyg_uint8 *src, cyg_int32 nbytes );
 126
 127     void
 128     check_free_memdq( struct memdq *dq );
 129
 130     void
 131     check_alloced_memdq( struct memdq *dq );
 132
 133 public:
 134     // THIS is the public API of memory pools generally that can have the
 135     // kernel oriented thread-safe package layer atop.
 136
 137     struct constructorargs {
 138         cyg_int32 alignment;
 139         cyg_uint8 *metabase;
 140         cyg_uint32 metasize;
 141         constructorargs(cyg_int32 align, cyg_uint8 *mbase, cyg_uint32 msize)
 142         {
 143             alignment = align; metabase = mbase; metasize = msize;
 144         }
 145     };
 146
 147     // Constructor: gives the base and size of the arena in which memory is
 148     // to be carved out.
 149     Cyg_Mempool_Sepmeta_Implementation(
 150         cyg_uint8 *  /* base */,
 151         cyg_int32    /* size */,
 152         CYG_ADDRWORD /* constructorargs */ );
 153
 154     // Destructor
 155     ~Cyg_Mempool_Sepmeta_Implementation();
 156
 157     // get size bytes of memory
 158     cyg_uint8 *
 159     try_alloc( cyg_int32 /* size */ );
 160
 161     // resize existing allocation, if oldsize is non-NULL, previous
 162     // allocation size is placed into it. If previous size not available,
 163     // it is set to 0. NB previous allocation size may have been rounded up.
 164     // Occasionally the allocation can be adjusted *backwards* as well as,
 165     // or instead of forwards, therefore the address of the resized
 166     // allocation is returned, or NULL if no resizing was possible.
 167     // Note that this differs from ::realloc() in that no attempt is
 168     // made to call malloc() if resizing is not possible - that is left
 169     // to higher layers. The data is copied from old to new though.
 170     // The effects of alloc_ptr==NULL or newsize==0 are undefined
 171     cyg_uint8 *
 172     resize_alloc( cyg_uint8 * /* alloc_ptr */, cyg_int32 /* newsize */,
 173                   cyg_int32 * /* oldsize */ );
 174
 175     // free size bytes of memory back to the pool
 176     // returns true on success
 177     cyg_bool
 178     free( cyg_uint8 * /* ptr */,
 179           cyg_int32   /* size */ );
 180
 181     // Get memory pool status
 182     // flags is a bitmask of requested fields to fill in. The flags are
 183     // defined in common.hxx
 184     void
 185     get_status( cyg_mempool_status_flag_t /* flags */,
 186                 Cyg_Mempool_Status & /* status */ );
 187
 188 };
 189
 190 #include <cyg/memalloc/sepmetaimpl.inl>
 191
 192 // -------------------------------------------------------------------------
 193 #endif // ifndef CYGONCE_MEMALLOC_SEPMETAIMPL_HXX
 194 // EOF sepmetaimpl.hxx