Determinism Should Ensure Deadlock-Freedom

The advent of multicore processors has made concurrent programming models mandatory. However, most concurrent programming models come with two major pitfalls: non-determinism and deadlocks. By determinism, we mean the output behavior of the program is independent of the scheduling choices (e.g., the operating system) and depends only on the input behavior. A few concurrent models provide deterministic behavior by providing constructs that impose additional synchronization, but improper or out-of-order use of these constructs leads to problems like deadlocks. In this paper, we argue for both determinism and deadlock-freedom. We propose a design of a deterministic, deadlock-free model. Any program that uses this model is guaranteed to produce the same output for a given input. Additionally, the program will never deadlock: the program will either terminate or run forever

Flexible plan execution using temporal planning and probabilistic models

Tese de mestrado integrado em Engenharia Física, Universidade de Lisboa, Faculdade de Ciências, 2020A inteligência sempre foi um dos fatores mais importantes para a espécie humana, daí nos termos chamado Homo Sapiens, que significa ”Homem sábio”. Desde a Antiguidade Grega que o Homem procura perceber o mundo à sua volta. Este desejo foi evoluindo durante séculos, até que o estudo da lógica matemática levou Alan Turing à Teoria de Computação, que sugere que uma máquina pode simular qualquer ato de dedução lógico através da manipulação de símbolos tão simples como ‘0’ e ‘1’. Esta ideia levou à cri ação de uma nova área científica, a Inteligência Artificial (IA), cujo propósito é criar programas capazes de demonstrar comportamento inteligente [42]. Um ramo específico da IA é o Planeamento, que trata a construção e execução de planos. Uma aplicação das tecnologias desenvolvidas em IA é a Robótica, que consiste no ramo de tecnologia responsável pelo desenho, construção, operação e aplicação de robôs, assim como de sistemas de controlo. Contudo, o Planeamento e a Robótica continuam a ser duas áreas científicas distintas, com os seus avanços distintos e conferências próprias. O objetivo desta tese consiste em estabelecer uma ponte entre o Planeamento e a Robótica, ao desenvolver um algoritmo inovador capaz de executar um plano temporal num ambiente perturbado, resistindo a mudanças inesperadas no meio ambiente e ao insucesso de ações. O algoritmo desenvolvido, denominado Olisipo, é uma evolução de um algoritmo desenvolvido previamente por Oscar Lima, Michael Cashmore, Daniele Magazzeni, Andrea Micheli e Rodrigo Ventura [33]. A versão original do algoritmo possuía uma fase offline e uma fase online. Este trabalho consistiu em melhorar a fase online, com a fase offline permanecendo inalterada. A fase offline usa um plano totalmente ordenado ∏tt, obtido a partir de um planeador já existente, e relaxa-o para obter um plano parcialmente ordenado ∏′ . Este plano parcialmente ordenado consiste em: uma rede com nós, correspondentes a todas as ações do plano totalmente ordenado inicial; e relações entre nós, nomeadamente temporais e de interferência. A fase online, que ocorre durante a execução do plano, consiste em utilizar uma procura Branch and Bound (B&B) [29] para construir, a partir de ∏′ , o plano totalmente ordenado com maior probabilidade de execução bem sucedida Γ, tendo em conta o estado atual. A procura B&B utiliza uma Rede de Bayes Dinâmica (RBD), construída iterativamente, para calcular a probabilidade de sucesso de um plano totalmente ordenado e podar a procura. Depois de encontrar Γ, a primeira ação desse plano é executada. Após a execução desta ação, o algoritmo Olisipo executa a última ação, de Γ, que seja compatível com o estado atual. Se nenhuma ação do plano for compatível com o estado atual, então um novo Γ é construído, utilizando ∏′ e o estado atual. Para testar e avaliar o algoritmo Olisipo, desenvolveu-se um ambiente virtual capaz de simular as perturbações do mundo real à execução de um plano. Com este propósito, o ambiente de simulação desenvolvido para o algoritmo original [33] foi extendido. Um código em Python foi desenvolvido para perturbar a Knowledge Base do ambiente virtual e, o código original escrito em C++, foi alterado para contabilizar a probabilidade de uma ação ser bem sucedida e a probabilidade dos efeitos de uma ação. As perturbações de factos no mundo e de ações ocorrem de forma aleatória, tendo em conta as probabilidades definidas pelo utilizador num ficheiro de texto. De seguida, estendeu-se o executor Esterel do ROSPlan [8] para servir como termo de comparação ao algoritmo Olisipo. Este simples executor executa um plano totalmente ordenado até a execução de uma ação falhar ou até uma ação deixar de ser aplicável. Quando isto acontece, o executor Esterel constrói um novo plano totalmente ordenado e tenta executá-lo. Este ciclo repete-se até o objetivo ser atingido ou até terem sido efetuados 10 replaneamentos, que foi definido como o número máximo de replaneamentos permitidos para ambos os algoritmos. Utilizou-se o planeador POPF [10] para construir o plano totalmente ordenado do executor Esterel, pois este também foi o planeador utilizado na fase offline do algoritmo Olisipo. Para comparar o algoritmo Olisipo e o executor Esterel, construiu-se um ambiente de simulação de um robô numa fábrica. Neste ambiente, o robô é responsável pela manuntenção de um conjunto de máquinas, de forma a evitar que alguma máquina se avarie e interrompa a produção. Cada máquina possui uma probabilidade diferente de se avariar e pode também receber uma manutenção aleatória não prevista, atualizando o seu estado. A ação de executar manutenção numa máquina, e de a máquina ser efetivamente mantida, tem também uma probabilidade de sucesso associada. A partir deste ambiente, dois domínios foram construídos, um domínio simples com apenas uma ação não-instanciada possível e outro com duas ações não-instanciadas possíveis. Para o domínio mais simples, foram construídos 10 problemas diferentes. Para o domínio mais complicado, foram construídos 8 problemas. As métricas escolhidas para avaliar o desempenho de cada algoritmo são: a probabilidade de uma execução bem sucedida; o número médio de replaneamentos em execuções bem sucedidas; o número médio de ações em execuções bem sucedidas e falhadas. A análise destas métricas foi feita a partir de 2000 tentativas de resolução de cada algoritmo em cada problema. Verificou-se que o algoritmo Olisipo supera o executor Esterel em todas as métricas. A partir dos resultados obtidos, é possível afirmar que o algoritmo Olisipo possui uma probabilidade de execução bem sucedida maior ou equivalente ao executor Esterel em todos os problemas testados, sendo que este aumento na probabilidade pode ir até aos 16%. Relativamente a replaneamentos em execuções bem sucedidas, o algoritmo Olisipo apresentou uma mediana de zero em todos os problemas, enquanto o executor Esterel apresentou uma mediana de até 2,2 replaneamentos. Relativamente ao número de ações executadas em execuções bem sucedidas, a mediana da distribuição correspondente ao algoritmo Olisipo foi sempre inferior à mediana correspondente à distribuição do executor Esterel. A melhoria relativa, apresentada pelo algoritmo Olisipo, no número de ações executadas em execuções bem sucedidas variou entre 10% e 52%. No caso de execuções falhadas, o algoritmo Olisipo também possuiu uma mediana inferior ao executor Esterel em todos os problemas, com uma melhoria relativa entre 39% e 58%. Com base nestes resultados, é possível concluir que o algoritmo Olisipo, relativamente a um simples executor como o Esterel, possui uma probabilidade de execução bem sucedida mais elevada, precisa de replanear menos vezes e executa menos ações, tanto em execuções bem sucedidas como falhadas. Estas vantagens do algoritmo Olisipo tornam-se particularmente interessantes em situações em que a execução de uma ação possui um custo ou resulta em consequências negativas. Considerando o exemplo utilizado anteriormente, de um robô que realiza manuntenção em máquinas numa fábrica, a execução de menos ações contribui para prolongar o tempo de trabalho do robô, uma vez que consumiria menos energia e precisaria de carregar as baterias com menos frequência. Esta vantagem é também útil em situações em que o robô não se encontre facilmente acessível ou em que não pode ser carregado facilmente. Por sua vez, o menor número de replaneamentos possibilita a utilização de um sistema computacional mais simples no robô, contribuindo também para a redução do seu consumo de energia. O código fonte do trabalho desenvolvido nesta tese é público 1 . Como o algoritmo Olisipo recebe apenas um plano totalmente ordenado e realiza uma execução de forma a maximizar a sua probabilidade de sucesso, é possível aplicar diretamente este algoritmo a outros planeadores, tornando a sua execução mais robusta. Relativamente ao trabalho futuro a desenvolver, uma possibilidade consiste em, durante a procura B&B, guardar outros planos totalmente ordenados, para além do plano que maximiza a probabilidade de sucesso. Isto pode ser útil pois as perturbações no ambiente podem, inesperadamente, tornar a execução de outro plano na execução com uma maior probabilidade de sucesso. Uma segunda possibilidade consiste em repetir a fase offline do Olisipo após um certo números de planos Γ serem consecutiva mente construídos ou após não ser possível construir um plano Γ. Uma terceira possibilidade consiste em guardar partes da árvore de procura e RBD, de forma a que, se for necessário procurar por um novo plano Γ e construir uma nova RBD, seja possível utilizar a árvore de procura e RBD anteriores para acelerar e facilitar as suas construções. Uma quarta possibilidade consiste em estudar o impacto da repetição da sub-fase PGen e verificar se podem haver outras soluções mais frutíferas. Uma quinta possibilidade consiste em otimizar o código desenvolvido, utilizando ferramentas como o Cython [3] para acelerar a sua execução. Por último, outra possibilidade consiste na implementação e teste do Olisipo num robô real, de forma a avaliar a sua praticabilidade e vantagens de forma mais concreta e relevante. Esta implementação consistiria num trabalho futuro bastante relevante.Planning is the branch of Artificial Intelligence which concerns the realisation of strategies or action sequences to be executed by intelligent agents. One of the assumptions considered in Classical Planning is the determinism of the world, meaning it is possible to predict with certainty the state resulting from the application of a certain action to another state. However, when the agent executing a plan is a robot interacting with the real world, then the agent is dealing with an uncertain and nondeterministic environment. In the real world, facts can unexpectedly change, actions are not instantaneous and their execution might fail. This makes the planning problem increasingly complex. This thesis aims to address the problem of executing a temporal plan in a perturbed environment. As a way to solve this problem, an algorithm capable of executing a temporal plan, while resisting unforeseen changes in the world, was developed and tested. The developed algorithm, named Olisipo, takes a probabilistic description of the world and aims to maximise the probability of a successful execution. In addition to this, the Olisipo algorithm acts as an add-on to external planners. The Olisipo algorithm is an improved version of the algorithm presented in [33]. This algorithm consists of an offline and an online phase. In the offline phase, a totally-ordered plan is relaxed and converted into a partially-ordered plan. In the online phase, Olisipo uses a Branch and Bound search to find the totally-ordered plan with the highest success probability. The success probability of a plan is calculated with a Dynamic Bayesian Network and a probabilistic description of the world. Afterwards, the algorithm tries to execute this plan while it is compatible with the state of the world, allowing for the skipping and repetition of actions, as well as for ignoring irrelevant facts in the world. If the plan stops being compatible with the state of the world, then a new totally-ordered plan is built. To test the performance of Olisipo, a simulation environment was created with 18 different problems. The Esterel dispatcher, from ROSPlan [8], was extended to act as a comparison term for the Olisipo algorithm. From the obtained results, it was shown that the Olisipo algorithm consistently had a higher probability of successfully solving a problem, performed fewer replans and also executed fewer actions, both for successful and failed executions. Hence, Olisipo offers a substantial improvement in performance for disturbed environments. Olisipo acts as an add-on to external planners and it has a public source code, so it can be implemented to improve the execution of any other planner

