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

/*

 *  (C) 2001 by Argonne National Laboratory.

 *      See COPYRIGHT in top-level directory.

 */

#include "mpiimpl.h"

/* -- Begin Profiling Symbol Block for routine MPI_Grequest_start */

#if defined(HAVE_PRAGMA_WEAK)

#pragma weak MPI_Grequest_start = PMPI_Grequest_start

#elif defined(HAVE_PRAGMA_HP_SEC_DEF)

#pragma _HP_SECONDARY_DEF PMPI_Grequest_start  MPI_Grequest_start

#elif defined(HAVE_PRAGMA_CRI_DUP)

#pragma _CRI duplicate MPI_Grequest_start as PMPI_Grequest_start

#elif defined(HAVE_WEAK_ATTRIBUTE)

int MPI_Grequest_start(MPI_Grequest_query_function * query_fn, MPI_Grequest_free_function * free_fn,

                       MPI_Grequest_cancel_function * cancel_fn, void *extra_state,

                       MPI_Request * request) __attribute__ ((weak, alias("PMPI_Grequest_start")));

#endif

/* -- End Profiling Symbol Block */

PMPI_LOCAL int MPIR_Grequest_free_classes_on_finalize(void *extra_data);

/* Define MPICH_MPI_FROM_PMPI if weak symbols are not supported to build

   the MPI routines.  You can use USE_WEAK_SYMBOLS to see if MPICH is

   using weak symbols to implement the MPI routines. */

#ifndef MPICH_MPI_FROM_PMPI

#undef MPI_Grequest_start

#define MPI_Grequest_start PMPI_Grequest_start

/* preallocated grequest classes */

#ifndef MPIR_GREQ_CLASS_PREALLOC

#define MPIR_GREQ_CLASS_PREALLOC 2

#endif

MPIR_Grequest_class MPIR_Grequest_class_direct[MPIR_GREQ_CLASS_PREALLOC] = { {0} };

MPIR_Object_alloc_t MPIR_Grequest_class_mem = { 0, 0, 0, 0, MPIR_GREQ_CLASS,

    sizeof(MPIR_Grequest_class),

    MPIR_Grequest_class_direct,

    MPIR_GREQ_CLASS_PREALLOC,

};

/* We jump through some minor hoops to manage the list of classes ourselves and

 * only register a single finalizer to avoid hitting limitations in the current

 * finalizer code.  If the finalizer implementation is ever revisited this code

 * is a good candidate for registering one callback per greq class and trimming

 * some of this logic. */

int MPIR_Grequest_registered_finalizer = 0;

MPIR_Grequest_class *MPIR_Grequest_class_list = NULL;

/* Any internal routines can go here.  Make them static if possible.  If they

   are used by both the MPI and PMPI versions, use PMPI_LOCAL instead of

   static; this macro expands into "static" if weak symbols are supported and

   into nothing otherwise. */

PMPI_LOCAL int MPIR_Grequest_free_classes_on_finalize(void *extra_data ATTRIBUTE((unused)))

{

    int mpi_errno = MPI_SUCCESS;

    MPIR_Grequest_class *last = NULL;

    MPIR_Grequest_class *cur = MPIR_Grequest_class_list;

    /* FIXME MT this function is not thread safe when using fine-grained threading */

    MPIR_Grequest_class_list = NULL;

    while (cur) {

        last = cur;

        cur = last->next;

        MPIR_Handle_obj_free(&MPIR_Grequest_class_mem, last);

    }

    return mpi_errno;

}

#undef FUNCNAME

#define FUNCNAME MPIR_Grequest_start

#undef FCNAME

#define FCNAME MPL_QUOTE(FUNCNAME)

int MPIR_Grequest_start(MPI_Grequest_query_function * query_fn,

                        MPI_Grequest_free_function * free_fn,

                        MPI_Grequest_cancel_function * cancel_fn,

                        void *extra_state, MPIR_Request ** request_ptr)

