A survey of MPI related debuggers and tools

technical reportMessage Passing Interface is a widely used standard in the High Performance and Scienti c Computing Community for writing programs that can exploit the capability of parallel platforms. However, the inherent complexity and the size of the communication standard have made it difficult for programmers to use it efficiently and more importantly correctly. There are numerous tools and debuggers written by various academic/industry communities to nd bugs in the MPI programs written by users. Some of them are MPI-CHECK (Iowa state Univ, [12]), MPIDD (UNBC, Canada [6]), UMPIRE (LLNL, [15]), Intel Message Checker (Intel, [5]), MARMOT (HLRS, [8]) and TotalView ([1]). A brief analysis and comparison of these tools are presented below. In addition, this report presents an overview of the debugging support build into some of the currently popular MPI libraries

MPI Support on the Grid

Grids as infrastructures offer access to computing, storage and other resources in a transparent way. The user does not have to be aware where and how the job is being executed. Grid clusters in particular are an interesting target for running computation-intensive calculations. Running MPI-parallel applications on such clusters is a logical approach that is of interest to both computer scientists and to engineers. This paper gives an overview of the issues connected to running MPI applications on a heterogenous Grid consisting of different clusters located at different sites within the Int.EU.Grid project. The role of a workload management system (WMS) for such a scenario, as well as important modifications that need to be made to a WMS oriented towards sequential batch jobs for better support of MPI applications and tools are discussed. In order to facilitate the adoption of MPI-parallel applications on heterogeneous Grids, the application developer should be made aware of performance problems, as well as MPI-standard issues within its code. Therefore tools for these issues are also supported within Int.EU.Grid. Also, the special case of running MPI applications on different clusters simultaneously as a more Grid-oriented computational approach is described

Doctor of Philosophy

dissertationAlmost all high performance computing applications are written in MPI, which will continue to be the case for at least the next several years. Given the huge and growing importance of MPI, and the size and sophistication of MPI codes, scalable and incisive MPI debugging tools are essential. Existing MPI debugging tools have, despite their strengths, many glaring de ficiencies, especially when it comes to debugging under the presence of nondeterminism related bugs, which are bugs that do not always show up during testing. These bugs usually become manifest when the systems are ported to di fferent platforms for production runs. This dissertation focuses on the problem of developing scalable dynamic verifi cation tools for MPI programs that can provide a coverage guarantee over the space of MPI nondeterminism. That is, the tools should be able to detect diff erent outcomes of nondeterministic events in an MPI program and enforce all those di fferent outcomes through repeated executions of the program with the same test harness. We propose to achieve the coverage guarantee by introducing efficient distributed causality tracking protocols that are based on the matches-before order. The matches-before order is introduced to address the shortcomings of the Lamport happens-before order [40], which is not sufficient to capture causality for MPI program executions due to the complexity of the MPI semantics. The two protocols we propose are the Lazy Lamport Clocks Protocol (LLCP) and the Lazy Vector Clocks Protocol (LVCP). LLCP provides good scalability with a small possibility of missing potential outcomes of nondeterministic events while LVCP provides full coverage guarantee with a scalability tradeoff . In practice, we show through our experiments that LLCP provides the same coverage as LVCP. This thesis makes the following contributions: •The MPI matches-before order that captures the causality between MPI events in an MPI execution. • Two distributed causality tracking protocols for MPI programs that rely on the matches-before order. • A Distributed Analyzer for MPI programs (DAMPI), which implements the two aforementioned protocols to provide scalable and modular dynamic verifi cation for MPI programs. • Scalability enhancement through algorithmic improvements for ISP, a dynamic verifi er for MPI programs

Runtime MPI Correctness Checking with a Scalable Tools Infrastructure

