Aplicações paralelas geralmente são executadas com o máximo número de threads de hardware disponíveis no sistema para maximizar o seu desempenho. Contudo, esta abordagem pode não ser a melhor escolha quando se busca eficiência energética e, em alguns casos, pode até mesmo degradar o desempenho. Desta maneira, o presente trabalho aplica a adaptação dinâmica do número de threads para otimizar o Energy-Delay Product (EDP) de aplicações paralelas OpenMP executadas em sistemas embarcados. Ao contrário de soluções anteriores, que focam em processadores de propósito geral (GPP, do inglês General Purpose Processors), o presente trabalho considera as características intrínsecas de sistemas embarcados, os quais geralmente possuem menos núcleos disponíveis, assim como apresentam diferenças significativas em relação à micro-arquitetura e à hierarquia de memória. Por meio de experimentos realizados em um sistema embarcado real com processador octa-core, este trabalho mostrou que a adaptação dinâmica do número de threads permite, em média, economizar 15,35% no consumo de energia com apenas 3,41% de perda de desempenho, gerando assim 12,47% de otimização de EDP em relação à configuração padrão (uso do máximo número de threads disponíveis no sistema). No melhor caso, a adaptação dinâmica foi capaz de economizar 26,97% em energia enquanto promoveu 25,74% de aumento no desempenho, resultando em 45,77% de melhora no EDP. / Parallel applications usually execute using the maximum number of threads allowed by the available hardware at hand to maximize performance. However, this approach may not be the best when it comes to energy efficiency and may even lead to performance decrease in some particular cases. In this way, the present work proposes a new apporach for the dynamic adaptation of the number of threads to optimize Energy-Delay Product (EDP) of OpenMP applications when running on Embedded Systems. Differently from previous solutions, which focus on General Purpose Processors (GPP), the current one takes into account the intrinsic characteristics of embedded systems, which usually have a lower number of cores and significantly different characteristics concerning the microarchitecture and memory hierarchy when compared to GPPs. Through experiments on a real embedded system with an octa-core processor, this work demonstrates that adapting the number of threads at runtime saves energy, on average, by 15,35% with only 3,41% loss performance, improving the EDP by 12,47% over the default configuration (maximum number of threads available in the system). In the best case, the dynamic adaptation saves 26,97 % in energy while promoting a 25,74 % increase in performance, resulting in a 45,77 % improvement in EDP.

A demanda por sistemas com elevado desempenho tem trazido a necessidade de aumentar o número de elementos de processamento, surgindo os chamados Sistemas em Chip Multiprocessados (MPSoCs). Além disso, com a possibilidade de redução da escala tecnológica na era submicrônica, permitindo a integração de vários dispositivos, os chips têm se tornado ainda mais complexos. No entanto, com o aumento no número de elementos de processamento, as interconexões são vistas com o principal gargalo dos sistemas-em-chip. Com isso, uma preocupação na forma como tais elementos se comunicam e estão interconectados tem sido levantada, uma vez que tais características são cruciais nos aspectos de desempenho, energia e potência, principalmente em sistemas embarcados. Essa necessidade permitiu o advento das redes-em-chip (Networks-on-Chip – NoCs) e inúmeros estudos já foram realizados para tais dispositivos. No entanto, devido ao aceleramento tecnológico atual, que traz a necessidade por sistemas ainda mais complexos, que consumam baixa energia e que permitam que as aplicações sejam constantemente atualizadas sem perder as características de desempenho, as arquiteturas de interconexão tradicionais não serão suficientes para satisfazer tais desafios. Outras alternativas de interconexão para MPSoCs precisam ser investigadas e nesse trabalho novas arquiteturas para NoCs com tais requisitos são apresentadas. As soluções propostas exploram hierarquia, adaptabilidade e interconexões em três dimensões. Esse trabalho aborda a necessidade do uso de diferentes estratégias em NoCs a fim de atingir os requisitos de desempenho e baixo consumo de potência dos atuais e futuros MPSoCs. Dessa forma, serão verificadas as diversas arquiteturas de interconexões para sistemas heterogêneos, sua escalabilidade, suas principais características e as vantagens das propostas apresentadas sobre as demais soluções. / The demand for systems with high performance has brought the need to increase the number of cores, emerging the called Multi-Processors System-on-Chip (MPSoCs). Also, with the shrinking feature size in deep-submicron era, allowing the integration of several devices, chips have become even more complex. However, with the increase in these elements, interconnections are seen as the main bottleneck in many core systemson- chip. With this, a concern about how these devices communicate and are interconnected has been raised, since these features are crucial for the performance, energy and power consumption aspects, mainly in embedded systems. This need allows the advent of the Networks-on-Chip (NoCs) and countless studies had already been done to analyze such interconnection devices. However, due to the current technological accelerating that brings the need for even more complex systems, consuming lower energy and providing constant application updates without losing performance features, traditional interconnect architectures will not be sufficient to satisfy such challenges. Other interconnecting alternatives for MPSoCs need to be investigated and in this work, novel architectures for NoCs meeting such requirements are presented. The proposed solutions explore hierarchy, adaptability and three dimensional interconnections. This work approaches the requirements in the use of different strategies for NoCs in order to reach the performance requisites and low power consumption of the current and future MPSoCs. Hence, in this approach, several interconnection architectures for heterogeneous systems, their scalability and the main features and advantages of the proposed strategies in comparison with others will be verified.

