Type and behaviour reconstruction for higher-order concurrent programs (original) (raw)
Related papers
A type-based algorithm for the control-flow analysis of higher-order concurrent programs
Lecture Notes in Computer Science, 1997
We address, in a type-based framework, the problem of control-flow analysis for concurrent and functional languages. We present an efficient algorithm that propagates automatically types, communication effects and call graphs. The algorithm comes with a logical characterization that consists of a type proof system. The latter operates on a Concurrent ML core-syntax: a strongly typed, polymorphic kernel that supports higher-order functions and concurrency primitives. Effects are represented as algebraic terms that record communication effects resulting from channel creation, sending and receiving. Call graphs record function calls and are captured by a term algebra that is close to usual process algebras. Types are annotated with effects and call graphs. For the sake of flexibility, a subtyping relation is considered on the type algebra. We present the language syntax together with its static semantics that consists of the typing rules and an inference algorithm. The latter is proved to be consistent and complete with respect to the typing rules.
Inferring Types for Parallel Programs
Electronic Proceedings in Theoretical Computer Science, 2017
(MPI) framework is widely used in implementing imperative programs that exhibit a high degree of parallelism. The PARTYPES approach proposes a behavioural type discipline for MPI-like programs in which a type describes the communication protocol followed by the entire program. Well-typed programs are guaranteed to be exempt from deadlocks. In this paper we describe a type inference algorithm for a subset of the original system; the algorithm allows to statically extract a type for an MPI program from its source code.
A partially deadlock-free typed process calculus
ACM Transactions on Programming Languages and Systems, 1998
We propose a novel static type system for a process calculus, which ensures both partial deadlockfreedom and partial confluence. The key novel ideas are (1) introduction of the order of channel use as type information, and (2) classification of communication channels into reliable and unreliable channels based on their usage and a guarantee of the usage by the type system. We can ensure that communication on reliable channels never causes deadlock and also that certain reliable channels never introduce nondeterminism. After presenting the type system and formal proofs of its correctness, we show encodings of the λ-calculus and typical concurrent objects in the deadlockfree fragment of the calculus and demonstrate how type information can be used for reasoning about program behavior.
Behavioural types for a calculus of concurrent objects
Lecture Notes in Computer Science, 1997
We present a new type system for TyCO, a name-passing calculus of concurrent objects. The system captures dynamic aspects of the behaviour of objects, namely non-uniform service availability. The notion of processes without errors is loosened, demanding only weak fairness in the treatment of messages.
An Action Semantics for ML Concurrency Primitives
FME'94: Industrial Benefit of Formal Methods, 1994
This paper is about the recently-developed framework of action semantics. The pragmatic qualities of action semantic descriptions are particularly good, which encourages their use in industrial-scale applications where semantic descriptions are needed, e.g., compiler development.
Type-based information flow analysis for the π-calculus
Acta Informatica, 2005
We propose a new type system for information flow analysis for the π-calculus. As demonstrated by recent studies, information about whether each communication succeeds is important for precise information flow analysis for concurrent programs. By collecting such information using ideas of our previous type systems for deadlock/livelock-freedom, our type system can perform more precise analysis for certain communication/synchronization patterns (like synchronization using locks) than previous type systems. Our type system treats a wide range of communication/synchronization primitives in a uniform manner, which enabled development of a clear proof of type soundness and a sound and complete type inference algorithm.
Towards type-theoretic semantics for transactional concurrency
Proceedings of the 4th international workshop on Types in language design and implementation - TLDI '09, 2008
We propose a dependent type theory that combines programming, specifications and reasoning about higher-order concurrent programs with shared higher-order transactional memory.
2005
We introduce a novel way to integrate functional and concurrent programming based on intuitionistic linear logic. The functional core arises from interpreting proof reduction as computation. The concurrent core arises from interpreting proof search as computation. The two are tightly integrated via a monad that permits both sides to share the same logical meaning for the linear connectives while preserving their different computational paradigms. For example, concurrent computation synthesizes proofs which can be evaluated as functional programs. We illustrate our design with some small examples, including an encoding of the pi-calculus.
Proceedings 24th Australian Computer Science Conference. ACSC 2001, 2000
Communicating Sequential Processes (CSP) is a language used to describe and reason about concurrent systems. It consists of a process algebra combined with a functional language. This combination poses unique problems when attempting to design a type checker. In this paper the differences between a conventional functional language type checker and a type checker for the CSP language are discussed. This type checker was developed to identify polymorphic types, an important first step towards the goal of automating data independence . The result of this work has been incorporated into the Adelaide Refinement Checker (ARC) -a CSP based tool suite for model checking concurrent systems.
Non-standard type inference for functional programs
1998
While visiting the Computer Science Department of the University of Torino in November/December 1997. vi The evaluation rules for PCF are a subset of the ones for PCFP (in Figure 2.2), since the rules APP 2 and PROJ i (i ∈ {1, 2}) are not needed. All the results in the previous sections apply to PCF as well. 2.6 PCFP with primitive recursion In this section we introduce an extension of PCFP, called PCFP T , which is more suitable for expressing programs extracted from formal proofs. The language PCFP T is obtained from PCFP by adding a program constructor for primitive recursion over natural numbers (rec). There are also two constructors for specifying simplified uses of primitive recursion: the constructor it (for iteration) and the constructor case. PCFP T , which is a variant of Gödel's system T , is the language considered in Part III of this thesis. The term formation rules for the new constructors are in Fig. 2.4, and the evaluation rules are in Fig. 2.5. Since for every PCFP T term there is an equivalent (w.r.t. the interpretation in all the closed term model described in Section 2.4) PCFP term (see Fact 2.10 below), we have that all the results for PCFP presented in the previous sections apply to PCFP T as well.