Andreas Rasche

Configuration and dynamic reconfiguration of component-based applications with Microsoft .NET

Dynamic reconfiguration provides of powerful mechanism to adapt component-based distributed applications to changing environmental conditions. We have designed and implemented a framework for dynamic component reconfiguration on the basis of the Microsoft .NET environment. Within this paper we present an experimental evaluation of our infrastructure for dynamic reconfiguration of component-based applications. Our framework supports the description of application configurations and profiles and allows for selection of a particular configuration and object/component instantiation based on measured environmental conditions. In response to changes in the environment, our framework will dynamically load new configurations, thus implementing dynamic reconfiguration of an application. Configuration code for components and applications has to interact with many functional modules and therefore is often scattered around the whole application. We use aspect-oriented programming techniques to handle configuration aspects separately from functional code. The timing behavior of dynamic reconfiguration depends heavily on properties of the underlying programming environment and the operating system. We have studied to which extend and with which performance impact the Microsoft .NET Platform/sup 1/ supports dynamic reconfiguration. The paper thoroughly discusses our experimental results.

Dynamic reconfiguration of component-based real-time software

Increasing capabilities of modern microcontrollers greatly increase their applicability to more and more complex scenarios. However, unstable and ever-changing environmental settings require embedded systems permanently to adapt to new situations. Dynamic reconfiguration provides a powerful mechanism to execute such adaptation strategies. The implementation of dynamic reconfiguration is still challenging for embedded real-time control software. Within earlier work we have presented our framework Adapt.NET for runtime adaption of component-based applications, including a runtime infrastructure for dynamic reconfiguration and monitoring, targeted for mobile and desktop environments. New experiments in our Web-based remote laboratory - the distributed control lab - require the reconfiguration to complete in bounded time. In the remote lab we use dynamic reconfiguration to adapt experiment control to failures in user control components. Within this paper, we analyze the timing behavior of the implemented dynamic reconfiguration algorithm in order to allow for predictable execution times. We describe how complex component-based real-time applications can be adapted to changing environmental conditions, continuously meeting all tasks deadlines during dynamic reconfiguration.

ReDAC -- Dynamic Reconfiguration of Distributed Component-Based Applications with Cyclic Dependencies

This paper introduces ReDAC, a new algorithm for dynamic reconfiguration of multi-threaded applications. In order to achieve high reliability and availability, distributed component software has to support dynamic reconfiguration. Typical examples include the application of hot-fixes to deal with security vulnerabilities. ReDAC can be implemented on top of the modern component-platforms Java and .NET. We extend the statical term component, denoting a unit of deployment, to runtime by defining a capsule (runtime component instance) to be a set of interconnected objects. This allows us to apply dynamic updates at the level of components during runtime without stopping whole applications. Using system-wide unique identifiers for threads (logical thread IDs), we can detect and also bring capsules into a reconfigurable state by selectively blocking threads, relying on data structures maintained by additional logic integrated into the capsules using aspect-oriented programming. An important contribution of this paper is that ReDAC supports the dynamic reconfiguration of distributed multi-threaded and re-entrant components with cyclic call dependencies.

Self-adaptive multithreaded applications: a case for dynamic aspect weaving

Shorter product cycles, the requirement for immediate reaction to cyber-attacks and the need for the adaptation to changing environmental conditions demand software reconfigurations to be performed at runtime, in order to reduce downtime. Especially long running applications, which have to provide continuous service should not be restarted for maintenance. They must be updated dynamically.We have developed a reconfiguration strategy allowing to identify valid reconfiguration points even in multithreaded environments, enabling dynamic application updates. The usage of dynamic aspect weaving enables us to transparently create self-adaptive applications without additional compilation steps or programming constraints in the software development process.We demonstrate how our approach can be applied to a real-world retail application of a large logistics company. We will describe the implementation of the reconfiguration aspect and our dynamic aspect weaving tool Rapier LOOM.NET.

Configurable services for mobile users

Mobile devices, such as cellular phones, personal digital assistants (PDAs), and organizers, are becoming increasingly popular. Due to the high volatility of those devices, the achievable quality-of-service (QoS) for mobile services can hardly be predicted. Even for one particular type of device - say a PDA - the implementation of a mobile service may use different communication interfaces over time (i.e.; wireless LAN, IrDA). Within this paper we present a new approach towards configuration of component-based services for mobile systems. Starting from a XML-based configuration language, which defines a set of rules for component configuration depending on a number of environmental parameters, our approach allows for instantiation and configuration of components. In contrast to many other approaches targeting distributed multimedia-style application on PC-class computers, our framework focuses on the extension of distributed services onto mobile devices. As proof-of-concept scenario we have implemented a configurable distributed video surveillance application on the basis of the Microsoft Distributed Component Object Model on Windows 2000 and on the Windows CE-based Pocket PC platform.

