<i>Delegation sketch</i>

Stylianopoulos, Charalampos; Walulya, Ivan; Almgren, Magnus; Papatriantafilou, Marina

doi:10.1145/3342195.3387542

Cited by 4 publications

(3 citation statements)

References 40 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The ever increasing rates of incoming data create a strong demand for parallel stream processing [8,18]. In order to allow queries to return fresh results in real-time without hampering data ingestion, it is paramount to support queries concurrently with updates [32,33]. But parallelizing sketches raises some important questions, for instance: What are the semantics of overlapping operations in a concurrent sketch?, How can we prove error guarantees for such a sketch?, and, in particular, Can we reuse the myriad of clever analyses of existing sketches' error bounds in parallel settings without opening the black box?…”

Section: Motivationmentioning

confidence: 99%

“…In spirit, IVL resembles the regularity correctness condition for single-writer registers [22], where a query must return either a value written by a concurrent write or the last value written by a write that completed before the query began. Stylianopoulos et al [33] adopt a 2:7 similar condition for data sketches, which they informally describe as follows: "a query takes into account all completed insert operations and possibly a subset of the overlapping ones." If the object's estimated quantity (return value) is monotonically increasing throughout every execution, then IVL essentially formalizes this condition, while also allowing intermediate steps of a single update to be observed.…”

Section: Relationship To Other Relaxationsmentioning

confidence: 99%

“…As noted in Section 3.4, previously suggested relaxations do not inherently guarantee that error bounds are preserved. For example, regular-like semantics, where a query "sees" some subset of the concurrent updates [33], satisfy IVL (and hence bound the error) for monotonic objects albeit not for general ones. Indeed, if object values can both increase and decrease, the results returned under such regular-like semantics can arbitrarily diverge from possible sequential ones.…”

Section: :9mentioning

confidence: 99%

See 2 more Smart Citations

Intermediate Value Linearizability: A Quantitative Correctness Criterion

Rinberg

Keidar

2023

J. ACM

View full text Add to dashboard Cite

Big data processing systems often employ batched updates and data sketches to estimate certain properties of large data. For example, a CountMin sketch approximates the frequencies at which elements occur in a data stream, and a batched counter counts events in batches. This paper focuses on correctness criteria for concurrent implementations of such objects. Specifically, we consider quantitative objects, whose return values are from an ordered domain, with a particular emphasis on (ϵ, δ )-bounded objects that estimate a numerical quantity with an error of at most ϵ with probability at least 1 − δ . The de facto correctness criterion for concurrent objects is linearizability. Intuitively, under linearizability, when a read overlaps an update, it must return the object’s value either before the update or after it. Consider, for example, a single batched increment operation that counts three new events, bumping a batched counter’s value from 7 to 10. In a linearizable implementation of the counter, a read overlapping this update must return either 7 or 10. We observe, however, that in typical use cases, any intermediate value between 7 and 10 would also be acceptable. To capture this additional degree of freedom, we propose Intermediate Value Linearizability (IVL) , a new correctness criterion that relaxes linearizability to allow returning intermediate values, for instance 8 in the example above. Roughly speaking, IVL allows reads to return any value that is bounded between two return values that are legal under linearizability. A key feature of IVL is that we can prove that concurrent IVL implementations of (ϵ, δ )-bounded objects are themselves (ϵ, δ )-bounded. To illustrate the power of this result, we give a straightforward and efficient concurrent implementation of an (ϵ, δ )-bounded CountMin sketch, which is IVL (albeit not linearizable). We present four examples for IVL objects, each showcasing a different way of using IVL. The first is a simple wait-free IVL batched counter, with O (1) step complexity for update. The next considers an (ϵ, δ )-bounded CountMin sketch, and further shows how to relax IVL using the notion of r -relaxation. Our third example is a non-atomic iterator over a data structure. In this example, we augment the data structure with an auxiliary history variable state that includes “tombstones” for items deleted from the data structure. Here, IVL semantics are required at the augmented level. Finally, using a priority queue , we show that some objects require IVL to be paired with other correctness criteria; indeed a natural correctness notion for a concurrent priority queue is IVL coupled with sequential consistency. Lastly, we show that IVL allows for inherently cheaper implementations than linearizable ones. In particular, we show a lower bound of Ω ( n ) on the step complexity of the update operation of any wait-free linearizable batched counter from single-writer multi-reader registers, which is more expensive than our O (1) IVL implementation.

show abstract