/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */

/*

 *  (C) 2008 by Argonne National Laboratory.

 *      See COPYRIGHT in top-level directory.

 */

#ifndef OPA_TEST_NAIVE

#  include "opa_primitives.h"

#else /* OPA_TEST_NAIVE */

#  define OPA_PRIMITIVES_H_INCLUDED

#  include "opa_config.h"

#  include "opa_util.h"

#  ifndef _opa_inline

#    define _opa_inline inline

#  endif

#endif /* OPA_TEST_NAIVE */

#include <assert.h>

#include <stdio.h>

#include <stdlib.h>

#include <limits.h>

#include <time.h>

#if defined(OPA_HAVE_PTHREAD_H)

#  include <pthread.h>

#endif /* HAVE_PTHREAD_H */

/* Define the macro to use for yielding the current thread (to others) */

#if defined(OPA_HAVE_PTHREAD_YIELD)

#  define OPA_TEST_YIELD() pthread_yield()

#elif defined(OPA_HAVE_SCHED_YIELD)

#  include <sched.h>

#  define OPA_TEST_YIELD() (void) sched_yield()

#else

#  define OPA_TEST_YIELD() (void) 0

#endif

/*

 * Naive redefinition of OPA functions as simple C operations.  These should

 * pass all the "simple" tests, but fail on the threaded tests (with >1 thread),

 * unless the tested operation is natively atomic.

 */

#ifdef OPA_TEST_NAIVE

#define OPA_UNIVERSAL_PRIMITIVE OPA_CAS

#define OPA_LL_SC_SUPPORTED 1

typedef volatile int OPA_int_t;

typedef void * volatile OPA_ptr_t;

#define OPA_load_int(A) (*(A))

#define OPA_store_int(A, B) ((void) (*(A) = (B)))

#define OPA_load_ptr(A) (*(A))

#define OPA_store_ptr(A, B) ((void) (*(A) = (B)))

#define OPA_add_int(A, B) ((void) (*(A) += (B)))

#define OPA_incr_int(A) ((void) (++(*(A))))

#define OPA_decr_int(A) ((void) (--(*(A))))

#define OPA_decr_and_test_int(A) (0 == --(*(A)))

static _opa_inline int OPA_fetch_and_add_int(OPA_int_t *ptr, int val)

{

    int prev = *ptr;

    *ptr += val;

    return prev;

}

#define OPA_fetch_and_incr_int(A) ((*(A))++)

#define OPA_fetch_and_decr_int(A) ((*(A))--)

#define OPA_cas_ptr(A, B, C) (*(A) == (B) ? (*(A) = (C), (B)) : *(A))

#define OPA_cas_int(A, B, C) (*(A) == (B) ? (*(A) = (C), (B)) : *(A))

static _opa_inline void *OPA_swap_ptr(OPA_ptr_t *ptr, void *val)

{

    void *prev;

    prev = *ptr;

    *ptr = val;

    return prev;

}

static _opa_inline int OPA_swap_int(OPA_int_t *ptr, int val)

{

    int prev;

    prev = *ptr;

    *ptr = val;

    return prev;

}

#define OPA_write_barrier() ((void) 0)

#define OPA_read_barrier() ((void) 0)

#define OPA_read_write_barrier() ((void) 0)

/* For LL/SC only use load/store.  This is more naive than the above

 * implementation for CAS */

#define OPA_LL_int OPA_load_int

#define OPA_SC_int(A, B) (OPA_store_int(A, B), 1)

#define OPA_LL_ptr OPA_load_ptr

#define OPA_SC_ptr(A, B) (OPA_store_ptr(A, B), 1)

#if defined(OPA_HAVE_SCHED_YIELD)

#  include <sched.h>

#  define OPA_busy_wait() sched_yield()

#else

#  define OPA_busy_wait() do { } while (0)

#endif

#endif /* OPA_TEST_NAIVE */

/*

 * Cache line padding.  See note in opa_queue.h.

 */

#define OPA_TEST_CACHELINE_PADDING 128

/*

 * Print the current location on the standard output stream.

 */

#define AT()            printf ("        at %s:%d in %s()...\n",              \

                                __FILE__, __LINE__, __FUNCTION__)

/*

 * The name of the test is printed by saying TESTING("something") which will

 * result in the string `Testing something' being flushed to standard output.

 * If a test passes, fails, or is skipped then the PASSED(), FAILED(), or

 * SKIPPED() macro should be called.  After HFAILED() or SKIPPED() the caller

 * should print additional information to stdout indented by at least four

 * spaces.

 */

#define TESTING(WHAT, NTHREADS)                                                \

do {                                                                           \

    if(NTHREADS) {                                                             \

        int nwritten_chars;                                                    \

        printf("Testing %s with %d thread%s %n",                               \

                WHAT,                                                          \

                (int) NTHREADS,                                                \

                (NTHREADS) > 1 ? "s" : "",                                     \

                &nwritten_chars);                                              \

        printf("%*s", nwritten_chars > 70 ? 0 : 70 - nwritten_chars, "");      \

    } /* end if */                                                             \

    else                                                                       \

        printf("Testing %-62s", WHAT);                                         \

    fflush(stdout);                                                            \

} while(0)

#define PASSED()        do {puts(" PASSED");fflush(stdout);} while(0)

#define FAILED()        do {puts("*FAILED*");fflush(stdout);} while(0)

#define WARNING()       do {puts("*WARNING*");fflush(stdout);} while(0)

#define SKIPPED()       do {puts(" -SKIP-");fflush(stdout);} while(0)

#define TEST_ERROR      do {FAILED(); AT(); goto error;} while(0)

#define FAIL_OP_ERROR(OP) do {FAILED(); AT(); OP; goto error;} while(0)

#define OP_SUPPRESS(OP, COUNTER, LIMIT) do {                                   \

    if((COUNTER) <= (LIMIT)) {                                                 \

        OP;                                                                    \

        if((COUNTER) == (LIMIT))                                               \

            puts("    Suppressing further output...");                         \

        fflush(stdout);                                                        \

    } /* end if */                                                             \

} while(0)

/*

 * Array of number of threads.  Each threaded test is run once for each entry in

 * this array.  Remove the last test if OPA_LIMIT_THREADS is defined.

 */

static const unsigned num_threads[] = {1, 2, 4, 10, 100};

static const unsigned num_thread_tests = sizeof(num_threads) / sizeof(num_threads[0])

#if OPA_MAX_NTHREADS < 10

- 2

#elif OPA_MAX_NTHREADS < 100

- 1

#endif /* OPA_LIMIT_THREADS */

;

/*

 * Factor to reduce the number of iterations by for each test.  Must be the same

 * size as num_threads.

 */

static const unsigned iter_reduction[] = {1, 1, 1, 1, 10};

/*

 * Other global variables.

 */

static unsigned curr_test;   /* Current test number bein run */