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 π - 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

A Type System for Unstructured Locking that Guarantees Deadlock Freedom without Imposing a Lock Ordering

Deadlocks occur in concurrent programs as a consequence of cyclic resource acquisition between threads. In this paper we present a novel type system that guarantees deadlock freedom for a language with references, unstructured locking primitives, and locks which are implicitly associated with references. The proposed type system does not impose a strict lock acquisition order and thus increases programming language expressiveness.Comment: In Proceedings PLACES 2010, arXiv:1110.385

PLACES'10: The 3rd Workshop on Programmng Language Approaches to concurrency and Communication-Centric Software

Paphos, Cyprus. March 201

Foundations of Session Types and Behavioural Contracts

International audienceBehavioural type systems, usually associated to concurrent or distributed computations, encompass concepts such as interfaces, communication protocols, and contracts, in addition to the traditional input/output operations. The behavioural type of a software component specifies its expected patterns of interaction using expressive type languages, so that types can be used to determine automatically whether the component interacts correctly with other components. Two related important notions of behavioural types are those of session types and behavioural contracts. This paper surveys the main accomplishments of the last twenty years within these two approaches

A framework for deadlock detection in core ABS

We present a framework for statically detecting deadlocks in a concurrent object-oriented language with asynchronous method calls and cooperative scheduling of method activations. Since this language features recursion and dynamic resource creation, deadlock detection is extremely complex and state-of-the-art solutions either give imprecise answers or do not scale. In order to augment precision and scalability we propose a modular framework that allows several techniques to be combined. The basic component of the framework is a front-end inference algorithm that extracts abstract behavioural descriptions of methods, called contracts, which retain resource dependency information. This component is integrated with a number of possible different back-ends that analyse contracts and derive deadlock information. As a proof-of-concept, we discuss two such back-ends: (i) an evaluator that computes a fixpoint semantics and (ii) an evaluator using abstract model checking.Comment: Software and Systems Modeling, Springer Verlag, 201

Foundations of session types and behavioural contracts

Behavioural type systems, usually associated to concurrent or distributed computations, encompass concepts such as interfaces, communication protocols, and contracts, in addition to the traditional input/output operations. The behavioural type of a software component specifies its expected patterns of interaction using expressive type languages, so types can be used to determine automatically whether the component interacts correctly with other components. Two related important notions of behavioural types are those of session types and behavioural contracts. This article surveys the main accomplishments of the last 20 years within these two approaches

A Machine-Checked, Type-Safe Model of Java Concurrency : Language, Virtual Machine, Memory Model, and Verified Compiler

The Java programming language provides safety and security guarantees such as type safety and its security architecture. They distinguish it from other mainstream programming languages like C and C++. In this work, we develop a machine-checked model of concurrent Java and the Java memory model and investigate the impact of concurrency on these guarantees. From the formal model, we automatically obtain an executable verified compiler to bytecode and a validated virtual machine

A lightweight deadlock analysis for programs with threads and reentrant locks

International audienceDeadlock analysis of multi-threaded programs with reentrant locks is complex because these programs may have infinitely many states. We define a simple calculus featuring recursion, threads and synchroniza-tions that guarantee exclusive access to objects. We detect deadlocks by associating an abstract model to programs-the extended lam model-and we define an algorithm for verifying that a problematic object dependency (e.g. a circularity) between threads will not be manifested. The analysis is lightweight because the deadlock detection problem is fully reduced to the corresponding one in lams (without using other models). The technique is intended to be an effective tool for the deadlock analysis of programming languages by defining ad-hoc extraction processes