Nos sistemas computacionais atuais, enquanto é necessário explorar a disponibilidade de múltiplos núcleos, também é obrigatório consumir menos energia. Para acelerar o processo de desenvolvimento de aplicações paralelas e o tornar mais transparente ao programador, Interfaces de Programação Paralela (IPPs) são largamente utilizadas. Entretanto, cada IPP implementa diferentes formas para trocar dados usando regiões compartilhadas da memória. Estas regiões são, geralmente, mais distantes do processador do que regiões privadas da memória e, por consequência, possuem maior tempo de acesso e consumo de energia. Ademais, o sistema de memória dos processadores embarcados é diferente em hierarquia, tamanho, tempo de acesso, consumo de energia, etc., quando comparado aos processadores de propósito geral. Assim, considerando o cenário supracitado, com diferentes IPPs sendo utilizadas em sistemas multicore com diferentes requisitos, neste trabalho será mostrado que cada interface possui comportamento diferente em termos de desempenho, consumo de energia e Energy-Delay Product (EDP), e que este comportamento varia de acordo com a característica da aplicação e o processador utilizado (propósito geral ou embarcado). Por exemplo, Pthreads consome 8% menos energia que o melhor caso de OpenMP; 12% menos que MPI-1; e 8% menos que MPI-2, considerando todos os benchmarks no processador Intel Core i7 (propósito geral). Em contrapartida, no processador ARM Cortex-A9 (sistema embarcado), o melhor caso com OpenMP consumiu 2% menos energia que Pthreads; 6% menos que MPI-1; e 15% menos que MPI-2, para o mesmo conjunto de benchmarks. / In current computer systems, while it is necessary to exploit the availability of multiple cores, it is also mandatory to consume less energy. To accelerate the development of parallel applications and to make it more transparent to the programmer, Parallel APIs (Application Programming Interfaces) are widely used. However, each Parallel API implements different ways to exchange data using shared memory regions. These regions are generally more remote than the private ones, and therefore have greater access time and energy consumption. Furthermore, the memory system of embedded processors is different with regard to hierarchy, size, access time, energy consumption, etc., when compared to general purpose processors. Thus, considering the above scenario, with different Parallel APIs being used in multicore systems with different requirements, this work will show that each interface has different behavior in terms of performance, energy consumption and Energy-Delay Product (EDP), and that this behavior varies according to the characteristic of the application and the processor employed (general purpose or embedded). For example, as a result of this work, we have observed that Pthreads consumes 8% less energy than the best case of OpenMP; 12% less than MPI-1; and 8% less than MPI-2, considering all benchmarks on the Intel Core i7 (general purpose). In contrast, in the ARM Cortex-A9 processor (embedded system), the best case with OpenMP consumed 2% less energy than Pthreads; 6% less than MPI-1; and 15% less than MPI-2 for the same benchmarks set.

