Thierry Gil

A contextual resources use: a proof of concept through the APACHES' platform

A homogeneous architecture made of an array of so-called NPUs (network processing units) is presented in this paper. Those NPUs are endowed with elementary processing and communication capabilities, that for exploring the opportunity of finely adapting system behavior according to current system state. Applications considered in this work are described as task graphs, which are mapped at run-time taking into account the performance requirements, the number of available NPUs and their respective positions. The placement is performed using different algorithms. An adaptive architecture running several MJPEG streaming applications is used for experiments and comparisons

Highly Scalable Dynamically Reconfigurable Systolic Ring-Architecture for DSP Applications

New parallel execution based machine paradigms must be considered. Thanks to their high level of flexibility structurally programmable architectures are potentially interesting candidates to overcome classical CPUs limitations. Based on a parallel execution model, we present in this paper a new dynamically reconfigurable architecture, dedicated to data oriented applications acceleration. Principles, realizations and comparative results will be exposed for some classical applications, targeted on different architectures.

A Bio-Inspired Agent Framework for Hardware Accelerated Distributed Pervasive Applications

This paper describes an agent oriented framework supporting bio-inspired mechanisms which takes profit of the intrinsic hardware parallelism of the pervasive platform developed within the Perplexus IST European project. The proposed framework is a flexible and modular means to describe and simulate complex phenomena such as biologically plausible neural networks or culture dissemination. Associated to this framework and based on the multiprocessor architecture of the Perplexus platform nodes, a tool suite capable of accelerating parallelizable agents is described. Therefore, this contribution combines the software flexibility of agent-based programming with the efficiency of multiprocessor hardware execution. This framework has been successfully tested with two experiments: a proof of concept application made of robots that autonomously improve their behaviours according to their environment and a spiking neural network simulation. These results prove that the framework and its associated methodology are relevant in the context of the simulation of complex phenomena.

Run-Time Resources Management on Coarse Grained, Packet-Switching Reconfigurable Architecture: A Case Study Through the APACHES’ Platform

The increasing number of cores used on a single die in response to the power-computing applications tends to orient SoCs more and more toward communication-centric concept. Networks-on-chip (NoC) are good candidates providing both parallelism and flexibility. Nevertheless they imply to consider the notion of locality when distributing the computation among a set of cores. Defining an optimal placement at compile-time is difficult since other applications may temporarily make use of some of the processing resources. This paper explores the opportunity of dynamically mapping task graphs through using different placement algorithms, experiments and comparisons are conducted on a homogeneous coarse-grain reconfigurable architecture running JPEG applications. Results show that run-time task mapping is possible and brings interesting benefits over a random or static placement, especially when contention effects stemming from the communication medium are taken into account.

JubiTool: Unified design flow for the Perplexus SIMD hardware accelerator

This paper presents a new unified design flow developed within the Perplexus project that aims to accelerate parallelizable data-intensive applications in the context of ubiquitous computing. This contribution relies on the JubiTool: a set of integrated tools (JubiSplitter, JubiCompiler, UbiAssembler), allowing respectively to extract, compile and assemble parallelizable parts of applications described in Jubi language. Jubi is a modified Java agent based language (JADE) dedicated to the Ubichip (the bio-inspired chip developed within the confines of the Perplexus project). By appending hardware directives to a software agent description, the inherent flexibility of software is combined with the runtime performance of a hardware execution. In the case of typical Perplexus applications such as the Spiking Neural Network Simulator, this contribution takes profit of the intrinsic property of the Ubichip in terms of parallelism resulting in an expected speedup of at least one order of magnitude. Finally, this hybrid (SW/HW) flow could be easily modified and adapted to support other kind of distributed platforms.