2,821 research outputs found

    Deductive Verification of Parallel Programs Using Why3

    Full text link
    The Message Passing Interface specification (MPI) defines a portable message-passing API used to program parallel computers. MPI programs manifest a number of challenges on what concerns correctness: sent and expected values in communications may not match, resulting in incorrect computations possibly leading to crashes; and programs may deadlock resulting in wasted resources. Existing tools are not completely satisfactory: model-checking does not scale with the number of processes; testing techniques wastes resources and are highly dependent on the quality of the test set. As an alternative, we present a prototype for a type-based approach to programming and verifying MPI like programs against protocols. Protocols are written in a dependent type language designed so as to capture the most common primitives in MPI, incorporating, in addition, a form of primitive recursion and collective choice. Protocols are then translated into Why3, a deductive software verification tool. Source code, in turn, is written in WhyML, the language of the Why3 platform, and checked against the protocol. Programs that pass verification are guaranteed to be communication safe and free from deadlocks. We verified several parallel programs from textbooks using our approach, and report on the outcome.Comment: In Proceedings ICE 2015, arXiv:1508.0459

    Pabble: parameterised Scribble

    Get PDF
    © 2014, The Author(s).Many parallel and distributed message-passing programs are written in a parametric way over available resources, in particular the number of nodes and their topologies, so that a single parallel program can scale over different environments. This article presents a parameterised protocol description language, Pabble, which can guarantee safety and progress in a large class of practical, complex parameterised message-passing programs through static checking. Pabble can describe an overall interaction topology, using a concise and expressive notation, designed for a variable number of participants arranged in multiple dimensions. These parameterised protocols in turn automatically generate local protocols for type checking parameterised MPI programs for communication safety and deadlock freedom. In spite of undecidability of endpoint projection and type checking in the underlying parameterised session type theory, our method guarantees the termination of end point projection and type checking

    Behavioral types in programming languages

    Get PDF
    A recent trend in programming language research is to use behav- ioral type theory to ensure various correctness properties of large- scale, communication-intensive systems. Behavioral types encompass concepts such as interfaces, communication protocols, contracts, and choreography. The successful application of behavioral types requires a solid understanding of several practical aspects, from their represen- tation in a concrete programming language, to their integration with other programming constructs such as methods and functions, to de- sign and monitoring methodologies that take behaviors into account. This survey provides an overview of the state of the art of these aspects, which we summarize as the pragmatics of behavioral types

    Protocol-based verification of message-passing parallel programs

    Get PDF
    © 2015 ACM.We present ParTypes, a type-based methodology for the verification of Message Passing Interface (MPI) programs written in the C programming language. The aim is to statically verify programs against protocol specifications, enforcing properties such as fidelity and absence of deadlocks. We develop a protocol language based on a dependent type system for message-passing parallel programs, which includes various communication operators, such as point-to-point messages, broadcast, reduce, array scatter and gather. For the verification of a program against a given protocol, the protocol is first translated into a representation read by VCC, a software verifier for C. We successfully verified several MPI programs in a running time that is independent of the number of processes or other input parameters. This contrasts with alternative techniques, notably model checking and runtime verification, that suffer from the state-explosion problem or that otherwise depend on parameters to the program itself. We experimentally evaluated our approach against state-of-the-art tools for MPI to conclude that our approach offers a scalable solution

    Future-based Static Analysis of Message Passing Programs

    Get PDF
    Message passing is widely used in industry to develop programs consisting of several distributed communicating components. Developing functionally correct message passing software is very challenging due to the concurrent nature of message exchanges. Nonetheless, many safety-critical applications rely on the message passing paradigm, including air traffic control systems and emergency services, which makes proving their correctness crucial. We focus on the modular verification of MPI programs by statically verifying concrete Java code. We use separation logic to reason about local correctness and define abstractions of the communication protocol in the process algebra used by mCRL2. We call these abstractions futures as they predict how components will interact during program execution. We establish a provable link between futures and program code and analyse the abstract futures via model checking to prove global correctness. Finally, we verify a leader election protocol to demonstrate our approach.Comment: In Proceedings PLACES 2016, arXiv:1606.0540

    Hybrid Session Verification through Endpoint API Generation

    Get PDF
    © Springer-Verlag Berlin Heidelberg 2016.This paper proposes a new hybrid session verification methodology for applying session types directly to mainstream languages, based on generating protocol-specific endpoint APIs from multiparty session types. The API generation promotes static type checking of the behavioural aspect of the source protocol by mapping the state space of an endpoint in the protocol to a family of channel types in the target language. This is supplemented by very light run-time checks in the generated API that enforce a linear usage discipline on instances of the channel types. The resulting hybrid verification guarantees the absence of protocol violation errors during the execution of the session. We implement our methodology for Java as an extension to the Scribble framework, and use it to specify and implement compliant clients and servers for real-world protocols such as HTTP and SMTP

    Session-Based Programming for Parallel Algorithms: Expressiveness and Performance

    Full text link
    This paper investigates session programming and typing of benchmark examples to compare productivity, safety and performance with other communications programming languages. Parallel algorithms are used to examine the above aspects due to their extensive use of message passing for interaction, and their increasing prominence in algorithmic research with the rising availability of hardware resources such as multicore machines and clusters. We contribute new benchmark results for SJ, an extension of Java for type-safe, binary session programming, against MPJ Express, a Java messaging system based on the MPI standard. In conclusion, we observe that (1) despite rich libraries and functionality, MPI remains a low-level API, and can suffer from commonly perceived disadvantages of explicit message passing such as deadlocks and unexpected message types, and (2) the benefits of high-level session abstraction, which has significant impact on program structure to improve readability and reliability, and session type-safety can greatly facilitate the task of communications programming whilst retaining competitive performance

    Formal verification of parallel C+MPI programs

    Get PDF
    Tese de mestrado em Engenharia Informática (Engenharia de software), apresentada à Universidade de Lisboa, através da Faculdade de Ciências, 2013O Message Passing Interface (MPI) [6] é o padrão de referência para a programação de aplicações paralelas de alto desempenho em plataformas de execução que podem ir até centenas de milhares de cores. O MPI pode ser utilizado em programas C ou Fortran, sendo baseado no paradigma de troca de mensagens. De acordo com o paradigma Single Program, Multiple Data (SPMD), um único programa define o comportamento de vários processos, utilizando chamadas a primitivas MPI, como por exemplo para comunicações ponto-a-ponto ou para comunicações colectivas. O uso de MPI levanta questões de fiabilidade, uma vez que é muito fácil escrever um programa contendo um processo que bloqueie indefinidamente enquanto espera por uma mensagem, ou que o tipo e a dimensão dos dados enviados e esperados por dois processos não coincidam. Assim, não é possível garantir à partida (em tempo de compilação) uma série de propriedades fundamentais sobre a execução de um programa. Lidar com este desafio não é de todo trivial. A verificação de programas MPI utiliza tipicamente técnicas avançadas como a verificação de modelos ou execução simbólica [9, 39]. Estas abordagens deparam-se frequentemente com o problema de escalabilidade, dado o espaço de estados do processo de verificação crescer exponencialmente com o número de processos considerados. A verificação em tempo útil pode estar limitada a menos de uma dezena de processos na verificação de aplicações real-world [41]. A verificação é ainda adicionalmente complicada por outros aspectos, como a existência de diversos tipos de primitivas MPI com diferentes semânticas de comunicação [39], ou a dificuldade em destrinçar o fluxo colectivo e individual de processos num único corpo comum de código [2]. A abordagem considerada para a verificação de programas MPI é baseada em tipos de sessão multi-participante [19]. A ideia base passa por especificar o protocolo de comunicação a ser respeitado por um conjunto de participantes que comunicam entre si trocando mensagens. A partir de um protocolo expresso desta forma, é possível extrair por sua vez o protocolo local de cada um dos participantes, segundo uma noção de projecção de comportamentos. Se para cada participante (processo) no programa MPI se verificar a aderência ao protocolo local respectivo, são garantidas propriedades como a ausência de condições de impasse e a segurança de tipos. A verificação desta aderência é feita sobre programas C que usam MPI, usando a ferramenta VCC da Microsoft Research [5]. Para codificar protocolos, foi utilizada uma linguagem formal de descrição de protocolos, apropriada à expressão dos padrões mais comuns de programas MPI. A partir de um protocolo expresso nessa linguagem. é gerado um header C que exprime o tipo num formato compatível com a ferramenta VCC [5]. Para além da codificação protocolo, a verificação é ainda guiada por um conjunto de contratos pré-definidos para primitivas MPI e por anotações no corpo do programa C. As anotações no programa são geradas automaticamente ou, em número tipicamente mais reduzido, introduzidas pelo programador. Os protocolos que regem as comunicações globais num programa MPI são especificados numa linguagem de protocolos, desenhada especificamente para o efeito no contexto do projecto MULTICORE em complemento ao trabalho desta tese, e em associação um plugin Eclipse que verifica a boa formação dos protocolos e que gera a codificação do protocolo na linguagem VCC. As ações básicas dos protocolos descrevem no caso geral primitivas MPI, por exemplo para comunicação ponto-a-ponto ou comunicação colectiva. Os valores associados a ações podem ser do género inteiro ou vírgula flutuante, bem como vectores. Além disso, qualquer um destes géneros pode ser refinado com imposição de restrições aos valores dos dados. As ações básicas são compostas através de operadores de sequência, iteração, e ainda de fluxo de controlo coletivo em correspondência a escolhas ou ciclos executados de forma síncrona por todos os participantes. A partir da especificação de um protocolo, a sua tradução no formato VCC define uma função de projecção. A função de projecção toma como argumento o índice do processo MPI, conhecido como rank, e devolve a codificação de um protocolo local a ser verificado para execução do participante, em linha com o enunciado pela noção de projeção [19]. Esta codificação reflecte de resto todas as características gerais da especificação do protocolo, em termos de ações básicas, o uso de tipos refinados, e operadores de composição. O processo de verificação tem por fim certificar a aderência do programa C+MPI face ao protocolo, para cada participante. Entre a inicialização e o término das comunicaçoes MPI, a verificação deve operar a redução progressiva do protocolo até ao protocolo vazio. As reduções são definidas mediante pontos de chamadas a primitivas MPI e características do fluxo de controlo de programa. Para manter o estado, a verificação manipula uma variável “fantasma” desde o ponto de entrada da programa (a função main()) que representa o protocolo. Para além da aderência ao protocolo, são ainda verificados aspectos complementares, como por exemplo se os dados usam regiões válidas de memória. Esta verificação usa um corpo base de definições, a que chamamos a “MPI anotada”. A MPI anotada compreende a lógica de protocolos e um corpo de contratos para um conjunto de primitivas MPI. A lógica de protocolos permite definir a estrutura de protocolos e definir as regras de redução, enquanto que os contratos das primitivas definem casos base para redução via ações de comunicação. Este corpo base pode ser importado para o contexto de verificação de um programa em particular, mediante a inclusão de um header C, a versão anotada do header convencional da MPI (mpi.h) [6]. Usando esta lógica base, o programa C pode ser anotado para verificação. As anotações relacionam-se com uma diversidade de aspectos que impactam da verificação do programa, tais como o fluxo de controlo colectivo, contratos de funções, invariantes de ciclos, asserções respeitantes ao uso de memória, ou a declaração de assunções até aí implícitas no comportamento do programa. O processo de anotação é um desafio para um programador, já que requer o domínio de uma lógica complexa de verificação. Para automatizar o processo, foi desenvolvido um anotador que gera uma parte significativa das anotações necessárias, transformando código C usando a biblioteca clang/LLVM [4]. O seu funcionamento base guia-se por anotações de alto nível para identificação de fluxo de controlo relevante e marcas de anotação simples introduzidas pelo programador, por forma a gerar em correspondência a um conjunto mais vasto e complexo de anotações. Após este processo automático, há anotações complementares que têm de ser introduzidas manualmente para a verificação bem sucedida de um programa. Estas últimas relacionam-se com aspectos diversos que ou são de inferência complexa, por exemplo o uso de memória, ou ainda não tratados na aproximação atual com um processo automatizado. Esta aproximação à verificação de programas C+MPI foi testada com um conjunto de exemplos tirados de livros de texto. Além de demonstrar a aplicabilidade da aproximação geral considerada, é apresentada uma análise do esforço de anotação e do tempo de verificação. O esforço de anotação mede a comparação entre o número de anotações automáticas face ao número de anotações manuais, verificando-se no caso geral que o número de anotações manuais é inferior ao número das automáticas. O tempo de verificação diz respeito ao tempo de execução da ferramenta VCC para o código anotado final de um programa. A análise de escalabilidade do mesmo face a um número crescente de processos permitiu identificar casos distintos: casos em que o tempo de execução é insensível ao número de processos e outros em que este tempo cresce exponencialmente face ao número de processos. Em conclusão, é definida uma metodologia para a verificação formal de programas MPI e demonstrada a sua aplicabilidade, combinando os paradigmas da teoria de tipos de sessão multi-participante e da verificação dedutiva de programas. Para lidar com uma maior gama de programas MPI, em particular programas real-world, ao longo do texto foram discutidos vários desafios que se colocam para uma evolução da metodologia, de tipo conceptual ou relacionados com a automação e escalabilidade. Para lidar com esses desafios, propõe-se na parte final um conjunto de linhas gerais para trabalho futuro.Message Passing Interface (MPI) is the de facto standard for message-based parallel applications. Two decades after the first version of its specification, MPI applications routinely execute on supercomputers and computer clusters. MPI programs incarnate the Single Program Multiple Data (SPMD) paradigm. A single body of code, written in C or Fortran, defines the behavior of all participant processes in a program. The number of processes is defined at runtime, and any partial distinction of behavior between participants is based on the unique rank (numerical identifier) of each process. The communication between processes is defined through point-to-point or collective communication primitives. As a result, programs may easily exhibit intricate behaviors mixing collective and participant-specific flow, making it difficult to verify a priori desirable properties like absence of deadlocks or adherence to a desired communication protocol. In line with the concern for verifiable program behavior in MPI, the theory of multiparty session types provides a framework for well-structured communication protocols by an arbitrary number of participant processes. By construction, a multi-party global protocol declares a desired interaction behavior that guarantees properties such as type safety and absence of deadlocks, and implicitly defines the individual local protocols per participant. Provided that the actual program specification of each participant conforms to the corresponding local protocol, the safety properties and the intended choreography of the global protocol are preserved by the program. This thesis proposes the application of multi-party session type theory to C+MPI programs, coupled with the use of deductive software verification. A framework is proposed for the expression of multi-party session protocols in the MPI context and their verification using a deductive software tool. The framework also addresses concerns for automation through semi-automatic annotation of verification logic in program code. An evaluation of the applicability of the approach is conducted over a sample set of programs

    Explicit connection actions in multiparty session types

    Get PDF
    This work extends asynchronous multiparty session types (MPST) with explicit connection actions to support protocols with op- tional and dynamic participants. The actions by which endpoints are connected and disconnected are a key element of real-world protocols that is not treated in existing MPST works. In addition, the use cases motivating explicit connections often require a more relaxed form of mul- tiparty choice: these extensions do not satisfy the conservative restric- tions used to ensure safety in standard syntactic MPST. Instead, we de- velop a modelling-based approach to validate MPST safety and progress for these enriched protocols. We present a toolchain implementation, for distributed programming based on our extended MPST in Java, and a core formalism, demonstrating the soundness of our approach. We discuss key implementation issues related to the proposed extensions: a practi- cal treatment of choice subtyping for MPST progress, and multiparty correlation of dynamic binary connections
    corecore