19.exceptions.mt.cpp

Go to the documentation of this file.

 
#include <stdexcept>   // for exceptions
#include <string>      // for string
 
#include <cassert>     // for assert
#include <cstdio>      // for printf()
 
#include <rw_cmdopt.h>
#include <rw_driver.h>
#include <rw_alarm.h>    // for rw_alarm()
#include <rw_thread.h>   // for rw_thread_pool()
#include <rw_valcmp.h>
 
 
#ifndef NTHREADS
#  ifndef _RWSTD_REENTRANT
#    define MAX_THREADS    0
#    define NTHREADS       0
#  else
#    define MAX_THREADS   32
#    define NTHREADS       4
#  endif   // _RWSTD_REENTRANT
#endif   // NTHREADS
 
 
/* extern */ int rw_opt_nloops   = 256 * 1024;
/* extern */ int rw_opt_nthreads = NTHREADS;
 
 
volatile int alarm_expired;
 
extern "C" {
 
static void handle_alarm (int)
{
    alarm_expired = 1;
}
 
}   // extern "C"
 
 
// string to intialize exceptions from
static const char what_buf [] = {
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789ABCDEF"
};
 
 
enum {
    exception_tag,
    logic_error_tag,
    domain_error_tag,
    invalid_argument_tag,
    length_error_tag,
    out_of_range_tag,
    runtime_error_tag,
    range_error_tag,
    overflow_error_tag,
    underflow_error_tag,
    Derived_tag
};
 
 
struct DerivedException: std::invalid_argument
{
    DerivedException (const char *str)
        : std::invalid_argument (str) { }
};
 
 
static void
throw_exception (unsigned which, const char *what)
{
    switch (which) {
    case exception_tag:        throw std::exception ();
    case logic_error_tag:      throw std::logic_error (what);
    case domain_error_tag:     throw std::domain_error (what);
    case invalid_argument_tag: throw std::invalid_argument (what);
    case length_error_tag:     throw std::length_error (what);
    case out_of_range_tag:     throw std::out_of_range (what);
    case runtime_error_tag:    throw std::runtime_error (what);
    case range_error_tag:      throw std::range_error (what);
    case overflow_error_tag:   throw std::overflow_error (what);
    case underflow_error_tag:  throw std::underflow_error (what);
    case Derived_tag:          throw DerivedException (what);
 
    default: _RWSTD_ASSERT (!"logic error: bad exception tag");
    }
}
 
 
extern "C" void*
test_single_exception (void *arg)
{
    const rw_thread_t* const tid = (rw_thread_t*)arg;
 
    std::printf ("thread procedure %ld starting...\n", tid->threadno);
 
    for (unsigned i = 0; i < unsigned (rw_opt_nloops); ++i) {
 
        if (alarm_expired)
            break;
 
        const std::size_t what_len = std::size_t (i % 1024);
 
        const char* const what = what_buf + sizeof what_buf - what_len - 1;
 
        const unsigned thrown = i % 11;
 
        unsigned caught = _RWSTD_UINT_MAX;
 
        try {
            // construct and throw an exception object of one
            // of the predefined standard exception classes
            // initialized with a distinct what string
            throw_exception (thrown, what);
        }
        catch (DerivedException ex) {
            // catch the exception object by value and verify
            // that the pointer returned by what() compares
            // equal to the string the thrown object was
            // constructed with
            caught = Derived_tag;
            assert (0 == rw_strncmp (ex.what (), what));
        }
        catch (std::domain_error ex) {
            caught = domain_error_tag;
            assert (0 == rw_strncmp (ex.what (), what));
        }
        catch (std::invalid_argument ex) {
            caught = invalid_argument_tag;
            assert (0 == rw_strncmp (ex.what (), what));
        }
        catch (std::length_error ex) {
            caught = length_error_tag;
            assert (0 == rw_strncmp (ex.what (), what));
        }
        catch (std::out_of_range ex) {
            caught = out_of_range_tag;
            assert (0 == rw_strncmp (ex.what (), what));
        }
        catch (std::range_error ex) {
            caught = range_error_tag;
            assert (0 == rw_strncmp (ex.what (), what));
        }
        catch (std::overflow_error ex) {
            caught = overflow_error_tag;
            assert (0 == rw_strncmp (ex.what (), what));
        }
        catch (std::underflow_error ex) {
            caught = underflow_error_tag;
            assert (0 == rw_strncmp (ex.what (), what));
        }
        catch (std::logic_error ex) {
            caught = logic_error_tag;
            assert (0 == rw_strncmp (ex.what (), what));
        }
        catch (std::runtime_error ex) {
            caught = runtime_error_tag;
            assert (0 == rw_strncmp (ex.what (), what));
        }
        catch (std::exception ex) {
            caught = exception_tag;
            rw_strncmp (ex.what (), what);
        }
 
        // verify that an object of the thrown type was caught
        assert (caught == thrown);
    }
 
    return 0;
}
 
 
static void
test_multi (unsigned i, unsigned nactive)
{
    const std::size_t what_len = (i + nactive) % sizeof what_buf;
 
    const char* const what = what_buf + sizeof what_buf - what_len - 1;
 
    const unsigned thrown = (i + nactive) % 10 + 1;
 
    try {
        // construct and throw an exception object of a distinct type
        // with a distinct what string at each level of recursion
        throw_exception (thrown, what);
    }
    catch (std::exception &ex) {
 
        // recursively throw another exception while the caught
        // exception object is still active
        if (nactive)
            test_multi (i, nactive - 1);
 
        // verify that the caught object's what string matches
        // the string the object was originally constructed with
        assert (0 == rw_strncmp (ex.what (), what));
    }
}
 
