first commit
This commit is contained in:
Jose Caban
368
extern/stdcxx/4.2.1/tests/support/atomic_xchg.cpp
vendored
Normal file
368
extern/stdcxx/4.2.1/tests/support/atomic_xchg.cpp
vendored
Normal file
@@ -0,0 +1,368 @@
|
||||
/***************************************************************************
|
||||
*
|
||||
* 18.atomic.xchg.cpp - test exercising the __rw_atomic_exchange() function
|
||||
* template
|
||||
*
|
||||
* $Id: atomic_xchg.cpp 580483 2007-09-28 20:55:52Z sebor $
|
||||
*
|
||||
***************************************************************************
|
||||
*
|
||||
* Licensed to the Apache Software Foundation (ASF) under one or more
|
||||
* contributor license agreements. See the NOTICE file distributed
|
||||
* with this work for additional information regarding copyright
|
||||
* ownership. The ASF licenses this file to you under the Apache
|
||||
* License, Version 2.0 (the "License"); you may not use this file
|
||||
* except in compliance with the License. You may obtain a copy of
|
||||
* the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
* implied. See the License for the specific language governing
|
||||
* permissions and limitations under the License.
|
||||
*
|
||||
* Copyright 2003-2006 Rogue Wave Software.
|
||||
*
|
||||
**************************************************************************/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <rw/_mutex.h>
|
||||
|
||||
#include <any.h>
|
||||
#include <cmdopt.h>
|
||||
#include <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_;
|
||||
|
||||
unsigned long threadno_; // thread ordinal number
|
||||
unsigned long niter_; // number of iterations
|
||||
unsigned long nxchg_; // number of exchanges
|
||||
};
|
||||
|
||||
thr_args_base::tag_t thr_args_base::type_tag_;
|
||||
|
||||
template <class intT>
|
||||
struct thr_args: thr_args_base
|
||||
{
|
||||
static unsigned long nincr_; // number of increments
|
||||
static intT *shared_; // shared variables
|
||||
static unsigned long nthreads_; // number of threads
|
||||
|
||||
static intT* get_array ();
|
||||
};
|
||||
|
||||
template <class intT>
|
||||
unsigned long thr_args<intT>::nincr_;
|
||||
|
||||
template <class intT>
|
||||
intT* thr_args<intT>::shared_ = thr_args<intT>::get_array ();
|
||||
|
||||
template <class intT>
|
||||
unsigned long 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>
|
||||
/* static */ intT* thr_args<intT>::get_array ()
|
||||
{
|
||||
static intT array [2];
|
||||
return array;
|
||||
}
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
template <class intT>
|
||||
intT exchange (intT &x, intT y)
|
||||
{
|
||||
#ifndef _RWSTD_REENTRANT
|
||||
|
||||
intT save (x);
|
||||
|
||||
x = y;
|
||||
|
||||
return save;
|
||||
|
||||
#else // if defined (_RWSTD_REENTRANT)
|
||||
|
||||
return _RW::__rw_atomic_exchange (x, y, false);
|
||||
|
||||
#endif // _RWSTD_REENTRANT
|
||||
}
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
template <class intT>
|
||||
void* thread_routine (thr_args<intT> *args)
|
||||
{
|
||||
// each thread operates on one of two shared values to exercise
|
||||
// problems due to operating on adjacent bytes or half-words
|
||||
const unsigned long inx = args->threadno_ % 2;
|
||||
|
||||
static volatile int failed;
|
||||
|
||||
// exercise atomic_exchange() in a tight loop
|
||||
|
||||
// perform the requested number increments, or until the
|
||||
// shared `failed' variable is set to a non-zero value
|
||||
|
||||
for (unsigned long i = 0; i != args->nincr_ && !failed; ++i) {
|
||||
|
||||
for (unsigned long j = 0; !failed; ++j) {
|
||||
|
||||
// increment the number of iterations of this thread
|
||||
++args->niter_;
|
||||
|
||||
// use intT() as a special "lock" value
|
||||
const intT old = exchange (args->shared_ [inx], intT ());
|
||||
|
||||
// increment the number of exchanges performed by this thread
|
||||
++args->nxchg_;
|
||||
|
||||
if (intT () != old) {
|
||||
|
||||
// shared variable was not locked by any other thread
|
||||
|
||||
// increment the value of the shared variable, taking
|
||||
// care to avoid the special "lock" value of intT()
|
||||
intT newval = intT (old + 1);
|
||||
|
||||
if (intT () == newval)
|
||||
++newval;
|
||||
|
||||
const intT lock = exchange (args->shared_ [inx], newval);
|
||||
|
||||
// increment the number of exchanges
|
||||
++args->nxchg_;
|
||||
|
||||
// the returned value must be the special "lock" value
|
||||
if (intT () == lock)
|
||||
break;
|
||||
|
||||
// fail by setting the shared failed variable (to
|
||||
// prevent deadlock) if the returned value is not
|
||||
// the special "lock" value
|
||||
|
||||
printf ("*** line %d: error: thread %lu failed "
|
||||
"at increment %lu after %lu iterations\n",
|
||||
__LINE__, args->threadno_, i, args->niter_);
|
||||
failed = 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (100UL * args->nincr_ == j) {
|
||||
|
||||
// fail by setting the shared failed variable (to
|
||||
// prevent deadlock) if the number of failed attempts
|
||||
// to lock the shared variable reaches the requested
|
||||
// number of increments * 100 (an arbitrary number)
|
||||
|
||||
printf ("*** line %d: error thread %lu \"timed out\" after "
|
||||
"%lu increments and %lu iterations\n",
|
||||
__LINE__, args->threadno_, i, args->niter_);
|
||||
failed = 1;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
extern "C" void* thread_routine (void *arg)
|
||||
{
|
||||
thr_args_base* const args = (thr_args_base*)arg;
|
||||
|
||||
printf ("thread %lu starting\n", args->threadno_);
|
||||
|
||||
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)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
#ifdef _RWSTD_REENTRANT
|
||||
|
||||
static const char* const fun = "__rw_atomic_exchange";
|
||||
|
||||
rw_info (0, 0, 0, "__rw::%s (%s&, %2$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_ = unsigned (rw_opt_nthreads);
|
||||
Args::type_tag_ = tag;
|
||||
Args::nincr_ = unsigned (rw_opt_nloops);
|
||||
Args::shared_ [0] = intT (1);
|
||||
Args::shared_ [1] = intT (1);
|
||||
|
||||
_RWSTD_ASSERT (Args::nthreads_ < sizeof tid / sizeof *tid);
|
||||
|
||||
Args args [sizeof tid / sizeof *tid];
|
||||
|
||||
for (unsigned long i = 0; i != Args::nthreads_; ++i) {
|
||||
|
||||
args [i].threadno_ = i;
|
||||
args [i].niter_ = 0;
|
||||
args [i].nxchg_ = 0;
|
||||
|
||||
rw_fatal (0 == rw_thread_create (tid + i, 0, thread_routine, args + i),
|
||||
0, __LINE__, "thread_create() failed");
|
||||
}
|
||||
|
||||
for (unsigned long i = 0; i != Args::nthreads_; ++i) {
|
||||
|
||||
rw_error (0 == rw_thread_join (tid [i], 0), 0, __LINE__,
|
||||
"thread_join() failed");
|
||||
|
||||
if (args [i].niter_) {
|
||||
// compute the percantage of thread iterations that resulted
|
||||
// in increments of one of the shared variables
|
||||
const unsigned long incrpcnt =
|
||||
(100U * Args::nincr_) / args [i].niter_;
|
||||
|
||||
printf ("thread %lu performed %lu exchanges in %lu iterations "
|
||||
"(%lu%% increments)\n",
|
||||
args [i].threadno_, args [i].nxchg_,
|
||||
args [i].niter_, incrpcnt);
|
||||
}
|
||||
}
|
||||
|
||||
// compute the expected result, "skipping" zeros by incrementing
|
||||
// expect twice when it overflows and wraps around to 0 (zero is
|
||||
// used as the lock variable in thread_routine() above)
|
||||
intT expect = intT (1);
|
||||
|
||||
const unsigned long nincr = (Args::nthreads_ * Args::nincr_) / 2U;
|
||||
|
||||
for (unsigned long i = 0; i != nincr; ++i) {
|
||||
if (intT () == ++expect)
|
||||
++expect;
|
||||
}
|
||||
|
||||
// verify that the final value of the variables shared among all
|
||||
// threads equals the number of increments performed by the threads
|
||||
rw_assert (Args::shared_ [0] == expect, 0, __LINE__,
|
||||
"1. %s (%s&, %2$s); %s == %s failed",
|
||||
fun, tname, TOSTR (Args::shared_ [0]), TOSTR (expect));
|
||||
|
||||
rw_assert (Args::shared_ [1] == expect, 0, __LINE__,
|
||||
"2. %s (%s&, %2$s); %s == %s failed",
|
||||
fun, tname, TOSTR (Args::shared_ [1]), TOSTR (expect));
|
||||
|
||||
#else // if !defined (_RWSTD_REENTRANT)
|
||||
|
||||
_RWSTD_UNUSED (tag);
|
||||
|
||||
#endif // _RWSTD_REENTRANT
|
||||
}
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
static int
|
||||
run_test (int, char**)
|
||||
{
|
||||
// exercise atomic exchange
|
||||
run_test ((char)0, thr_args_base::Char);
|
||||
run_test ((signed char)0, thr_args_base::SChar);
|
||||
run_test ((unsigned char)0, thr_args_base::UChar);
|
||||
|
||||
run_test ((short)0, thr_args_base::Short);
|
||||
run_test ((unsigned short)0, thr_args_base::UShort);
|
||||
|
||||
run_test ((int)0, thr_args_base::Int);
|
||||
run_test ((unsigned int)0, thr_args_base::UInt);
|
||||
|
||||
run_test ((long)0, thr_args_base::Long);
|
||||
run_test ((unsigned long)0, thr_args_base::ULong);
|
||||
|
||||
#ifdef _RWSTD_LONG_LONG
|
||||
|
||||
run_test ((_RWSTD_LONG_LONG)0, thr_args_base::LLong);
|
||||
run_test ((unsigned _RWSTD_LONG_LONG)0, thr_args_base::ULLong);
|
||||
|
||||
#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);
|
||||
}
|
||||
Reference in New Issue
Block a user