Imperative Language

14,000,000 Leading Edge Experts on the ideXlab platform

Scan Science and Technology

Contact Leading Edge Experts & Companies

Scan Science and Technology

Contact Leading Edge Experts & Companies

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
    2014
    Co-Authors: Jean-yves Marion, Romain Péchoux
    Abstract:

    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, 2014
    Co-Authors: Jean-yves Marion, Romain Péchoux
    Abstract:

    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, 2014
    Co-Authors: Jean-yves Marion, Romain Péchoux
    Abstract:

    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, 2010
    Co-Authors: Gerard Boudol
    Abstract:

    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, 2007
    Co-Authors: Gerard Boudol
    Abstract:

    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
    2014
    Co-Authors: Jean-yves Marion, Romain Péchoux
    Abstract:

    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, 2014
    Co-Authors: Jean-yves Marion, Romain Péchoux
    Abstract:

    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, 2014
    Co-Authors: Jean-yves Marion, Romain Péchoux
    Abstract:

    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, 2015
    Co-Authors: Georg Neis, Janoliver Kaiser, Craig Mclaughlin, Derek Dreyer, Viktor Vafeiadis
    Abstract:

    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, 2015
    Co-Authors: Georg Neis, Janoliver Kaiser, Craig Mclaughlin, Derek Dreyer, Viktor Vafeiadis
    Abstract:

    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, 2013
    Co-Authors: Marc Bender, J I Zucker
    Abstract:

    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, 2013
    Co-Authors: Marc Bender, J I Zucker
    Abstract:

    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.