rlogutil.c

fortran并行计算包

	{
	    event.start_time += pOffsets[index];
	    event.end_time += pOffsets[index];
	    fseek(f, -(int)sizeof(RLOG_EVENT), SEEK_CUR);
	    error = WriteFileData((const char *)&event, sizeof(RLOG_EVENT), f);
	    if (error)
	    {
		rlog_err_printf("writing modified event failed.\n");
		return -1;
	    }
	    fseek(f, 0, SEEK_CUR);
	}
    }
    return 0;
}

int RLOG_ModifyEvents(const char *filename, double *pOffsets, int n)
{
    int i, rank_index, cur_rank, min_rank = 0;
    /*int j;*/
    RLOG_IOStruct *pInput;
    int type, length;
    int error;

    /* allocate an input structure */
    pInput = (RLOG_IOStruct*)malloc(sizeof(RLOG_IOStruct));
    if (pInput == NULL)
    {
	printf("malloc failed - %s\n", strerror(errno));
	return -1;
    }
    pInput->ppCurEvent = NULL;
    pInput->ppCurGlobalEvent = NULL;
    pInput->gppCurEvent = NULL;
    pInput->gppPrevEvent = NULL;
    pInput->ppEventOffset = NULL;
    pInput->ppNumEvents = NULL;
    pInput->nNumArrows = 0;
    /* open the input rlog file */
    pInput->f = fopen(filename, "rb+");
    if (pInput->f == NULL)
    {
	printf("fopen(%s) failed, error: %s\n", filename, strerror(errno));
	free(pInput);
	return -1;
    }
    pInput->nNumRanks = 0;
    /* read the sections */
    while (fread(&type, sizeof(int), 1, pInput->f))
    {
	fread(&length, sizeof(int), 1, pInput->f);
	switch (type)
	{
	case RLOG_HEADER_SECTION:
	    /*printf("type: RLOG_HEADER_SECTION, length: %d\n", length);*/
	    if (length != sizeof(RLOG_FILE_HEADER))
	    {
		rlog_err_printf("error in header size %d != %d\n", length, sizeof(RLOG_FILE_HEADER));
		return -1;
	    }
	    if (ReadFileData((char*)&pInput->header, sizeof(RLOG_FILE_HEADER), pInput->f))
	    {
		rlog_err_printf("error reading rlog header\n");
		return -1;
	    }
	    
	    pInput->nNumRanks = pInput->header.nMaxRank + 1 - pInput->header.nMinRank;
	    min_rank = pInput->header.nMinRank;
	    
	    pInput->pRank = (int*)malloc(pInput->nNumRanks * sizeof(int));
	    pInput->pNumEventRecursions = (int*)malloc(pInput->nNumRanks * sizeof(int));
	    pInput->ppNumEvents = (int**)malloc(pInput->nNumRanks * sizeof(int*));
	    pInput->ppCurEvent = (int**)malloc(pInput->nNumRanks * sizeof(int*));
	    pInput->ppCurGlobalEvent = (int**)malloc(pInput->nNumRanks * sizeof(int*));
	    pInput->gppCurEvent = (RLOG_EVENT**)malloc(pInput->nNumRanks * sizeof(RLOG_EVENT*));
	    pInput->gppPrevEvent = (RLOG_EVENT**)malloc(pInput->nNumRanks * sizeof(RLOG_EVENT*));
	    pInput->ppEventOffset = (long**)malloc(pInput->nNumRanks * sizeof(long*));
	    for (i=0; i<pInput->nNumRanks; i++)
	    {
		pInput->pRank[i] = -1;
		pInput->pNumEventRecursions[i] = 0;
		pInput->ppNumEvents[i] = NULL;
		pInput->ppCurEvent[i] = NULL;
		pInput->ppCurGlobalEvent[i] = NULL;
		pInput->gppCurEvent[i] = NULL;
		pInput->gppPrevEvent[i] = NULL;
		pInput->ppEventOffset[i] = NULL;
	    }
	    break;
	case RLOG_STATE_SECTION:
	    /*printf("type: RLOG_STATE_SECTION, length: %d\n", length);*/
	    pInput->nNumStates = length / sizeof(RLOG_STATE);
	    pInput->nStateOffset = ftell(pInput->f);
	    fseek(pInput->f, length, SEEK_CUR);
	    break;
	case RLOG_ARROW_SECTION:
	    /*printf("type: RLOG_ARROW_SECTION, length: %d\n", length);*/
	    pInput->nNumArrows = length / sizeof(RLOG_ARROW);
	    pInput->nArrowOffset = ftell(pInput->f);
	    error = ModifyArrows(pInput->f, pInput->nNumArrows, pInput->header.nMinRank, pOffsets, n);
	    if (error)
	    {
		printf("Modifying the arrow section failed, error %d\n", error);
		RLOG_CloseInputStruct(&pInput);
		return -1;
	    }
	    /* fseek(pInput->f, length, SEEK_CUR); */
	    break;
	case RLOG_EVENT_SECTION:
	    /*printf("type: RLOG_EVENT_SECTION, length: %d, ", length);*/
	    fread(&cur_rank, sizeof(int), 1, pInput->f);
	    if (cur_rank - min_rank >= pInput->nNumRanks)
	    {
		printf("Error: event section out of range - %d <= %d <= %d\n", pInput->header.nMinRank, cur_rank, pInput->header.nMaxRank);
		RLOG_CloseInputStruct(&pInput);
		return -1;
	    }
	    rank_index = cur_rank - min_rank;
	    fread(&pInput->pNumEventRecursions[rank_index], sizeof(int), 1, pInput->f);
	    /*printf("levels: %d\n", pInput->nNumEventRecursions);*/
	    if (pInput->pNumEventRecursions[rank_index])
	    {
		pInput->ppCurEvent[rank_index] = (int*)malloc(pInput->pNumEventRecursions[rank_index] * sizeof(int));
		pInput->ppCurGlobalEvent[rank_index] = (int*)malloc(pInput->pNumEventRecursions[rank_index] * sizeof(int));
		pInput->gppCurEvent[rank_index] = (RLOG_EVENT*)malloc(pInput->pNumEventRecursions[rank_index] * sizeof(RLOG_EVENT));
		pInput->gppPrevEvent[rank_index] = (RLOG_EVENT*)malloc(pInput->pNumEventRecursions[rank_index] * sizeof(RLOG_EVENT));
		pInput->ppNumEvents[rank_index] = (int*)malloc(pInput->pNumEventRecursions[rank_index] * sizeof(int));
		pInput->ppEventOffset[rank_index] = (long*)malloc(pInput->pNumEventRecursions[rank_index] * sizeof(long));
	    }
	    for (i=0; i<pInput->pNumEventRecursions[rank_index]; i++)
	    {
		fread(&pInput->ppNumEvents[rank_index][i], sizeof(int), 1, pInput->f);
		/*printf(" level %2d: %d events\n", i, pInput->pNumEvents[i]);*/
	    }
	    if (pInput->pNumEventRecursions[rank_index])
	    {
		pInput->ppEventOffset[rank_index][0] = ftell(pInput->f);
		for (i=1; i<pInput->pNumEventRecursions[rank_index]; i++)
		{
		    pInput->ppEventOffset[rank_index][i] = pInput->ppEventOffset[rank_index][i-1] + (pInput->ppNumEvents[rank_index][i-1] * sizeof(RLOG_EVENT));
		}
	    }
	    length -= ((pInput->pNumEventRecursions[rank_index] + 2) * sizeof(int));
	    ModifyEvents(pInput->f, length / sizeof(RLOG_EVENT), pInput->header.nMinRank, pOffsets, n);
	    /* fseek(pInput->f, length, SEEK_CUR); */
	    break;
	default:
	    /*printf("unknown section: type %d, length %d\n", type, length);*/
	    fseek(pInput->f, length, SEEK_CUR);
	    break;
	}
    }
    /* reset the iterators */
    /*
    RLOG_ResetStateIter(pInput);
    RLOG_ResetArrowIter(pInput);
    for (j=0; j<pInput->nNumRanks; j++)
    {
	for (i=0; i<pInput->pNumEventRecursions[j]; i++)
	    RLOG_ResetEventIter(pInput, j+pInput->header.nMinRank, i);
    }
    RLOG_ResetGlobalIter(pInput);
    */
    RLOG_CloseInputStruct(&pInput);
    return 0;
}

