The following table summarizes platforms on which ACE runs:
| Fully supported, i.e., continually tested and used daily | Solaris 2.5, 2.6, and 7, Windows NT (MSVC++ 4.x, 5.0, and 6.0), DEC Alpha Windows NT (MSVC++ 5.0), Linux/Intel, Linux/Alpha, VxWorks, LynxOS, Digital UNIX 4.0, HP/UX, AIX | 
| Nearly fully supported, i.e., periodically tested | Windows 95, IRIX 6.x, MVS | 
| Partially supported, i.e., infrequently tested | Windows CE, Tandem, Chorus, SCO, UnixWare, SunOS 4.x, FreeBSD, NetBSD | 
| Planned support, i.e., pending | pSoS, | 
Any UNIX/POSIX/Win32 variation is a potential target platform for ACE. If you have porting questions or have a problem compiling the ACE wrappers on the platforms shown above please send email to either ACE Newsgroup or the ACE mailing list and we'll try to help you fix the problems.
All of ACE has been ported to the Win32 API (which includes Windows NT and Windows '95). The entire release now compiles using the Microsoft Visual C++ 4.x, 5.0, and 6.0 compilers (the 2.0 compiler may also work, but we haven't tested it recently). ACE can be built as both a static and dynamic library, using the Win32 installation process described below.
Please see the Non-static ACE_Object_Manager discussion below.
Most of ACE has been ported to Windows CE using Visual C++ 5.0 with CE Toolkit. ACE has been tested on x86 Emulator and an HP 360LX with an SH series CPU. Please be sure to read this file (CE-status.txt) for up-to-date information about ACE on CE. ACE can only be built as DLL library now.
All the source code and tests should build and run without any problems on Solaris 2.5.1, 2.6 and 7 platforms using the Sun C++ compiler. We use this version/patchlevel of Sun C++:
      CC: WorkShop Compilers 4.2 21 Apr 1997 C++ 4.2 patch 104631-02
      There are likely to be build problems with older versions or different patchlevels of Sun C++.
Thanks to Susan Liebeskind <shl@janis.gtri.gatech.edu> for providing the following useful information:
The home page for Sun technical patches is http://access1.sun.com. Searching for 104631 will bring you to a page allowing you to access the latest version of the C++ 4.2 patches.
      By default, ACE uses both the Solaris and POSIX thread interface.
      To disable use of the Solaris thread interface, add
      -D_POSIX_PTHREAD_SEMANTICS to the CFLAGS
      in your
      ACE_wrappers/include/makeinclude/platform_macros.GNU.
      See the Solaris Intro (3) man page for more information.
      To disable ACE thread support completely, build with the
      threads=0 make flag.  See the Makefile
      Flags section below for more information on make flags.
