/ray/src/lib/salloc.cc

Go to the documentation of this file.

/* 
 * lib/salloc.cc
 * 
 * Routines for memory allocation which limit the amount of memory 
 * being used at the same time as well as support for allocation 
 * checking/debugging. 
 * 
 * Copyright (c) 2000--2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [ 
 * 
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#include "salloc.h"

#include <stdio.h>

#if HAVE_MALLOC_H
#include <malloc.h>
#endif


// This is the low-level interface to the system to be used: 
inline void *_malloc(size_t size)  {  return(malloc(size));  }
inline void *_realloc(void *ptr,size_t size)  {  return(realloc(ptr,size));  }
inline void _free(void *ptr)  {  return(free(ptr));  }


//------------------------------------------------------------------------------
// Internal code, mostly for allocation debugging and allocation limitation. 

// We need a mutex to protect the statistics and also the B-tree in 
// case allocation debugging is switched on. 
#include <lib/threads/mutex.h>
static FastMutex mutex;

static struct LMallocUsage lmu=
{
    INIT_FIELD(alloc_limit) 0,
    INIT_FIELD(curr_used) 0,
    INIT_FIELD(max_used) 0,
    INIT_FIELD(malloc_calls) 0,
    INIT_FIELD(realloc_calls) 0,
    INIT_FIELD(free_calls) 0,
    INIT_FIELD(used_chunks) 0,
    INIT_FIELD(max_used_chunks) 0,
    INIT_FIELD(real_failures) 0,
    INIT_FIELD(limit_failures) 0
};

/* Set the limit: maximum amount of memory to aquire using LMalloc(). */
void LMallocSetLimit(size_t limit)
{  lmu.alloc_limit=limit;  }

/* Get the LMallocUsage content: */
void LMallocGetUsage(struct LMallocUsage *dest)
{
    if(dest)
    {  memcpy(dest,&lmu,sizeof(lmu));  }
}


static void _LMallocPrintStats()
{
    fprintf(stderr,
        "  Alloc: %u bytes in %d chunks; Peak: %u by,%d chks; (%u/%u/%u)\n",
        lmu.curr_used,lmu.used_chunks,lmu.max_used,lmu.max_used_chunks,
        lmu.malloc_calls,lmu.realloc_calls,lmu.free_calls);
    fprintf(stderr,
        "  Limit: %u bytes;  USE_MALLOC_USABLE_SIZE=%s, LMALLOC_DEBUGGING=%s\n",
        lmu.alloc_limit,
#if USE_MALLOC_USABLE_SIZE
        "yes",
#else
        "no",
#endif
#if LMALLOC_DEBUGGING
        "yes"
#else
        "no"
#endif
        );
}


// Called whenever we exit due to allocation issues to be somewhat more 
// verbose. 
static void _LMallocExit()
{
    _LMallocPrintStats();
    
    abort();   // This aids in debugging. 
    exit(-1);
}

#if LMALLOC_DEBUGGING

struct _packed_ LMEntry
{
    void *ptr;
#if !USE_MALLOC_USABLE_SIZE
    size_t _size;
#endif
    
    inline size_t size()
    {
#if USE_MALLOC_USABLE_SIZE
        return(malloc_usable_size(ptr));
#else
        return(_size);
#endif
    }
    
    // These are needed for the TLBTree to operate properly. 
    inline bool operator==(const LMEntry &e) const  {  return(ptr==e.ptr);  }
    inline bool operator!=(const LMEntry &e) const  {  return(ptr!=e.ptr);  }
    inline bool operator<(const LMEntry &e) const   {  return(ptr<e.ptr);  }
    inline bool operator<=(const LMEntry &e) const  {  return(ptr<=e.ptr);  }
    inline bool operator>(const LMEntry &e) const   {  return(ptr>e.ptr);  }
    inline bool operator>=(const LMEntry &e) const  {  return(ptr>=e.ptr);  }
    // For the search: 
    inline bool operator==(void *ptr2) const  {  return(ptr==ptr2);  }
    inline bool operator!=(void *ptr2) const  {  return(ptr!=ptr2);  }
    inline bool operator<(void *ptr2) const   {  return(ptr<ptr2);  }
    inline bool operator<=(void *ptr2) const  {  return(ptr<=ptr2);  }
    inline bool operator>(void *ptr2) const   {  return(ptr>ptr2);  }
    inline bool operator>=(void *ptr2) const  {  return(ptr>=ptr2);  }
    
    // Constructor: Same API independent of USE_MALLOC_USABLE_SIZE. 
#if USE_MALLOC_USABLE_SIZE
    inline LMEntry(void *pptr,size_t /*psize*/) : ptr(pptr) {}
#else
    inline LMEntry(void *pptr,size_t psize) : ptr(pptr),_size(psize) {}
#endif
    
    // Default constructor does nothing. 
    inline LMEntry() {}
    
    // Destructor: 
    inline ~LMEntry(){}
    
    // Copy constructor and assignment: use default. 
};


