mpidi_kvs.c

mpi并行计算的c++代码 可用vc或gcc编译通过 可以用来搭建并行计算试验环境

	    /* --BEGIN ERROR HANDLING-- */
	    if (pElement == NULL)
	    {
		mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**nomem", "**nomem %s", "MPIDI_KVS_database_element_t");
		MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_KVS_PUT);
		return mpi_errno;
	    }
	    /* --END ERROR HANDLING-- */
	    pElement->pNext = pNode->pData;
	    MPIU_Strncpy(pElement->pszKey, key, MPIDI_MAX_KVS_KEY_LEN);
	    MPIU_Strncpy(pElement->pszValue, value, MPIDI_MAX_KVS_VALUE_LEN);
	    pNode->pData = pElement;
	    MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_KVS_PUT);
	    return MPI_SUCCESS;
	}
	pNode = pNode->pNext;
    }

    pmi_errno = PMI_KVS_Put(name, key, value);
    if (pmi_errno != PMI_SUCCESS)
    {
	/* --BEGIN ERROR HANDLING-- */
	mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**pmi_kvs_put",
					 "**pmi_kvs_put %s %s %s %d", name, key, value, pmi_errno);
	/* --END ERROR HANDLING-- */
    }
    /*mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);*/
    MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_KVS_PUT);
    return mpi_errno;
}

/* FIXME: No one uses this routine */
#if 0
#undef FUNCNAME
#define FUNCNAME MPIDI_KVS_Delete
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
int MPIDI_KVS_Delete(const char *name, const char *key)
{
    int mpi_errno = MPI_SUCCESS;
    MPIDI_KVS_database_node_t *pNode;
    MPIDI_KVS_database_element_t *pElement, *pElementTrailer;
    MPIDI_STATE_DECL(MPID_STATE_MPIDI_KVS_DELETE);

    MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_KVS_DELETE);

    pNode = kvs.pDatabase;
    while (pNode)
    {
	if (strcmp(pNode->pszName, name) == 0)
	{
	    pElementTrailer = pElement = pNode->pData;
	    while (pElement)
	    {
		if (strcmp(pElement->pszKey, key) == 0)
		{
		    if (pElementTrailer != pElement)
		    {
			pElementTrailer->pNext = pElement->pNext;
		    }
		    else
		    {
			pNode->pData = pElement->pNext;
		    }
		    MPIU_Free(pElement);
		    MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_KVS_DELETE);
		    return MPI_SUCCESS;
		}
		pElementTrailer = pElement;
		pElement = pElement->pNext;
	    }
	    /* --BEGIN ERROR HANDLING-- */
	    mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);
	    MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_KVS_DELETE);
	    return mpi_errno;
	    /* --END ERROR HANDLING-- */
	}
	pNode = pNode->pNext;
    }

    /* --BEGIN ERROR HANDLING-- */
    mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);
    MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_KVS_DELETE);
    return mpi_errno;
    /* --END ERROR HANDLING-- */
}
#endif

/* FIXME: This routine is unused (should be used during finalize) */
#undef FUNCNAME
#define FUNCNAME MPIDI_KVS_Destroy
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
int MPIDI_KVS_Destroy(const char *name)
{
    int mpi_errno = MPI_SUCCESS, pmi_errno;
    MPIDI_KVS_database_node_t *pNode, *pNodeTrailer;
    MPIDI_KVS_database_element_t *pElement;
    MPIDI_STATE_DECL(MPID_STATE_MPIDI_KVS_DESTROY);

    MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_KVS_DESTROY);

    pNodeTrailer = pNode = kvs.pDatabase;
    while (pNode)
    {
	if (strcmp(pNode->pszName, name) == 0)
	{
	    while (pNode->pData)
	    {
		pElement = pNode->pData;
		pNode->pData = pNode->pData->pNext;
		MPIU_Free(pElement);
	    }
	    if (pNodeTrailer == pNode)
	    {
		kvs.pDatabase = kvs.pDatabase->pNext;
	    }
	    else
	    {
		pNodeTrailer->pNext = pNode->pNext;
	    }
	    MPIU_Free(pNode);
	    MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_KVS_DESTROY);
	    return MPI_SUCCESS;
	}
	pNodeTrailer = pNode;
	pNode = pNode->pNext;
    }

    pmi_errno = PMI_KVS_Destroy(name);
    if (pmi_errno != PMI_SUCCESS)
    {
	/* --BEGIN ERROR HANDLING-- */
	mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**pmi_kvs_destroy",
					 "**pmi_kvs_destroy %d", pmi_errno);
	/* --END ERROR HANDLING-- */
    }
    /*mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);*/
    MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_KVS_DESTROY);
    return mpi_errno;
}

