wrapper.cpp

newos is new operation system

///-*-C++-*-//////////////////////////////////////////////////////////////////
//
// Hoard: A Fast, Scalable, and Memory-Efficient Allocator
//        for Shared-Memory Multiprocessors
// Contact author: Emery Berger, http://www.cs.utexas.edu/users/emery
//
// Copyright (c) 1998-2000, The University of Texas at Austin.
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as
// published by the Free Software Foundation, http://www.fsf.org.
//
// This library 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
// Library General Public License for more details.
//
//////////////////////////////////////////////////////////////////////////////

/*
  wrapper.cpp
  ------------------------------------------------------------------------
  Implementations of malloc(), free(), etc. in terms of hoard.
  This lets us link in hoard in place of the stock malloc
  (useful to test fragmentation).
  ------------------------------------------------------------------------
  @(#) $Id: wrapper.cpp,v 1.35 2001/06/01 18:37:28 emery Exp $
  ------------------------------------------------------------------------
  Emery Berger                    | <http://www.cs.utexas.edu/users/emery>
  Department of Computer Sciences |             <http://www.cs.utexas.edu>
  University of Texas at Austin   |                <http://www.utexas.edu>
  ========================================================================
*/

#include <string.h>
#include "config.h"

#if USE_PRIVATE_HEAPS
#include "privateheap.h"
#define HEAPTYPE privateHeap
#else
#include "threadheap.h"
#define HEAPTYPE threadHeap
#endif

#include "processheap.h"
#include "arch-specific.h"


inline static processHeap * getAllocator (void) {
  static char * buf = (char *) hoardSbrk (sizeof(processHeap));
  static processHeap * theAllocator = new (buf) processHeap;
  return theAllocator;
}

#define HOARD_MALLOC(x) malloc(x)
#define HOARD_FREE(x) free(x)
#define HOARD_REALLOC(x,y) realloc(x,y)
#define HOARD_CALLOC(x,y) calloc(x,y)
#define HOARD_MEMALIGN(x,y) memalign(x,y)
#define HOARD_VALLOC(x) valloc(x)

extern "C" void * HOARD_MALLOC(size_t);
extern "C" void HOARD_FREE(void *);
extern "C" void * HOARD_REALLOC(void *, size_t);
extern "C" void * HOARD_CALLOC(size_t, size_t);
extern "C" void * HOARD_MEMALIGN(size_t, size_t);
extern "C" void * HOARD_VALLOC(size_t);

/* let libsupc++ provide the new/delete implementations */
#if 0
void * operator new (size_t size)
{
  return HOARD_MALLOC (size);
}
/*
void * operator new (size_t size, const std::nothrow_t&) throw() {
  return HOARD_MALLOC (size);
}
*/
void * operator new[] (size_t size)
{
  return HOARD_MALLOC (size);
}
/*
void * operator new[] (size_t size, const std::nothrow_t&) throw() {
  return HOARD_MALLOC (size);
}
*/
void operator delete (void * ptr)
{
  HOARD_FREE (ptr);
}

void operator delete[] (void * ptr)
{
  HOARD_FREE (ptr);
}
#endif

extern "C" void * HOARD_MALLOC (size_t sz)
{
  static processHeap * pHeap = getAllocator();
  void * addr = pHeap->getHeap(pHeap->getHeapIndex()).malloc (sz);
  return addr;
}

extern "C" void * HOARD_CALLOC (size_t nelem, size_t elsize)
{
  static processHeap * pHeap = getAllocator();
  void * ptr = pHeap->getHeap(pHeap->getHeapIndex()).malloc (nelem * elsize);
  // Zero out the malloc'd block.
  memset (ptr, 0, nelem * elsize);
  return ptr;
}

extern "C" void HOARD_FREE (void * ptr)
{
  static processHeap * pHeap = getAllocator();
#if USE_PRIVATE_HEAPS
  pHeap->getHeap(pHeap->getHeapIndex()).free(ptr);
#else
  pHeap->free (ptr);
#endif
}


