org.apache.hadoop.hbase.ipc

Class AdaptiveLifoCoDelCallQueue

java.lang.Object

org.apache.hadoop.hbase.ipc.AdaptiveLifoCoDelCallQueue

All Implemented Interfaces:

Iterable<CallRunner>, Collection<CallRunner>, BlockingQueue<CallRunner>, Queue<CallRunner>

@InterfaceAudience.Private
public class AdaptiveLifoCoDelCallQueue
extends Object
implements BlockingQueue<CallRunner>

Adaptive LIFO blocking queue utilizing CoDel algorithm to prevent queue overloading. Implementing BlockingQueue interface to be compatible with RpcExecutor. Currently uses milliseconds internally, need to look into whether we should use nanoseconds for timeInterval and minDelay.

See Also:

Fail at Scale paper, CoDel version for generic job queues in Wangle library

Field Summary

Fields

Modifier and Type	Field and Description
private int	codelInterval
private int	codelTargetDelay
private long	intervalTime
private AtomicBoolean	isOverloaded
private double	lifoThreshold
private int	maxCapacity
private long	minDelay
private LongAdder	numGeneralCallsDropped
private LongAdder	numLifoModeSwitches
private LinkedBlockingDeque<CallRunner>	queue
private AtomicBoolean	resetDelay

Constructor Summary

Constructors

Constructor and Description
AdaptiveLifoCoDelCallQueue(int capacity, int targetDelay, int interval, double lifoThreshold, LongAdder numGeneralCallsDropped, LongAdder numLifoModeSwitches)

Method Summary

Modifier and Type	Method and Description
boolean	add(CallRunner callRunner)
boolean	addAll(Collection<? extends CallRunner> c)
void	clear()
boolean	contains(Object o)
boolean	containsAll(Collection<?> c)
int	drainTo(Collection<? super CallRunner> c)
int	drainTo(Collection<? super CallRunner> c, int maxElements)
CallRunner	element()
boolean	isEmpty()
Iterator<CallRunner>	iterator()
private boolean	needToDrop(CallRunner callRunner)
boolean	offer(CallRunner callRunner)
boolean	offer(CallRunner callRunner, long timeout, TimeUnit unit)
CallRunner	peek()
CallRunner	poll()
CallRunner	poll(long timeout, TimeUnit unit)
void	put(CallRunner callRunner)
int	remainingCapacity()
CallRunner	remove()
boolean	remove(Object o)
boolean	removeAll(Collection<?> c)
boolean	retainAll(Collection<?> c)
int	size()
CallRunner	take() Behaves as LinkedBlockingQueue.take(), except it will silently skip all calls which it thinks should be dropped.
Object[]	toArray()
<T> T[]	toArray(T[] a)
String	toString()
void	updateTunables(int newCodelTargetDelay, int newCodelInterval, double newLifoThreshold) Update tunables.

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.util.Collection

equals, hashCode, parallelStream, removeIf, spliterator, stream

Methods inherited from interface java.lang.Iterable

forEach

Field Detail

queue

private LinkedBlockingDeque<CallRunner> queue

maxCapacity

private int maxCapacity

numGeneralCallsDropped

private LongAdder numGeneralCallsDropped

numLifoModeSwitches

private LongAdder numLifoModeSwitches

codelTargetDelay

private volatile int codelTargetDelay

codelInterval

private volatile int codelInterval

lifoThreshold

private volatile double lifoThreshold

minDelay

private volatile long minDelay

intervalTime

private volatile long intervalTime

resetDelay

private AtomicBoolean resetDelay

isOverloaded

private AtomicBoolean isOverloaded

Constructor Detail

AdaptiveLifoCoDelCallQueue

public AdaptiveLifoCoDelCallQueue(int capacity,
                                  int targetDelay,
                                  int interval,
                                  double lifoThreshold,
                                  LongAdder numGeneralCallsDropped,
                                  LongAdder numLifoModeSwitches)

Method Detail

updateTunables

