Abstract: System adaptivity is becoming an important feature of modern embedded multiprocessor systems. To achieve the goal of system adaptivity when executing Polyhedral Process Networks (PPNs) on a generic tiled Network-on-Chip (NoC) MPSoC platform, we propose an approach to enable the run-time migration of processes among the available platform resources. In our approach, process migration is allowed by a middleware layer which comprises two main components. The first component concerns the inter-tile data communication between processes. We develop and evaluate a number of different communication approaches which implement the semantics of the PPN model of computation on a generic NoC platform. The presented communication approaches do not depend on the mapping of processes, and have been implemented on a Network-on-Chip multiprocessor platform prototyped on an FPGA. Their comparison in terms of the introduced overhead is presented in two case studies with different communication characteristics. The second middleware component allows the actual run-time migration of PPN processes. To this end, we propose and evaluate a process migration mechanism which leverages the PPN model of computation to guarantee a predictable and efficient migration procedure. The efficiency and applicability of the proposed migration mechanism is shown in a real-life case study.
Notes: Special issue on Application-Driven Design of Processor, Memory, and Communication Architectures for MPSoCs
Abstract: Kahn process networks (KPN) is a distributed model of computation used for describing systems where streams of data are transformed by processes executing in sequence or parallel. Autonomous processes communicate through unbounded FIFO channels in absence of a global scheduler. In this work, we propose a task-aware middleware concept that allows adaptivity in KPN implemented over a Network-on-Chip (NoC). We also list our ideas on the development of a simulation platform as an initial step towards creating fault-tolerance strategies for KPNs applications running on NoCs. In doing that, we extend our SACRE (Self-adaptive Component Run-time Environment) framework by integrating it with an open source NoC simulator, Noxim. We evaluate the overhead that the middleware brings to the the total execution time and to the total amount of data transferred in the NoC. With this work, we also provide a methodology that can help in identifying the requirements and implementing fault tolerance and adaptivity support on real platforms.
Notes: Selected Papers from the International Workshop on Reconfigurable Communication-centric Systems on Chips (ReCoSoC’ 2010)
Abstract: Self-adaptivity is the capability of a system to adapt itself dynamically to achieve its goals. Self-adaptive systems will be widely used in the future both to efficiently use system resources and to ease the management of complex systems. The frameworks for self-adaptivity developed so far usually concentrate either on self-adaptive software or on self-adaptive hardware, but not both. In this paper, we propose a model of self-adaptive systems and we describe how to manage self-adaptivity at all levels (both hardware and software) by means of a decentralized control algorithm. The key advantage of decentralized control is in the simplicity of the local controllers. Simulation results are provided to show the main characteristics of the model and to discuss it.
Notes: Challenges in self-adaptive computing (Selected papers from the Aether-Morpheus 2007 workshop), Accepted Manuscript, Available online 29 July 2008
Abstract: Self-adaptivity is the capability of a system to adapt itself dynamically to achieve its goals. By means of this mechanism the system is able to autonomously modify its behavior or the way in which applications are run and implemented to achieve the goals set.In this paper we propose a framework that uses a component-based approach to implement self-adaptivity at application level. By using this mechanism, the framework provides the ability to perform both adaptation on the structure of the application (i.e., how the components are connected together) and on internal parameters of each component. At application level, there is a mechanism to monitor different parameters and to check whether the system is meeting the assigned goals or not. A controller drives adaptations when goals are not met.
Notes: Special Issue on the 2nd International Workshop on Adaptive and Reconfigurable Embedded Systems (APRES’09)
Abstract: We investigate and propose a number of different middleware approaches, namely virtual connector, virtual connector with variable rate, and request-based, which implement the semantics of Kahn Process Networks on Network-on-Chip architectures. All of the presented solutions allow for run-time system adaptivity. We implement the approaches on a Network-on-Chip multiprocessor platform prototyped on an FPGA. Their comparison in terms of the introduced overhead is presented on two case studies with different communication characteristics. We found out that the virtual connector mechanism outperforms other approaches in the communication-intensive application. In the other case study, which has a higher computation/communication ratio, the middleware approaches show similar performance.
Abstract: As CMOS technology scales down into the deep submicron domain, the aspects of fault tolerance in complex Networks-on-Chip (NoCs) architectures are assuming an increasing relevance. Task remapping is a software based solution for dealing with permanent failures in processing elements in the NoC. In this work, we formulate the optimal task mapping problem for mesh-based NoC multiprocessors with deterministic routing as an integer linear programming (ILP) problem with the objective of minimizing the communication traffic in the system and the total execution time of the application. We find the optimal mappings at design time for all scenarios where single-faults occur in the processing nodes. We propose heuristics for the online task remapping problem and compare their performances with the optimal solutions.
Abstract: The electricity market is going through a deep modification as it is moving toward the integration of smart grids. Future homes will include smarter electric devices that will be easily managed from the power consumption stand point. The capability of performing short-term negotiation of energy purchases, if introduced and if efficiently exploited, will give the user the ability to reduce energy costs. In this paper we discuss a scheduling problem for household tasks that will help users save money spent on their energy consumption. Our system model relies on electricity price signals, availability of locally-generated power and flexible tasks with deadlines. A case study shows that cost savings are possible but fast and efficient solutions to the scheduling problem are needed for their real world use.
Abstract: Due to thermal effects and decreasing manufacturing yields with technology scaling, continuity of service of chips and of applications running on them becomes increasingly important. In line with the trend of increasing the core numbers on a single chip, we propose fault tolerance techniques for applications based on the KPN formalism and run on NoC-based multicore architectures without a shared address space. At the core of our approach, there are a task-aware middleware concept and a self-adaptive run-time environment that adapts the application at run-time to meet performance and continuity of service requirements.
Abstract: We propose a task-aware middleware concept and provide details for its implementation on Network-on-Chip (NoC). We also list our ideas on the development of a simulation platform as an initial step towards creating fault-tolerance strategies for Kahn Process Networks (KPN) applications running on NoCs. In doing that, we extend our SACRE (Self-adaptive Component Run-time Environment) framework by integrating it with an open source NoC simulator, Noxim. We also hope that this work may help in identifying the requirements and implementing fault tolerance and adaptivity support on real platforms.
Abstract: Component based design has proved to be an effective approach in the development of large and complex software systems. Extending this methodology to the design of embedded systems requires identifying and assembling reusable components that capture the behavioral properties of the system which are independent from the implementation. One of the most important benefits here is to provide the designer with very high level semantics of the components and let the framework care about creating communicating channels between components and satisfying extrta-functional properties. In this design process from the specifications to the final synthesizable blueprint we focus on the composition of components given a set of specifications and a repository of components. In order to validate the correctness of our composition algorithm we emphasize on the use of executable specifications at different levels of abstraction viz. service, functional and non-functional levels. We also propose a very abstract way of specifying the system that would be the input for the composition algorithm and lead to the final design.
Abstract: Self-adaptivity is the capability of a system to adapt itself dynamically to achieve its goals. By means of this mechanism the system is able to autonomously modify its behavior or the way in which applications are run and implemented to achieve the goals set. In this paper we propose a framework that uses a component-based approach to implement self-adaptivity at application level. By using this mechanism, the framework provides the ability to perform both adaptation on the structure of the application (i.e., how the components are connected together) and on internal parameters of each component. At application level, there is a mechanism to monitor different parameters and to check whether the system is meeting the assigned goals or not. A controller drives adaptations when goals are not met.
Abstract: In this paper we describe a new way for simulating self-adaptive systems developed by relying on a component-based approach, this approach proves to be useful both in easing self-adaptivity and in providing the ability to mix hardware and software elements. Our simulation method is based on SACRE (Self-Adaptive Component Run-time Environment), a framework we have defined in Java for simulating self-adaptive systems.
Abstract: Self-adaptivity is the capability of a system to adapt itself dynamically to achieve its goals. One of the important aspects that affects the quality of such a system is adaptation management. In [1], a model has been proposed as a solution to this problem that features decentralized controllers and a recommendation mechanism to coordinate adaptation management both on hardware and software. The model also allows to separate application development from self-adaptivity concerns through a goal specification interface. In this paper we refine the model proposed in [1] for applications that are based on component technologies. We also apply the model to the implementation of a self-adaptive video streaming server running on a handheld device. In the cited work the model was validated by simulations. In this work, we provide the main outline of our implementation although it is a work-in-progress.
Abstract: To teach Java programming language better and in a more enjoyable way, we developed a framework for card games that allows students to write and test their own intelligent players. This paper briefly describes the design of the framework, the advantages of using it to assign homework and reports our experience with a class carried out in our institute.
Abstract: Thanks to the HiPEAC collaboration grant that I received in winter 2010, I worked with Emanuele Cannella and Todor Stefanov at LIACS, University of Leiden on the implementation of a task-aware middleware for fault-tolerant and adaptive KPN applications on an FPGA-based NoC platform. This is a summary of my collaboration. The complexity of multiprocessor systems on chip (MPSoCs) is rapidly increasing, driven by the technology improvement and the adoption of more and more complex applications in consumer electronics. Programming such complex systems at a low level of abstraction is extremely difficult and error-prone. A promising way to raise the level of abstraction is using models of computation (MoCs) to specify applications. Among these MoC, Kahn Process Networks (KPNs) have been widely studied and used for streaming/multimedia applications. A favorable feature of the KPN MoC is that its simple operational semantics allows for the easy adoption of system adaptivity mechanisms such as run-time resource management. System adaptivity is becoming increasingly important in the MPSoC domain for several reasons, such as dynamic variation of quality of service requirements, fault tolerance, or power efficiency. Networks-on-Chip (NoCs) are emerging communication infrastructures for MPSoCs that, among many other advantages, allow for system adaptivity. However, there is a mismatch between the generic structure of the NoCs and the semantics of the KPN MoC. Therefore, we investigated and proposed several approaches to overcome this mismatch. All of the proposed approaches consider system adaptivity as a driving objective and do not require specific hardware support from the platform. We proposed and implemented three middleware approaches, namely virtual connector, virtual connector with variable rate, and request-based, to execute Kahn Process Networks on Network-on-Chip architectures. The key differences between these approaches are the rate of acknowledgement of empty slots in the remote queues and the buffering requirement in the sender side. Experimental results on two applications (Sobel and MJPEG encoder) with very different computation and communication characteristics showed that the virtual connector approach outperforms the others in terms of the overhead in the total execution time when implementing communication-dominant applications. However, especially for this kind of applications, the price we pay for system adaptivity and generality is large in terms of performance, if compared to customized point-to-point systems. On the contrary, when the computation/communication ratio of an application is higher, as in the second case study, the overhead introduced by the execution on NoC with all the proposed middlewares is much lower. The overhead in terms of the amount of data transferred in the network is the least for request-based approach for both applications.
Abstract: Moving to custom devices, especially for personal health care, the full design flow of applications needs to be redesigned. One fundamental part of the devices life cycle is maintenance, mainly regarding the software. Software development methodologies provide design flows that can accommodate specification changes such as addition of new features and adaptation to new technologies some time after software has been released. However, these are thought for applications in which changes can be made by using a typical procedure that consists of stopping the system, loading the new program and restarting the system with the new program. This approach is not valid for applications that are meant to run non-stop, such as health care systems. For these applications, there is no solution to on-the-fly updating that is language-, platform- and application domain-independent: due to the complexity of the problem, existing approaches provide solutions to eased problems by narrowing the problem space to some domains of applications. This master thesis explores the problem of on-the-fly programming of embedded systems with the goal of providing general methodologies for enabling on-the-fly programming of safety-critical embedded systems