O mercado de sistemas embarcados tem demandado uma variada gama de aplicações, aplicações estas cada vez mais complexas. Para atender tal demanda, visto o declínio da lei de Moore e os processadores chegando ao seu limite de dissipação térmica, os projetistas são pressionados a desenvolverem novas organizações computacionais. Para manter a compatibilidade binária, de forma que a grande quantidade de aplicativos e ferramentas já desenvolvidas possa ser reutilizada, as empresas desenvolvem seus produtos focando em melhorias de um dado processador que irá executar a mesma ISA (Instruction Set Architecture). Essa necessidade de compatibilidade de código impõe muitas restrições à equipe de projeto, haja vista as limitações impostas pela ISA legada. A Tradução Binária (TB) abre novas possibilidades aos projetistas, visto que permite a execução de códigos previamente compilados para uma determinada arquitetura em outra arquitetura. No entanto, a TB acrescenta mais uma camada entre o código e sua execução, trazendo perdas de desempenho. Este trabalho explora um novo mecanismo de tradução binária dinâmico de dois níveis que, ao trocar o primeiro nível, pode executar ISAs diferentes de forma totalmente transparente e ainda amortiza os custos de tradução. Da mesma forma ao trocar o segundo nível de tradução binária pode-se trocar a arquitetura alvo. Com base nesse tradutor de dois níveis, é apresentado como estudo de caso um sistema computacional composto por uma arquitetura reconfigurável capaz de executar códigos x86, ARM, PowerPC e MIPS de forma transparente, com compatibilidade binária e com ganhos de desempenho. / The embedded systems market is demanding a wide range of applications, and these applications are increasing in complexity. In order to meet this demand, since the decline of Moore’s law and processors reaching their thermal dissipation limits, designers are pushed to develop new computer organizations. In order to support binary compatibility, so that the large quantity of applications and tools already deployed can be reused, companies develop their products focusing on improvement of a given processor that will execute the same ISA (Instruction Set Architecture) as before. This need for code compatibility impose a lot of restrictions to the design team, considering the limitations imposed by the legacy ISA. Binary Translation (BT) open new possibilities for designers, since it allows the execution of a code previously compiled to a specific architecture in another architecture. However, BT adds another layer between code and actual execution, therefore bringing performance penalties. This work explores a dynamic two-level binary translation system that, by changing the first BT level, allows the execution of different ISAs in a transparent fashion and still amortizes translation costs. In the same way, it is possible to switch to another target architecture by only changing the second BT level. Based on this two-level translator this work presents, as a case study, a computational architecture comprising of an dynamic reconfigurable array that can execute x86, ARM, PowerPC and MIPS binary codes in a transparent way, maintaining binary compatibility with performance gains.

Sistemas embarcados, em especial aqueles utilizados em robótica, apresentam, em sua estrutura, uma multiplicidade de dispositivos que resultam em uma arquitetura bastante heterogênea e bem distribuída. Para auxiliar na resolução dessa complexidade inerente, este trabalho resgata os conceitos de frameworks, buscando na sua integração e modelo conceitual, desenvolver um conjunto de ferramentas que gerencia a mediação entre sistemas embarcados e demais aplicações de software, fornecendo bibliotecas e componentes reutilizáveis para aplicações na robótica. Propõe-se utilizar framework e middleware de sistemas open-source para integração entre a plataforma de software e hardware. Um dos objetivos do projeto é criar um framework multi-plataforma com diferentes tipos de serviços para o de desenvolvimento de aplicações no campo da robótica. O projeto tem como estudo de caso sistemas embarcados aplicados em robótica móvel e tecnologia assistiva. / Embedded systems, especially those used in robotics, present in its structure, a plurality of devices that result in a very heterogeneous and well distributed architecture. To help resolve this inherent complexity, the work rescues the concepts of frameworks, seeking their integration and conceptual model, develop a set of tools that manage to mediate between embedded systems and other of software applications, providing reusable libraries and components for applications in robotics. It is proposed to use framework and middleware systems open source for integration between the platform software and hardware. One of the project objectives is to create a multi-platform framework with different types of services, considering the programming and compatibility with hardware for the development of applications in the field of robotics. The project’s case study developing embedded applied in mobile and Assistive Technology robotics.