int RLOG_CloseInputStruct(RLOG_IOStruct **ppInput)
{
    int i;
    if (ppInput == NULL)
	return -1;
    fclose((*ppInput)->f);
    for (i=0; i<(*ppInput)->nNumRanks; i++)
    {
	if ((*ppInput)->ppCurEvent[i])
	    free((*ppInput)->ppCurEvent[i]);
	if ((*ppInput)->ppCurGlobalEvent[i])
	    free((*ppInput)->ppCurGlobalEvent[i]);
	if ((*ppInput)->gppCurEvent[i])
	    free((*ppInput)->gppCurEvent[i]);
	if ((*ppInput)->gppPrevEvent[i])
	    free((*ppInput)->gppPrevEvent[i]);
	if ((*ppInput)->ppEventOffset[i])
	    free((*ppInput)->ppEventOffset[i]);
	if ((*ppInput)->ppNumEvents[i])
	    free((*ppInput)->ppNumEvents[i]);
    }
    if ((*ppInput)->ppCurEvent)
	free((*ppInput)->ppCurEvent);
    if ((*ppInput)->ppCurGlobalEvent)
	free((*ppInput)->ppCurGlobalEvent);
    if ((*ppInput)->gppCurEvent)
	free((*ppInput)->gppCurEvent);
    if ((*ppInput)->gppPrevEvent)
	free((*ppInput)->gppPrevEvent);
    if ((*ppInput)->ppEventOffset)
	free((*ppInput)->ppEventOffset);
    if ((*ppInput)->ppNumEvents)
	free((*ppInput)->ppNumEvents);
    free(*ppInput);
    *ppInput = NULL;
    return 0;
}

