Formalization of Phase Ordering

Phasers pose an interesting synchronization mechanism that generalizes many collective synchronization patterns seen in parallel programming languages, including barriers, clocks, and point-to-point synchronization using latches or semaphores. This work characterizes scheduling constraints on phaser operations, by relating the execution state of two tasks that operate on the same phaser. We propose a formalization of Habanero phasers, May-Happen-In-Parallel, and Happens-Before relations for phaser operations, and show that these relations conform with the semantics. Our formalization and proofs are fully mechanized using the Coq proof assistant, and are available online.Comment: In Proceedings PLACES 2016, arXiv:1606.0540

Types for X10 Clocks

X10 is a modern language built from the ground up to handle future parallel systems, from multicore machines to cluster configurations. We take a closer look at a pair of synchronisation mechanisms: finish and clocks. The former waits for the termination of parallel computations, the latter allow multiple concurrent activities to wait for each other at certain points in time. In order to better understand these concepts we study a type system for a stripped down version of X10. The main result assures that well typed programs do not run into the errors identified in the X10 language reference, namely the ClockUseException. The study will open, we hope, doors to a more flexible utilisation of clocks in the X10 language.Comment: In Proceedings PLACES 2010, arXiv:1110.385

Programming multicores safely : handling barrier deadlocks

Tese de doutoramento, Informática (Ciências da Computação), Universidade de Lisboa, Faculdade de Ciências, 2015Nowadays, most produced computing devices include multicore processors. Applications that run on these devices only scale if they can compute in parallel. To this end, mainstream programming languages, like Java and C♯, adopted various parallel programming techniqffes. his thesis focffses on a parallel technique, called barrier, used for synchronisation. A barrier coordinates the execution order of parallel activities, by letting them wait for each other. Tasks using barriers are susceptible to the problem of deadlocks, where at least two activities are (indirectly) in a stalemate because of a conflicting ordering of some barriers. Deadlocks are a class of concurrency failures with a big impact in parallel programs. To help make parallel programming more productive, we propose two complementary techniques that handle deadlocks caused by barriers: a runtime verification tool, and a deadlock-free programming model. We present Armus, a runtime verification tool specialised in barrier deadlocks that is distributed, fault-tolerant, and verifies X10 and Java programs. Our technique verifies more barrier synchronisation patterns than existing state-of-the-art techniques. We improve deadlock verification based on graph analysis: our technique selects from two alternative graph representations of concurrency dependencies to hasten deadlock checking. Armus is evaluated with three benchmark suites in local and distributed scenarios. To handle barrier deadlocks at design time we propose a language called SBrenner that extends and formalises a programming model that originates from the Habanero-Java and the X10 languages. The outcome is a deadlock-free programming model that leverages pipeline parallelism. We present an operational semantics and a type system for SBrenner. Offr type system enjoys the properties of progress and subject reduction.Actualmente, a generalidade dos dispositivos de computação inclui um processador multicore. As aplicações que correm em processadores muIticore só aumentam o seu desempenho se computarem em paralelo, aproveitando assim o poder computacional dos núcleos disponíveis. Para este efeito, as linguagens de programação mais populares, tal como Java e C♯, adoptaram, nos últimos anos, várias técnicas de programação paralela. Esta tese lida com uma classe de falhas que origina da utilização de uma técnica de programação paralela, chamada barreira, cuja funcionalidade é a de sincronizar grupos de tarefas. Uma barreira coordena a ordem de execução de um grupo de tarefas, disponibilizando um ponto de execução em que as várias tarefas dum grupo podem esperar umas pelas outras. As tarefas que usam barreiras são vulneráveis ao problema de impasse, em que pelo menos duas tarefas estão (indirectamente) à espera uma da outra em barreiras diferentes sem que qualquer uma das tarefas possa avançar. Os impasses constituem uma classe de falhas, da área de concorrência, com grande impacto em programas paralelos. O nosso objectivo é aumentar a produtividade da programação paralela tratando do problema de impasses em barreiras. Nesta tese propomos duas técnicas complementares para lidar com o problema de impasses: uma ferramenta de verificação especializada em impasses sobre barreiras que é distribuída, tolerante a falhas e verifica aplicações X10 e Java; um modelo de programação isento de impasses

