Lawn: an Unbound Low Latency Timer Data Structure for Large Scale, High Throughput Systems

TL;DR

Lawn introduces a low latency, unbound range timer data structure based on the Timing Wheel algorithm, optimized for large-scale, high-throughput real-time systems, with minimal overhead and no performance degradation.

Contribution

The paper presents a novel unbound timer data structure that simplifies implementation and improves performance over existing algorithms for real-time applications.

Findings

Minimal overhead in timer management

No overflow or performance degradation

Effective in large-scale, high-throughput environments

Abstract

As demand for Real-Time applications rises among the general public, the importance of enabling large-scale, unbound algorithms to solve conventional problems with low to no latency is critical for product viability. Timer algorithms are prevalent in the core mechanisms behind operating systems, network protocol implementation, stream processing, and several database capabilities. This paper presents a field-tested algorithm for low latency, unbound range timer structure, based upon the well excepted Timing Wheel algorithm. Using a set of queues hashed by TTL, the algorithm allows for a simpler implementation, minimal overhead no overflow and no performance degradation in comparison to the current state of the algorithms under typical use cases.

Figures

Tables

Table 1. TABLE I: Runtime Complexity for common data structure based schemes

Operation	List Based	Tree Based
StartTimer	$O\left(n\right)$	$O\left(log\left(n\right)\right)$
PerTick	$O\left(1\right)$	$O\left(1\right)$
DeleteTimer	$O\left(n\right)$	$O\left(log\left(n\right)\right)$

Table 2. TABLE II: Runtime Complexity for the Hashed Timing Wheel scheme

Operation	Worst	Mean
StartTimer	$O\left(n\right)$	$O\left(1\right)$
PerTick	$O\left(n\right)$	$O\left(1\right)$
DeleteTimer	$O\left(1\right)$	$O\left(1\right)$

Table 3. TABLE III: Runtime Complexity for the Lawn scheme

Operation	Worst	Mean
StartTimer	$O\left(1\right)$	$O\left(1\right)$
PerTick	$O\left(n\right)$	$O\left(t\sim 1\right)$
DeleteTimer	$O\left(1\right)$	$O\left(1\right)$

Table 4. TABLE IV: Mean Runtime Complexity comparison

Operation	Timing Wheel	Lawn
StartTimer	$O\left(1\right)$	$O\left(1\right)$
PerTick	$O\left(1\right)$	$𝑶\left(𝒕\sim \mathrm{𝟏}\right)$
DeleteTimer	$O\left(1\right)$	$O\left(1\right)$
TimerExpired	$O\left(1\right)$	$O\left(1\right)$
overflow	$𝑶\left(𝒏\right)$	$O\left(1\right)$
space	$O\left(n\right)$	$O\left(n\right)$

Full text

I Introduction

This paper presents a theoretical analysis of a timer data-structure designed for use with hi-throughput computer systems called Lawn. In this paper, it will be shown that although the current state of the art algorithm is theoretically optimal, under some use cases (namely where max TTL is unpredictable, or the needed Tick resolution may change) it is under-performing due to the overflow problem, which the algorithm presented here addresses. Utilizing Lawn may assist in improving overall performance and flexibility in TTL and Tick resolution with no need for any prior knowledge of the using system apart from it not utilizing non-discrete stochastic values for timer TTLs.

I-A Model

In a similar manner to previous work[4, 5, 6], the model discussed in this paper shall consist of the following components, each corresponding with a different stage in the life cycle of a timer in the data store:

StartTimer\linebreak\downarrow\linebreak PerTickBookkeeping\hskip 2.84526pt\rotatebox[origin={c}]{-90.0}{\curvearrowleft}\linebreak\swarrow\hskip 15.0pt\searrow\linebreak DeleteTimer\hskip 15.0ptTimerExpired

StartTimer(TTL,timerId,Payload)

This routine is called by the client to start a timer that will expire in after the TTL has passed. The client is also expected to supply a timer ID in order to distinguish it from other timers in the data store. Some implementations also allow the client to provide a Payload, usually some form of a callback action to be performed or data to be returned on timer expiration.

PerTickBookkeeping()

