  Dynamic analyses are a standard approach to analyzing and testing concurrent
programs. Such techniques observe program traces and analyze them to infer the
presence or absence of bugs. At its core, each analysis maintains a partial
order $P$ that represents order dependencies between events of the analyzed
trace $\sigma$. Naturally, the scalability of the analysis largely depends on
how efficiently it maintains $P$. The standard data structure for this task has
thus far been vector clocks. These, however, are slow for analyses that follow
a non-streaming style, costing $O(n)$ for inserting (and propagating) each new
ordering in $P$, where $n$ is the size of $\sigma$, while they cannot handle
the deletion of existing orderings.
  In this paper we develop collective sparse segment trees (CSSTs), a simple
but elegant data structure for generically maintaining a partial order $P$.
CSSTs thrive when the width $k$ of $P$ is much smaller than the size $n$ of its
domain, allowing inserting, deleting, and querying for orderings in $P$ to run
in $O(logn)$ time. For a concurrent trace, $k$ is bounded by the number of its
threads, and is normally orders of magnitude smaller than its size $n$, making
CSSTs fitting for this setting. Our experimental results confirm that CSSTs are
the best data structure currently to handle a range of dynamic analyses from
existing literature.
