/*
 * Copyright 2010-2015 Intel Corporation.
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, version 2.1.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301 USA.
 *
 * Disclaimer: The codes contained in these modules may be specific
 * to the Intel Software Development Platform codenamed Knights Ferry,
 * and the Intel product codenamed Knights Corner, and are not backward
 * compatible with other Intel products. Additionally, Intel will NOT
 * support the codes or instruction set in future products.
 *
 * Intel offers no warranty of any kind regarding the code. This code is
 * licensed on an "AS IS" basis and Intel is not obligated to provide
 * any support, assistance, installation, training, or other services
 * of any kind. Intel is also not obligated to provide any updates,
 * enhancements or extensions. Intel specifically disclaims any warranty
 * of merchantability, non-infringement, fitness for any particular
 * purpose, and any other warranty.
 *
 * Further, Intel disclaims all liability of any kind, including but
 * not limited to liability for infringement of any proprietary rights,
 * relating to the use of the code, even if Intel is notified of the
 * possibility of such liability. Except as expressly stated in an Intel
 * license agreement provided with this code and agreed upon with Intel,
 * no license, express or implied, by estoppel or otherwise, to any
 * intellectual property rights is granted herein.
 */
/**
 Description:
    Define APIs of MYO for compiler or pre-processor to transfer original programs.
 */

#ifndef _MYO_IMPL_H_
#define _MYO_IMPL_H_

/** @ingroup MYO
 *  @addtogroup MYOIMPL_API
@{
* @file myoimpl.h 
*/