Increasing computational demand of simulations motivates the use of parallel computing systems. At the same time, this parallelism poses challenges to application developers. The Message Passing Interface (MPI) is a de-facto standard for distributed memory programming in high performance computing. However, its use also enables complex parallel programing errors such as races, communication errors, and deadlocks. Automatic tools can assist application developers in the detection and removal of such errors. This thesis considers tools that detect such errors during an application run and advances them towards a combination of both precise checks (neither false positives nor false negatives) and scalability. This includes novel hierarchical checks that provide scalability, as well as a formal basis for a distributed deadlock detection approach. At the same time, the development of parallel runtime tools is challenging and time consuming, especially if scalability and portability are key design goals. Current tool development projects often create similar tool components, while component reuse remains low. To provide a perspective towards more efficient tool development, which simplifies scalable implementations, component reuse, and tool integration, this thesis proposes an abstraction for a parallel tools infrastructure along with a prototype implementation. This abstraction overcomes the use of multiple interfaces for different types of tool functionality, which limit flexible component reuse. Thus, this thesis advances runtime error detection tools and uses their redesign and their increased scalability requirements to apply and evaluate a novel tool infrastructure abstraction. The new abstraction ultimately allows developers to focus on their tool functionality, rather than on developing or integrating common tool components. The use of such an abstraction in wide ranges of parallel runtime tool development projects could greatly increase component reuse. Thus, decreasing tool development time and cost. An application study with up to 16,384 application processes demonstrates the applicability of both the proposed runtime correctness concepts and of the proposed tools infrastructure

Doctor of Philosophy

dissertationMessage passing (MP) has gained a widespread adoption over the years, so much so, that even heterogeneous embedded multicore systems are running programs that are developed using message passing libraries. Such a phenomenon is a shift in computing practices, since, traditionally MP programs have been developed specifically for high performance computing. With growing importance and the complexity of MP programs in today's times, it becomes absolutely imperative to have formal tools and sound methodologies that can help reason about the correctness of the program. It has been demonstrated by many researchers in the area of concurrent program verification that a suitable strategy to verify programs which rely heavily on nondeterminism, is dynamic verification. Dynamic verification integrates the best features of testing and model checking. In the area of MP program verification, however, there have been only a handful of dynamic verifiers. These dynamic verifiers, despite their strengths, suffer from the explosion in execution scenarios. All existing dynamic verifiers, to our knowledge, exhaustively explore the nondeterministic choices in an MP program. It is apparent that an MP program with many nondeterministic constructs will quickly inundate such tools. This dissertation focuses on the problem of containing the exponential space of execution scenarios (or interleavings) while providing a soundness and completeness guarantee over safety properties of MP programs (specifically deadlocks). We present a predictive verification methodology and an associated framework, called MAAPED(Messaging Application Analysis with Predictive Error Discovery), that operates in polynomial time over MP programs to detect deadlocks among other safety property violations. In brief, we collect a single execution trace of an MP program and without re-running other execution schedules, reliably construct the artifacts necessary to predict any mishappening in an unexplored execution schedule with the aforementioned formal guarantee. The main contributions of the thesis are the following: The Functionally Irrelevant Barrier Algorithm to increase program productivity and ease in verification complexity. A sound pragmatic strategy to reduce the interleaving space of existing dynamic verifiers which is complete only for a certain class of MPI programs. A generalized matches-before ordering for MP programs. A predictive polynomial time verification framework as an alternate solution in the dynamic MP verification landscape. A soundness and completeness proof for the predictive framework's deadlock detection strategy for many formally characterized classes of MP programs. In the process of developing solutions that are mentioned above, we also collected important experiences relating to the development of dynamic verification schedulers. We present those experiences as a minor contribution of this thesis

The MPI BUGS INITIATIVE: a Framework for MPI Verification Tools Evaluation

International audienceEnsuring the correctness of MPI programs becomes as challenging and important as achieving the best performance. Many tools have been proposed in the literature to detect incorrect usages of MPI in a given program. However, the limited set of code samples each tool provides and the lack of metadata stating the intent of each test make it difficult to assess the strengths and limitations of these tools. In this paper, we present the MPI BUGS INITIATIVE, a complete collection of MPI codes to assess the status of MPI verification tools. We introduce a classification of MPI errors and provide correct and incorrect codes covering many MPI features and our categorization of errors. The resulting suite comprises 1,668 codes, each coming with a well-formatted header that clarifies the intent of each code and specifies how to execute and evaluate it. We evaluated the completeness of the MPI BUGS INITIATIVE against eight stateof-the-art MPI verification tools

Exploration efficace de l'espace d'état pour les programmes distribués asynchrones: Adaptation de l’UDPOR aux programes MPI.

