The Experts below are selected from a list of 31971 Experts worldwide ranked by ideXlab platform
Hector J Levesque - One of the best experts on this subject based on the ideXlab platform.
-
congolog a Concurrent Programming language based on the situation calculus
Artificial Intelligence, 2000Co-Authors: Giuseppe De Giacomo, Yves Lesperance, Hector J LevesqueAbstract:Abstract As an alternative to planning, an approach to high-level agent control based on Concurrent Program execution is considered. A formal definition in the situation calculus of such a Programming language is presented and illustrated with some examples. The language includes facilities for prioritizing the execution of Concurrent processes, interrupting the execution when certain conditions become true, and dealing with exogenous actions. The language differs from other procedural formalisms for concurrency in that the initial state can be incompletely specified and the primitive actions can be user-defined by axioms in the situation calculus. Some mathematical properties of the language are proven, for instance, that the proposed semantics is equivalent to that given earlier for the portion of the language without concurrency.
-
reasoning about Concurrent execution prioritized interrupts and exogenous actions in the situation calculus
International Joint Conference on Artificial Intelligence, 1997Co-Authors: Giuseppe De Giacomo, Yves Lesperance, Hector J LevesqueAbstract:As an alternative to planning, an approach to highlevel agent control based on Concurrent Program execution is considered. A formal definition in the situation calculus of such a Programming language is presented and illustrated with a detailed example. The language includes facilities for prioritizing the Concurrent execution, interrupting the execution when certain conditions become true, and dealing with exogenous actions. The language differs from other procedural formalisms for concurrency in that the initial state can be incompletely specified and the primitive actions can be user-defined by axioms in the situation calculus.
Xinyu Feng - One of the best experts on this subject based on the ideXlab platform.
-
Rely-Guarantee-Based Simulation for Compositional Verification of Concurrent Program Transformations
ACM Transactions on Programming Languages and Systems, 2014Co-Authors: Hongjin Liang, Xinyu Feng, Ming FuAbstract:Verifying Program transformations usually requires proving that the resulting Program (the target) refines or is equivalent to the original one (the source). However, the refinement relation between individual sequential threads cannot be preserved in general with the presence of parallel compositions, due to instruction reordering and the different granularities of atomic operations at the source and the target. On the other hand, the refinement relation defined based on fully abstract semantics of Concurrent Programs assumes arbitrary parallel environments, which is too strong and cannot be satisfied by many well-known transformations. In this article, we propose a Rely-Guarantee-based Simulation (RGSim) to verify Concurrent Program transformations. The relation is parametrized with constraints of the environments that the source and the target Programs may compose with. It considers the interference between threads and their environments, thus is less permissive than relations over sequential Programs. It is compositional with respect to parallel compositions as long as the constraints are satisfied. Also, RGSim does not require semantics preservation under all environments, and can incorporate the assumptions about environments made by specific Program transformations in the form of rely/guarantee conditions. We use RGSim to reason about optimizations and prove atomicity of Concurrent objects. We also propose a general garbage collector verification framework based on RGSim, and verify the Boehm et al. Concurrent mark-sweep GC.
-
a rely guarantee based simulation for verifying Concurrent Program transformations
Symposium on Principles of Programming Languages, 2012Co-Authors: Hongjin Liang, Xinyu FengAbstract:Verifying Program transformations usually requires proving that the resulting Program (the target) refines or is equivalent to the original one (the source). However, the refinement relation between individual sequential threads cannot be preserved in general with the presence of parallel compositions, due to instruction reordering and the different granularities of atomic operations at the source and the target. On the other hand, the refinement relation defined based on fully abstract semantics of Concurrent Programs assumes arbitrary parallel environments, which is too strong and cannot be satisfied by many well-known transformations. In this paper, we propose a Rely-Guarantee-based Simulation (RGSim) to verify Concurrent Program transformations. The relation is parametrized with constraints of the environments that the source and the target Programs may compose with. It considers the interference between threads and their environments, thus is less permissive than relations over sequential Programs. It is compositional w.r.t. parallel compositions as long as the constraints are satisfied. Also, RGSim does not require semantics preservation under all environments, and can incorporate the assumptions about environments made by specific Program transformations in the form of rely/guarantee conditions. We use RGSim to reason about optimizations and prove atomicity of Concurrent objects. We also propose a general garbage collector verification framework based on RGSim, and verify the Boehm et al. Concurrent mark-sweep GC.
Aarti Gupta - One of the best experts on this subject based on the ideXlab platform.
-
symbolic predictive analysis for Concurrent Programs
Formal Aspects of Computing, 2011Co-Authors: Chao Wang, Rhishikesh Limaye, Malay K. Ganai, Sudipta Kundu, Aarti GuptaAbstract:Predictive analysis aims at detecting concurrency errors during runtime by monitoring a concrete execution trace of a Concurrent Program. In recent years, various models based on the happens-before causality relations have been proposed for predictive analysis. However, these models often rely on only the observed runtime events and typically do not utilize the Program source code. Furthermore, the enumerative algorithms they use for verifying safety properties in the predicted traces often suffer from the interleaving explosion problem. In this paper, we introduce a precise predictive model based on both the Program source code and the observed execution events, and propose a symbolic algorithm to check whether a safety property holds in all feasible permutations of events of the given trace. Rather than explicitly enumerating and checking the interleavings, our method conducts the search using a novel encoding and symbolic reasoning with a satisfiability modulo theory solver. We also propose a technique to bound the number of context switches allowed in the interleavings during the symbolic search, to further improve the scalability of the algorithm.
-
trace based symbolic analysis for atomicity violations
Tools and Algorithms for Construction and Analysis of Systems, 2010Co-Authors: Chao Wang, Rhishikesh Limaye, Malay K. Ganai, Aarti GuptaAbstract:We propose a symbolic algorithm to accurately predict atomicity violations by analyzing a concrete execution trace of a Concurrent Program. We use both the execution trace and the Program source code to construct a symbolic predictive model, which captures a large set of alternative interleavings of the events of the given trace. We use precise symbolic reasoning with a satisfiability modulo theory (SMT) solver to check the feasible interleavings for atomicity violations. Our algorithm differs from the existing methods in that all reported atomicity violations can appear in the actual Program execution; and at the same time the feasible interleavings analyzed by our model are significantly more than other predictive models that guarantee the absence of false alarms.
-
symbolic pruning of Concurrent Program executions
Foundations of Software Engineering, 2009Co-Authors: Chao Wang, Aarti Gupta, Swarat Chaudhuri, Yu YangAbstract:We propose a new algorithm for verifying Concurrent Programs, which uses concrete executions to partition the Program into a set of lean partitions called Concurrent trace Programs (CTPs), and symbolically verifies each CTP using a satisfiability solver. A CTP, derived from a concrete execution trace, implicitly captures all permutations of the trace that also respect the control flow of the Program. We show that a CTP, viewed as a coarser equivalence class than the popular (Mazurkiewicz) trace equivalence in partial order reduction (POR) literature, leads to more effective pruning of the search space during model checking. While classic POR can prune away redundant interleavings within each trace equivalence class, the pruning in POR is not property driven. We use symbolic methods to achieve property-driven pruning. The effort of exploration is distributed between a symbolic component (verification of a particular CTP) and an enumerative component (exploration of the space of CTPs). We show that the proposed method facilitates more powerful pruning of the search space during the enumerative exploration.
-
monotonic partial order reduction an optimal symbolic partial order reduction technique
Computer Aided Verification, 2009Co-Authors: Vineet Kahlon, Chao Wang, Aarti GuptaAbstract:We present a new technique called Monotonic Partial Order Reduction (MPOR) that effectively combines dynamic partial order reduction with symbolic state space exploration for model checking Concurrent software. Our technique hinges on a new characterization of partial orders defined by computations of a Concurrent Program in terms of quasi-monotonic sequences of thread-ids. This characterization, which is of independent interest, can be used both for explicit or symbolic model checking. For symbolic model checking, MPOR works by adding constraints to allow automatic pruning of redundant interleavings in a SAT/SMT solver based search by restricting the interleavings explored to the set of quasi-monotonic sequences. Quasi-monotonicity guarantees both soundness (all necessary interleavings are explored) and optimality (no redundant interleaving is explored) and is, to the best of our knowledge, the only known optimal symbolic POR technique.
Chao Wang - One of the best experts on this subject based on the ideXlab platform.
-
dynamic partial order reduction for relaxed memory models
Programming Language Design and Implementation, 2015Co-Authors: Naling Zhang, Markus Kusano, Chao WangAbstract:Under a relaxed memory model such as TSO or PSO, a Concurrent Program running on a shared-memory multiprocessor may observe two types of nondeterminism: the nondeterminism in thread scheduling and the nondeterminism in store buffering. Although there is a large body of work on mitigating the scheduling nondeterminism during runtime verification, methods for soundly mitigating the store buffering nondeterminism are lacking. We propose a new dynamic partial order reduction (POR) algorithm for verifying Concurrent Programs under TSO and PSO. Our method relies on modeling both types of nondeterminism in a unified framework, which allows us to extend existing POR techniques to TSO and PSO without overhauling the verification algorithm. In addition to sound POR, we also propose a buffer-bounding method for more aggressively reducing the state space. We have implemented our new methods in a stateless model checking tool and demonstrated their effectiveness on a set of multithreaded C benchmarks.
-
symbolic predictive analysis for Concurrent Programs
Formal Aspects of Computing, 2011Co-Authors: Chao Wang, Rhishikesh Limaye, Malay K. Ganai, Sudipta Kundu, Aarti GuptaAbstract:Predictive analysis aims at detecting concurrency errors during runtime by monitoring a concrete execution trace of a Concurrent Program. In recent years, various models based on the happens-before causality relations have been proposed for predictive analysis. However, these models often rely on only the observed runtime events and typically do not utilize the Program source code. Furthermore, the enumerative algorithms they use for verifying safety properties in the predicted traces often suffer from the interleaving explosion problem. In this paper, we introduce a precise predictive model based on both the Program source code and the observed execution events, and propose a symbolic algorithm to check whether a safety property holds in all feasible permutations of events of the given trace. Rather than explicitly enumerating and checking the interleavings, our method conducts the search using a novel encoding and symbolic reasoning with a satisfiability modulo theory solver. We also propose a technique to bound the number of context switches allowed in the interleavings during the symbolic search, to further improve the scalability of the algorithm.
-
trace based symbolic analysis for atomicity violations
Tools and Algorithms for Construction and Analysis of Systems, 2010Co-Authors: Chao Wang, Rhishikesh Limaye, Malay K. Ganai, Aarti GuptaAbstract:We propose a symbolic algorithm to accurately predict atomicity violations by analyzing a concrete execution trace of a Concurrent Program. We use both the execution trace and the Program source code to construct a symbolic predictive model, which captures a large set of alternative interleavings of the events of the given trace. We use precise symbolic reasoning with a satisfiability modulo theory (SMT) solver to check the feasible interleavings for atomicity violations. Our algorithm differs from the existing methods in that all reported atomicity violations can appear in the actual Program execution; and at the same time the feasible interleavings analyzed by our model are significantly more than other predictive models that guarantee the absence of false alarms.
-
Staged Concurrent Program analysis
2010Co-Authors: Nishant Sinha, Chao WangAbstract:Concurrent Program verification is challenging because it involves exploring a large number of possible thread interleavings together with complex sequential reasoning. As a result, Concurrent Program verifiers resort to bi-modal reasoning, which alternates between reasoning over intra-thread (sequential) semantics and interthread (Concurrent) semantics. Such reasoning often involves repeated intra-thread reasoning for exploring each interleaving (interthread reasoning) and leads to inefficiency. In this paper, we present a new two-stage analysis which completely separates intra- and inter-thread reasoning. The first stage uses sequential Program semantics to obtain a precise summary of each thread in terms of the global accesses made by the thread. The second stage performs inter-thread reasoning by composing these thread-modular summaries using the notion of sequential consistency. Assertion violations and other concurrency errors are then checked in this composition with the help of an off-the-shelf SMT solver. We have implemented our approach in the FUSION framework for checking Concurrent C Programs shows that avoiding redundant bi-modal reasoning makes the analysis more scalable
-
symbolic pruning of Concurrent Program executions
Foundations of Software Engineering, 2009Co-Authors: Chao Wang, Aarti Gupta, Swarat Chaudhuri, Yu YangAbstract:We propose a new algorithm for verifying Concurrent Programs, which uses concrete executions to partition the Program into a set of lean partitions called Concurrent trace Programs (CTPs), and symbolically verifies each CTP using a satisfiability solver. A CTP, derived from a concrete execution trace, implicitly captures all permutations of the trace that also respect the control flow of the Program. We show that a CTP, viewed as a coarser equivalence class than the popular (Mazurkiewicz) trace equivalence in partial order reduction (POR) literature, leads to more effective pruning of the search space during model checking. While classic POR can prune away redundant interleavings within each trace equivalence class, the pruning in POR is not property driven. We use symbolic methods to achieve property-driven pruning. The effort of exploration is distributed between a symbolic component (verification of a particular CTP) and an enumerative component (exploration of the space of CTPs). We show that the proposed method facilitates more powerful pruning of the search space during the enumerative exploration.
Giuseppe De Giacomo - One of the best experts on this subject based on the ideXlab platform.
-
congolog a Concurrent Programming language based on the situation calculus
Artificial Intelligence, 2000Co-Authors: Giuseppe De Giacomo, Yves Lesperance, Hector J LevesqueAbstract:Abstract As an alternative to planning, an approach to high-level agent control based on Concurrent Program execution is considered. A formal definition in the situation calculus of such a Programming language is presented and illustrated with some examples. The language includes facilities for prioritizing the execution of Concurrent processes, interrupting the execution when certain conditions become true, and dealing with exogenous actions. The language differs from other procedural formalisms for concurrency in that the initial state can be incompletely specified and the primitive actions can be user-defined by axioms in the situation calculus. Some mathematical properties of the language are proven, for instance, that the proposed semantics is equivalent to that given earlier for the portion of the language without concurrency.
-
reasoning about Concurrent execution prioritized interrupts and exogenous actions in the situation calculus
International Joint Conference on Artificial Intelligence, 1997Co-Authors: Giuseppe De Giacomo, Yves Lesperance, Hector J LevesqueAbstract:As an alternative to planning, an approach to highlevel agent control based on Concurrent Program execution is considered. A formal definition in the situation calculus of such a Programming language is presented and illustrated with a detailed example. The language includes facilities for prioritizing the Concurrent execution, interrupting the execution when certain conditions become true, and dealing with exogenous actions. The language differs from other procedural formalisms for concurrency in that the initial state can be incompletely specified and the primitive actions can be user-defined by axioms in the situation calculus.