extern "C" void*
test_multi_exceptions (void *arg)
{
    const rw_thread_t* const tid = (rw_thread_t*)arg;
 
    std::printf ("thread procedure %ld starting...\n", tid->threadno);
 
    for (unsigned i = 0; i < unsigned (rw_opt_nloops); ++i) {
 
        if (alarm_expired)
            break;
 
        // exercise up to 4 simultaneously active exceptions
        test_multi (i, i % 4);
    }
 
    return 0;
}
 
 
static int
run_test (int, char**)
{
    // get the current alarm (if any) set for the test
    // on the command line without resetting it
    const unsigned max_sec = rw_alarm (0, rw_sig_hold);
 
    // compute a shorter timeout for each of the two subtests
    const unsigned nsec = 3 < max_sec ? max_sec / 2 : 0;
 
    rw_info (0, 0, 0,
             "single active exception per thread"
             "%{?}; timeout in %u seconds%{;}",
             0 != max_sec, nsec ? nsec : max_sec);
 
    // set a shorter alarm if possible
    if (nsec) {
        alarm_expired = 0;
        rw_alarm (nsec, handle_alarm);
    }
 
    const std::size_t nthreads = std::size_t (rw_opt_nthreads);
 
#if 0 < NTHREADS 
 
    rw_fatal (0 == rw_thread_pool (0, nthreads, 0, test_single_exception, 0),
              0, __LINE__, "rw_thread_pool() failed");
 
#else   // if !(0 < NTHREADS)
 
    rw_thread_t tid = rw_thread_t ();
 
    test_single_exception (&tid);
 
#endif   // NTHREADS
 
    rw_info (0, 0, 0,
             "multiple active exceptions per thread"
             "%{?}; timeout in %u seconds%{;}",
             0 != max_sec, nsec ? nsec : max_sec);
 
    // set another shorter alarm if possible
    if (nsec) {
        alarm_expired = 0;
        rw_alarm (nsec, handle_alarm);
    }
 
#if 0 < NTHREADS 
 
    rw_fatal (0 == rw_thread_pool (0, nthreads, 0, test_multi_exceptions, 0),
              0, __LINE__, "rw_thread_pool() failed");
 
#else   // if !(0 < NTHREADS)
 
    test_multi_exceptions (&tid);
 
#endif   // NTHREADS
 
    // restore the original alarm to go off approximately
    // when the original alar would have if it hadn't been
    // replaced above
    if (nsec)
        rw_alarm (2 * nsec, rw_sig_restore);
 
    return 0;
}
 
 
int main (int argc, char *argv[])
{
    return rw_test (argc, argv, __FILE__,
                    "lib.std.exceptions",
                    "thread safety", run_test,
                    "|-nloops#0 "        // must be non-negative
                    "|-nthreads#0-*",    // must be in [0, MAX_THREADS]
                    &rw_opt_nloops,
                    int (MAX_THREADS),
                    &rw_opt_nthreads);
}