Compiling the π - calculus into a multithreaded typed assembly language

Tese de mestrado, Informática, Universidade de Lisboa, Faculdade de Ciências, 2009Restrições físicas e eléctricas limitam o aumento da velocidade do relógio dos processadores, pelo que não se espera que o poder computacional por unidade de processamento aumente muito num futuro próximo. Em vez disso, os fabricantes estão a aumentar o número de unidades de processamento (cores) por processador para continuarem a criar produtos com aumentos de performance. A indústria fez grandes investimentos em projectos como o RAMP e BEE2 que permitem a emulação de arquitecturas multi-core, mostrando interesse em suportar as fundações para a investigação de software que se destina a essas arquitecturas. Para tirar vantagem de arquitecturas multi-core, tem de se dominar tanto a programação concorrente como a paralela. Com a grande disponibilidade de sistemas paralelos que vai desde sistemas embebidos até a super computadores, acreditamos que os programadores têm de fazer uma mudança de paradigma passando da programação sequencial para a programação paralela e produzir software adaptado, de raiz, a plataformas multi-core. O multithreading é uma escolha bem conhecida e usada pela indústria para desenvolver sistemas explicitamente paralelos. Os locks são um mecanismo utilizado para sincronizar programas multithreaded de uma forma altamente eficiente. Porém, é comum surgirem problemas relacionados com concorrência como deter um lock tempo demais, não compreender quando se usam locks leitores/escritores ou escolher um mecanismo de sincronização desadequado. Estes problemas podem ser mitigados com recurso a abstracções de concorrência. Os tipos e as regras de tipos são formas simples e eficazes de garantir segurança. Os tipos não são só usados por sistemas de tipos para garantir que programas não têm erros de execução, mas servem também como especificações (verificáveis de uma forma automática). A informação dada pelos tipos é expressiva o suficiente para representar propriedades operacionais importantes, como segurança de memória. Os compiladores que preservam tipos perduram a informação dada pelos tipos por todos os passos de compilação, permitindo uma compilação mais segura e que preserva a semântica (representada pelos tipos). Propomos um compilador que endereça os problemas que levantámos até agora:-uma linguagem fonte com abstracções para concorrência e para o paralelismo;-um compilador que se destine a uma arquitectura multi-core;-uma tradução que preserve a informação dada pelos tipos. Em relação à linguagem fonte, os cálculos de processos evidenciam-se como um bom modelo de programação para a computação concorrente. O cálculo π em particular, tem uma semântica bem compreendida, consiste num conjunto pequeno de operadores em que a comunicação é o passo fundamental de computação. Os cálculos de processos oferecem esquemas de compilação natural que expõe o paralelismo ao nível dos threads. Por estas razões, escolhemos o cálculo π simplesmente tipificado como linguagem fonte. Vasconcelos e Martins propõem o MIL como uma linguagem assembly tipificada para arquitecturas multithreaded, um modelo que assenta numa máquina abstracta multi-core com memória principal partilhada. Esta linguagem fortemente tipificada oferece as seguintes propriedades de segurança: de memória, de controlo de fluxo e de liberdade de race conditions. O MIL contradiz a ideia que considera a associação entre a memória e locks uma convenção, ao torná-la explícita na linguagem. O sistema de tipos faz cumprir uma política de utilização de lock que inclui: proibir apanhar um lock em posse (fechado), proibir libertar um lock que não está em posse e faz com que os threads não se esqueçam de libertar todos os locks no final da sua execução. Propomos uma tradução que preserva os tipos do cálculo π para o MIL. O cálculo π é uma álgebra de processos para descrever mobilidade: uma rede de processos interligados computa comunicando ligações (ou referências a outros processos). No cálculo π, a comunicação reconfigura dinamicamente a rede, fazendo com que os processos passem a estar visíveis a diferentes nós quando o sistema evolui. Ao traduzirmos o cálculo π em MIL, partimos de uma linguagem onde os processos comunicam através de passagem de mensagens e chegamos a uma linguagem onde threads comunicam por memória partilhada. O processo de compilação não é directo nem trivial: certas abstracções, como canais, não têm uma representação complementar no MIL. Para ajudar a tradução, desenvolvemos, na linguagem de destino, uma biblioteca de tampões não limitados e polimórficos que são usados como canais. Estes tampões não limitados são monitores de Hoare, daí introduzirem uma forma de sincronização aos threads que estejam a aceder o tampão, e que encapsulam a manipulação directa de locks. A disciplina de locks do MIL permite representar explicitamente a noção da transferência ininterrupta da região crítica dos monitores — vai do thread que assinala a condição, e que termina, para o thread que está à espera nessa mesma condição, e que é activado. Os tampões não limitados são uma boa forma de representar canais, o que por sua vez simplifica a tradução, já que enviar uma mensagem corresponde a colocar um elemento no tampão, e que receber uma mensagem equivale a retirar um elemento do tampão. Impomos uma ordem FIFO no tampão, para assegurarmos que as mensagens enviadas têm a oportunidade de serem alguma vez recebidas. A função de tradução que definimos é uma especificação formal do compilador. A tradução do cálculo π para MIL comporta a tradução de tipos, de valores e de processos. Os compiladores que preservam os tipos dão garantias em termos de segurança (os programas gerados não vão correr mal) e também em termos de correcção parcial (as propriedades semânticas dadas pelos tipos perduram no programa gerado). O nosso resultado principal é, portanto, uma tradução que preserva os tipos: o compilador gera programas MIL correctos ao nível dos tipos para processos π fechados e bem tipificados. Outra preocupação da nossa função de tradução é que o programa gerado tente manter o nível de concorrência do programa fonte, o que inclui a criação dinâmica de threads e a sincronização entre threads. As contribuições deste trabalho são:-um algoritmo de compilação que preserva os tipos, mostrando a flexibilidade do MIL num ambiente tipificado e race-free.-Exemplos de programação e estruturas de dados feitos em MIL. Mostramos a implementação de tampões polimórficos não limitados sob a forma de monitores, de variáveis de condição genéricas (primitivas dos monitores) e de filas polimórficas. Também descrevemos como codificar monitores na linguagem MIL.-Ferramentas. Criámos um protótipo para o compilador de π para MIL, o que consiste em: o analisador sintáctico, o analisador semântico (estático) e o gerador de código. Refinámos o protótipo do MIL: adicionámos suporte para tipos universais e existenciais, locks de leitores/escritores, locks lineares e tuplos locais. Criámos uma applet Java que mostra de uma forma rápida e intuitiva o nosso trabalho sem ser necessário qualquer instalação (desde que o navegador web suporte applets de Java): podemos gerar código MIL a partir de código π, alterar o código MIL gerado e executá-lo. Os nossos protótipos estão disponíveis on-line, em http://gloss.di.fc.ul.pt/mil/: a applet Java, o código fonte e exemplos π e MIL.Physical and electrical constrains are compelling manufactures to augment the number of cores in each die to continue delivering performance gains. To take advantage of the emerging multicore architectures, we need to master parallel and concurrent programming. We encourage empowering languages with adequate concurrency primitives: finegrained for low-level languages and coarse grained for high-level languages. This way, compilers can reuse fined-grained primitives to encode multiple coarse-grained primitives. Work in type-directed compilers (e.g., the Typed Intermediate Language for the ML language) showed that using a strongly typed intermediate language increases not only safety but also efficiency. Typed assembly languages (TAL) draw the benefits from having type information from end-to-end, originating type-preserving compilers. Vasconcelos and Martins proposed the Multithreaded Intermediate Language (MIL) as a typed assembly language for multithreaded architectures, featuring an abstract multicore machine with shared memory that is equipped with locks. We propose a type-preserving translation from a simply typed π-calculus into MIL. Process calculi provide natural compilation schemes that expose thread-level parallelism, present in the target architecture. By translating the π-calculus into MIL, we depart from a language where processes communicate through message-passing and arrive in a language where threads communicate through shared memory. Our contributions consist of-a translation function that generates MIL from the π-calculus;-the translation is type-preserving;-using an unbounded buffer monitor to encode channels;-detailed examples in MIL (handling concurrency primitives and control-flow);-implementations in MIL of condition variables, of polymorphic queues, and of na unbounded buffer;-a generic encoding of monitors in MIL

