poolalloc/runtime/FL2Allocator/PoolAllocator.h

//===- PoolAllocator.h - Pool allocator runtime interface file --*- C++ -*-===//
// 
//                     The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
// 
//===----------------------------------------------------------------------===//
//
// This file defines the interface which is implemented by the LLVM pool
// allocator runtime library.
//
//===----------------------------------------------------------------------===//

#ifndef POOLALLOCATOR_RUNTIME_H
#define POOLALLOCATOR_RUNTIME_H

struct PoolSlab;
struct FreedNodeHeader;

// NodeHeader - Each block of memory is preceeded in the the pool by one of
// these headers.  If the node is allocated, the ObjectSize value is used, if
// the object is free, the 'Next' value is used.
struct NodeHeader {
  unsigned Size;
};


// When objects are on the free list, we pretend they have this header.  
struct FreedNodeHeader {
  // NormalHeader - This is the normal node header that is on allocated or free
  // blocks.
  NodeHeader Header;

  // Next - The next object in the free list.
  FreedNodeHeader *Next;

  // PrevP - The pointer that points to this node on the free list.
  FreedNodeHeader **PrevP;
};


// Large Arrays are passed on to directly malloc, and are not necessarily page
// aligned.  These arrays are marked by setting the object size preheader to ~0.
// LargeArrays are on their own list to allow for efficient deletion.
struct LargeArrayHeader {
  LargeArrayHeader **Prev, *Next;
  
  // Marker: this is the ObjectSize marker which MUST BE THE LAST ELEMENT of
  // this header!
  unsigned Marker;
};


// FreeList*Size - These are size classes for each of the freelists in a pool.
// An object in a particular free list is guaranteed to be <= this size.
enum {
  FreeListZeroSize = 8,
  FreeListOneSize  = 12,
  FreeListTwoSize  = 16,

  // There are four free lists.
  LargeFreeList = 3
};

struct PoolTy {
  // Lists - the list of slabs in this pool.
  PoolSlab *Slabs;

  // The free node lists for objects of various sizes.  
  FreedNodeHeader *FreeNodeLists[4];

  // NumObjects - the number of poolallocs for this pool.
  unsigned NumObjects;

  // BytesAllocated - The total number of bytes ever allocated from this pool.
  // Together with NumObjects, allows us to calculate average object size.
  unsigned BytesAllocated;

  // LargeArrays - A doubly linked list of large array chunks, dynamically
  // allocated with malloc.
  LargeArrayHeader *LargeArrays;

  // The size to allocate for the next slab.
  unsigned AllocSize;

  // The declared size of the pool, just kept for the record.
  unsigned DeclaredSize;
};

extern "C" {
  void poolinit(PoolTy *Pool, unsigned DeclaredSize);
  void poolmakeunfreeable(PoolTy *Pool);
  void pooldestroy(PoolTy *Pool);
  void *poolalloc(PoolTy *Pool, unsigned NumBytes);
  void poolfree(PoolTy *Pool, void *Node);
}

#endif