atomic_add.cpp

Go to the documentation of this file.

 
#include <stdio.h>
#include <string.h>
 
#include <rw/_mutex.h>
 
#include <rw_any.h>
#include <rw_cmdopt.h>
#include <rw_driver.h>
#include <rw_thread.h>   // for rw_thread_create()
 
 
struct thr_args_base
{
    static enum tag_t {
        Char, SChar, UChar,
        Short, UShort, Int, UInt, Long, ULong,
        LLong, ULLong
    } type_tag_;
};
 
thr_args_base::tag_t thr_args_base::type_tag_;
 
template <class intT>
struct thr_args: thr_args_base
{
    unsigned         threadno_;     // thread ordinal number
    static int       inc_;          // increment, decrement, or both
    static unsigned  nincr_;        // number of increments
    static intT     *shared_;       // shared variables
    static unsigned  nthreads_;     // number of threads
 
    static intT* get_array ();
};
 
template <class intT>
int thr_args<intT>::inc_;
 
template <class intT>
unsigned thr_args<intT>::nincr_;
 
template <class intT>
intT* thr_args<intT>::shared_ = thr_args<intT>::get_array ();
 
template <class intT>
unsigned thr_args<intT>::nthreads_;
 
// working around compiler bugs that prevent us from defining
// a static array data member of a class template (PR #30009)
template <class intT>
intT* thr_args<intT>::get_array ()
{
    static intT array [2];
    return array;
}
 
 
template <class T>
T preincrement (T &x)
{
#ifndef _RWSTD_REENTRANT
 
    return ++x;
 
#else   // if defined (_RWSTD_REENTRANT)
 
    return _RW::__rw_atomic_preincrement (x, false);
 
#endif   // _RWSTD_REENTRANT
}
 
 
template <class T>
T predecrement (T &x)
{
#ifndef _RWSTD_REENTRANT
 
    return --x;
 
#else   // if defined (_RWSTD_REENTRANT)
 
    return _RW::__rw_atomic_predecrement (x, false);
 
#endif   // _RWSTD_REENTRANT
}
 
 
template <class intT>
void* thread_routine (thr_args<intT> *args)
{
    printf ("thread %u starting to %screment\n",
            args->threadno_,
              args->inc_ < 0 ? "de"
            : args->inc_ > 0 ? "in"
            : "decrement and in");
 
    if (args->inc_ > 0) {
 
        // exercise atomic_preincrement() in a tight loop
 
        for (unsigned i = 0; i != args->nincr_; ++i) {
            preincrement (args->shared_ [0]);
            preincrement (args->shared_ [1]);
        }
    }
    else if (args->inc_ < 0) {
 
        // exercise atomic_predecrement() in a tight loop
 
        for (unsigned i = 0; i != args->nincr_; ++i) {
            predecrement (args->shared_ [0]);
            predecrement (args->shared_ [1]);
        }
    }
    else {
 
        // exercise both atomic_preincrement() and atomic_predecrement()
 
        for (unsigned i = 0; i != args->nincr_; ++i) {
            preincrement (args->shared_ [0]);
            predecrement (args->shared_ [0]);
            preincrement (args->shared_ [1]);
            predecrement (args->shared_ [1]);
        }
    }
 
    return 0;
}
 
 
extern "C" void* thread_routine (void *arg)
{
    thr_args_base* const args = (thr_args_base*)arg;
 
    switch (args->type_tag_) {
 
    case thr_args_base::Char:
        return thread_routine ((thr_args<char>*)(arg));
    case thr_args_base::SChar:
        return thread_routine ((thr_args<signed char>*)(arg));
    case thr_args_base::UChar:
        return thread_routine ((thr_args<unsigned char>*)(arg));
 
    case thr_args_base::Short:
        return thread_routine ((thr_args<short>*)(arg));
    case thr_args_base::UShort:
        return thread_routine ((thr_args<unsigned short>*)(arg));
 
    case thr_args_base::Int:
        return thread_routine ((thr_args<int>*)(arg));
    case thr_args_base::UInt:
        return thread_routine ((thr_args<unsigned int>*)(arg));
 
    case thr_args_base::Long:
        return thread_routine ((thr_args<long>*)(arg));
    case thr_args_base::ULong:
        return thread_routine ((thr_args<unsigned long>*)(arg));
 
#ifdef _RWSTD_LONG_LONG
 
    case thr_args_base::LLong:
        return thread_routine ((thr_args<_RWSTD_LONG_LONG>*)(arg));
    case thr_args_base::ULLong:
        return thread_routine ((thr_args<unsigned _RWSTD_LONG_LONG>*)(arg));
 
#endif   // _RWSTD_LONG_LONG
 
    };
 
    return 0;
}
 
 
/* extern */ int rw_opt_nloops   = 1024 * 1024;
/* extern */ int rw_opt_nthreads = 4;
 
