SOUZA, O. Metodologia para porte do sistema operacional Linux para sistemas embarcados. 2007. 78 f. Dissertação (Mestrado em Engenharia de Teleinformática) – Centro de Tecnologia, Universidade Federal do Ceará, Fortaleza, 2007. / Submitted by Marlene Sousa (mmarlene@ufc.br) on 2016-04-05T12:10:56Z No. of bitstreams: 1 2007_dis_osouza.pdf: 947735 bytes, checksum: 7e9a83068dadae0c7e247ec7883cd3fc (MD5) / Approved for entry into archive by Marlene Sousa(mmarlene@ufc.br) on 2016-04-05T19:04:01Z (GMT) No. of bitstreams: 1 2007_dis_osouza.pdf: 947735 bytes, checksum: 7e9a83068dadae0c7e247ec7883cd3fc (MD5) / Made available in DSpace on 2016-04-05T19:04:01Z (GMT). No. of bitstreams: 1 2007_dis_osouza.pdf: 947735 bytes, checksum: 7e9a83068dadae0c7e247ec7883cd3fc (MD5) Previous issue date: 2007-10-07 / Embedded system development frequently uses the “trial and error” approach for Operating System (OS) porting,resulting in incomplete or inconsistent porting. In this work, we present a pioneer work addressing this issue. We propose a complete method for detecting OS parts that should be adjusted in order to port the OS into a new hardware platform. The proposed method combines information from the OS source-code and peculiarities of the new hardware platform, resulting in: a complete list of source-codes that must be adjusted; the interdependence between these source-codes; the priority order of modifications for each source-code; and an effort-based schedule to help planning the modifications. In addition, we propose an algorithm dealing with source-code’s cyclic references. Finally, we present a study-case based on an application developed according the proposed method. / Em projetos de desenvolvimento de sistemas embarcados normalmente adota-se uma abordagem de “tentativa e erro” nas atividades relacionadas ao porte do sistema operacional(SO), resultando em um porte incompleto ou inconsistente. Nesta pesquisa apresenta-se um trabalho original onde se propõe uma solução para esta abordagem através de uma metodologia completa para a detecção das partes do SO que devem ser ajustadas de forma que o SO seja portado para a nova plataforma de hardware. A metodologia proposta combina as informações do código-fonte do SO e as particularidades do novo hardware, resultando em: uma lista completa do código-fonte que deve ser ajustado; a interdependência entre estes códigos-fonte; a ordem de prioridade de modificação para cada código-fonte; e um cronograma baseado em esforço, para auxiliar o planejamento das modificações. Adicionalmente, propõe-se um algoritmo para a resolução de referências cíclicas em arquivos de código-fonte. Por fim, é apresentado um estudo de caso baseado em uma aplicação desenvolvida segundo a metodologia proposta.

No mercado altamente globalizado de hoje, a manutenção dos equipamentos tem se tornado um fator crucial para as empresas dos mais diversos segmentos. Técnicas de manutenção baseadas no nível de degradação dos equipamentos estão sendo preferidas em detrimento das técnicas tradicionais como manutenção corretiva e preventiva, e trazem benefícios como tempos de paradas reduzidos, tarefas de manutenção facilitadas e melhor gerenciamento de ativos. Com o desenvolvimento das técnicas de manutenção inteligente, os sistemas embarcados que comportarão estes algoritmos necessitarão cada vez mais de alta flexibilidade, combinada com alta velocidade de processamento e baixo consumo. Em outras palavras, eles tornam-se cada vez mais complexos, o que tem impacto direto no projeto destes sistemas. Neste contexto, a programação baseada em modelos em conjunto com a capacidade de geração automática de código para uma dada plataforma tem despertado grande interesse. O presente trabalho tem como objetivo realizar a análise dos espaços de projeto e também do desempenho de diferentes implementações para algoritmos de manutenção inteligente quando executados em hardware e software. A partir de implementações disponíveis nos ambientes MATLAB e LabVIEW™ de um sistema de manutenção inteligente chamado Watchdog Agent™, e utilizando ferramentas de geração automática de código, o desempenho dos sistemas de manutenção gerados é comparado usando-se parâmetros como tempo de execução e ocupação de memória ou da área do FPGA. Para os testes são utilizados dados de vibração coletados de uma bancada de testes composta por um atuador eletromecânico para válvulas. / In today’s highly globalized market, equipment maintenance has become a crucial factor for companies from several segments. Maintenance strategies based on equipment’s condition level are being preferred in place of traditional techniques such as corrective and preventive maintenance, and incur in benefits such as reduced downtime, facilitated maintenance tasks and better assets management. With the development of intelligent maintenance techniques, the embedded systems that will be used with such algorithms will need increasingly more flexibility, combined with high processing speed and low power consumption. In other words, they became increasingly more complex, what directly impact in their project. Within this context, model based engineering associated with automatic platform-specific code generation capabilities are of great interest. This work has as objective to perform a design space exploration by analyzing the performance of different implementations for intelligent maintenance algorithms when executed in hardware and software. Based on implementations available in MATLAB™ and LabVIEW™ environments of an intelligent maintenance system called Watchdog Agent, and using automatic code generation tools, the performance of the generated systems are compared using parameters such as execution time and memory or FPGA area occupation. For the validation tests, vibration data collected from a test bench composed by an electric mechanical actuator will be used.

