omAllocSystem.h File Reference

#include "omalloc/omConfig.h"

Go to the source code of this file.

Macros
#define	omSizeWOfLargeAddr(addr)
#define	omVallocFromSystem(size)

Functions
size_t	omSizeOfAddr (const void *addr)
size_t	omSizeWOfAddr (void *addr)
size_t	omSizeOfLargeAddr (void *addr)
void *	omAllocFromSystem (size_t size)
void *	omReallocFromSystem (void *addr, size_t newsize)
void	omFreeToSystem (void *addr)
void *	omReallocSizeFromSystem (void *addr, size_t oldsize, size_t newsize)
void	omFreeSizeToSystem (void *addr, size_t size)
void *	_omVallocFromSystem (size_t size, int fail)
void	omVfreeToSystem (void *page, size_t size)
void *	omAllocLarge (size_t size)
void *	omReallocLarge (void *old_addr, size_t new_size)
void	omFreeLarge (void *addr)
void *	omRealloc0Large (void *old_addr, size_t new_size)
void *	omAlloc0Large (size_t size)

Macro Definition Documentation

omSizeWOfLargeAddr

#define omSizeWOfLargeAddr

(

addr

)

Value:

(omSizeOfLargeAddr(addr) >> LOG_SIZEOF_LONG)

Definition at line 19 of file omAllocSystem.h.

omVallocFromSystem

#define omVallocFromSystem

(

size

)

Value:

_omVallocFromSystem(size, 0)

Definition at line 28 of file omAllocSystem.h.

Function Documentation

_omVallocFromSystem()

void * _omVallocFromSystem	(	size_t	size,
		int	fail )

Definition at line 318 of file omAllocSystem.c.

{
  void* page = OM_VALLOC_FROM_SYSTEM(size);
  if (page == NULL)
  {
    OM_MEMORY_LOW_HOOK();
    page = OM_VALLOC_FROM_SYSTEM(size);
    if (page == NULL)
    {
      if (fail) return NULL;
      else
      {
        OM_OUT_OF_MEMORY_HOOK();
        /* should never get here */
        omAssume(0);
        exit(1);
      }
    }
  }
 
#ifndef OM_NDEBUG
  if (((unsigned long) page) + size > om_MaxAddr)
    om_MaxAddr = ((unsigned long) page) + size;
  if (((unsigned long) page) < om_MinAddr)
    om_MinAddr = ((unsigned long) page);
#endif
 
  omAssume(omIsAddrPageAligned(page));
  om_Info.CurrentBytesFromValloc += size;
  if (om_Info.CurrentBytesFromValloc > om_Info.MaxBytesFromValloc)
  {
    om_Info.MaxBytesFromValloc = om_Info.CurrentBytesFromValloc;
#if defined(OM_HAVE_VALLOC_MMAP) && defined(OM_MALLOC_MAX_BYTES_SYSTEM)
    if (om_Info.MaxBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM > om_Info.MaxBytesSystem)
      om_Info.MaxBytesSystem = om_Info.MaxBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM;
#endif
#if defined(HAVE_SBRK) && !defined(OM_HAVE_VALLOC_MMAP) && !defined(OM_MALLOC_MAX_BYTES_SBRK)
    if (! om_SbrkInit) om_SbrkInit = (unsigned long) sbrk(0) - size;
    if (om_Info.CurrentBytesFromMalloc + om_Info.CurrentBytesFromValloc > om_Info.MaxBytesSbrk)
    {
      om_Info.MaxBytesSbrk = (unsigned long) sbrk(0) - om_SbrkInit;
      omAssume(om_Info.MaxBytesSbrk >= om_Info.CurrentBytesFromMalloc
               + om_Info.CurrentBytesFromValloc);
    }
#endif
  }
  OM_VALLOC_HOOK(size);
  return page;
}

omAlloc0Large()

void * omAlloc0Large

(

size_t

size

)

Definition at line 82 of file omAllocSystem.c.

{
  void* addr = omAllocLarge(size);
  memset(addr, 0, size);
  return addr;
}

omAllocFromSystem()

void * omAllocFromSystem

(

size_t

size

)

Definition at line 194 of file omAllocSystem.c.