SP@CE - An SP-Based Programming Model for Consumer Electronics Streaming Applications

Abstract. Consumer Electronics (CE) devices are becoming the favorite target platforms for multimedia streaming applications, but finding the right solutions for efficient programming, both in terms of development time and application performance is not trivial. In this context, we presen

Dynamic expressivity with static optimization for streaming languages

Developers increasingly use streaming languages to write applications that process large volumes of data with high throughput. Unfortunately, when picking which streaming language to use, they face a difficult choice. On the one hand, dynamically scheduled languages allow developers to write a wider range of applications, but cannot take advantage of many crucial optimizations. On the other hand, statically scheduled languages are extremely performant, but have difficulty expressing many important streaming applications. This paper presents the design of a hybrid scheduler for stream processing languages. The compiler partitions the streaming application into coarse-grained subgraphs separated by dynamic rate boundaries. It then applies static optimizations to those subgraphs. We have implemented this scheduler as an extension to the StreamIt compiler. To evaluate its performance, we compare it to three scheduling techniques used by dynamic systems (OS thread, demand, and no-op) on a combination of micro-benchmarks and real-world inspired synthetic benchmarks. Our scheduler not only allows the previously static version of StreamIt to run dynamic rate applications, but it outperforms the three dynamic alternatives. This demonstrates that our scheduler strikes the right balance between expressivity and performance for stream processing languages.National Science Foundation (U.S.) (CCF-1162444

Skalabilna implementacija dekodera po normi MPEG korištenjem tokovnog programskog jezika

In this paper, we describe a scalable and portable parallelized implementation of a MPEG decoder using a streaming computation paradigm, tailored to new generations of multi--core systems. A novel, hybrid approach towards parallelization of both new and legacy applications is described, where only data--intensive and performance--critical parts are implemented in the streaming domain. An architecture--independent \u27StreamIt\u27 language is used for design, optimization and implementation of parallelized segments, while the developed \u27StreamGate\u27 interface provides a communication mechanism between the implementation domains. The proposed hybrid approach was employed in re--factoring of a reference MPEG video decoder implementation; identifying the most performance--critical segments and re-implementing them in \u27StreamIt\u27 language, with \u27StreamGate\u27 interface as a communication mechanism between the host and streaming kernel. We evaluated the scalability of the decoder with respect to the number of cores, video frame formats, sizes and decomposition. Decoder performance was examined in the presence of different processor load configurations and with respect to the number of simultaneously processed frames.U ovom radu opisujemo skalabilnu i prenosivu implementaciju dekodera po normi MPEG ostvarenu korištenjem paradigme tokovnog računarstva, prilagođenu novim generacijama višejezgrenih računala. Opisan je novi, hibridni pristup paralelizaciji novih ili postojećih aplikacija, gdje se samo podatkovno intenzivni i računski zahtjevni dijelovi implementiraju u tokovnoj domeni. Arhitekturno neovisni jezik StreamIt koristi se za oblikovanje, optimiranje i izvedbu paraleliziranih segmenata aplikacije, dok razvijeno sučelje \u27StreamGate\u27 omogućava komunikaciju između domena implementacije. Predloženi hibridni pristup razvoju paraleliziranih aplikacija iskorišten je u preoblikovanju referentnog dekodera video zapisa po normi MPEG; identificirani su računski zahtjevni segmenti aplikacije i ponovno implementirani u jeziku StreamIt, sa sučeljem \u27StreamGate\u27 kao poveznicom između slijedne i tokovne domene. Ispitivana su svojstva skalabilnosti s obzirom na ciljani broj jezgri, format video zapisa i veličinu okvira te dekompoziciju ulaznih podataka. Svojstva dekodera  su praćena u prisustvu različitih opterećenja ispitnog računala, i s obzirom na broj istovremeno obrađivanih okvira

Compilation de systèmes temps réel

I introduce and advocate for the concept of Real-Time Systems Compilation. By analogy with classical compilation, real-time systems compilation consists in the fully automatic construction of running, correct-by-construction implementations from functional and non-functional specifications of embedded control systems. Like in a classical compiler, the whole process must be fast (thus enabling a trial-and-error design style) and produce reasonably efficient code. This requires the use of fast heuristics, and the use of fine-grain platform and application models. Unlike a classical compiler, a real-time systems compiler must take into account non-functional properties of a system and ensure the respect of non-functional requirements (in addition to functional correctness). I also present Lopht, a real-time systems compiler for statically-scheduled real-time systems we built by combining techniques and concepts from real-time scheduling, compilation, and synchronous languages

Cache optimizations for stream programs

Thesis (M. Eng.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2005.Includes bibliographical references (leaves 73-75).As processor speeds continue to increase, the memory bottleneck remains a primary impediment to attaining performance. Effective use of the memory hierarchy can result in significant performance gains. This thesis focuses on a set of transformations that either reduce cache-miss rate or reduce the number of memory accesses for the class of streaming applications, which are becoming increasingly prevalent in embedded, desktop and high-performance processing. A fully automated optimization algorithm is presented that reduces the memory bottleneck for stream applications developed in the high-level stream programming language StreamIt. This thesis presents four memory optimizations: 1) cache aware fusion, which combines adjacent program components while respecting instruction and data cache constraints, 2) execution scaling, which judiciously repeats execution of program components to improve instruction and state locality, 3) scalar replacement, which converts certain data buffers into a sequence of scalar variables that can be register allocated, and 4) optimized buffer management, which reduces the overall number of memory accesses issued by the program. The cache aware fusion and execution scaling reduce the instruction and data cache-miss rates and are founded upon a simple and intuitive cache model that quantifies the temporal locality for a sequence of actor executions.(cont.) The scalar replacement and optimized buffer management reduce the number of memory accesses. An experimental evaluation of the memory optimizations is presented for three different architectures: StrongARM 1110, Pentium 3 and Itanium 2. Compared to unoptimized StreamIt code, the memory optimizations presented in this thesis yield a 257% speedup on the StrongARM, a 154% speedup on the Pentium 3, and a 152% speedup on Itanium 2. These numbers represent averages over our streaming benchmark suite. The most impressive speedups are demonstrated on an embedded processor StrongARM, which has only a single data and a single instruction cache, thus increasing the overall cost of memory operations and cache misses.by JÄnis. SermuliÅÅ¡.M.Eng