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.
If you are using AIX 4.2.1 or later, there is no patch needed; the dynamic library APIs are included in the base operating system.
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.
CXX 6.0 is _much_ improved in this regard. Please note that include/makeinclude/platform_osf1_4.0.GNU has a WARNING_FLAGS macro that is disabled by default, because most users probably 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 on the version of Digital UNIX 4.0 that we tested with at Washington U. There appear to be variations in Digital UNIX 4.0, however, because users elsewhere report test failures with the same version of CXX 6.0.
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.
Ganesh Pai <gpai@voicetek.com> subsequently did the port for version 2.1.2, also with g++.
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.
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.
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.
collect2.
% 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
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/.
#include "config-win32.h"#define ACE_HAS_WINNT4 0#define ACE_HAS_STANDARD_CPP_LIBRARY 1#define ACE_HAS_DLL 0#define __ACE_INLINE__ 0The 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:
You'll have to let ACE know the target type at compile time. There are several ways to do this; please see the $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++, 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 */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.
This requires that main be declared with its arguments
even if they're not used, and with int return type:
int
main (int, char *[])
ACE on VxWorks assumes that
your main function is named main when using
ACE_HAS_NONSTATIC_OBJECT_MANAGER. 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 an
ACE_Object_Manager. Please see the #define of main
(int, char *[]) in ace/OS.h to see how ACE does
that for entry points named main.
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.
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.
% 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; ln -s 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 to 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.
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.
profile Enable profiling; see PCFLAGS and PCCFLAGS.
purify Purify all executables.
quantify Quantify all executables.
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.
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.