{
  void* ptr;
 
  ptr = OM_MALLOC_FROM_SYSTEM(size);
  if (ptr == NULL)
  {
    OM_MEMORY_LOW_HOOK();
    ptr = OM_MALLOC_FROM_SYSTEM(size);
    if (ptr == NULL)
    {
      OM_OUT_OF_MEMORY_HOOK();
      exit(1);
    }
  }
#if defined(HAVE_MALLOC_SIZE) || defined(HAVE_MALLOC_USABLE_SIZE)
  size=_omSizeOfLargeAddr(ptr);
#else
  size=omSizeOfAddr(ptr);
#endif
#ifndef OM_NDEBUG
  if (((unsigned long) ptr) + size > om_MaxAddr)
    om_MaxAddr = ((unsigned long) ptr) + size;
  if (((unsigned long) ptr) < om_MinAddr)
    om_MinAddr = ((unsigned long) ptr);
#endif
 
  om_Info.CurrentBytesFromMalloc += size;
  if (om_Info.CurrentBytesFromMalloc > om_Info.MaxBytesFromMalloc)
  {
    om_Info.MaxBytesFromMalloc = om_Info.CurrentBytesFromMalloc;
#if defined(OM_HAVE_VALLOC_MMAP) && defined(OM_MALLOC_MAX_BYTES_SYSTEM)
    if (om_Info.CurrentBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM > om_Info.MaxBytesSystem)
      om_Info.MaxBytesSystem = om_Info.CurrentBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM;
#endif
#if defined(HAVE_SBRK) && !defined(OM_MALLOC_MAX_BYTES_SBRK)
    if (! om_SbrkInit) om_SbrkInit = (unsigned long) sbrk(0) - size;
    if (om_Info.MaxBytesFromMalloc
#ifndef OM_HAVE_VALLOC_MMAP
        + om_Info.CurrentBytesFromValloc
#endif
        > om_Info.MaxBytesSbrk)
    {
      om_Info.MaxBytesSbrk = (unsigned long) sbrk(0) - om_SbrkInit;
    }
#endif
  }
  OM_MALLOC_HOOK(size);
  return ptr;
}

omAllocLarge()

void * omAllocLarge

(

size_t

size

)

Definition at line 48 of file omAllocSystem.c.

{
  char* addr;
  size = OM_ALIGN_SIZE(size);
  addr = omAllocFromSystem(size + SIZEOF_STRICT_ALIGNMENT);
  *((size_t*) addr) = size;
  return (void *)(addr + SIZEOF_STRICT_ALIGNMENT);
}

omFreeLarge()

void omFreeLarge

(

void *

addr

)

Definition at line 73 of file omAllocSystem.c.

{
  char* _addr = (char *)addr - SIZEOF_STRICT_ALIGNMENT;
  omFreeSizeToSystem(_addr, *((size_t*) _addr) + SIZEOF_STRICT_ALIGNMENT);
}

omFreeSizeToSystem()

void omFreeSizeToSystem	(	void *	addr,
		size_t	size )

Definition at line 311 of file omAllocSystem.c.

{
  OM_FREE_TO_SYSTEM( addr );
  om_Info.CurrentBytesFromMalloc -= size;
  OM_FREE_HOOK(size);
}

omFreeToSystem()

void omFreeToSystem

(

void *

addr

)

Definition at line 306 of file omAllocSystem.c.

{
  omFreeSizeToSystem(addr, omSizeOfAddr(addr));
}

omRealloc0Large()

void * omRealloc0Large	(	void *	old_addr,
		size_t	new_size )

Definition at line 89 of file omAllocSystem.c.

{
  size_t old_size;
  char* new_addr;
 
  omAssume(!omIsBinPageAddr(old_addr));
 
  old_size = omSizeOfLargeAddr(old_addr);
 
  new_addr = omReallocLarge(old_addr, new_size);
  new_size = omSizeOfLargeAddr(new_addr);
  if (new_size > old_size)
    memset(new_addr + old_size, 0, new_size - old_size);
  return (void *)new_addr;
}

omReallocFromSystem()

void * omReallocFromSystem	(	void *	addr,
		size_t	newsize )

Definition at line 245 of file omAllocSystem.c.

{
  return omReallocSizeFromSystem(addr, omSizeOfAddr(addr), newsize);
}

omReallocLarge()

void * omReallocLarge	(	void *	old_addr,
		size_t	new_size )

Definition at line 57 of file omAllocSystem.c.

{
  char* _old_addr;
  char* new_addr;
 
  omAssume(omIsLargeAddr(old_addr));
 
  new_size = OM_ALIGN_SIZE(new_size);
  _old_addr = (char *)old_addr - SIZEOF_STRICT_ALIGNMENT;
  new_addr = omReallocSizeFromSystem(_old_addr,
                                     *((size_t*) _old_addr) + SIZEOF_STRICT_ALIGNMENT,
                                     new_size + SIZEOF_STRICT_ALIGNMENT);
  *((size_t*) new_addr) = new_size;
  return (void *)(new_addr + SIZEOF_STRICT_ALIGNMENT);
}

