Hoare-style Reasoning with Higher-order Control: Continuations and Concurrency

• Autores: Germán Andrés Delbianco Porta
• Directores de la Tesis: Aleksandar Nanevski (dir. tes.)
• Lectura: En la Universidad Politécnica de Madrid ( España ) en 2017
• Idioma: español
• Tribunal Calificador de la Tesis: ANINDYA BANERJEE (presid.), Manuel Carro Liñares (secret.), Ana Sokolova (voc.), César Sánchez Sánchez (voc.), Bart Jacobs (voc.)
• Materias:
  • Lógica
    • Aplicaciones de la lógica
    • Lógica deductiva
      • Lógica formal
      • Sistemas formales
  • Matemáticas
    • Ciencia de los ordenadores
      • Lenguajes de programación
• Enlaces
  • Tesis en acceso abierto en: Archivo Digital UPM
• Resumen

  • The issue of software correctness is a long-standing problem in the computer science community, and it has always been relevant. Nowadays, even more so with the software industry becoming increasingly aware of the importance and benefits of formal verification. This comes as a consequence of realizing that having mathematical proof of the correctness of software systems is more efficient, even from an economical standpoint, than relying on a posteriori cycles of testing, debugging and re-implementing. However, formal verification is it painstakingly hard: it is a discipline closely connected to the semantic models on which programming languages are developed, usually involving complex mathematics. As technology paces forward, developing new logics to keep up becomes even harder. Since proving properties about complex programs is hard, it is preferable to have to do their proofs at most once. Unfortunately, this is not always possible.

    The main goal of this thesis is, in general, the development and application of program logics aimed at the modular verification of stateful programs with higher-order control effects. In particular, it focuses of two different kinds of control effects: sequential control, in the shape of continuations and higher-order control operators like callcc; and shared variable concurrency.

    A continuation is a powerful abstraction which models the "future of a computation". The availability of higher-order control operators like callcc make this execution context first-class citizens of a programming language, allowing client programs to have operational access (and control) over its execution context. The ability to manipulate "the future" makes these operators more powerful than plain goto-like instructions, but it also hinders the formal reasoning about programs. The contribution of this thesis in this regard is the development of a novel separation-like logic for the verification of higher-order stateful programs featuring callcc and abort control operators.

    As to shared-memory (or shared-variable) concurrency, we live in a world of massively concurrent software systems running over increasing multi-processing power. In such a context, it is natural to expect programmers---and thus programming languages---to desire to exploit the available parallelism in order to produce more efficient software. Unfortunately, the intricacies of concurrency conspire against reasoning---both formally and intuitively---about the correctness of algorithms.

    The contribution of this thesis in this regard is "Linking in Time", a novel approach to specification of concurrent objects, in which the dynamic and non-local aspects inherent to concurrency reasoning can be represented in a procedure-local and thread-local manner. This technique has been formally mechanized in FCSL, a fine-grained concurrent separation logic, and it has been applied to prove the correctness of non-trivial concurrent objects with highly-speculative, non-obvious correctness. The approach is similar in its goals to linearizability, but is carried out exclusively using a separation-style logic to uniformly represent the state and time aspects of the data structure and its methods.