Modeling, Simulation And Verification Language Program Research Articles

DAG-Based Formal Modeling of Spark Applications with MSVL

Apache Spark is a high-speed computing engine for processing massive data. With its widespread adoption, there is a growing need to analyze its correctness and temporal properties. However, there is scarce research focused on the verification of temporal properties in Spark programs. To address this gap, we employ the code-level runtime verification tool UMC4M based on the Modeling, Simulation, and Verification Language (MSVL). To this end, a Spark program S has to be translated into an MSVL program M, and the negation of the property P specified by a Propositional Projection Temporal Logic (PPTL) formula that needs to be verified is also translated to an MSVL program M1; then, a new MSVL program “M and M1” can be compiled and executed. Whether program S violates the property P is determined by the existence of an acceptable execution of “M and M1”. Thus, the key issue lies in how to formalize model Spark programs using MSVL programs. We previously proposed a solution to this problem—using the MSVL functions to perform Resilient Distributed Datasets (RDD) operations and converting the Spark program into an MSVL program based on the Directed Acyclic Graph (DAG) of the Spark program. However, we only proposed this idea. Building upon this foundation, we implement the conversion from RDD operations to MSVL functions and propose, as well as implement, the rules for translating Spark programs to MSVL programs based on DAG. We confirm the feasibility of this approach and provide a viable method for verifying the temporal properties of Spark programs. Additionally, an automatic translation tool, S2M, is developed. Finally, a case study is presented to demonstrate this conversion process.

A novel approach to verifying context free properties of programs

This paper proposes an approach to verifying context free properties of programs. In this approach, the system to be verified is modeled as a program m in Modeling, Simulation and Verification Language (MSVL), and the desired property is also specified by an MSVL program m′. Then program m and formula ¬m′ are interpreted by means of executing programs m and m′. If an acceptable execution path is generated, a counterexample is found, otherwise the property is valid. To show how the proposed approach works, an example is given.

Translating Xd-C programs to MSVL programs

C language is one of the most popular languages for software systems. In order to verify safety, reliability and security properties of such systems written in C, a tool UMC4M for runtime verification at code level based on Modeling, Simulation and Verification Language (MSVL) and its compiler MC is employed. To do so, a C program P has to be translated to an MSVL program M and the negation of a desired property Q is also translated to an MSVL program M', then “M and M'” is compiled and executed armed with MC. Whether P violates Q is checked by evaluating whether there exists an acceptable execution of new MSVL program “M and M'”. Therefore, how to translate a C program to an MSVL program is a critical issue. However, in general, C is of complicated structures with goto statement. In this paper, we confine the syntax of C in a suitable subset called Xd-C without loss of expressiveness. Further, we present a translation algorithm from an Xd-C program to an MSVL program based on translation algorithms for expressions and statements. Moreover, the equivalences between expressions and statements involved in Xd-C and MSVL programs are inductively proved. Subsequently, the equivalence between the original Xd-C program and the translated MSVL program is also proved. In addition, the proposed approach has been implemented by a tool called C2M. A benchmark of experiments including 13 real-world Xd-C programs is conducted. The results show that C2M works effectively.

Verifying Full Regular Temporal Properties of Programs via Dynamic Program Execution

Verification of programs at code level has attracted more and more attentions since the cost is high to extract models from source code. Most of approaches available for code level verification are carried out by inserting assertions into programs and then checking whether the assertions are violated. In this way, only safety properties can be verified, however, other temporal properties of programs such as liveness are hard to be verified. To tackle this problem, a novel runtime verification approach, which can verify full regular temporal properties of a program, is proposed in this paper. With this approach, a program to be verified is written in a modeling, simulation and verification language (MSVL) as a program M and a desired property is specified by a propositional projection temporal logic formula $P$ . The negation of the desired property is then translated to an MSVL program M’ . Thus, whether M violates $P$ can be checked by evaluating whether there exists an acceptable execution of the new MSVL program “ M and M’ .” This problem can efficiently be solved with the MSVL compiler where verification cases are generated via dynamic symbolic execution. Further, we adopt parallel mechanism to handle various execution paths of a program for improving the efficiency. The proposed approach has been implemented in a tool called MSV . Experiments show that the performance of MSV outperforms existing tools such as T2, RiTHM, and LTLAutomizer in verifying temporal properties of real-world programs.

