org.mmtk.utility.deque
Class LocalSSB

java.lang.Object
  org.mmtk.utility.deque.Deque
      org.mmtk.utility.deque.LocalSSB

All Implemented Interfaces:

Constants

Direct Known Subclasses:

LocalQueue, WriteBuffer

 class LocalSSB
extends Deque
implements Constants

This class implements a local (unsynchronized) sequential store buffer. An SSB is strictly FIFO (although this class does not implement dequeuing).

Each instance stores word-sized values into a local buffer. When the buffer is full, or if the flushLocal() method is called, the buffer enqueued at the tail of a SharedDeque. This class provides no mechanism for dequeing.

The implementation is intended to be as efficient as possible, in time and space, as it is used in critical code such as the GC work queue and the write buffer used by many "remembering" collectors. Each instance has just two fields: a bump pointer and a pointer to the SharedDeque

Preconditions: Buffers are always aligned on buffer-size address boundaries.

Invariants: Buffers are filled such that tuples (of the specified arity) are packed to the low end of the buffer. Thus buffer overflows on inserts and pops (underflow actually) will always arise when then cursor is buffer-size aligned.

tail

protected Address tail

the location in the buffer

tailBufferEnd

protected Address tailBufferEnd

the end of the buffer

queue

protected final SharedDeque queue

the shared queue

LocalSSB

LocalSSB(SharedDeque queue)

Constructor

Parameters:

queue - The shared queue to which this local ssb will append its buffers (when full or flushed).

flushLocal

public void flushLocal()

Flush the buffer and add it to the shared queue (this will make any entries in the buffer visible to any consumer associated with the shared queue).

reset

public void reset()

resetLocal

public void resetLocal()

Reset the local buffer (throwing away any local entries).

checkTailInsert

protected final void checkTailInsert(int arity)

Check whether there is space in the buffer for a pending insert. If there is not sufficient space, allocate a new buffer (dispatching the full buffer to the shared queue if not null).

Parameters:

arity - The arity of the values stored in this SSB: the buffer must contain enough space for this many words.

uncheckedTailInsert

protected final void uncheckedTailInsert(Address value)

Insert a value into the buffer. This is unchecked. The caller must first call checkInsert() to ensure the buffer can accommodate the insertion.

Parameters:

value - the value to be inserted.

normalizeTail

protected final Address normalizeTail(int arity)

In the case where a buffer must be flushed before being filled (either to the queue or to the head), the entries must be slid to the base of the buffer in order to preserve the invariant that all non-tail buffers will have entries starting at the base (which allows a simple test against the base to be used when popping entries). This is expensive, so should be avoided.

Parameters:

arity - The arity of the buffer in question

Returns:

The last slot in the normalized buffer that contains an entry

bufferSentinel

protected final Offset bufferSentinel(int arity)

Return the sentinel offset for a buffer of a given arity. This is used both to compute the address at the end of the buffer.

Parameters:

arity - The arity of this buffer

Returns:

The sentinel offset value for a buffer of the given arity.

tailOverflow

private void tailOverflow(int arity)

Buffer space has been exhausted, allocate a new buffer and enqueue the existing buffer (if any).

Parameters:

arity - The arity of this buffer (used for sanity test only).

closeAndEnqueueTail

private void closeAndEnqueueTail(int arity)

Close the tail buffer (normalizing if necessary), and enqueue it at the tail of the shared buffer queue.

Parameters:

arity - The arity of this buffer.

isFlushed

public final boolean isFlushed()

Return true if this SSB is locally empty

Returns:

true if this SSB is locally empty