extern "C" void * HOARD_MEMALIGN (size_t alignment, size_t size)
{
  static processHeap * pHeap = getAllocator();
  void * addr = pHeap->getHeap(pHeap->getHeapIndex()).memalign (alignment, size);
  return addr;
}


extern "C" void * HOARD_VALLOC (size_t size)
{
  return HOARD_MEMALIGN (hoardGetPageSize(), size);
}


extern "C" void * HOARD_REALLOC (void * ptr, size_t sz)
{
  if (ptr == NULL) {
    return HOARD_MALLOC (sz);
  }
  if (sz == 0) {
    HOARD_FREE (ptr);
    return NULL;
  }

  // If the existing object can hold the new size,
  // just return it.

  size_t objSize = HEAPTYPE::objectSize (ptr);

  if (objSize >= sz) {
    return ptr;
  }

  // Allocate a new block of size sz.

  void * buf = HOARD_MALLOC (sz);

  // Copy the contents of the original object
  // up to the size of the new block.

  size_t minSize = (objSize < sz) ? objSize : sz;
  memcpy (buf, ptr, minSize);

  // Free the old block.

  HOARD_FREE (ptr);

  // Return a pointer to the new one.

  return buf;
}


#ifdef WIN32

// Replace the CRT debugging allocation routines, just to be on the safe side.
// This is not a complete solution, but should avoid inadvertent mixing of allocations.

extern "C" void * _malloc_dbg (size_t sz, int, const char *, int) {
	return HOARD_MALLOC (sz);
}

void * operator new(
        unsigned int cb,
        int nBlockUse,
        const char * szFileName,
        int nLine
        )
{
	return HOARD_MALLOC (cb);
}

extern "C" void * _calloc_dbg (size_t num, size_t size, int, const char *, int) {
	return HOARD_CALLOC (num, size);
}

extern "C" void * _realloc_dbg (void * ptr, size_t newSize, int, const char *, int) {
	return HOARD_REALLOC (ptr, newSize);
}

extern "C" void _free_dbg (void * ptr, int) {
	HOARD_FREE (ptr);
}

extern "C" size_t _msize_dbg (void * ptr) {
  // Find the block and superblock corresponding to this ptr.

  block * b = (block *) ptr - 1;
  assert (b->isValid());

  // Check to see if this block came from a memalign() call.
  if (((unsigned long) b->getNext() & 1) == 1) {
    // It did. Set the block to the actual block header.
    b = (block *) ((unsigned long) b->getNext() & ~1);
    assert (b->isValid());
  }

  superblock * sb = b->getSuperblock();
  assert (sb);
  assert (sb->isValid());

  const int sizeclass = sb->getBlockSizeClass();
  return hoardHeap::sizeFromClass (sizeclass);
}

extern "C" size_t _msize (void * ptr) {
  // Find the block and superblock corresponding to this ptr.

  block * b = (block *) ptr - 1;
  assert (b->isValid());

  // Check to see if this block came from a memalign() call.
  if (((unsigned long) b->getNext() & 1) == 1) {
    // It did. Set the block to the actual block header.
    b = (block *) ((unsigned long) b->getNext() & ~1);
    assert (b->isValid());
  }

  superblock * sb = b->getSuperblock();
  assert (sb);
  assert (sb->isValid());

  const int sizeclass = sb->getBlockSizeClass();
  return hoardHeap::sizeFromClass (sizeclass);
}

extern "C" void * _nh_malloc_base (size_t sz, int) {
	return HOARD_MALLOC (sz);
}

extern "C" void * _nh_malloc_dbg (size_t sz, size_t, int, int, const char *, int) {
	return HOARD_MALLOC (sz);
}

#endif // WIN32


#if 0
extern "C" void malloc_stats (void)
{
  TheWrapper.TheAllocator()->stats();
}
#endif