int RLOG_GetFileHeader(RLOG_IOStruct *pInput, RLOG_FILE_HEADER *pHeader)
{
    if (pInput == NULL)
	return -1;
    memcpy(pHeader, &pInput->header, sizeof(RLOG_FILE_HEADER));
    return 0;
}

int RLOG_GetNumStates(RLOG_IOStruct *pInput)
{
    if (pInput == NULL)
	return -1;
    return pInput->nNumStates;
}

int RLOG_GetState(RLOG_IOStruct *pInput, int i, RLOG_STATE *pState)
{
    if (pInput == NULL || pState == NULL || i < 0 || i >= pInput->nNumStates)
	return -1;
    fseek(pInput->f, pInput->nStateOffset + (i * sizeof(RLOG_STATE)), SEEK_SET);
    if (ReadFileData((char*)pState, sizeof(RLOG_STATE), pInput->f))
    {
	rlog_err_printf("Error reading rlog state\n");
	return -1;
    }

    pInput->nCurState = i+1;

    return 0;
}

int RLOG_ResetStateIter(RLOG_IOStruct *pInput)
{
    if (pInput == NULL)
	return -1;
    pInput->nCurState = 0;
    return 0;
}

int RLOG_GetNextState(RLOG_IOStruct *pInput, RLOG_STATE *pState)
{
    if (pInput == NULL || pState == NULL)
	return -1;
    if (pInput->nCurState >= pInput->nNumStates)
	return 1;
    fseek(pInput->f, pInput->nStateOffset + (pInput->nCurState * sizeof(RLOG_STATE)), SEEK_SET);
    if (ReadFileData((char*)pState, sizeof(RLOG_STATE), pInput->f))
    {
	rlog_err_printf("Error reading next rlog state\n");
	return -1;
    }
    pInput->nCurState++;
    return 0;
}

int RLOG_GetNumArrows(RLOG_IOStruct *pInput)
{
    if (pInput == NULL)
	return -1;
    return pInput->nNumArrows;
}

int RLOG_GetArrow(RLOG_IOStruct *pInput, int i, RLOG_ARROW *pArrow)
{
    if (pInput == NULL || pArrow == NULL || i < 0 || i >= pInput->nNumArrows)
	return -1;
    fseek(pInput->f, pInput->nArrowOffset + (i * sizeof(RLOG_ARROW)), SEEK_SET);
    if (ReadFileData((char*)pArrow, sizeof(RLOG_ARROW), pInput->f))
    {
	rlog_err_printf("Error reading rlog arrow\n");
	return -1;
    }

    pInput->nCurArrow = i+1;

    return 0;
}

int RLOG_ResetArrowIter(RLOG_IOStruct *pInput)
{
    if (pInput == NULL)
	return -1;
    pInput->nCurArrow = 0;
    return 0;
}

