io.druid.query.topn

Class PooledTopNAlgorithm

java.lang.Object

io.druid.query.topn.BaseTopNAlgorithm<int[],BufferAggregator[],PooledTopNAlgorithm.PooledTopNParams>

io.druid.query.topn.PooledTopNAlgorithm

All Implemented Interfaces:

TopNAlgorithm<int[],PooledTopNAlgorithm.PooledTopNParams>

public class PooledTopNAlgorithm
extends BaseTopNAlgorithm<int[],BufferAggregator[],PooledTopNAlgorithm.PooledTopNParams>

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	PooledTopNAlgorithm.PooledTopNParams

Nested classes/interfaces inherited from class io.druid.query.topn.BaseTopNAlgorithm

BaseTopNAlgorithm.AggregatorArrayProvider, BaseTopNAlgorithm.BaseArrayProvider<T>

Field Summary

Fields inherited from interface io.druid.query.topn.TopNAlgorithm

EMPTY_ARRAY, INIT_POSITION_VALUE, SKIP_POSITION_VALUE

Constructor Summary

Constructors

Constructor and Description
PooledTopNAlgorithm(Capabilities capabilities, TopNQuery query, StupidPool<ByteBuffer> bufferPool)

Method Summary

Methods

Modifier and Type	Method and Description
void	cleanup(PooledTopNAlgorithm.PooledTopNParams params)
protected void	closeAggregators(BufferAggregator[] bufferAggregators)
protected BufferAggregator[]	makeDimValAggregateStore(PooledTopNAlgorithm.PooledTopNParams params)
protected int[]	makeDimValSelector(PooledTopNAlgorithm.PooledTopNParams params, int numProcessed, int numToProcess)
PooledTopNAlgorithm.PooledTopNParams	makeInitParams(DimensionSelector dimSelector, Cursor cursor)
protected void	scanAndAggregate(PooledTopNAlgorithm.PooledTopNParams params, int[] positions, BufferAggregator[] theAggregators, int numProcessed) Use aggressive loop unrolling to aggregate the data How this works: The aggregates are evaluated AGG_UNROLL_COUNT at a time.
protected int[]	updateDimValSelector(int[] dimValSelector, int numProcessed, int numToProcess)
protected void	updateResults(PooledTopNAlgorithm.PooledTopNParams params, int[] positions, BufferAggregator[] theAggregators, TopNResultBuilder resultBuilder)

Methods inherited from class io.druid.query.topn.BaseTopNAlgorithm

makeAggregators, makeBufferAggregators, makeResultBuilder, run

Methods inherited from class java.lang.Object

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

Constructor Detail

PooledTopNAlgorithm

public PooledTopNAlgorithm(Capabilities capabilities,
                   TopNQuery query,
                   StupidPool<ByteBuffer> bufferPool)

Method Detail

makeInitParams

public PooledTopNAlgorithm.PooledTopNParams makeInitParams(DimensionSelector dimSelector,
                                                  Cursor cursor)

makeDimValSelector

protected int[] makeDimValSelector(PooledTopNAlgorithm.PooledTopNParams params,
                       int numProcessed,
                       int numToProcess)

Specified by:

makeDimValSelector in class BaseTopNAlgorithm<int[],BufferAggregator[],PooledTopNAlgorithm.PooledTopNParams>

updateDimValSelector

protected int[] updateDimValSelector(int[] dimValSelector,
                         int numProcessed,
                         int numToProcess)

Specified by:

updateDimValSelector in class BaseTopNAlgorithm<int[],BufferAggregator[],PooledTopNAlgorithm.PooledTopNParams>

makeDimValAggregateStore

protected BufferAggregator[] makeDimValAggregateStore(PooledTopNAlgorithm.PooledTopNParams params)

Specified by:

makeDimValAggregateStore in class BaseTopNAlgorithm<int[],BufferAggregator[],PooledTopNAlgorithm.PooledTopNParams>

scanAndAggregate

protected void scanAndAggregate(PooledTopNAlgorithm.PooledTopNParams params,
                    int[] positions,
                    BufferAggregator[] theAggregators,
                    int numProcessed)

Use aggressive loop unrolling to aggregate the data How this works: The aggregates are evaluated AGG_UNROLL_COUNT at a time. This was chosen to be 8 rather arbitrarily. The offsets into the output buffer are precalculated and stored in aggregatorOffsets For queries whose aggregate count is less than AGG_UNROLL_COUNT, the aggregates evaluted in a switch statement. See http://en.wikipedia.org/wiki/Duff's_device for more information on this kind of approach This allows out of order execution of the code. In local tests, the JVM inlines all the way to this function. If there are more than AGG_UNROLL_COUNT aggregates, then the remainder is calculated with the switch, and the blocks of AGG_UNROLL_COUNT are calculated in a partially unrolled for-loop. Putting the switch first allows for optimization for the common case (less than AGG_UNROLL_COUNT aggs) but still optimizes the high quantity of aggregate queries which benefit greatly from any speed improvements (they simply take longer to start with).

Specified by:

scanAndAggregate in class BaseTopNAlgorithm<int[],BufferAggregator[],PooledTopNAlgorithm.PooledTopNParams>

updateResults

protected void updateResults(PooledTopNAlgorithm.PooledTopNParams params,
                 int[] positions,
                 BufferAggregator[] theAggregators,
                 TopNResultBuilder resultBuilder)

Specified by:

updateResults in class BaseTopNAlgorithm<int[],BufferAggregator[],PooledTopNAlgorithm.PooledTopNParams>

closeAggregators

protected void closeAggregators(BufferAggregator[] bufferAggregators)

Specified by:

closeAggregators in class BaseTopNAlgorithm<int[],BufferAggregator[],PooledTopNAlgorithm.PooledTopNParams>

cleanup

public void cleanup(PooledTopNAlgorithm.PooledTopNParams params)