Generalizing abstractions in form-based visual programming languages : from direct manipulation to static representation

We believe concreteness, direct manipulation and responsiveness in a visual programming language increase its usefulness. However, these characteristics present a challenge in generalizing programs for reuse, especially when concrete examples are used as one way of achieving concreteness. In this thesis, we present a technique to solve this problem by deriving generality automatically through the analysis of logical relationships among concrete program entities from the perspective of a particular computational goal. Use of this technique allows a fully general form-based program with reusable abstractions to be derived from one that was specified in terms of concrete examples and direct manipulation. Also addressed in this thesis is how to statically represent the generalized programs. In general, we address how to design better static representations. A weakness of many interactive visual programming languages is their static representations. Lack of an adequate static representation places a heavy cognitive burden on a VPL's programmers, because they must remember potentially long dynamic sequences of screen displays in order to understand a previously-written program. However, although this problem is widely acknowledged, research on how to design better static representations for interactive VPLs is still in its infancy. Building upon the cognitive dimensions developed for programming languages by cognitive psychologists Green and others, we have developed a set of concrete benchmarks for VPL designers to use when designing new static representations. These benchmarks provide design-time information that can be used to improve a VPL's static representation

Dynamic task scheduling and binding for many-core systems through stream rewriting

This thesis proposes a novel model of computation, called stream rewriting, for the specification and implementation of highly concurrent applications. Basically, the active tasks of an application and their dependencies are encoded as a token stream, which is iteratively modified by a set of rewriting rules at runtime. In order to estimate the performance and scalability of stream rewriting, a large number of experiments have been evaluated on many-core systems and the task management has been implemented in software and hardware.In dieser Dissertation wurde Stream Rewriting als eine neue Methode entwickelt, um Anwendungen mit einer großen Anzahl von dynamischen Tasks zu beschreiben und effizient zur Laufzeit verwalten zu können. Dabei werden die aktiven Tasks in einem Datenstrom verpackt, der zur Laufzeit durch wiederholtes Suchen und Ersetzen umgeschrieben wird. Um die Performance und Skalierbarkeit zu bestimmen, wurde eine Vielzahl von Experimenten mit Many-Core-Systemen durchgeführt und die Verwaltung von Tasks über Stream Rewriting in Software und Hardware implementiert

Dynamically reconfigurable architecture for embedded computer vision systems

The objective of this research work is to design, develop and implement a new architecture which integrates on the same chip all the processing levels of a complete Computer Vision system, so that the execution is efficient without compromising the power consumption while keeping a reduced cost. For this purpose, an analysis and classification of different mathematical operations and algorithms commonly used in Computer Vision are carried out, as well as a in-depth review of the image processing capabilities of current-generation hardware devices. This permits to determine the requirements and the key aspects for an efficient architecture. A representative set of algorithms is employed as benchmark to evaluate the proposed architecture, which is implemented on an FPGA-based system-on-chip. Finally, the prototype is compared to other related approaches in order to determine its advantages and weaknesses

A computational framework for sound segregation in music signals

Tese de doutoramento. Engenharia Electrotécnica e de Computadores. Faculdade de Engenharia. Universidade do Porto. 200

Protecting applications using trusted execution environments

While cloud computing has been broadly adopted, companies that deal with sensitive data are still reluctant to do so due to privacy concerns or legal restrictions. Vulnerabilities in complex cloud infrastructures, resource sharing among tenants, and malicious insiders pose a real threat to the confidentiality and integrity of sensitive customer data. In recent years trusted execution environments (TEEs), hardware-enforced isolated regions that can protect code and data from the rest of the system, have become available as part of commodity CPUs. However, designing applications for the execution within TEEs requires careful consideration of the elevated threats that come with running in a fully untrusted environment. Interaction with the environment should be minimised, but some cooperation with the untrusted host is required, e.g. for disk and network I/O, via a host interface. Implementing this interface while maintaining the security of sensitive application code and data is a fundamental challenge. This thesis addresses this challenge and discusses how TEEs can be leveraged to secure existing applications efficiently and effectively in untrusted environments. We explore this in the context of three systems that deal with the protection of TEE applications and their host interfaces: SGX-LKL is a library operating system that can run full unmodified applications within TEEs with a minimal general-purpose host interface. By providing broad system support inside the TEE, the reliance on the untrusted host can be reduced to a minimal set of low-level operations that cannot be performed inside the enclave. SGX-LKL provides transparent protection of the host interface and for both disk and network I/O. Glamdring is a framework for the semi-automated partitioning of TEE applications into an untrusted and a trusted compartment. Based on source-level annotations, it uses either dynamic or static code analysis to identify sensitive parts of an application. Taking into account the objectives of a small TCB size and low host interface complexity, it defines an application-specific host interface and generates partitioned application code. EnclaveDB is a secure database using Intel SGX based on a partitioned in-memory database engine. The core of EnclaveDB is its logging and recovery protocol for transaction durability. For this, it relies on the database log managed and persisted by the untrusted database server. EnclaveDB protects against advanced host interface attacks and ensures the confidentiality, integrity, and freshness of sensitive data.Open Acces

A manifesto for future generation cloud computing: research directions for the next decade

The Cloud computing paradigm has revolutionised the computer science horizon during the past decade and has enabled the emergence of computing as the fifth utility. It has captured significant attention of academia, industries, and government bodies. Now, it has emerged as the backbone of modern economy by offering subscription-based services anytime, anywhere following a pay-as-you-go model. This has instigated (1) shorter establishment times for start-ups, (2) creation of scalable global enterprise applications, (3) better cost-to-value associativity for scientific and high performance computing applications, and (4) different invocation/execution models for pervasive and ubiquitous applications. The recent technological developments and paradigms such as serverless computing, software-defined networking, Internet of Things, and processing at network edge are creating new opportunities for Cloud computing. However, they are also posing several new challenges and creating the need for new approaches and research strategies, as well as the re-evaluation of the models that were developed to address issues such as scalability, elasticity, reliability, security, sustainability, and application models. The proposed manifesto addresses them by identifying the major open challenges in Cloud computing, emerging trends, and impact areas. It then offers research directions for the next decade, thus helping in the realisation of Future Generation Cloud Computing

Interactive High Performance Volume Rendering

This thesis is about Direct Volume Rendering on high performance computing systems. As direct rendering methods do not create a lower-dimensional geometric representation, the whole scientific dataset must be kept in memory. Thus, this family of algorithms has a tremendous resource demand. Direct Volume Rendering algorithms in general are well suited to be implemented for dedicated graphics hardware. Nevertheless, high performance computing systems often do not provide resources for hardware accelerated rendering, so that the visualization algorithm must be implemented for the available general-purpose hardware. Ever growing datasets that imply copying large amounts of data from the compute system to the workstation of the scientist, and the need to review intermediate simulation results, make porting Direct Volume Rendering to high performance computing systems highly relevant. The contribution of this thesis is twofold. As part of the first contribution, after devising a software architecture for general implementations of Direct Volume Rendering on highly parallel platforms, parallelization issues and implementation details for various modern architectures are discussed. The contribution results in a highly parallel implementation that tackles several platforms. The second contribution is concerned with the display phase of the “Distributed Volume Rendering Pipeline”. Rendering on a high performance computing system typically implies displaying the rendered result at a remote location. This thesis presents a remote rendering technique that is capable of hiding latency and can thus be used in an interactive environment

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