Mixed Shared-Distributed Hash Tables Approaches for Parallel State Space Construction

Abstract

We propose an algorithm for parallel state space construction based on an original concurrent data structure, called a localization table, that aims at better spatial and temporal balance. Our proposal is close in spirit to algorithms based on distributed hash tables, with the distinction that states are dynamically assigned to processors; i.e. we do not rely on an a-priori static partition of the state space.In our solution, every process keeps a share of the global state space. Data distribution and coordination between processes is made through the localization table, that is a lockless, thread-safe data structure that approximates the set of states being processed. The localization table is used to dynamically assign newly discovered states and can be queried to return the identity of the processor that own a given state. With this approach, we are able to consolidate a network of local hash tables into an (abstract) distributed one without sacrificing memory affinity -data that are "logically connected" and physically close to each others -and without incurring performance costs associated to the use of locks to ensure data consistency.We evaluate the performance of our algorithm on different benchmarks and compare these results with other solutions proposed in the literature and with existing verification tools.

Bounded saturation-based CTL model checking

“…The size of the state space of the SR-100 model is about 10 100 . We also used a model of Hanoi towers from [15]. The state space of our Hanoi towers model with 12 rings is 531 441 states.…”

Programming bsp and multi-bsp algorithms in ml

“…As intended, the programmer must manage the distribution of the data for these two different models. For example, with the mc case, the algorithm of [19] handles a specific data-structure (with locks) shared by the threads on cores and distributes the states across the nodes using the hash technique. We can also cite the work of [14] in which a bsp extension of C++ runs the same code on both a cluster and on multi-cores.…”

An Experiment on Parallel Model Checking of a CTL Fragment

“…We build our model checking algorithm on top of the parallel state space generation algorithm of [11], described in the previous section. Our other design choices follow from our goal to target models with very large state spaces.…”

“…We consider a shared memory architecture where all processing units share the state space (using the mixed approach presented in [11]) and where the working stacks are partially distributed (such as the stacks W and A used in our pseudo-code). For most of our pseudo-code, it is enough to rely on atomic compare and swap primitives to protect from parallel data races and other synchronization issues; typically, compare-and-swap primitives will be used when we need to test the value of a label or when we need to update the label of a state (for instance with expressions like sons(s).dec()).…”