ElasticScheduler (kontraktor 2.00 API)

java.lang.Object
- org.nustaq.kontraktor.impl.ElasticScheduler

All Implemented Interfaces:

Monitorable, Scheduler

Direct Known Subclasses:

RemoteScheduler
```
public class ElasticScheduler
extends Object
implements Scheduler, Monitorable
```
Created by ruedi on 13.06.14. A scheduler implementing "vertical" scaling. Instead of distributing load amongs a given set of threads, it increases the number of threads/cores with load. This way an actor has an dedicated thread executing it instead of random thread hopping when using an executor to schedule actor messages. Additionally this way I can use spin locks without going to 800% CPU if threadmax = 8.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class ElasticScheduler.SchedulingReport

Nested Classes
Modifier and Type	Class and Description
`static class`	`ElasticScheduler.SchedulingReport`

Field Summary

Fields
Modifier and Type	Field and Description
`protected BackOffStrategy`	`backOffStrategy`
`static boolean`	`DEBUG_SCHEDULING`
`static int`	`DEFQSIZE`
`static Timer`	`delayedCalls`
`protected ExecutorService`	`exec`
`static int`	`MAX_STACK_ON_SYNC_CBDISPATCH`
`static boolean`	`REALLY_DEBUG_SCHEDULING`
`static int`	`RECURSE_ON_BLOCK_THRESHOLD`

Constructor Summary

Constructors
Constructor and Description

ElasticScheduler(int maxThreads)

ElasticScheduler(int maxThreads, int defQSize)

Constructors
Constructor and Description
`ElasticScheduler(int maxThreads)`
`ElasticScheduler(int maxThreads, int defQSize)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Future`	`$getReport()`
`Future<Monitorable[]>`	`$getSubMonitorables()`
`DispatcherThread`	`assignDispatcher(int minLoadPerc)` if a low load thread is avaiable, return it. else try creation of new thread.
`protected DispatcherThread`	`createDispatcherThread()`
`void`	`delayedCall(long millis, Runnable toRun)`
`Object`	`enqueueCall(Actor sendingActor, Actor receiver, String methodName, Object[] args, boolean isCB)`
`int`	`getActiveThreads()`
`BackOffStrategy`	`getBackoffStrategy()`
`int`	`getDefaultQSize()`
`InvocationHandler`	`getInvoker(Actor dispatcher, Object toWrap)`
`int`	`getMaxThreads()`
`<T> T`	`inThread(Actor actor, T callback)` Creates a wrapper on the given object enqueuing all calls to INTERFACE methods of the given object to the given actors's queue.
`Future`	`put2QueuePolling(CallEntry e)`
`void`	`put2QueuePolling(Queue q, boolean isCBQ, Object o, Object receiver)`
`void`	`rebalance(DispatcherThread dispatcherThread)` called from inside overloaded thread.
`<T> void`	`runBlockingCall(Actor emitter, Callable<T> toCall, Callback<T> resultHandler)`
`void`	`runOutside(Actor actor, Runnable toRun)`
`void`	`threadStopped(DispatcherThread th)`
`void`	`tryIsolate(DispatcherThread dispatcherThread, Actor refToExclude)`
`void`	`tryStopThread(DispatcherThread dispatcherThread)` stepwise move actors onto other dispatchers.
`Future<Future[]>`	`yield(Future... futures)` wait for all futures to complete and return an array of fulfilled futures e.g. yield( f1, f2 ).then( (f,e) -> System.out.println( f[0].getResult() + f[1].getResult() ) );
`void`	`yield(int count)`
`Future<List<Future>>`	`yield(List<Future> futures)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - MAX_STACK_ON_SYNC_CBDISPATCH
```
public static final int MAX_STACK_ON_SYNC_CBDISPATCH
```
    See Also:
    
    Constant Field Values
  - DEFQSIZE
```
public static int DEFQSIZE
```
  - DEBUG_SCHEDULING
```
public static boolean DEBUG_SCHEDULING
```
  - REALLY_DEBUG_SCHEDULING
```
public static boolean REALLY_DEBUG_SCHEDULING
```
  - RECURSE_ON_BLOCK_THRESHOLD
```
public static int RECURSE_ON_BLOCK_THRESHOLD
```
  - backOffStrategy
```
protected BackOffStrategy backOffStrategy
```
  - exec
```
protected ExecutorService exec
```
  - delayedCalls
```
public static Timer delayedCalls
```
- Constructor Detail
  - ElasticScheduler
```
public ElasticScheduler(int maxThreads)
```
  - ElasticScheduler
```
public ElasticScheduler(int maxThreads,
                        int defQSize)
```
- Method Detail
  - getActiveThreads
```
public int getActiveThreads()
```
  - getMaxThreads
```
public int getMaxThreads()
```
    Specified by:
    
    getMaxThreads in interface Scheduler
  - getDefaultQSize
```
public int getDefaultQSize()
```
    Specified by:
    
    getDefaultQSize in interface Scheduler
  - put2QueuePolling
```
public Future put2QueuePolling(CallEntry e)
```
  - yield
```
public void yield(int count)
```
    Specified by:
    
    yield in interface Scheduler
  - put2QueuePolling
```
public void put2QueuePolling(Queue q,
                             boolean isCBQ,
                             Object o,
                             Object receiver)