#include <lib/tl/defop.h>
struct LMEntryOperators : TLDefaultOperators_CDT<LMEntry>
{
    // Private versions of the (de)allocation routines: 
    // Because of course, here in the allocation routines, we cannot use 
    // our own allocation routines recursively! 
    static inline void *alloc(size_t size)
    {
        void *ptr=_malloc(size);
        if(!ptr)  _AllocFailure(size);
        return(ptr);
    }
    static inline void *free(void *ptr)
        {  _free(ptr);  return(NULL);  }
};


// We use a TLBTree to efficiently store the pointers. 
#include <lib/tl/tlbtree.h>
typedef TLBTree<LMEntry,LMEntryOperators> LMTree;
static LMTree *InitializeAllocDebugging();
// This will automatically call the init function on startup. 
static LMTree *chunks = InitializeAllocDebugging();

static LMTree *InitializeAllocDebugging()
{
    // Okay, be careful here inside the alloc debugging code. 
    // We cannot simply call operator new or LMalloc(). 
    
    void *space=_malloc(sizeof(LMTree));
    if(!space)  _AllocFailure(sizeof(LMTree));
    // Use operator new with explicit placement.
    LMTree *chunks = new(space) LMTree(/*m=*/32);
    
    fprintf(stderr,"LMalloc debugging initialized "
        "(sizeof(LMEntry)=%d, MUS=%s).\n",
        sizeof(LMEntry),
#if USE_MALLOC_USABLE_SIZE
        "yes"
#else
        "no"
#endif
        );
    
    // Register that statistics are written on exit. 
    atexit(&_LMallocPrintStats);
    
    return(chunks);
}

#endif  /* LMALLOC_DEBUGGING */

// NOTE: It is crucial that we do this here and not above in the 
//       alloc debug code. 
#if !USE_MALLOC_USABLE_SIZE
// We do not know in realloc/free how big the block is and we have no 
// alloc debugging in place to get the size by other means, so assume 
// a size of 1 for all chunks and thereby acually count the number of 
// *calls* to LMalloc()/LRealloc()/LFree(). 
#define malloc_usable_size(x)  1
#endif 


static inline void *_LMalloc(size_t size)
{
    MutexLock<FastMutex> lock(mutex);
    
    if(lmu.alloc_limit)
    {
        if(lmu.curr_used+size>lmu.alloc_limit)
        {
            ++lmu.limit_failures;
            //if(lmalloc_failure_handler)
            //{  (*lmalloc_failure_handler)(size);  }
            return(NULL);
        }
    }
    
    void *ptr=_malloc(size);     // <-- DO IT
    ++lmu.malloc_calls;
    
    if(!ptr)
    {
        ++lmu.real_failures;
        //if(lmalloc_failure_handler)
        //{  (*lmalloc_failure_handler)(size);  }
        return(ptr);   // ...which is NULL
    }
    
#if LMALLOC_DEBUGGING
    LMEntry e(ptr,size);
    int rv=chunks->store(e,/*allow_update=*/0);
    if(rv)
    {
        fprintf(stderr,
            "OOPS(alloc): Chunk %p (size=%u) was already allocated.\n",
            ptr,size);
        _LMallocExit();
    }
    lmu.curr_used+=e.size();  // <-- NOT the size var on stack!
#else
    lmu.curr_used+=malloc_usable_size(ptr);
#endif
    
    if(lmu.max_used<lmu.curr_used)
    {  lmu.max_used=lmu.curr_used;  }
    
    ++lmu.used_chunks;
    if(lmu.max_used_chunks<lmu.used_chunks)
    {  lmu.max_used_chunks=lmu.used_chunks;  }
    
    /*#if AllocDebugging
    if(hlib_allocdebug_trace)
    {
        if(hlib_allocdebug_trace>1)
        {  fprintf(stderr,"@HLAT->malloc[%u](%u)=%p\n",
            hlib_allocdebug_seq,size,ptr);  }
        if(hlib_allocdebug_seq==hlib_allocdebug_abort_seq)
        {  abort();  }
        ++hlib_allocdebug_seq;
    }
    #endif*/
    
    return(ptr);
}


static inline void _LFree(void *ptr)
{
    MutexLock<FastMutex> lock(mutex);
    
    // ptr!=NULL here. 
    
    /*#if AllocDebugging
    if(hlib_allocdebug_trace)
    {
        if(hlib_allocdebug_trace>1)
        {  fprintf(stderr,"@HLAT->free[%u](%p)\n",hlib_allocdebug_seq,ptr);  }
        if(hlib_allocdebug_seq==hlib_allocdebug_abort_seq)
        {  abort();  }
        ++hlib_allocdebug_seq;
    }
    #endif*/
    
#if LMALLOC_DEBUGGING
    LMEntry e;
    int rv=chunks->remove(ptr,&e);
    if(rv)
    {
        fprintf(stderr,"OOPS(free): Chunk %p was never allocated.\n",ptr);
        _LMallocExit();
    }
    size_t size=e.size();
#else
    size_t size=malloc_usable_size(ptr);
#endif
    if(lmu.curr_used>=size)
    {  lmu.curr_used-=size;  }
    else  /* should never happen... */
    {  lmu.curr_used=0;  }
    
    _free(ptr);   // <-- DO IT
    ++lmu.free_calls;
    
    --lmu.used_chunks;
}