Heterogeneous adaptive component-based applications with Adaptive.Net

Adaptation to changing environmental conditions is a major challenge for most distributed applications. The service-oriented programming paradigm leads to an increasing number of applications that are not only meant to provide services through standard user-interfaces hosted on desktop computers, but are to be accessible from small mobile devices as well. The integration of the different programming environments on desktop (i.e.; Windows) and mobile computers (i.e.; Java Micro Editions - J2ME) puts an extra burden on the programmer of this kind of applications. In addition, unstable conditions caused by modern infrastructures for mobile applications and varying properties of computational devices have to be considered during runtime of the application. Dynamic reconfiguration provides a powerful mechanism for adaptive computing. Within this paper, we elaborate on the extension of our previously developed Adaptive.Net framework towards CORBA and Java. With the introduction of new connector types, our framework is able to provide seamless support for adaptive, heterogeneous applications based on .Net, Java, and CORBA. In context of our framework, applications consist of components which interact via so-called connectors. The component/connector model allows for mediating between component frameworks (Java, .Net) as well as between communication protocols (CORBA, .Net Remoting, sockets, etc.). Within the paper we give an overview of our adaptation framework Adaptive.Net, that includes a monitoring infrastructure, a reconfiguration platform and tools for building adaptive applications. Using a proof-of-concept application, we experimentally evaluate our connector architecture and study interoperability of Java, CORBA, and .Net objects.

Real-time robotics and process control experiments in the Distributed Control Lab

The Distributed Control Lab (DCL) provides an open infrastructure for conducting robotics and control experiments over the Internet. It is based on web services technologies and offers a wide range of frontend applications. Within the DCL environment work is focused on safety strategies and mechanisms in order to prevent malicious code from damaging experimental equipment. These include source code analyses, .NET code access security, runtime observation and the dynamic replacement of faculty control algorithms. The .NET framework provides a solid base for a safe execution of user code in the lab. In the Lego .NET experiment work is focused on making the Microsoft .NET run-time available for the DCL Lego Mindstorm robot experiment. A frontend for the GNU Compiler Collection (GCC) has been implemented that translates ECMA intermediate language into native code. This strategy allows the extension of the concept of code access security to embedded devices. Within the paper an overview of the DCLs architecture is presented and the frontends implemented, including a Visual Studio .NET plug-in, are introduced. The installed experiments are introduced and case studies of implemented techniques to ensure their and the DCLs safety are described.

Predictable interactive control of experiments in a service-based remote laboratory

Remote and virtual laboratories are commonly used in electronic engineering and computer science to provide hands-on experience for students. Web services have lately emerged as a standardized interfaces to remote laboratory experiments and simulators. One drawback of direct Web service interfaces to experiments is that the connected hardware could be damaged due to missed deadlines of the remotely executed control applications. Within this paper, we suggest an architecture for predictable and interactive control of remote laboratory experiments accessed over Web service protocols. We present this concept as an extension of our existing Distributed Control Lab infrastructure. Using our architecture, students can conduct complex control experiments on physical experiments remotely without harming hardware installations.

Towards a real-time implementation of the ECMA Common Language Infrastructure

In the development of embedded systems, higher-level programming languages have become popular because they often induce higher developer productivity. Tool developers desiring to offer support for such languages need to solve various problems; in particular, they need to support the creation of realtime systems. In this paper, we present an approach for supporting real-time capabilities in C# and, consequently, the Common Language Infrastructure

Hardware-Near Programming in the Common Language Infrastructure

Virtual machine-based programming languages, such as Java and C # have made the programming of desktop computer systems simpler, less error-prone and more efficient. Embedded systems development rarely benefits from this advantages. This is because the disciplines special needs, such as direct hardware access and timelininess, are rarely considered in these environments. In particular, virtual machines usually do not allow for accessing hardware directly, making it impossible to express substantial parts of embedded systems inside the virtual environment. By specifying additional rules, describing an implementation of a conforming compiler, and presenting examples, we show how the virtual machine defined by the ECMA standard 335 can be carefully extended to support hardware-near programming