Dada a grande diversidade de aplicações embarcadas presentes nos atuais dispositivos portáveis, ambos os paralelismos em nível de threads e de instruções devem ser explorados para obter ganhos de desempenho e energia. Enquanto MPSoCs (sistemas em chip de múltiplos núcleos) são amplamente usados para esse propósito, estes falham quando consideramos produtividade de software, já que eles são compostos de chips com diferentes arquiteturas que precisam ser programados separadamente. Por outro lado, processadores multi núcleos de propósito geral implementam a mesma arquitetura, mas são compostos de núcleos homogêneos de processadores superescalares que consomem muita potência. Nesta dissertação, propõe-se um novo sistema, que tira proveito de circuitos reconfiguráveis para criar diferentes organizações que implementam a mesma arquitetura, capazes de apresentar alto desempenho com baixo custo energético. Para garantir a compatibilidade binária, usa-se um mecanismo de tradução binária que transforma o código a ser executado no circuito reconfigurável durante a execução. Usando aplicações representativas, mostra-se que uma versão do sistema heterogêneo pode ganhar da sua versão homogênea em média de 59% em desempenho e 10% em energia, com melhoras em EDP (Energy-Delay Product – Produto da energia pelo tempo de execução) em quase todos os cenários. Além disso, este trabalho também propõe e avalia seis escalonadores para este sistema heterogêneo: dois algoritmos estáticos, os quais alocam as threads no primeiro núcleo livre, onde elas permanecerão durante toda a execução; um escalonador direcionado por contagem de instruções, o qual realoca as threads durante pontos de sincronização de acordo com a sua contagem de instruções; um escalonador de Feedback, que usa dados de dentro da unidade reconfigurável para realocar threads; o PC-Feedback, que adiciona um mecanismo de reuso de dados ao último escalonador; e um escalonador Oráculo, que é capaz de decidir a melhor alocação de threads possível. Mostra-se que o algoritmo estático pode ter alto desempenho em aplicações com alto paralelismo, contudo para um desempenho mais uniforme em todas as aplicações os algoritmos de Feedback e PC-Feedback são mais indicados. / Given the large diversity of embedded applications one can find in current portable devices, for energy and performance reasons one must exploit both Thread- and Instruction Level Parallelism. While MPSoCs (Multiprocessor system-on-chip) are largely used for this purpose, they fail when one considers software productivity, since it comprises different ISAs (Instruction Set Architecture) that must be programmed separately. On the other hand, general purpose multicores implement the same ISA, but are composed of a homogeneous set of very power consuming superscalar processors. In this dissertation, we show how one can effectively use a reconfigurable unit to provide a number of different possible heterogeneous configurations while still sustaining the same ISA, capable of reaching high performance with low energy cost. To ensure ISA compatibility, we use a binary translation mechanism that transforms code to be executed on the fabric at run-time. Using representative benchmarks, we show that one version of the heterogeneous system can outperform its homogenous counterpart in average by 59% in performance and 10% in energy, with EDP (Energy-Delay Product) improvements in almost every scenario. Furthermore, this work also proposes and evaluates six schedulers for the heterogeneous system: two static algorithms, which allocate the threads on the first free core, where they will run during the entire execution; an Instruction Count (IC) Driven scheduler, which reallocates threads during synchronization points accordingly to their instruction count; a Feedback scheduler, which uses data from inside the reconfigurable unit to reallocate threads; the PCFeedback scheduler, that adds a reuse mechanism to the last one; and an Oracle scheduler, which is capable of deciding the best thread allocation possible. We show that the static algorithm can reach high performance in applications with high parallelism, however for uniform performance in all applications, the Feedback and PC-Feedback algorithms are better designated.

Virtualização permite o compartilhamento de uma rede física entre uma ou mais redes virtuais. O Problema de Mapeamento de Redes Virtuais é um dos principais desafios na virtualização de redes. Esse problema consiste em mapear uma rede virtual em uma rede física, respeitando restrições de capacidade. O presente trabalho mostra que encontrar uma solução factível para esse problema é NP-Difícil. Mesmo assim, muitas instâncias podem ser pode ser resolvidas na prática através da exploração de sua estrutura. Nós apresentamos um algoritmo de Branch & Price aplicado a instâncias de diferentes topologias e tamanhos. Os experimentos realizados sugerem que o algoritmo proposto é superior ao modelo de programação linear resolvido com CPLEX. / Virtualization allows one or more virtual networks to share physical infrastructures. The Virtual Network Embedding problem (VNEP) is one of the main challenges in the virtualization of physical networks. This problem consists in mapping a virtual network into a physical network while respecting capacity constraints. This work shows that finding a feasible solution for this problem is NP-Hard. However, many instances can be solved up to optimality in practice by exploiting the problem structure. We present a Branch & Price algorithm applied to instances of different topologies and sizes. The experimental results suggest that the proposed algorithm is superior to the Integer Linear Programming model solved by CPLEX.

