Date: Sat, 03 May 1997 20:33:23 -0500 From: Nanbor Wang <nw1@cs.wustl.edu> To: freebsd-hackers@freebsd.org Cc: "Thomas S. Traylor" <ttraylor@titan.cs.mci.com>, Amancio Hasty <hasty@rah.star-gate.com> Subject: ACE on FreeBSD Message-ID: <199705040133.UAA14739@siesta.cs.wustl.edu>
next in thread | raw e-mail | index | archive | help
Hi All, Thanks to the help many of you gave me, the Adaptive Communication Environment (ACE) is now officially supporting FreeBSD in its latest beta release. Originally developed by Douglas Schmidt (and currently maintained by him,) ACE is an OO toolkit that implements many design patterns for communication software. Attached is a very brief introlduction of ACE. You can get the latest ACE beta release at http://www.cs.wustl.edu/~schmidt/ACE_wrappers/ACE.tar.gz For more detailed information about ACE, please check, http://www.cs.wustl.edu/~schmidt/ACE.html At this moment, the non-threaded version of ACE seems to work fine. Most tests and examples that I've tried work. However, there are still some problem with the threaded version. This is primary because of the automatical non-block feature (bug?) that associates with send/recv while linking with libc_r. Since ACE is for writing communication programs and this breaks the most basic operation of ACE, I can't say threaded version of ACE works at this moment. I have run most of the tests and examples included but not all of them. Amancio has ported ACE once. I have grabbed his port yesterday and will check his port with the current release so that I can incorporate his work into official release. The port currently still need more extensive tests. Therefore, if anyone of you are interested in giving it a try, please grab it from the above URL and let me know if any questions/problems arise. Regards, Nanbor Wang ---------------------------------------------------------------------- Overview of ACE (from <http://www.cs.wustl.edu/~schmidt/ACE-overview.html>) The ADAPTIVE Communication Environment (ACE) is an object-oriented (OO) toolkit that implements fundamental design patterns for communication software. ACE provides a rich set of reusable C++ wrappers, class categories, and frameworks that perform common communication software tasks across a range of operating system platforms. The communication software tasks provided by ACE include event demultiplexing and event handler dispatching, service initialization, interprocess communication, shared memory management, message routing, dynamic (re)configuration of distributed services, multi-threading, and concurrency control. ACE is targeted for developers of high-performance and real-time communication services and applications on UNIX, POSIX, and Win32 platforms. ACE simplifies the development of OO network applications and services that utilize interprocess communication, event demultiplexing, explicit dynamic linking, and concurrency. 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 has been ported to a wide range of uni-processor and multi-process OS platforms including Win32 (i.e., WinNT and Win95), most versions of UNIX (e.g., SunOS 4.x and 5.x, SGI IRIX, DG/UX, HP-UX, OSF/1, AIX, Linux, SCO, and FreeBSD), VxWorks, and MVS OpenEdition. It is currently used in commercial products by dozens of companies. There are C++ and Java versions of ACE available. C++ Wrappers for OS Interfaces The lower-level portions of ACE provide a set of portable and type-secure C++ wrappers that encapsulate the following C language OS interfaces: IPC mechanisms -- e.g., Internet- and UNIX-domain sockets, TLI, Named Pipes (for UNIX and Win32) and STREAM pipes; Event multiplexing -- e.g., select(), poll(), and Win32 WaitForMultipleObjects and I/O completion ports; Multi-threading and synchronization -- e.g., Solaris threads, POSIX Pthreads, and Win32 threads; Explicit dynamic linking -- e.g., dlopen/dlsym on UNIX and LoadLibrary/GetProc on Win32; Memory-mapped files and shared memory management -- e.g., BSD mmap(), SYSV shared memory, and Win32 shared memory; System V IPC -- e.g., shared memory, semaphores, message queues. The OS Adaptation Layer shields the upper levels of ACE from platform dependencies associated with the underlying OS interfaces. Frameworks and Class Categories ACE also contains a higher-level network programming framework that integrates and enhances the lower-level C++ wrappers. This framework supports the dynamic configuration of concurrent distributed services into applications. The framework portion of ACE contains the following class categories: The Reactor -- Supports both Reactive and Proactive I/O; The Service Configurator -- -- Support dynamic (re)configuration of objects; The ADAPTIVE Service Executive -- A user-level implementation of System V STREAMS, that supports modular integration of hierarchically-related communicaion services; Concurrency -- Various types of higher-level concurrency control and synchronization patterns (such as Polymorphic Futures and Active Objects); Shared Malloc -- Components for managing dynamically allocation of shared and local memory; CORBA integration -- Integrates ACE with CORBA implementations (such as single-threaded and multi-threaded Orbix and Visibroker for C++). The class categories in the higher-level framework work portably on UNIX and Win32. Distributed Services and Components Finally, ACE provides a standard library of distributed services that are packaged as components. These service components play two roles in ACE: 1. They provide reusable components for common distributed system tasks such as logging, naming, locking, and time synchronization; 2.They illustrate how to utilize ACE features such as the Reactor, Service Configurator, Service Initialization, Concurrency, and IPC components. Future Directions of ACE ACE is continually evolving and improving -- it's future is looking bright. Shortly, we hope to have ACE supported commercially, in much the same way that Cygnus Solutions operates. In addition, many members of the ACE development team are currently working on building a high-performance, real-time ORB using ACE. ---------------------------------------------------------------------- (Please check out <http://www.cs.wustl.edu/~schmidt/ACE.html>; for more detailed information about ACE.)
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?199705040133.UAA14739>