int RLOG_GetNextArrow(RLOG_IOStruct *pInput, RLOG_ARROW *pArrow)
{
    if (pInput == NULL)
	return -1;
    if (pInput->nCurArrow >= pInput->nNumArrows)
	return 1;
    fseek(pInput->f, pInput->nArrowOffset + (pInput->nCurArrow * sizeof(RLOG_ARROW)), SEEK_SET);
    if (ReadFileData((char*)pArrow, sizeof(RLOG_ARROW), pInput->f))
    {
	rlog_err_printf("Error reading next rlog arrow\n");
	return -1;
    }
    pInput->nCurArrow++;
    return 0;
}

int RLOG_GetNumEventRecursions(RLOG_IOStruct *pInput, int rank)
{
    if (pInput == NULL || rank < pInput->header.nMinRank || rank > pInput->header.nMaxRank)
	return -1;
    return pInput->pNumEventRecursions[rank - pInput->header.nMinRank];
}

int RLOG_GetNumEvents(RLOG_IOStruct *pInput, int rank, int recursion_level)
{
    int rank_index;
    if (pInput == NULL || recursion_level < 0 || rank < pInput->header.nMinRank || rank > pInput->header.nMaxRank)
	return -1;
    rank_index = rank - pInput->header.nMinRank;
    if (recursion_level >= pInput->pNumEventRecursions[rank_index])
	return -1;
    return pInput->ppNumEvents[rank_index][recursion_level];
}

int RLOG_GetEvent(RLOG_IOStruct *pInput, int rank, int recursion_level, int index, RLOG_EVENT *pEvent)
{
    int rank_index;
    if (pInput == NULL || pEvent == NULL || rank < pInput->header.nMinRank || rank > pInput->header.nMaxRank)
	return -1;
    rank_index = rank - pInput->header.nMinRank;
    if (recursion_level < 0 || recursion_level >= pInput->pNumEventRecursions[rank_index])
	return -1;
    if (index < 0 || index >= pInput->ppNumEvents[rank_index][recursion_level])
	return -1;

    fseek(pInput->f, pInput->ppEventOffset[rank_index][recursion_level] + (index * sizeof(RLOG_EVENT)), SEEK_SET);
    if (ReadFileData((char*)pEvent, sizeof(RLOG_EVENT), pInput->f))
    {
	rlog_err_printf("Error reading rlog event\n");
	return -1;
    }

    /* GetEvent sets the current iteration position also */
    pInput->ppCurEvent[rank_index][recursion_level] = index+1;

    return 0;
}

int RLOG_FindEventBeforeTimestamp(RLOG_IOStruct *pInput, int rank, int recursion_level, double timestamp, RLOG_EVENT *pEvent, int *pIndex)
{
    RLOG_EVENT event;
    int low, high, mid;
    int rank_index;

    if (pInput == NULL || pEvent == NULL || rank < pInput->header.nMinRank || rank > pInput->header.nMaxRank)
	return -1;
    rank_index = rank - pInput->header.nMinRank;
    if (recursion_level < 0 || recursion_level >= pInput->pNumEventRecursions[rank_index])
	return -1;

    low = 0;
    high = pInput->ppNumEvents[rank_index][recursion_level]-1;
    mid = high/2;

    for (;;)
    {
	RLOG_GetEvent(pInput, rank, recursion_level, mid, &event);
	if (event.start_time < timestamp)
	{
	    low = mid;
	}
	else
	    high = mid;
	mid = (low + high) / 2;
	if (low == mid)
	{
	    if (event.start_time < timestamp)
	    {
		RLOG_GetEvent(pInput, rank, recursion_level, low+1, &event);
		if (event.start_time < timestamp)
		    low++;
	    }
	    break;
	}
    }
    if (pIndex != NULL)
	*pIndex = low;
    return RLOG_GetEvent(pInput, rank, recursion_level, low, pEvent);
}

int RLOG_FindAnyEventBeforeTimestamp(RLOG_IOStruct *pInput, int rank, double timestamp, RLOG_EVENT *pEvent)
{
    RLOG_EVENT event, cur_event;
    int index, i, rank_index;

    if (pInput == NULL || pEvent == NULL || rank < pInput->header.nMinRank || rank > pInput->header.nMaxRank)
	return -1;
    rank_index = rank - pInput->header.nMinRank;

    if (RLOG_FindEventBeforeTimestamp(pInput, rank, 0, timestamp, &event, &index) == -1)
	return -1;
    for (i=1; i<pInput->pNumEventRecursions[rank_index]; i++)
    {
	if (RLOG_FindEventBeforeTimestamp(pInput, rank, i, timestamp, &cur_event, &index) != -1)
	{