A evolução de serviços requer estratégicas para lidar adequadamente com a gerência de versões resultantes das alterações ocorridas durante o ciclo de vida do serviço. Normalmente, uma versão de serviço é exposta como um documento que descreve a funcionalidade do serviço, orientando desenvolvedores clientes sobre os detalhes de acesso ao serviço. No entanto, não existe um padrão para o tratamento de versões dos documentos que descrevem o serviço. Isso implica na dificuldade de identificação e localização de alterações, bem como na medição do seu impacto, especialmente em uma perspectiva mais granular. A compatibilidade aborda um estilo mais elegante de evolução de serviços, considerando os efeitos provenientes das alterações nas aplicações cliente. Ela define um conjunto de alterações permissivas, as quais não afetem a integração externa com o serviço. Entretanto, provedores não conseguem garantir que as alterações necessárias ao serviço estarão no conjunto de alterações compatíveis. Além disso, o conceito de compatibilidade é muitas vezes aplicado sobre a descrição do serviço como um todo, o que pode não ser representativo do uso real do serviço por uma aplicação cliente em particular. Assim, é de responsabilidade dos desenvolvedores clientes avaliar a extensão das alterações no serviço a fim de medir o impacto no seu cenário em particular. Esse processo pode ser difícil e propenso a erros sem o uso de mecanismos de identificação de mudanças. Este trabalho aborda a evolução do serviço de maneira mais granular, o que chamamos de nível de feature. Desse modo, nós propomos um modelo de controle de versões e um algoritmo de compatibilidade a nível de feature, que permite a identificação e qualificação do impacto das alterações, assim como a avaliação da compatibilidade das mudanças neste nível de feature. Este trabalho também apresenta um experimento com base em um serviço real, que explora o modelo de controle de versões para avaliar a extensão das mudanças implícitas e explícitas e sua avaliação de compatibilidade. / Service evolution requires sound strategies to appropriately manage versions resulting from changes during service lifecycle. Typically, a service version is exposed as a description document that describes the service functionality, guiding client developers on the details for accessing the service. However, there is no standard for handling the versioning of service descriptions, which implies on difficulties on identifying and tracing changes as well as measuring their impact, particularly in a finer grain perspective. Compatibility addresses the graceful evolution of services by considering the effects of changes on client applications. It defines a set of permissible change cases that do not disrupt the service external integration. However, providers cannot always guarantee that the necessary changes yield compatible service descriptions. Moreover, the concept of compatibility is often applied to the entire service description, which can not be representative of the actual use of the service by a particular client application. So, it is the client’s developers responsibility to assess the extent of the change and their impact in their particular usage scenario, which can be hard and error-prone without proper change identification mechanisms. This work addresses service evolution in a finer grain manner, which we refer to as feature level. Hence, we propose a versioning model and a compatibility algorithm at feature level, which allows the identification and qualification of changes impact points, their ripple effect, as well as the assessment of changes’ compatibility in this finer grain of features. This work also reports an experiment based on a real service, which explores the versioning model to assess the scope of implicit and explicit changes and their compatibility assessment.

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.

