Ace self-adaption communication environment

I. Ace Overview

Ace adaptive communication environment (Adaptive Communication Environment) is a free-to-use, open-source object-oriented (OO) framework, which implements many core modes for concurrent communication software. ACE provides a rich set of reusableC ++Wrapper facade and architecture components can be used to complete common communication software tasks across multiple platforms, including: multi-channel event separation and event processor allocation, signal processing, service initialization, inter-process communication, shared memory management, message routing, distributed service dynamic (heavy) configuration, concurrent execution and synchronization, and so on.

Ace is intended for developers of high-performance and real-time communication services and applications. It simplifies the use of inter-process communication, event Multi-Channel Separation, explicit dynamic links and concurrent ooNetworkDevelopment of applications and services. In addition, Ace automates system configuration and reconfiguration through dynamic links between services and applications at runtime.

Ace is continuously improving. Riverace Corporation (Http://www.riverace.comUse the Open Source business model to provide commercial support for Ace. In addition, many members of the ACE development team are currently conducting the ace orb (TAO,Http://www.cs.wustl.edu /~ Schmidt/tao.html.

Ii. Benefits of using ace

Many benefits of using ace include:
(1)Enhanced portability: With the help of ACE components, it is easy to write concurrency on an OS PlatformNetworkApplications, and then quickly port them to a variety of other OS platforms. Besides, because Ace is an open-source free software, you don't have to worry about being locked to a specific operating system platform or compiler.
(2)Better Software Quality: Ace is designed to use a number of key patterns that can improve the quality of software. These quality factors include communication software flexibility, scalability, reusability, and adequacy.
(3)Higher efficiency and predictabilityAce is carefully designed to support a wide range of application Quality of Service (QoS) requirements, including low response waiting times for latency-sensitive applications, high performance of high-bandwidth applications, and real-time application predictability.
(4)Easy to switch to standard advanced Middleware: Tao uses reusable components and patterns provided by Ace. It is the development source code and standard implementation of CORBA, and optimizes high-performance and real-time systems. To this end, ACE and Tao are designed to work together well to provide a comprehensive middleware solution.

Iii. Ace Structure and Functions

The key components in ACE and their hierarchies are displayed:
The structure and components of each layer are described as follows.

Iv. Ace OS Adaptation Layer

This layer is written in C and directly resident on the local OS API. It provides a lightweight POSIX OS-like adaptation layer to shield other layers and components in ACE and the following Platform proprietary features associated with OS APIs:

(1)Concurrency and Synchronization: The ace Adaptation Layer encapsulates OS APIs for multithreading, multi-process, and synchronization.

(2)Inter-process communication (IPC) and shared memory: The ace Adaptation Layer encapsulates OS APIs for local and remote IPC and shared memory.

(3)Multi-channel event Separation Mechanism: The Adaptation Layer of ACE encapsulates OS APIs for synchronous and asynchronous multi-path separation of I/O, timer, signal, and synchronization-based events.

(4)Explicit Dynamic Link: The Adaptation Layer of ACE encapsulates OS APIs for explicit dynamic connections. Explicit Dynamic Links allow you to configure application services during installation or running.

(5)File System Mechanism: The Adaptation Layer of ACE encapsulates OS file system APIs for operating files and directories.

The portability of the ace OS Adaptation Layer enables ace to run on many operating systems. Ace has been transplanted and tested on a wide range of OS platforms, including Win32 (that is, using MS on Intel and Alpha platforms ).VC++ And BorlandC ++Builder and IBM Visual Age of WINNT 3.5.x, 4.X, 2000, Win95/98 and wince), Mac OS X, most versionsUNIX(For example, Solaris 1. X and 2.x, sgi irix 5. X and 6.xon intel, DG/UX, HP-UX 9.x, 10. X and 11.x, DEC/CompaqUNIX3. X and 4.X, AIX 3.x and 4.X,UNIXWare, SCO, and freely availableUNIXImplementation, such as DebianLinux2. x, RedHatLinux5.2, 6.x, 7.x, FreeBSD, and NetBSD), real-time operating systems (such as lynxos, VxWorks, chorus classix 4.0, QNX neutrino, RTEMS, and PSOs), MVS openedition, and Cray unicos.

Given the abstraction provided by the ace OS adaptation layer, all these platforms use the same code tree. This design greatly enhances the portability and maintainability of ACE. In additionJavaThe ACE version is available (Http://www.cs.wustl.edu /~ Eea1/jace.html).

V. OS InterfaceC ++Packaging appearance

Highly portable can be written directly on the ace OS Adaptation LayerC ++Application. However, most ace developers useC ++Packaging appearance layer. By providing type-safeC ++Interfaces (these interfaces encapsulate and enhance local OS concurrency, communication, memory management, multi-channel event separation, dynamic links, and file system APIs). Ace packaging simplifies application development. Applications can combine and use these packages by selectively inheriting, aggregating, and/or instantiating the following components:

(1)Concurrency and synchronization Components: Ace abstracts local OS multithreading and multi-process mechanisms such as mutex and semaphore to create advanced OO concurrency abstractions, such as active object) and polymorphic future ).