#ifdef __cplusplus
extern "C" {
#define EXTERN_C extern "C"
#else
#define EXTERN_C /* nothing */
#endif

#       define MYOACCESSAPI /* nothing */

#ifdef DEFINE_ARENA_API_CILK_SHARED
#define CILK_SHARED _Cilk_shared
#else
#define CILK_SHARED /* nothing */
#endif

/* **************************************************************************** *\
    APIs to enable functions being remotely called
\* **************************************************************************** */

typedef void *(*MyoiRemoteFuncType)(void *);

/** @fn extern MyoError myoiRemoteFuncRegister(MyoiRemoteFuncType in_pFuncAddr,
 * const char *in_pFuncName)
 * @brief Register a function so that it can be remotely called. This should be
 * done in myoiUserInit or before calling myoiLibInit. After myoiLibInit,
 * there will be a table on all peers, which contains the information for
 * all remotely callable functions.
 *
 * @param in_pWrapFuncAddr address of the wrapper function.
 * @param in_pFuncName name of the function.
 * @return
 *      MYO_SUCCESS; or
 *      an error number to indicate the error.
 **/

MYOACCESSAPI
MyoError myoiRemoteFuncRegister(MyoiRemoteFuncType in_pFuncAddr,
        const char *in_pFuncName);
/** @fn extern MyoError myoiRemoteFuncLookupByName(char *in_pFuncName, 
 * MyoiRemoteFuncType *out_pWrapFuncAddr)
 * @brief Get the address of the wrapper function by looking up the table
 * by name. This API can be used when assigning a function pointer to
 * remotely callable functions.
 *
 * @param in_pFuncName name of the function.
 * @param out_pWrapFuncAddr address of the wrapper function.
 * @return
 *      MYO_SUCCESS; or
 *      an error number to indicate the error.
 **/
MYOACCESSAPI MyoError myoiRemoteFuncLookupByName(char *in_pFuncName,
        MyoiRemoteFuncType *out_pWrapFuncAddr);

/** @fn extern MyoError myoiRemoteFuncLookupByAddr(MyoiRemoteFuncType 
 * in_pWrapFuncAddr,char **out_pFuncName)
 * @brief Get the name of a remote function by looking up the table by
 * the address. This API can be used when calling a remotely callable 
 * function by a function pointer.
 *
 * @param in_pWrapFuncAddr address of the function.
 * @param out_pFuncName name of the function.
 * @return
 *      MYO_SUCCESS; or
 *      an error number to indicate the error.
 **/
MYOACCESSAPI MyoError myoiRemoteFuncLookupByAddr(MyoiRemoteFuncType in_pWrapFuncAddr,
        char **out_pFuncName);

//! Host Side Shared Function Pointer Entry Struct
typedef struct {
    //! Function Name
    const char *funcName;
    //! Function Address
    void *funcAddr;
    //! Local Thunk Address
    void *localThunkAddr;
} MyoiHostSharedFptrEntry;

//! Target Side Shared Function Pointer Entry Struct
typedef struct {
    //! Function Name
    const char *funcName;
    //! Function Address
    void *funcAddr;
    //! Wrap Function Address
    void *wrapFuncAddr;
    //! Locak Thunk Address
    void *localThunkAddr;
} MyoiTargetSharedFptrEntry;

/**
 * @cond INCLUDE_MYO_INTERNAL_DOCUMENTATION
 * @fn extern MyoError myoiHostFptrTableRegister(void *in_pAddrOfFptrTable, 
 * int in_NumEntry, int in_Ordered)
 * @brief Register shared functions on host side. A 16 byte thunk will be 
 * allocated for each function entry in non-coherent shared memory. The 
 * thunk will contain a jump instruction to the local version of the 
 * shared function, which is provided by the second item of the function 
 * entry. Also, the address of the thunk will be stored to the 3rd item 
 * of the function entry for Compiler usage.
 *
 * @param in_pAddrOfFptrTable start address of the shared function 
 * table, assuming it follows the format of MyoiHostSharedFptrEntry.
 * @param in_NumEntry number of entry in the table.
 * @param in_Ordered whether the table is ordered by function name.
 * @return
 *      MYO_SUCCESS; or
 *      an error number to indicate the error.
 **/
MYOACCESSAPI
MyoError myoiHostFptrTableRegister(
        void *in_pAddrOfFptrTable, int in_NumEntry, int in_Ordered);

/** @fn extern MyoError myoiTargetFptrTableRegister(void *in_pAddrOfFptrTable,
 * int in_NumEntry, int in_Ordered)
 * @brief Register shared functions on target side. This function is the 
 * same as myoiHostFptrTableRegister, except it does not need to allocate 
 * thunks from non-coherent shared memory for each function entry, but 
 * instead looks up this information from a table retrieved from the 
 * Host side.
 *
 * @param in_pAddrOfFptrTable start address of the shared function 
 * table, assuming it follows the format of MyoiTargetSharedFptrEntry.
 * @param in_NumEntry number of entry in the table.
 * @param in_Ordered whether the table is ordered by function name.
 * @return
 *      MYO_SUCCESS; or
 *      an error number to indicate the error.
 **/
extern MyoError myoiTargetFptrTableRegister(
        void *in_pAddrOfFptrTable, int in_NumEntry, int in_Ordered);
/**
 * @endcond
 **/

/* *************************************************************************** *\
    APIs for remote function calls
\* *************************************************************************** */

typedef void * MyoiRFuncCallHandle;

/** @fn extern MyoiRFuncCallHandle myoiRemoteCall(char *in_pFuncName, 
 * void *in_pArgs, int in_deviceNum)
 * @brief Call a remote callable function. If there are multiple arguments 
 * for the function, pack them to a shared buffer beforehand and take the
 * address of the shared buffer as this function. After receiving the call 
 * requests from other peers, the arguments should be unpacked from the 
 * shared buffer before calling the target function. The shared buffer 
 * can also be used to store the return value of the function.
 *
 * @param in_pFuncName name of the function.
 * @param in_pArgs address of the shared buffer.
 * @return
 *      Handle used to check the result.
 **/
MYOACCESSAPI
MyoiRFuncCallHandle myoiRemoteCall(const char *in_pFuncName, void *in_pArgs, int in_deviceNum);

/**
 * @cond INCLUDE_MYO_INTERNAL_DOCUMENTATION
 * @fn extern MyoError myoiRemoteThunkCall(void *in_funcThunkAddr, void *in_pArgs, int in_deviceNum)
 * @brief Call a remote callable function. If there are multiple arguments for 
 * the function, pack them to a shared buffer beforehand and take the address
 * of the shared buffer as this function. After receiving the call requests
 * from other peers, the arguments should be unpacked from the shared buffer
 * before calling the target function. The shared buffer can also be used to 
 * store the return value of the function.
 *
 * @param in_funcThunkAddr pointer to function thunk in the non-coherent
 * shared memory.
 * @param in_pArgs address of the shared buffer.
 * @PARAM in_deviceNum: device ID (0-N-1) for the MIC device to run 
 * function call.  -1 request causes MYO to schedule an available device.  
 * For RPC from device to host, in_deviceNum should always be -1.
 * @return
 *      MYO_SUCCESS; or
 *      an error number to indicate the error.
 **/
MYOACCESSAPI
MyoError myoiRemoteThunkCall(void *in_funcThunkAddr, void *in_pArgs, int in_deviceNum);
/**
 * @endcond
 **/

/** @fn extern MyoError myoiCheckResult(MyoiRFuncCallHandle in_Handle)
 * @brief Check whether the remote call is done.
 *
 * @param in_Handle handle of the remote call.
 * @return
 *      MYO_SUCCESS (done); or
 *      an error number to indicate the error.
 **/
extern MyoError myoiCheckResult(MyoiRFuncCallHandle in_Handle);

/** @fn extern MyoError myoiGetResult(MyoiRFuncCallHandle in_Handle)
 * @brief Wait till the remote call is done.
 *
 * @param in_Handle handle of the remote call.
 * @return
 *      MYO_SUCCESS; or
 *      an error number to indicate the error.
 **/
MYOACCESSAPI
MyoError myoiGetResult(MyoiRFuncCallHandle in_Handle);

/* **************************************************************************** *\
    APIs related with shared variables.
\* **************************************************************************** */

/* 
 * It is Compiler's responsibility to make sure all shared variables
 * located in shared memory space and have the same address in all sides.
 * However, it is hard for Compiler to do this. So we propose a solution
 * which is changing the definition of all shared variables and accessing
 * them indirectly, and making sure all shared variables pointing
 * to the same shared space on all sides. For example,
 *
 * "shared int a;" is changed to "shared int *a";
 * Also all the accesses to "a" is change to "*a".
 *
 * We suppose the shared memory for each shared variable is allocated on
 * host side by Compiler. For the upper example, Compiler can call:
 *
 * a = (shared int *) myoSharedMalloc(sizeof(shared int));
 *
 * Now the issue is how to make "a" on other sides also pointing to the
 * same shared memory on other sides. We provide two methods to do this.
 * They can be used in a hybrid way.
 */

/* 
 * The first method is calling myoiVarRegister for each shared variable
 * on all sides in myoiUserInit. On host side, we will get a table containing
 * a table containing the shared address and name of each shared variable.
 * After calling myoiUserInit, we will propagate the table to other sides.
 * On card side, after getting the table from host, myoiUserInit is called.
 * When calling myoiVarRegister in myoiUserInit, we will make local pointer
 * of each shared variable pointing to the same shared memory with the local
 * pointer on host side of the same shared variable pointing to.
 */

/* 
 * The second method suppose that Compiler already have a table on all sides.
 * On host side, the table contains the name and the shared address of each
 * shared variable. On card side, the table contains the name of each shared
 * variable and the address of the local pointer which will pointing to shared
 * memory space.
 *
 * On host side, Compiler generates a call to myoiHostVarTablePropagate
 * after initializing MYO runtime and making the host side table ready.
 * On card side, Compiler uses myoiMicVarTableRegister to tell
 * the runtime where the card side table is.
 *
 * Since there may be multiple libraries on card side for the same application,
 * myoiHostVarTablePropagate and myoiMicVarTableRegister can be called multiple
 * times and called simultaneously.
 *
 * Inside runtime, the local pointer of the same shared variable on all sides
 * will be make sure pointing to the same shared space by using the information
 * of the Compiler provided tables.
 */

/* 
 * Comipler knows the following two structures to make sure the var table
 * has the following format.
 */

/* 
 * This is structure of the Shared var table entry. This table contains 
 * the shared address and name of each shared variable
 */

/** @fn extern MyoError myoiVarRegister(void *in_pAddrOfLocalPtrToShared, char *in_pSVarName)
 * @brief Register shared variables. Call it on all sides in myoiUserInit. 
 * On host side, make sure calling it after allocating shared memory for 
 * the shared variables by calling myoSharedMalloc.
 *
 * @param in_pAddrOfLocalPtrToShared the address assigned by the compiler 
 * for the shared variable, which is the address of a local pointer, 
 * pointing to shared memory space.
 * @param in_pSVarName name of shared variable.
 * @return
 *      MYO_SUCCESS; or
 *      an error number to indicate the error.
 **/
MYOACCESSAPI
MyoError myoiVarRegister(
        void *in_pAddrOfLocalPtrToShared, const char *in_pSVarName);

/*
 * Compiler knows the following two structures to make sure the var table
 * has the following format.
 */

/**
 * This is structure of the Shared var table entry. This table contains 
 * the shared address and name of each shared variable
 **/
typedef struct {
    //! Variable Name
    const char *varName;
    //! Shared Address
    void *sharedAddr;
} MyoiSharedVarEntry;

//! Structure of the var table entry on host
typedef struct {
    //! Variable Name
    const char *varName;
    //! Variable Size
    int size;
    //! Local pointer to Shared var
    void *ptrToLocalPtrToShared;
} MyoiHostSharedVarEntry;

//! Structure of the var table entry on card 
typedef struct {
    //! Variable Name
    const char *varName;
    //! Local pointer to Shared var
    void *ptrToLocalPtrToShared;
} MyoiMicSharedVarEntry;

/** @fn extern MyoError myoiHostVarTablePropagate(void *in_pAddrOfSVarTable, int in_NumEntry)
 * @brief Send the host side var table to the card side. Card side will also 
 * have a copy of the host side var table after this propagation, although it 
 * is in an internal format different than the original host side var table, 
 * due to implementation convenience.
 *
 * @param in_pAddrOfSVarTable start address of the host side var table,
 * assuming it follows the format of MyoiSharedVarEntry.
 * @param in_NumEntry number of entry in the table.
 * @return
 *      MYO_SUCCESS; or
 *      an error number to indicate the error.
 **/
MYOACCESSAPI MyoError myoiHostVarTablePropagate(
        void *in_pAddrOfSVarTable, int in_NumEntry);

/**
 * @cond INCLUDE_MYO_INTERNAL_DOCUMENTATION
 * @fn extern MyoError myoiMicVarTableRegister(void *in_pAddrOfSVarTable, int in_NumEntry)
 * @brief Tell the runtime where the card side table is.
 *
 * @param in_pAddrOfSVarTable start address of the card side var
 * table, assuming it follows the format of MyoiMicSharedVarEntry.
 * @param in_NumEntry number of entry in the table.
 * @return
 *      MYO_SUCCESS; or
 *      an error number to indicate the error.
 **/
extern MyoError myoiMicVarTableRegister(
        void *in_pAddrOfSVarTable, int in_NumEntry);
/**
 * @endcond
 **/

/** @fn MyoError myoiHostSharedMallocTableRegister(void *in_pAddrOfSVarTable, int in_NumEntry, int in_Ordered)
 * @brief Allocate shared memory for all shared variables in the table. 
 * Also update local address of the shared variable with new shared address.
 *
 * @param in_pAddrOfSVarTable start address of the shared variable table,
 * assuming it follows the format of MyoiHostSharedVarEntry.
 * @param in_NumEntry number of entry in the table.
 * @param in_Ordered whether the table ordered by name.
 * @return
 *      MYO_SUCCESS; or
 *      an error number to indicate the error.
 **/
MYOACCESSAPI
MyoError myoiHostSharedMallocTableRegister(
        void *in_pAddrOfSVarTable, int in_NumEntry, int in_Ordered);

/** @fn extern MyoError myoiTargetSharedMallocTableRegister(void *in_pAddrOfSVarTable, int in_NumEntry, int in_Ordered)
 * @brief Register the shared variables on the target side.
 *
 * @param in_pAddrOfSVarTable start address of the shared varaible table,
 * assuming it follows the format of MyoiMicSharedVarEntry.
 * @param in_NumEntry number of entry in the table.
 * @param in_Ordered whether the table ordered by name.
 * @return
 *      MYO_SUCCESS; or
 *      an error number to indicate the error.
 **/
extern MyoError myoiTargetSharedMallocTableRegister(
        void *in_pAddrOfSVarTable, int in_NumEntry, int in_Ordered);

/** @fn MyoError myoiLibInit(void * in_args, void (*userInitFunc))
 * @brief Init entry of the MYO library responsible for initializing 
 * the runtime.
 *
 * @param in_args mechanism to pass arguments to the Initialization 
 * routine. The default value of NULL would mean the host is blocked 
 * on the completion of myoiLibInit() on all nodes. A subset of the 
 * installed cards can be intialized by passing an array of 
 * MyoiUserParams. For example, in a system with two cards, to run a
 * MYO application only on the second card, intialize the array as 
 * follows:
 *      @code 
 *      MyoiUserParams UserParas[64];
 *      UserParas[0].type = MYOI_USERPARAMS_DEVID; 
 *      UserParas[0].nodeid = 2;
 *      UserParas[1].type = MYOI_USERPARAMS_LAST_MSG;
 *      if(MYO_SUCCESS != myoiLibInit(&UserParas, (void*)&myoiUserInit)) {
 *          printf("Failed to initialize MYO runtime\n");
 *          return -1;
 *      }
 *      @endcode
 * This intialization is required only in the client/host side
 * of the application. The server/card side executable should be
 * executed only on the second card in this case.
 *
 * Another capability for the MyoiUserParams structure in MYO is specifying
 * a remote procedure call to be executed on the host or card, immediately after
 * myoiLibInit() completes. This capability is useful because some calls in
 * MYO return immediately, but do not actually complete until after the MYO
 * library is completely initialized on all peers.  An example follows,
 * showing how to cause MYO to execute the registered function named
 * "PostMyoLibInitFunction" on the first card only:
 *      @code
 *      MyoiUserParams UserParas[64];
 *      UserParas[0].type = MYOI_USERPARAMS_POST_MYO_LIB_INIT_FUNC;
 *      UserParas[0].nodeid = 1;
 *      SetPostLibInitFuncName(UserParas[1], "PostMyoLibInitFunction");
 *      UserParas[2].type = MYOI_USERPARAMS_LAST_MSG;
 *      if(MYO_SUCCESS != myoiLibInit(&UserParas, (void*)&myoiUserInit)) {
 *          printf("Failed to initialize MYO runtime\n");
 *          return -1;
 *      }
 *      @endcode
 *
 * Note, to cause PostMyoLibInitFunction to be executed on ALL cards,
 * specify: MYOI_USERPARAMS_POST_MYO_LIB_INIT_FUNC_ALL_NODES for the nodeid.
 * That is:
 *      @code
 *      UserParas[0].nodeid = MYOI_USERPARAMS_POST_MYO_LIB_INIT_FUNC_ALL_NODES;
 *      @endcode
 *
 * @param userInitFunc Shared variables and remote functions are
 * registered in this routine, which is called by the runtime during
 * library initialization. 
 * @return
 *      MYO_SUCCESS;
 *      MYO_ERROR;
 **/
MYOACCESSAPI
MyoError myoiLibInit(void * in_args, void *userInitFunc /*userInitFunc must be: MyoError (*userInitFunc)(void) */);

/** @fn extern MyoError myoiSupportsFeature(MyoFeatureType myoFeature)
 * @brief Supports runtime query to determine whether a feature is supported
 * by the myo that is installed on the system. This function is intended to
 * support client code to query the myo library to determine whether its set
 * of capabilities are able to support the client's needs.
 *
 * @param myoFeature The feature that is to be inquired about.
 * @return
 *      MYO_SUCCESS; if the feature is supported.
 *      MYO_FEATURE_NOT_IMPLEMENTED if the feature is not supported.
 *
 * (For more information, please also see the declaration of the MyoFeatureType enum declaration.)
 **/
MYOACCESSAPI
MyoError myoiSupportsFeature(MyoFeatureType myoFeature);

/** @fn void myoiLibFini()
 * @brief Finalize the MYO library, all resources held by the runtime are 
 * released by this routine.
 *
 * @return
 **/
MYOACCESSAPI
void myoiLibFini();

/* *************************************************************************** *\
    APIs to set shared memory space consistent/non-consistent.
\* *************************************************************************** */

/** @fn extern MyoError myoiSetMemNonConsistent(void *in_pAddr, size_t in_Size)
 * @brief Set part of the shared memory space to be non-consistent, which
 * means that the consistency of this part of shared memory space does not 
 * need to be maintained between HOST and cards.
 *
 * @param in_pAddr The start address of the specified shared memory space;
 * @param in_Size The size of the specified shared memory space;
 * @return
 *      MYO_SUCCESS; or
 *      an error number to indicate the error.
 **/
MYOACCESSAPI
MyoError myoiSetMemNonConsistent(void *in_pAddr, size_t in_Size);

/** @fn extern MyoError myoiSetMemConsistent(void *in_pAddr, size_t in_Size)
 * @brief Set part of the shared memory space to be consistent, which 
 * means that the consistency of this part of shared memory space needs 
 * to be maintained between HOST and cards.
 *
 * @param in_pAddr The start address of the specified shared 
 * memory space.
 * @param in_size The size of the specified shared memory space.
 * @return
 *      MYO_SUCCESS; or
 *      an error number to indicate the error.
 **/
MYOACCESSAPI
MyoError myoiSetMemConsistent(void *in_pAddr, size_t in_Size);

/* A collection of external data symbols */
EXTERN_C MYOACCESSAPI unsigned int myoiMyId; /* MYO_MYID if on accelerators */
EXTERN_C MYOACCESSAPI volatile int myoiInitFlag;

 //! Structure of the array element that is passed to myoiLibInit() to initialize a subset of the available cards, or
 //! to specify a remote call function to be called after successful myo library initialization:
typedef struct {
    //!type = MYOI_USERPARAMS_DEVID or  MYOI_USERPARAMS_POST_MYO_LIB_INIT_FUNC for each element in the array except
    //!the last element, type should be: MYOI_USERPARAMS_LAST_MSG.
    int type;
    //! nodeid refers to the 'one-based' card index.  Specifying, 1 represents the first card, mic0, 2 represents the
    // second card, mic1, 3 represents the third card, mic2, ....).
    // NOTE: for type == MYOI_USERPARAMS_POST_MYO_LIB_INIT_FUNC, specifying MYOI_USERPARAMS_POST_MYO_LIB_INIT_FUNC_ALL_NODES
    // for nodeid, will execute the named function, on each card in the system, mic0, mic1, mic2, .... micn.
    int nodeid;
} MyoiUserParams;

//!The following two types are dealt with entirely with just one MyoiUserParams structure:
//!MYOI_USERPARAMS_DEVID maps node ids.
#define MYOI_USERPARAMS_DEVID                             1
//!MYOI_USERPARAMS_LAST_MSG terminates the array of MyoiUserParams.
#define MYOI_USERPARAMS_LAST_MSG                         -1

//!The following type requires setting the node id in a MyoiUserParams structure, and then following the struct
//!with a MyoiUserParamsPostLibInit union:
#define MYOI_USERPARAMS_POST_MYO_LIB_INIT_FUNC            2
//!nodeid can be one of the following macros, or a number >=1, corresponding to the card number (1 == mic0,
//!2 == mic1, 3 == mic2, ....)
//!Setting nodeid to MYOI_USERPARAMS_POST_MYO_LIB_INIT_FUNC_ALL_NODES causes the function to be called on all
//!cards:
#define MYOI_USERPARAMS_POST_MYO_LIB_INIT_FUNC_ALL_NODES  0
//!Setting nodeid to MYOI_USERPARAMS_POST_MYO_LIB_INIT_FUNC_HOST_NODE causes the function to be called on the
//!host instead of the card:
#define MYOI_USERPARAMS_POST_MYO_LIB_INIT_FUNC_HOST_NODE -1

//!The postLibInit union contains two members that serves two different purposes:
//!1. It can be used to stipulate the name of the function to be remotely called from host to card, on successful
//!myo library initialization, (member postLibInitRemoveFuncName) using the type:
//!MYOI_USERPARAMS_POST_MYO_LIB_INIT_FUNC.   OR
//!2. It can be an actual function pointer (member name: postLibInitHostFuncAddress) that will be called on the host,
//!on successful myo library initialization, using the type: MYOI_USERPARAMS_POST_MYO_LIB_INIT_FUNC, with nodeid:
//!MYOI_USERPARAMS_POST_MYO_LIB_INIT_FUNC_HOST_NODE
typedef union {
   const char *postLibInitRemoveFuncName;
   void (*postLibInitHostFuncAddress)(void);
} MyoiUserParamsPostLibInit;

/* These are two macros to help get the information in a MyoiUserParamsPostLibInit union from a MyoiUserParams struct; */
#define GetPostLibInitFuncName(USERPARAMS) ((MyoiUserParamsPostLibInit *) (& (USERPARAMS)))->postLibInitRemoveFuncName
#define GetPostLibInitFuncAddr(USERPARAMS) ((MyoiUserParamsPostLibInit *) (& (USERPARAMS)))->postLibInitHostFuncAddress

/* These are two macros to help set the information in a MyoiUserParamsPostLibInit union from a MyoiUserParams struct; */
#define SetPostLibInitFuncName(USERPARAMS,FUNC_NAME) GetPostLibInitFuncName(USERPARAMS) = FUNC_NAME
#define SetPostLibInitFuncAddr(USERPARAMS,FUNC_ADDR) GetPostLibInitFuncAddr(USERPARAMS) = FUNC_ADDR

#ifdef __cplusplus
}
#endif
#endif // _MYO_IMPL_H_
/*! @} */