Dynamic Determinacy Race Detection for Task-Parallel Programs with Promises

Much of the past work on dynamic data-race and determinacy-race detection algorithms for task parallelism has focused on structured parallelism with fork-join constructs and, more recently, with future constructs. This paper addresses the problem of dynamic detection of data-races and determinacy-races in task-parallel programs with promises, which are more general than fork-join constructs and futures. The motivation for our work is twofold. First, promises have now become a mainstream synchronization construct, with their inclusion in multiple languages, including C++, JavaScript, and Java. Second, past work on dynamic data-race and determinacy-race detection for task-parallel programs does not apply to programs with promises, thereby identifying a vital need for this work. This paper makes multiple contributions. First, we introduce a featherweight programming language that captures the semantics of task-parallel programs with promises and provides a basis for formally defining determinacy using our semantics. This definition subsumes functional determinacy (same output for same input) and structural determinacy (same computation graph for same input). The main theoretical result shows that the absence of data races is sufficient to guarantee determinacy with both properties. We are unaware of any prior work that established this result for task-parallel programs with promises. Next, we introduce a new Dynamic Race Detector for Promises that we call DRDP. DRDP is the first known race detection algorithm that executes a task-parallel program sequentially without requiring the serial-projection property; this is a critical requirement since programs with promises do not satisfy the serial-projection property in general. Finally, the paper includes experimental results obtained from an implementation of DRDP. The results show that, with some important optimizations introduced in our work, the space and time overheads of DRDP are comparable to those of more restrictive race detection algorithms from past work. To the best of our knowledge, DRDP is the first determinacy race detector for task-parallel programs with promises

