Huihoo Announces the Availablity of Commercial Support of ACE
1.Introduction of ACE
The Adaptive Communication Environment (ACE) is a widely-used, open-source object-oriented toolkit written in C++ that implements core concurrency and networking patterns for communication software. ACE includes many components that simplify the development of communication software, thereby enhancing flexibility, efficiency, reliability and portability. Components in the ACE framework provide the following capabilities:
。Concurrency and synchronization.
。Interprocess communication (IPC)
。File system management
。Event demultiplexing and handler dispatching.
。Connection establishment and service initialization.
。Static and dynamic configuration and reconfiguration of software.
。Layered protocol construction and stream-based frameworks.
。Distributed communication services -naming, logging, time synchronization,event routing and network locking. etc. The framework components provided by ACE are based on a family of patterns that have been applied successfully to thousands of commercial systems over the past decade.
2.The ACE Architecture
ACE has a layered design, with the following three basic layers in its architecture:
。The operating system (OS) adaptation layer
。The C++ wrapper fa?ade layer
。The frameworks and patterns layer
Each of these layers is shown in the figure below and described in the following sections.
2.1 The OS Adaptation Layer
The OS Adaptation is a thin layer of C++ code that sits between the native OS APIs and the rest of ACE. This layer shields the higher layers of ACE from platform dependencies, which makes code written with ACE relatively platform independent. Thus, with little or no effort developers can move an ACE application from platform to platform. The OS adaptation layer is also the reason why the ACE framework is available on so many platforms. A few of the OS platforms on which ACE is available currently, include; real-time operating systems, (VxWorks, Chorus, LynxOS, RTEMS, OS/9, QNX Neutrion, and pSoS), most versions of UNIX (SunOS 4.x and 5.x; SGI IRIX 5.x and 6.x; HP-UX 9.x, 10.x and 11.x; DEC UNIX 3.x and 4.x; AIX 3.x and 4.x; DG/UX; Linux; SCO; UnixWare; NetBSD and FreeBSD), Win32 (WinNT 3.5.x, 4.x, Win95 and WinCE using MSVC++ and Borland C++), MVS OpenEdition, and Cray UNICOS.
2.2 The C++ Wrapper Facade Layer
The C++ wrapper facade layer includes C++ classes that can be used to build highly portable and typesafe C++ applications. This is the largest part of the ACE toolkit and includes approximately 50% of the total source code. C++ wrapper classes are available for:
。Concurrency and synchronization - ACE provides several concurrency and synchronization wrapper fa?ade classes that abstract the native OS multi-threading and multi-processing API. These wrapper facades encapsulate synchronization primitives, such as semaphores, file locks, barriers, and dondition variables. Higher-level synchronization utilities, such as Guards, are also available. All these primitives share similar interfaces and thus are easy to use and substitute for one another.
。IPC components - ACE provides several C++ wrapper fa?ade classes that encapsulate different inter-process communication (IPC) interfaces that are available on different operating systems. For example, wrapper fa?ade classes are provided to encapsulate IPC mechanisms, such as BSD Sockets, TLI, UNIX FIFOs, STREAM Pipes, Win32 Named Pipes. ACE also provides message queue classes, and wrapper facades for certain real-time OS-specific message queues.
。Memory management components - ACE includes classes to allocate and deallocate memory dynamically, as well as pre-allocation of dynamic memory. This memory is then managed locally with the help of management classes provided in ACE. Fine-grain memory management is necessary in most real-time and embedded systems. There are also classes to flexibly manage inter-process shared memory.
。Timer classes - Various classes are available to handle scheduling and canceling of timers. Different varieties of timers in ACE use different underlying mechanisms (e.g., heaps, timer wheels, or ordered lists) to provide varying performance characteristics. Regardless of which underlying mechanism is used, however, the interface to these classes remains the same, which makes it easy to use any timer implementations. In addition to these timer classes, wrapper fa?ade classes are available for high-resolution timers (which are available on some platforms, such as VxWorks, Win32/Pentium, AIX and Solaris) and Profile Timers.
。Container classes - ACE also includes several portable STL-type container classes, such as Map, Hash_Map, Set, List, and Array.
。Signal handling - ACE provides wrapper fa?ade classes that encapsulate the OS-specific signal handling interface. These classes simplify the installation and removal of signal handlers and allow the installation of several handlers for one signal. Also available are signal guard classes that can be used to selectively disable some or all signals in the scope of the guard.
。Filesystem components - ACE contains classes that wrap the filesystem API. These classes include wrappers for file I/O, asynchronous file I/O, file locking, file streams, file connection, etc.
。Thread management - ACE provides wrapper facades classes to create and manage threads. These wrappers also encapsulate the OS-specific threading API and can be used to provide advanced functionality, such as thread-specific storage.
2.3 The ACE Framework Components
The ACE framework components are the highest-level building blocks available in ACE. These framework components are based on several design patterns specific to the communication software domain. A designer can use these framework components to build systems at a much higher level than the native OS API calls. These framework components are therefore not only useful in the implementation stage of development, but also at the design stage, since they provide a set of micro-architectures and pattern langauges for the system being built. This layer of ACE contains the following framework components:
。Event handling framework - Most communication software includes a large amount of code to handle various types of events, such as I/O-based, timer-based, signal-based, and synchronization-based events. These events must be efficiently de-multiplexed, dispatched and handled by the software. Unfortunately, developers historically end up re-inventing the wheel by writing this code repeatedly since their event de-multiplexing, dispatching, and handling code were tightly coupled and could not be used independent of one another. ACE includes a framework component called the Reactor to solve this problem. The Reactor provides code for efficient event de-multiplexing and dispatching, which de-couples the event demultiplexing and dispatch code from the handling code, thereby enhancing re-usability and flexibility.
。Connection and service initialization components - ACE includes Connector and Acceptor components that decouple the initiation of a connection from the service performed by the application after the connection has been established. This omponent is useful in application servers that receive a large number of connection requests. The connections are initialized first in an application-specific manner and then each connection can be handled differently via the appropriate handling routine. This decoupling allows developers to focus on the handling and initialization of connections separately. Therefore, if at a later stage developers determine the number of connection requests are different than they estimated, they can chose to use a different set of initialization policies (ACE includes a variety of default policies) to achieve the required level of performance.
。Stream framework - The ACE Streams framework simplifies the development of software that is intrinsically layered or hierarchic. A good example is the development of user-level protocol stacks that are composed of several interconnected layers. These layers can largely be developed independently from each other. Each layer processes and changes the data as it passes through the stream and then passes it along to the next layer for further processing. Since layer can be designed and configured independently of each other they are more easily re-used and replaced.
。Service Configuration framework - Another problem faced by communication software developers is that software services often must be configured at installation time and then be reconfigured at run-time. The implementation of a certain service in an application may require change and thus the application must be reconfigured with the update service. The ACE Service Configurator framework supports dynamic initialization, suspend,resumption, reconfiguration, and termination of services provided by an application. Although there have been rapid advances in the field of computer networks, the development of communication software has become more harder. Much of the effort expended on developing communication software involves "re-inventing the wheel," where components that are known to be common across applications are re-written rather then re-used. ACE addresses this problem by integrating common components, micro-architectures, and instances of pattern languges that are known to be reusable in the network and systems programming domains. Thus, application developers can download and learn ACE, pick and choose the components needed to use in their applications, and build and integrate concurrent networking applications quickly. In addition to capturing simple building blocks in its C++ wrapper facade layer, ACE includes larger framework components that capture proven micro-architectures and pattern languages that are useful in the realm of communication software.
3.The ACE Features
ACE provides significant advantages to development teams building mission-critical C++ applications, including:
。Broad functionality and multithread safety. ACE contains the fundamental components developers need for virtually programming task in C++, with specialized functionality for multithreading. All ACE components are multithread safe, so developers can count on them to behave the same in a multithreaded environment or in a single-threaded environment.
。Higher-level, object-oriented interfaces to complex underlying APIs. The consistent, object-oriented interfaces in ACE shorten the learning curve, increasing developer productivity and the ability to deliver projects on schedule. By letting ACE manage the granular details, developers can get a head start on solving the business logic challenges unique to their applications.
。Integration and neutrality. All ACE components work together with TAO, and also work with a variety of industry-leading operating systems, compilers, and threading libraries.
。Flexible, cross-platform extensibility. Applications built using ACE can run on multiple operating systems, including Windows, Linux, and other popular UNIX operating systems, with minimal code changes. ACE interfaces are consistent across platforms, allowing developers in many cases to simply recompile and run their application on a different platform without rewriting any code at all. This flexibility is an essential advantage in the face of changing business requirements.
。Full source code. ACE is with full source code.Then you may have no worry of the software security.And if you have the need of changing some of the source code,you can do it yourself.
。Zero License Fee. Zero-license fee and high quality service which huihoo can provide will benefit you.
。Fully-tested and field-proven code offering the performance of C++. ACE and TAO are being used in thousands of commercial products at many companies, as well as at various universities and research labs around the world, in many types of communication systems, particularly telecom, medical, aerospace, and financial services.
。Support and services from an established vendor. Technical support, mentoring,training, and consulting from huihoo helps support development efforts and ensure project success.
4.Benefits of Using ACE
Some of the many benefits of using ACE include:
。Increased portability -- ACE components make it easy to write concurrent networked applications on one OS platform and quickly port them to many other OS platforms. Moreover, because ACE is open source, free software, you never have to worry about getting locked into a particular operating system platform or compiler configuration.
。Increased software quality -- ACE components are designed using many key patterns that increase key qualities, such as flexibility, extensibility, reusability, and modularity, of communication software.
。Increased efficiency and predictability -- ACE is carefully designed to support a wide range of application quality of service (QoS) requirements, including low latency for delay-sensitive applications, high performance for bandwidth-intensive applications, and predictability for real-time applications.
。Easier transition to standard higher-level middleware -- ACE provides the reusable components and patterns used in The ACE ORB (TAO), which is an open-source standard-compliant implementation of CORBA that's optimized for high-performance and real-time systems. Thus, ACE and TAO are designed to work well together in order to provide comprehensive middleware solutions.
5.Huihoo's services for you
Huihoo will be providing two courses for you "Advanced CORBA programmig with Java" and "Advanced CORBA programming with C++". We'll develop some useful tools and more CORBA services on ACE and TAO for our customers. Of course we'll add it to open-source distribution. Huihoo has skilled Java，C++，software engineering CORBA consultants who can provide your software engineers with ACE and TAO products support. We can help you solve your application problems.
Huihoo was found in 2001.She is consisting of many CORBA and EJB fans all devoting into middleware developping and applying. We have successfully started our own opensource CORBA and J2EE opensource products named Orbas and JFox.
ACE+TAO Commercial Support: http://www.cs.wustl.edu/~schmidt/commercial-support.html
Email: [email protected] and [email protected]