/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
/*
 *  (C) 2001 by Argonne National Laboratory.
 *      See COPYRIGHT in top-level directory.
 */

#ifndef MPL_THREAD_PRIV_H_INCLUDED
#define MPL_THREAD_PRIV_H_INCLUDED

#if MPL_THREAD_PACKAGE_NAME != MPL_THREAD_PACKAGE_NONE && !defined(MPL_TLS)
/* We need to provide a function that will cleanup the storage attached
 * to the key.  */
void MPLI_cleanup_tls(void *a);

/* In the case where the thread level is set in MPI_Init_thread, we
   need a blended version of the non-threaded and the thread-multiple
   definitions.

   The approach is to have TWO MPLI_per_thread_t pointers.  One is local
   (The MPL_THREADPRIV_DECL is used in the routines local definitions),
   as in the threaded version of these macros.  This is set by using a routine
   to get thread-private storage.  The second is a preallocated, extern
   MPLI_per_thread_t struct, as in the single threaded case.  Based on
   whether MPL is initialized with thread safety, one or the other is used.
 */

#define MPL_THREADPRIV_KEY_CREATE(key, var, err_ptr_, class_)           \
    do {                                                                \
        void *thread_ptr;                                               \
                                                                        \
        MPL_thread_tls_create(MPLI_cleanup_tls, &(key) , err_ptr_);     \
        if (unlikely(*((int *) err_ptr_)))                              \
            break;                                                      \
        thread_ptr = MPL_calloc(1, sizeof(var), class_);                \
        if (unlikely(!thread_ptr)) {                                    \
            *((int *) err_ptr_) = MPL_THREAD_ERROR;                     \
            break;                                                      \
        }                                                               \
        MPL_thread_tls_set(&(key), thread_ptr, err_ptr_);               \
    } while (0)

#define MPL_THREADPRIV_KEY_GET_ADDR(is_threaded, key, var, addr, err_ptr_)  \
    do {                                                                \
        if (is_threaded) {                                              \
            void *thread_ptr;                                           \
            MPL_thread_tls_get(&(key), &thread_ptr, err_ptr_);          \
            if (unlikely(*((int *) err_ptr_)))                          \
                break;                                                  \
            if (!thread_ptr) {                                          \
                thread_ptr = MPL_calloc(1, sizeof(var), MPL_MEM_OTHER); \
                if (unlikely(!thread_ptr)) {                            \
                    *((int *) err_ptr_) = MPL_THREAD_ERROR;             \
                    break;                                              \
                }                                                       \
                MPL_thread_tls_set(&(key), thread_ptr, err_ptr_);       \
                if (unlikely(*((int *) err_ptr_)))                      \
                    break;                                              \
            }                                                           \
            addr = thread_ptr;                                          \
        }                                                               \
        else {                                                          \
            addr = &(var);                                              \
        }                                                               \
    } while (0)

#define MPL_THREADPRIV_KEY_DESTROY(key, err_ptr_)       \
    do {                                                \
        void *thread_ptr;                               \
                                                        \
        MPL_thread_tls_get(&(key), &thread_ptr, err_ptr_); \
        if (unlikely(*((int *) err_ptr_)))                 \
            break;                                      \
                                                        \
        if (thread_ptr)                                 \
            MPL_free(thread_ptr);                       \
                                                        \
        MPL_thread_tls_set(&(key), NULL, err_ptr_);     \
        if (unlikely(*((int *) err_ptr_)))              \
            break;                                      \
                                                        \
        MPL_thread_tls_destroy(&(key), err_ptr_);       \
    } while (0)

#else /* MPL_THREAD_PACKAGE_NAME != MPL_THREAD_PACKAGE_NONE || defined(MPL_TLS) */

/* We have proper thread-local storage (TLS) support from the compiler, which
 * should yield the best performance and simplest code, so we'll use that. */
#define MPL_THREADPRIV_KEY_CREATE(...)
#define MPL_THREADPRIV_KEY_GET_ADDR(is_threaded, key, var, addr, err_ptr_) \
    do {                                                                \
        addr = &(var);                                                  \
        *((int *) err_ptr_) = MPL_THREAD_SUCCESS;                       \
    } while (0)
#define MPL_THREADPRIV_KEY_DESTROY(...)

#endif

#endif /* MPL_THREAD_PRIV_H_INCLUDED */