Future-based Static Analysis of Message Passing Programs

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

Deductive Verification of Parallel Programs Using Why3

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

Protocol-based verification of message-passing parallel programs

© 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

Behavioral types in programming languages

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

PARCOACH: Combining static and dynamic validation of MPI collective communications

International audienceNowadays most scientific applications are parallelized based on MPI communications. Collective MPI communications have to be executed in the same order by all processes in their communicator and the same number of times, otherwise it is not conforming to the standard and a deadlock or other undefined behavior can occur. As soon as the control-flow involving these collective operations becomes more complex, in particular including conditionals on process ranks, ensuring the correction of such code is error-prone. We propose in this paper a static analysis to detect when such situation occurs, combined with a code transformation that prevents from deadlocking. We focus on blocking MPI collective operations in SPMD applications, assuming MPI calls are not nested in multithreaded regions. We show on several benchmarks the small impact on performance and the ease of integration of our techniques in the development process

GEM: graphical explorer for MPI programs

technical reportFormal dynamic verification can complement MPI program testing by detecting hard-to-find concurrency bugs. In previous work, we described our dynamic verifier called ISP that can parsimoniously search the execution space of an MPI program while detecting important classes of bugs. One major limitation of ISP, when used by itself, is the lack of a powerful and widely usable graphical front-end. We present a new tool called Graphical Explorer of Message Passing (GEM) that overcomes this limitation. GEM is a plug-in architecture that greatly enhances the usability of ISP, and may help bring ISP within reach of a wide array of programmers, given its imminent release as part of the Eclipse Foundation Parallel Tools Platform (PTP) Version 3.0. This paper describes GEM?s features, its architecture, and usage experience summary of the ISP/GEM combination. Recently, we applied this combination on a widely used parallel hypergraph partitioner. Even with modest amounts of computational resources, the ISP/GEM combination finished quickly, and intuitively displayed a previously unknown resource leak in this code-base

Formal verification of parallel C+MPI programs

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