Previous | Table of Contents | Next |
ACE is an object-oriented framework that implements core concurrency and distribution patterns (Schmidt, 1996a) for communication software. ACE provides a rich set of reusable C++ wrappers and framework components that are targeted for developers of high-performance, real-time services and applications across a wide range of OS platforms. The components in ACE provide reusable implementations of the following communication software tasks:
This section outlines the structure of the ACE framework. Section 2.4 illustrates how components and patterns in ACE can be applied to build high-performance, concurrent Web servers.
ACE is a large framework, containing more than 100,000 lines of C++ code divided into about 250 classes. To separate concerns and to reduce the complexity of the frameworks, ACE is designed using a layered architecture. Figure 2.2 illustrates the vertical and horizontal relationships between ACE components.
FIGURE 2.2. The structure of the components in ACE.
The lower layers of ACE are C++ wrappers that encapsulate core OS communication and concurrency services. The higher layers of ACE extend the C++ wrappers to provide reusable frameworks, self-contained distributed service components, and middleware applications that simplify the creation, composition, and configuration of large-scale communication systems.
2.3.1.1. The ACE C++ Wrapper Layer
Approximately 10% of ACE (that is, approximately 10,000 lines of code) is devoted to the OS adaptation layer, which resides directly atop the native OS APIs written in C. The OS adaptation layer shields the other layers in ACE from platform-specific dependencies associated with the following OS services:
The portability provided by the OS adaptation layer enables ACE to run on a wide range of operating systems, including most versions of UNIX, Win32, OpenEdition MVS, and embedded platforms such as VxWorks.
Although it is possible to program directly to the OS adaptation layer, most applications use the C++ wrappers layer, shown in Figure 2.2. ACE C++ wrappers improve application robustness by encapsulating and enhancing the native OS concurrency, communication, memory management, event demultiplexing, and dynamic linking mechanisms with type-safe OO interfaces. This alleviates the need for applications to directly access the underlying OS libraries, which are written using weakly typed C interfaces. Therefore, C++ compilers can detect type system violations at compile time rather than at runtime. ACE uses inlining extensively to eliminate performance penalties that would otherwise be incurred from the additional type-safety and levels of abstraction provided by the OS adaptation layer and the C++ wrappers.
The C++ wrappers provided by ACE are quite extensive, constituting about 50% of the source code. Applications can combine and compose these wrappers by selectively inheriting, aggregating, and/or instantiating the following components:
Previous | Table of Contents | Next |