No full-text available
To read the full-text of this research,
you can request a copy directly from the author.
The ADAPTIVE Communication Environment
Abstract
The ADAPTIVE Communication Environment (ACE) is an object-oriented (OO) toolkit that implements fundamental design patterns for communication software. ACE is targeted for developers of high-performance communication services and applications on UNIX and Win32 platforms. ACE simplifies the development of OO network applications and services that utilize interprocess communication, event demultiplexing, explicit dynamic linking, and concurrency. ACE automates system configuration and reconfiguration by dynamically linking services into applications at run-time and executing these services in one or more processes or threads. This paperdescribes the structure and functionality of ACE and illustrates core ACE features using examples from domains like telecommunications, enterprise medical imaging, and WWW services. ACE is freely available and is being used for many commercial projects (such as Ericsson, Bellcore, Siemens, Motorola, Kodak, and McDonnell Douglas), as well as many academic ...
... The internally visible stable interface to the user code also provides operating system independent representations of the most often needed artefacts like threads, timer, synchronization mechanisms, memory access etc. Since these are based on ACE [Schmidt, 2009, Schmidt & Huston, 2002, Schmidt & Huston, 2003, they are also stable across nearly all relevant operating systems in use. User code can comprise any number of threads and can include any kind of existing libraries. ...
... Therefore, the message based protocol of SMARTSOFT can be mapped onto all kinds of different middleware systems with all kinds of different characteristics. The CORBA based mapping is detailed in [Schlegel, 2004] and the ACE [Schmidt, 2009] based mapping in [Schlegel & Lotz, 2010]. Figure 16: The development process at-a-glance. ...
... Los entornos ICE y CORBA se basan en el uso de "mediadores de objetos" (Object Request Broker: ORB) que permiten el manejo de referencias a objetos distribudos. Las soluciones "Common ORB" basadas en el ORB de ACE, TAO [7] que se sustenta sobre el framework ACE (Adaptive Communication Environment) [8]. Para proporcionar al sistema tolerancia a fallos o mecanismos de adaptación es necesario que el middleware tenga mecanismos de monitorización y medida de indicadores de rendimiento. ...
... Il s'appuit sur un méta-modèle appelé SmartMars (Modeling and Analysis of Robotic Systems)[128] implémenté sous forme de profil UML, et a servi de base pour construire un outil intégré à Eclipse appelé SmartMDSD (Model Driven Software Design)[143]. Ce dernier offre un environnement de développement intégré pour les logiciels robotiques selon une approche dirigée par les modèles et permet de générer du code vers CORBA (Common Object Request Broker Architecture)[1] et ACE (Adaptive Communication Environment)[129]. ...
Avec la construction des robots de plus en plus complexes, la croissance des architectures logicielles robotiques et l’explosion de la diversité toujours plus grande des applications et misions des robots, la conception, le développement et l’intégration des entités logicielles des systèmes robotiques, constituent une problématique majeure de la communauté robotique. En effet, les architectures logicielles robotiques et les plateformes de développement logiciel pour la robotique sont nombreuses, et sont dépendantes du type de robot (robot de service, collaboratif, agricole, médical, etc.) et de son mode d'utilisation (en cage, d’extérieur, en milieu occupé, etc.). L’effort de maintenance de ces plateformes et leur coût de développement sont donc considérables.Les roboticiens se posent donc une question fondamentale : comment réduire les coûts de développement des systèmes logiciels robotiques, tout en augmentant leur qualité et en préservant la spécificité et l’indépendance de chaque système robotique? Cette question induit plusieurs autres : d’une part, comment décrire et encapsuler les diverses fonctions que doit assurer le robot, sous la forme d’un ensemble d’entités logicielles en interaction? Et d’autre part, comment conférer à ces entités logicielles, des propriétés de modularité, portabilité, réutilisabilité, interopérabilité, etc.?A notre avis, l’une des solutions les plus probables et prometteuses à cette question consiste à élever le niveau d’abstraction dans la définition des entités logicielles qui composent les systèmes robotiques. Pour ce faire, nous nous tournons vers l’ingénierie dirigée par les modèles, et plus particulièrement la conception des DSML (Domain Specific Modeling Language).Dans cette thèse, nous réalisons dans un premier temps, une étude comparative des langages de modélisation et de méthodes utilisés dans le développement des systèmes embarqués temps réel en général. L’objectif de ce premier travail étant de voir s’il en existe qui puissent permettre de répondre aux questions susmentionnées des roboticiens. Cette étude, non seulement nous montre que ces approches ne sont pas adaptées à la définition des architectures logicielles robotiques, mais elle aboutit surtout à unFramework, que nous proposons et qui aide à choisir la (les) méthode(s) et/ou le(s) langage(s) de modélisation le(s) plus adapté(s) aux besoins du concepteur. Par la suite, nous proposons un DSML baptisé RsaML (Robotic Software Architecture Modeling Language), pour la définition des architectures logicielles robotiques avec prise en compte de propriétés temps réel. Pour ce faire, un méta-modèle est proposé à partir des concepts que les roboticiens ont l’habitude d’utiliser pour la définition de leurs applications. Il constitue la syntaxe abstraite du langage. Les propriétés temps réel sont identifiées à leur tour et incluses dans les concepts concernés. Des règles sémantiques du domaine de la robotique sont ensuite définies sous forme de contraintes OCL, puis intégrées au méta-modèle, pour permettre que des vérifications de propriétés non fonctionnelles et temps réel soient effectuées sur les modèles construits. Le Framework de modélisation EMF d’Eclipse a été utilisé pour mettre en oeuvre un éditeur qui supporte le langage RsaML.La suite des travaux réalisés dans cette thèse a consisté à définir des transformations de modèles, puis à les utiliser pour implémenter des générateurs. Ces derniers permettent à partir d’un modèle RsaML construit, d’une part, de produire sa documentation et, d’autre part, de produire du code source en langage C. Ces contributions sont validées à travers un cas d’étude décrivant un scénario basé sur le robot Khepera III.
... ICE and CORBA frameworks, both of them, make use of an Object Request Broker (ORB) that defines the interface for exchanged objects. Common ORB solutions are based on "The ACE ORB" (TAO) [7] which relies on the Adaptive Communication Environment (ACE) framework [8]. In order to bring the system a fault-tolerance and/or adaptation mechanisms it is need to offer the proper mechanisms to measure the performance. ...
In the current context of distributed systems, the communications have moved from a model based on connected nodes, to a model that must connect processes, or including connect data. There are many paradigms, mechanisms and architectures to give support to these distributed systems. Most of these mechanisms are extensions or evolutions of distributed node based architecture where the knowledge about the physical node is necessary. To isolate communications from the physical aspects of distributed systems a middleware, centered on the data, and oriented to connect processes has been developed. The middleware, called “CKMultipeer”, allows processes to communicate data between them. Communication is integrated without worrying about the network configuration and management. This article describes the implementation of the middleware, as well as the tests developed. Through the design of a graphical interface, the communications performance is analyzed.
... Libraries like Pthreads [19] and ACE [110] support semaphores. After Concurrent Pascal [52] introduced support for monitors, other programming languages supported monitor as well. ...
L’utilisation de concepts avancés de programmation concurrente permet de dépasser les inconvénients de l’utilisation de techniques de bas niveau à base de verrous ou de moniteurs. Elle augmente le niveau d’abstraction, libérant les programmeurs d’applications concurrentes d’une focalisation excessive sur des détails. Cependant, avec les approches actuelles, la logique nécessaire à la mise en place de schémas de coordinations complexes est fragmentée en plusieurs points de l’application sous forme de« join patterns », de notifications et de la logique applicative qui crée implicitement des dépendances entre les canaux de communication et donc, indirectement, les « join patterns » (qui définissent ces canaux). Nous présentons JEScala, un langage qui capture les schémas de coordination (d’une application concurrente) d’une manière plus expressive et modulaire, en s’appuyant sur l’intégration fine d’un système d’évènements avancé et des « join patterns ». Nous implémentons des automates finis à partir de « joins » à l’aide de JEScala et introduisons un langage dédié à la définition de ces automates finis permettant d’en obtenir des implémentations plus efficaces. Nous validons notre approche avec des études de cas et évaluons l’efficacité de son exécution. Nous comparons la performance de trois implémentations d’un automate fini. Nous validons enfin l’idée d’un moniteur d’évènements en créant un programme JEScala concurrent à partir d’un découpage d’un programme séquentiel.
... ICE, CORBA, and DDS all of them make use of an Object Request Broker (ORB) which defines the interface for exchanged objects.The use of an ORB provide end-to-end Quality of service (QoS). Most ORB implementations are based on The ACE ORB (TAO) [17] which, as can be noticed in its name, is built on the Adaptive Communication Enviroment (ACE) framework [16].However the most evolved of them is DDS which is created with the prpose of standardize data distribution frameworks. DDS provides a high performance QoS-based service which offers a very adaptable communication. ...
This paper presents a control kernel based middleware description. Capabilities and developed functionality are enhanced. The establishment of a event-based middleware control system offers a more reliable and efficient way to perform control tasks by ensuring a proper distribution of the requirements, actions and services between the system devices according to their availability of resources. Middleware is able to perform its capabilities over a distributed or partitioned system allowing to the programmer the control application design from a topology-independent point of view of the whole system. Quality of service (QoS) concept are introduced in data exchange providing a real-time communications between nodes. Data distribution system (DDS) is used as base to achieve this reliable communications. A user interface has been designed to help the programmer in the middleware configuration task.
... In particular we found it convenient to base our implementation on ACE, an open-source library that among many things provides a tiny object-oriented OS wrapper. For more information about ACE see (Schmidt, 2003;Schmidt and Huston, 2002). ACE runs on Windows, Linux, and QNX that were also our target operating systems. ...
... The good news, however, is that the lower-level aspects of computer representation and native hardware representation are most often already taken care of by middleware, frameworks or operating systems 3 on top of which robotics and automation components are typically built. At those lower levels, some relevant standards exist already, such as CORBA [12], and several open source projects provide quite usable (but incompatible) implementations, e.g., [2,6,13]. In addition, some major mathematical representations that are relevant in the component standardization context are quite well developed, (i.e., they have well-defined semantics, mathematically verifiable implementations, and design and code generation tools): ...
This paper presents a strategy to design standards for software libraries in robotic systems (or rather, in large-scale engineering systems in general). The strategy involves the separation between objects (algorithmic functionality and single-activity behaviour) and components (multi-activity in- teraction architecture and behaviour), and the introduction of four complementary levels in software standardization, in order to develop standards that are consistent and stable enough to survive the never-ending evolution in the domain of robotics. The major motivation behind the standards-making strategy is decoupling: (i) to divide the domain to be standardised into a family of complementary sub- standards (either hierarchically ordered, or unconnected) that are each as small as naturally possible, and that can be combined in various ways according to the needs of specic application domains; and (ii) to separate the abstract programming interface of each library from its concrete implementation(s). These standardization suggestions could inspire many (Open Source) robotics software projects, enhancing their interoperability.
... The Flow Meter makes use of the ACE library/toolkit [4]. We use this toolkit to provide C++ wrappers around common network functionality (sockets) as well as to provide tools to aid thread creation, thread management and inter-thread communication. ...
The Automated Network Games Enhance-ment Layer (ANGEL) project aims to leverage Machine Learning (ML) techniques to automate the classification and isolation of interactive (e.g. games, voice over IP) and non-interactive (e.g. web) traffic. This information is then used to dynamically reconfigure the network to improve the Quality of Service provided to the current interactive traffic flows and subsequently deliver improved perfor-mance to the end users. Within this scope, the project will develop protocols that allow the adjustment of Consumer Premise Equipment (CPE -eg. cable/ADSL) configuration to provide better quality of service to interactive flows detected in real-time. This document describes the basic design motivation of the Flow Meter Software Component of ANGEL. The Flow Meter is responsible for capturing packets off a network connection, collating the statistical properties and forwarding this information to the Flow Classifier Component.
... All portability issues are now isolated to the FSL, freeing the maintainers of the legacy system and the developers of replacements systems to focus upon application-oriented issues. We are building the FSL on top of Doug Schmidt's ACE toolkit [Schmidt, 1999]. ...
Mature information systems grow old disgracefully as successive waves of hacking result in accidental architectures which resist the reflection of on-going business process change. Such petrified systems are termed legacy systems. Legacy systems are simultaneously business assets and business liabilities. Their hard-won dependability and accurate reflection of tacit business knowledge prevents us from undertaking green-field development of replacement systems. Their resistance to the reflection of business process change prevents us from retaining them. Consequently, we are drawn in this paper to a controlled pattern-oriented legacy system migration strategy. Legacy systems exhibit six undesirable anti-patterns. A legacy system migration strategy must focus upon the controlled elimination of these anti-patterns by the step-wise application of six corresponding desirable patterns. Adherence to this migration strategy results in adaptive systems reflecting purposeful architectures open to the on-going reflection of business process change. Without such a strategy there is a very real danger that legacy system migration will occur all too literally. That is, the old legacy system will be migrated to a new legacy system albeit it one using the latest buzzword-compliant technology.
... Other frameworks for engineering applications are the proposals by [5,21,29,39,47] for numerical simulation and finite elements. Frameworks with similar capabilities abound in other domains: network [41] and communication [40] software, graphical modeling [46], and software development tools [13]. ...
We present an object-oriented framework, named
DOOLINES
, for non-linear static and dynamic analyses of slender marine structures which often appear in offshore structures employed in the petroleum and gas industries as, among others, flexible risers, steel catenary risers, umbilicals, floating hoses, and mooring lines.
DOOLINES
allows the rapid development of tailored, modular, reusable and extensible large-size systems, being itself extensible. These properties, along with the ease of use of our framework, are assessed by means of case studies. Code examples are provided.
... We built the dynamicTAO components using the ACE wrappers [5] for operating system services. Thus, dynamicTAO runs on the several different platforms to which ACE was ported. ...
Conventional middleware systems fail to address important issues related to dynamism. Modern computer systems have to deal not only with heterogeneity in the underlying hardware and software platforms but also with highly dynamic environments. Mobile and distributed applications are greatly affected by dynamic changes of the environment characteristics such as security constraints and resource availability. Existing middleware is not prepared to react to these changes.
In many cases, application developers know when adaptive changes in communication and security strategies would improve system performance. But often, they are not able to benefit from it because the middleware lacks the mechanisms to support monitoring (to detect when adaptation should take place) and on-the-fly reconfiguration.
dynamicTAO is a CORBA-compliant reflective ORB that supports dynamic configuration. It maintains an explicit representation of its own internal structure and uses it to carry out runtime customization safely. After describing dynamicTAO’s design and implementation, we discuss our experience on the development of two systems benefiting from the reflective nature of our ORB: a flexible monitoring system for distributed objects and a mechanism for enforcing access control based on dynamic security policies.
... In addition, developers often have to learn the language of the framework's domain which describes the abstractions and range of functionality available (Bosch et al. 1999). In recent years application frameworks have emerged that address a wide range of domains, for example network communications (Schmidt 2005), graph modelling (White et al. 2005) drawing editors (Gamma and Eggenschwiler 2005), middleware, e.g. CORBA (OMG 2005a), and program development environments, e.g. ...
This paper describes the results of a long-term empirical investigation into object-oriented framework reuse. The aim is to
identify the major problems that occur during framework reuse and the impact of current documentation techniques on these
problems. Four major reuse problems are identified: understanding the functionality of framework components; understanding
the interactions between framework components; understanding the mapping from the problem domain to the framework implementation;
understanding the architectural assumptions in the framework design. Two forms of documentation are identified as having the
potential to address these problems, namely pattern languages and micro-architecture descriptions. An in-depth, qualitative
analysis suggests that, although pattern languages do provide useful support in terms of introducing framework concepts, this
can be bypassed by developers using their previous knowledge, occasionally to the detriment of the final solution. Micro-architecture
documentation appears to provide support for simple interaction and functionality queries, but it is not able to address large
scale interaction problems involving multiple classes within the framework. The paper concludes that, although a combination
of pattern language and micro-architecture documentation is useful for framework reuse, the forms of these documentation types
used in this study require further enhancement to become effective. The paper also serves as an example to encourage others
to perform evaluation of framework understanding and documentation.
... Two open-source reference implementations are available. The first implementation is based on CORBA (ACE/TAO) and the second one on ACE [32] only. ...
The development of service robots has gained more and more attention over the last years. A major challenge on the way towards industrial-strength service robotic systems is to make the step from code-driven to model-driven engineering. In this work we propose to put models into the focus of the whole life-cycle of robotic systems covering design-time as well as run-time. We describe how to explicate parameters, properties and resource information in the models at design-time and how to take these information into account by the run-time system of the robot to support its decision making process. We underpin our work by an exhaustive real-world example which is completely developed with our tools.
... Most of these works hardly propose effective changes on the traditional service lifecycle, solely focusing on techniques for speeding the service development process. Such techniques include the use of design patterns applied to the domain of service construction [15], languages for modeling services [18] and programming libraries together with extensions in operating systems [9][20]. Despite their relevance, all these techniques do not take into account adaptations accomplished during service operation. ...
One of the main challenges in the telecommunication sector has been to devise communication environments that allows: (i)
the integration of a multitude of different services in a single and efficient communication system, and (ii) the rapid and
easy creation, modification and continuous adaptation to new demands and conditions. In this paper, we present a recursive-structuring
model that gives adequate support for defining both communication environments and their adaptation mechanisms. Second, we
propose the use of frameworks as powerful artifacts that can help a service designer delineate common abstractions that appear
within any communication environment, allowing design reuse. Finally, we discuss the role of software architecture, and more
precisely of ADLs, as an appropriate way to describe communication environments according to the model and frameworks mentioned
above.
... ACE [6] focuses on module details whereas PEPt focuses on the top-level picture in order to guide the overall structuring of a system. RM-ODP's [7] engineering viewpoint channel model is similar to PEPt but does not define important interactions such as how two binding objects interact. ...
Requirement: Users of remoting systems (e.g., RPC and Messaging) want to concentrate on the data being sent. They should not have to use a different programming model just to use a different protocol. Problem: Remoting systems need to support alternate encodings, protocols and transports, either because of evolving standards or through dynamic negotiation with a peer. Solution: This paper has two main ideas. First, it clearly partitions a remoting system into four main blocks: presentation, encoding, protocol and transport. It identifies the extensibility points, the responsibilities and interactions of those blocks. Second, it shows how, for each message arriving on a connection accepted and created by an Acceptor, the Acceptor acts as a factory for specific encoders and protocol handlers. Thus a remoting system can dynamically adapt to new encodings, protocols and transports without changing the programming model presented to the programmer. Experience: We have used this model to adaptively alternate between XML and binary encoding, protocol and transport combinations in an RMI system. We show size and performance results for these combinations. Conclusion: This model isolates change from the remoting system user while allowing common remoting infrastructure to be extended and reused. The model does not degrade performance.
... ACE [3], the ADAPTIVE (A Dynamically Assembled Protocol Transformation, Integration, and eValuation Environment ) Communication Environment, is an objectoriented network programming framework that implements many core patterns useful in network applications, especially those that make use of concurrency. The target audience of ACE includes developers of highperformance and real-time network applications, but ACE is generally applicable to a wide range of networkprogramming problems. ...
Network protocols such as the File Transfer Protocol (FTP) have been vital to the success of the Internet. Network operating systems have developed APIs to allow application programmers to easily implement these protocols. The most popular API in usage today is the BSD Sockets API. This API provides low-level operations for performing connection establishment, message transmission and reception and provides ways to configure various low-level network parameters. However, this low-level API forces network programmers to duplicate code in and between applications, lends itself very poorly to common Object-Oriented and Pattern-Oriented software design
... Two reference implementations are available on sourceforge [24]. The first implementation is based on CORBA and the second one on ACE [25] only. Consequently, we propose SMARTMARS (Modeling and Analysis of Robotic Systems) (fig. ...
Engineering the software development process in robotics is one of the basic necessities towards industrial-strength service robotic systems. A major challenge is to make the step from code-driven to model-driven systems. This is essential to replace hand-crafted single-unit systems by systems composed out of components with explicitly stated properties. Furthermore, this fosters reuse by separating robotics knowledge from short-cycled implementational technologies. Altogether, this is one but important step towards "able" robots. This paper reports on a model-driven development process for robotic systems. The process consists of a robotics metamodel with first explications of non-functional properties. A model-driven toolchain based on Eclipse provides the model transformation and code generation steps. It also provides design time analysis of resource parameters (e.g. schedulability analysis of realtime tasks) as a first step towards overall resource awareness in the development of integrated robotic systems. The overall approach is underpinned by several real world scenarios. Comment: 6 pages; 1st International Workshop on Domain-Specific Languages and models for ROBotic systems (DSLRob'10), October 2010
The development of service robots has gained more and more attention over the last years. A major challenge on the way towards industrial-strength service robotic systems is to make the step from code-driven to model-driven engineering. In this work we propose to put models into the focus of the whole life-cycle of robotic systems covering design-time as well as run-time. We describe how to explicate parameters, properties and resource information in the models at design-time and how to take these information into account by the run-time system of the robot to support its decision making process. We underpin our work by an exhaustive real-world example which is completely developed with our tools.
The iCub robot is a humanoid robot that have been developed at the Italian Institute of technology and University of Genoa, with the purpose to carry out research in embodied cognition. More precisely, the iCub robot is the result of a research project focusing on the study of developmental capabilities of cognitive systems. This project, called RobotCub, has been funded by the European Commission through Unit E5 Cognitive Systems, Interaction & Robotics (see [6, 9, 10, 15, 16]). In the framework of embodied cognition, perception covers a fundamental role in robot learning and development. They are in fact the result of the continuous interaction with the environment, which is necessary to build the basis to abstract reasoning. To achieve learning capabilities and self development and reasoning, anthropomorphism, compliance and sensorization are fundamental. These aspects are necessary to study human and humanoid development. To allow the robot to become a self-reasoning system, the basic perceptual aspects of human become requisites of the design process of a humanoid platform. The main features characterizing the design of the iCub robot, including the choice of the sensors the robotic platform is equipped with, are therefore here presented.
The chapter presents an overview of the hardware and software architecture of the iCub robot. In particular, it shows the way the code to perform torque feedback and active compliance control have been implemented. Qualitative peformances of the implemented methodologies are reported by means of a comparison of the virtal sensor method, with mechanical joint torque sensors and additional external FTS. Based on the YARP famework, a set of modules perform the estimation of joint torques, of external forces and of gravity compensation terms have been implemented. The implementation of these YARP modules are finally reported.
Component Based Software Engineering is a common approach to master complexity in service robotic systems. Moreover, these systems must be robust and safe. Common robotic middlewares and frameworks provide component models with well defined communication mechanisms. However, generic means are missing to gain insight into running components. Components must be monitored (i) during their development for debugging purposes, (ii) during their integration into a system for verification and error detection purposes and (iii) at runtime for administration and online diagnosis purposes. This paper presents a generic concept for runtime monitoring of robotics software components which is independent of any specific robotic middleware and framework. After that, a reference implementation shows a concrete integration of the concept into the SmartSoft component model. Two real world scenarios at the end demonstrate the usage of monitoring.
Update in maintenance, which is an important step in the software development cycle, is an necessary support of almost all the software in various application fields. Online update, which can reduce the cost and is convenient to the customer, is of great practical value. An idea of software update program, which can run across platforms, is brought forward and realized in this paper. The device of this program is mean to update across platforms, reduce the artifacial participation in update, and increase the ability of reuse of this program.
The ACS is a CORBA-based control system framework with all features expected from a modern control system. It has been recently installed at the ANKA light source in Karlsruhe, Germany and is being used to develop the ALMA control system. ALMA is a joint project between astronomical organisations in Europe, USA and Japan and will consist of 64 12-meter sub-millimetre radio telescopes. ACS provides a powerful XML-based configuration database, synchronous and asynchronous communication, configurable monitors and alarms that automatically reconnect after a server crash, run-time name/location resolution, archiving, error system and logging system. Furthermore, ACS has built-in management, which allows centralized control over processes with commands such as start/stop/reload, send message, disconnect client, etc. and is fine-grained to the level of single devices. ACS comes with all necessary generic GUI applications and tools for management, display of logs and alarms and a generic object explorer, which discovers all CORBA objects, their attributes and commands at run-time and allows the user to invoke any command. A Visual configuration database editor is under development. An XML/XSLT generator creates an Abeans plug for each controlled object, giving access to all Abeans applications such as snapshot, table, GUI panels, and allowing one to use the CosyBeans GUI components for creating Java applications. For those that write their own control system, ACS allows to define own types of controlled data and own models of communication, yet use powerful support libraries as long as one adheres to some rules in the form of programming patterns. ACS users several standard CORBA services such as notification service, naming service, interface repository and implementation repository. ACS hides all details of the underlying mechanisms, which use many complex features of CORBA, queuing, asynchronous communication, thread pooling, life-cycle management, etc. Written in C++ and using the free ORB TAO, which is based on the operating system abstraction platform ACE, ACS has been ported to Windows, Linux, Solaris and VxWorks. The applications are written in Java and run on any JVM -enabled platform. ACS is based on the experience accumulated with similar projects in the astronomical and particle accelerator communities, reusing and extending concepts and components of implementation. Although designed for ALMA, ACS has the potential for being reused in other new control systems, as proven by the nearly seamless installation at the ANKA this spring.
Vital functions of robots are provided by software and software dominance is still growing. Mastering the software complexity is not only a demanding but also indispensable task towards an operational robot. Component based software approaches provide suitable means to master the complexity issue. Nevertheless shareable, distributable and reusable off-the-shelf software components for robotics are still a great dream. One of the reasons is the lack of a software component model taking into account robotics needs. The challenge of component based software approaches for robotic systems is to assist in building a system and to provide a software architecture without enforcing a particular robot architecture.
This paper presents communication primitives as core of a robotics component model. Dynamic wiring of components at run-time is explicitly supported by a separate pattern which tightly interacts with the communication primitives. This makes the major difference to other approaches. Advantages provided are software reuse, improved maintainability and software reconfiguration on-the-fly. The presented approach already proved its fitness in several major projects. The CORBA based implementation is freely available and is maintained and continued as part of the open source project OROCOS [1,9].
Die Erschließung breiter Anwendungspotenziale für Serviceroboter erfordert den Schritt weg von manuell erstellten Einzelentwürfen
hin zu baukastenartig zusammengesetzten Systemen. Grundlegend hierfür ist der Schritt weg von codezentrierten hin zu modellgetriebenen
Systemen. In modellgetriebenen Ansätzen wird langlebiges Lösungswissen von kurzlebigen Implementierungstechnologien entkoppelt.
Durch das Explizieren von Eigenschaften wie Ressourcenbedarf und Kommunikationsverhalten wird die Systemebene adressiert,
so dass Zusammensetzbarkeit von ausgereiften Komponenten ebenso unterstützt werden kann wie der Nachweis von Systemeigenschaften.
Die so möglichen ressourcenadäquaten Lösungen mit zugesicherten Eigenschaften und der Wiederverwendung ausgereifter Lösungen
wird als grundlegend für die effiziente Umsetzung der geforderten Qualitätsmaßstäbe vieler zukünftiger Servicerobotikapplikationen
gesehen. Diese Arbeit beschreibt die Umsetzung eines modellgetriebenen Softwareentwicklungsprozesses in OpenArchitectureWare
auf der Basis eines Komponentenansatzes und eines Ausführungscontainers, der beispielsweise völlig unabhängig von der Middleware
ist.
In this paper we present a distributed computing system designed to provide computational resources to a mobile robot. The described system offers simple programming and debugging, easy modification of the data types coming from sensors, high computation power obtained by distributing the computation on remote nodes, portability and low overhead, making it well suited for imple-menting AI applications in the robotic domain. We developed an XML-based language, called XML-VM, that enables to transfer among remote machines not only the data to be processed, but also the algorithms by which they have to be processed. All the code implementing the system is written in ANSI C++ for efficiency and portability reasons. We applied the system to the problem of image based localisation of a mobile robot using the properties of the Fourier transform of omnidirectional images. The image based localisation task is demanding in terms of computational power and memory requirements; therefore it is well suited to the described system. Ex-perimental results for off-line robot localisation are reported in terms of absolute time and relative speed-up, confirming the high performances of the system.
In this paper we describe the architecture of an IKEv2 pro-tocol implementation. The architecture has been designed with the aim to make the implementation meet a number of good characteristics: to be as fast as possible, scalable, easy to understand and enhance, as well as portable across different operating systems and processor architectures. As a byproduct we endeavored to specify an architectural pat-tern that might be used to build other, similar network pro-tocols. In order to make this pattern even more attractive, parts of the architecture are separated as a generic software framework, thus allowing reuse of the code base. The im-plementation itself is written in the C programming lan-guage but borrows some of the concepts from object ori-ented programming. More specifically, it both enforces the access to private data structures of the different modules and uses messages, i.e. objects, to communicate different events among subsystems.
Performance analysis of parallel applications can be a time-consuming and daunting task, as it requires detailed a understanding
of the interactions of the system’s components. We present the design and the prototypical implementation of a system for
the automation of the performance analysis process developed within the Peridot project. Our system is based on the notion
of cooperating agents that detect performance problems automatically at runtime and in a distributed fashion, avoiding several
problems of classical performance analysis techniques such as overwhelmingly large trace files.
Performance engineering of parallel and distributed applications is a complex task that iterates through various phases, ranging from modeling and prediction, to performance measurement, experiment management, data collection, and bottleneck analysis. There is no evidence so far that all of these phases should/can be integrated in a single monolithic tool. Moreover, the emergence of Cloud computing as well as established Grid infrastructures as a wide-area platform for high-performance computing raises the idea to provide tools as interacting Web services that share resources, support interoperability among different users and tools, and most important provide omni-present services over Grid or Cloud infrastructures.
This paper presents the Light Communication (LiCo) library, designed to implement communications primitives based on permanent,
point-to-point, bi-directional channels. LiCo, using the standard TCP layer, allows the interoperability of different computing
systems. LiCo library has been designed to be as simple as possible, hiding to the programmers all the unnecessary details
connected to initializations and HW heterogeneity management. We report results in the ping/pong test performed between different
systems connected through different communication media and we compare, on the same ping/pong, LiCo performances with the
ones achieved by PVM and by straight socket communications.
Programming robotic systems is not an easy task, even developing software for simple systems may be difficult, or at least
cumbersome and error prone. In this document it is presented a C++ distributed component based programming framework for robotics
socalled CoolBOT, around which we have started an open source initiative which is freely available via www.coolbotproject.org termed The
CoolBOT
Project. This framework, started initally as a framework for easy software integration in robotics, has been improved in order to
allow, not only easy integration using the CBSE paradigm, but also transparent distributed system computation.
In this paper we describe an application model for seamless mobile data access using handheld devices and wireless links. We go beyond the current model in which handhelds are used as smart organizers augmented with stripped down versions of popular desktop programs. Instead, we propose to integrate handheld devices seamlessly in a distributed computing environment. Componentized applications, adaptable middleware frameworks, and standardized protocols play a significant role in this new paradigm. We also describe an implementation within this paradigm using PalmORB, a CORBA client for the 3Com Palm devices.
In recent years, the convergence of computer vision and computer graphics has put forth new research areasthat work on scene reconstruction from and analysis of multi-view video footage. In free-viewpoint video, forexample, new views of a scene are generated from an arbitrary viewpoint in real-time using a set of multi-viewvideo streams as inputs. The analysis of real-world scenes from multi-view video to extract motion informationor reflection models is another field of research that...
With the advent of distributed computing, application management
is driven into a new era. In this world, application quality of service,
resource availability at different domains, and user requirements, are
combined in a dynamic, synergistic, and geographically broad
cooperation. We present an architecture and initial implementation of a
middleware that satisfies user requests according to expected
requirements, distributes networked resource load beyond the local
environment, and respects the logical constraints of different domains.
Static characteristics of resources are advertised as service offers
using the CORBA trading service, while dynamic changes in their state
are reported using the CORBA event service. We present a model where,
unlike traditional high-level management systems, resources compete to
satisfy application requirements
Die Arbeiten innerhalb des SFB 527 „Integration symbolischer und subsymbolischer Informationsverarbeitung in adaptiven sensomoto-risehen Systemen“ beinhalten die Realisierung des Demonstrators SMARTULm. Als Plattform wird ein Roboter des Typs B21 von RWI verwendet Eine wesentliche Komponente zur erfolgreichen Realisierung der Systemarchitektur des Demonstrators spielt die Unterstützung durch einen adäquaten Softwarerahmen. Dieser umfaßt neben Softwarekomponenten vor allem auch strukturelle Vorgaben, welche die Integrierbarkeit einzelner Komponenten in ein Gesamtsystem sicherstellen. In diesem Beitrag wird der Softwarerahmen SMARTSOFT vorgestellt, welcher die Realisierung sensomotorischer Systeme wesentlich erleichtert.
The range of distributed real-time and embedded (DRE) system applications has continued to expand at a vigorous rate. Designers of DRE systems are constantly challenged to provide new capabilities to meet expanding requirements and increased computational needs, while under pressure to provide constantly improving price/performance ratios and shorter times to market. Recently emerging hybrid chips containing both CPUs and FPGA components have the po- tential to enjoy significant economies of scale, while en- abling system designers to include a significant amount of specialization within the FPGA component. However, re- alizing the promise of these new hybrid CPU/FPGA chips will require programming models supporting a far more in- tegrated view of CPU and FPGA based application compo- nents than that provided by current methods. This paper de- scribes methods we are developing for supporting a multi- threaded programming model providing strongly integrated interface to CPU and FPGA based component threads.
The performance of a software system is determined by its resource demands, and the degree of competition for such resources
during execution. The demands are in part determined by pre-existing software components including libraries, operating systems,
middleware, and increasingly, also by application level components. A suitable description of the resource demands of a component
can be used for rapid performance and capacity analysis of a planned system. Resource demands may be found by theoretical
analysis (as in big-O complexity analysis), or by measurement, as considered here. This paper describes the general notion
of a workbench and repository for the gathering and maintenance of resource demand data, in the form of resource functions,
and two research prototypes. The key elements are a test harness for each software component, automation based on a stored
plan for running the test, function fitting for parametric dependencies, and a repository for retrieval of demand values.
These tools simplify the process of getting the essential data for performance analysis, so that it can be economical and
timely.
The research activity of our group at the Department of Computer Science, University of Pisa, is focused on programming models
and environments for the development of high-performance multidisciplinary applications. The enabling computing platforms
we are considering are complex distributed architectures, whose nodes are parallel machines of any kind, including PC/workstation
clusters. In general such platforms are characterized by heterogeneity of nodes, and by dynamicity in resource management
and allocation. In this context, Grid platforms at various levels of integration [25] are of main interest, including complex
distributed structures of general and dedicated subsystems, private heterogeneous networks, and systems for pervasive and
ubiquitous computing. In the following, we shall speak of Grids to refer to such architectural scenario.
[SPA]Las unidades de control de robots son sistemas intensivos en software, por lo que el diseño del mismo es esencial para el desarrollo y evolución del sistema global. El hardware es también un elemento primordial en estos sistemas, no sólo por su papel como plataforma de ejecución del software de control, sino porque es habitual encontrar componentes COTS o diseñados especialmente para la aplicación, que realizan parte de la funcionalidad del sistema. Por ello, hardware y software se deben poder integrar adecuadamente y combinar de distintas formas de acuerdo con el diseño del sistema. Para manejar la complejidad intrínseca de estos sistemas, se hace necesario plantear modelos de desarrollo rigurosos y arquitecturas bien definidas que se puedan reutilizar en otros productos. Disponer de tales arquitecturas facilita enormemente el desarrollo de nuevas aplicaciones fiables y de calidad, pues permite, por un lado la reutilización de modelos y componentes y por otro, ofrece un marco para el desarrollo de los mismos. De este modo se pueden reducir costes dado que se reduce el tiempo de desarrollo y se reutilizan componentes ya probados. En esta tesis se propone ACROSET como una arquitectura de referencia para el dominio de las unidades de control de robots de servicio teleoperados que define los principales subsistemas que deben o pueden aparecer en cualquier arquitectura concreta, sus responsabilidades y relaciones. En ACROSET se propone un modelo de componentes conceptual en el que se definen los componentes que pueden aparecer en cualquier sistema del dominio considerado y los patrones de interacción entre componentes al mismo nivel que éstos, gracias al uso de puertos y conectores. Una de las principales características de ACROSET es su flexibilidad tanto para la definición de arquitecturas de sistemas concretos como para la evolución de las mismas. Precisamente el éxito de la arquitectura residirá en su habilidad para adaptarse a la variabilidad entre los sistemas del dominio para el que ha sido definida. Para el nivel de abstracción que exige el manejo de tal variabilidad, las metodologías de desarrollo dirigidas por casos de uso no son apropiadas, por lo que se adopta una metodología orientada específicamente hacia el diseño de arquitecturas como el ABD (Architecture Based Design Method), que parte de requisitos funcionales y de calidad lo suficientemente amplios y abstractos como para abarcar todo el dominio. Dicha metodología se completa con el modelo de 4 vistas propuesto por Hofmeister con el fin de expresar el modelo conceptual en UML y tratar a componentes y conectores como entidades de primera clase. Se ha validado ACROSET con su instanciación para las unidades de control de diversos robots de limpieza de cascos de buques. En concreto, en esta tesis se presenta su instanciación para el prototipo GOYA y la familia de robots del proyecto EFTCoR. También se ha utilizado un robot didáctico 4U4 para probar diferentes combinaciones hardware/software a partir de ACROSET. [ENG]Robots control units are software intensive systems, so that the design of that software is essential for the development and evolution of the overall system. Hardware is also a primordial element in these systems, not only for its role as an execution platform for the control software, but because it is habitual to find COTS components or especially designed components that carry out part of the functionality of the system. For that reason, hardware and software should can be appropriately integrated and combined in different ways according to the design of the system. To deal with the intrinsic complexity of these systems is necessary to use rigorous development methods and architectural frameworks and tools that embody well defined concepts to enable effective realization of systems to meet high level goals. Such methods and architectural frameworks allow rapid development of systems and reuse of a large variety of components, with oncomitant savings in time and money. In this thesis ACROSET is proposed as reference architecture for the domain of control units for teleoperated service robots. This architecture defines the main subsystems that should or could appear in any concrete architecture, their responsibilities and relationships. ACROSET proposes a conceptual framework to define the components and their interaction patterns that could appear in any system of the considered domain. This architectural framework relies on the abstract concepts of component,port and connector. One of the main characteristics of ACROSET is its flexibility as much for the definition of architectures for concrete systems as for the evolution of the same ones. The success of the architecture depends on its ability to deal with the variability among the systems of the considered domain. Furthermore, at the level of abstraction required to manage the variability of the systems, the development methodologies directed by use cases are not appropriate. For this reason, an architecture oriented approach is adopted: the ABD (Architecture Based Design Method), which starts from functional and quality requirements wide and abstract enough to include the entire domain. Such method is completed with the 4 views proposed by Hofmeister to express the conceptual view of the architecture with UML and to treat components and connectors as first class entities. ACROSET has been validated with different instantiations for the control units of various ship hull cleaning robots. Specifically, in this thesis the instantiation of ACROSET for the GOYA prototype and the family of robots in the EFTCoR project is presented. A didactic robot (4U4) has also been used to test different hardware/software combinations.
Advanced mobile robots have to cope with many different situations
and have to fulfil their tasks even in dynamic environments.
Furthermore, there is an increasing demand that those systems perform
not only a single task but show a whole set of different capabilities.
This includes the concurrent and interruptable execution of several
tasks. Reliably performing different tasks over long periods of time not
only requires advanced basic skills, but also an appropriate robot
control architecture. This includes, e.g., mechanisms to coordinate the
execution of competing tasks. We present the architecture used on our
B21 demonstrator of the SFB 527. A special emphasis is laid on aspects
of our supporting software framework, SMARTSOFT, and the implemented set
of skills
Outlines a framework for the application-oriented management of
network resources, suggesting exchange of appropriate application
management information between management nodes in different domains, in
order to better assist the application's task. When the application
requirements cannot be satisfied within the local environment,
management information is passed to the closest available resource of
the same type. In our proposed approach, resources are represented as
resource virtual machines which exhibit similar characteristics, change
their state and perform operations with respect to the availability of
the resource, the user or task priority, and/or the user requirements.
Attempting to balance the functionality overhead and the real-time
constraints of decision making as to the appropriate resource to satisfy
a request, the resource virtual machines encapsulate the decision
concerning the ability of the resource to satisfy specific requests. The
suggested model is based on distributed computing principles and
proposes a hierarchical structure of specialized entities (inspectors)
to assist information exchange among a variety of nodes or subnetworks.
Finally, `resource inspectors' of the same type (controlling the same
type of resource) constitute a logical communication backbone. We
present the model's architecture, as well as a prototype implementation
using the Common Object Request Broker Architecture (CORBA)
Presents the software framework SMARTSOFT to implement
sensorimotor systems. SMARTSOFT not only contains software components to
support a modularized implementation but also structural rules and
templates. These ensure that the implementation of modules is conforming
with an overall multilayer system architecture. Since the provided
structures allow the exact specification of the external behavior of
modules in terms of interfaces and dependencies, the interaction with a
symbolic task execution layer is explicitly supported. SMARTSOFT
significantly eases the implementation and integration of new modules
into a complex sensorimotor system which for example provides the
opportunity even to compare and reuse different modules on a mobile
platform. SMARTSOFT has already proven its usefulness within the
collaborative research center (SFB 527) “Integration of Symbolic
and Subsymbolic Information Processing in Adaptive Sensorimotor
Systems”
This paper describes the Service Configurator pattern, whic h decouples the implementation of services from the time when they are configured. This pattern increases the flexibility a nd extensibility of applications by enabling their constitue nt ser- vices to be configured at any point in time. The Service Con- figurator pattern is widely used in application environment s (e.g., to configure Java applets into WWW browsers), operat- ing systems (e.g., to configure device drivers), and distrib uted systems (e.g., to configure standard Internet communicatio n services).
Object-oriented programming is as much a different way of designing programs as it is a different way of designing programming languages. This paper describes what it is like to design systems in Smalltalk. In particular, since a major motivation for object-oriented programming is software reuse, this paper describes how classes are developed so that they will be reusable.
The book, The Mythical Man-Month, Addison-Wesley, 1975 (excerpted in Datamation, December 1974), gathers some of the published data about software engineering and mixes it with the assertion of a lot of personal opinions. In this presentation, the author will list some of the assertions and invite dispute or support from the audience. This is intended as a public discussion of the published book, not a regular paper.
This paper describes the Active Object pattern, which decou- ples method execution from method invocation in order to simplify synchronized access to a shared resource by meth- ods invoked in different threads of control. The Active Object pattern allows one or more independent threads of execution to interleave their access to data modeled as a single ob- ject. A broad class of producer/consumer and reader/writer problems are well-suited to this model of concurrency. This pattern is commonly used in distributed systems requiring multi-threaded servers. In addition, client applications (such as windowing systems and network browsers), are increas- ingly employing active objects to simplify concurrent, asyn- chronous network operations.
This paper describes a new approach to dynamic link/unlink editing. The basis of this approach is a library of link editing functions that can add compiled object code to or remove such code from a process any time during its execution. Loading modules, searching libraries, resolving external references, and allocating storage for global and static data structures are all performed at run time. This approach provides the efficiency of native machine code execution along with the flexibility to modify a program during its execution, thereby making many new applications possible. This paper also describes three sample applications of these dynamic link editing functions: program customization, incremental program development, and support for debugging and testing. A prototype of this approach is implemented under UNIX as a library package called dld for the C programming language and is available for VAX, Sun 3 and SPARCstation machines.
This paper makes two contributions to the d evelopment and evaluation of object-oriented communication software. First, it reports performance results from benchmarking several network programming mechanisms (such as so ckets and CORBA) on Ethernet and ATM networks. These results il- lustrate that developers of high-bandwidth, low-delay appli- cations (such as interactive medical imaging or teleconfer- encing) must evaluate their performance requirements and the efficiency of their communication infrastructure carefully before adopting a distributed object solution. Second, the paper describes the software architecture and design princi- ples of the ACE object-oriented network programming com- ponents. These components encapsulate UNIX and Win- dows NT network programming interfaces (such as sockets, TLI, and named pipes) with C++ wrappers. D evelopers of object-oriented communication software have traditionally had to choose between high-performance, lower-l evel inter- faces provided by sockets or TLI or less efficient, higher- level interfaces provided by communication frameworks like CORBA or DCE. ACE represents a midpoint in the solution space by improving the correctness, programming simplicity, portability, and reusability of performance-sensitive commu- nication software.
This paper describes a method of accurately measuring and profiling kernel code in real time. Some background is covered, which describes other more common, and easier, methods of profiling, and why these methods were rejected. Some goals are stated, and a proposed hardware/software solution is described. As a case study, the profiling method is used to evaluate a kernel incorporating the Berkeley TCP/IP networking code; the results of this exercise are presented, showing how tracing of network software in real time highlights optimal or non-optimal code paths. Warning to software people: this paper contains some descriptions of hardware. Warning to non-kernel-hackers: this paper has lots of kernel hacking in it.
The ISO TP4 and TP0 transport layer protocols and associated network service paradigms cannot interoperate, yet both are likely to be in common use. To allow users of TP4 to communicate with users of TP0, transport layer gateways will be needed. This ...
Thesis (M.A.)--University of Texas at Austin, 1994. Vita. Includes bibliographical references.
A framework containing a number of resources, languages, and tools
for generating customized protocols that support diverse multimedia
applications running on high-performance networks is described. The
framework facilitates the configuration of application-tailored,
function-based communication protocols that are automatically
synthesized from high-level specifications
Transport system services that integrate operating system
resources such as CPUs, virtual memory, and I/O devices with network
protocols to support distributed multimedia applications running on
local and wide area networks are described and classified. A taxonomy is
presented, and four commercial and experimental transport systems are
compared and evaluated in terms of their protocol processing support.
The systems discussed are System V UNIX STREAMS, the BSD UNIX networking
subsystem, the x -kernel, and the Choices Conduit system
A new virtual memory architecture for the Sun implementation of the UNIX+ operating system is described. Our goals included unifying and simplifying the concepts the system used to manage memory, as well as providing an implementation that fit well with the rest of the system. We discuss an architecture suitable for environments that (potentially) consist of systems of heterogeneous hardware and software architectures. The result is a page-based system in which the fundamental notion is that of mapping process addresses to files. 1. Introduction and Motivation The UNIX operating system has traditionally provided little support for memory sharing between processes, and no support for facilities such as file mapping. For some communities, the lack of such facilities has been a barrier to the adoption of UNIX, or has hampered the development of applications that might have benefited from their availability. Our own desire to provide a shared libraries capability has provided addit...
The design and implementation of a shared libraries facility for Sun's implementation of the UNIX+ operating system (SunOS) is described. Shared libraries extend the resource utilitization benefits obtained from sharing code between processes running the same program to processes running different programs by sharing the libraries common to them. In this design, shared libraries are viewed as the result of the application of several more basic system mechanisms, specifically # kernel-supplied facilities for file-mapping and "copy-on-write" sharing; # a revised link editor supporting dynamic binding; and # compiler and assembler changes to generate position-independent code. The use of these mechanisms is transparent to applications code and build procedures, and also to library source code written in higher-level languages. Details of the use and operation of the mechanism are provided, together with the policies by which they are applied to create a system with shared lib...
In a new version of the Unix operating system, a flexible coroutine-based design replaces the traditional rigid connection between processes and terminals or networks. Processing modules may be inserted dynamically into the stream that connects a user's program to a device. Programs may also connect directly to programs, providing interprocess communication. Introduction The part of the Unix operating system that deals with terminals and other character devices has always been complicated. In recent versions of the system it has become even more so, for two reasons. 1) Network connections require protocols more ornate than are easily accommodated in the existing structure. A notion of "line disciplines" was only partially successful, mostly because in the traditional system only one line discipline can be active at a time. 2) The fundamental data structure of the traditional character I/O system, a queue of individual characters (the "clist"), is costly because it accepts and dispense...
This paper describes the design of the ACE object-oriented thread encapsulation C++ class library. This library shields programmers from differences between Solaris threads, POSIX pthreads, and Win32 threads. The architecture of this class library is presented from an end-user and internal design perspective and key design and implementation issues are discussed. Readers will gain an understanding of the overall design approach, as well as the tradeoffs between various software quality factors such as performance, portability, and extensibility. 1 Introduction Certain types of distributed applications benefit from using a concurrent model of execution to perform their tasks. Concurrency is particularly useful to improve performance and simplifying programming for network servers on multi-processor platforms. For server applications, using threads to handle multiple client requests concurrently is often more convenient and less error-prone than the following design alternatives: ffl A...
Developing correct and efficient concurrent applications is hard. Programmers must learn new mechanisms (such as multi-threading and synchronization APIs) and techniques (such as concurrency control and deadlock avoidance algorithms) . In addition, many familiar design patterns (such as Singleton or Observer) that work well for sequential programs contain subtle assumptions that do not apply in the context of concurrency. As an example, this paper shows how the canonical implementation of the Singleton pattern does not work correctly in the presence of preemptive multi-tasking or true parallelism. To solve this problem, we describe the DoubleChecked Locking pattern. This pattern enables Just Once Events (events that are performed only once, such as Singleton initialization), and that unnecessary locking overhead is eliminated. Furthermore, the Double-Checked Locking pattern illustrates how changes in underlying forces (i.e., the addition of multi-threading and parallelism to Singleton)...
Computer communication systems must undergo significant changes to keep pace with the increasingly demanding and diverse multimediaapplications that will run on the next generation of high-performance networks. To facilitate these changes, we are developing "A Dynamically Assembled Protocol Transformation, Integration, and eValuation Environment " (ADAPTIVE). ADAPTIVE provides an integrated environment for developing and experimenting with flexible transport system architectures that support lightweight and adaptive communication protocols for diverse multimedia applications running on high-performance networks. Our approach employs a collection of reusable "building block" protocol mechanisms that may be composed together automatically based upon functional specifications. The resulting protocols execute in parallel on several target platforms including shared memory and message-passing multiprocessors. ADAPTIVE provides a framework for (1) determining the functionality of customized ...
This paper will appear at the EuroPLoP '96 Conference in Kloster Irsee, Germany. 1 Introduction
This paper describes a pair of patterns that enhance the reuse, extensibility, and portability of object-oriented communication software by permittingnetwork services to evolve independently of the mechanisms used to establish connections used by the services. The Acceptor and Connector patterns decouple the passive and active establishment of a connection, respectively, from the service performed once the connection is established. In addition, the patterns decouple the service creation and concurrency strategies from the services themselves. 1 Introduction Connection-oriented protocols (such as TCP/IP or IPX/SPX) provide reliable delivery of data between two or more endpoints of communication. Establishing connections between endpoints involves the following two roles: ffl Passive role -- which initializes an endpoint of communication at a particular address and waits passively for the other endpoint(s) to connect with it; ffl Active role -- which actively initiates a connection t...
This paper describes the Half-Sync/Half-Async pattern, which integrates synchronous and asynchronous I/O models to support both programming simplicity and execution efficiency in complex concurrent software systems. In this pattern, higher-level tasks use a synchronous I/O model, which simplifies concurrent programming. In contrast, lower-level tasks use an asynchronous I/O model, which enhances execution efficiency. This pattern is widely used in operating systems such as UNIX, Mach, WindowsNT, and VMS, as well as other complex concurrent systems. 1 Intent The Half-Sync/Half-Async pattern decouples synchronous I/O from asynchronous I/O in a system to simplify concurrent programming effort without degrading execution efficiency. 2 Motivation To illustrate the Half-Sync/Half-Async pattern, consider the software architecture of the BSD UNIX [1] networking subsystem shown in Figure 1. The BSD UNIX kernel coordinates I/O between asynchronous communication devices (such as network adapter...
This paper explores the Service Configurator pattern, which decouples the implementation of communication services from their configuration. This pattern increases the flexibility and extensibility of communication services by enabling their configuration and reconfiguration at any point in time without affecting other services. The Service Configurator pattern is widely used in system and application programming environments including UNIX, Windows NT, and Java. 1 Intent Decouples the behavior of communication services from the point in time at which these services are configured into an application or system. 2 Also Known As Super-server 3 Motivation 3.1 Context To illustrate the need for the Service Configurator pattern, consider the ever-increasing range of communication services offered in the Internet: ffl WWW browsing and content retrieval services (e.g., httpd); ffl Electronic mail and network news transfer agents (e.g., sendmail and nntpd); ffl File access on remote ma...
Asynchronous Completion Token pattern allows applications to efficiently associate state with the completion of asynchronous operations. Contemporary applications must respond to many types of events, ranging from user interface notifications to network messages. Delay-sensitive applications, such as network management systems, often perform long-running operations asynchronously to avoid blocking the processing of other pending events. When these asynchronous operations complete, applications may need more information thansimply the notification itself to properly handle the event. This paper describes how such applications can benefit from the use of the Asynchronous Completion Token pattern. 1 Intent To efficiently associate state with the completion of asynchronous operations. 2 Also Known As "Magic Cookie" 3 Motivation 3.1 Context To illustrate the Asynchronous Completion Token pattern, consider the structure of a network Management Application that monitors the performance an...
This paper describes the design and performance of an object-oriented communication framework being developed by Kodak Health Imaging Systems and the Electronic Radiology Laboratory at Washington University School of Medicine. The framework is designed to meet the demands of Project Spectrum, which is a large-scale distributed electronic medical imaging system. A novel aspect of this framework is its seamless integration of flexible high-level CORBA distributed object computing middleware with efficient lowlevel socket network programming mechanisms. In the paper, we outline the design goals and software architecture of our framework, illustrate the performance of the framework over ATM, and describe how we resolved design challenges we faced when developing an object-oriented communication framework for distributed medical imaging. 1 Introduction The demand for distributed electronic medical imaging systems (EMISs) is driven by technological advances and economicnecessity [1]. Recen...
This paper appeared in the January 1996 issue of the C++ Report magazine.
This paper describes the design and performance of an object-oriented communication framework being developed by the Health Imaging division of Eastman Kodak and the Electronic Radiology Laboratory at Washington University School of Medicine. The framework is designed to meet the demands of next-generation electronic medical imaging systems, which must transfer extremely large quantities of data efficiently and flexibly in a distributed environment. A novel aspect of this framework is its seamless integration of flexible high-level CORBA distributed object computing middleware with efficient low-level socket network programming mechanisms. In the paper, we outline the design goals and software architecture of our framework, describe how we resolved design challenges, and illustrate the performance of the framework over high-speed ATM networks. 1 Introduction The demand for distributed electronic medical imaging systems (EMISs) is pushed by technological advances and pulled by economi...
Abstract Developers of communication software must confront recurring design challenges involving robustness, efficiency, and extensibility. Many of these challenges are independent of the application-specific requirements. Successful developers resolve these challenges by applying appropriate design patterns. However, these patterns have traditionallybeen locked in the minds of expert developers or buried within complex system source code. The primary contribution of this paper is to describe a family of design patterns that underly many object-oriented communication software systems. In addition to describing each pattern separately, the paper illustrates how knowledge of the relationships and trade-offs among patterns helps guide the construction of reusable communication software frameworks. 1 Introduction Building,maintaining,and enhancing high quality communication systems is hard. Developers must have a deep understanding of many complex issues such as service initialization ...
This paper describes a new operating system kernel, called the x-kernel, that provides an explicit architecture for constructing and composing network protocols. Our experience implementing and evaluating several protocols in the x-kernel shows that this architecture is both general enough to accommodate a wide range of protocols, yet efficient enough to perform competitively with less structured operating systems. 1 Introduction Network software is at the heart of any distributed system. It manages the communication hardware that connects the processors in the system and it defines abstractions through which processes running on those processors exchange messages. Network software is extremely complex: it must hide the details of the underlying hardware, recover from transmission failures, ensure that messages are delivered to the application processes in the appropriate order, and manage the encoding and decoding of data. To help manage this complexity, network software is divi...
this paper appeared in the July/August 1994 issue of the C++ Report.
When processes wish to communicate, they must first establish communication. The stream mechanisms introduced in the Eighth Edition Unix system,1 which have now become part of AT&T's Unix System V2, provide a flexible way for processes to conduct an already-begun conversation with devices and with each other: an existing stream connection is named by a file descriptor, and the usual read, write, and I/O control requests apply. Processing modules may be inserted dynamically into a stream connection, so network protocols, terminal processing, and device drivers separate cleanly. However, these mechanisms, by themselves, do not provide a general way to create channels between processes.
Simple extensions provide new ways of establishing communication. In our system, the traditional Unix IPC mechanism, the pipe, is a cross-connected stream.
A generalisation of file-system mounting associates a stream with a named file. When the file is opened, operations on the file are operations on the stream.
Open files may be passed from one process to another over a pipe.
These low-level mechanisms allow construction of flexible and general routines for connecting local and remote processes.
The ADAPTIVE Service eXecutive (ASX) is a highly modular and extensible object-oriented framework that simplifies the development and configuration of distributed applications on shared memory multi-processor platforms. This paper describes the structure and functionality of the ASX framework 's object-oriented architecture. In addition, the paper presents the results of performance experiments conducted using ASX-based implementations of connection-oriented and connectionless protocols from the TCP/IP protocol family. These experiments measure the performance impact of alternative methods for parallelizing communication protocol stacks. Throughout the paper, examples are presented to indicate how the use of object-oriented techniques facilitate application extensibility, component reuse, and performance enhancement. 1 Introduction Distributed computing is a promising technology for improving collaboration through connectivity and interworking; performance through parallel processing...