If you use g++ or egcs on Solaris 7, you might need to rebuild it on a SunOS 5.7 (Solaris 7) host. Some versions of g++ and egcs provide replacements for system header files. The replacements on older SunOS systems are not compatible with the SunOS 5.7 system headers. See David Levine's Hints page for instructions on how to build egcs on a SunOS 5.7 host, using a g++ or egcs that was built on an older SunOS host.
Note that shared libraries do not interact very well with Centerline C++ or Sun C++ on SunOS 4.1.x. This is due to odd behavior of the SunOS 4.1.x linker, which (1) does not properly call constructors of global objects within shared libraries and (2) does not call the init() and fini() functions in shared libraries, even though the manual claims that these functions are called! In particular, this means that the tests in the directory $(ACE_ROOT)/tests/Service_Configurator/IPC-tests/server/ will not work for statically linked services.
Some versions of SunOS 4.1.x do not contain the /usr/lib/libnsl.a library. This library seems to be optional since System V Transport Layer Interface (TLI) support is optional on SunOS 4.1.x (in contrast, it's the "preferred" transport interface on Solaris).
The best work-around for now is probably to either add a dummy libnsl.a in /lib (which may not be feasible) or simply comment out the line:
LIBS += -lnsl
      in the $ACE_ROOT/include/makeinclude/wrapper_macros.GNU
      file.  Naturally, any programs, e.g., the TLI_SAP tests,
      that use the TLI wrappers aren't going to work!
Note that on SunOS 4.x you may get warnings from the linker that "archive has no table of contents; add one using ranlib(1)" for certain libraries, e.g., libASX.a, libThreads.a, and libSPIPE.a. This occurs since SunOS 4.x does not support these features.
The ACE port to AIX assumes that the user has installed the AIX patch containing the dl*() APIs. To use these APIs, IBM has created a separate product (free to AIX licensees) called shared library hookable symbols (or slhs/6000). If you don't have this patch, the sv* commands for compiling and linking will not be present on the system.
If you are using AIX 4.2.1 or later, this patch isn't needed; the dynamic library APIs are included in the base operating system.
However, another patch may be needed. Thanks to Susan Liebeskind <shl@janis.gtri.gatech.edu> for submitting the following useful information:
When building on AIX 4.2.1, using the xlC V3.1 compilers, you may get the following error when building the ACE shared library.
makeC++SharedLib_r -p 0 -o libACE.so  -bI:/lib/pse.exp  -L/usr/local/src/ACE_wra
ppers/ace -L./ -ltli_r -ldl libACE.a
ld: 0711-317 ERROR: Undefined symbol: .__CurrentException
ld: 0711-345 Use the -bloadmap or -bnoquiet option to obtain more information.
make: *** [libACE.so] Error 8
      
      To fix this error, you need a patch to the supporting xlC related
      libraries.  To obtain this patch, go to the
      IBM
      public patch website, and retrieve the patch
      PTF U453697, or its successor, for xlC.You may wish to retrieve this patch with the fixdist tool, also available at the website. Installation of this patch will install patched versions of the C++ libraries, which correctly define this symbol.
BTW, here's a technique from Rob Jordan <jordan@hursley.ibm.com> that can reduce the size of the ACE libraries by about one third, and can also be applied to applications. It works by optimising the sharing of template functions, which are created in an ``unusual'' way under AIX. It also speeds up compilation.
Here's how to optimise the ACE library generation:
      Look at the Makefile
      in $ACE_ROOT/ace. Create a file called
      ACE_All_Src.cpp, and add a line to #include
      each of the source files
      listed under FILES= in the Makefile. Create a
      file called ACE_All_Tmp.h
      and add a line to #include each of the .h files listed under
      TEMPLATE_FILES= in the Makefile. Now update the Makefile so that
      FILES=ACE_All_Src and TEMPLATE_FILES=ACE_All_Tmp.
      ACE has been ported to Linux on both Intel
      and Alpha platforms.  If you use a RedHat 5.x distribution, it's best
      to use RedHat 5.1 or later.  ACE works without any modifications on
      RedHat 5.1, 5.2, and 6.0, and on Debian 2.1 on both Intel and Alpha;
      use the include/makeinclude/platform_linux_lxpthreads.GNU
      and ace/config-linux-lxpthreads.h platform/config
      files.
      The glibc 2.0 dynamic loader isn't thread safe. If you want to use the
      Invocation API you'll have to set LD_BIND_NOW=true. If you
      want to use dlopen, you should use RTLD_NOW.
      The dynamic loader in glibc 2.1 is thread safe.
      The ACE Tokens_Test hangs with egcs 1.1b on   Linux.  It
      runs properly when built with egcs 1.0.2, egcs 1.0.3 and egcs 1.1.1.
      All other ACE tests run properly with these egcs versions.
NOTE: The TAO NameService uses IP multicasting by default, though it is not required. IP multicast on Linux requires the following:
ace/config-linux-common.h.  If you don't use
            IP multicast, add #define ACE_HAS_IP_MULTICAST 0
            to your ace/config.h before building ACE.
eth0.  If
            you don't have or use linuxconf, try adding a multicast
            routing table entry using something like this:
             # route add -net 224.0.0.0 netmask 240.0.0.0 dev eth0
            
      NOTE: Be careful when installing egcs on RedHat
      systems.  If you don't remove your old gcc and libg++ RPMs, it's best
      to install egcs in a different directory than /usr, such as
      /usr/local, and set your PATH and
      LD_LIBRARY_PATH accordingly.
Some of the ACE tests fail on older, pre-glibc2 Linux platforms, such as RedHat 4.2. The problems are with threads and thread-specific storage.
ACE has been ported to SCO UNIX using the GNU g++ 2.7.2 compiler. Arturo Montes <mitosys@colomsat.net.co> maintains this code. In addition, he also maintains a version of FSU pthreads.
ACE used to build fine using the SGI C++ and GNU GCC compilers for IRIX 5.x. It has been ported to IRIX 6.x using the SGI MipsPro 7.1 C++ compiler; be aware that in IRIX 6.2 there is a number of patches that have to be installed and exceptions appear to fail with the O32 ABI. Please check the config files for the details.
HP sells 2 C++ compilers for HP-UX 10.x and 11.00. If you are using 9.x, there's only the first one.
The Digital UNIX C++ 5.4 through 5.7 compilers have problems with ACE's templates. They compile the lib and most of the test programs, although they warn about template usage. Most tests run, some dump core. If you use a 5.x version of cxx, be sure to set the CXX_VER variable to CXX_5, either on your make command line or in an environment variable. The ACE Makefiles assume by default that the cxx version is 6.x or later.
CXX 6.0 and 6.1 are much improved over 5.x: V6.0-020, V6.1-025, and later build all of ACE cleanly. All of the tests in ACE_wrappers/tests run successfully with CXX 6.0 and CXX 6.1. Please note that problems have been reported with some versions of CXX 6.1, notably versions -021 and earlier. It's best to use V6.1-022 or later.
GNU gcc 2.7.2.1 compiles without problems. All tests run (besides minor problems). Thanks to Thilo Kielmann < kielmann@informatik.uni-siegen.de> and David Trumble <trumble@cvg.enet.dec.com> for help with this port.
FreeBSD is a fast evolving platform. However, it has the advantage of having standard releases. At this moment, ACE supports both -stable (2.2.x) and -current (3.0). Threaded version of ACE is only supported on -current. It might just work for -stable but we never tried that.
      Notice that on FreeBSD, ld.so only looks for so
      libraries with version number appended.  ACE makefiles
      create symlink for most libraries they generate to
      $ACE_ROOT/ace with appropriate ACE version.
      However, this does not work for libACE.so itself so you have to
      create it manually (If you figure out how to do this, please
      let us know) like this: 
      ln -sf $ACE_ROOT/ace/libACE.so $ACE_ROOT/ace/libACE.so.4.5
      Like FreeBSD, NetBSD's ld.so also requires
      versioned .so files.
Steve Huston <shuston@riverace.com> has ported ACE to work with UnixWare 2.01 and g++.
Ganesh Pai <gpai@voicetek.com> subsequently did the port for version 2.1.2, also with g++.
Wei Chiang <chiang@tele.nokia.fi> has ported ACE to Chorus 3.1 using GNU g++ 2.7.2.
      ACE builds and runs properly on LynxOS 3.0.0 for Intel targets.
      Some of the ACE tests fail; they are disabled in
      ACE_wrappers/tests/run_tests.sh.
ACE builds cleanly on LynxOS 3.0.0 for PowerPC targets. For the most part, it runs properly. But, there appears to be a problem with registering signal handlers. So, some of the ACE tests seg fault when attempting to do that.
Please see the comments in the ACE platform_lynxos.GNU file for information on, and an example of, tailoring for your particular platform.
We actively maintain ACE on LynxOS 3.0.0. It should build and run on LynxOS 2.5, but we no longer test on that OS version.
      NOTE: if you want to use IP multicast on LynxOS, be sure to add
      this line to your /net/rc.network, and reboot:
        /bin/route add "224.0.0.0" "$my_name"
      
David Levine <levine@cs.wustl.edu> has ported ACE to VxWorks 5.2/5.3/5.3.1 with the GreenHills 1.8.8 and g++ 2.7.2 compilers.
In addition to all of the other benefits of ACE, it helps work around some deficiencies with VxWorks 5.3/5.3.1. Some of these apply only with g++, at least thru version 2.7.2. That is the version that is shipped with Tornado 1.0.1/ VxWorks 5.3.1. The problems are:
Please note that ACE uses one of the spare fields in the Wind River task control block, spare4, for thread- specific storage. This field is specified in only one place, in ace/OS.i, so it can easily be changed to one of the other spare fields, if necessary.
      Versions of ACE from 4.3.3 and beyond destroy dynamically
      allocated singletons in the ACE library.  But, they may not
      properly destroy some static objects.  If you have trouble
      running a program multiple times, it may be necessary to
      unload the module, using unld, and reload it between runs.
      Alternatively, you could try calling cplusDtors
      and then cplusCtors between runs.
All of ACE has been ported to OpenEdition by Chuck Gehr <gehr@sweng.stortek.com>. The ACE library, all the tests and most of the examples and apps build clean. There are still some problems that need to be ironed out:
MVS does not support the dynamic linking dl...() calls that the Service Configurator uses to dynamically link services at run time. As a result, all the examples and apps that use a svc.conf file (for dynamically configuring service objects) do not work, however, most of these apps can be built/run statically. Also, the Svc_Conf_l.cpp and Svc_Conf_y.cpp files are generated using flex and yacc on a ascii (not ebcdic) machine and as a result they don't work very well with ebcdic svc.conf files. We should be able to regenerate these files on MVS but MVS doesn't have flex. This is something that needs to be done.
Some of the tests do not execute properly. This is a minority and over time the goal is to get to 100%.
The make scheme for some of the apps still doesn't work perfectly on MVS. This is mainly due to the way shared libraries are handled on MVS. See additional build tips for MVS for more on this.
        /usr/ccs/lib/libgen.a(reg_compile.o): In function `_get_vars_storage':
        reg_compile.o(.text+0x30): relocation truncated to fit: R_SPARC_GOT13 free
      
      the suggested workaround is to comment out the ACE_HAS_REGEX
      #define in ace/config-sunos5.5.h.
      Or better, create an ace/config.h that looks like:
      
      #ifndef ACE_CONFIG_H
      // ACE_CONFIG_H is defined by the following #included header.
      #include "ace/config-sunos5.5.h"
      #undef ACE_HAS_REGEX
      #endif /* ACE_CONFIG_H */
      
      We don't know what causes the link problem, though the
      workaround solves it.
% make optimize=0OCFLAGS line.
config.status
      file.  This file is produced when installing gcc; it specifies
      where to install the binary files that gcc uses.  For example,
      it specifies whether to use Solaris's
      /usr/ccs/bin binary utils or GNU binary
      utils.  The config.status file is an output of
      the gcc configure script; it is preferable to use
      the --prefix option to configure instead
      of hacking its output.
      NOTE: if you do use the GNU linker, you might need to change
      the -G flag to -shared in
      the SOFLAGS definition in your
      include/makeinclude/platform_macros.GNU.
collect2.
repo=1
      to your make invocation, or to your
      include/makeinclude/platform_macros.GNU.  ACE
      still uses explicit template instantiation for building its
      libraries to help avoid link conflicts.  Please see the g++
      FAQ and gcc manual for more information on the -frepo option.
-fno-implicit-templates option from the
      CCFLAGS macro in your include/makeinclude/platform_macros.GNU, and
      thereby use the default g++ implicit template instantiation.
-fno-exceptions to egcs (and g++ starting with version
      2.8.0) invocations.  This disables exception handling support.  On
      Solaris/sparc and Linux/alpha, it results in a 25 percent reduction
      in the size of libACE.so.  To enable exception handling, add
      exceptions=1 to your make command line
      invocation, or to your
      $ACE_ROOT/include/makeinclude/platform_macros.GNU.
      If you need or want to use egcs' shared libraries, build it
      with the --enable-shared egcs config option.  The
      --enable-shared option is not an
      egcs run-time option.  Build egcs in a way similar to the
      following example:
      
         $ ./configure --enable-shared
         $ make bootstrap
      LD_LIBRARY_PATH environment
      variable, if necessary, to pick up those shared libraries.
PAGE_SIZE to 8192.  Then rebuild ACE.  Thanks to
      Ganesh Pai for this
      information.
      % setenv ACE_ROOT /home/cs/faculty/schmidt/ACE_wrappers
      However, if you're building a number of versions of ACE, e.g., for different OS platforms or for different releases of ACE, you might use the following approach:
      % setenv ACE_ROOT $cwd
      
$ACE_ROOT/ace/config.h file that includes
      the appropriate platform/compiler-specific header configurations
      (such as config-sunos5-sunc++-4.x.h).  This file
      contains the #defines that
      are used throughout ACE to indicate which features your system
      supports (see the $ACE_ROOT/ace/OS.h file for many
      examples of how the ACE build configuration is affected by these
      macro settings).  Make sure you settings are placed
      before the inclusion of the platform-specific
      header file.There are config files for most versions of UNIX. If there isn't a version of this file that matches your platform/compiler, you'll need to make one. Please send me email if you get it working so I can add it to the master ACE release.
      % setenv LD_LIBRARY_PATH $ACE_ROOT/ace:$LD_LIBRARY_PATH
      
      % make
      
      at the root of the ACE source tree.  This will build the ACE library,
      tests, the examples, and the sample applications.  Building the entire
      ACE release can take a long time, however.  Therefore, you might
      consider cd'ing into the $ACE_ROOT/ace/ directory and running
      make there to build just the ACE library.  As a sanity
      check, you might also want to build and run the automated ``one-button'' tests in
      $ACE_ROOT/tests/.
ACE contains project files for Microsoft Visual C++ 4.x (*.mdp) and 5.0 with Service Pack 3, and 6.0 (*.dsw), as well as Borland C++ 5.x (ace.ide).
There are also project group files (BPG) to compile ACE and the one-button tests with Borland C++ Builder 3.0. This port has not been completed yet, so basically you are on your own here. The port was started by Gonzalo A. Diethelm, so contact him for any further directions.
Note concerning MSVC 5.0 and Service Pack 3: There has been confusion regarding MSVC 5 and its Service Pack 3. Some ACE users have, in the past, had problems with SP3 that were not present in SP2. Thanks to the diligent efforts of Bill Fulton, the mystery appears to be solved. The key? (Oh, this is a good one...) It would appear that there are actually multiple versions of SP3 in existence. The earlier ones have the bug, while later ones have it fixed. The service pack downloadable from Microsoft's web site as of June 16, 1998 works fine. The CD containing SP3, if it has part number X03-50158 on the disc (the part number on the jacket is probably different), also works fine.
So, if you are experiencing problems with SP3, get a newer one - it'll probably work. Sheesh...
Note, however, that regardless of the version of SP3, there are some STL bugs in SP3 which you should get corrected. Please see http://www.dinkumware.com/vc_fixes.html for details. Thank you to Ben Eng for the pointer to the STL fixes.
config.h in the ACE_ROOT\ace
      directory that contains: #include "ace/config-win32.h"#define ACE_HAS_WINNT4 0#define ACE_HAS_STANDARD_CPP_LIBRARY 1config.h file.  Notice that if you want to
      spawn a new thread with CWinThread, make sure you spawn the
      thread with THR_USE_AFX flag set.#define ACE_HAS_MFC 1ACE_USES_STATIC_MFC in your
      config.h file.  If you insist on linking everything
      statically, you'll have to modify the project file yourself.#define ACE_HAS_WINCE
      #define ACE_HAS_DLL 0#define ACE_NO_INLINEThe tests are located in ACE_ROOT\tests. There are two corresponding project files in that directory also (tests.mdp and tests.dsp).
Once you build all the tests (Batch Build works well for this), you
can run the batch file run_tests.bat in the
tests directory to try all the tests.
BUILDING ACE ON A WIN32 MACHINE THAT LACKS A NETWORK CARD
You may want to run ACE on a non-networked machine. To do so, you must install TCP/IP and configure it to ignore the absence of a network card. This is one method:
Many project files already contain Alpha NT configurations, but others do not (requiring them to be added). Also, since most of the development happens on x86, problems building ACE on Alpha NT can often be fixed by recreating the configurations from the x86 versions.
Here are the steps to add an Alpha Configuration.
Note: MSVC 6 has a bug where if a .dsp is converted from version 5 to 6 on x86, the Alpha configuration will be partially corrupted. If this occurs, the easiest way to fix it is as above, recreate it.
A few notes on VxWorks builds (thanks to Paul von Behren for these notes):
ld step.  You must have perl installed
      to use ace_ld.  If perl is not on your path, you'll
      have to set PERL_PATH, either in your
      $(ACE_ROOT)/include/makeinclude/platform_macros.GNU
      or in your environment.
$ACE_ROOT/include/makeinclude/platform_vxworks5.x_g++.GNU
platform file for detailed information.The VxWorks platform_vxworks*.GNU files are set up so that shared libraries are not built on VxWorks. Only static libraries, with .a extension, are built. Therefore, it's not necessary to set the LD_LIBRARY_PATH environment variable on your host system when building for VxWorks targets. Please note, however, if you use TAO on VxWorks that you will need to set your LD_LIBRARY_PATH to find the TAO IDL compiler libraries (installed in the ace directory) on the host.
With g++, $ACE_ROOT/bin/ace_ld is used to munch object files and libraries to set up calls to static constructors and destructors. bin/ace_ld requires perl on the host platform.
These non-default VxWorks kernel configuration #defines
are required with ACE:
#define INCLUDE_CPLUS /* include C++ support */ #define INCLUDE_CPLUS_IOSTREAMS /* include iostreams classes */ #define INCLUDE_POSIX_ALL /* include all available POSIX functions */For completeness, here are the non-default
#defines that
we used for VxWorks 5.3.1/g++ 2.7.2:
#define INCLUDE_CPLUS /* include C++ support */ #define INCLUDE_CPLUS_IOSTREAMS /* include iostreams classes */ #define INCLUDE_CONFIGURATION_5_2 /* pre-tornado tools */ #define INCLUDE_DEBUG /* pre-tornado debugging */ #define INCLUDE_LOADER /* object module loading */ #define INCLUDE_NET_SYM_TBL /* load symbol table from network */ #define INCLUDE_SYM_TBL_SYNC /* synchronize host and target symbol tables */ #define INCLUDE_NFS /* nfs package */ #define INCLUDE_PING /* ping() utility */ #define INCLUDE_POSIX_ALL /* include all available POSIX functions */ #define INCLUDE_RDB /* remote debugging package */ #define INCLUDE_RLOGIN /* remote login */ #define INCLUDE_RPC /* rpc package */ #define INCLUDE_SECURITY /* shell security for network access */ #define INCLUDE_SHELL /* interactive c-expression interpreter */ #define INCLUDE_SHOW_ROUTINES /* show routines for system facilities*/ #define INCLUDE_SPY /* spyLib for task monitoring */ #define INCLUDE_STARTUP_SCRIPT /* execute start-up script */ #define INCLUDE_STAT_SYM_TBL /* create user-readable error status */ #define INCLUDE_SYM_TBL /* symbol table package */ #define INCLUDE_UNLOADER /* object module unloading */ #define INCLUDE_WINDVIEW /* WindView command server */If you use TAO, it's also a good idea to increase the
NUM_FILES parameter from its default of 50 to,
say, 1000.Please note that those VxWorks kernel configuration parameters are set in the VxWorks configAll.h file. You must rebuild your VxWorks kernel after modifying that file.
It probably wouldn't take much effort to modify the
ACE library to not require INCLUDE_CPLUS_IOSTREAMS,
if necessary.
If you're first getting started with ACE and/or VxWorks, I recommend just building the ACE library and tests first. (Some of the ACE examples, in System_V_IPC, don't build on VxWorks yet.) Then try running the tests. Please see $ACE_ROOT/tests/README for the latest status of the ACE tests on VxWorks.
Please note that the main entry point is renamed to
ace_main (configurable via ACE_MAIN) on VxWorks with g++,
to comply with its restriction against using main.
In addition, ACE_HAS_NONSTATIC_OBJECT_MANAGER is enabled by default
to cleanly support construction and destruction of static objects.
Please see the Non-static
ACE_Object_Manager discussion for the important implication
of this feature.
ACE threads (VxWorks tasks) can be named, for example, by supplying a
non-null argument to the Thread_Manager spawn routines.  However,
names beginning with "==ace_t==" are forbidden because
that prefix is used internally by ACE.
You can spawn a new task to run ace_main, using either
VxWorks sp, or ACE'S spa.
spa can be used from the VxWorks shell to pass arguments
to ace_main.  Its usage is:
spa ace_main, "arg1" [, ...]
By default, the ACE Makefiles link the ACE library into every
executable.  If you want to run multiple ACE executables but just use
a single ACE library, it should be possible, though I haven't tried
it.  Just link the first executable to be loaded onto the target with
the ACE library, as usual.  All other executables can be linked
without the ACE library by added ACELIB= to the make
invocation when building them.  When they are loaded onto the target,
the should load against the symbols from the ACE library from the
first executable that was loaded.
static_libs_only=1 to either
your ACE_wrappers/include/makeinclude/platform_macros.GNU
or your make invocation.  Then, be sure to load
the ACE (and any other) shared library before loading your
executable(s).A shared library for VxWorks uses the same code as for a static (non-shared) library. However, calls to static constructors/ destructors are added. The code in the shared library must be reentrant if you shared it between programs (tasks). The ACE library meets this requirement.
Shared libraries reduce build time, executable size, and load time of the executable. But, you must manually load the shared library before loading your executable(s) with a command such as:
-> ld < libACE.so
A few additional Windows Notes, from Paul von Behren:
Tornado\host\x86-win32\bin\TorVars.bat.  This is done
      implicitly within the Tornado IDE.
ace_ld, you still need perl installed -
      see 
      http://www.activestate.com/software/default.htm for Windows
      perl.
ACE_ROOT\ace directory
      creating the library libACE.a.  If perl is available, make also works
      in the ACE_ROOT\tests directory.
ACE_ROOT defined
      before starting Tornado, you can specify an ACE Makefile as a Tornado
      target and Tornado will then call make from the menu.
cdk.exe and installed that on my NT box.
      I downloaded perl5.0 from where I can't remember.  There may have been
      bits and pieces from other places for things like vi and
      less.
  /ace/ACE_wrappers.NT and
      /ace/ACE_wrappers.vxworks.  The NT tree is for building
      aced.dll and tao_idl.exe as currently
      documented for ACE/TAO on NT/VC++5.0. The VxWorks tree is the
      cross compilation tree.
  
      /tornado/host/x86-win32/bin:
      /tornado/host/x86-win32/lib/gcc-lib/i386-wrs-vxworks/cygnus-2.7.2-960126:
      /tornado/host/x86-win32/i386-wrs-vxworks/bin:
      /ace/ace_wrappers/bin:
      /gnuwin32/b18/H-i386-cygwin32/bin:
      /gnuwin32/b18/tcl/bin:
      /WINNT/system32:
      /WINNT:
      /WINNT/system32/nls/ENGLISH:
      /bin
      
      Other environment variables:
      WIND_BASE=/tornado
      SHELL=/bin/sh.exe
      TERM=pcbios
      TAO_ROOT=/ace/ACE_wrappers.vxworks/TAO
      CPP_LOCATION=/Program Files/DevStudio/VC/bin/CL.EXE
      GCC_EXEC_PREFIX=/tornado/host/x86-win32/lib/gcc-lib/
      WIND_HOST_TYPE=x86-win32
      ACE_ROOT=/ace/ACE_wrappers.vxworks
      
  /tornado is the root of the Tornado install
      ($WIND_BASE).
  /gnuwin32 is the root of a Cygnus GNU download and install.
  /bin content is:
      aced.dll
      cygwin.dll
      perl.exe
      rm.exe
      sh.exe
      true
      
      aced.dll is produced in an ACE NT source tree according to
      documented procedure for NT VC++5.0 ACE build.
      cygwin.dll is from the Cygnus GNU software download and install.
  $ACE_ROOT/ace/config.h that looks like:
      #define __ACE_INLINE__ 0
      #define ACE_HAS_DLL 0
      #include "config-vxworks5.x.h"
      
      And create a $ACE_ROOT/include/makeinclude/platform_macros.GNU
      that looks like:
      WIND_BASE = /tornado
      WIND_HOST_TYPE = x86-win32
      PATH += :$(WIND_BASE)/host/$(WIND_HOST_TYPE)/bin
      CPU = I80486
      include $(ACE_ROOT)/include/makeinclude/platform_NTvxworks5.x_g++.GNU
      
      (But, I guess the PATH+= line is superfluous based on the PATH as shown
      previously).
      Finally, create a
      $ACE_ROOT/include/makeinclude/platform_NTvxworks5.x_g++.GNU
      with diff output from 'diff platform_vxworks5.x_g++.GNU
      platform_NTvxworks5.x_g++.GNU' that looks like:
      
      58c58
      < HOST_DIR        = $(WIND_BASE)/host/sun4-solaris2
      ---
      > HOST_DIR        = $(WIND_BASE)/host/x86-win32
      62,63c62,63
      < CXX             = g++$(TOOLENV)
      < CFLAGS          += -DVXWORKS -D_REENTRANT -ansi -fno-builtin
      -fno-defer-pop -fvolatile -nostdinc -nostdlib -pipe -Wall
      ---
      > CXX             = $(CC)
      > CFLAGS          += -DVXWORKS -D_REENTRANT -ansi -fno-builtin -fno-defer-pop \
      -fvolatile -nostdinc -nostdlib -Wall #-pipe
      
  
      cd $ACE_ROOT/ace; make
      
  make.exe in the
      /gnuwin32/b18/H-i386-cygwin32/bin directory as I couldn't get
      make shipped with Tornado to run ace_ld and I couldn't figure out any
      other work around.
      cd $ACE_ROOT/tests; /gnuwin32/b18/H-i386-cygwin32/bin/make
      
      Also, running the tests works as already documented.
aced.dll in /bin.
  
      CPP_LOCATION=/Program Files/DevStudio/VC/bin/CL.exe
      cd $TAO_ROOT/orbsvcs/orbsvcs
      /gnuwin32/b18/H-i386-cygwin32/bin/make
      
  
      CPP_LOCATION=/Program Files/DevStudio/VC/bin/CL.exe
      cd $TAO_ROOT/tao
      /gnuwin32/b18/H-i386-cygwin32/bin/make
      
  
main) contained in $ACE_ROOT/netsvcs/servers/main.cpp
      should also be compiled and ready to run.
      % setenv LD_LIBRARY_PATH $ACE_ROOT/ace:$LD_LIBRARY_PATH
      
main driver program dynamically.
      To specify which services should be linked in and executed, edit the
      $ACE_ROOT/netsvcs/servers/svc.conf
      file.  During your editing, you should update information (such as the
      default service port numbers) that affects the initialization of
      services in this file.  Refer to the
      Service Configurator
      documentation to learn how the configuration file is parsed and
      how the services are dynamically linked and executed.  In
      addition, refer to the Network
      Services documentation to learn more about how to configure
      each network service.
If you are using MSVC 4.x, you will need to add another directory to your global include and library paths, ACE_ROOT/netsvcs/lib. When you use the dynamic libraries, make sure to also include ACE_ROOT/netsvcs/lib in your PATH.
ACE::init () and ACE::fini
().  The comments in the header
file, ace/Object_Manager.h provide more detail.
Special requirements are imposed on applications if the
ACE_Object_Manager is instantiated, by ACE, on the stack of the main
thread.  This behavior is selected by defining
ACE_HAS_NONSTATIC_OBJECT_MANAGER in
ace/config.h.  Again, see the ACE Object_Manager header file,
ace/Object_Manager.h for more information.  One of
these requirements is discussed here, because it is so important.
Please note that ACE_HAS_NONSTATIC_OBJECT_MANAGER is
defined in the distributed ACE config.h headers for
VxWorks and Win32.
The important requirement is that the program must
declare its main function with two arguments, even if
they're not used, and with int return type:
int
main (int, char *[])
main exactly that
way, then you'll see a link error about ace_main_i being
undefined.
Alternatively, this feature can be disabled by commenting out the
#define ACE_HAS_NONSTATIC_OBJECT_MANAGER in the
ace/config.h.  But, that will make repeated testing more
difficult on VxWorks.  And, you'd either have to call static
constructors and destructors manually or unload/load the program
between runs.  On Win32, disabling the feature can possibly lead to
shutdown difficulties.
ACE_HAS_NONSTATIC_OBJECT_MANAGER assumes that your
main function is named main.  Any violation
of this assumption is at your peril.  If you really need to call your
entry point something other than main, you'll need to
construct and destroy the ACE_Object_Manager.  The best way to do that
is to call ACE::init () and ACE::fini ().
Or, see the #define of main (int, char *[])
in ace/OS.h to see how ACE does
that for entry points named main.
% cd $ACE_ROOT/bin % make % mv clone ~/bin % rehash
Then create a ./build subdirectory someplace, e.g., under $ACE_ROOT, and then invoke the top-level Makefile with the ``clone'' target, e.g.:
% cd $ACE_ROOT % mkdir build-SunOS5 % cd build-SunOS5 % make -f ../Makefile clone % (cd ace; echo "\#include "ace/config-sunos5.5-g++.h" > config.h) % (cd include/makeincludes; ln -s platform_sunos5-g++.h platform_macros.GNU) % setenv ACE_ROOT $cwd % make
This will establish a complete tree of links. Note that you must build a config.h and platform_macros.GNU in cloned directory. In addition, make sure you set your LD_LIBRARY_PATH to $ACE_ROOT/ace:$LD_LIBRARY_PATH on SVR4 UNIX platforms.
When you do a make in the $ACE_ROOT directory you will be producing object code that is not stored in the same place as the original source tree. This way, you can easily build another platform in a parallel tree structure.
VERY IMPORTANT!
If you use the ``clone trick'' discussed above, make sure that the symbolic links are correctly in place before starting the build. In particular, if you plan to clone the tree, it is preferable to do so before you start a build procedure on the original tree. This is because the build procedure create object directories (.obj and .shobj) and the cloning procedure will clone these directories also. You would end up with links pointing to object files of another platform. If you clone the tree after you've done a build on the original tree, make sure to remove all ".obj", ".shobj" and (any other files or directories) in all subdirectories before starting the build on your cloned tree.
Alternatively, the perl script
ACE_wrappers/bin/create_ace_build can be used to create
build trees.  It creates them below ACE_wrappers/build.
It filters out all but the necessary files, so the warning above does
not apply.  See the comments at the top of the script itself for usage
information.
You can get a copy of GNU make that has been ported to MVS OpenEdition from the IBM OpenEdition web site. ACE's make scheme generates compile commands that have options and operands interspersed. By default, the c89/cc/c++ compiler expects all options to precede all operands. To get around this, you must set a special compiler environment variable (_CXX_CCMODE) to 1 which tells the compiler to allow options and operands to be interspersed.
Note that the environment variable LD_LIBRARY_PATH is called LIBPATH on MVS.
Shared objects are built a little different on MVS than on other UNIX implementations. This has been accounted for in the makefiles that come with ACE When the linker (via the cxx command) builds the libACE.so file it will also create a file called libACE.x. This is a side-deck file and it must be included in subsequent link edits with application code. For more information on this see the C/C++ MVS Programming Guide. If you want to build your application statically, i.e., using libACE.a instead of libACE.so, you can set ACELIB to ACELIB_STATIC in platform_mvs.GNU.
When the libACE.so file is built (via the MVS pre-linker and binder), you will get a rc=4 from the pre-linker. This is ok. This is due to some warnings about unresolved references which should get resolved during the link step. Note, however, there shouldn't be any unresolved references from the binder (linkage editor). You can get pre-link and link maps by uncommenting the PMAP and LMAP lines in the platform_mvs.GNU file.
Please note that the effects of a flag may be platform specific. Also, combinations of certain flags may or may not be allowed on specific platforms, e.g., debug=1 opt=1 is supported by g++ but not all other C++ compilers.
If you use Purify or Quantify:  purify or quantify must
be on your PATH.  By default, ACE puts the Purify/Quantify
caches below /tmp.  To override that, set the
PURE_CACHE_BASE_DIR variable, either in your environment
or on the make make command line, to the destination
directory for your instrumented libraries.
Flag             Description
----             -----------
debug            Enable debugging; see DCFLAGS and DCCFLAGS.
exceptions       Enable exception handling (not supported by all platforms).
fast             Enable -fast option, e.g., with Sun C++.
inline           Enable ACE inlining.  Some platforms enable inlining by
default, others do not.
optimize         Enable optimization; see OCFLAGS and OCCFLAGS.
orbix            Enable use of Orbix.
probe            Enable ACE_Timeprobes.
profile          Enable profiling; see PCFLAGS and PCCFLAGS.
purify           Purify all executables.
quantify         Quantify all executables.
repo             Use GNU template repository (g++ with repo patches and
                   egcs only).
rtti             Enable run-time type identification.  On some platforms,
                   it is enabled by default, so this is ignored.
shared_libs      Build shared libraries. Ignored if static_libs_only is set.
static_libs      Build shared libraries. Ignored if shared_libs_only is set.
shared_libs_only Only build shared libraries.  Ignored if no SHLIBs are
specified by the Makefile, as in performance-tests/Misc.
static_libs_only Only build static libraries.
threads          Build with thread support.
xt_reactor       Build the XtReactor.
Usually, users do not need to be concerned with make targets.
Just enter ``make'' on the command line to build.  A few notable
targets are listed below.
Target             Description
------             -----------
show_statics       Lists all static objects in object files built for
current directory.  Only supported for g++.
show_uninit        Lists all uninitialized in object files built for
current directory.  Only supported for g++.
Back to the ACE home page.