This routine encompasses all the actions, operation and callbacks to be performed as part of timer management and expiration check every interval as determined by the data store granularity. Upon discovery of an outstanding timer to expire TimerExpired will be initiated by this routine.

DeleteTimer(timerId)

The client may call this utility routine in order to remove from the data store an outstanding timer (corresponding with a given timer ID), this is done by calling TimerExpired for the requested timer before PerTickBookkeeping had marked it to be expired.

TimerExpired(timerId)

Internally invoked by either PerTickBookkeeping or DeleteTimer this routine entails all actions and operations needed in order to remove all traces of the timer corresponding with a given timer ID from the data store and invoking the any callbacks that were provided as Payload during the StartTimer routine.

I-B callback run-time complexity

Since payload and callback run-time complexity varies significantly between different data store implementations, the store of such data can be achieved for $O(1)$ using a simple hash map, and the handling of such callbacks can be done in a discrete, highly (or even embarrassingly) parallel, this paper will disregard this aspect of timer stores.

II Current Solutions

II-A List and Tree Based Schemes

Being included as an integral part of almost any modern programming language, these basic data structures enable convenient and simple addition of timer management to any software. That said, such simple structures suffer from oversimplification and are appropriate for very unique use cases - where the number of timers it fairly small or the ticks are far enough from one another. Using such implementations for large scale applications will require the grouping of timer producers and consumers into groups small

II-B Hashed Timing Wheel

The Hashed Timing Wheel was designed to be an all-purpose timer storage solution for a unified system of known size and resolution[7, 4, 8, 9, 10]. While previous work has shown that Hashed Timing Wheels have optimal run-time complexity, and in ideal conditions are in fact, optimal, real-world implementations would suffer from either being bound by maximal TTL and resolution combination, or would require a costly ($O(n)$) run-time re-build upon of the data structure upon reaching such limits (in [5] it is referred to as ”the overflow problem”). For large numbers of timers, producers, or consumers as is common in large scale operations, the simplest and mose effective solution is to overestimate the needed resolution and/or TTL so to abstain from rebuilding for as long as possible.

III The Lawn Data Structure

III-A Intended Use Cases

This algorithm was first developed during the writing of a large scale, Stream Processing geographic intersection product[11] using a FastData[12] model. The data structure was to receive inputs from one or more systems that make use of a very limited range of TTLs in proportion to the number of concurrent timers they use.

Assumptions and Constraints

As this algorithm was originally designed to operate as the core of a dehydration utility for a single FastData application, where TTLs are usually discrete and variance is low it is intended for use under the assumptions that:

$Unique\ TTL\ Count\ll Concurrent\ Timer\ Count$

Assuming that most timers will have a TTL from within a small set of options will enable the application of the core concept behind the algorithm - TTL bucketing.

III-A1 The Data Structure

Lawn is, at its core, a hash of sorted sets111These are the TTL ’buckets’, much like Timing Wheel. The main difference is the key used for hashing these sets is the timer TTL. Meaning different timers will be stored in the same set based only on their TTL regardless of arrival time. Within each set, the timers are naturally sorted by time of arrival - effectively using the set as a queue (as can be seen in fig. 1). Using this queuing methodology based on TTL, we ensure that whenever a new timer is added to a queue, every other timer that is already there would be expired before the current one, since it is already in the queue and have the same TTL.

The data structure is analogous to blades of grass (hence the name) - each blade grows from the roots up, and periodically (in our case every $Tick$) the overgrown tops of the grass blades (the expired timers) are maintained by mowing the lawn to the desired level (current time).

III-B Algorithm

III-B1 Correctness & Completeness

To prove the algorithm’s correctness, it should be demonstrated that for each Timer $t$ with TTL $ttl$, TimerExpired operation is called on $t$ within Tick of $ttl$. Since the algorithm pivots around the TTL bucketing concept, wherein each timer is stored exactly once in its corresponding bucket, and these buckets are independent of each other, it is sufficient to demonstrating correctness for all timers of a bucket, That is:

$\forall\quad T^{start},T^{ttl}\in\mathbb{N}\quad\exists\quad T^{stop}\in\mathbb{N}:T^{stop}-T^{start}\approx T^{ttl}$

Alternatively, we can use the sorting analogy made by G. Varghese et al.[4] to show that given two triggers $T_{n},T_{m}$:

