/*
* Copyright (c) 2003-2005 Hewlett-Packard Development Company, L.P.
*
* This file may be redistributed and/or modified under the
* terms of the GNU General Public License as published by the Free Software
* Foundation; either version 2, or (at your option) any later version.
*
* It is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License in the
* file COPYING for more details.
*/
#if defined(HAVE_CONFIG_H)
# include "config.h"
#endif
#if defined(AO_NO_PTHREADS) && defined(AO_USE_PTHREAD_DEFS)
# include <stdio.h>
int main(void)
{
printf("test skipped\n");
return 0;
}
#else
#include "run_parallel.h"
#include "test_atomic_include.h"
#if defined(AO_USE_PTHREAD_DEFS) || defined(AO_PREFER_GENERALIZED)
# define NITERS 100000
#else
# define NITERS 10000000
#endif
void * add1sub1_thr(void * id);
int add1sub1_test(void);
void * acqrel_thr(void *id);
int acqrel_test(void);
void * test_and_set_thr(void * id);
int test_and_set_test(void);
#if defined(AO_HAVE_fetch_and_add1) && defined(AO_HAVE_fetch_and_sub1)
AO_t counter = 0;
void * add1sub1_thr(void * id)
{
int me = (int)(AO_PTRDIFF_T)id;
int i;
for (i = 0; i < NITERS; ++i)
if ((me & 1) != 0) {
(void)AO_fetch_and_sub1(&counter);
} else {
(void)AO_fetch_and_add1(&counter);
}
return 0;
}
int add1sub1_test(void)
{
return counter == 0;
}
#endif /* defined(AO_HAVE_fetch_and_add1) && defined(AO_HAVE_fetch_and_sub1) */
#if defined(AO_HAVE_store_release_write) && defined(AO_HAVE_load_acquire_read)
/* Invariant: counter1 >= counter2 */
AO_t counter1 = 0;
AO_t counter2 = 0;
void * acqrel_thr(void *id)
{
int me = (int)(AO_PTRDIFF_T)id;
int i;
for (i = 0; i < NITERS; ++i)
if (me & 1)
{
AO_t my_counter1;
if (me != 1)
{
fprintf(stderr, "acqrel test: too many threads\n");
abort();
}
my_counter1 = AO_load(&counter1);
AO_store(&counter1, my_counter1 + 1);
AO_store_release_write(&counter2, my_counter1 + 1);
}
else
{
AO_t my_counter1a, my_counter2a;
AO_t my_counter1b, my_counter2b;
my_counter2a = AO_load_acquire_read(&counter2);
my_counter1a = AO_load(&counter1);
/* Redo this, to make sure that the second load of counter1 */
/* is not viewed as a common subexpression. */
my_counter2b = AO_load_acquire_read(&counter2);
my_counter1b = AO_load(&counter1);
if (my_counter1a < my_counter2a)
{
fprintf(stderr, "Saw release store out of order: %lu < %lu\n",
(unsigned long)my_counter1a, (unsigned long)my_counter2a);
abort();
}
if (my_counter1b < my_counter2b)
{
fprintf(stderr,
"Saw release store out of order (bad CSE?): %lu < %lu\n",
(unsigned long)my_counter1b, (unsigned long)my_counter2b);
abort();
}
}
return 0;
}
int acqrel_test(void)
{
return counter1 == NITERS && counter2 == NITERS;
}
#endif /* AO_HAVE_store_release_write && AO_HAVE_load_acquire_read */
#if defined(AO_HAVE_test_and_set_acquire)
AO_TS_t lock = AO_TS_INITIALIZER;
unsigned long locked_counter;
volatile unsigned long junk = 13;
AO_ATTR_NO_SANITIZE_THREAD
void do_junk(void)
{
junk *= 17;
junk *= 19;
}
void * test_and_set_thr(void * id)
{
unsigned long i;
for (i = 0; i < NITERS/10; ++i)
{
while (AO_test_and_set_acquire(&lock) != AO_TS_CLEAR);
++locked_counter;
if (locked_counter != 1)
{
fprintf(stderr, "Test and set failure 1, counter = %ld, id = %d\n",
(long)locked_counter, (int)(AO_PTRDIFF_T)id);
abort();
}
locked_counter *= 2;
locked_counter -= 1;
locked_counter *= 5;
locked_counter -= 4;
if (locked_counter != 1)
{
fprintf(stderr, "Test and set failure 2, counter = %ld, id = %d\n",
(long)locked_counter, (int)(AO_PTRDIFF_T)id);
abort();
}
--locked_counter;
AO_CLEAR(&lock);
/* Spend a bit of time outside the lock. */
do_junk();
}
return 0;
}
int test_and_set_test(void)
{
return locked_counter == 0;
}
#endif /* defined(AO_HAVE_test_and_set_acquire) */
#if (!defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__BORLANDC__) \
|| defined(AO_USE_NO_SIGNALS) || defined(AO_USE_WIN32_PTHREADS)) \
&& defined(AO_TEST_EMULATION)
void AO_store_full_emulation(volatile AO_t *addr, AO_t val);
AO_t AO_fetch_compare_and_swap_emulation(volatile AO_t *addr, AO_t old_val,
AO_t new_val);
# ifdef AO_HAVE_double_t
int AO_compare_double_and_swap_double_emulation(volatile AO_double_t *,
AO_t old_val1, AO_t old_val2,
AO_t new_val1, AO_t new_val2);
# endif
void test_atomic_emulation(void)
{
AO_t x;
# ifdef AO_HAVE_double_t
AO_double_t w; /* double-word alignment not needed */
w.AO_val1 = 0;
w.AO_val2 = 0;
TA_assert(!AO_compare_double_and_swap_double_emulation(&w, 4116, 2121,
8537, 6410));
TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
TA_assert(AO_compare_double_and_swap_double_emulation(&w, 0, 0,
8537, 6410));
TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
# endif
AO_store_full_emulation(&x, 1314);
TA_assert(x == 1314);
TA_assert(AO_fetch_compare_and_swap_emulation(&x, 14, 13117) == 1314);
TA_assert(x == 1314);
TA_assert(AO_fetch_compare_and_swap_emulation(&x, 1314, 14117) == 1314);
TA_assert(x == 14117);
}
#else
# define test_atomic_emulation() (void)0
#endif /* _MSC_VER && !AO_USE_NO_SIGNALS || !AO_TEST_EMULATION */
int main(void)
{
test_atomic();
test_atomic_acquire();
test_atomic_release();
test_atomic_read();
test_atomic_write();
test_atomic_full();
test_atomic_release_write();
test_atomic_acquire_read();
test_atomic_dd_acquire_read();
# if defined(AO_HAVE_fetch_and_add1) && defined(AO_HAVE_fetch_and_sub1)
run_parallel(4, add1sub1_thr, add1sub1_test, "add1/sub1");
# endif
# if defined(AO_HAVE_store_release_write) && defined(AO_HAVE_load_acquire_read)
run_parallel(3, acqrel_thr, acqrel_test,
"store_release_write/load_acquire_read");
# endif
# if defined(AO_HAVE_test_and_set_acquire)
run_parallel(5, test_and_set_thr, test_and_set_test,
"test_and_set");
# endif
test_atomic_emulation();
return 0;
}
#endif /* !AO_NO_PTHREADS || !AO_USE_PTHREAD_DEFS */