ACE is a enormously moveable, common, open-source host infrastructure middleware toolkit. The source code is freely accessible from https://killexams.com/vendors-exam-list or http://
www.riverace.com/. The core ACE library consists of roughly a quarter million lines of C++ code that comprises approximately 500 courses. many of these courses cooperate to kind ACE's essential frameworks. The ACE toolkit also includes greater-level components, as well as a big set of examples and an extensive automatic regression verify suite.
To separate issues, in the reduction of complexity, and let useful subsetting, ACE is designed the use of a layered architecture [POSA1], proven in figure 1.7. The capabilities provided by means of ACE span the session, presentation, and application layers within the OSI reference model [Bla91]. The groundwork of the ACE toolkit is its aggregate of an OS adaptation layer and C++ wrapper facades, which together encapsulate core OS network programming mechanisms to run portably on all of the OS platforms shown in Sidebar 2 (web page 16). The bigger layers of ACE construct on this foundation to deliver reusable frameworks, networked carrier components, and standards-based mostly middleware.
figure 1.7: The Layered architecture of ACE1.4.2 A Synopsis of the ACE Frameworks
The ACE frameworks are an integrated set of classes that can be instantiated and customised to supply complete networked applications and repair add-ons. These frameworks assist to switch decades of accumulated capabilities at once from the ACE developers to
Sidebar 2: OS systems Supported by ACE
ACE runs on a wide array of operating programs, including:
PCs, as an example, windows (32- and 64-bit versions), WinCE, and Macintosh OS X
Most types of UNIX, for instance, SunOS/Solaris, IRIX, HP-UX, Tru64 UNIX (Digital UNIX), AIX, DG/UX, Linux (Redhat, Debian, and SuSE), SCO OpenServer, UnixWare, NetBSD, and FreeBSD
actual-time operating systems, as an instance, VxWorks, ChorusOS, LynxOS, Phar-lap TNT, QNX Neutrino and RTP, RTEMS, and pSoS
big commercial enterprise techniques, as an instance, OpenVMS, MVS OpenEdition, Tandem NonStop-UX, and Cray UNICOS.
ACE can be used with all the predominant C++ compilers on these platforms. The ACE internet website at https://killexams.com/exam-simulator a complete, updated checklist of platforms, along with instructions for downloading and constructing ACE.
ACE users in the sort of advantage embodied in smartly-validated and reusable C++ software artifacts. The ACE frameworks enforce a pattern language for programming concurrent object-oriented networked functions. determine 1.8 illustrates the ACE frameworks. to illustrate how the ACE frameworks rely on and use each other, the lines between bins symbolize a dependency in the course of the arrow. each and every framework is printed beneath.
figure 1.eight: the key Frameworks in ACE
ACE Reactor and Proactor frameworks. These frameworks implement the Reactor and Proactor patterns [POSA2], respectively. each are architectural patterns that permit functions to be driven by activities that are delivered to the application from one or extra experience sources, essentially the most critical of that are I/O endpoints. The Reactor framework helps a reactive I/O mannequin, with pursuits signaling the capacity to start a synchronous I/O operation. The Proactor framework is designed for a proactive I/O model the place one or greater asynchronous I/O operations are initiated and the completion of each operation triggers an experience. Proactive I/O fashions can achieve the efficiency merits of concurrency with out incurring lots of its liabilities. The Reactor and Proactor frameworks automate the detection, demultiplexing, and dispatching of utility-defined handlers in accordance with many sorts of hobbies. Chapters three and four describe the ACE Reactor framework and Chapter eight describes the ACE Proactor framework.
ACE carrier Configurator framework. This framework implements the component Configurator pattern [POSA2], which is a design pattern that enables an software to hyperlink and unlink its part implementations without needing to regulate, recompile, or relink the utility statically. The ACE provider Configurator framework helps the config-uration of applications whose services will also be assembled late within the design cycle, comparable to at installation time and/or run time. functions with excessive availability requirements, corresponding to mission-essential techniques that perform online transaction processing or real-time industrial procedure automation, regularly require such bendy configuration capabilities. Chapter 2 describes the design dimensions linked to configuring networked functions and Chapter 5 describes the ACE provider Configurator framework.
ACE project framework. This framework implements quite a few concurrency patterns, akin to lively Object and Half-Sync/Half-Async [POSA2]. energetic Object is a design pattern that decouples the thread that executes a technique from the thread that invoked it. Its aim is to raise concurrency and simplify synchronized entry to things that reside in their own threads of handle. Half-Sync/Half-Async is an architectural pattern that decouples asynchronous and synchronous processing in concurrent techniques, to simplify programming without reducing efficiency unduly. This pattern comprises two intercommunicating layers, one for asynchronous and one for synchronous service processing. A queueing layer mediates communication between capabilities in the asynchronous and synchronous layers. Chapter 5 of C++NPv1 describes the design dimensions linked to concurrent networked purposes and Chapter 6 of this ebook describes the ACE project framework.
ACE Acceptor-Connector framework. This framework leverages the Reactor framework and reifies the Acceptor-Connector pattern [POSA2]. This design pattern decouples the connection and initialization of cooperating peer services in a networked system from the processing they operate once linked and initialized. The Acceptor-Connector framework decouples the lively and passive initialization roles from utility-described service processing carried out with the aid of speaking peer capabilities after initialization is comprehensive. Chapter 7 describes this framework.
ACE Streams framework. This framework implements the Pipes and Filters pattern, which is an architectural pattern that offers a structure for programs that process a circulation of facts [POSA1]. The ACE Streams framework simplifies the construction and composition of hierarchically layered capabilities, akin to person-degree protocol stacks and community management agents [SS94]. Chapter 9 describes this framework.
When used collectively, the ACE frameworks outlined above allow the construction of networked functions that can also be up-to-date and extended without the need to alter, recompile, relink, or restart working applications. ACE achieves this unprecedented flexibility and extensibility by means of combining
OS mechanisms, reminiscent of adventure demultiplexing, IPC, dynamic linking, multithreading, multiprocessing, and synchronization [Ste99]
C++ language aspects, corresponding to templates, inheritance, and dynamic binding [Bja00]
Patterns, corresponding to element Configurator [POSA2], method [GoF], and Handler/Callback [Ber95]
The ACE frameworks deliver inversion of handle via callbacks, as proven below:
Inversion of manage
Reactor and Proactor
Calls again to utility-offered event handlers to function processing when movements happen synchronously and asynchronously.
Calls back to utility-supplied service objects to initialize, suspend, resume, and finalize them.
Calls again to an application-offered hook system to operate processing in one or greater threads of handle.
Calls lower back to service handlers to initialize them after they're connected.
Calls lower back to initialize and finalize initiatives when they are pushed and popped from a movement.
The callback methods in ACE's framework classes are defined as C++ digital strategies. This use of dynamic binding allows networked functions to freely put into effect and lengthen interface strategies without editing or rebuilding latest framework classes. In distinction, the ACE wrapper facades rarely use callbacks or digital strategies, so that they don't seem to be as extensible because the ACE frameworks. The ACE wrapper facades do guide a huge latitude of use cases, besides the fact that children, and might be built-in together by way of general programming [Ale01] innovations in keeping with the C++ features and traits courses idioms outlined in Sidebar 40 (page one hundred sixty five).
determine 1.9 illustrates how the class libraries and frameworks in ACE are complementary technologies. The ACE toolkit simplifies the implementation of its frameworks by the use of its category libraries of containers, which consist of lists, queues, hash tables, strings, and other reusable information structures. Likewise, application-defined code invoked by using adventure handlers within the ACE Reactor framework can use the ACE wrapper facades and the C++ regular library classes [Jos99] to function IPC, synchronization, file administration, and string processing operations. Sidebar 3 describes how to build the ACE library so that you should experiment with the examples they existing in this publication.
determine 1.9: making use of classification Libraries to improve and Use ACE Frameworks
Sidebar three: building ACE and classes that Use ACE
ACE is open-supply software that you can download from https://killexams.com/project-management. edu or https://killexams.com/exam-list/Medical and build your self. These websites include a wealth of alternative cloth on ACE, equivalent to tutorials, technical papers, and a top level view of different ACE wrapper facades and frameworks that don't seem to be lined during this booklet. that you may also purchase a prebuilt version of ACE from Riverace at a nominal cost. See https://killexams.com/exam-list/Medical for a list of the prebuilt compiler and OS platforms supported by Riverace.
if you want to build ACE yourself, be sure to download and unpack the ACE distribution into an empty directory. The precise-degree directory in the distribution is termed ACE_wrappers. They check with this accurate-level directory as "ACE_ROOT." be sure to create an atmosphere variable by that name containing the whole course to the correct-degree ACE directory. The ACE supply and header files live in $ACE_ROOT/ace.
The $ACE_ROOT/ACE-installation.html file has finished instructions for building ACE, together with a way to configure it on your OS and compiler. This publication's networked logging carrier instance supply and header info reside in $ACE_ROOT/examples/ C++NPv2 and are able to construct on all structures that ACE supports. To build your own courses, the $ACE_ROOTdirectory need to be brought to your compiler's file include course. For command-line compilers, this may also be executed with the -Ior /Icompiler choice. Graphical IDEs give an identical alternatives, akin to MSVC++'s "Preprocessor, further consist of directories" portion of the C/C++ tab on the project Settings dialog box.