$\forall\quad T_{n},T_{m}\quad|\quad T^{start}_{n}<T^{start}_{m},T^{ttl}_{n}=T^{ttl}_{m}\quad\exists\quad T^{stop}_{n},T^{stop}_{m}\Rightarrow T^{stop}_{n}<T^{stop}_{m}$

Taking into account that each bucket only contains triggers with the same TTL we can simplify the above:

$\forall\quad T_{n},T_{m}\quad|\quad T^{start}_{n}<T^{start}_{m}\Rightarrow T^{stop}_{n}<T^{stop}_{m}$

Which, due to the bucket being a sorted set, ordered by $T^{start}$ and triggers being expired by bucket order from old to new is self-evident, and we arrived at a proof.

III-B2 Space and Runtime Complexity

The Lawn data structure is dense by design, as every timer is stored exactly once, a new trigger will add at most a single TTL bucket and empty TTL buckets are always removed, the data structure footprint will only grow linearly with the number of timers. Hence, overall space complexity is linear to the number of timers ($O(n)$).

Since the PerTickBookkeeping routine of Lawn iterates over the top item of all known TTL buckets on every expiration cycle (where at least one timer is expected to expire), it’s mean case runtime is linear to $t$ (the number of different TTLs) and seems to be lacking even in comparison to more primitive implementations of timer storage. That said, with an added assumption that the TTL set size is roughly constant over time, or at worst asymptotically smaller then the number of timers, we can regard this operation as constant time.

This assumption is valid in our case as it is derived from the needs of the algorithm users, these being other computer systems, which often have either a single TTL used repeatedly, their TTLs are chosen from a list of hard-coded values or derived from a simple mathematical operation (sliding windows are a good example of this method, using fixed increments or powers of 2 to determine TTLs etc.). Computer systems which are using highly variable TTL values are suitable for usage with this timer algorithm only under specific circumstances (such as multi-worker expiration system as described below).

Space complexity

is $O(n)$ since at worst case each timer is stored in its own bucket alongside a single entry in the timer hash. To compare, this spatial footprint is bound from above by that of the Hashed Hierarchical Timing Wheel, as due to it’s multi-level structure a single timer can be pointed at by a chain of hierarchical wheels, increasing its overall space requirement.

IV Comparison and Reflection

While general use systems, aggregating timers from several sources with, or applications with highly predictable needs may benefit from the relative stability of run-time provided by Timing Wheel (let alone the fact that it has been shown to be an optimal solution in terms of run-time complexity) Large scale machine serving systems would suffer from the overflow problem when faced with unpredictable scale of usage. This is handled in Lawn by a ”slow and steady” approach, optimizing for specific use cases.

Designed for large scale, high throughput systems, Lawn has displayed beyond state of the art performance for systems complying with its core assumptions of a multi-worker, hi-frequency, hi-timer-count with low TTL variance applications.

IV-A A View of Multiprocessing

Unlike the state-of-the-art Timer Wheel algorithm, Lawn enables the simultaneous timer handling and bookkeeping by splitting the buckets between several worker processes or threads, adding or removing workers as needed. This method enables usage of the Lawn algorithm in highly parallel applications and does not require the use of semaphores than other synchronization mechanisms within the bucket level.

IV-B Known implementations of Lawn

As mentioned in the body of this paper, the Lawn algorithm has already been tested and deployed in several programming languages by different organizations. Some of these implementations were developed by or in tandem with the author of this paper and some with his permission all with reported improvement in performance. The algorithm is free to use and the source code for many of these implementations has been published under an open source license.

Redis Internals [13] - a high performance in-memory key-value store - uses Lawn implementation for streams and other internal timers. 2. 2.

ReDe event dehydrator Redis module[14]. 3. 3.

Mellanox RDMA timers for an undisclosed Infiniband subsystem. 4. 4.

User specific rate limiting-timers for client device power consumption optimization[11]. 5. 5.

$clib$ Timer management utility lib.

V Conclusion

Lawn is a simplified overflow-free algorithm that displays near-optimal results for use cases involving many (millions) concurrent timers from large scale (tens of thousands) of independent machine systems. The algorithm is currently deployed and in use by several organizations under real-world load, all reporting satisfactory results.