오랜만에 ACE를 보니 이전에는 좀 기능이 많은 C++ Class Library였는데, 이제는 분산시스템을 위한 Framework으로 이용할 만큼 많이 발전했네요.
Who is Using ACE을 보니 제가 관심두는 영역인 통신 영역에서도 벌써 많은 레퍼런스가 있군요.
The Structure and Functionality of ACE
The following diagram illustrates the key components in ACE and their hierarchical relationships:
Frameworks
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:
- Event demultiplexing components -- The ACE Reactor and Proactor are extensible, object-oriented demultiplexers that dispatch application-specific handlers in response to various types of I/O-based, timer-based, signal-based, and synchronization-based events.
- Service initialization components -- The ACE Acceptor and Connector components decouple the active and passive initialization roles, respectively, from application-specific tasks that communication services perform once initialization is complete.
- Service configuration components -- The ACE Service Configurator supports the configuration of applications whose services may be assembled dynamically at installation-time and/or run-time.
- Hierarchically-layered stream components -- The ACE Streams components simplify the development of communication software applications, such as user-level protocol stacks, that are composed of hierarchically-layered services.
- ORB adapter components -- ACE can be integrated seamlessly with single-threaded and multi-threaded CORBA implementations via its ORB adapters.
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:
- 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.
- 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:
- Network addressing and service identification.
- Presentation conversions, such as encryption, compression, and network byte-ordering conversions between heterogeneous end-systems with alternative processor byte-orderings.
- Process and thread creation and synchronization.
- System call and library routine interfaces to local and remote interprocess communication (IPC) mechanisms.
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:
- Authentication, authorization, and data security.
- Service location and binding.
- Service registration and activation.
- Demultiplexing and dispatching in response to events.
- Implementing message framing atop bytestream-oriented communication protocols like TCP.
- Presentation conversion issues involving network byte-ordering and parameter marshaling.
To provide developers of communication software with these features, the following higher-level middleware applications are bundled with the ACE release:
- 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.
- 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.