A temporal logic programming approach to planning

This paper presents an approach to performing artificial intelligence planning through temporal logic programming with Search Control Knowledge (SCK). First, the planning problem described with Planning Domain Description Language is modeled as a program m in Modeling, Simulation and Verification Language (MSVL). Second, the SCK is also specified with an MSVL program $$m'$$ . Third, using the basic operation “and” in MSVL, a new MSVL program “ $$m~and~m'$$ ” is obtained. Forth, with the compiler MC of MSVL, an executable binary code of program “ $$m~and~m'$$ ” is obtained. Finally, planning result can be obtained via executing the executable code. Experimental results on selected benchmark planning domains from the International Planning Competition 2014 show that our approach is more effective in practice. Furthermore, the obtained plans are verified with the toolkit MSV so that a plan can be confirmed whether it is a reliable one.

Verify heaps via unified model checking

This paper addresses the problem of verifying heap evolution properties of pointer programs. To this end, a new unified model checking approach with MSVL (Modeling, Simulation and Verification Language) and PPTLSL is presented. The former is an executable subset of PTL (Projection Temporal Logic) while the latter is an extension of PPTL (Propositional Projection Temporal Logic) with separation logic. MSVL is used to model pointer programs, and PPTLSL to specify heap evolution properties. Technically, on one hand, models of MSVL programs are characterized by Normal Form Graphs (NFGs). On the other hand, PPTLSL is equisatisfiably reduced to its subset which can reuse the decision procedure of PPTL. Our technique is able to deal with a variety of pointer structures such as linked lists and composite structures. In addition, we implement a prototype tool by using an SMT solver as the verification engine in order to demonstrate our approach.

A compiler for MSVL and its applications

In this paper, we present a method for implementing a compiler called MC for Modeling, Simulation and Verification Language (MSVL) based on LLVM. MC accepts a well formed MSVL program as input and generates an executable binary code. Different from other compilers, MC can be used not only to compile programs but also to model and verify programs. The details of implementation including the architecture design, lexical, syntactic and semantic analysis, as well as preprocessing and scheduling algorithms. Besides, we show MC can be utilized as an infrastructure for Artificial Intelligence (AI) planning. Several examples are given to show applications of MC in modeling and verifying programs, as well as AI planning.

A mechanism of function calls in MSVL

Modeling, Simulation and Verification Language (MSVL) is a useful formalism for specification and verification of concurrent systems. To make it more practical and easier to use, we extend MSVL with external and internal function calls. To do so, the syntax of function definitions and function calls is formalized. Then, the syntax of expressions in MSVL is extended by including function calls. Further, the evaluation rules are redefined. Moreover, the set of statements in MSVL is also extended and the semantics of function call statements is formalized. In addition, the existence of minimal models of MSVL programs involving new added statements is proved. Finally, an example is given to illustrate how to interpret function calls in practice with MSVL.

Model checking Petri nets with MSVL

This paper presents three translations from Petri nets to Modeling, Simulation and Verification Language (MSVL) programs. Each translation is directed by one of the three semantics of Petri nets, namely interleaving, concurrency and max-concurrency. Further, for each translation, an equivalence relation between Petri nets and generated MSVL programs is proved. As a result, the supporting tool MSV for MSVL can be used to verify the properties of Petri nets. Case studies are given to show how to do so with MSV under each semantics.

A formal proof of the deadline driven scheduler in PPTL axiomatic system

This paper presents an approach for verifying the correctness of the feasibility theorem on the deadline driven scheduler (DDS) with the axiom system of Propositional Projection Temporal Logic (PPTL). To do so, the deadline driven scheduling algorithm is modeled by an MSVL (Modeling, Simulation and Verification Language) program and the feasibility theorem is formulated by PPTL formulas with two parts: a necessary part and a sufficient part. Then, several lemmas are abstracted and proved by means of the axiom system of PPTL. With the help of the lemmas, two parts of the theorem are deduced respectively. This case study convinces us that some real-time properties of systems can be formally verified by theorem proving using the axiom system of PPTL.