Synchronous/Reactive Programming of Concurrent System Software

Synchronous languages are intended for programming reactive systems. Reactive systems, which include real-time systems and key operating system components, interact continually with their environment. This paper considers the applicability of imperative synchronous/reactive languages to the development of general system software, that is, to the implementation of operating system kernels, file systems, databases, networks, server architectures, device drivers, etc. The languages Esterel and Reactive C (RC) receive special attention as Esterel is the oldest and most developed such language and RC is specifically designed for compatibility with C systems programming. An alternative soft-instruction software architecture is described, which is well suited to real-world system programming. © 1997 by John Wiley & Sons, Ltd.     

Telerobotic systems design based on real‐time CORBA

A new class of telerobotic applications is making its way into research laboratories, fine arts or science museums, and industrial installations. Virtual laboratories and remote equipment maintenance are examples of these applications, which are built exploiting distributed computing systems and Internet technologies. Distributed computing technologies provide several advantages to telerobotic applications, such as dynamic and multiuser access to remote resources and arbitrary user locations. Nonetheless, building these applications remains a substantial endeavor, especially when performance requirements must be met. The aim of this paper is to investigate how mainstream and advanced features of the CORBA object‐oriented middleware can be put to work to meet the requirements of novel telerobotic applications. We show that Real‐Time CORBA extensions and asynchronous method invocation of CORBA services can be relied upon to meet performance and functional requirements, thereby enabling teleoperation on local area networks. Furthermore, CORBA services for concurrency control and large‐scale data distribution enable geographic‐scale access for robot teleprogramming. Limitations in the currently available implementations of the CORBA standard are also discussed, along with their implications. The effectiveness and suitability for telerobotic applications of several CORBA mechanisms are tested first individually and then by means of a software framework exploiting CORBA services and ensuring component‐based development, software reuse, low development cost, fully portable real‐time and communication support. A comprehensive telerobotic application built based on the framework is described in the paper and evaluated on both local and wide area networks. The application includes a robot manipulator and several sensory subsystems under concurrent access by multiple competing or collaborating operators, one of which is equipped with a multimodal user interface acting as the master device. © 2005 Wiley Periodicals, Inc.     

Introducing object orientation into large and complex systems

The paper investigates the applicability of the object-oriented technique to large and complex systems as exemplified by the operating system BS2000 which has been under constant development for a number of years. The proposed system architecture ensures the harmonious coexistence of procedural and object-oriented parts of the system. New domains, which are implemented using the object-oriented paradigm, can be smoothly embedded in the existing system. The parallel usage of different implementation languages is rendered economically viable. In our framework some representative parts of the system were redesigned and implemented in a prototype. The extensibility of the design was checked by including further parts into this scheme. The results are encouraging, so that the object-oriented technique will be used in the further development process. The proposed technique can also be applied to systems with a different structure, even a monolithic one     

CORBA在OA中的应用探讨

CORBA是当前非常重要的分布式对象技术之一,它能在分布式异构环境下集成各种不同的应用。针对当前办公自动化中存在的异构问题,提出将CORBA技术应用其中开发异构环境下分布式的办公自动化系统,并结合实例讨论了基于CORBA的办公自动化系统的特点、结构和实现技术。     

Bridging boundaries: CORBA in perspective

Applications that cross the boundaries of different computing machines, operating systems, and programming languages are increasingly the norm. As a result, the need for what might be called bridging technologies to develop software that works across heterogeneous environments has become more compelling. The Common Object Request Broker Architecture is one such technology that is both robust and commercially available. CORBA essentially describes how client applications can invoke operations on server objects using the services of an intermediary known as an Object Request Broker, or ORB. This article introduces CORBA by describing its key components. It then reviews the boundaries it helps to bridge. It concludes by comparing CORBA with a number of other bridging technologies available today     

Distributed Telerobotics System Based on Common Object Request Broker Architecture

