How can I use boost::thread::timed_join with nanoseconds enabled in boost::date_time?

Question

Here is some C++ code illustrating my problem with a minimal expample:

// uncomment the next line, to make it hang up:
//#define BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG //needed for nanosecond support of boost
#include <boost/thread.hpp>
void foo()
{
    while(true);
}
int main(int noParameters, char **parameterArray)
{
    boost::thread MyThread(&foo);
    if ( MyThread.timed_join( boost::posix_time::seconds(1) ) )
    {
        std::cout<<"\nDone!\n";
    }
    else
    {
        std::cerr<<"\nTimed out!\n";
    }
}

As long as I don't turn on the nanosecond support everthing works as expected, but as soon as I uncomment the #define needed for the nanosecond support in boost::posix_time the program doesn't get past the if-statement any more, just as if I had called join() instead of timed_join().

Now I've already figured out, that this happens because BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG changes the actual data representation of the timestamps from a single 64bit integer to 64+32 bit. A lot boost stuff is completely implemented inside the headers but the thread methods are not and because of that they cannot adapt to the new data format without compiling them again with the apropriate options. Since the code is meant to run on an external server, compiling my own version of boost is not an option and neither is turning off the nanosecond support.

Therefore my question is as follows: Is there a way to pass on a value (on the order of seconds) to timed_join() without using the incompatible 96bit posix_time methods and without modifying the standard boost packages?

I'm running on Ubuntu 12.04 with boost 1.46.1.

Note that timed_join is deprecated in recent versions of boost. — Stephan Dollberg, Feb 22 '13 at 20:14

score 1 · Answer 1 · answered Feb 22 '13 at 19:50

Unfortunately I don't think your problem can be cleanly solved as written. Since the library you're linking against was compiled without nanosecond support, by definition you violate the one-definition rule if you happen to enable nanosecond support for any piece that's already compiled into the library binary. In this case, you're enabling it across the function calls to timed_join.

The obvious solution is to decide which is less painful to give up: Building your own boost, or removing nanosecond times.

The less obvious "hack" that may or may not totally work is to write your own timed_join wrapper that takes a thread object and an int representing seconds or ms or whatever. Then this function is implemented in a source file with nothing else and that does not enable nanosecond times for the specific purpose of calling into the compiled boost binary. Again I want to stress that if at any point you fail to completely segregate such usages you'll violate the one definition rule and run into undefined behavior.

How can I use boost::thread::timed_join with nanoseconds enabled in boost::date_time?

1 Answers1