Distributed message passing applications are in the mainstream of information technology since they exploit the power of parallel computer systems to produce higher performance. Designing distributed programs remains challenging because developers have to reason about concurrency, non-determinism, data distribution… that are main characteristics of distributed programs. Besides, it is virtually impossible to ensure the correctness of such programs via classical testing approaches since one may never successfully reach the execution that leads to unwanted behaviors in the programs. There is thus a need for more powerful verification techniques. Model-checking is one of the formal methods that allows to verify automatically and effectively some properties on models of computer systems by exploring all possible behaviors (states and transitions) of the system model. However, state spaces increase exponentially with the number of concurrent processes, leading to “state space explosion”.Unfolding-based Dynamic Partial Order Reduction (UDPOR) is a recent technique mixing Dynamic Partial Order Reduction (DPOR) with concepts of concurrency theory such as unfoldings to efficiently mitigate state space explosion in model-checking of concurrent programs. It is optimal in the sense that each Mazurkiewicz trace, i.e. a class of interleavings equivalent by commuting adjacent independent actions, is explored exactly once. And it is applicable to running programs, not only models of programs.The thesis aims at adapting UDPOR to verify asynchronous distributed programs (e.g. MPI programs) in the setting of the SIMGRID simulator of distributed applications. To do so, an abstract programming model of asynchronous distributed programs is defined and formalized in the TLA+ language, allowing to precisely define an independence relation, a main ingredient of the concurrency semantics. Then, the adaptation of UDPOR, involving the construction of an unfolding, is made efficient by a precise analysis of dependencies in the programming model, allowing efficient computations of usually costly operation. A prototype implementation of UDPOR adapted to distributed asynchronous programs has been developed, giving promising experimental results on a significant set of benchmarks.Distributed message passing applications are in the mainstream of information technology since they exploit the power of parallel computer systems to produce higher performance. Designing distributed programs remains challenging because developers have to reason about concurrency, non-determinism, data distribution… that are main characteristics of distributed programs. Besides, it is virtually impossible to ensure the correctness of such programs via classical testing approaches since one may never successfully reach the execution that leads to unwanted behaviors in the programs. There is thus a need for more powerful verification techniques. Model-checking is one of the formal methods that allows to verify automatically and effectively some properties on models of computer systems by exploring all possible behaviors (states and transitions) of the system model. However, state spaces increase exponentially with the number of concurrent processes, leading to “state space explosion”.Unfolding-based Dynamic Partial Order Reduction (UDPOR) is a recent technique mixing Dynamic Partial Order Reduction (DPOR) with concepts of concurrency theory such as unfoldings to efficiently mitigate state space explosion in model-checking of concurrent programs. It is optimal in the sense that each Mazurkiewicz trace, i.e. a class of interleavings equivalent by commuting adjacent independent actions, is explored exactly once. And it is applicable to running programs, not only models of programs.The thesis aims at adapting UDPOR to verify asynchronous distributed programs (e.g. MPI programs) in the setting of the SIMGRID simulator of distributed applications. To do so, an abstract programming model of asynchronous distributed programs is defined and formalized in the TLA+ language, allowing to precisely define an independence relation, a main ingredient of the concurrency semantics. Then, the adaptation of UDPOR, involving the construction of an unfolding, is made efficient by a precise analysis of dependencies in the programming model, allowing efficient computations of usually costly operation. A prototype implementation of UDPOR adapted to distributed asynchronous programs has been developed, giving promising experimental results on a significant set of benchmarks

Protocol based programming of concurrent systems

