org.mmtk.utility.deque
Class SharedDeque

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

All Implemented Interfaces:

Constants

Direct Known Subclasses:

SortSharedDeque

public class SharedDeque
extends Deque
implements Constants

This supports unsynchronized enqueuing and dequeuing of buffers for shared use. The data can be added to and removed from either end of the deque.

DISABLE_WAITING

private static final boolean DISABLE_WAITING

See Also:

Constant Field Values

NEXT_OFFSET

private static final Offset NEXT_OFFSET

PREV_OFFSET

private static final Offset PREV_OFFSET

TRACE

private static final boolean TRACE

See Also:

Constant Field Values

TRACE_DETAIL

private static final boolean TRACE_DETAIL

See Also:

Constant Field Values

TRACE_BLOCKERS

private static final boolean TRACE_BLOCKERS

See Also:

Constant Field Values

name

private final String name

The name of this shared deque - for diagnostics

rps

private RawPageSpace rps

Raw page space from which to allocate

arity

private final int arity

Number of words per entry

completionFlag

private volatile int completionFlag

Completion flag - set when all consumers have arrived at the barrier

numConsumers

private volatile int numConsumers

# active threads - processing is complete when # waiting == this

numConsumersWaiting

private volatile int numConsumersWaiting

# threads waiting

head

protected volatile Address head

Head of the shared deque

tail

protected volatile Address tail

Tail of the shared deque

bufsenqueued

private volatile int bufsenqueued

lock

private Lock lock

WARN_PERIOD

private static final long WARN_PERIOD

See Also:

Constant Field Values

TIMEOUT_PERIOD

private static final long TIMEOUT_PERIOD

See Also:

Constant Field Values

SharedDeque

public SharedDeque(String name,
                   RawPageSpace rps,
                   int arity)

Constructor

getArity

final int getArity()

Get the arity (words per entry) of this queue

enqueue

final void enqueue(Address buf,
                   int arity,
                   boolean toTail)

Enqueue a block on the head or tail of the shared queue

Parameters:

buf -

arity -

toTail -

clearDeque

public final void clearDeque(int arity)

dequeue

final Address dequeue(int arity)

dequeue

final Address dequeue(int arity,
                      boolean fromTail)

dequeueAndWait

final Address dequeueAndWait(int arity)

dequeueAndWait

final Address dequeueAndWait(int arity,
                             boolean fromTail)

prepare

public final void prepare()

Prepare for parallel processing. All active GC threads will participate, and pop operations will block until all work is complete.

prepareNonBlocking

public final void prepareNonBlocking()

Prepare for processing where pop operations on the deques will never block.

prepare

private void prepare(int consumers)

Prepare for parallel processing where a specific number of threads take part.

Parameters:

consumers - # threads taking part.

reset

public final void reset()

assertExhausted

public final void assertExhausted()

alloc

final Address alloc()

free

final void free(Address buf)

enqueuedPages

public final int enqueuedPages()

dequeue

private Address dequeue(boolean waiting,
                        boolean fromTail)

Dequeue a block from the shared pool. If 'waiting' is true, and the queue is empty, wait for either a new block to show up or all the other consumers to join us.

Parameters:

waiting -

fromTail -

Returns:

the Address of the block

spinWait

private void spinWait(boolean fromTail)

Spinwait for GC work to arrive

Parameters:

fromTail - Check the head or the tail ?

setNext

private static void setNext(Address buf,
                            Address next)

Set the "next" pointer in a buffer forming the linked buffer chain.

Parameters:

buf - The buffer whose next field is to be set.

next - The reference to which next should point.

getNext

protected final Address getNext(Address buf)

Get the "next" pointer in a buffer forming the linked buffer chain.

Parameters:

buf - The buffer whose next field is to be returned.

Returns:

The next field for this buffer.

setPrev

private void setPrev(Address buf,
                     Address prev)

Set the "prev" pointer in a buffer forming the linked buffer chain.

Parameters:

buf - The buffer whose next field is to be set.

prev - The reference to which prev should point.

getPrev

protected final Address getPrev(Address buf)

Get the "next" pointer in a buffer forming the linked buffer chain.

Parameters:

buf - The buffer whose next field is to be returned.

Returns:

The next field for this buffer.

checkDequeLength

private boolean checkDequeLength(int length)

Check the number of buffers in the work queue (for debugging purposes).

Parameters:

length - The number of buffers believed to be in the queue.

Returns:

True if the length of the queue matches length.

lock

private void lock()

Lock this shared queue. We use one simple low-level lock to synchronize access to the shared queue of buffers.

unlock

private void unlock()

Release the lock. We use one simple low-level lock to synchronize access to the shared queue of buffers.

complete

private boolean complete()

Is the current round of processing complete ?

setCompletionFlag

private void setCompletionFlag()

Set the completion flag.

clearCompletionFlag

private void clearCompletionFlag()

Clear the completion flag.

setNumConsumers

private void setNumConsumers(int newNumConsumers)

setNumConsumersWaiting

private void setNumConsumersWaiting(int newNCW)

setHead

private void setHead(Address newHead)

setTail

private void setTail(Address newTail)