You must use SPM to install and build a compatible Tools.h++ library before you attempt to build Threads.h++. A compatible Tools.h++ library is one that was built using the same platform and build options that will be used to compile Threads.h++.
For a list of the version-specific dependencies for Threads.h++, see the file dependencies.html in rw_root/htmldocs/thrverbd.
If you own an earlier version of Tools.h++ you may have received an unlock key for an updated version with this CD. If you didn't receive a key, you may still be entitled to a free upgrade. For upgrade information, please call the toll-free number that appears on your CD package label or visit our web site:
If you use Rogue Wave's Standard C++ Library with Tools.h++, be sure to upgrade to the most recent version of Standard C++ Library at the same time you upgrade Tools.h++.
Additional dependencies are best discussed in terms of the seven Threads.h++ packages and two subpackages, listed in order of build dependency:
Execution Tracing
Thread-compatible Exception
Synchronization
Smart Pointer
Functor
Functor List subpackage
Functor Map subpackage
Interthread Communication
Threading
Figure 1 illustrates the dependencies among packages.
A build of Threads.h++ creates nine C++ libraries. The following sections discuss the dependencies for each of the packages.
The Execution Tracing package consists of one C++ library: trace. The Execution Tracing package is used for outputting messages at runtime from your objects to monitor execution, debug, or log events. To build the trace package, you must use SPM to install and build a compatible Tools.h++ library, before you attempt to build Threads.h++. A compatible Tools.h++ library is one that was built using the same platform and build options that will be used to compile Threads.h++.
NOTE: Be sure to build the version of Tools.h++ from the same SPM CD as the Threads.h++ version you are using, not an earlier version of Tools.h++.
The Thread-compatible Exception package consists of one C++ library: threxcept. The Thread-compatible Exception package contains exceptions used by other packages in Threads.h++ as well as a template for creating your own exceptions, which will enable them to be thrown across thread boundaries. To build the threxcept package, you must use SPM to install and build a compatible Tools.h++ library, before you attempt to build Threads.h++. You must also build the Execution Tracing (trace) package before building the Thread-compatible Exception package. A compatible Tools.h++ library is one that was built using the same platform and build options that will be used to compile Threads.h++.
NOTE: Be sure to build the version of Tools.h++ from the same SPM CD as the Threads.h++ version you are using, not an earlier version of Tools.h++.
The Synchronization package consists of one C++ library: sync, which includes a variety of mutual exclusion and conditional synchronization mechanisms for use in a multi-threaded environment. To build the sync package, you must use SPM to install and build a compatible Tools.h++ library, before you attempt to build Threads.h++. You must also build the Execution Tracing (trace), and Thread-compatible Exception (threxcept) packages before building the Synchronization package. A compatible Tools.h++ library is one that was built using the same platform and build options that will be used to compile Threads.h++.
NOTE: Be sure to build the version of Tools.h++ from the same SPM CD as the Threads.h++ version you are using, not an earlier version of Tools.h++.
The Smart Pointer package consists of one C++ library: pointer. The Smart Pointer package contains a set of templates which provide exception-safe dynamic memory allocation for your objects. To build the pointer package, you must use SPM to install and build a compatible Tools.h++ library, before you attempt to build Threads.h++. You must also build the Execution Tracing (trace), Thread-compatible Exception (threxcept), and Synchronization (sync) packages before building the Smart Pointer package. A compatible Tools.h++ library is one that was built using the same platform and build options that will be used to compile Threads.h++.
NOTE: Be sure to build the version of Tools.h++ from the same SPM CD as the Threads.h++ version you are using, not an earlier version of Tools.h++.
The basic Functor package consists of one C++ library: functor. In addition to basic functors, the package includes two subpackages with their own libraries. The Functor package contains a set of templates to allow global, static and member functions to be encapsulated into objects that can be generically executed without prior knowledge of the function signature or argument count. To build the functor package, you must use SPM to install and build a compatible Tools.h++ library, before you attempt to build Threads.h++. You must also build the Execution Tracing (trace), Thread-compatible Exception (threxcept), Synchronization (sync) and Smart Pointer (pointer) packages before building the Functor package. A compatible Tools.h++ library is one that was built using the same platform and build options that will be used to compile Threads.h++.
NOTE: Be sure to build the version of Tools.h++ from the same SPM CD as the Threads.h++ version you are using, not an earlier version of Tools.h++.
The subpackage software resides in separate directories under the functor directories. You can build the two Functor subpackages, Functor Lists and Functor Maps, independently of each other.
The Functor List subpackage consists of one C++ library: functor_list. If you need to call more than one functor per invocation, use functor lists. You must build the basic Functor package (functor) before building the Functor List subpackage.
The Functor Map subpackage consists of one C++ library: functor_map. If you're calling one functor per invocation, but you have multiple functors to choose from, use a functor map. You must build the basic Functor package (functor) before building the Functor Map subpackage.
The Interthread Communication package consists of one C++ library: itc. The Interthread Communication package is a set of classes that use producer-consumer synchronization semantics to coordinate multithread access. To build the itc package, you must use SPM to install and build a compatible Tools.h++ library, before you attempt to build Threads.h++. You must also build the Execution Tracing (trace), Thread-compatible Exception (threxcept), Synchronization (sync), Smart Pointer (pointer), and Functor (functor) packages before building the Interthread Communication package. A compatible Tools.h++ library is one that was built using the same platform and build options that will be used to compile Threads.h++.
NOTE: Be sure to build the version of Tools.h++ from the same SPM CD as the Threads.h++ version you are using, not an earlier version of Tools.h++.
The Threading package consists of one C++ library: thread. The Threading package is a set of thread management classes that allow you to create, control, and monitor threads of execution in your application. To build the thread package, you must use SPM to install and build a compatible Tools.h++ library, before you attempt to build Threads.h++. You must also build the Execution Tracing (trace), Thread-compatible Exception (threxcept), Synchronization (sync), Smart Pointer (pointer), Functor (functor), and Interthread Communication (itc) packages before building the Threading package. A compatible Tools.h++ library is one that was built using the same platform and build options that will be used to compile Threads.h++.
NOTE: Be sure to build the version of Tools.h++ from the same SPM CD as the Threads.h++ version you are using, not an earlier version of Tools.h++.
©Copyright 2000, Rogue Wave Software, Inc.
Contact Rogue Wave about documentation or support issues.