Tese de mestrado, Engenharia Informática (Engenharia de Software), Universidade de Lisboa, Faculdade de Ciências, 2014Desenvolver sistemas de software concorrentes (e paralelos) seguros é difícil. É muito mais difícil verificar software paralelo do que é fazer o mesmo para aplicações sequenciais. A Message Passing Interface (MPI) é uma especificação independente de linguagem para protocolos de comunicação, utilizada para programar computadores paralelos e baseada no paradigma de troca de mensagens, seguindo o paradigma Single Program Multiple Data (SMPD) em que um único pedaço de código é partilhado por todos os processos. Programas MPI apresentam uma séria de desafios de correção: o tipo de dados trocados na comunicação pode não corresponder, o que resulta em computações erradas, ou o programa pode entrar numa situação de impasse resultando em recursos desperdiçados. Este trabalho tem como objective melhorar o estado-da-arte da verificação de programas paralelos. O estado-da-arte na verificação de programas MPI utiliza técnicas de verificação de modelos que não escalam com o número de processos e são tipicamente feitas em tempo de execução, o que desperdiça recursos e está dependente da qualidade do conjunto de testes. A nossa abordagem é inspirada em tipos de sessão multi-participante (multi-party session types). A teoria dos tipos de sessão parte da caracterização da comunicação entre vários processos de um programa de um ponto de vista global (mensagem do processo 0 para o processo 1 corresponderia a envio para o processo 1 no processo 0 e recebo do processo 0 no processo 1 localmente). A esta caracterização dá-se o nome de protocolo. Protocolos bem formados são por construção livres de impasse e a comunicação é correcta (o tipo de dados enviado é o mesmo que o tipo de dados recebido). Se for provado que um programa segue um protocolo, então essas mesmas propriedades (ausência de impasses e correcção na comunicação) são preservadas para o programa. Primeiro, um protocolo é especificado numa linguagem desenhada para o efeito. As primitivas suportadas pela linguagem de protocolos são baseadas nas primitivas MPI, com a adição de escolhas e ciclos colectivos. Estas primitivas representam tomadas de decisão colectivas que não recorrerem a comunicação. Tomadas de decisão colectivas acontecem em programas SPMD porque todos os processos partilham o mesmo código, e como tal é possível garantir que todos os programas calculam o mesmo valor num certo ponto do programa se os dados forem iguais. Além disso, foi adicionada uma primitiva foreach, que expande um pedaço de protocolo para uma gama de valores. Esta primitiva permite que protocolos sejam paramétricos quanto ao número de processos. Os dados enviados nas mensagens podem ter restrições associadas, especificadas recorrendo a tipos dependentes. Os protocolos são escritos num plugin Eclipse. O plugin valida a boa formação dos protocolos com base numa teoria, utilizando o SMT solver Z3 da Microsoft Research para provar certas propriedades, e que as restrições nos tipos dependentes são congruentes. O plugin foi implementado recorrendo a Xtext, uma framework para desenvolvimentos de plugins Eclipse. O plugin, além de validar a boa formação, compila os protocolos para vários formatos, entre os quais o formato Why. Why é uma das linguagens da plataforma Why3, uma plataforma para verificação dedutiva de software. A linguagem Why é utilizada para escrever teorias, e é aliada à linguagem WhyML (inspirada em OCaml) para escrita de programas. Foi desenvolvida em Why uma teoria para protocolos, em que protocolos são especificados como um tipo de dados da linguagem. O ficheiro gerado pelo plugin especifica um protocolo utilizando os construtores deste tipo de dados Para especificar as restrições de tipos dependentes, uma teoria de funções anónimas incluída com a plataforma Why3 é utilizada. Além disso, foi desenvolvida uma biblioteca WhyML para programação paralela. Esta biblioteca inclui primitivas inspiradas em MPI, e primitivas para escolhas colectivas e ciclos colectivos. Estas primitivas têm como pré-condição que a cabeça do protocolo é a primitiva esperada, e que os dados a serem enviados respeitam a restrição do tipo de dados a ser enviado. Todas as primitivas têm como parâmetro o estado actual do protocolo, e na sua pós-condição consomem a primitiva à cabeça. Graças a estas anotações é possível saber se o programa segue o protocolo, confirmando no final do programa se o protocolo foi consumido por completo. Dado um programa paralelo escrito em WhyML, o protocolo em formato Why e a teoria de protocolos, o programador pode utilizar o Why3 IDE para verificar a conformidade do programa face ao protocolo. O Why3 IDE permite dividir a prova em partes, e provar cada parte com um SMT solver diferente. Caso nenhum SMT solver seja capaz de provar uma das sub-provas, o programador pode recorrer a um proof assistant e tratar da sub-prova manualmente. Além das anotações de primitivas colectivas, o programador também precisa de por um anotação no final de cada bloco que verifica se o protocolo está vazio naquele ponto (sem a qual não é possível garantir que o protocolo foi seguido), de marcar que partes do código correspondem a que expansão da primitiva foreach, e precisa de adicionar variantes e invariantes aos ciclos. Em resumo, a nossa abordagem é a seguinte: 1. O programador escreve um protocolo que explicita globalmente a comunicação que deve ocorrer.2. Este protocolo, se bem formado, é correcto por construção. A comunicação é correcta e é livre de impasses.3. A boa formação do protocolo é feita num plugin Eclipse, que também o compila para vários formatos, entre os quais o formato Why. 4. O programador escreve o seu programa paralelo em WhyML, recorrendo a uma biblioteca de programação paralela inspirada em MPI desenvolvida neste projecto. 5. As primitivas da biblioteca são anotadas com pré e pós-condições que verificam a conformidade do programa face ao protocolo. 6. Oprograma, aliado ao protocolo em formato Why e a uma teoria de protocolos, é verificado no Why3 IDE 7. O Why3 IDE permite dividir a prova em partes, e provar cada parte com um SMT solver diferente. No caso em que nenhum SMT solver consiga tratar da sub-prova, o programador pode recorrer a um proof assistant e tratar da sub-prova manualmente. 8. Se o programa passar na verificação, as propriedades do protocolo (correcção na comunicação e ausência de empasses) são garantidas para o programa. Estas anotações impõe trabalho extra ao programador, mas são dentro do esperado para este tipo de ferramenta. A nossa solução foi testada com recurso a três programas MPI, obtidos em livros de texto. Foram verificados vários exemplos clássicos de programação paralela, adaptados de livros de texto. Comparativamente à ferramenta mais próxima (que utiliza o verificador de programas C, VCC), o número de anotações da nossa solução é menor, as anotações enquadram-se melhor com o código e o tempo de verificação é semelhante. No entanto, a nossa solução recorre a uma linguagem que não é apropriada para a industria, a linguagem WhyML. As linguagens C ou Fortran aliadas à biblioteca MPI são o gold standard para programação paralela de alta performance, e são as linguagens com que os programadores no ramo estão familiarizados. Como tal, para trabalho futuro, propomos o desenvolvimento de uma linguagem de alto nível o mais semelhante possível a C ou Fortran, com primitivas de programação paralela built-in, incluindo escolhas colectivas e ciclos colectivos. Esta linguagem deverá compilar para código C ou Fortran, convertendo as primitivas da linguagem em primitivas MPI. Este passo de conversão pode também optimizar o programa, recorrendo a primitivas de comunicação MPI mais eficientes que as usadas, sendo esta uma funcionalidade importante para programação paralela de alta performance cuja principal preocupação é a eficiência do programa. Compilando também para WhyML, estes programas podem ser verificados. E como as primitivas de programação paralela são built-in na linguagem, a grande maioria das anotações necessárias pode ser gerada automaticamente. É também necessário suportar mais funcionalidades MPI, incluindo comunicação assíncrona, topologias e comunicadores.Developing safe, concurrent (and parallel) software systems is hard. It is much more difficult to debug or verify parallel software than it is to do the same for sequential applications. The Message Passing Interface (MPI) [12] is a languageindependent specification for communication protocols, used to program parallel computers and based on the message-passing paradigm. MPI programs present a number of correctness challenges: communication may not match, resulting in errant computations, or the program may deadlock resulting in wasted resources. This work hopes to improve the state-of-the-art of MPI program verification. The state-of-the-art in MPI program verification relies on model-checking techniques which do not scale with the number of processes and are typically done at runtime, which wastes resources and is dependent on the quality of the test set. Our approach is inspired by multi-party session types. First, a protocol is specified in a language designed for the purpose. A well-formed protocol is communication-safe and deadlock free. An Eclipse plugin verifies the well-formation of the protocol, and compiles it to Why, a language of a deductive software verification platform called Why3. This compiled protocol, allied with a theory for protocols also written in Why, is used to verify parallel WhyML programs, WhyML being another language of the Why3 platform. If a program passes verification, the properties of communication safety and deadlock freedom are preserved for the program. This verification occurs at compile time and is not dependent on any kind of test set, avoiding the issues of model-checking techniques. We verified several parallel programs from textbooks using our approach

