The most efficient way to calculate strong bisimilarity is by finding the relational coarsest par... more The most efficient way to calculate strong bisimilarity is by finding the relational coarsest partition on a transition system. We provide the first linear time algorithm to calculate strong bisimulation using parallel random access machines (PRAMs). More precisely, with n states, m transitions and |Act| ≤ m action labels, we provide an algorithm on max(n, m) processors that calculates strong bisimulation in time O(n + |Act|) and space O(n + m). The best-known PRAM algorithm has time complexity O(n log n) on a smaller number of processors making it less suitable for massive parallel devices such as GPUs. An implementation on a GPU shows that the linear time-bound is achievable on contemporary hardware.
State space explosion is still the main problem in the area of model checking. This paper focuses... more State space explosion is still the main problem in the area of model checking. This paper focuses on using beam search, a heuristic search algorithm, for pruning state spaces while generating. Original beam search is adapted to the state space generation setting and two new variants, motivated by some practical case studies, are devised. Remarkably, the resulting framework is shown to encompass A* search and some partial order reduction algorithms. These beam searches have all been implemented in the !CRL toolset. Case studies and comparisons with SPIN are also presented.
We show that timed branching bisimilarity as defined by van der Zwaag [14] and Baeten & Middelbur... more We show that timed branching bisimilarity as defined by van der Zwaag [14] and Baeten & Middelburg [2] is not an equivalence relation, in case of a dense time domain. We propose an adaptation based on van der Zwaag's definition, and prove that the resulting timed branching bisimilarity is an equivalence indeed. Furthermore, we prove that in case of a discrete time domain, van der Zwaag's definition and our adaptation coincide.
We present the Refiner tool, which offers techniques to define behavioural transformations applic... more We present the Refiner tool, which offers techniques to define behavioural transformations applicable on formal models of concurrent systems, reason about semantics preservation and the preservation of safety and liveness properties of such transformations, and apply them on models. Behavioural transformations allow to change the potential behaviour of systems. This is useful for model-driven development approaches, where systems are designed and created by first developing an abstract model, and iteratively refining this model until it is concrete enough to automatically generate source code from it. Properties that hold on the initial model and should remain valid throughout the development in later models can be maintained, by which the effort of verifying those properties over and over again is avoided. The tool integrates with the existing model checking toolsets mCRL2 and Cadp, resulting in a complete model checking approach for model-driven system development.
Branching bisimilarity is a behavioural equivalence relation on labelled transition systems that ... more Branching bisimilarity is a behavioural equivalence relation on labelled transition systems that takes internal actions into account. It has the traditional advantage that algorithms for branching bisimilarity are more efficient than all algorithms for other weak behavioural equivalences, especially weak bisimilarity. With m the number of transitions and n the number of states, the classic O(mn) algorithm has recently been replaced by an O(m log n) algorithm, which is unfortunately rather complex. This paper combines the ideas from Groote et al. [9] with the ideas from Valmari [19]. This results in a simpler O(m log n) algorithm. Benchmarks show that this new algorithm is faster and more memory efficient than all its predecessors.
We show that timed branching bisimilarity as defined by Van der Zwaag [17] and Baeten and Middelb... more We show that timed branching bisimilarity as defined by Van der Zwaag [17] and Baeten and Middelburg [2] is not an equivalence relation, in case of a dense time domain. We propose an adaptation based on Van der Zwaag's definition, and prove that the resulting timed branching bisimilarity is an equivalence indeed. Furthermore, we prove that in case of a discrete time domain, Van der Zwaag's definition and our adaptation coincide. Finally, we prove that a rooted version of timed branching bisimilarity is a congruence over a basic timed process algebra containing parallelism, successful termination and deadlock.
In model-driven software development, models and model refinements are used to create software. T... more In model-driven software development, models and model refinements are used to create software. To automatically generate correct software from abstract models by means of model refinement, desirable properties of the initial models must be preserved. We propose an explicit-state model checking technique to determine whether refinements are property preserving. We use networks of labelled transition systems (LTSs) to represent models with concurrent components, and formalise refinements as systems of LTS transformation rules. Property preservation checking involves determining how a rule system relates to an input network, and checking bisimilarity between behaviour subjected to transformation and the corresponding behaviour after transformation. In this way, one avoids generating the entire LTS of the new model. Experimental results demonstrate speedups of several orders of magnitude.
Techniques are required that support developers to produce GPU software that is both functionally... more Techniques are required that support developers to produce GPU software that is both functionally correct and highperforming. We envision an integration of pushbutton formal verification techniques into a Model Driven Engineering workflow. In this paper, we present our vision on this topic, and how we plan to make steps in that direction in the coming five years.
Over the years, researchers have developed many formal method tools to support software developme... more Over the years, researchers have developed many formal method tools to support software development. However, hardly any studies are conducted to determine whether the actual problems developers encounter are sufficiently addressed. For the relatively young field of GPU programming, we would like to know whether the tools developed so far are sufficient, or whether some problems still need attention. To this end, we first look at what kind of problems programmers encounter in OpenCL and CUDA. We gather problems from Stack Overflow and categorise them with card sorting. We find that problems related to memory, synchronisation of threads, threads in general and performance are essential topics. Next, we look at (verification) tools in industry and research, to see how these tools addressed the problems we discovered. We think many problems are already properly addressed, but there is still a need for easy to use sound tools. Alternatively, languages or programming styles can be created, that allows for easier checking for soundness. Keywords: GPU • GPGPU • Formal methods • Verification • Bugs • CUDA • OpenCL
In this paper, we show how scheduling problems can be modelled in untimed process algebra, by usi... more In this paper, we show how scheduling problems can be modelled in untimed process algebra, by using special tick actions. A minimal-time trace leading to a particular action, is one that minimizes the number of tick steps. As a result, we can use any (timed or untimed) model checking tool to find shortest schedules. Instantiating this scheme to µCRL, we profit from a richer specification language than timed model checkers usually offer. Also, we can profit from efficient distributed state space generators. We propose a variant of breadth-first search that visits all states between consecutive tick steps, before moving to the next time slice. We experimented with a sequential and a distributed implementation of this algorithm. We also experimented with beam search, which visits only parts of the search space, to find nearoptimal solutions. Our approach is applied to find optimal schedules for test batches of a realistic clinical chemical analyser, which performs several kinds of tests on patient samples.
The goal of our NIRICT GPGPU Reconnaissance project was to understand the breadth and depth of th... more The goal of our NIRICT GPGPU Reconnaissance project was to understand the breadth and depth of the GPGPU research actively done in The Netherlands. Thus, we set out to provide all the stakeholders-beneficiaries and designers/developers alike-a platform to showcase their work. Based on these showcases, we can now sketch a landscape of the Dutch GPGPU research. This document presents this landscape, but it also goes beyond it by providing a vision on how GPGPU research can be strengthened in the near future. Ultimately, this vision should help the integration of GPGPU research in the national and international research roadmaps. Motivation Graphics processing units (GPUs) were initially designed to support computer graphics. Their specific architecture provides high processing power and massive parallelism, which allows for efficient solving of typical graphics-related tasks. However, it was soon realised that such architectures are also suitable for many other computational tasks, which led to the development of the area of GPGPU (General Purpose GPU) programming. As a result, GPUs are now used in many different fields, including numerical simulation, media processing, medical imaging, eye-tracking, genomics, fluid dynamics, and machine learning. Complex GPU applications typically need to be programmed at a relatively low level, since they require expert knowledge on the specific hardware used. Given the importance, range and increasing complexity of GPGPU applications today, the main research challenge for GPGPU programming is that we urgently need systematic techniques that can optimise given GPGPU applications without requiring expert knowledge. This would allow GPGPU applications to be developed at a more convenient higher abstraction level. These techniques should offer a predictable performance increase, while preserving the original behaviour. Research on performance and correctness of GPGPU applications in the Netherlands is spread around, without much collaboration. However, this is a fast growing area, with high potential for important results and high visibility. Therefore, we organised a series of workshops to establish closer connections between the different researchers working in this area, with the goal to strengthen Dutch research on performance and correctness of GPGPU applications. This report is based on the outcomes of these workshops, providing an outlook on how to further develop research on GPGPU-related topics. as well as discussing how this research can
The need for massively parallel algorithms, suitable to exploit the computational power of hardwa... more The need for massively parallel algorithms, suitable to exploit the computational power of hardware such as graphics processing units, is ever increasing. In this paper, we propose a new algorithm for the on-the-fly verification of Linear-Time Temporal Logic (LTL) formulae [45] that is aimed at running on such devices. We prove its correctness and termination guarantee, and experimentally compare a GPU implementation with state-of-the-art LTL model checkers. Our new GPU LTLchecking algorithm is up to 150× faster on proving the correctness of a system than LTSmin running on a 32-core high-end CPU, and is more economic in using the available memory.
Various techniques have been proposed to accelerate explicitstate model checking with GPUs, but n... more Various techniques have been proposed to accelerate explicitstate model checking with GPUs, but none address the compact storage of states, or if they do, at the cost of losing completeness of the checking procedure. We investigate how to implement a tree database to store states as binary trees in GPU memory. We present fine-grained parallel algorithms to find and store trees, experiment with a number of GPUspecific configurations, and propose a novel hashing technique, called Cleary-Cuckoo hashing, which enables the use of Cleary compression on GPUs. We are the first to assess the effectiveness of using a tree database, and Cleary compression, on GPUs. Experiments show processing speeds of up to 131 million states per second.
Since 2013, the leading SAT solvers in SAT competitions all use inprocessing, which, unlike prepr... more Since 2013, the leading SAT solvers in SAT competitions all use inprocessing, which, unlike preprocessing, interleaves search with simplifications. However, inprocessing is typically a performance bottleneck, in particular for hard or large formulas. In this work, we introduce the first attempt to parallelize inprocessing on GPU architectures. As one of the main challenges in GPU programming is memory locality, we present new compact data structures and devise a data-parallel garbage collector. It runs in parallel on the GPU to reduce memory consumption and improve memory locality. Our new parallel variable elimination algorithm is roughly twice as fast as previous work. Moreover, we augment the variable elimination with the first parallel algorithm for functional dependency extraction in an attempt to find more logical gates to eliminate that cannot be found with syntactic approaches. We present a novel algorithm to generate clausal proofs in parallel to validate all simplification...
2020 IEEE 32nd International Conference on Tools with Artificial Intelligence (ICTAI)
Most modern and successful SAT solvers are based on the Conflict-Driven Clause-Learning (CDCL) al... more Most modern and successful SAT solvers are based on the Conflict-Driven Clause-Learning (CDCL) algorithm. The CDCL approach is to try to learn from previous assignments, and based on this, prune the search space to make better decisions in the future. In the current paper, we propose the introduction of a multiple decision maker (MDM) into CDCL. Adhering to a number of rules, MDM constructs sets of decisions to be made at once. Experiments show MDM has a considerably positive impact on CDCL, for many different SAT application problems. Overall, about 50% of the benchmarks we considered were solved faster when MDM was enabled, and the total processing time of all benchmarks was reduced by 6%. Moreover, MDM allowed 31 extra problems to be solved. We introduce MDM, analyse its impact, and try to understand the cause of that impact.
We present work in progress on, verified, transformation of a modeling language based on communic... more We present work in progress on, verified, transformation of a modeling language based on communicating concurrent state machines, slco, to Java. Some concurrency related challenges, related to atomicity and non-standard fairness issues, are pointed out. We discuss solutions based on Java synchronization concepts.
Efficient algorithms have been developed to model check liveness properties, such as the well-kno... more Efficient algorithms have been developed to model check liveness properties, such as the well-known Nested Depth-First Search, which uses a depth-first search (DFS) strategy. However, in some settings, DFS is not a suitable option. For instance, when considering distributed model checking on a cluster, or many-core model checking using a Graphics Processing Unit (GPU), Breadth-First Search (BFS) is a more natural choice, at least for basic reachability analysis. Liveness property checking, however, requires the detection of (accepting) cycles, and BFS is not very suitable to detect these on-the-fly. In this paper, we consider how a model checker that completely runs on a GPU can be extended to efficiently verify whether finite-state concurrent systems satisfy liveness properties. We exploit the fact that the state space is the product of the behaviour of several parallel automata. The result of this work is the very first GPU-based model checker that can check liveness properties. A. Wijs-We gratefully acknowledge the support of NVIDIA Corporation with the donation of the GeForce Titan X used for this research.
We present the first parallel algorithms that decide strong and branching bisimilarity in linear ... more We present the first parallel algorithms that decide strong and branching bisimilarity in linear time. More precisely, if a transition system has n states, m transitions and $$\vert Act \vert $$ | A c t | action labels, we introduce an algorithm that decides strong bisimilarity in $$\mathcal {O}(n+\vert Act \vert )$$ O ( n + | A c t | ) time on $$\max (n,m)$$ max ( n , m ) processors and an algorithm that decides branching bisimilarity in $$\mathcal {O}(n+\vert Act \vert )$$ O ( n + | A c t | ) time using up to $$\max (n^2,m,\vert Act \vert n)$$ max ( n 2 , m , | A c t | n ) processors.
The most efficient way to calculate strong bisimilarity is by finding the relational coarsest par... more The most efficient way to calculate strong bisimilarity is by finding the relational coarsest partition on a transition system. We provide the first linear time algorithm to calculate strong bisimulation using parallel random access machines (PRAMs). More precisely, with n states, m transitions and |Act| ≤ m action labels, we provide an algorithm on max(n, m) processors that calculates strong bisimulation in time O(n + |Act|) and space O(n + m). The best-known PRAM algorithm has time complexity O(n log n) on a smaller number of processors making it less suitable for massive parallel devices such as GPUs. An implementation on a GPU shows that the linear time-bound is achievable on contemporary hardware.
State space explosion is still the main problem in the area of model checking. This paper focuses... more State space explosion is still the main problem in the area of model checking. This paper focuses on using beam search, a heuristic search algorithm, for pruning state spaces while generating. Original beam search is adapted to the state space generation setting and two new variants, motivated by some practical case studies, are devised. Remarkably, the resulting framework is shown to encompass A* search and some partial order reduction algorithms. These beam searches have all been implemented in the !CRL toolset. Case studies and comparisons with SPIN are also presented.
We show that timed branching bisimilarity as defined by van der Zwaag [14] and Baeten & Middelbur... more We show that timed branching bisimilarity as defined by van der Zwaag [14] and Baeten & Middelburg [2] is not an equivalence relation, in case of a dense time domain. We propose an adaptation based on van der Zwaag's definition, and prove that the resulting timed branching bisimilarity is an equivalence indeed. Furthermore, we prove that in case of a discrete time domain, van der Zwaag's definition and our adaptation coincide.
We present the Refiner tool, which offers techniques to define behavioural transformations applic... more We present the Refiner tool, which offers techniques to define behavioural transformations applicable on formal models of concurrent systems, reason about semantics preservation and the preservation of safety and liveness properties of such transformations, and apply them on models. Behavioural transformations allow to change the potential behaviour of systems. This is useful for model-driven development approaches, where systems are designed and created by first developing an abstract model, and iteratively refining this model until it is concrete enough to automatically generate source code from it. Properties that hold on the initial model and should remain valid throughout the development in later models can be maintained, by which the effort of verifying those properties over and over again is avoided. The tool integrates with the existing model checking toolsets mCRL2 and Cadp, resulting in a complete model checking approach for model-driven system development.
Branching bisimilarity is a behavioural equivalence relation on labelled transition systems that ... more Branching bisimilarity is a behavioural equivalence relation on labelled transition systems that takes internal actions into account. It has the traditional advantage that algorithms for branching bisimilarity are more efficient than all algorithms for other weak behavioural equivalences, especially weak bisimilarity. With m the number of transitions and n the number of states, the classic O(mn) algorithm has recently been replaced by an O(m log n) algorithm, which is unfortunately rather complex. This paper combines the ideas from Groote et al. [9] with the ideas from Valmari [19]. This results in a simpler O(m log n) algorithm. Benchmarks show that this new algorithm is faster and more memory efficient than all its predecessors.
We show that timed branching bisimilarity as defined by Van der Zwaag [17] and Baeten and Middelb... more We show that timed branching bisimilarity as defined by Van der Zwaag [17] and Baeten and Middelburg [2] is not an equivalence relation, in case of a dense time domain. We propose an adaptation based on Van der Zwaag's definition, and prove that the resulting timed branching bisimilarity is an equivalence indeed. Furthermore, we prove that in case of a discrete time domain, Van der Zwaag's definition and our adaptation coincide. Finally, we prove that a rooted version of timed branching bisimilarity is a congruence over a basic timed process algebra containing parallelism, successful termination and deadlock.
In model-driven software development, models and model refinements are used to create software. T... more In model-driven software development, models and model refinements are used to create software. To automatically generate correct software from abstract models by means of model refinement, desirable properties of the initial models must be preserved. We propose an explicit-state model checking technique to determine whether refinements are property preserving. We use networks of labelled transition systems (LTSs) to represent models with concurrent components, and formalise refinements as systems of LTS transformation rules. Property preservation checking involves determining how a rule system relates to an input network, and checking bisimilarity between behaviour subjected to transformation and the corresponding behaviour after transformation. In this way, one avoids generating the entire LTS of the new model. Experimental results demonstrate speedups of several orders of magnitude.
Techniques are required that support developers to produce GPU software that is both functionally... more Techniques are required that support developers to produce GPU software that is both functionally correct and highperforming. We envision an integration of pushbutton formal verification techniques into a Model Driven Engineering workflow. In this paper, we present our vision on this topic, and how we plan to make steps in that direction in the coming five years.
Over the years, researchers have developed many formal method tools to support software developme... more Over the years, researchers have developed many formal method tools to support software development. However, hardly any studies are conducted to determine whether the actual problems developers encounter are sufficiently addressed. For the relatively young field of GPU programming, we would like to know whether the tools developed so far are sufficient, or whether some problems still need attention. To this end, we first look at what kind of problems programmers encounter in OpenCL and CUDA. We gather problems from Stack Overflow and categorise them with card sorting. We find that problems related to memory, synchronisation of threads, threads in general and performance are essential topics. Next, we look at (verification) tools in industry and research, to see how these tools addressed the problems we discovered. We think many problems are already properly addressed, but there is still a need for easy to use sound tools. Alternatively, languages or programming styles can be created, that allows for easier checking for soundness. Keywords: GPU • GPGPU • Formal methods • Verification • Bugs • CUDA • OpenCL
In this paper, we show how scheduling problems can be modelled in untimed process algebra, by usi... more In this paper, we show how scheduling problems can be modelled in untimed process algebra, by using special tick actions. A minimal-time trace leading to a particular action, is one that minimizes the number of tick steps. As a result, we can use any (timed or untimed) model checking tool to find shortest schedules. Instantiating this scheme to µCRL, we profit from a richer specification language than timed model checkers usually offer. Also, we can profit from efficient distributed state space generators. We propose a variant of breadth-first search that visits all states between consecutive tick steps, before moving to the next time slice. We experimented with a sequential and a distributed implementation of this algorithm. We also experimented with beam search, which visits only parts of the search space, to find nearoptimal solutions. Our approach is applied to find optimal schedules for test batches of a realistic clinical chemical analyser, which performs several kinds of tests on patient samples.
The goal of our NIRICT GPGPU Reconnaissance project was to understand the breadth and depth of th... more The goal of our NIRICT GPGPU Reconnaissance project was to understand the breadth and depth of the GPGPU research actively done in The Netherlands. Thus, we set out to provide all the stakeholders-beneficiaries and designers/developers alike-a platform to showcase their work. Based on these showcases, we can now sketch a landscape of the Dutch GPGPU research. This document presents this landscape, but it also goes beyond it by providing a vision on how GPGPU research can be strengthened in the near future. Ultimately, this vision should help the integration of GPGPU research in the national and international research roadmaps. Motivation Graphics processing units (GPUs) were initially designed to support computer graphics. Their specific architecture provides high processing power and massive parallelism, which allows for efficient solving of typical graphics-related tasks. However, it was soon realised that such architectures are also suitable for many other computational tasks, which led to the development of the area of GPGPU (General Purpose GPU) programming. As a result, GPUs are now used in many different fields, including numerical simulation, media processing, medical imaging, eye-tracking, genomics, fluid dynamics, and machine learning. Complex GPU applications typically need to be programmed at a relatively low level, since they require expert knowledge on the specific hardware used. Given the importance, range and increasing complexity of GPGPU applications today, the main research challenge for GPGPU programming is that we urgently need systematic techniques that can optimise given GPGPU applications without requiring expert knowledge. This would allow GPGPU applications to be developed at a more convenient higher abstraction level. These techniques should offer a predictable performance increase, while preserving the original behaviour. Research on performance and correctness of GPGPU applications in the Netherlands is spread around, without much collaboration. However, this is a fast growing area, with high potential for important results and high visibility. Therefore, we organised a series of workshops to establish closer connections between the different researchers working in this area, with the goal to strengthen Dutch research on performance and correctness of GPGPU applications. This report is based on the outcomes of these workshops, providing an outlook on how to further develop research on GPGPU-related topics. as well as discussing how this research can
The need for massively parallel algorithms, suitable to exploit the computational power of hardwa... more The need for massively parallel algorithms, suitable to exploit the computational power of hardware such as graphics processing units, is ever increasing. In this paper, we propose a new algorithm for the on-the-fly verification of Linear-Time Temporal Logic (LTL) formulae [45] that is aimed at running on such devices. We prove its correctness and termination guarantee, and experimentally compare a GPU implementation with state-of-the-art LTL model checkers. Our new GPU LTLchecking algorithm is up to 150× faster on proving the correctness of a system than LTSmin running on a 32-core high-end CPU, and is more economic in using the available memory.
Various techniques have been proposed to accelerate explicitstate model checking with GPUs, but n... more Various techniques have been proposed to accelerate explicitstate model checking with GPUs, but none address the compact storage of states, or if they do, at the cost of losing completeness of the checking procedure. We investigate how to implement a tree database to store states as binary trees in GPU memory. We present fine-grained parallel algorithms to find and store trees, experiment with a number of GPUspecific configurations, and propose a novel hashing technique, called Cleary-Cuckoo hashing, which enables the use of Cleary compression on GPUs. We are the first to assess the effectiveness of using a tree database, and Cleary compression, on GPUs. Experiments show processing speeds of up to 131 million states per second.
Since 2013, the leading SAT solvers in SAT competitions all use inprocessing, which, unlike prepr... more Since 2013, the leading SAT solvers in SAT competitions all use inprocessing, which, unlike preprocessing, interleaves search with simplifications. However, inprocessing is typically a performance bottleneck, in particular for hard or large formulas. In this work, we introduce the first attempt to parallelize inprocessing on GPU architectures. As one of the main challenges in GPU programming is memory locality, we present new compact data structures and devise a data-parallel garbage collector. It runs in parallel on the GPU to reduce memory consumption and improve memory locality. Our new parallel variable elimination algorithm is roughly twice as fast as previous work. Moreover, we augment the variable elimination with the first parallel algorithm for functional dependency extraction in an attempt to find more logical gates to eliminate that cannot be found with syntactic approaches. We present a novel algorithm to generate clausal proofs in parallel to validate all simplification...
2020 IEEE 32nd International Conference on Tools with Artificial Intelligence (ICTAI)
Most modern and successful SAT solvers are based on the Conflict-Driven Clause-Learning (CDCL) al... more Most modern and successful SAT solvers are based on the Conflict-Driven Clause-Learning (CDCL) algorithm. The CDCL approach is to try to learn from previous assignments, and based on this, prune the search space to make better decisions in the future. In the current paper, we propose the introduction of a multiple decision maker (MDM) into CDCL. Adhering to a number of rules, MDM constructs sets of decisions to be made at once. Experiments show MDM has a considerably positive impact on CDCL, for many different SAT application problems. Overall, about 50% of the benchmarks we considered were solved faster when MDM was enabled, and the total processing time of all benchmarks was reduced by 6%. Moreover, MDM allowed 31 extra problems to be solved. We introduce MDM, analyse its impact, and try to understand the cause of that impact.
We present work in progress on, verified, transformation of a modeling language based on communic... more We present work in progress on, verified, transformation of a modeling language based on communicating concurrent state machines, slco, to Java. Some concurrency related challenges, related to atomicity and non-standard fairness issues, are pointed out. We discuss solutions based on Java synchronization concepts.
Efficient algorithms have been developed to model check liveness properties, such as the well-kno... more Efficient algorithms have been developed to model check liveness properties, such as the well-known Nested Depth-First Search, which uses a depth-first search (DFS) strategy. However, in some settings, DFS is not a suitable option. For instance, when considering distributed model checking on a cluster, or many-core model checking using a Graphics Processing Unit (GPU), Breadth-First Search (BFS) is a more natural choice, at least for basic reachability analysis. Liveness property checking, however, requires the detection of (accepting) cycles, and BFS is not very suitable to detect these on-the-fly. In this paper, we consider how a model checker that completely runs on a GPU can be extended to efficiently verify whether finite-state concurrent systems satisfy liveness properties. We exploit the fact that the state space is the product of the behaviour of several parallel automata. The result of this work is the very first GPU-based model checker that can check liveness properties. A. Wijs-We gratefully acknowledge the support of NVIDIA Corporation with the donation of the GeForce Titan X used for this research.
We present the first parallel algorithms that decide strong and branching bisimilarity in linear ... more We present the first parallel algorithms that decide strong and branching bisimilarity in linear time. More precisely, if a transition system has n states, m transitions and $$\vert Act \vert $$ | A c t | action labels, we introduce an algorithm that decides strong bisimilarity in $$\mathcal {O}(n+\vert Act \vert )$$ O ( n + | A c t | ) time on $$\max (n,m)$$ max ( n , m ) processors and an algorithm that decides branching bisimilarity in $$\mathcal {O}(n+\vert Act \vert )$$ O ( n + | A c t | ) time using up to $$\max (n^2,m,\vert Act \vert n)$$ max ( n 2 , m , | A c t | n ) processors.
Uploads
Papers by Anton Wijs