#define MAX_THREADS   32
 
 
template <class intT>
void run_test (intT, thr_args_base::tag_t tag, int inc)
{
    static const char* const tname = rw_any_t (intT ()).type_name ();
 
    if (!rw_enabled (tname)) {
        rw_note (0, 0, 0, "%s test disabled", tname);
        return;
    }
 
#if defined (_RWSTD_REENTRANT)
 
    static const char* const fun =
          inc < 0 ? "__rw_atomic_predecrement"
        : inc > 0 ? ":__rw_atomic_preincrement"
        : "__rw_atomic_pre{in,de}crement";
 
    rw_info (0, 0, 0, "__rw::%s (%s&): %d iterations in %d threads",
             fun, tname, rw_opt_nloops, rw_opt_nthreads);
 
    rw_thread_t tid [MAX_THREADS];
 
    typedef thr_args<intT> Args;
 
    Args::nthreads_   = rw_opt_nthreads;
    Args::type_tag_   = tag;
    Args::inc_        = inc;
    Args::nincr_      = unsigned (rw_opt_nloops);
    Args::shared_ [0] = intT ();
    Args::shared_ [1] = intT ();
 
    _RWSTD_ASSERT (Args::nthreads_ < sizeof tid / sizeof *tid);
 
    Args args [sizeof tid / sizeof *tid];
 
    memset (args, 0, sizeof args);
 
    for (unsigned i = 0; i != Args::nthreads_; ++i) {
 
        args [i].threadno_ = i;
 
        rw_fatal (0 == rw_thread_create (tid + i, 0, thread_routine, args + i),
                  0, __LINE__, "thread_create() failed");
    }
            
    for (unsigned i = 0; i != Args::nthreads_; ++i) {
 
        rw_error (0 == rw_thread_join (tid [i], 0), 0, __LINE__,
                  "thread_join() failed");
    }
 
    // compute the expected result
    intT expect = intT ();
 
    if (inc < 0) {
        for (unsigned i = 0; i != Args::nthreads_ * Args::nincr_; ++i)
            --expect;
    }
    else if (inc > 0) {
        for (unsigned i = 0; i != Args::nthreads_ * Args::nincr_; ++i)
            ++expect;
    }
 
    // verify that the final value of the variable shared among all
    // threads equals the number of increments or decrements performed
    // by all threads
    rw_assert (Args::shared_ [0] == expect, 0, __LINE__,
               "1. %s (%s&); %s == %s failed",
               fun, tname, TOSTR (Args::shared_ [0]), TOSTR (expect));
 
    rw_assert (Args::shared_ [1] == expect, 0, __LINE__,
               "2. %s (%s&); %s == %s failed",
               fun, tname, TOSTR (Args::shared_ [1]), TOSTR (expect));
 
#else   // if !defined (_RWSTD_REENTRANT)
 
    _RWSTD_UNUSED (tag);
    _RWSTD_UNUSED (inc);
 
#endif   // _RWSTD_REENTRANT
}
 
 
static int
run_test (int, char**)
{
    // exercise atomic subtract
    run_test ((char)0, thr_args_base::Char, -1);
    run_test ((signed char)0, thr_args_base::SChar, -1);
    run_test ((unsigned char)0, thr_args_base::UChar, -1);
 
    run_test ((short)0, thr_args_base::Short, -1);
    run_test ((unsigned short)0, thr_args_base::UShort, -1);
 
    run_test ((int)0, thr_args_base::Int, -1);
    run_test ((unsigned int)0, thr_args_base::UInt, -1);
 
    run_test ((long)0, thr_args_base::Long, -1);
    run_test ((unsigned long)0, thr_args_base::ULong, -1);
 
#ifdef _RWSTD_LONG_LONG
 
    run_test ((_RWSTD_LONG_LONG)0, thr_args_base::LLong, -1);
    run_test ((unsigned _RWSTD_LONG_LONG)0, thr_args_base::ULLong, -1);
 
#endif    // _RWSTD_LONG_LONG
 
    // exercise atomic add
    run_test ((char)0, thr_args_base::Char, +1);
    run_test ((signed char)0, thr_args_base::SChar, +1);
    run_test ((unsigned char)0, thr_args_base::UChar, +1);
 
    run_test ((short)0, thr_args_base::Short, +1);
    run_test ((unsigned short)0, thr_args_base::UShort, +1);
 
    run_test ((int)0, thr_args_base::Int, +1);
    run_test ((unsigned int)0, thr_args_base::UInt, +1);
 
    run_test ((long)0, thr_args_base::Long, +1);
    run_test ((unsigned long)0, thr_args_base::ULong, +1);
 
#ifdef _RWSTD_LONG_LONG
 
    run_test ((_RWSTD_LONG_LONG)0, thr_args_base::LLong, +1);
    run_test ((unsigned _RWSTD_LONG_LONG)0, thr_args_base::ULLong, +1);
 
#endif    // _RWSTD_LONG_LONG
 
 
    // exercise both atomic add and subtract
    run_test ((char)0, thr_args_base::Char, 0);
    run_test ((signed char)0, thr_args_base::SChar, 0);
    run_test ((unsigned char)0, thr_args_base::UChar, 0);
 
    run_test ((short)0, thr_args_base::Short, 0);
    run_test ((unsigned short)0, thr_args_base::UShort, 0);
 
    run_test ((int)0, thr_args_base::Int, 0);
    run_test ((unsigned int)0, thr_args_base::UInt, 0);
 
    run_test ((long)0, thr_args_base::Long, 0);
    run_test ((unsigned long)0, thr_args_base::ULong, 0);
 
#ifdef _RWSTD_LONG_LONG
 
    run_test ((_RWSTD_LONG_LONG)0, thr_args_base::LLong, 0);
    run_test ((unsigned _RWSTD_LONG_LONG)0, thr_args_base::ULLong, 0);
 
#endif    // _RWSTD_LONG_LONG
 
    return 0;
}
 
 
int main (int argc, char *argv[])
{
    return rw_test (argc, argv, __FILE__,
                    0 /* no clause */,
                    0 /* no comment */,
                    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);
}