O crescente aumento da complexidade dos sistemas embarcados demanda consigo a necessidade do uso de novas abordagens que acelerem o seu desenvolvimento, como por exemplo, o desenvolvimento baseado em modelos. Essas novas abordagens buscam aumentar o nível de abstração, utilizando conceitos de orientação a objetos e UML para modelar um software embarcado. Porém, com o aumento do nível de abstração, o projetista de software embarcado não possui a ideia exata do impacto de suas decisões de modelagem em questões importantes, como desempenho, consumo de energia, entre tantas outras que são de suma importância em um projeto embarcado. Dessa forma, se fazem necessárias técnicas de análise e/ou estimação de projeto que, em um ambiente de desenvolvimento mais abstrato, possam auxiliar o projetista a tomar melhores decisões nas etapas inicias de projeto, garantindo assim, as funcionalidades (requisitos funcionais) e os requisitos não funcionais do sistema embarcado. Neste trabalho, propõe-se estimar os requisitos não funcionais de um sistema embarcado a partir de informações (métricas) extraídas das etapas iniciais do projeto. Pretende-se com isso auxiliar o projetista na exploração do espaço de projeto já nos estágios iniciais do processo de desenvolvimento, através de uma rápida realimentação sobre o impacto de uma decisão de projeto no desempenho da aplicação em uma dada plataforma de execução. Os resultados experimentais mostram a aplicabilidade da abordagem, principalmente para um ambiente de evolução e manutenção de projetos de software, onde se tem um histórico de métricas de aplicações semelhantes para serem usadas como dados de treinamento. Neste cenário, a abordagem proposta possui acurácia de pelo menos 98% para as estimativas apresentadas ao projetista. Em um cenário heterogêneo, assumindo o uso da metodologia em um sistema diferente daquele usado para treinamento, a acurácia do método de estimação cai para pelo menos 80%. / The increasing complexity of embedded systems demands the use of new approaches to accelerate their development, such as model-driven engineering. Such approaches aim at increasing the level of abstraction using concepts such as object-orientation and UML for modeling the embedded software. However, with the increase of the abstraction level, the embedded software developer looses controllability and predictability over important issues such as performance, power dissipation and memory usage for a specific embedded platform. Thus, new design estimation techniques that can be used in the early development stages become necessary. Such a strategy may help the designer to make better decisions in the early stages of the project, thus ensuring the final system meets both functional and non-functional requirements. In this work, we propose an estimation technique of non-functional requirements for embedded systems, based on data (metrics) extracted from early stages of the project. The proposed methodology allows to better explore different design options in the early steps of software development process and can therefore provide a fast and yet accurate feedback to the developer. Experimental results show the applicability of the approach, particularly for software evolution and maintenance, which has a history of similar applications metrics to be used as training data. In this scenario, the accuracy of the estimation is at least of 98%. In a heterogeneous scenario, where the estimation is performed for a system that is different from the one used during training, the accuracy drops to 80%.

