http://people.alari.ch/derino/apps/bebop Onur Derin - Publication list en-us http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=Derin.DATE13.MISC http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=DeRaMeTu.PECCS.2013 Self-adaptive systems are able to adapt themselves to mutating internal/external conditions so as to meet their goals. One of the challenges to be tackled when designing such systems is the overhead introduced in making the system monitorable and adaptable. A large overhead can easily compensate the benefits of adaptation. In this work, we are addressing this challenge within the context of KPN applications on NoC-based MPSoCs. In particular, parametric adaptations at the application level are considered. We present a low overhead technique for the implementation of the monitor-controller-adapter loop, which is present in self-adaptive systems. The technique is fundamentally based on an extended network interface which provides the ability to interrupt remote tiles on a NoC-based multiprocessor platform. Results from the MJPEG case study show that the proposed interrupt-based approach incurs an overhead as low as 0.4\% without compromising the quality of the adaptation control. Our new technique provides an improvement of approximately 6.25\% compared to another state-of-the-art technique that interacts with the application using KPN semantics (i.e., blocking channels). Moreover, the sensitivity of the overhead to the complexity of the adaptation controller is much lower in case of our interrupt-based technique as compared to the blocking channel based scheme. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=madness.dsd.2012 Modern embedded systems increasingly require adaptive run-time management. The system may adapt the mapping of the applications in order to accommodate the current workload conditions, to balance load for efficient resource utilization, to meet quality of service agreements, to avoid thermal hot-spots and to reduce power consumption. As the possibility of experiencing run-time faults becomes increasingly relevant with deep-sub-micron technology nodes, in the scope of the MADNESS project, we focus particularly on the problem of graceful degradation by dynamic remapping in presence of run-time faults. In this paper, we summarize the major results achieved in the MADNESS project until now regarding the system adaptivity and fault tolerant processing. We report the first results of the integration between platform level and middleware level support for adaptivity and fault tolerance. A case study demonstrates the survival ability of the platform via a low-overhead process migration mechanism and a near-optimal online remapping heuristic. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=163.DeRaMeCa12.ASE Self-adaptivity is the ability of a system to adapt itself dynamically to internal and external changes. Such a capability helps systems to meet the performance and quality goals, while judiciously using available resources. In this paper, we propose a framework to implement application level self-adaptation capabilities in KPN applications running on NoC-based MPSoCs. The monitor-controller-adapter mechanism is used at the application level. The monitor measures various parameters to check whether the system meets the assigned goals. The controller takes decisions to steer the system towards the goal, which are applied by the adapters. The proposed framework requires minimal modifications to the application code and offers ease of integration. It incorporates a generic adaptation controller based on fuzzy logic. We present the MJPEG encoder as a case study to demonstrate the effectiveness of the approach. Our results show that even if the parameters of the fuzzy controller are not tuned optimally, the adaptation convergence is achieved within reasonable time and error limits. Moreover, the incurred steady-state overhead due to the framework is 4\% for average frame-rate, 3.5\% for average bit-rate, and 0.5\% for additional control data introduced in the network. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=CaDeMeTuSt12.VLSI 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. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=madness-d53 http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=CaDeSt11MISC http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=CaDeSt11.DASIP 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. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=Derin.HIPEACinfo27MISC 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. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=DeKaFi11.NOCS 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. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=Derin.HIPEAC.Chamonix.2011MISC Our work within the MADNESS EU FP7 Project has been presented. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=DeDiFi11.IJRC 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. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=madness-d52 http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=DeFiSaMeSeRa10 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. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=madness-d51 http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=DeDi10 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. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=DeFe10 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. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=DeFe09.2 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. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=DeFe09.3 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. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=DeFe09 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. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=PaDe09 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. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=aether-d413 http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=DeFeTa08 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. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=DeFeTa08.2 http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=DeFe08 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. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=aether-d514 http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=TaFeDe07 http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=Der2007 To teach Java programming language better and in a more enjoyableway, we developed a framework for card games that allows studentsto write and test their own intelligent players. This paperbriefly describes the design of the framework, the advantages ofusing it to assign homework and reports our experience with aclass carried out in our institute. http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=aether-d412 http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=aether-d521 http://people.alari.ch/derino/apps/bebop/index.php?action=showcategory&by=ID&pub=05deriMS 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