By Topic

Object-Oriented Real-Time Distributed Computing, 2002. (ISORC 2002). Proceedings. Fifth IEEE International Symposium on

Date April 29 2002-May 1 2002

Filter Results

Displaying Results 1 - 25 of 62
  • Proceedings Fifth IEEE International Symposium on Object-Oriented Real-Time Distributed Computing. ISIRC 2002

    Save to Project icon | Request Permissions | PDF file iconPDF (470 KB)  
    Freely Available from IEEE
  • Rationale for the direction of the distributed real-time specification for java panel position paper

    Page(s): 258 - 259
    Save to Project icon | Request Permissions | PDF file iconPDF (271 KB)  
    Freely Available from IEEE
  • Author index

    Page(s): 465 - 466
    Save to Project icon | Request Permissions | PDF file iconPDF (237 KB)  
    Freely Available from IEEE
  • Addressing dynamic dispatching issues in WCET analysis for object-oriented hard real-time systems

    Page(s): 109 - 116
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (300 KB) |  | HTML iconHTML  

    There is a trend towards using object-oriented programming languages to develop hard real-time applications. However some object-oriented features, such as dynamic dispatching and dynamic loading, are prohibited from being used in hard realtime systems because they are either unpredictable and/or un-analysable. Arguably, these restrictions could make applications very limited and unrealistic since they could eliminate the major advantages of object-oriented programming. This paper demonstrates how we can address the dynamic dispatching issues in Worst-Case Execution Timing (WCET) analysis with minimum annotations. The major contributions include: discussing the major issues involved in using and restricting dynamic binding features; weakening the restriction of using dynamic dispatching; presenting how to estimate tighter and safer WCET value in object-oriented hard real-time systems. Our approach shows that allowing the use of dynamic dispatching can not only provide a more flexible way to develop object-oriented hard real-time applications, but also does not necessarily result in unpredictable timing analysis View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Handling aperiodic tasks in diverse real-time systems via plug-ins

    Page(s): 137 - 144
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (299 KB) |  | HTML iconHTML  

    Functionality for various services of scheduling algorithms is typically provided as extensions to a basic algorithm. A similar approach dominates operating system functionality: implementation of the actual real-time scheduling algorithm. In this paper, we propose the use of a plug-in approach to add functionality to existing scheduling schemes and provide for easy, replacement on the operating system level. In particular, we present an architecture to disentangle actual real-time scheduling from dispatching and other kernel routines with a small API, suited for a variety of scheduling schemes as plug-ins. We detail two plug-ins for aperiodic task handling and how they can extend two target systems, table-driven and earliest deadline first scheduling, using the approach presented View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A generic approach to structuring and implementing complex fault-tolerant software

    Page(s): 207 - 214
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (279 KB) |  | HTML iconHTML  

    This paper addresses the practical implementation of means of tolerating residual software faults in complex software systems, especially concurrent and distributed ones. There are several inherent difficulties in implementing such fault-tolerant software systems, including the controlled use of extra redundancy and the mixture of different design concerns. In an attempt to minimise these difficulties, we present a generic implementation approach, composed of a multi-layered reference architecture, a configuration method and an architectural pattern. We evaluate our implementation approach using an industrial control application whose control software we equip with the ability to tolerate a variety of software faults. The preliminary evidence shows that our approach can simplify the implementation process, reduce repetitive development effort and provide high flexibility through a generic interface for a wide range of fault tolerance schemes View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Enhancing Real-Time Event Service for synchronization in object oriented distributed systems

    Page(s): 233 - 240
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (297 KB) |  | HTML iconHTML  

    Distributed object computing middleware such as CORBA, RMI, and DCOM have gained wide acceptance and has shielded programmers from many tedious and error-prone aspects of distributed programming. In particular, CORBA event service has been used extensively in embedded systems. We propose an aspect oriented approach to develop synchronization code for distributed systems that use event service as the underlying communication middleware. Our approach is to factor out synchronization as a separate aspect, synthesize synchronization code and then compose it with the functional code. We use high-level "global invariants" to specify the synchronization policies which are then automatically translated into synchronization code for the underlying event service. To implement synchronization efficiently using the event service, we propose enhancements to the semantics of the event service. Specifically, we define the notion of condition events and exactly k semantics. Given these enhancements, we describe a synthesis procedure to translate global invariants into synchronization code based on events. We describe the implementation of the enhancements on the Tao's Real-Time Event Service. We present experimental results to demonstrate that the enhanced event service leads to more efficient implementation of synchronization. We feel that our methodology and the enhanced Real-Time Event Service will lead to more confident use of sophisticated synchronization policies in distributed object oriented systems View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Full text access may be available. Click article title to sign in or learn about subscription options.
  • A component-based approach for embedded software development

    Page(s): 402 - 410
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (349 KB) |  | HTML iconHTML  

    The rapid growth in the demand of embedded systems and the increased complexity of embedded software pose an urgent need for advanced embedded software development techniques. Software technology is shifting toward semi-automated code generation and integration of systems from components. Component-based development (CBD) techniques can significantly reduce the time and cost for developing software systems. However, there are some difficult problems with the CBD approach. Component identification and retrieval as well as component composition require extensive knowledge of the components. Designers need to go through a steep learning curve in order to effectively compose a system out of available components. We discuss an integrated mechanism for component-based development of embedded software. We develop an On-line Repository for Embedded Software (ORES) to facilitate component management and retrieval. ORES uses an ontology-based approach to facilitate repository browsing and effective search. Based on ORES, we develop the code template approach to facilitate semi-automated component composition. A code template can be instantiated by different sets of components and, thus, offers more flexibility and configurability and better reuse. Another important aspect in embedded software is the nonfunctional requirements and properties. In ORES, we capture nonfunctional properties of components and provide facilities for the analysis of overall system properties View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Full text access may be available. Click article title to sign in or learn about subscription options.
  • An architecture-based comparison of verification and statistical reliability assessment methods for embedded software systems

    Page(s): 177 - 180
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (309 KB)  

    Embedded computer systems are used to automate critical real-time applications, including process control systems, manufacturing systems, transportation systems, etc. In order to certify these critical systems, it is necessary to be able to rigorously demonstrate that high quality has been achieved. One approach is to decompose the software into more manageable aspects that can be independently certified. The software architecture is then used to certify the overall system. We compare the efficacy of formal verification and statistical reliability assessment methods for certifying the system based on the certification of the independent aspects and the system architecture View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A technique for managing complexity of use cases for large complex embedded systems

    Page(s): 225 - 232
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (428 KB) |  | HTML iconHTML  

    Modern computer based systems are becoming increasingly complex ensembles of hardware and software; thus adding more challenges to the software requirements engineering process. Although it is well acknowledged in the literature that the use case technique provides a successful requirements engineering tool, there is very little published material on how the use case technique deals with large complex systems. This paper proposes an extension for the use case technique by defining a hierarchical framework for the use cases of large complex embedded systems, and giving some guidance on how to identify actors on different levels. The technique is a result of practical experience with an industrial real-life case study from the aerospace industry View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • On mapping RT-UML specifications to RT-Java API: bridging the gap

    Page(s): 348 - 355
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (445 KB) |  | HTML iconHTML  

    Two recent standards have a great potential to impulse the use of object orientation in the development of real-time applications. The first is the Real-Time Specification for Java (RT-Java), consisting in an application programming interface (API) for real-time object-oriented programming. The other is the emerging RT-UML standard, which addresses the specification of real-time requirements and time using extended UML diagrams. This work proposes an approach for bridging the gap between the two emerging standards, aiming to provide a clear link between the modeled real-time constraints and the programming entities that provide their implementation. The main idea is to enhance the traceability as well as readability of timing constraints from a model-based requirements model to implementation. Relationships between the stereotypes and tags used to decorate the UML diagrams and their code representation are explained. An assessment of the benefits achieved using both standards as well are as some proposed enhancements are also discussed View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A time-triggered Ethernet protocol for Real-Time CORBA

    Page(s): 215 - 222
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (365 KB) |  | HTML iconHTML  

    The Real-Time CORBA and minimum CORBA specifications are important steps towards defining standard-based middleware which can satisfy real-time requirements in an embedded system. This real-time middleware must be based on a real-time operating system (RTOS) and a real-time network. This article presents a new time-triggered Ethernet protocol that has been implemented under RTLinux. Furthermore it describes a Real-Time CORBA implementation called ROFES, which is based on this new real-time network View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • An approach to object-oriented component customization for real-time software development

    Page(s): 429 - 436
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (268 KB) |  | HTML iconHTML  

    To reuse components in component-based real-time software development, especially the ones acquired from external sources, a component must satisfy its real-time constraints, such as thread priority and thread synchronization, to satisfy system real-time requirements. Since real-time applications have various real-time requirements, the ability to customize components for various real-time constraints is needed. Hence, the components to be used in real-time software development must have a set of well-defined features to facilitate component customization. Furthermore, since there are many techniques available for addressing real-time requirements, the features themselves must also be customizable to support these techniques used in a particular type of real-time applications. In this paper, an object-oriented component customization approach, including component customization and framework extension, for real-time applications software development, is presented View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A replication strategy for distributed real-time object-oriented databases

    Page(s): 129 - 136
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (327 KB) |  | HTML iconHTML  

    This paper describes a replication algorithm for distributed real-time object-oriented databases in a static environment. All data requirements are specified a priori, and the algorithm creates replication transactions that copy remote data to a local site in order to guarantee that even, data request reads temporally valid data. The algorithm conditions are proven to be necessary and sufficient for providing this guarantee. Test results indicate that under most conditions, this replication strategy is better than total replication, which is a typical strategy used in distributed databases View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Integrating real-time synchronization schemes into preemption threshold scheduling

    Page(s): 145 - 152
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (398 KB) |  | HTML iconHTML  

    Preemption threshold scheduling (PTS) provides prominent benefits for fixed priority scheduling such as increased schedulability, reduced context switches, and decreased memory requirements. Since such benefits allow for scalable real-time system design, we have adopted it into our automatic implementation synthesis method for real-time object-oriented models. In this paper, we present the integration of real-time synchronization schemes into PTS. Specifically, we investigate how to integrate priority inheritance protocols into preemption threshold scheduling such as the basic priority inheritance protocol and the priority ceiling protocol. In our integrated schemes, (1) the preemption threshold, instead of the priority, of a blocked task is inherited when blocking occurs; and (2) priority ceiling, instead of preemption threshold ceiling is used. We also show that our integrated schemes can minimize worst-case context switches and thus is appropriate for the implementation of real-time object-oriented design models View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • TMO-Linux: a Linux-based real-time operating system supporting execution of TMOs

    Page(s): 288 - 294
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (406 KB) |  | HTML iconHTML  

    The TMO (time-triggered message-triggered object) model is a well-known real-time object model for distributed and timeliness-guaranteed computing. We developed two TMO execution engines, named WTMOS and LTMOS, the former is for Windows platforms and the latter is for Linux platforms. Those are middleware engines supporting deadline driven real-time execution of TMO methods and distributed IPC. The engines have several advantages such as heterogeneous computing support, flexibility, and high portability. However, the deadline-driven schedulers of the middlewares lose temporal accuracy in some cases because the scheduling is performed by controlling priorities of real-time threads. To increase temporal accuracy and reduce overhead by middlewares, we developed a new Linux-based operating system named "TMO-Linux" that supports distributed real-time execution of TMO instances as embedded services of an operating system. In this paper, we present the functions and structure of TMO-Linux. Our preliminary experimental results show that TMO-Linux has better timing accuracy and performance than the middleware engines View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • ARTISST: an extensible and modular simulation tool for real-time systems

    Page(s): 365 - 372
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (416 KB) |  | HTML iconHTML  

    ARTISST (ARTISST is a Real-Time System Simulation Tool) is a modular event-driven simulation framework for real-time systems. It is targeted towards the performance evaluation of complex dynamic real-time systems made of tasks performing arbitrary computations and exhibiting a complex and realistic pattern for their arrival law, synchronization relations, and execution time. The simulator actually focuses on a time-accurate simulation, since it allows, among other things, to take the operating system (including its scheduler) costs into account. Furthermore, thanks to its modular and object-oriented software architecture, the simulator is not dedicated to a particular operating system API, but is fully customizable instead. This paper describes ARTISST, and illustrates its functionalities and customization facilities on two example real-time systems View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Asynchronous transfer of control in the Real-Time Specification for JavaTM

    Page(s): 101 - 108
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (355 KB) |  | HTML iconHTML  

    The Real-Time Specification for Java provides a facility for asynchronous transfer of control based on exception handling and a generalization of the interrupt () method from the Thread class. This mechanism allows the programming of useful idioms such as timeouts and thread termination without the latency found in polling, and it avoids the problems inherent in the Thread class's stop () and destroy () methods View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • OCL goes real-time

    Page(s): 423 - 424
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (224 KB) |  | HTML iconHTML  

    OCL (Object Constraint Language) is becoming an important means to formulate formal specifications in the context of object-oriented software development. The question is whether this approach is appropriate for real-time systems as well. This question is discussed from the point of view of UML/OCL itself but also from an applications point of view View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Distributed simulation of multi-agent hybrid systems

    Page(s): 356 - 364
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (302 KB) |  | HTML iconHTML  

    Systems such as coordinating robot systems, automobiles, aircraft, and chemical process control systems can be modeled as interacting hybrid systems, where hybrid systems are finite state machines with continuous dynamics. The language CHARON and its simulator have been developed to model and analyze interacting hybrid systems as communicating agents. Simulations are widely used for the analyses of hybrid systems. The simulation of a complex system is, however usually very slow. This paper proposes four algorithms for distributed simulations of hybrid systems. The idea behind distributed simulations is to achieve a speedup by utilizing multiple computing resources. The agents of a modeled system are distributed over multiple processors to simulate the agents more efficiently. Since the state of the agent is affected by the input from other agents, they synchronize to update their local states. The challenge here is how to reduce the agent synchronization overhead. We present two approaches for resolving the problem: conservative and optimistic approaches. For the optimistic approach, we present three different algorithms for distributed simulations of hybrid systems, and compare them View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Real-time resource reservation for synchronized multimedia object over wireless LAN

    Page(s): 386 - 393
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (303 KB) |  | HTML iconHTML  

    We propose a proxy-based framework that provides QoS support to mobile users. We describe the overall QoS architecture and implement a number of key QoS functions, including bandwidth allocation and synchronization. In this architecture, admission control is exercised to ensure the long-term availability of resources to mobile clients, where the resources include bandwidth for supporting the required presentation rates and buffer for synchronizing media streams. Bandwidth allocation is implemented in Linux traffic control using stochastic fairness queueing and token bucket filter disciplines to provide bandwidth guarantees for the multimedia connections. An adaptive synchronization technique is also implemented in the proxy to synchronize multiple streams originating from different sources before transmitting them to the clients for presentation. Finally, a number of quality adaptation strategies that accommodate the diverse requirements and capabilities of clients are described View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Aspect-oriented programming with C# and .NET

    Page(s): 241 - 248
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (375 KB) |  | HTML iconHTML  

    Microsoft has introduced the .NET architecture as a new component-based programming environment, which allows for easy integration of classical distributed programming techniques with Web computing. NET defines a type system and introduces notions such as component, object, and interface, which are building blocks for distributed multi-language component-based applications. As many other component frameworks, .NET mainly focuses on functional interfaces of components. Non-functional aspects of components, such as resource usage (CPU, memory), timing behavior, fault-tolerance, or security requirements are currently not expressed in .NET's component interfaces. We discuss the usage of aspect-oriented programming techniques in context of the .NET framework. We focus on the fault-tolerance aspect and discuss the expression of non-functional component properties (aspects) as C# custom attributes. Our approach uses reflection to generate replicated objects based on settings of a special "fault-tolerance" attribute for C# components. We have implemented an aspect-weaver for integration of aspect-code and component-code, which uses the mechanisms of the language-neutral .NET type system. Therefore, our approach is not restricted to the C# language but works for any of the .NET programming languages View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • IKE 2-implementing the stateful distributed object paradigm

    Page(s): 45 - 53
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (298 KB) |  | HTML iconHTML  

    This paper describes IKE 2, distributed object computing middleware that supports the creation of interoperable realtime distributed applications. These applications appear in many domains, such as telecom, aerospace, military testing and training ranges, and financial services. IKE 2 combines the concepts of CORBA distributed objects and anonymous publish-subscribe data dissemination to provide a programming abstraction known as a stateful distributed object (SDO). Every SDO can have both a remote method interface and publication state. The remote method interface allows client applications to invoke methods on target objects efficiently without concern for their location, programming language, OS platform, communication protocols and interconnects, or hardware. The publication state of a given SDO is disseminated to applications that have expressed their interest by subscribing to certain characteristics, such as the type of the SDO. Subscribers can read the publication state of an SDO as if it were a local object. The SDOs provided by the IKE 2 metaobject model support inheritance from other SDOs, containment of other SDOs, and references to other SDOS. IKE 2 is implemented in C++. The API relies heavily on compile-time type-safety to help ensure reliable behavior at runtime-a critical feature of any real-time system. Automatic code generation is used to provide the high-level abstractions without unduly burdening application programmers View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.