/*@ MPI_T_category_get_info - Get the information about a category Input/Output Parameters: + name_len - length of the string and/or buffer for name (integer) - desc_len - length of the string and/or buffer for desc (integer) Input Parameters: . cat_index - index of the category to be queried (integer) Output Parameters: + name - buffer to return the string containing the name of the category (string) . desc - buffer to return the string containing the description of the category (string) . num_cvars - number of control variables contained in the category (integer) . num_pvars - number of performance variables contained in the category (integer) - num_categories - number of categories contained in the category (integer) .N ThreadSafe .N Errors .N MPI_SUCCESS .N MPI_T_ERR_NOT_INITIALIZED .N MPI_T_ERR_INVALID_INDEX @*/ int MPI_T_category_get_info(int cat_index, char *name, int *name_len, char *desc, int *desc_len, int *num_cvars, int *num_pvars, int *num_categories) { int mpi_errno = MPI_SUCCESS; cat_table_entry_t *cat; MPID_MPI_STATE_DECL(MPID_STATE_MPI_T_CATEGORY_GET_INFO); MPIR_ERRTEST_MPIT_INITIALIZED(mpi_errno); MPIR_T_THREAD_CS_ENTER(); MPID_MPI_FUNC_ENTER(MPID_STATE_MPI_T_CATEGORY_GET_INFO); /* Validate parameters */ # ifdef HAVE_ERROR_CHECKING { MPID_BEGIN_ERROR_CHECKS { MPIR_ERRTEST_CAT_INDEX(cat_index, mpi_errno); /* Do not do _TEST_ARGNULL for other arguments, since this is * allowed or will be allowed by MPI_T standard. */ } MPID_END_ERROR_CHECKS } # endif /* HAVE_ERROR_CHECKING */ /* ... body of routine ... */ cat = (cat_table_entry_t *)utarray_eltptr(cat_table, cat_index); MPIR_T_strncpy(name, cat->name, name_len); MPIR_T_strncpy(desc, cat->desc, desc_len); if (num_cvars != NULL) *num_cvars = utarray_len(cat->cvar_indices); if (num_pvars != NULL) *num_pvars = utarray_len(cat->pvar_indices); if (num_categories != NULL) *num_categories = utarray_len(cat->subcat_indices); /* ... end of body of routine ... */ fn_exit: MPID_MPI_FUNC_EXIT(MPID_STATE_MPI_T_CATEGORY_GET_INFO); MPIR_T_THREAD_CS_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, "**mpi_t_category_get_info", "**mpi_t_category_get_info %d %p %p %p %p %p %p %p", cat_index, name, name_len, desc, desc_len, num_cvars, num_pvars, num_categories); } # endif mpi_errno = MPIR_Err_return_comm(NULL, FCNAME, mpi_errno); goto fn_exit; /* --END ERROR HANDLING-- */ }
/*@ MPI_T_enum_get_item - Get the information about an item in an enumeration Input/Output Parameters: . name_len - length of the string and/or buffer for name (integer) Input Parameters: . enumtype - enumeration to be queried (handle) Output Parameters: + index - number of the value to be queried in this enumeration (integer) . value - variable value (integer) - name - buffer to return the string containing the name of the enumeration item (string) .N ThreadSafe .N Errors .N MPI_SUCCESS .N MPI_T_ERR_NOT_INITIALIZED .N MPI_T_ERR_INVALID_HANDLE .N MPI_T_ERR_INVALID_ITEM @*/ int MPI_T_enum_get_item(MPI_T_enum enumtype, int index, int *value, char *name, int *name_len) { int mpi_errno = MPI_SUCCESS; enum_item_t *item; MPIR_FUNC_TERSE_STATE_DECL(MPID_STATE_MPI_T_ENUM_GET_ITEM); MPIR_ERRTEST_MPIT_INITIALIZED(mpi_errno); MPIR_T_THREAD_CS_ENTER(); MPIR_FUNC_TERSE_ENTER(MPID_STATE_MPI_T_ENUM_GET_ITEM); /* Validate parameters */ #ifdef HAVE_ERROR_CHECKING { MPID_BEGIN_ERROR_CHECKS; { MPIR_ERRTEST_ENUM_HANDLE(enumtype, mpi_errno); MPIR_ERRTEST_ENUM_ITEM(enumtype, index, mpi_errno); MPIR_ERRTEST_ARGNULL(value, "value", mpi_errno); /* Do not do TEST_ARGNULL for name or name_len, since this is * permitted per MPI_T standard. */ } MPID_END_ERROR_CHECKS; } #endif /* HAVE_ERROR_CHECKING */ /* ... body of routine ... */ item = (enum_item_t *) utarray_eltptr(enumtype->items, index); *value = item->value; MPIR_T_strncpy(name, item->name, name_len); /* ... end of body of routine ... */ #ifdef HAVE_ERROR_CHECKING fn_exit: #endif MPIR_FUNC_TERSE_EXIT(MPID_STATE_MPI_T_ENUM_GET_ITEM); MPIR_T_THREAD_CS_EXIT(); return mpi_errno; #ifdef HAVE_ERROR_CHECKING fn_fail: /* --BEGIN ERROR HANDLING-- */ { mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_RECOVERABLE, __func__, __LINE__, MPI_ERR_OTHER, "**mpi_t_enum_get_item", "**mpi_t_enum_get_item %p %d %p %p %p", enumtype, index, value, name, name_len); } mpi_errno = MPIR_Err_return_comm(NULL, __func__, mpi_errno); goto fn_exit; /* --END ERROR HANDLING-- */ #endif }
/*@ MPI_T_enum_get_info - Get the information about an enumeration Input/Output Parameters: . name_len - length of the string and/or buffer for name (integer) Input Parameters: . enumtype - enumeration to be queried (handle) Output Parameters: + num - number of discrete values represented by this enumeration (integer) - name - buffer to return the string containing the name of the enumeration (string) .N ThreadSafe .N Errors .N MPI_SUCCESS .N MPI_T_ERR_NOT_INITIALIZED .N MPI_T_ERR_INVALID_HANDLE @*/ int MPI_T_enum_get_info(MPI_T_enum enumtype, int *num, char *name, int *name_len) { int mpi_errno = MPI_SUCCESS; MPID_MPI_STATE_DECL(MPID_STATE_MPI_T_ENUM_GET_INFO); MPIR_ERRTEST_MPIT_INITIALIZED(mpi_errno); MPIR_T_THREAD_CS_ENTER(); MPID_MPI_FUNC_ENTER(MPID_STATE_MPI_T_ENUM_GET_INFO); /* Validate parameters */ # ifdef HAVE_ERROR_CHECKING { MPID_BEGIN_ERROR_CHECKS { MPIR_ERRTEST_ENUM_HANDLE(enumtype, mpi_errno); MPIR_ERRTEST_ARGNULL(num, "num", mpi_errno); /* Do not do _TEST_ARGNULL for name or name_len, since this is * permitted per MPI_T standard. */ } MPID_END_ERROR_CHECKS } # endif /* HAVE_ERROR_CHECKING */ /* ... body of routine ... */ *num = utarray_len(enumtype->items); MPIR_T_strncpy(name, enumtype->name, name_len); /* ... end of body of routine ... */ fn_exit: MPID_MPI_FUNC_EXIT(MPID_STATE_MPI_T_ENUM_GET_INFO); MPIR_T_THREAD_CS_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, "**mpi_t_enum_get_info", "**mpi_t_enum_get_info %p %p %p %p", enumtype, num, name, name_len); } # endif mpi_errno = MPIR_Err_return_comm(NULL, FCNAME, mpi_errno); goto fn_exit; /* --END ERROR HANDLING-- */ }
/*@ MPI_T_pvar_get_info - Get the inforamtion about a performance variable Input/Output Parameters: + name_len - length of the string and/or buffer for name (integer) - desc_len - length of the string and/or buffer for desc (integer) Input Parameters: . pvar_index - index of the performance variable to be queried between 0 and num_pvar-1 (integer) Output Parameters: + name - buffer to return the string containing the name of the performance variable (string) . verbosity - verbosity level of this variable (integer) . var_class - class of performance variable (integer) . datatype - MPI type of the information stored in the performance variable (handle) . enumtype - optional descriptor for enumeration information (handle) . desc - buffer to return the string containing a description of the performance variable (string) . binding - type of MPI object to which this variable must be bound (integer) . readonly - flag indicating whether the variable can be written/reset (integer) . continuous - flag indicating whether the variable can be started and stopped or is continuously active (integer) - atomic - flag indicating whether the variable can be atomically read and reset (integer) .N ThreadSafe .N Errors .N MPI_SUCCESS .N MPI_T_ERR_NOT_INITIALIZED .N MPI_T_ERR_INVALID_INDEX @*/ int MPI_T_pvar_get_info(int pvar_index, char *name, int *name_len, int *verbosity, int *var_class, MPI_Datatype *datatype, MPI_T_enum *enumtype, char *desc, int *desc_len, int *binding, int *readonly, int *continuous, int *atomic) { int mpi_errno = MPI_SUCCESS; const pvar_table_entry_t *entry; const pvar_table_entry_t *info; MPID_MPI_STATE_DECL(MPID_STATE_MPI_T_PVAR_GET_INFO); MPIR_ERRTEST_MPIT_INITIALIZED(mpi_errno); MPIR_T_THREAD_CS_ENTER(); MPID_MPI_FUNC_ENTER(MPID_STATE_MPI_T_PVAR_GET_INFO); /* Validate parameters */ # ifdef HAVE_ERROR_CHECKING { MPID_BEGIN_ERROR_CHECKS { MPIR_ERRTEST_PVAR_INDEX(pvar_index, mpi_errno); /* Do not do _TEST_ARGNULL for other arguments, since this is * allowed or will be allowed by MPI_T standard. */ } MPID_END_ERROR_CHECKS } # endif /* HAVE_ERROR_CHECKING */ /* ... body of routine ... */ entry = (pvar_table_entry_t *) utarray_eltptr(pvar_table, pvar_index); if (!entry->active) { mpi_errno = MPI_T_ERR_INVALID_INDEX; goto fn_fail; } info = (pvar_table_entry_t *) utarray_eltptr(pvar_table, pvar_index); MPIR_T_strncpy(name, info->name, name_len); MPIR_T_strncpy(desc, info->desc, desc_len); if (verbosity != NULL) *verbosity = info->verbosity; if (var_class != NULL) *var_class = info->varclass; if (datatype != NULL) *datatype = info->datatype; if (enumtype != NULL) *enumtype = info->enumtype; if (binding != NULL) *binding = info->bind; if (readonly != NULL) *readonly = info->flags & MPIR_T_PVAR_FLAG_READONLY; if (continuous != NULL) *continuous = info->flags & MPIR_T_PVAR_FLAG_CONTINUOUS; if (atomic != NULL) *atomic = info->flags & MPIR_T_PVAR_FLAG_ATOMIC; /* ... end of body of routine ... */ fn_exit: MPID_MPI_FUNC_EXIT(MPID_STATE_MPI_T_PVAR_GET_INFO); MPIR_T_THREAD_CS_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, "**mpi_t_pvar_get_info", "**mpi_t_pvar_get_info %d %p %p %p %p %p %p %p %p %p %p %p %p", pvar_index, name, name_len, verbosity, var_class, datatype, enumtype, desc, desc_len, binding, readonly, continuous, atomic); } # endif mpi_errno = MPIR_Err_return_comm(NULL, FCNAME, mpi_errno); goto fn_exit; /* --END ERROR HANDLING-- */ }