A confiabilidade de algoritmos para detecção de pedestres é um problema fundamental para carros auto dirigíveis ou com auxílio de direção. Métodos que utilizam algoritmos de detecção de objetos como Histograma de Gradientes Orientados (HOG - Histogram of Oriented Gradients) ou Redes Neurais de Convolução (CNN – Convolutional Neural Network) são muito populares em aplicações automotivas. Unidades de Processamento Gráfico (GPU – Graphics Processing Unit) são exploradas para executar detecção de objetos de uma maneira eficiente. Infelizmente, as arquiteturas das atuais GPUs tem se mostrado particularmente vulneráveis a erros induzidos por radiação. Este trabalho apresenta uma validação e um estudo analítico sobre a confiabilidade de duas classes de algoritmos de detecção de objetos, HOG e CNN. Esta pesquisa almeja não somente quantificar, mas também qualificar os erros produzidos por radiação em aplicações de detecção de objetos em GPUs embarcadas. Os resultados experimentais com HOG foram obtidos usando duas arquiteturas de GPU embarcadas diferentes (Tegra e AMD APU), cada uma foi exposta por aproximadamente 100 horas em um feixe de nêutrons em Los Alamos National Lab (LANL). As métricas Precision e Recall foram usadas para validar a criticalidade do erro. Uma análise final mostrou que por um lado HOG é intrinsecamente resiliente a falhas (65% a 85% dos erros na saída tiveram um pequeno impacto na detecção), do outro lado alguns erros críticos aconteceram, tais que poderiam resultar em pedestres não detectados ou paradas desnecessárias do veículo. Este trabalho também avaliou a confiabilidade de duas Redes Neurais de Convolução para detecção de Objetos:Darknet e Faster RCNN. Três arquiteturas diferentes de GPUs foram expostas em um feixe de nêutrons controlado (Kepler, Maxwell, e Pascal), com as redes detectando objetos em dois data sets, Caltech e Visual Object Classes. Através da análise das saídas corrompidas das redes neurais, foi possível distinguir entre erros toleráveis e erros críticos, ou seja, erros que poderiam impactar na detecção de objetos. Adicionalmente, extensivas injeções de falhas no nível da aplicação (GDB) e em nível arquitetural (SASSIFI) foram feitas, para identificar partes críticas do código para o HOG e as CNNs. Os resultados mostraram que não são todos os estágios da detecção de objetos que são críticos para a confiabilidade da detecção final. Graças a injeção de falhas foi possível identificar partes do HOG e da Darknet, que se protegidas, irão com uma maior probabilidade aumentar a sua confiabilidade, sem adicionar um overhead desnecessário. A estratégia de tolerância a falhas proposta para o HOG foi capaz de detectar até 70% dos erros com 12% de overhead de tempo. / Pedestrian detection reliability is a fundamental problem for autonomous or aided driving. Methods that use object detection algorithms such as Histogram of Oriented Gradients (HOG) or Convolutional Neural Networks (CNN) are today very popular in automotive applications. Embedded Graphics Processing Units (GPUs) are exploited to make object detection in a very efficient manner. Unfortunately, GPUs architecture has been shown to be particularly vulnerable to radiation-induced failures. This work presents an experimental evaluation and analytical study of the reliability of two types of object detection algorithms: HOG and CNNs. This research aim is not just to quantify but also to qualify the radiation-induced errors on object detection applications executed in embedded GPUs. HOG experimental results were obtained using two different architectures of embedded GPUs (Tegra and AMD APU), each exposed for about 100 hours to a controlled neutron beam at Los Alamos National Lab (LANL). Precision and Recall metrics are considered to evaluate the error criticality. The reported analysis shows that, while being intrinsically resilient (65% to 85% of output errors only slightly impact detection), HOG experienced some particularly critical errors that could result in undetected pedestrians or unnecessary vehicle stops. This works also evaluates the reliability of two Convolutional Neural Networks for object detection: You Only Look Once (YOLO) and Faster RCNN. Three different GPU architectures were exposed to controlled neutron beams (Kepler, Maxwell, and Pascal) detecting objects in both Caltech and Visual Object Classes data sets. By analyzing the neural network corrupted output, it is possible to distinguish between tolerable errors and critical errors, i.e., errors that could impact detection. Additionally, extensive GDB-level and architectural-level fault-injection campaigns were performed to identify HOG and YOLO critical procedures. Results show that not all stages of object detection algorithms are critical to the final classification reliability. Thanks to the fault injection analysis it is possible to identify HOG and Darknet portions that, if hardened, are more likely to increase reliability without introducing unnecessary overhead. The proposed HOG hardening strategy is able to detect up to 70% of errors with a 12% execution time overhead.