{

    int mpi_errno = MPI_SUCCESS;

    MPIR_CHKPMEM_DECL(1);

    /* MT FIXME this routine is not thread-safe in the non-global case */

    *request_ptr = MPIR_Request_create(MPIR_REQUEST_KIND__GREQUEST);

    MPIR_ERR_CHKANDJUMP1(*request_ptr == NULL, mpi_errno, MPI_ERR_OTHER, "**nomem", "**nomem %s",

                         "generalized request");

    MPIR_Object_set_ref(*request_ptr, 1);

    (*request_ptr)->cc_ptr = &(*request_ptr)->cc;

    MPIR_cc_set((*request_ptr)->cc_ptr, 1);

    (*request_ptr)->comm = NULL;

    MPIR_CHKPMEM_MALLOC((*request_ptr)->u.ureq.greq_fns, struct MPIR_Grequest_fns *,

                        sizeof(struct MPIR_Grequest_fns), mpi_errno, "greq_fns", MPL_MEM_GREQ);

    (*request_ptr)->u.ureq.greq_fns->cancel_fn = cancel_fn;

    (*request_ptr)->u.ureq.greq_fns->free_fn = free_fn;

    (*request_ptr)->u.ureq.greq_fns->query_fn = query_fn;

    (*request_ptr)->u.ureq.greq_fns->poll_fn = NULL;

    (*request_ptr)->u.ureq.greq_fns->wait_fn = NULL;

    (*request_ptr)->u.ureq.greq_fns->grequest_extra_state = extra_state;

    (*request_ptr)->u.ureq.greq_fns->greq_lang = MPIR_LANG__C;

    /* Add an additional reference to the greq.  One of them will be

     * released when we complete the request, and the second one, when

     * we test or wait on it. */

    MPIR_Request_add_ref((*request_ptr));

    MPIR_CHKPMEM_COMMIT();

  fn_exit:

    return mpi_errno;

  fn_fail:

    MPIR_CHKPMEM_REAP();

    goto fn_exit;

}

#else

extern MPIR_Grequest_class MPIR_Grequest_class_direct[];

extern MPIR_Object_alloc_t MPIR_Grequest_class_mem;

extern int MPIR_Grequest_registered_finalizer;

extern MPIR_Grequest_class *MPIR_Grequest_class_list;

#endif

#undef FUNCNAME

#define FUNCNAME MPI_Grequest_start

#undef FCNAME

#define FCNAME MPL_QUOTE(FUNCNAME)

/*@

   MPI_Grequest_start - Create and return a user-defined request

Input Parameters:

+ query_fn - callback function invoked when request status is queried (function)

. free_fn - callback function invoked when request is freed (function)

. cancel_fn - callback function invoked when request is cancelled (function)

- extra_state - Extra state passed to the above functions.

Output Parameters:

.  request - Generalized request (handle)

 Notes on the callback functions:

 The return values from the callback functions must be a valid MPI error code

 or class.  This value may either be the return value from any MPI routine

 (with one exception noted below) or any of the MPI error classes.

 For portable programs, 'MPI_ERR_OTHER' may be used; to provide more

 specific information, create a new MPI error class or code with

 'MPI_Add_error_class' or 'MPI_Add_error_code' and return that value.

 The MPI standard is not clear on the return values from the callback routines.

 However, there are notes in the standard that imply that these are MPI error

 codes.  For example, pages 169 line 46 through page 170, line 1 require that

 the 'free_fn' return an MPI error code that may be used in the MPI completion

 functions when they return 'MPI_ERR_IN_STATUS'.

 The one special case is the error value returned by 'MPI_Comm_dup' when

 the attribute callback routine returns a failure.  The MPI standard is not

 clear on what values may be used to indicate an error return.  Further,

 the Intel MPI test suite made use of non-zero values to indicate failure,

 and expected these values to be returned by the 'MPI_Comm_dup' when the

 attribute routines encountered an error.  Such error values may not be valid

 MPI error codes or classes.  Because of this, it is the user''s responsibility

 to either use valid MPI error codes in return from the attribute callbacks,

 if those error codes are to be returned by a generalized request callback,

 or to detect and convert those error codes to valid MPI error codes (recall

 that MPI error classes are valid error codes).

.N ThreadSafe

.N Fortran

.N Errors

.N MPI_SUCCESS

.N MPI_ERR_ARG

@*/