static inline void *_LRealloc(void *ptr,size_t size)
{
    MutexLock<FastMutex> lock(mutex);
    
    // size!=0 and ptr!=NULL here. 
    
    /*#if AllocDebugging
    void *_old_ptr=ptr;
    #endif*/
    
#if 0   /* <-- Use malloc() and free() instead if realloc(). */
#warning "<--NO REALLOC--!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!-->"
    {
        /* This depends on a working malloc_usable_size(). */
        void *nptr=LMalloc(size);
        size_t osize=malloc_usable_size(ptr);
        if(!nptr)  return(NULL);
        memcpy(nptr,ptr,osize<size ? osize : size);
        LFree(ptr);
        return(nptr);
    }
#endif
    
#if LMALLOC_DEBUGGING
    LMEntry e;
    int rv=chunks->remove(ptr,&e);
    if(rv)
    {
        fprintf(stderr,"OOPS(realloc): Chunk %p was never allocated.\n",ptr);
        _LMallocExit();
    }
    size_t oldsize=e.size();
#else
    size_t oldsize=malloc_usable_size(ptr);
#endif
    
    if(lmu.curr_used>=oldsize)
    {  lmu.curr_used-=oldsize;  }
    else  /* should never happen... */
    {  lmu.curr_used=0;  }
    
    if(lmu.alloc_limit && lmu.curr_used+size>lmu.alloc_limit)
    {
        // FAIL: The old chunks stays allocated!
        ptr=NULL;
        ++lmu.limit_failures;
        
        // Decrement here since we will increment afterwards...
        --lmu.real_failures;
    }
    else
    {
        ptr=realloc(ptr,size);     // <-- DO IT
        ++lmu.realloc_calls;
    }
        
    if(!ptr)
    {
        lmu.curr_used+=oldsize;
        //lmu.max_used does not need to be updated here. 
        ++lmu.real_failures;
        
#if LMALLOC_DEBUGGING
        rv=chunks->store(e,/*allow_update=*/0);
        if(rv)
        {
            fprintf(stderr,"OOPS: Chunk %p again in B-tree?!\n",ptr);
            _LMallocExit();
        }
#endif
        
        //if(lmalloc_failure_handler)
        //{  (*lmalloc_failure_handler)(size);  }
        return(NULL);
    }
    
#if LMALLOC_DEBUGGING
    e=LMEntry(ptr,size);
    rv=chunks->store(e,/*allow_update=*/0);
    if(rv)
    {
        fprintf(stderr,
            "OOPS(realloc): Chunk %p (size=%u) again in B-tree?!\n",
            ptr,size);
        _LMallocExit();
    }
    lmu.curr_used+=e.size();  // <-- ...and NOT the size var on the stack. 
#else
    lmu.curr_used+=malloc_usable_size(ptr);
#endif
    if(lmu.max_used<lmu.curr_used)
    {  lmu.max_used=lmu.curr_used;  }
    
    /*#if AllocDebugging
    if(hlib_allocdebug_trace)
    {
        if(hlib_allocdebug_trace>1)
        {  fprintf(stderr,"@HLAT->realloc[%u](%p,%u)=%p\n",hlib_allocdebug_seq,
            _old_ptr,size,ptr);  }
        if(hlib_allocdebug_seq==hlib_allocdebug_abort_seq)
        {  abort();  }
        ++hlib_allocdebug_seq;
    }
    #endif*/
    
    return(ptr);
}


//------------------------------------------------------------------------------
// "High-level" routines: The frontend to the "user": 
// The called _L* functions are declared static inline. 

void _AllocFailure(size_t size)
{
    fprintf(stderr,"Failed to allocate %u bytes of memory.\n",size);
    
    _LMallocExit();
}


void *LMalloc(size_t size)
{
    if(!size)  return(NULL);
    void *ptr=_LMalloc(size);
//fprintf(stderr,"LMalloc(%d)=%p \n",size,ptr);
    if(!ptr)  _AllocFailure(size);
    return(ptr);
}


void *LFree(void *ptr)
{
    if(ptr)  _LFree(ptr);
//fprintf(stderr,"LFree(%p) \n",ptr);
    return(NULL);
}


void *LRealloc(void *ptr,size_t size)
{
    if(!ptr)  return(LMalloc(size));
    if(!size)  return(LFree(ptr));
    void *nptr=_LRealloc(ptr,size);
//fprintf(stderr,"LRealloc(%p,%d)=&p \n",ptr,size,nptr);
    if(!nptr)  _AllocFailure(size);
    return(nptr);
}

---