This paper proposes using CORBA as communication architecture to integrate network-distributed software and robotic systems in support systems for the aged or disabled. The proposed method keeps system costs low and expands availability. Its high scaling and inter-operating ability allows clients and server objects that are written in different languages, run in different operating systems, and connected to different networks to inter-operate. It also enables the system to be extended and integrated with other technologies and applications distributed over the Internet. Based on CORBA, we developed hardware base including a robot arm and an omnidirectional mobile robot and application servers including a task-level robot arm control server, live feedback image server, mobile robot control server and iGPS server. By remotely controlling mobile robot to cooperate with the robot arm, the caregivers or family member can use the developed system for some basic services to the aged or disabled.     

A taxonomy and survey of grid resource management systems for distributed computing

The resource management system is the central component of distributed network computing systems. There have been many projects focused on network computing that have designed and implemented resource management systems with a variety of architectures and services. In this paper, an abstract model and a comprehensive taxonomy for describing resource management architectures is developed. The taxonomy is used to identify approaches followed in the implementation of existing resource management systems for very large‐scale network computing systems known as Grids. The taxonomy and the survey results are used to identify architectural approaches and issues that have not been fully explored in the research. Copyright © 2001 John Wiley & Sons, Ltd.     

Decentralized event‐triggered control of large‐scale nonlinear systems

This paper studies the decentralized event‐triggered control of large‐scale nonlinear systems. We consider a class of decentralized control systems that are transformable into an interconnection of input‐to‐state stable subsystems with the sampling errors as the inputs. The sampling events for each subsystem are triggered by a threshold signal, and the threshold signals for the subsystems are independent with each other for the decentralized implementation. By appropriately designing the event‐triggering mechanisms, it is shown that infinitely fast sampling can be avoided for each subsystem and asymptotic regulation is achievable for the large‐scale system. The proposed design is based on the ISS small‐gain arguments, and is validated by a benchmark example of controlling two coupled inverted pendulums.     

The implementation and evaluation of the use of CORBA in an engineering design application

Many computer applications today require some form of distributed computing to allow different software components to communicate. Several different commercial products now exist based on the Common Object Request Broker Architecture (CORBA) of the Object Management Group. The use of such tools, however, often requires the modification of existing systems, rather than the development of new applications. The objective of this research has been to integrate the use of a CORBA tool into an existing engineering design application for the purpose of (1) evaluating the amount of re‐engineering that is involved to effectively integrate distributed object computing into an existing application, and (2) evaluating the use and performance of distributed object computing in an engineering domain, which often requires the transfer of large amounts of information. The results of this work demonstrate that CORBA technology can be easily integrated into existing applications. The ease of the integration as well as the efficiency of the resulting system, however, depends upon the degree of modification that developers are willing to consider in the re‐engineering process. The most transparent approach to the use of CORBA requires less modification and generally produces less efficient performance. The less transparent approach to the use of CORBA can potentially require significant system modification but produce greater performance gains. This work outlines issues that must be considered for the partitioning of functionality between the client and the server, development of an IDL interface, development of client and server‐side wrappers, and support for concurrent, multi‐user access. In addition, this work also provides performance and implementation comparisons of different techniques for the use of wrappers and for the transfer of large data files between the client and the server. Performance comparisons for the incorporation of concurrent access are also presented. Copyright © 1999 John Wiley & Sons, Ltd.     

多线程的软件实现

由于多线程能够更好地开发并行性和提高系统性能,在体系结构,操作系统、运行库、程序设计语言各级增加对多线程的支持成为一种趋势。本文从软件的角度分析说明多线程及其在实现上的差异。     

Abstractions for software architecture and tools to support them

Architectures for software use rich abstractions and idioms to describe system components, the nature of interactions among the components, and the patterns that guide the composition of components into systems. These abstractions are higher level than the elements usually supported by programming languages and tools. They capture packaging and interaction issues as well as computational functionality. Well-established (if informal) patterns guide the architectural design of systems. We sketch a model for defining architectures and present an implementation of the basic level of that model. Our purpose is to support the abstractions used in practice by software designers. The implementation provides a testbed for experiments with a variety of system construction mechanisms. It distinguishes among different types of components and different ways these components can interact. It supports abstract interactions such as data flow and scheduling on the same footing as simple procedure call. It can express and check appropriate compatibility restrictions and configuration constraints. It accepts existing code as components, incurring no runtime overhead after initialization. It allows easy incorporation of specifications and associated analysis tools developed elsewhere. The implementation provides a base for extending the notation and validating the model     

