The following table summarizes platforms on which ACE runs:
Fully supported, i.e., continually tested and used daily | Solaris 2.5 and 2.6, 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 and 2.6 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.
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 8To 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. ACE will work without any modifications on
RedHat 5.1; use the
include/makeinclude/platform_linux_lxpthreads.GNU
and ace/config_linux_lxpthreads.h
platform/config
files.
The ACE Tokens_Test
hangs with egcs 1.1b on
Linux. It runs properly when built with egcs 1.0.2. All
other ACE tests run properly with both 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. 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 OSF/1 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.
CXX 6.0 and 6.1 are _much_ improved in this regard: V6.0-020
and V6.1-025 and later build all of ACE cleanly. Please note that
include/makeinclude/platform_osf1_4.0.GNU
has a
WARNING_FLAGS
macro that is disabled by
default, to support users who don't have 6.0 yet. If you do, enable
that macro definition by either adding CXX_VER=POST_5X to your gmake
invocation, or editing your include/makeinclude/platform_macros.GNU
file. 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"
Dave Mayerhoefer <davem@lynx.com>
has ported ACE to LynxOS 2.5 using GNU g++ 2.7.2. However, you may need
to apply some patches
to LynxOS to get ACE working.
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.
% make optimize=0
Or, you can edit your include/makeinclude/platform_sunos5_g++.GNU,
and comment out the OCFLAGS
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
.
--enable-shared
egcs config option,
so that it provides shared libraries. Be sure to set your
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/.
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 1
config.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 1
ACE_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_INLINE__ 0
The 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 that 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. For those that do not, follow these steps to add them.
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
.
$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" [, ...]
All arguments must be quoted, even numbers.
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.
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\include\makeinclude\rules.nested.GNU
(the error message says something about "dir unexpected").
ACE_ROOT\ace directory
creating the library libACE.a. If perl is available, make also works
in the ACE_ROOT\tests directory (ignore the final error
attempting to run /bin/true).
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: /binOther 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/makeAlso, 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 *[])
If you don't declare 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.