int MPI_Grequest_start(MPI_Grequest_query_function * query_fn,

                       MPI_Grequest_free_function * free_fn,

                       MPI_Grequest_cancel_function * cancel_fn,

                       void *extra_state, MPI_Request * request)

{

    int mpi_errno = MPI_SUCCESS;

    MPIR_Request *request_ptr;

    MPIR_FUNC_TERSE_STATE_DECL(MPID_STATE_MPI_GREQUEST_START);

    MPIR_ERRTEST_INITIALIZED_ORDIE();

    MPID_THREAD_CS_ENTER(GLOBAL, MPIR_THREAD_GLOBAL_ALLFUNC_MUTEX);

    MPIR_FUNC_TERSE_ENTER(MPID_STATE_MPI_GREQUEST_START);

    /* Validate parameters if error checking is enabled */

#ifdef HAVE_ERROR_CHECKING

    {

        MPID_BEGIN_ERROR_CHECKS;

        {

            MPIR_ERRTEST_ARGNULL(request, "request", mpi_errno);

        }

        MPID_END_ERROR_CHECKS;

    }

#endif /* HAVE_ERROR_CHECKING */

    /* ... body of routine ...  */

    mpi_errno = MPIR_Grequest_start(query_fn, free_fn, cancel_fn, extra_state, &request_ptr);

    if (mpi_errno)

        goto fn_fail;

    MPIR_OBJ_PUBLISH_HANDLE(*request, request_ptr->handle);

    /* ... end of body of routine ... */

  fn_exit:

    MPIR_FUNC_TERSE_EXIT(MPID_STATE_MPI_GREQUEST_START);

    MPID_THREAD_CS_EXIT(GLOBAL, MPIR_THREAD_GLOBAL_ALLFUNC_MUTEX);

    return mpi_errno;

  fn_fail:

    /* --BEGIN ERROR HANDLING-- */

#ifdef HAVE_ERROR_CHECKING

    {

        mpi_errno =

            MPIR_Err_create_code(mpi_errno, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER,

                                 "**mpi_grequest_start", "**mpi_grequest_start %p %p %p %p %p",

                                 query_fn, free_fn, cancel_fn, extra_state, request);

    }

#endif

    mpi_errno = MPIR_Err_return_comm(NULL, FCNAME, mpi_errno);

    goto fn_exit;

    /* --END ERROR HANDLING-- */

}

/* -- Begin Profiling Symbol Block for routine MPIX_Grequest_class_create*/

#if defined(HAVE_PRAGMA_WEAK)

#pragma weak MPIX_Grequest_class_create = PMPIX_Grequest_class_create

#elif defined(HAVE_PRAGMA_HP_SEC_DEF)

#pragma _HP_SECONDARY_DEF PMPIX_Grequest_class_create MPIX_Grequest_class_create

#elif defined(HAVE_PRAGMA_CRI_DUP)

#pragma _CRI duplicate MPIX_Grequest_class_create as PMPIX_Grequest_class_create

#elif defined(HAVE_WEAK_ATTRIBUTE)

int MPIX_Grequest_class_create(MPI_Grequest_query_function * query_fn,

                               MPI_Grequest_free_function * free_fn,

                               MPI_Grequest_cancel_function * cancel_fn,

                               MPIX_Grequest_poll_function * poll_fn,

                               MPIX_Grequest_wait_function * wait_fn,

                               MPIX_Grequest_class * greq_class)

    __attribute__ ((weak, alias("PMPIX_Grequest_class_create")));

#endif

/* -- End Profiling Symbol Block */

/* Define MPICH_MPI_FROM_PMPI if weak symbols are not supported to build

   the MPI routines */

#ifndef MPICH_MPI_FROM_PMPI

#undef MPIX_Grequest_class_create

#define MPIX_Grequest_class_create PMPIX_Grequest_class_create

#endif

#undef FUNCNAME

#define FUNCNAME MPIX_Grequest_class_create

#undef FCNAME

#define FCNAME MPL_QUOTE(FUNCNAME)

/* extensions for Generalized Request redesign paper */

int MPIX_Grequest_class_create(MPI_Grequest_query_function * query_fn,

                               MPI_Grequest_free_function * free_fn,

                               MPI_Grequest_cancel_function * cancel_fn,

                               MPIX_Grequest_poll_function * poll_fn,

                               MPIX_Grequest_wait_function * wait_fn,

                               MPIX_Grequest_class * greq_class)