```
    Specified by:
    
    put2QueuePolling in interface Scheduler
  - enqueueCall
```
public Object enqueueCall(Actor sendingActor,
                          Actor receiver,
                          String methodName,
                          Object[] args,
                          boolean isCB)
```
    Specified by:
    
    enqueueCall in interface Scheduler
  - threadStopped
```
public void threadStopped(DispatcherThread th)
```
    Specified by:
    
    threadStopped in interface Scheduler
  - getInvoker
```
public InvocationHandler getInvoker(Actor dispatcher,
                                    Object toWrap)
```
    Specified by:
    
    getInvoker in interface Scheduler
  - inThread
```
public <T> T inThread(Actor actor,
                      T callback)
```
    Creates a wrapper on the given object enqueuing all calls to INTERFACE methods of the given object to the given actors's queue. This is used to enable processing of resulting callback's in the callers thread. see also @InThread annotation.
    
    Specified by:
    
    inThread in interface Scheduler
    
    Type Parameters:
    
    T -
    
    Parameters:
    
    callback -
    
    Returns:
  - delayedCall
```
public void delayedCall(long millis,
                        Runnable toRun)
```
    Specified by:
    
    delayedCall in interface Scheduler
  - runBlockingCall
```
public <T> void runBlockingCall(Actor emitter,
                                Callable<T> toCall,
                                Callback<T> resultHandler)
```
    Specified by:
    
    runBlockingCall in interface Scheduler
  - runOutside
```
public void runOutside(Actor actor,
                       Runnable toRun)
```
    Specified by:
    
    runOutside in interface Scheduler
  - yield
```
public Future<Future[]> yield(Future... futures)
```
    wait for all futures to complete and return an array of fulfilled futures e.g. yield( f1, f2 ).then( (f,e) -> System.out.println( f[0].getResult() + f[1].getResult() ) );
    
    Specified by:
    
    yield in interface Scheduler
    
    Parameters:
    
    futures -
    
    Returns:
  - yield
```
public Future<List<Future>> yield(List<Future> futures)
```
    Specified by:
    
    yield in interface Scheduler
  - assignDispatcher
```
public DispatcherThread assignDispatcher(int minLoadPerc)
```
    if a low load thread is avaiable, return it. else try creation of new thread. if this is not possible return thread with lowest load
    
    Specified by:
    
    assignDispatcher in interface Scheduler
    
    Returns:
  - createDispatcherThread
```
protected DispatcherThread createDispatcherThread()
```
    Returns:
    
    an UNSTARTED dispatcher thread
  - rebalance
```
public void rebalance(DispatcherThread dispatcherThread)
```
    called from inside overloaded thread. all actors assigned to the calling thread therefore can be safely moved
    
    Specified by:
    
    rebalance in interface Scheduler
    
    Parameters:
    
    dispatcherThread -
  - tryIsolate
```
public void tryIsolate(DispatcherThread dispatcherThread,
                       Actor refToExclude)
```
    Specified by:
    
    tryIsolate in interface Scheduler
  - tryStopThread
```
public void tryStopThread(DispatcherThread dispatcherThread)
```
    stepwise move actors onto other dispatchers. Note actual termination is not done here. removes given dispatcher from the scheduling array, so this thread won't be visible to scheduling anymore. In extreme this could lead to high thread numbers, however this behaviour was never observed until now .. FIXME: in case decoupled threads live forever, do a hard stop on them FIXME: sort by load and spread load amongst all threads (current find min and put removedActors on it).
    
    Specified by:
    
    tryStopThread in interface Scheduler
    
    Parameters:
    
    dispatcherThread -
  - getBackoffStrategy
```
public BackOffStrategy getBackoffStrategy()
```
    Specified by:
    
    getBackoffStrategy in interface Scheduler
  - $getReport
```
public Future $getReport()
```
    Specified by:
    
    $getReport in interface Monitorable
  - $getSubMonitorables
```
public Future<Monitorable[]> $getSubMonitorables()
```
    Specified by:
    
    $getSubMonitorables in interface Monitorable

Class ElasticScheduler

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MAX_STACK_ON_SYNC_CBDISPATCH

DEFQSIZE

DEBUG_SCHEDULING

REALLY_DEBUG_SCHEDULING

RECURSE_ON_BLOCK_THRESHOLD

backOffStrategy

exec

delayedCalls

Constructor Detail

ElasticScheduler

ElasticScheduler

Method Detail

getActiveThreads

getMaxThreads

getDefaultQSize

put2QueuePolling

yield

put2QueuePolling

enqueueCall

threadStopped

getInvoker

inThread

delayedCall

runBlockingCall

runOutside

yield

yield

assignDispatcher

createDispatcherThread

rebalance

tryIsolate

tryStopThread

getBackoffStrategy

$getReport

$getSubMonitorables