A software engineering approach for the development of heterogeneous robotic applications

One of the most evident characteristics of robotic applications is heterogeneity: large robotic projects involve many different researchers with very different programming needs and areas of research, using a variety of hardware and software that must be integrated efficiently (i.e.: with a low development cost) to construct applications that satisfy not only classic robotic requirements (fault-tolerance, real-time specifications, intensive access to hardware, etc.) but also software engineering aspects (reusability, maintainability, etc.). Most existing solutions to this problem either do not deal with such heterogeneity or do not cover specific robotic needs. In this paper we propose a framework for the integration of heterogeneous robotic software through a software engineering approach: the BABEL development system, which is aimed to cover the main phases of the application lifecycle (design, implementation, testing, and maintainance) when unavoidable heterogeneity conditions are present. The capabilities of our system are shown by its support for designing and implementing diverse real robotic applications that use several programming languages (C, C++, JAVA), execution platforms (RT-operating systems, MS-Windows, no operating system at all), communication middleware (CORBA, TCP/IP, USB), and also a variety of hardware components (Personal Computers, microcontrollers, and a wide diversity of sensor and actuator devices in mobile robots and manipulator arms).     

基于CORBA的多层分布式系统研究

CORBA规范实现了分布式系统和面向对象技术的完美结合，实现中使用了代理器，将分布式请求映射到能处理这些请求的实现上，实现不同语言环境（C^ ,Java,Delphi,C等）之间的互调用，并运行在不同的操作系统（如：Windows,Linux,Solaris,Unix等）上，使其灵活运用于多层分布式系统的互操作中。     

一个基于COP的控制软件安全性增强方法

控制软件往往是安全攸关系统的核心,其正确性对系统安全起着至关重要的作用。然而由于系统面对的环境因素越来越复杂,软件设计之初不可能考虑到所有可能面对的环境变化因素,系统的安全性面临新的挑战。因此在软件维护阶段,以环境变化为中心,增量式地增强软件的安全性显得非常重要。面向上下文编程方法(Context-Oriented Programming,COP)正是一种以软件运行上下文环境为中心的编程方法。现有的支撑COP思想的运行机制可以使得系统根据精确的上下文信息动态地调整系统的行为,但是有些上下文引发的系统行为调整会导致系统执行器的现有运行被打断,对于这类影响系统执行器行为的上下文,现有的COP运行机制还没有提供有效处理方法。根据现有的COP方法,给出了一个基于软件上下文保存与恢复的控制软件安全性增强的编程模型,并在LegoNXT控制器上实现了相应的运行支撑和编程工具,通过一个产品分拣系统的安全性增强实例,初步验证了该编程模型的合理性。     

The Real-Time Process Algebra (RTPA)

The real-time process algebra (RTPA) is a set of new mathematical notations for formally describing system architectures, and static and dynamic behaviors. It is recognized that the specification of software behaviors is a three-dimensional problem known as: (i) mathematical operations, (ii) event/process timing, and (iii) memory manipulations. Conventional formal methods in software engineering were designed to describe the 1-D (type (i)) or 2-D (types (i) and (iii)) static behaviors of software systems via logic, set and type theories. However, they are inadequate to address the 3-D problems in real-time systems. A new notation system that is capable to describe and specify the 3-D real-time behaviors, the real-time process algebra (RTPA), is developed in this paper to meet the fundamental requirements in software engineering.RTPA is designed as a coherent software engineering notation system and a formal engineering method for addressing the 3-D problems in software system specification, refinement, and implementation, particularly for real-time and embedded systems. In this paper, the RTPA meta-processes, algebraic relations, system architectural notations, and a set of fundamental primary and abstract data types are described. On the basis of the RTPA notations, a system specification method and a refinement scheme of RTPA are developed. Then, a case study on a telephone switching system is provided, which demonstrates the expressive power of RTPA on formal specification of both software system architectures and behaviors. RTPA elicits and models 32 algebraic notations, which are the common core of existing formal methods and modern programming languages. The extremely small set of formal notations has been proven sufficient for modeling and specifying real-time systems, their architecture, and static/dynamic behaviors in real-world software engineering environment.