#undef FUNCNAME
#define FUNCNAME MPIDI_KVS_First
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
int MPIDI_KVS_First(const char *name, char *key, char *value)
{
    int mpi_errno = MPI_SUCCESS, pmi_errno;
    MPIDI_KVS_database_node_t *pNode;
    char *pmi_key = NULL, *pmi_value = NULL;
    int pmi_key_len_max, pmi_value_len_max;
    MPIDI_STATE_DECL(MPID_STATE_MPIDI_KVS_FIRST);

    MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_KVS_FIRST);

    if (key != NULL)
    {
	key[0] = '\0';
    }
    pNode = kvs.pDatabase;
    while (pNode)
    {
	if (strcmp(pNode->pszName, name) == 0)
	{
	    if (key != NULL)
	    {
		if (pNode->pData)
		{
		    MPIU_Strncpy(key, pNode->pData->pszKey, MPIDI_MAX_KVS_KEY_LEN);
		    MPIU_Strncpy(value, pNode->pData->pszValue, MPIDI_MAX_KVS_VALUE_LEN);
		    pNode->pIter = pNode->pData->pNext;
		}
		else
		    key[0] = '\0';
	    }
	    else
	    {
		pNode->pIter = pNode->pData;
	    }
	    MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_KVS_FIRST);
	    return MPI_SUCCESS;
	}
	pNode = pNode->pNext;
    }

    pmi_errno = PMI_KVS_Get_key_length_max(&pmi_key_len_max);
    pmi_errno = PMI_KVS_Get_value_length_max(&pmi_value_len_max);
    pmi_key = (char*)MPIU_Malloc(pmi_key_len_max);
    if (pmi_key == NULL)
    {
	/* --BEGIN ERROR HANDLING-- */
	mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);
	goto fn_exit;
	/* --END ERROR HANDLING-- */
    }
    pmi_value = (char*)MPIU_Malloc(pmi_value_len_max);
    if (pmi_value == NULL)
    {
	/* --BEGIN ERROR HANDLING-- */
	mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);
	goto fn_exit;
	/* --END ERROR HANDLING-- */
    }
    pmi_errno = PMI_KVS_Iter_first(name, pmi_key, pmi_key_len_max, pmi_value, pmi_value_len_max);
    if (pmi_errno == PMI_SUCCESS)
    {
	/* FIXME: check for truncation */
	MPIU_Strncpy(key, pmi_key, MPIDI_MAX_KVS_KEY_LEN);
	MPIU_Strncpy(value, pmi_value, MPIDI_MAX_KVS_VALUE_LEN);
    }
    else
    {
	/* --BEGIN ERROR HANDLING-- */
	mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**pmi_kvs_iter_first",
					 "**pmi_kvs_iter_first %s %d", name, pmi_errno);
	goto fn_exit;
	/* --END ERROR HANDLING-- */
    }
fn_exit:
    if (pmi_key != NULL)
    {
	MPIU_Free(pmi_key);
    }
    if (pmi_value != NULL)
    {
	MPIU_Free(pmi_value);
    }
    /*mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);*/
    MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_KVS_FIRST);
    return mpi_errno;
}

