org.mmtk.utility.alloc

Class SegregatedFreeListLocal<S extends SegregatedFreeListSpace>

java.lang.Object

org.mmtk.utility.alloc.Allocator

org.mmtk.utility.alloc.SegregatedFreeList<S>

org.mmtk.utility.alloc.SegregatedFreeListLocal<S>

Direct Known Subclasses:

ExplicitFreeListLocal, MarkSweepLocal

public abstract class SegregatedFreeListLocal<S extends SegregatedFreeListSpace>
extends SegregatedFreeList<S>

This abstract class implements a simple segregated free list.

See: Wilson, Johnstone, Neely and Boles "Dynamic Storage Allocation: A Survey and Critical Review", IWMM 1995, for an overview of free list allocation and the various implementation strategies, including segregated free lists.

We maintain a number of size classes, each size class having a free list of available objects of that size (the list may be empty). We call the storage elements "cells". Cells reside within chunks of memory called "blocks". All cells in a given block are of the same size (i.e. blocks are homogeneous with respect to size class). Each block maintains its own free list (free cells within that block). For each size class a list of blocks is maintained, one of which will serve the role of the current free list. When the free list on the current block is exhausted, the next block for that size class becomes the current block and its free list is used. If there are no more blocks the a new block is allocated.

Field Summary

Fields

Modifier and Type	Field and Description
protected AddressArray	currentBlock

Fields inherited from class org.mmtk.utility.alloc.SegregatedFreeList

freeList, space

Constructor Summary

Constructors

Constructor and Description
SegregatedFreeListLocal(S space) Constructor

Method Summary

Modifier and Type	Method and Description
Address	allocSlowOnce(int bytes, int align, int offset) Allocate bytes contiguous bytes of non-zeroed memory.
void	flush() Zero all of the current free list pointers, and refresh the currentBlock values, so instead of the free list pointing to free cells, it points to the block containing the free cells.

Methods inherited from class org.mmtk.utility.alloc.SegregatedFreeList

alloc, getSpace

Methods inherited from class org.mmtk.utility.alloc.Allocator

alignAllocation, alignAllocation, alignAllocationNoFill, allocSlow, allocSlowInline, determineCollectionAttempts, fillAlignmentGap, getMaximumAlignedSize, getMaximumAlignedSize

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

currentBlock

protected final AddressArray currentBlock

Constructor Detail

SegregatedFreeListLocal

public SegregatedFreeListLocal(S space)

Constructor

Parameters:

space - The space with which this allocator will be associated

Method Detail

allocSlowOnce

public final Address allocSlowOnce(int bytes,
                                   int align,
                                   int offset)

Allocate bytes contiguous bytes of non-zeroed memory. First check if the fast path works. This is needed since this method may be called in the context when the fast version was NOT just called. If this fails, it will try finding another block with a non-empty free list, or allocating a new block.

This code should be relatively infrequently executed, so it is forced out of line to reduce pressure on the compilation of the core alloc routine.

Precondition: None

Postconditions: A new cell has been allocated (not zeroed), and the block containing the cell has been placed on the appropriate free list data structures. The free list itself is not updated (the caller must do so).

Specified by:

allocSlowOnce in class Allocator

Parameters:

bytes - The size of the object to occupy this space, in bytes.

offset - The alignment offset.

align - The requested alignment.

Returns:

The address of the first word or zero on failure.

flush

public final void flush()

Zero all of the current free list pointers, and refresh the currentBlock values, so instead of the free list pointing to free cells, it points to the block containing the free cells. Then the free lists for each cell can be reestablished during GC. If the free lists are being preserved on a per-block basis (eager mark-sweep and reference counting), then free lists are remembered for each block.