com.bigdata.cache

Class HardReferenceQueueWithBatchingUpdates<T>

java.lang.Object

com.bigdata.cache.HardReferenceQueueWithBatchingUpdates<T>

All Implemented Interfaces:

IHardReferenceQueue<T>

public class HardReferenceQueueWithBatchingUpdates<T>
extends Object
implements IHardReferenceQueue<T>

A variant relying on thread-local IHardReferenceQueues to batch updates and thus minimize thread contention for the lock required to synchronize calls to add(Object).

Version:

$Id$

Author:

Bryan Thompson

Field Summary

Fields inherited from interface com.bigdata.cache.IHardReferenceQueue

DEFAULT_NSCAN

Constructor Summary

Constructors

Constructor and Description
HardReferenceQueueWithBatchingUpdates(boolean threadLocalBuffers, int concurrencyLevel, IHardReferenceQueue<T> sharedQueue, int threadLocalQueueNScan, int threadLocalQueueCapacity, int threadLocalTryLockSize, com.bigdata.cache.IBatchedUpdateListener<T> batchedUpdateListener)
HardReferenceQueueWithBatchingUpdates(IHardReferenceQueue<T> sharedQueue, int threadLocalQueueNScan, int threadLocalQueueCapacity, int threadLocalTryLockSize, com.bigdata.cache.IBatchedUpdateListener<T> batchedUpdateListener) Designated constructor.

Method Summary

Methods

Modifier and Type	Method and Description
boolean	add(T ref) Adds the reference to the thread-local queue, returning true iff the queue was modified as a result.
int	capacity() The capacity of the shared queue.
void	clear(boolean clearRefs) Discards the thread-local buffers and clears the backing ring buffer.
boolean	contains(Object ref) Not supported.
boolean	evict() Not supported.
void	evictAll(boolean clearRefs) Not supported.
boolean	isEmpty() Not supported.
boolean	isFull() Not supported.
int	nscan() The nscan value of the shared queue.
boolean	offer(T ref) Offers the reference to the thread-local queue, returning true iff the queue was modified as a result.
T	peek() Not supported.
int	size() The size of the shared queue (approximate).

Methods inherited from class java.lang.Object

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

Constructor Detail

HardReferenceQueueWithBatchingUpdates

public HardReferenceQueueWithBatchingUpdates(IHardReferenceQueue<T> sharedQueue,
                                     int threadLocalQueueNScan,
                                     int threadLocalQueueCapacity,
                                     int threadLocalTryLockSize,
                                     com.bigdata.cache.IBatchedUpdateListener<T> batchedUpdateListener)

Designated constructor.

Parameters:

sharedQueue - The backing IHardReferenceQueue.

threadLocalQueueNScan - The #of references to scan on the thread-local queue.

threadLocalQueueCapacity - The capacity of the thread-local queues in which the updates are gathered before they are batched into the shared queue. This must be at least

threadLocalTryLockSize - Once the thread-local queue is this full an attempt will be made to barge in on the lock and batch the updates to the shared queue. This feature may be disabled by passing ZERO (0).

HardReferenceQueueWithBatchingUpdates

public HardReferenceQueueWithBatchingUpdates(boolean threadLocalBuffers,
                                     int concurrencyLevel,
                                     IHardReferenceQueue<T> sharedQueue,
                                     int threadLocalQueueNScan,
                                     int threadLocalQueueCapacity,
                                     int threadLocalTryLockSize,
                                     com.bigdata.cache.IBatchedUpdateListener<T> batchedUpdateListener)

Method Detail

size

public int size()

The size of the shared queue (approximate).

Specified by:

size in interface IHardReferenceQueue<T>

capacity

public int capacity()

The capacity of the shared queue.

Specified by:

capacity in interface IHardReferenceQueue<T>

nscan

public int nscan()

The nscan value of the shared queue.

Specified by:

nscan in interface IHardReferenceQueue<T>

evict

public boolean evict()

Not supported.

Specified by:

evict in interface IHardReferenceQueue<T>

Returns:

true iff a reference was evicted.

See Also:

HardReferenceQueueEvictionListener

evictAll

public void evictAll(boolean clearRefs)

Not supported.

Specified by:

evictAll in interface IHardReferenceQueue<T>

Parameters:

clearRefs - When true, the reference are actually cleared from the cache. This may be false to force persistence of the references in the cache without actually clearing the cache.

isEmpty

public boolean isEmpty()

Not supported.

Specified by:

isEmpty in interface IHardReferenceQueue<T>

isFull

public boolean isFull()

Not supported.

Specified by:

isFull in interface IHardReferenceQueue<T>

peek

public T peek()

Not supported.

Specified by:

peek in interface IHardReferenceQueue<T>

add

public final boolean add(T ref)

Adds the reference to the thread-local queue, returning true iff the queue was modified as a result.

When using true thread-local buffers, this is non-blocking unless the thread-local queue is full. If the thread-local queue is full, the existing references will be batched first onto the shared queue.

Contention can arise when using striped locks. For the synthetic test (on a 2 core laptop with 8 threads), implementing using per-thread BatchQueues scores 6,984,896 ops/sec whereas implementing using striped locks the performance score is only 4,654,673. One thread on the laptop has a throughput of 4,856,814, the maximum possible throughput for 2 threads is ~ 9M. The actual performance of the striped locks approach depends on the degree of collision in the Thread.getId() values and the #of BatchQueue instances in the array.

While striped locks clearly have less throughput when compared to thread- local BatchQueues, the striped lock performance can be significantly better than implementations without lock amortization strategies and we do not have to worry about references on BatchQueues "escaping" when we rarely see requests for some threads (which is basically a memory leak).

Specified by:

add in interface IHardReferenceQueue<T>

Parameters:

ref - The reference to be added.

Returns:

The BatchQueue.

Throws:

InterruptedException - TODO Actually, using the CHM (7M ops/sec) rather than acquiring a permit (4.7M ops/sec) is MUCH less expensive even when using only one thread. The permit is clearly costing us. Striped locks might do as well as thread-local locks if we could replace the permit with a less expensive lock.

offer

public final boolean offer(T ref)

Offers the reference to the thread-local queue, returning true iff the queue was modified as a result. This is non-blocking unless the thread-local queue is full. If the thread-local queue is full, the existing references will be batched first onto the shared queue.

clear

public final void clear(boolean clearRefs)

Discards the thread-local buffers and clears the backing ring buffer.

Note: This method can have side-effects from asynchronous operations if the queue is still in use.

Specified by:

clear in interface IHardReferenceQueue<T>

Parameters:

clearRefs - When true the references are explicitly set to null which can facilitate garbage collection.

contains

public final boolean contains(Object ref)

Not supported.