#undef FUNCNAME
#define FUNCNAME MPIDI_KVS_Next
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
int MPIDI_KVS_Next(const char *name, char *key, char *value)
{
    int mpi_errno = MPI_SUCCESS, pmi_errno;
    MPIDI_KVS_database_node_t *pNode;
    char *pmi_key = NULL, *pmi_value = NULL;
    int pmi_key_len_max, pmi_value_len_max;
    MPIDI_STATE_DECL(MPID_STATE_MPIDI_KVS_NEXT);

    MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_KVS_NEXT);

    key[0] = '\0';
    pNode = kvs.pDatabase;
    while (pNode)
    {
	if (strcmp(pNode->pszName, name) == 0)
	{
	    if (pNode->pIter)
	    {
		MPIU_Strncpy(key, pNode->pIter->pszKey, MPIDI_MAX_KVS_KEY_LEN);
		MPIU_Strncpy(value, pNode->pIter->pszValue, MPIDI_MAX_KVS_VALUE_LEN);
		pNode->pIter = pNode->pIter->pNext;
	    }
	    else
	    {
		key[0] = '\0';
	    }
	    MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_KVS_NEXT);
	    return MPI_SUCCESS;
	}
	pNode = pNode->pNext;
    }

    pmi_errno = PMI_KVS_Get_key_length_max(&pmi_key_len_max);
    pmi_errno = PMI_KVS_Get_value_length_max(&pmi_value_len_max);
    pmi_key = (char*)MPIU_Malloc(pmi_key_len_max);
    if (pmi_key == NULL)
    {
	/* --BEGIN ERROR HANDLING-- */
	mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);
	goto fn_exit;
	/* --END ERROR HANDLING-- */
    }
    pmi_value = (char*)MPIU_Malloc(pmi_value_len_max);
    if (pmi_value == NULL)
    {
	/* --BEGIN ERROR HANDLING-- */
	mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);
	goto fn_exit;
	/* --END ERROR HANDLING-- */
    }
    pmi_errno = PMI_KVS_Iter_next(name, pmi_key, pmi_key_len_max, pmi_value, pmi_value_len_max);
    if (pmi_errno == PMI_SUCCESS)
    {
	/* FIXME: check for truncation */
	MPIU_Strncpy(key, pmi_key, MPIDI_MAX_KVS_KEY_LEN);
	MPIU_Strncpy(value, pmi_value, MPIDI_MAX_KVS_VALUE_LEN);
    }
    else
    {
	/* --BEGIN ERROR HANDLING-- */
	mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**pmi_kvs_iter_next",
					 "**pmi_kvs_iter_next %s %d", name, pmi_errno);
	goto fn_exit;
	/* --END ERROR HANDLING-- */
    }
fn_exit:
    if (pmi_key != NULL)
    {
	MPIU_Free(pmi_key);
    }
    if (pmi_value != NULL)
    {
	MPIU_Free(pmi_value);
    }
    /*mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);*/
    MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_KVS_NEXT);
    return mpi_errno;
}

/* FIXME: What is this routine for? */
#if 0
#undef FUNCNAME
#define FUNCNAME MPIDI_KVS_Firstkvs
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
int MPIDI_KVS_Firstkvs(char *name)
{
    MPIDI_STATE_DECL(MPID_STATE_MPIDI_KVS_FIRSTKVS);

    MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_KVS_FIRSTKVS);

    kvs.pDatabaseIter = kvs.pDatabase;
    if (name != NULL)
    {
	if (kvs.pDatabaseIter)
	{
	    MPIU_Strncpy(name, kvs.pDatabaseIter->pszName, MPIDI_MAX_KVS_NAME_LEN);
	}
	else
	{
	    name[0] = '\0';
	}
    }

    MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_KVS_FIRSTKVS);
    return MPI_SUCCESS;
}

/* FIXME: What is this routine for? */
#undef FUNCNAME
#define FUNCNAME MPIDI_KVS_Nextkvs
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
int MPIDI_KVS_Nextkvs(char *name)
{
    MPIDI_STATE_DECL(MPID_STATE_MPIDI_KVS_NEXTKVS);

    MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_KVS_NEXTKVS);

    if (kvs.pDatabaseIter == NULL)
    {
	name[0] = '\0';
    }
    else
    {
	kvs.pDatabaseIter = kvs.pDatabaseIter->pNext;
	if (kvs.pDatabaseIter)
	{
	    MPIU_Strncpy(name, kvs.pDatabaseIter->pszName, MPIDI_MAX_KVS_NAME_LEN);
	}
	else
	{
	    name[0] = '\0';
	}
    }

    MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_KVS_NEXTKVS);
    return MPI_SUCCESS;
}
#endif  /* unused routines */

#endif