Compiling the π\pi-calculus into a Multithreaded Typed Assembly Language

Current trends in hardware made available multi-core CPU systems to ordinary users, challenging researchers to devise new techniques to bring software into the multi-core world. However, shaping software for multi-cores is more envolving than simply balancing workload among cores. In a near future (in less than a decade) Intel prepares to manufacture and ship 80-core processors; programmers must perform a paradigm shift from sequential to concurrent programming and produce software adapted for multi-core platforms. In the last decade, proposals have been made to compile formal concurrent and functional languages, notably the $\pi$-calculus, typed concurrent objects, and the $\lambda$-calculus, into assembly languages. The last work goes a step further and presents a series of type-preserving compilation steps leading from System F to a typed assembly language. Nevertheless, all theses works are targeted at sequential architectures. This paper proposes a type-preserving translation from the $\pi$-calculus into MIL, a multithreaded typed assembly language for multi-core/multi-processor architectures. We start from a simple asynchronous typed version of the $\pi$-calculus and translate it into MIL code that is then linked to a run-time library (written in MIL) that provides support for implementation of the $\pi$-calculus primitives (e.g., queuing messages and processes). In short, we implement a message-passing paradigm in a shared memory architectur

Type Inference for Deadlock Detection in a Multithreaded Polymorphic Typed Assembly Language

