Overview of ACE

The ADAPTIVE Communication Environment (ACE) is a freely available, open-source object-oriented (OO) framework that implements many core patterns for concurrent communication software. ACE provides a rich set of reusable C++ wrapper facades and framework components that perform common communication software tasks across a range of OS platforms. The communication software tasks provided by ACE include event demultiplexing and event handler dispatching, signal handling, service initialization, interprocess communication, shared memory management, message routing, dynamic (re)configuration of distributed services, concurrent execution and synchronization.

ACE is targeted for developers of high-performance and real-time communication services and applications. It simplifies the development of OO network applications and services that utilize interprocess communication, event demultiplexing, explicit dynamic linking, and concurrency. In addition, 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.

ACE continues to improve and its future is bright. ACE is supported commercially by multiple companies using an open-source business model. In addition, many members of the ACE development team are currently working on building The ACE ORB (TAO).

Benefits of Using ACE?

Some of the many benefits of using ACE include:

The Structure and Functionality of ACE

The following diagram illustrates the key components in ACE and their hierarchical relationships:
The structure and participants of the layers in this diagram are described below.

The ACE OS Adapter Layer

This layer resides directly atop the native OS APIs that are written in C. It provides a small footprint, "POSIX-like" OS adaptation layer that shields the other layers and components in ACE from platform-specific dependencies associated with the following OS APIs: The portability of ACE's OS adaptation layer enables it to run on a many operating systems. ACE has been ported and tested on a wide range of OS platforms including Windows (i.e., WinNT 3.5.x, 4.x, 2000, Embedded NT, XP, Win95/98, and WinCE using MSVC++, Borland C++ Builder, and IBM's Visual Age on 32- and 64-bit Intel and Alpha platforms), Mac OS X, most versions of UNIX (e.g., Solaris on SPARC and Intel, SGI IRIX 5.x and 6.x, DG/UX, HP-UX 10.x, and 11.x, Tru64UNIX 3.x and 4.x, AIX 3.x, 4.x, 5.x, DG/UX, UnixWare, SCO, and freely available UNIX implementations, such as Debian Linux 2.x, RedHat Linux 5.2, 6.x, 7.x, 8x, and 9.x, as well as the various Enterprise editions, SUSE Linux 8.1 and 9.2, Timesys Linux, FreeBSD, and NetBSD), real-time operating systems (e.g., LynxOS, VxWorks, ChorusOS, QnX Neutrino, RTEMS, OS9, and PSoS), OpenVMS, MVS OpenEdition, and CRAY UNICOS. A single source tree is used for all these platforms. There is also a Java version of ACE.

Because of the abstraction provided by ACE's OS adaptation layer, a single source tree is used for all these platforms. This design greatly simplies the portability and maintainability of ACE.

C++ Wrapper Facades for OS Interfaces

It is possible to program highly portable C++ applications directly atop ACE's OS adaptation layer. However, most ACE developers use the C++ wrapper facade layer shown in the figure above. The ACE C++ wrapper facades simplify application development by providing typesafe C++ interfaces that encapsulate and enhance the native OS concurrency, communication, memory management, event demultiplexing, dynamic linking, and file system APIs. Applications can combine and compose these wrappers by selectively inheriting, aggregating, and/or instantiating the following components: The C++ wrappers provide many of the same features as the OS adaptation layer in ACE. However, these features are structured in terms of C++ classes and objects, rather than stand-alone C functions. This OO packaging helps to reduce the effort required to learn and use ACE correctly.

For instance, the use of C++ improves application robustness because the C++ wrappers are strongly typed. Therefore, compilers can detect type system violations at compile-time rather than at run-time. In contrast, it is not possible to detect typesystem violations for C-level OS APIs, such as sockets or filesystem I/O, until run-time.

ACE employs a number of techniques to minimize or eliminate performance overhead. For instance, ACE uses C++ inlining extensively to eliminate method call overhead that would otherwise be incurred from the additional typesafety and levels of abstraction provided by its OS adaptation layer and the C++ wrappers In addition, ACE avoids the use of virtual methods for performance-critical wrappers, such as send/recv methods for socket and file I/O.


ACE also contains a higher-level network programming framework that integrates and enhances the lower-level C++ wrapper facades. This framework supports the dynamic configuration of concurrent distributed services into applications. The framework portion of ACE contains the following components:

The ACE framework components facilitate the development of communication software that can be updated and extended without the need to modify, recompile, relink, or often restart running applications. This flexibility is achieved in ACE by combining (1) C++ language features, such as templates, inheritance, and dynamic binding, (2) design patterns, such as Abstract Factory, Strategy, and Service Configurator, and (3) OS mechanisms, such as explicit dynamic linking and multi-threading.

Distributed Services and Components

In addition to its OS adaptation layer, C++ wrapper facades, and framework components, ACE provides a standard library of distributed services that are packaged as self-contained components. Although these service components are not strictly part of the ACE framework library, these service components play two roles in ACE:

  1. Factoring out reusable distributed application building blocks -- These service components provide reusable implementations of common distributed application tasks such as naming, event routing, logging, time synchronization, and network locking.

  2. Demonstrating common use-cases of ACE components -- The distributed services also demonstrate how ACE components like Reactors, Service Configurators, Acceptors and Connectors, Active Objects, and IPC wrappers can be used effectively to develop flexible, efficient, and reliable communication software.

Higher-level Distributed Computing Middleware Components

Developing robust, extensible, and efficient communication applications is challenging, even when using a communication framework like ACE. In particular, developers must still master a number of complex OS and communication concepts such as:

It is possible to alleviate some of the complexity of developing communication applications by employing higher-level distributed computing middleware, such as CORBA, DCOM, or Java RMI. Higher-level distributed computing middleware resides between clients and servers and automates many tedious and error-prone aspects of distributed application development, including:

To provide developers of communication software with these features, the following higher-level middleware applications are bundled with the ACE release:

  1. The ACE ORB (TAO) -- TAO is a real-time implementation of CORBA built using the framework components and patterns provided by ACE. TAO contains the network interface, OS, communication protocol, and CORBA middleware components and features. TAO is based on the standard OMG CORBA reference model, with the enhancements designed to overcome the shortcomings of conventional ORBs for high-performance and real-time applications. TAO, like ACE, is freely available, open source software.

  2. JAWS -- JAWS is a high-performance, adaptive Web server built using the framework components and patterns provided by ACE. JAWS is structured as a framework of frameworks. The overall JAWS framework contains the following components and frameworks: an Event Dispatcher, Concurrency Strategy, I/O Strategy, Protocol Pipeline, Protocol Handlers, and Cached Virtual Filesystem. Each framework is structured as a set of collaborating objects implemented by combining and extending components in ACE. JAW is also freely available, open-source software.

Back to the ACE home page.

Last modified 16:14:53 CST 16 December 2012