public void updateTunables(int newCodelTargetDelay,
                           int newCodelInterval,
                           double newLifoThreshold)

Update tunables.

Parameters:

newCodelTargetDelay - new CoDel target delay

newCodelInterval - new CoDel interval

newLifoThreshold - new Adaptive Lifo threshold

take

public CallRunner take()
                throws InterruptedException

Behaves as LinkedBlockingQueue.take(), except it will silently skip all calls which it thinks should be dropped.

Specified by:

take in interface BlockingQueue<CallRunner>

Returns:

the head of this queue

Throws:

InterruptedException - if interrupted while waiting

poll

public CallRunner poll()

Specified by:

poll in interface Queue<CallRunner>

needToDrop

private boolean needToDrop(CallRunner callRunner)

Parameters:

callRunner - to validate

Returns:

true if this call needs to be skipped based on call timestamp and internal queue state (deemed overloaded).

offer

public boolean offer(CallRunner callRunner)

Specified by:

offer in interface BlockingQueue<CallRunner>

Specified by:

offer in interface Queue<CallRunner>

size

public int size()

Specified by:

size in interface Collection<CallRunner>

toString

public String toString()

Overrides:

toString in class Object

poll

public CallRunner poll(long timeout,
                       TimeUnit unit)
                throws InterruptedException

Specified by:

poll in interface BlockingQueue<CallRunner>

Throws:

InterruptedException

peek

public CallRunner peek()

Specified by:

peek in interface Queue<CallRunner>

remove

public boolean remove(Object o)

Specified by:

remove in interface Collection<CallRunner>

Specified by:

remove in interface BlockingQueue<CallRunner>

contains

public boolean contains(Object o)

Specified by:

contains in interface Collection<CallRunner>

Specified by:

contains in interface BlockingQueue<CallRunner>

toArray

public Object[] toArray()

Specified by:

toArray in interface Collection<CallRunner>

toArray

public <T> T[] toArray(T[] a)

Specified by:

toArray in interface Collection<CallRunner>

clear

public void clear()

Specified by:

clear in interface Collection<CallRunner>

drainTo

public int drainTo(Collection<? super CallRunner> c)

Specified by:

drainTo in interface BlockingQueue<CallRunner>

drainTo

public int drainTo(Collection<? super CallRunner> c,
                   int maxElements)

Specified by:

drainTo in interface BlockingQueue<CallRunner>

iterator

public Iterator<CallRunner> iterator()

Specified by:

iterator in interface Iterable<CallRunner>

Specified by:

iterator in interface Collection<CallRunner>

add

public boolean add(CallRunner callRunner)

Specified by:

add in interface Collection<CallRunner>

Specified by:

add in interface BlockingQueue<CallRunner>

Specified by:

add in interface Queue<CallRunner>

remove

public CallRunner remove()

Specified by:

remove in interface Queue<CallRunner>

element

public CallRunner element()

Specified by:

element in interface Queue<CallRunner>

addAll

public boolean addAll(Collection<? extends CallRunner> c)

Specified by:

addAll in interface Collection<CallRunner>

isEmpty

public boolean isEmpty()

Specified by:

isEmpty in interface Collection<CallRunner>

containsAll

public boolean containsAll(Collection<?> c)

Specified by:

containsAll in interface Collection<CallRunner>

removeAll

public boolean removeAll(Collection<?> c)

Specified by:

removeAll in interface Collection<CallRunner>

retainAll

public boolean retainAll(Collection<?> c)

Specified by:

retainAll in interface Collection<CallRunner>

remainingCapacity

public int remainingCapacity()

Specified by:

remainingCapacity in interface BlockingQueue<CallRunner>

put

public void put(CallRunner callRunner)
         throws InterruptedException

Specified by:

put in interface BlockingQueue<CallRunner>

Throws:

InterruptedException

offer

public boolean offer(CallRunner callRunner,
                     long timeout,
                     TimeUnit unit)
              throws InterruptedException

Specified by:

offer in interface BlockingQueue<CallRunner>

Throws:

InterruptedException