Os processadores embarcados operando em sistemas de segurança ou de missão crítica não podem falhar. Qualquer falha neste tipo de aplicação pode levar a consequências inaceitáveis, como risco de vida ou danos à propriedade ou ao meio ambiente. Os sistemas embarcados que operam em aplicações aeroespaciais são sucetíveis à falhas transientes induzidas por radiação. Entretanto, os efeitos de radiação também podem ser observados ao nível do solo. Falhas transientes afetam os processadores modificando os valores armazenados em elementos de memória, tais como registradores e memória de dados. Essas falhas podem levar o processador a executar incorretamente a aplicação, provocando erros na saída ou travamentos no sistema. Os avanços recentes em processadores embarcados concistem na integração de processadores hard-core e FPGAs. Tais dispositivos, comumente chamados de Sistemas-em-Chip Totalmente Programáveis (APSoCs), também são sucetíveis aos efeitos de radiação. Com objetivo de minimizar esse problema de tolerância a falhas, este trabalho apresenta um Dual-Core LockStep (DCLS) como uma técnica de tolerância para mitigar falhas induzidas por radiação que afetam processadores embarcados em APSoCs. Lockstep é um método baseado em redundância usado para detectar e corrigir falhas transientes. O DCLS proposto é implementado em um processador ARM Cortex-A9 hard-core embarcado no APSoC Zynq-7000. A eficiência da abordagem implementada foi validada tanto em aplicações executando em bare-metal como no sistema operacional FreeRTOS. Experimentos com íons pesados e emulação de falhas por injeção foram executados para analisar a sucetibilidade do sistema a inversão de bits. Os resultados obtidos mostram que a abordagem é capaz de diminuir a seção de choque do sistema com uma alta taxa de proteção. O sistema DCLS mitigou com sucesso até 78% das falhas injetadas. Otimizações de software também foram avaliadas para uma melhor compreenção dos trade-offs entre desempenho e confiabilidade. Através da análise de diferentes partições de software, observou-se que o tempo de execução de um bloco da aplicação deve ser muito maior que o tempo de verificação para que se obtenha menor impacto em desempenho. A avaliação de otimizações de compilador demonstrou que utilizar o nível O3 aumenta a vulnerabilidade da aplicação à falhas transientes. Como o O3 requer o uso de mais registradores que os otros níveis de otimização, o sistema se torna mais sucetível à falhas. Por outro lado, os resultados dos experimentos de radiação apontam que a aplicação compilada com nível O3 obtém maior Carga de Trabalho Média Entre Falhas (MWBF). Como a aplicação executa mais rápido, mais dados são computados corretamente antes da ocorrência de um erro. / The embedded processors operating in safety- or mission-critical systems are not allowed to fail. Any failure in such applications could lead to unacceptable consequences as life risk or significant damage to property or environment. Concerning faults originated by the radiation-induced soft errors, the embedded systems operating in aerospace applications are particularly susceptible. However, the radiation effects can also be observed at ground level. Soft errors affect processors by modifying values stored in memory elements, such as registers and data memory. These faults may lead the processor to execute an application incorrectly, generating output errors or leading hangs and crashes in the system. The recent advances in embedded systems concern the integration of hard-core processors and FPGAs. Such devices, called All Programmable System-on-Chip (APSoC), are also susceptible to radiation effects. Aiming to address this fault tolerance problem this work presents a Dual-Core LockStep (DCLS) as a fault tolerance technique to mitigate radiation-induced faults affecting processors embedded into APSoCs. Lockstep is a method based on redundancy used to detect and correct soft errors. The proposed DCLS is implemented in a hard-core ARM Cortex-A9 embedded into a Zynq-7000 APSoC. The approach efficiency was validated not only on applications running in baremetal but also on top of FreeRTOS systems. Heavy ions experiments and fault injection emulation were performed to analyze the system susceptibility to bit-flips. The obtained results show that the approach is able to decrease the system cross section with a high rate of protection. The DCLS system successfully mitigated up to 78% of the injected faults. Software optimizations were also evaluated to understand the trade-offs between performance and reliability better. By the analysis of different software partitions, it was observed that the execution time of an application block must to be much longer than the verification time to achieve fewer performance penalties. The compiler optimizations assessment demonstrate that using O3 level increases the application vulnerability to soft errors. Because O3 handles more registers than other optimizations, the system is more susceptible to faults. On the other hand, results from radiation experiments show that O3 level provides a higher Mean Workload Between Failures (MWBF). As the application runs faster, more data are correctly computed before an error occurrence.

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.