Synthesis of correct-by-construction MPI programs

Tese de mestrado, Engenharia Informática (Engenharia de Software), Universidade de Lisboa, Faculdade de Ciências, 2014MPI (Message Passing Interface) é o padrão de programação concorrente mais usado em super-computadores. Devido à sua portabilidade, diversidade de funções e desenvolvimento constante, MPI é usado mundialmente em diversos campos de investigação, como na pesquisa de curas para o cancro, previsões metereológicas, investigação de fontes de energia alternativas e mais. Este tipo de programas contém trocas de mensagens complexas e operações colectivas que dificultam a sua implementação. Independentemente do talento ou cuidado do programador, é fácil introduzir erros que bloqueiam toda a execução do programa e a sua análise tornase igualmente complicada. Dada a complexidade e importância das áreas em que o MPI é usado, ferramentas que facilitem o desenvolvimento e análise deste tipo de programas são necessárias. Ferramentas actuais para análise de código MPI usam técnicas refinadas como a verificação de modelos ou execução simbólica. Na maioria dos casos estas soluções não acompanham a escalabilidade dos programas, sendo fiáveis até 1024 processos, pouco quando comparado com as aplicações MPI que correm em computadores com milhares de processadores. Os programadores de aplicações paralelas têm lidar com duas partes principais: a parte de computação e a parte de comunicação. Computação representa a parte lógica e aritmética do programa, enquanto que a coordenação refere-se à interação entre processos / participantes. A programação paralela inclui frequentemente programação de baixo nível. Mesmo primitivas MPI usadas para enviar mensagens contém um mínimo de seis parâmetros. Ao desenvolver aplicações paralelas complexas, lidar com funções de baixo nível pode ser um aborrecimento. Se de alguma forma fosse possível contornar esta questão, o desenvolvimento de aplicações paralelas seria muito mais fácil. Misturar computação com comunicação complica ainda mais esta tarefa, pelo que há uma necessidade de dividir as duas partes, tanto para fins de modificabilidade como de organização. Esqueletos de aplicações paralelas podem ser definidos de muitas maneiras, mas o conceito principal é que o esqueleto permite que os programadores tenham uma visão de topo da parte de comunicação do programa, dando-lhes uma estrutura correcta à partida, aliviando o seu trabalho. Assim sendo, o foco do desenvolvimento recai na parte de computação do programa. A ferramenta MPI Sessions, criada antes do ínicio desta tese mas na qual esta se insere, difere das restantes ferramentas de verificação MPI pela possibilidade de usar análise estática para verificar propriedades ligadas à concorrencia, possivelmente em tempo polinomial. A framework, criada antes do ínicio desta tese, baseia-se na teoria dos tipos de sessão multi-participante. A teoria dos tipos de sessão passa por caracterizar o padrão de comunicação entre vários processos de um programa e, verificando-se que os participantes seguem o protocolo de comunicação especificado, é garantido que certas propriedades como a ausencia de interbloqueio e coerencia de tipos são garantidas. O desafio encontrasse na forma de analisar se certo programa C+MPI obedece a um protocolo de comunicação especificado. Para este fim é usado o VCC, um verificador de programas C desenvolvido pela Microsoft Research. O processo de uso do MPI Sessions passa por primeiro especificar um protocolo de comunicação, numa linguagem desenvolvida para este fim, num plugin Eclipse que avalia automaticamente se o protocolo está bem formado. Se sim, o plugin traduz automaticamente o protocolo para um formato reconhecido pelo VCC. Para guiar o processo de validação são necessárias anotações no código fonte, nomeadamente nas funções MPI e operadores de controlo de fluxo. Estas anotações ajudam a identificar os campos das funções MPI que vão ser comparadas com o que está especificado no protocolo, a fim de identificar se a ordem de operações no código corresponde à que está no protocolo. No caso das funções MPI criou-se uma biblioteca especial que contém contractos para cada função. Esta biblioteca é incluida no ficheiro fonte pelo que apenas as anotações relacionadas com o controlo de fluxo têm de ser inseridas manualmente. Este tese estende as funcionalidades da ferramenta MPI Sessions, possibilitando a síntese de um esqueleto C+MPI fiel ao protocolo de comunicação especificado. Este esqueleto contém a parte de comunicação programa e dita o seu fluxo de execução. O esqueleto é composto por funções MPI e por chamadas a funções a ser definidas pelo utilizador, a parte de computação do programa. A ferramenta complementa automáticamente o código gerado com anotações VCC, permitindo a verificação da fidelidade do código ao protocolo - portanto, o programa contém uma prova que certifica a sua correcção. As funções de computação complementares são fornecidas pelo utilizador sob a forma de funções “callback”, usadas para definir os buffers de dados a serem transmitidos ou armazenados durante/após a comunicação, as condições envolvidas na implementação de ciclos e escolhas, e as funções de processamento de dados. Devido a uma especificação de protocolos aumentada, com marcas simples que identificam os pontos de funções “callback”, é possível ligar esqueleto ao código a ser definido pelo utilizador. A ferramenta consome estas marcas e gera um cabeçalho C com os protótipos necessários (assinaturas) para as funções “callback” que serão implementadas pelo utilizador. O código gerado e o definido pelo utilizador podem então ser compilados juntamente com a biblioteca MPI instalada no sistema para obter um executável. Em suma, a nossa abordagem tem as seguintes características principais: 1. Protocolos de comunicação apartir dos quais é feita a síntese automática de programas C+MPI. As etapas manuais do desenvolvimento do programa são apenas a definição do próprio protocolo, e a implementação de funções “callback” necessárias ao controle do fluxo de dados e as funções de processamento. 2. A correção do código sintetizado é certificada, também de forma automatizada, através das anotações de verificação que são copuladas com o esqueleto C+MPI. 3. A abordagem utiliza a infra-estrutura MPI Sessions já em existente para a especificação e verificação de protocolos MPI. Os aperfeiçoamentos compreendem a síntese “back-end” que se alimenta da estrutura de protocolos e o uso de marcas adicionais dentro do protocolo para definir funções “callback”. As nossa solução foi testada com recurso a sete programas MPI, obtidos em livros de texto e da “suite” de “benchmark” FEVS [2]. Através da especificação de protocolos de comunicação, baseados nesses programas, comparámos os tempos de execução dos programas síntetizados com os programas originais (a fim de verificarmos a qualidade dos programas gerados), o número de linhas de código geradas automáticamente, a diferença de linhas de código entre as duas versões (a fim de termos uma primeira noção se o esforço do utilizador é diminuído seguindo o nosso método). É também apresentada uma análise dos tempos de verificação para cada um dos exemplos e as anotações geradas automáticamente necessárias para essa verificação. Concluíndo, é definido o processo de síntese de código C+MPI funcional e correcto, com base em protocolos de comunicação aumentados para esse propósito e que seguem a teoria de tipos de sessão multi-participante. São explicadas as alterações feitas ao plugin para acomodar as mudanças necessárias para suportar a síntese de código, bem como outras funcionalidades adicionadas para facilitar o uso do plugin. É validado o nosso trabalho através de vários testes que avaliam tanto a parte funcional dos programas gerados (tempo de execução), bem como a vantagem da nossa solução face ao processo desenvolvimento normal - os programas gerados são correctos por construção. Na conclusão são propostas várias ideias para a continuidade do melhoramento não só da vertente de síntese da ferramenta, bem como do projecto como um todo. O resultado é uma ferramenta funcional e útil, disponibilizada publicamente na internet, incluindo exemplos prontos a usar e um manual práctico.Message Passing Interface (MPI) is the de facto standard for programming high performance parallel applications, with implementations that support hundreds of thousands of processing cores. MPI programs, written in C or Fortran, adhere to the Single Program Multiple Data (SPMD) paradigm, in which a single program specifies the behavior of the various processes, each working on different data, and that communicate through message-passing. Errors in MPI programs are easy to introduce, given the complexity in designing parallel programs and of MPI itself, plus the low-level and unchecked semantics of C and Fortran. One can easily write programs that cause processes to deadlock waiting for messages, or that exchange data of mismatched type or length. In the general case, it is impossible to certify that a program avoids these errors, or that it overall complies with an intended communication pattern. To deal with this general problem, we propose the synthesis of C+MPI programs from well-founded protocol specifications, based on the theory of multiparty session types. The idea is to depart from a high-level protocol specification that defines an intended communication pattern, and automatically synthesize a C+MPI code skeleton that is faithful to the source protocol specification. To define the functionality of a complete program, the skeleton needs only to be complemented by user-provided functions that do not employ any MPI calls, and merely implement the bindings for the skeleton’s control and data flow logic. The underlying multiparty session types’ theory ensures the preservation of key properties from protocol specification to synthesized code, such as deadlock freedom and type safety. For certification of the whole synthesis process, the C+MPI skeleton also includes annotations that are processed by a software verifier to mechanically verify compliance with the protocol. This thesis presents the design, implementation, and evaluation of the proposed approach, within a software framework called MPI Sessions