com.illumon.iris.db.tables.live

Enum LiveTableMonitor

java.lang.Object

java.lang.Enum<LiveTableMonitor>

com.illumon.iris.db.tables.live.LiveTableMonitor

All Implemented Interfaces:

LiveTableRegistrar, NotificationQueue, Comparable<LiveTableMonitor>

public enum LiveTableMonitor
extends Enum<LiveTableMonitor>
implements LiveTableRegistrar, NotificationQueue

This class contains a thread which periodically updates a set of monitored LiveTables at a specified target cycle time. The target cycle time can be configured to reduce or increase the refresh rate of the monitored tables.

This class can be configured via the following Configuration property

• LiveTableMonitor.targetcycletime (optional) - The default target cycle time in ms (1000 if not defined)

Nested Class Summary

Nested classes/interfaces inherited from interface com.illumon.iris.db.tables.live.NotificationQueue

NotificationQueue.Dependency, NotificationQueue.IndexUpdateNotification, NotificationQueue.Notification<TYPE extends IntrusiveDoublyLinkedNode<TYPE>>

Method Summary

Modifier and Type	Method and Description
void	addNotification(NotificationQueue.Notification notification) Enqueue a notification to be flushed according to its priority.
void	addTable(LiveTable table) Add a table to the list of tables to refresh and mark it as refreshing if it was a DynamicNode.
void	checkInitiateTableOperation() If we are establishing a new table operation, on a refreshing table without the LiveTableMonitor lock; then we are likely committing a grievous error, but one that will only occasionally result in us getting the wrong answer or if we are lucky an assertion.
void	doUnchecked(Runnable runnable) Execute the supplied code while table operations are unchecked.
<T> T	doUnchecked(Supplier<T> supplier) Execute the supplied code while table operations are unchecked.
AwareFunctionalLock	exclusiveLock() Get the exclusive lock for this LiveTableMonitor.
boolean	maybeRefreshTable(LiveTable liveTable, boolean onlyIfHaveLock) Call LiveTableMonitor.maybeRefreshTable(LiveTable) only if the calling thread already holds the lock.
void	removeTables(Collection<LiveTable> tablesToRemove) Remove a collection of tables from the list of refreshing tables.
void	requestRefresh(LiveTable table) Request a refresh for a single table.
boolean	setCheckTableOperations(boolean value) If you know that the table operations you are performing are indeed safe, then call this method with false to disable table operation checking.
AwareFunctionalLock	sharedLock() Get the shared lock for this LiveTableMonitor.

Methods inherited from interface com.illumon.iris.db.tables.live.LiveTableRegistrar

removeTable

Method Detail

sharedLock

public AwareFunctionalLock sharedLock()

Get the shared lock for this LiveTableMonitor.

Using this lock will prevent refresh processing from proceeding concurrently, but will allow other read-only processing to proceed.

The shared lock implementation is expected to support reentrance.

This lock does not support Lock.newCondition(). Use the exclusive lock if you need to wait on events that are driven by refresh processing.

Returns:

The shared lock for this LiveTableMonitor

exclusiveLock

public AwareFunctionalLock exclusiveLock()

Get the exclusive lock for this LiveTableMonitor.

Using this lock will prevent refresh or read-only processing from proceeding concurrently.

The exclusive lock implementation is expected to support reentrance.

Note that using the exclusive lock while the shared lock is held by the current thread will result in exceptions, as lock upgrade is not supported.

This lock does support Lock.newCondition().

Returns:

The exclusive lock for this LiveTableMonitor

checkInitiateTableOperation

public void checkInitiateTableOperation()

If we are establishing a new table operation, on a refreshing table without the LiveTableMonitor lock; then we are likely committing a grievous error, but one that will only occasionally result in us getting the wrong answer or if we are lucky an assertion. This method is called from various query operations that should not be established without the LTM lock.

The refresh thread pool threads are allowed to instantiate operations, even though that thread does not have the lock; because they are protected by the main refresh thread and dependency tracking.

If you are sure that you know what you are doing better than the query engine, you may call LiveTableMonitor.setCheckTableOperations(boolean) to set a thread local variable bypassing this check.

setCheckTableOperations

public boolean setCheckTableOperations(boolean value)

If you know that the table operations you are performing are indeed safe, then call this method with false to disable table operation checking. Conversely, if you want to enforce checking even if the configuration disagrees; call it with true.

Parameters:

value - the new value of check table operations

Returns:

the old value of check table operations

doUnchecked

public <T> T doUnchecked(Supplier<T> supplier)

Execute the supplied code while table operations are unchecked.

Parameters:

supplier - the function to run

Returns:

the result of supplier

doUnchecked

public void doUnchecked(Runnable runnable)

Execute the supplied code while table operations are unchecked.

Parameters:

runnable - the function to run

addTable

public void addTable(@NotNull
                     LiveTable table)

Add a table to the list of tables to refresh and mark it as refreshing if it was a DynamicNode.

Specified by:

addTable in interface LiveTableRegistrar

Parameters:

table - The table to be added to the refresh list

ImplNote:

This will do nothing in unit test mode other than mark the table as refreshing.

removeTables

public void removeTables(Collection<LiveTable> tablesToRemove)

Remove a collection of tables from the list of refreshing tables.

Parameters:

tablesToRemove - The tables to remove from the list of refreshing tables

ImplNote:

This will not set the tables as non-refreshing.

addNotification

public void addNotification(NotificationQueue.Notification notification)

Enqueue a notification to be flushed according to its priority. Non-terminal notifications should only be enqueued during the updating phase of a cycle. That is, they should be enqueued from a LiveTable.refresh() or subsequent notification delivery.

Specified by:

addNotification in interface NotificationQueue

Parameters:

notification - The notification to enqueue

See Also:

NotificationQueue.Notification.isTerminal(), LogicalClock.State

maybeRefreshTable

public boolean maybeRefreshTable(LiveTable liveTable,
                                 boolean onlyIfHaveLock)

Call LiveTableMonitor.maybeRefreshTable(LiveTable) only if the calling thread already holds the lock.

Parameters:

liveTable - The LiveTable that we would like to refresh

onlyIfHaveLock - If true, check that the lock is held first and do nothing if it is not

Returns:

true if the table was found and the refresh resulted in a notification, false otherwise.

requestRefresh

public void requestRefresh(@NotNull
                           LiveTable table)

Request a refresh for a single table.

The update will occur on the LTM thread

Parameters:

table - The table to refresh.