The Experts below are selected from a list of 3558 Experts worldwide ranked by ideXlab platform
Romain Péchoux - One of the best experts on this subject based on the ideXlab platform.
-
Complexity Information Flow in a Multi-threaded Imperative Language
2014Co-Authors: Jean-yves Marion, Romain PéchouxAbstract:We propose a type system to analyze the time consumed by multi-threaded Imperative programs with a shared global memory, which delineates a class of safe multi-threaded programs. We demon-strate that a safe multi-threaded program runs in polynomial time if (i) it is strongly terminating wrt a non-deterministic scheduling policy or (ii) it terminates wrt a deterministic and quiet scheduling policy. As a consequence, we also characterize the set of polynomial time functions. The type system presented is based on the fundamental notion of data tiering, which is central in implicit computational complexity. It regu-lates the information flow in a computation. This aspect is interesting in that the type system bears a resemblance to typed based informa-tion flow analysis and notions of non-interference. As far as we know, this is the first characterization by a type system of polynomial time multi-threaded programs.
-
complexity information flow in a multi threaded Imperative Language
Theory and Applications of Models of Computation, 2014Co-Authors: Jean-yves Marion, Romain PéchouxAbstract:In this paper, we propose a type system to analyze the time consumed by multi-threaded Imperative programs with a shared global memory, which delineates a class of safe multi-threaded programs. We demonstrate that a safe multi-threaded program runs in polynomial time if (i) it is strongly terminating wrt a non-deterministic scheduling policy or (ii) it terminates wrt a deterministic and quiet scheduling policy. As a consequence, we also characterize the set of polynomial time functions. The type system presented is based on the fundamental notion of data tiering, which is central in implicit computational complexity. It regulates the information flow in a computation. This aspect is interesting in that the type system bears a resemblance to typed based information flow analysis and notions of non-interference. As far as we know, this is the first characterization by a type system of polynomial time multi-threaded programs.
-
TAMC - Complexity Information Flow in a Multi-threaded Imperative Language
Lecture Notes in Computer Science, 2014Co-Authors: Jean-yves Marion, Romain PéchouxAbstract:In this paper, we propose a type system to analyze the time consumed by multi-threaded Imperative programs with a shared global memory, which delineates a class of safe multi-threaded programs. We demonstrate that a safe multi-threaded program runs in polynomial time if (i) it is strongly terminating wrt a non-deterministic scheduling policy or (ii) it terminates wrt a deterministic and quiet scheduling policy. As a consequence, we also characterize the set of polynomial time functions. The type system presented is based on the fundamental notion of data tiering, which is central in implicit computational complexity. It regulates the information flow in a computation. This aspect is interesting in that the type system bears a resemblance to typed based information flow analysis and notions of non-interference. As far as we know, this is the first characterization by a type system of polynomial time multi-threaded programs.
Gerard Boudol - One of the best experts on this subject based on the ideXlab platform.
-
typing termination in a higher order concurrent Imperative Language
Information & Computation, 2010Co-Authors: Gerard BoudolAbstract:We propose means to predict termination in a higher-order Imperative and concurrent Language a la ML. We follow and adapt the classical method for proving termination in typed formalisms, namely the realizability technique. There is a specific difficulty with higher-order state, which is that one cannot define a realizability interpretation simply by induction on types, because applying a function may have side-effects at types not smaller than the type of the function. Moreover, such higher-order side-effects may give rise to computations that diverge without resorting to explicit recursion. We overcome these difficulties by introducing a type and effect system for our Language that enforces a stratification of the memory. The stratification prevents the circularities in the memory that may cause divergence, and allows us to define a realizability interpretation of the types and effects, which we then use to establish that typable sequential programs in our system are guaranteed to terminate, unless they use explicit recursion in a divergent way. We actually prove a more general fairness property, that is, any typable thread yields the scheduler after some finite computation. Our realizability interpretation also copes with dynamic thread creation.
-
fair cooperative multithreading typing termination in a higher order concurrent Imperative Language
International Conference on Concurrency Theory, 2007Co-Authors: Gerard BoudolAbstract:We propose a new operational model for shared variable concurrency, in the context of a concurrent, higher-order Imperative Language a la ML. In our model the scheduling of threads is cooperative, and a non-terminating process suspends itself on each recursive call. A property to ensure in such a model is fairness, that is, any thread should yield the scheduler after some finite computation. To this end, we follow and adapt the classical method for proving termination in typed formalisms, namely the realizability technique. There is a specific difficulty with higher-order state, which is that one cannot define a realizability interpretation simply by induction on types, because applying a function may have side-effects at types not smaller than the type of the function. Moreover, such higher-order side-effects may give rise to computations that diverge without resorting to explicit recursion. We overcome these difficulties by introducing a type and effect system for our Language that enforces a stratification of the memory. The stratification prevents the circularities in the memory that may cause divergence, and allows us to define a realizability interpretation of the types and effects, which we then use to prove the intended termination property.
Jean-yves Marion - One of the best experts on this subject based on the ideXlab platform.
-
Complexity Information Flow in a Multi-threaded Imperative Language
2014Co-Authors: Jean-yves Marion, Romain PéchouxAbstract:We propose a type system to analyze the time consumed by multi-threaded Imperative programs with a shared global memory, which delineates a class of safe multi-threaded programs. We demon-strate that a safe multi-threaded program runs in polynomial time if (i) it is strongly terminating wrt a non-deterministic scheduling policy or (ii) it terminates wrt a deterministic and quiet scheduling policy. As a consequence, we also characterize the set of polynomial time functions. The type system presented is based on the fundamental notion of data tiering, which is central in implicit computational complexity. It regu-lates the information flow in a computation. This aspect is interesting in that the type system bears a resemblance to typed based informa-tion flow analysis and notions of non-interference. As far as we know, this is the first characterization by a type system of polynomial time multi-threaded programs.
-
complexity information flow in a multi threaded Imperative Language
Theory and Applications of Models of Computation, 2014Co-Authors: Jean-yves Marion, Romain PéchouxAbstract:In this paper, we propose a type system to analyze the time consumed by multi-threaded Imperative programs with a shared global memory, which delineates a class of safe multi-threaded programs. We demonstrate that a safe multi-threaded program runs in polynomial time if (i) it is strongly terminating wrt a non-deterministic scheduling policy or (ii) it terminates wrt a deterministic and quiet scheduling policy. As a consequence, we also characterize the set of polynomial time functions. The type system presented is based on the fundamental notion of data tiering, which is central in implicit computational complexity. It regulates the information flow in a computation. This aspect is interesting in that the type system bears a resemblance to typed based information flow analysis and notions of non-interference. As far as we know, this is the first characterization by a type system of polynomial time multi-threaded programs.
-
TAMC - Complexity Information Flow in a Multi-threaded Imperative Language
Lecture Notes in Computer Science, 2014Co-Authors: Jean-yves Marion, Romain PéchouxAbstract:In this paper, we propose a type system to analyze the time consumed by multi-threaded Imperative programs with a shared global memory, which delineates a class of safe multi-threaded programs. We demonstrate that a safe multi-threaded program runs in polynomial time if (i) it is strongly terminating wrt a non-deterministic scheduling policy or (ii) it terminates wrt a deterministic and quiet scheduling policy. As a consequence, we also characterize the set of polynomial time functions. The type system presented is based on the fundamental notion of data tiering, which is central in implicit computational complexity. It regulates the information flow in a computation. This aspect is interesting in that the type system bears a resemblance to typed based information flow analysis and notions of non-interference. As far as we know, this is the first characterization by a type system of polynomial time multi-threaded programs.
Viktor Vafeiadis - One of the best experts on this subject based on the ideXlab platform.
-
pilsner a compositionally verified compiler for a higher order Imperative Language
International Conference on Functional Programming, 2015Co-Authors: Georg Neis, Janoliver Kaiser, Craig Mclaughlin, Derek Dreyer, Viktor VafeiadisAbstract:Compiler verification is essential for the construction of fully verified software, but most prior work (such as CompCert) has focused on verifying whole-program compilers. To support separate compilation and to enable linking of results from different verified compilers, it is important to develop a compositional notion of compiler correctness that is modular (preserved under linking), transitive (supports multi-pass compilation), and flexible (applicable to compilers that use different intermediate Languages or employ non-standard program transformations). In this paper, building on prior work of Hur et al., we develop a novel approach to compositional compiler verification based on parametric inter-Language simulations (PILS). PILS are modular: they enable compiler verification in a manner that supports separate compilation. PILS are transitive: we use them to verify Pilsner, a simple (but non-trivial) multi-pass optimizing compiler (programmed in Coq) from an ML-like source Language S to an assembly-like target Language T, going through a CPS-based intermediate Language. Pilsner is the first multi-pass compiler for a higher-order Imperative Language to be compositionally verified. Lastly, PILS are flexible: we use them to additionally verify (1) Zwickel, a direct non-optimizing compiler for S, and (2) a hand-coded self-modifying T module, proven correct w.r.t. an S-level specification. The output of Zwickel and the self-modifying T module can then be safely linked together with the output of Pilsner. All together, this has been a significant undertaking, involving several person-years of work and over 55,000 lines of Coq.
-
ICFP - Pilsner: a compositionally verified compiler for a higher-order Imperative Language
Proceedings of the 20th ACM SIGPLAN International Conference on Functional Programming - ICFP 2015, 2015Co-Authors: Georg Neis, Janoliver Kaiser, Craig Mclaughlin, Derek Dreyer, Viktor VafeiadisAbstract:Compiler verification is essential for the construction of fully verified software, but most prior work (such as CompCert) has focused on verifying whole-program compilers. To support separate compilation and to enable linking of results from different verified compilers, it is important to develop a compositional notion of compiler correctness that is modular (preserved under linking), transitive (supports multi-pass compilation), and flexible (applicable to compilers that use different intermediate Languages or employ non-standard program transformations). In this paper, building on prior work of Hur et al., we develop a novel approach to compositional compiler verification based on parametric inter-Language simulations (PILS). PILS are modular: they enable compiler verification in a manner that supports separate compilation. PILS are transitive: we use them to verify Pilsner, a simple (but non-trivial) multi-pass optimizing compiler (programmed in Coq) from an ML-like source Language S to an assembly-like target Language T, going through a CPS-based intermediate Language. Pilsner is the first multi-pass compiler for a higher-order Imperative Language to be compositionally verified. Lastly, PILS are flexible: we use them to additionally verify (1) Zwickel, a direct non-optimizing compiler for S, and (2) a hand-coded self-modifying T module, proven correct w.r.t. an S-level specification. The output of Zwickel and the self-modifying T module can then be safely linked together with the output of Pilsner. All together, this has been a significant undertaking, involving several person-years of work and over 55,000 lines of Coq.
J I Zucker - One of the best experts on this subject based on the ideXlab platform.
-
assignment calculus a pure Imperative Language
Foundations of Computer Science, 2013Co-Authors: Marc Bender, J I ZuckerAbstract:We undertake a study of Imperative computation. Beginning with a philosophical analysis of the distinction between Imperative and functional Language features, we define a (pure) Imperative Language as one whose constructs are (inherently) referentially opaque. We then give a definition of a computation Language by identifying desirable properties for such a Language.
-
LFCS - Assignment Calculus: A Pure Imperative Language
Logical Foundations of Computer Science, 2013Co-Authors: Marc Bender, J I ZuckerAbstract:We undertake a study of Imperative computation. Beginning with a philosophical analysis of the distinction between Imperative and functional Language features, we define a (pure) Imperative Language as one whose constructs are (inherently) referentially opaque. We then give a definition of a computation Language by identifying desirable properties for such a Language.