Partículas radioativas, ao atingirem o hardware dos sistemas computacionais, podem resultar em comportamentos inesperados durante a execução de um software. Tais comportamentos inesperados podem persistir por toda a vida útil do sistema ou podem ter uma duração limitada. Nesse último caso, temos o que chamamos de falhas transientes. Falhas transientes podem fazer com que as instruções do programa executem em uma sequência incorreta, o que chamamos de erros de fluxo de controle (Control-flow errors - CFEs). Estudos mostram que entre 33% e 77% das falhas transientes que afetam o hardware se manifestam como erros de fluxo de controle, dependendo do tipo do processador. Se o sistema não realizar nenhuma verificação em tempo de execução, um erro de fluxo de controle pode não ser detectado, o que pode resultar em uma execução incorreta do programa. Sistemas projetados para aplicações de baixo custo voltados para sistemas embarcados, onde os custos e desempenho são os fatores principais, utilizam técnicas baseadas em software para aumentar a confiabilidade do sistema. As técnicas baseadas em software para detecção de CFEs são conhecidas como signature monitoring ou signature checking. Essas técnicas introduzem código extra em todos os blocos básicos do programa com a finalidade de detectar os CFEs. Esse código extra implica em overhead, que pode ter uma grande variação dependendo da técnica utilizada. Na tentativa de minimizar o overhead imposto pelas técnicas de detecção de CFEs, neste trabalho foi desenvolvida a técnica de detecção e proteção de blocos básicos suscetíveis através da análise sistemática de single bit-flip. O objetivo da técnica é detectar os blocos básicos suscetíveis do programa através da análise sistemática de single bit-flip e proteger apenas esses blocos básicos. A técnica foi avaliada em termos de sua taxa de cobertura de falhas e desempenho. Para avaliar a taxa de cobertura falhas foram realizadas várias campanhas de injeção de falhas nos programas da suíte de benchmarks Mibench. A avaliação de desempenho foi feita com base na quantidade de instruções de máquina executadas pelos benchmarks, comparando quantidade de instruções antes e depois da utilização da técnica detecção e proteção de blocos básicos suscetíveis. Os resultados dos experimentos mostram que é possível reduzir em até 27,93% a quantidade de blocos básicos protegidos e ao mesmo tempo manter uma alta taxa de cobertura de falhas. Porém, em termos de desempenho, o ganho não ficou na mesma proporção da quantidade de blocos básicos não protegidos, ficando abaixo do esperado. / Radioactive particles hitting the hardware of computer systems may result in unexpected behavior during software execution. Such unexpected behavior may persist for the lifetime of the system or may have a limited duration. In the latter case, we have what is called a transient fault. Transient faults may cause the program instructions to execute in an incorrect sequence. This incorrect sequence is called a control flow error (CFE). Research show that between 33% to 77% of transient faults manifest themselves as CFEs, depending on the type of the processor. If the system does not perform any verification at runtime, a control flow error may be not detected, which can result in incorrect program execution. Systems projected to low-cost embedded applications, where cost and performance are the main factors, use software based techniques to improve system reliability. Software based techniques to detect CFEs are known as signature monitoring or signature checking. These techniques insert extra code in each basic block of the program in order to detect CFEs. This extra code add an undesirable overhead in the program, which can have large variation depending on the technique used. In the attempt to minimize the overhead added by CFEs detection techniques, this work developed a technique of detection and protection of susceptible basic blocks through systematic bit-flip analysis. The purpose of this technique is to detect the susceptible basic blocks of the program through the systematic bit-flip analysis and to protect only these basic blocks. The technique was evaluated based on its fault coverage rate and performance. To evaluate the fault coverage rate a fault injection campaing was performed in the programs of the Mibench benchmark suite. The performance evaluation was based in the number of instruction executed by each benchmark, comparing the number of instructions before and after the use of the proposed technique. The experimental results show that is possible to reduce up to 27,93% the amount of protected basic blocks, while keeping a high faults coverage hate. However, in terms of performance, the gain was not in the same proportion, being lower than expected.

As the number of embedded applications is increasing, the current strategy of several companies is to launch a new platform within short periods, to execute the application set more efficiently, with low energy consumption. However, for each new platform deployment, new tool chains must come along, with additional libraries, debuggers and compilers. This strategy implies in high hardware redesign costs, breaks binary compatibility and results in a high overhead in the software development process. Therefore, focusing on area savings, low energy consumption, binary compatibility maintenance and mainly software productivity improvement, we propose the exploitation of Custom Reconfigurable Arrays for Multiprocessor System (CReAMS). CReAMS is composed of multiple adaptive reconfigurable systems to efficiently explore Instruction and Thread Level Parallelism (ILP and TLP) at hardware level, in a totally transparent fashion. Conceived as homogeneous organization, CReAMS shows a reduction of 37% in energy-delay product (EDP) compared to an ordinary multiprocessing platform when assuming the same chip area. When a variety of processor with different capabilities on exploiting ILP are coupled in a single die, conceiving CReAMS as a heterogeneous organization, performance improvements of up to 57% and energy savings of up to 36% are showed in comparison with the homogenous platform. In addition, the efficiency of the adaptability provided by CReAMS is demonstrated in a comparison to a multiprocessing system composed of 4- issue Out-of-Order SparcV8 processors, 28% of performance improvements are shown considering a power budget scenario.