{

    MPIR_Grequest_class *class_ptr;

    int mpi_errno = MPI_SUCCESS;

    class_ptr = (MPIR_Grequest_class *)

        MPIR_Handle_obj_alloc(&MPIR_Grequest_class_mem);

    /* --BEGIN ERROR HANDLING-- */

    if (!class_ptr) {

        mpi_errno = MPIR_Err_create_code(MPI_SUCCESS,

                                         MPIR_ERR_RECOVERABLE, FCNAME, __LINE__,

                                         MPI_ERR_OTHER, "**nomem",

                                         "**nomem %s", "MPIX_Grequest_class");

        goto fn_fail;

    }

    /* --END ERROR HANDLING-- */

    class_ptr->query_fn = query_fn;

    class_ptr->free_fn = free_fn;

    class_ptr->cancel_fn = cancel_fn;

    class_ptr->poll_fn = poll_fn;

    class_ptr->wait_fn = wait_fn;

    MPIR_Object_set_ref(class_ptr, 1);

    if (MPIR_Grequest_class_list == NULL) {

        class_ptr->next = NULL;

    } else {

        class_ptr->next = MPIR_Grequest_class_list;

    }

    MPIR_Grequest_class_list = class_ptr;

    if (!MPIR_Grequest_registered_finalizer) {

        /* must run before (w/ higher priority than) the handle check

         * finalizer in order avoid being flagged as a leak */

        MPIR_Add_finalize(&MPIR_Grequest_free_classes_on_finalize,

                          NULL, MPIR_FINALIZE_CALLBACK_HANDLE_CHECK_PRIO + 1);

        MPIR_Grequest_registered_finalizer = 1;

    }

    MPIR_OBJ_PUBLISH_HANDLE(*greq_class, class_ptr->handle);

    /* ... end of body of routine ... */

  fn_exit:

    return mpi_errno;

  fn_fail:

    /* --BEGIN ERROR HANDLING-- */

#ifdef HAVE_ERROR_CHECKING

    {

        mpi_errno =

            MPIR_Err_create_code(mpi_errno, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER,

                                 "**mpix_grequest_class_create",

                                 "**mpix_grequest_class_create %p %p %p %p %p", query_fn, free_fn,

                                 cancel_fn, poll_fn, wait_fn);

    }

#endif

    mpi_errno = MPIR_Err_return_comm(0, FCNAME, mpi_errno);

    goto fn_exit;

    /* --END ERROR HANDLING-- */

}

/* -- Begin Profiling Symbol Block for routine MPIX_Grequest_class_allocate */

#if defined(HAVE_PRAGMA_WEAK)

#pragma weak MPIX_Grequest_class_allocate = PMPIX_Grequest_class_allocate

#elif defined(HAVE_PRAGMA_HP_SEC_DEF)

#pragma _HP_SECONDARY_DEF PMPIX_Grequest_class_allocate MPIX_Grequest_class_allocate

#elif defined(HAVE_PRAGMA_CRI_DUP)

#pragma _CRI duplicate MPIX_Grequest_class_allocate as PMPIX_Grequest_class_allocate

#elif defined(HAVE_WEAK_ATTRIBUTE)

int MPIX_Grequest_class_allocate(MPIX_Grequest_class greq_class, void *extra_state,

                                 MPI_Request * request)

    __attribute__ ((weak, alias("PMPIX_Grequest_class_allocate")));

#endif

/* -- End Profiling Symbol Block */

/* Define MPICH_MPI_FROM_PMPI if weak symbols are not supported to build

   the MPI routines */

#ifndef MPICH_MPI_FROM_PMPI

#undef MPIX_Grequest_class_allocate

#define MPIX_Grequest_class_allocate PMPIX_Grequest_class_allocate

#endif

#undef FUNCNAME

#define FUNCNAME MPIX_Grequest_class_allocate

int MPIX_Grequest_class_allocate(MPIX_Grequest_class greq_class,

                                 void *extra_state, MPI_Request * request)