Este trabalho apresenta o projeto e arquitetura de uma plataforma para execução de Agentes com funções implementadas em hardware, tomando vantagem do uso de hardware reconfigurável. Os Agentes em hardware são implementados utilizando dispositivos FPGA (Field-programmable Gate Array). O trabalho estende trabalhos anteriores semelhantes na área, com o diferencial de adicionar suporte às funcionalidades de reconfiguração parcial do hardware, suportar aplicações que demandam alto desempenho em hardware – como processamento de sinais e imagens – e redução de recursos de hardware necessários para execução da interface em software. A plataforma proposta utiliza o framework JADE (Java Agent Development Framework), que é um dos frameworks mais populares no estado da arte de desenvolvimento de Agentes e compatível com outros frameworks de Agentes através da conformidade aos padrões FIPA (Foundation for Intelligent Physical Agents). Com o uso do JADE, a plataforma possibilita a comunicação entre Agentes com funções implementadas em hardware e Agentes puramente implementados em software dentro de um mesmo SMA (Sistema Multi-Agente). Uma funcionalidade notável do JADE é a possibilidade de migração de Agentes entre plataformas de um mesmo SMA. Através do uso da reconfiguração parcial de hardware em conjunto com o JADE, a plataforma permite a migração de Agentes de software para hardware e vice-versa, além de suportar reconfiguração de múltiplos Agentes em hardware com um único FPGA. A plataforma faz uso de um único chip através do uso de um processador soft core implementado na lógica programável. O uso deste processador é um diferencial neste trabalho, e mostra que é possível utilizar o JADE em sistemas embarcados com recursos de processamento limitados. Ou seja, em um Agente cuja principal função é implementada em hardware, basta um processador bastante simples para atuar como uma interface entre o hardware e o framework de Agentes. O uso do processador dentro do FPGA tem também o benefício de oferecer formas de acesso mais integrado ao hardware, permitindo maior desempenho na transmissão de dados ao hardware. A plataforma foi validada através de estudos de caso de Agentes com implementações em hardware e em software, incluindo um estudo de caso aplicado de processamento de imagem embarcado utilizando VANTs (Veículos Aéreos Não-Tripulados). O estudo também apresenta comparações de desempenho entre a execução dos Agentes em hardware e em outras plataformas embarcadas de prateleira. Os experimentos realizados mostram um ganho significativo de desempenho nas implementações em FPGA, especialmente considerando processamento de imagens de alta resolução, mesmo considerando que o FPGA executa em frequências consideravelmente reduzidas em comparação às outras plataformas testadas. / This work described the design and architecture of a platform for execution of Agents whose functions are implemented in hardware, by leveraging the use of reconfigurable hardware. The hardware Agents are implemented using FPGA (Field-programmable Gate Array) devices. This work extends previous similar work in this field, while adding the features of hardware partial reconfiguration, supporting applications which require high performance in hardware – such as image or signal processing – and reducing the hardware resource for the software interface execution. The proposed platform makes use of the JADE (Java Agent Development Framework) framework, which is one of the most popular frameworks in state-of-the-art Agent development, and is also compatible with other Agent development frameworks due to compliance with FIPA (Foundation for Intelligent Physical Agents) standards. With the use of JADE, the platform enables communication among Agents which are implemented in hardware and Agents purely implemented in software, inside the same MAS (Multi-Agent System). One notable feature of JADE is the possibility of migrating Agents among platforms inside a single MAS. Through the use of hardware partial reconfiguration along with JADE, the platform enables the migration of Agents from software to hardware and viceversa, in addition to supporting múltiple hardware Agents in a single FPGA. The platform makes use of a single chip, by using a MicroBlaze soft core processor implemented in programmable logic. The use of this processor is a distinction on this work, and it shows that it is possible to use JADE on embedded systems with limited processing power. That is, in an Agent whose main function is implemented in hardware, a very simple processor to act as an interface between hardware and the Agent framework is enough. The use of the soft core processor inside the FPGA also has the benefit of offering more integrated ways of accessing hardware, enabling higher performance for transferring data to hardware. The platform was validated through case studies of hardware and software Agent implementation, including a case study applied to image processing using UAVs (Unmanned Aerial Vehicles). The study also shows performance comparisons between the Agent execution in hardware and in other off-the-shelf embedded platforms. The performed experiments report a significative performance increase in the FPGA implementations, particularly in high resolution image processing, even considering that the FPGA runs in considerably lower clock frequency than the other tested platforms.

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.