omReallocSizeFromSystem()

void * omReallocSizeFromSystem	(	void *	addr,
		size_t	oldsize,
		size_t	newsize )

Definition at line 250 of file omAllocSystem.c.

{
  void* res;
 
  /*oldsize=omSizeOfLargeAddr(addr);*/
  res = OM_REALLOC_FROM_SYSTEM(addr, newsize);
  if (res == NULL)
  {
    OM_MEMORY_LOW_HOOK();
    /* Can do a realloc again: manpage reads:
       "If realloc() fails the original block is left untouched -
       it is not freed or moved." */
    res = OM_REALLOC_FROM_SYSTEM(addr, newsize);
    if (res == NULL)
    {
      OM_OUT_OF_MEMORY_HOOK();
      /* should never get here */
      omAssume(0);
      exit(1);
    }
  }
  /*newsize=omSizeOfAddr(res);*/
 
#ifndef OM_NDEBUG
  if (((unsigned long) res) + newsize > om_MaxAddr)
    om_MaxAddr = ((unsigned long) res) + newsize;
  if (((unsigned long) res) < om_MinAddr)
    om_MinAddr = ((unsigned long) res);
#endif
 
  om_Info.CurrentBytesFromMalloc += (long) newsize - (long) oldsize;
 
 
  if (om_Info.CurrentBytesFromMalloc > om_Info.MaxBytesFromMalloc)
  {
    om_Info.MaxBytesFromMalloc = om_Info.CurrentBytesFromMalloc;
#if defined(OM_HAVE_VALLOC_MMAP) && defined(OM_MALLOC_MAX_BYTES_SYSTEM)
    if (om_Info.CurrentBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM > om_Info.MaxBytesSystem)
      om_Info.MaxBytesSystem = om_Info.CurrentBytesFromValloc + OM_MALLOC_MAX_BYTES_SYSTEM;
#endif
#if defined(HAVE_SBRK) && !defined(OM_MALLOC_MAX_BYTES_SBRK)
    if (om_Info.MaxBytesFromMalloc
#ifndef OM_HAVE_VALLOC_MMAP
        + om_Info.CurrentBytesFromValloc
#endif
        > om_Info.MaxBytesSbrk)
    {
      om_Info.MaxBytesSbrk = (unsigned long) sbrk(0) - om_SbrkInit;
    }
#endif
  }
 
  OM_REALLOC_HOOK(oldsize, newsize);
  return res;
}

omSizeOfAddr()

size_t omSizeOfAddr

(

const void *

addr

)

Definition at line 110 of file omAllocSystem.c.

{
  /*if (addr==NULL) return 0; */
 
  return (omIsBinPageAddr(addr) ?
#ifdef OM_HAVE_TRACK
          (omIsBinAddrTrackAddr(addr) ? omOutSizeOfTrackAddr((char *)addr) : omSizeOfBinAddr(addr)) :
#else
          omSizeOfBinAddr(addr) :
#endif
          omSizeOfLargeAddr((char *)addr));
}

omSizeOfLargeAddr()

size_t omSizeOfLargeAddr

(

void *

addr

)

Definition at line 105 of file omAllocSystem.c.

{
  return _omSizeOfLargeAddr((char *)addr);
}

omSizeWOfAddr()

size_t omSizeWOfAddr

(

void *

addr

)

Definition at line 123 of file omAllocSystem.c.

{
 
  return (omIsBinPageAddr(addr) ?
#ifdef OM_HAVE_TRACK
          (omIsBinAddrTrackAddr(addr) ? omOutSizeOfTrackAddr(addr) >> LOG_SIZEOF_LONG : omSizeWOfBinAddr(addr)) :
#else
          omSizeWOfBinAddr(addr) :
#endif
          omSizeOfLargeAddr(addr) >> LOG_SIZEOF_LONG);
}

omVfreeToSystem()

void omVfreeToSystem	(	void *	page,
		size_t	size )

Definition at line 368 of file omAllocSystem.c.

{
  omAssume(omIsAddrPageAligned(page));
  OM_VFREE_TO_SYSTEM(page, size);
  om_Info.CurrentBytesFromValloc  -= size;
  OM_VFREE_HOOK(size);
}