{

    int mpi_errno;

    MPIR_Request *lrequest_ptr;

    MPIR_Grequest_class *class_ptr;

    *request = MPI_REQUEST_NULL;

    MPIR_Grequest_class_get_ptr(greq_class, class_ptr);

    mpi_errno = MPIR_Grequest_start(class_ptr->query_fn, class_ptr->free_fn,

                                    class_ptr->cancel_fn, extra_state, &lrequest_ptr);

    if (mpi_errno == MPI_SUCCESS) {

        *request = lrequest_ptr->handle;

        lrequest_ptr->u.ureq.greq_fns->poll_fn = class_ptr->poll_fn;

        lrequest_ptr->u.ureq.greq_fns->wait_fn = class_ptr->wait_fn;

        lrequest_ptr->u.ureq.greq_fns->greq_class = greq_class;

    }

    return mpi_errno;

}

/* -- Begin Profiling Symbol Block for routine MPIX_Grequest_start */

#if defined(HAVE_PRAGMA_WEAK)

#pragma weak MPIX_Grequest_start = PMPIX_Grequest_start

#elif defined(HAVE_PRAGMA_HP_SEC_DEF)

#pragma _HP_SECONDARY_DEF PMPIX_Grequest_start MPIX_Grequest_start

#elif defined(HAVE_PRAGMA_CRI_DUP)

#pragma _CRI duplicate MPIX_Grequest_start as PMPIX_Grequest_start

#elif defined(HAVE_WEAK_ATTRIBUTE)

int MPIX_Grequest_start(MPI_Grequest_query_function * query_fn,

                        MPI_Grequest_free_function * free_fn,

                        MPI_Grequest_cancel_function * cancel_fn,

                        MPIX_Grequest_poll_function * poll_fn,

                        MPIX_Grequest_wait_function * wait_fn,

                        void *extra_state, MPI_Request * request)

    __attribute__ ((weak, alias("PMPIX_Grequest_start")));

#endif

/* -- End Profiling Symbol Block */

/* Define MPICH_MPI_FROM_PMPI if weak symbols are not supported to build

   the MPI routines */

#ifndef MPICH_MPI_FROM_PMPI

#undef MPIX_Grequest_start

#define MPIX_Grequest_start PMPIX_Grequest_start

#endif

#undef FUNCNAME

#define FUNCNAME MPIX_Grequest_start

int MPIX_Grequest_start(MPI_Grequest_query_function * query_fn,

                        MPI_Grequest_free_function * free_fn,

                        MPI_Grequest_cancel_function * cancel_fn,

                        MPIX_Grequest_poll_function * poll_fn,

                        MPIX_Grequest_wait_function * wait_fn,

                        void *extra_state, MPI_Request * request)

{

    int mpi_errno;

    MPIR_Request *lrequest_ptr;

    *request = MPI_REQUEST_NULL;

    mpi_errno =

        MPIX_Grequest_start_impl(query_fn, free_fn, cancel_fn, poll_fn, wait_fn, extra_state,

                                 &lrequest_ptr);

    if (mpi_errno == MPI_SUCCESS) {

        *request = lrequest_ptr->handle;

    }

    return mpi_errno;

}

#ifndef MPICH_MPI_FROM_PMPI

#undef FUNCNAME

#define FUNCNAME MPIX_Grequest_start_impl

#undef FCNAME

#define FCNAME MPL_QUOTE(FUNCNAME)

int MPIX_Grequest_start_impl(MPI_Grequest_query_function * query_fn,

                             MPI_Grequest_free_function * free_fn,

                             MPI_Grequest_cancel_function * cancel_fn,

                             MPIX_Grequest_poll_function * poll_fn,

                             MPIX_Grequest_wait_function * wait_fn,

                             void *extra_state, MPIR_Request ** request)

{

    int mpi_errno;

    mpi_errno = MPIR_Grequest_start(query_fn, free_fn, cancel_fn, extra_state, request);

    if (mpi_errno == MPI_SUCCESS) {

        (*request)->u.ureq.greq_fns->poll_fn = poll_fn;

        (*request)->u.ureq.greq_fns->wait_fn = wait_fn;

    }

    return mpi_errno;

}

#endif /* MPICH_MPI_FROM_PMPI */