We previously developed a polymorphic type system and a type checker for a multithreaded lock-based polymorphic typed assembly language (MIL) that ensures that well-typed programs do not encounter race conditions. This paper extends such work by taking into consideration deadlocks. The extended type system verifies that locks are acquired in the proper order. Towards this end we require a language with annotations that specify the locking order. Rather than asking the programmer (or the compiler's backend) to specifically annotate each newly introduced lock, we present an algorithm to infer the annotations. The result is a type checker whose input language is non-decorated as before, but that further checks that programs are exempt from deadlocks

COMPILING THE pi-CALCULUS INTO A MULTITHREADED TYPED ASSEMBLY LANGUAGE

Restrições físicas e eléctricas limitam o aumento da velocidade do relógio dos processadores, pelo que não se espera que o poder computacional por unidade de processamento aumente muito num futuro próximo. Em vez disso, os fabricantes estão a aumentar o número de unidades de processamento (\texto {cores}) por processador para continuarem a criar produtos com aumentos de performance. A indústria fez grandes investimentos em projectos como o RAMP e BEE2 que permitem a emulação de arquitecturas multi-core, mostrando interesse em suportar as fundações para a investigação de \ texto {software} que se destina a essas arquitecturas. Para tirar vantagem de arquitecturas multi-core, tem de se dominar tanto a programação concorrente como a paralela. Com a grande disponibilidade de sistemas paralelos que vai desde sistemas embebidos até a super computadores, acreditamos que os programadores têm de fazer uma mudança de paradigma passando da programação sequencial para a programação paralela e produzir \texto{software} adaptado, de raiz, a plataformas multi-core. O \texto{multithreading} é uma escolha bem conhecida e usada pela indústria para desenvolver sistemas explicitamente paralelos. Os \ texto {locks} são um mecanismo utilizado para sincronizar programas texto {multithreaded} de uma forma altamente eficiente. Porém, é comum surgirem problemas relacionados com concorrência como deter um \ texto {lock} tempo demais, não compreender quando se usam \t texto {locks} leitores/escritores ou escolher um mecanismo de sincronização desadequado. Estes problemas podem ser mitigados com recurso a abstracções de concorrência. Os tipos e as regras de tipos são formas simples e eficazes de garantir segurança. Os tipos não são só usados por sistemas de tipos para garantir que programas não têm erros de execução, mas servem também como especificações (verificáveis de uma forma automática). A informação dada pelos tipos é expressiva o suficiente para representar propriedades operacionais importantes, como segurança de memória. Os compiladores que \emph{preservam tipos} perduram a informação dada pelos tipos por todos os passos de compilação, permitindo uma compilação mais segura e que preserva a semântica (representada pelos tipos). Propomos um compilador que endereça os problemas que levantámos até agora: * uma linguagem fonte com abstracções para concorrência e para o paralelismo; * um compilador que se destine a uma arquitectura multi-core; * uma tradução que preserve a informação dada pelos tipos. Em relação à linguagem fonte, os cálculos de processos evidenciam-se como um bom modelo de programação para a computação concorrente. O cálculo pi, em particular, tem uma semântica bem compreendida, consiste num conjunto pequeno de operadores em que a comunicação é o passo fundamental de computação. Os cálculos de processos oferecem esquemas de compilação natural que expõe o paralelismo ao nível dos \ texto {threads}. Por estas razões, escolhemos o cálculo pi simplesmente tipificado como linguagem fonte. Vasconcelos e Martins propõem o MIL como uma linguagem\ texto {assembly} tipificada para arquitecturas\ texto {multithreaded}, um modelo que assenta numa máquina abstracta multi-core com memória principal partilhada. Esta linguagem fortemente tipificada oferece as seguintes propriedades de segurança: de memória, de controlo de fluxo e de liberdade de\ texto {race conditions}. O MIL contradiz a ideia que considera a associação entre a memória e\textit{locks} uma convenção, ao torná-la explícita na linguagem. O sistema de tipos faz cumprir uma política de utilização de\ texto {lock} que inclui: proibir apanhar um \ texto {lock} em posse (fechado), proibir libertar um \ texto {lock} que não está em posse e faz com que os \ texto {threads} não se esqueçam de libertar todos os \ texto {locks} no final da sua execução. Propomos uma tradução que preserva os tipos do cálculo pi para o MIL. O cálculo pi é uma álgebra de processos para descrever \emph{mobilidade}: uma rede de processos interligados computa comunicando ligações (ou referências a outros processos). No cálculo pi, a comunicação reconfigura dinamicamente a rede, fazendo com que os processos passem a estar visíveis a diferentes nós quando o sistema evolui. Ao traduzirmos o cálculo pi em MIL, partimos de uma linguagem onde os processos comunicam através de passagem de mensagens e chegamos a uma linguagem onde \ texto {threads} comunicam por memória partilhada. O processo de compilação não é directo nem trivial: certas abstracções, como canais, não têm uma representação complementar no MIL. Para ajudar a tradução, desenvolvemos, na linguagem de destino, uma biblioteca de tampões não limitados e polimórficos que são usados como canais. Estes tampões não limitados são monitores de Hoare, daí introduzirem uma forma de sincronização aos \ texto {threads} que estejam a aceder o tampão, e que encapsulam a manipulação directa de \ texto {locks}. A disciplina de \ texto {locks} do MIL permite representar explicitamente a noção da transferência ininterrupta da região crítica dos monitores---vai do \ texto {thread} que assinala a condição, e que termina, para o \ texto {thread} que está à espera nessa mesma condição, e que é activado. Os tampões não limitados são uma boa forma de representar canais, o que por sua vez simplifica a tradução, já que enviar uma mensagem corresponde a colocar um elemento no tampão, e que receber uma mensagem equivale a retirar um elemento do tampão. Impomos uma ordem FIFO no tampão, para assegurarmos que as mensagens enviadas têm a oportunidade de serem alguma vez recebidas. A função de tradução que definimos é uma especificação formal do compilador. A tradução do cálculo pi para MIL comporta a tradução de tipos, de valores e de processos. Os compiladores que preservam os tipos dão garantias em termos de segurança (os programas gerados não vão correr mal) e também em termos de correcção parcial (as propriedades semânticas dadas pelos tipos perduram no programa gerado). O nosso resultado principal é, portanto, uma tradução que preserva os tipos: o compilador gera programas MIL correctos ao nível dos tipos para processos pi fechados e bem tipificados. Outra preocupação da nossa função de tradução é que o programa gerado tente manter o nível de concorrência do programa fonte, o que inclui a criação dinâmica de \ texto {threads} e a sincronização entre \texto{threads}. As contribuições deste trabalho são: * Um algoritmo de compilação que preserva os tipos, mostrando a flexibilidade do MIL num ambiente tipificado e \ texto {race-free}. * Exemplos de programação e estruturas de dados feitos em MIL. Mostramos a im\-ple\-men\-ta\-ção de tampões polimórficos não limitados sob a forma de monitores, de variáveis de condição genéricas (primitivas dos monitores) e de filas polimórficas. Também descrevemos como codificar monitores na linguagem MIL. * Ferramentas. Criámos um protótipo para o compilador de $\pi$ para MIL, o que consiste em: o analisador sintáctico, o analisador semântico (estático) e o gerador de código. Refinámos o protótipo do MIL: adicionámos suporte para tipos universais e existenciais, \ texto {locks} de leitores/escritores, locks lineares e tuplos locais. Criámos uma \ texto {applet} Java que mostra de uma forma rápida e intuitiva o nosso trabalho sem ser necessário qualquer instalação (desde que o navegador \ texto {web} suporte \ texto {applets} de Java): podemos gerar código MIL a partir de código $\pi$, alterar o código MIL gerado e executá-lo. Os nossos protótipos estão disponíveis \ texto {on-line}, em http://gloss.di.fc.ul.pt/mil/: a \ texto {applet} Java, o código fonte e exemplos $\pi$ e MIL

Compiling the π-calculus into a Multithreaded Typed Assembly Language

Introduction. Current trends in hardware made available multi-core CPU systems to ordinary users, challenging researchers to devise new techniques to bring software into the multi-core world. However, shaping software for multicores is more envolving than simply balancing workload among cores. In a near future (in less than a decade) Intel prepares to manufacture and ship 80-cor