(2)IPC and file system components: AceC ++Encapsulate local and/or remote IPC mechanisms, such as socket, TLI,UNIXFIFO and Stream pipelines, and Win32 Named pipelines. In addition, aceC ++The package also encapsulates the OS file system API.

(2)Memory Management ComponentThe ACE memory management component provides a flexible and scalable abstraction for managing the shared memory between processes and the Dynamic Allocation and release of heap memory in processes.

AceC ++Packaging provides many of the same features as the ace OS adaptation layer. However, these features useC ++Class and object instead of independent C functions. Such oo packaging helps reduce the effort required to learn and use ACE correctly.

For example,C ++Application robustness is improved becauseC ++Packaging is strongly typed. Therefore, the compiler can detect type system violations during compilation rather than runtime. On the contrary, it is impossible to detect type system violations of C-level OS APIs such as socket or file system I/O during runtime.

Ace uses many techniques to reduce or eliminate additional performance overhead. For example, Ace is widely used.C ++Inline to eliminate additional method call overhead; such overhead may be caused by the OS adaptation layer andC ++The additional type security and abstraction layers provided by the package bring about. In addition, Ace avoids virtual functions for packaging key performances, such as the socket and file I/O send/Recv methods.

Vi. Architecture

ACE also contains an advancedNetworkProgramming architecture, integrated and enhanced at a lower levelC ++Packaging appearance. This architecture supports dynamic configuration of concurrent distributed services into applications. The architecture of ACE includes the following components:
(1)Multi-channel event separation component: Ace reactor and proactor are scalable object-oriented multi-channel splitters that distribute proprietary processors for applications, to respond to various types of I/O, timer, signal, and synchronization events.
(2)Service initialization component: The ace acceptor and connector (connector) components decouple active and passive initialization tasks with application proprietary tasks executed by the communication service once Initialization is complete.
(3)Service Configuration component: ACE service configurator (service configurator) supports application configuration. Services of these applications can be dynamically assembled during installation and/or running.
(4)Layered stream component: The ace stream component simplifies the development of communication software applications composed of layered services, such as user-level protocol stacks.
(5) orb adapter component: Through orb adapter, Ace can be seamlessly integrated with single-line and multi-thread CORBA implementations.

The ACE architecture components facilitate the development of communication software. They can be updated and expanded without modifying, re-compiling, re-linking, or frequently restarting running applications. In ace, this flexibility is achieved by combining the following elements: (1)C ++Language features, such as templates, inheritance and dynamic binding, (2) design patterns, such as abstract factory, policy and service configurator, and (3) OS mechanism, for example, explicit dynamic links and multithreading.

VII. distributed services and components

In addition to the OS adaptation layer,C ++ACE also provides a standard distributed service library encapsulated into self-contained components. Although these service components are not strictly components of the ACE architecture library, they play two roles in ACE:
(1)Break down the "blocks" of reusable distributed applications": These service components provide reusable Implementation of Common distributed application tasks, such as name services, Event Routing, logs, time synchronization, andNetworkLocked.
(2)Demonstrate common ace component Use Cases: These distributed services also demonstrate how to use reactor, service configurator, acceptor, connector, and active object, and IPC packages such ace components to effectively develop flexible, efficient, and reliable communication software.

8. Advanced Distributed computing middleware components

Even with a communication architecture like Ace, developing robust, scalable, and efficient communication applications is still challenging. In particular, developers must master many complex OS and communication concepts, such
(1)NetworkAddressing and service identification.

(2) Representation conversion, such as encryption, compression, and byte sequence conversion between heterogeneous terminal systems.

(3) creation and synchronization of processes and threads.

(4) System Call and database routine of the communication (IPC) mechanism between local and remote processes.

By usingJavaAdvanced Distributed computing middleware such as RMI may reduce the complexity of developing communication applications. Advanced Distributed computing middleware resides between the client and the server, which can automatically complete many troublesome and error-prone aspects of distributed application development, including: (1) authentication, authorization, and data security.

(2) Service positioning and binding.

(3) Register and enable the service.

(4) event Multi-Channel Separation and dispatch.

(5) message frames are implemented based on byte stream-oriented communication protocols such as TCP.

(6) involvedNetworkThe representation conversion problem of bytecode and parameter orchestration.

To provide these features to communication software developers, Ace binds the following advanced middleware applications:
(1)The ace orb (TAO): Tao is a real-time implementation of CORBA built using the architecture components and modes provided by Ace, includingNetworkInterfaces, operating systems, communication protocols, and CORBA middleware components and features. Based on the standard omg corba reference model, Tao has been designed with enhancements to overcome the disadvantages of traditional ORB for high performance and real-time applications. Like ace, Tao is also an open source software that can be freely used.
(2)Jaws: Jaws is a high-performance, self-adaptive web server that is built using the architecture components and modes provided by Ace. Jaws is constructed as a "framework ". The overall architecture of Jaws includes the following components and architectures: Event multi-path dispatcher, concurrency policy, I/O policy, protocol pipeline, protocol processor, and cache Virtual File System. Each architecture is constructed into a group of collaboration objects, which are implemented by combining and extending the components in Ace. Jaws is also an open source software that can be freely used.

9. Home Page

Ace homepage:Http://www.cs.wustl.edu /~ Schmidt/ace.htmlHere, you can get the latest version of ACE and other related resources.