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

   1 #ifndef CYGONCE_MEMALLOC_DLMALLOC_HXX
   2 #define CYGONCE_MEMALLOC_DLMALLOC_HXX
   3
   4 //==========================================================================
   5 //
   6 //      dlmalloc.hxx
   7 //
   8 //      Interface to the port of Doug Lea's malloc implementation
   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:         2000-06-18
  49 // Purpose:      Define standard interface to Doug Lea's malloc implementation
  50 // Description:  Doug Lea's malloc has been ported to eCos. This file provides
  51 //               the interface between the implementation and the standard
  52 //               memory allocator interface required by eCos
  53 // Usage:        #include <cyg/memalloc/dlmalloc.hxx>
  54 //
  55 //
  56 //####DESCRIPTIONEND####
  57 //
  58 //==========================================================================
  59
  60 // CONFIGURATION
  61
  62 #include <pkgconf/memalloc.h>
  63
  64 #ifdef CYGIMP_MEMALLOC_ALLOCATOR_DLMALLOC_THREADAWARE
  65 # include <pkgconf/system.h>
  66 # ifdef CYGPKG_KERNEL
  67 #  include <pkgconf/kernel.h>
  68 # endif
  69 #endif
  70
  71 // when used as an implementation for malloc, we need the following
  72 // to let the system know the name of the class
  73 #define CYGCLS_MEMALLOC_MALLOC_IMPL Cyg_Mempool_dlmalloc
  74
  75 // if the implementation is all that's required, don't output anything else
  76 #ifndef __MALLOC_IMPL_WANTED
  77
  78 // INCLUDES
  79
  80 #include <stddef.h>                      // size_t, ptrdiff_t
  81 #include <cyg/infra/cyg_type.h>          // types
  82 #ifdef CYGIMP_MEMALLOC_ALLOCATOR_DLMALLOC_THREADAWARE
  83 # include <cyg/memalloc/mempolt2.hxx>    // kernel safe mempool template
  84 #endif
  85 #include <cyg/memalloc/dlmallocimpl.hxx> // dlmalloc implementation
  86 #include <cyg/memalloc/common.hxx>       // Common memory allocator infra
  87 #ifdef CYGFUN_KERNEL_THREADS_TIMER
  88 # include <cyg/kernel/ktypes.h>          // cyg_tick_count
  89 #endif
  90
  91
  92 // TYPE DEFINITIONS
  93
  94
  95 class Cyg_Mempool_dlmalloc
  96 {
  97 protected:
  98 #ifdef CYGIMP_MEMALLOC_ALLOCATOR_DLMALLOC_THREADAWARE
  99     Cyg_Mempolt2<Cyg_Mempool_dlmalloc_Implementation> mypool;
 100 #else
 101     Cyg_Mempool_dlmalloc_Implementation mypool;
 102 #endif
 103
 104
 105 public:
 106     // Constructor: gives the base and size of the arena in which memory is
 107     // to be carved out, note that management structures are taken from the
 108     // same arena.
 109     Cyg_Mempool_dlmalloc( cyg_uint8 *base, cyg_int32 size,
 110                           CYG_ADDRWORD argthru=0 )
 111         : mypool( base, size, argthru ) {}
 112
 113     // Destructor
 114     //~Cyg_Mempool_dlmalloc() {}
 115
 116     // get some memory; wait if none available
 117     // if we aren't configured to be thread-aware this is irrelevant
 118 #ifdef CYGIMP_MEMALLOC_ALLOCATOR_DLMALLOC_THREADAWARE
 119     cyg_uint8 *
 120     alloc( cyg_int32 size ) { return mypool.alloc( size ); }
 121
 122 # ifdef CYGFUN_KERNEL_THREADS_TIMER
 123     // get some memory with a timeout
 124     cyg_uint8 *
 125     alloc( cyg_int32 size, cyg_tick_count delay_timeout ) {
 126         return mypool.alloc( size, delay_timeout );
 127     }
 128 # endif
 129 #endif
 130
 131     // get some memory, return NULL if none available
 132     cyg_uint8 *
 133     try_alloc( cyg_int32 size ) { return mypool.try_alloc( size ); }
 134
 135
 136     // resize existing allocation, if oldsize is non-NULL, previous
 137     // allocation size is placed into it. If previous size not available,
 138     // it is set to 0. NB previous allocation size may have been rounded up.
 139     // Occasionally the allocation can be adjusted *backwards* as well as,
 140     // or instead of forwards, therefore the address of the resized
 141     // allocation is returned, or NULL if no resizing was possible.
 142     // Note that this differs from ::realloc() in that no attempt is
 143     // made to call malloc() if resizing is not possible - that is left
 144     // to higher layers. The data is copied from old to new though.
 145     // The effects of alloc_ptr==NULL or newsize==0 are undefined
 146     cyg_uint8 *
 147     resize_alloc( cyg_uint8 *alloc_ptr, cyg_int32 newsize,
 148                   cyg_int32 *oldsize ) {
 149         return mypool.resize_alloc( alloc_ptr, newsize, oldsize);
 150     }
 151
 152     // free the memory back to the pool
 153     // returns true on success
 154     cyg_bool
 155     free( cyg_uint8 *ptr, cyg_int32 size=0 ) { return mypool.free(ptr, size); }
 156
 157     // Get memory pool status
 158     // flags is a bitmask of requested fields to fill in. The flags are
 159     // defined in common.hxx
 160     void
 161     get_status( cyg_mempool_status_flag_t flags, Cyg_Mempool_Status &status ) {
 162         // set to 0 - if there's anything really waiting, it will be set to
 163         // 1 later
 164         status.waiting = 0;
 165         mypool.get_status( flags, status );
 166     }
 167 };
 168
 169 #endif // ifndef __MALLOC_IMPL_WANTED
 170
 171 #endif // ifndef CYGONCE_MEMALLOC_DLMALLOC_HXX
 172 // EOF dlmalloc.hxx