rlogutil.c

fortran并行计算包

	    if (cur_event.start_time > event.start_time)
		event = cur_event;
	}
    }
    *pEvent = event;
    return 0;
}

int RLOG_ResetEventIter(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] && 
	pInput->ppCurEvent[rank_index] != NULL)
    {
	pInput->ppCurEvent[rank_index][recursion_level] = 0;
    }
    return 0;
}

int RLOG_GetNextEvent(RLOG_IOStruct *pInput, int rank, int recursion_level, RLOG_EVENT *pEvent)
{
    int rank_index;
    if (pInput == NULL || recursion_level < 0 || pEvent == NULL || rank < pInput->header.nMinRank || rank > pInput->header.nMaxRank)
	return -1;
    rank_index = rank - pInput->header.nMinRank;
    if (recursion_level < pInput->pNumEventRecursions[rank_index] && pInput->ppCurEvent[rank_index] != NULL)
    {
	if (pInput->ppCurEvent[rank_index][recursion_level] >= pInput->ppNumEvents[rank_index][recursion_level])
	    return 1;
	fseek(pInput->f, 
	    pInput->ppEventOffset[rank_index][recursion_level] + 
	    (pInput->ppCurEvent[rank_index][recursion_level] * sizeof(RLOG_EVENT)), SEEK_SET);
	if (ReadFileData((char*)pEvent, sizeof(RLOG_EVENT), pInput->f))
	{
	    rlog_err_printf("Error reading next rlog event\n");
	    return -1;
	}
	pInput->ppCurEvent[rank_index][recursion_level]++;
	return 0;
    }
    return 1;
}

int RLOG_GetRankRange(RLOG_IOStruct *pInput, int *pMin, int *pMax)
{
    if (pInput == NULL)
	return -1;
    *pMin = pInput->header.nMinRank;
    *pMax = pInput->header.nMaxRank;
    return 0;
}

static RLOG_BOOL FindMinGlobalEvent(RLOG_IOStruct *pInput, int *rank, int *level, int *index);
static RLOG_BOOL FindMinGlobalEvent(RLOG_IOStruct *pInput, int *rank, int *level, int *index)
{
    int i,j;
    double dmin = RLOG_MAX_DOUBLE;
    RLOG_BOOL found = RLOG_FALSE;

    if (pInput == NULL)
	return RLOG_FALSE;

    for (i=0; i<pInput->nNumRanks; i++)
    {
	for (j=0; j<pInput->pNumEventRecursions[i]; j++)
	{
	    if (pInput->ppCurGlobalEvent[i][j] < pInput->ppNumEvents[i][j])
	    {
		if (pInput->gppCurEvent[i][j].start_time < dmin)
		{
		    *rank = i;
		    *level = j;
		    *index = pInput->ppCurGlobalEvent[i][j];
		    dmin = pInput->gppCurEvent[i][j].start_time;
		    found = RLOG_TRUE;
		}
	    }
	}
    }

    return found;
}

static RLOG_BOOL FindMaxGlobalEvent(RLOG_IOStruct *pInput, int *rank, int *level, int *index);
static RLOG_BOOL FindMaxGlobalEvent(RLOG_IOStruct *pInput, int *rank, int *level, int *index)
{
    int i,j;
    double dmax = RLOG_MIN_DOUBLE;
    RLOG_BOOL found = RLOG_FALSE;

    if (pInput == NULL)
	return RLOG_FALSE;

    for (i=0; i<pInput->nNumRanks; i++)
    {
	for (j=0; j<pInput->pNumEventRecursions[i]; j++)
	{
	    if (pInput->ppCurGlobalEvent[i][j] > 0)
	    {
		if (pInput->gppPrevEvent[i][j].start_time > dmax)
		{
		    *rank = i;
		    *level = j;
		    *index = pInput->ppCurGlobalEvent[i][j];
		    dmax = pInput->gppPrevEvent[i][j].start_time;
		    found = RLOG_TRUE;
		}
	    }
	}
    }

    return found;
}

int RLOG_ResetGlobalIter(RLOG_IOStruct *pInput)
{
    int i,j, n;
    RLOG_EVENT min_event = {0};
    RLOG_BOOL bMinSet = RLOG_FALSE;

    if (pInput == NULL)
	return -1;

    pInput->gnCurRank = 0;
    pInput->gnCurLevel = 0;
    pInput->gnCurEvent = 0;

    for (i=0; i<pInput->nNumRanks; i++)
    {
	/* reset all the cur_events to zero for each rank */
	for (j=0; j<pInput->pNumEventRecursions[i]; j++)
	{
	    pInput->ppCurGlobalEvent[i][j] = 0;
	    /* get the first event for each rank:level */
	    n = pInput->ppCurEvent[i][j];
	    RLOG_GetEvent(pInput, pInput->header.nMinRank + i, j, 0, &pInput->gppCurEvent[i][j]);
	    /* reset the cur_event after reading */
	    pInput->ppCurEvent[i][j] = n;
	}
	if (pInput->pNumEventRecursions[i] > 0)
	{
	    if (!bMinSet)
	    {
		min_event = pInput->gppCurEvent[pInput->header.nMinRank+i][0];
		bMinSet = RLOG_TRUE;
	    }
	    /* save the rank with the earliest event */
	    if (min_event.start_time > pInput->gppCurEvent[i][0].start_time)
	    {
		min_event = pInput->gppCurEvent[i][0];
		pInput->gnCurRank = i;
	    }
	}
    }

    /* save the global current event */
    pInput->gCurEvent = pInput->gppCurEvent[pInput->gnCurRank][pInput->gnCurLevel];

    /* get the next event to replace the current */
    n = pInput->ppCurEvent[pInput->gnCurRank][pInput->gnCurLevel];
    /* get the next event */
    RLOG_GetEvent(pInput, pInput->gnCurRank, pInput->gnCurLevel, 1, 
	&pInput->gppCurEvent[pInput->gnCurRank][pInput->gnCurLevel]);
    pInput->ppCurGlobalEvent[pInput->gnCurRank][pInput->gnCurLevel] = 1;
    /* reset the cur_event after reading */
    pInput->ppCurEvent[pInput->gnCurRank][pInput->gnCurLevel] = n;

    return 0;
}

int RLOG_GetNextGlobalEvent(RLOG_IOStruct *pInput, RLOG_EVENT *pEvent)
{
    int n;

    if (pInput == NULL || pEvent == NULL)
	return -1;

    /* put the current in the previous slot */
    pInput->gppPrevEvent[pInput->gnCurRank][pInput->gnCurLevel] = pInput->gCurEvent;

    /* find the next event and put it in the current event */
    if (!FindMinGlobalEvent(pInput, &pInput->gnCurRank, &pInput->gnCurLevel, &pInput->gnCurEvent))
    {
	/* find min failed meaning we are at the end, so replace the event we just over-wrote */
	n = pInput->ppCurEvent[pInput->gnCurRank][pInput->gnCurLevel];
	RLOG_GetEvent(pInput, pInput->gnCurRank, pInput->gnCurLevel, pInput->gnCurEvent-2, 
	    &pInput->gppCurEvent[pInput->gnCurRank][pInput->gnCurLevel]);
	pInput->ppCurEvent[pInput->gnCurRank][pInput->gnCurLevel] = n;
	return -1;
    }
    pInput->gCurEvent = pInput->gppCurEvent[pInput->gnCurRank][pInput->gnCurLevel];

    /* replace the next event with its next event */

    /* save the current position */
    n = pInput->ppCurEvent[pInput->gnCurRank][pInput->gnCurLevel];
    /* get the next event */
    RLOG_GetEvent(pInput, pInput->gnCurRank, pInput->gnCurLevel, pInput->gnCurEvent+1, 
	&pInput->gppCurEvent[pInput->gnCurRank][pInput->gnCurLevel]);
    pInput->ppCurGlobalEvent[pInput->gnCurRank][pInput->gnCurLevel] = pInput->gnCurEvent+1;
    /* reset the current position */
    pInput->ppCurEvent[pInput->gnCurRank][pInput->gnCurLevel] = n;


    /* return the new current event */
    *pEvent = pInput->gCurEvent;

    return 0;
}

int RLOG_GetPreviousGlobalEvent(RLOG_IOStruct *pInput, RLOG_EVENT *pEvent)
{
    int n;

    if (pInput == NULL || pEvent == NULL)
	return -1;

    /* put the current back in its next slot */
    pInput->gppCurEvent[pInput->gnCurRank][pInput->gnCurLevel] = pInput->gCurEvent;
    pInput->ppCurGlobalEvent[pInput->gnCurRank][pInput->gnCurLevel]--;

    /* find the previous event and put it in the current event */
    if (!FindMaxGlobalEvent(pInput, &pInput->gnCurRank, &pInput->gnCurLevel, &pInput->gnCurEvent))
    {
	/* find max failed meaning we are at the beginning, so replace the event we just over-wrote */
	n = pInput->ppCurEvent[pInput->gnCurRank][pInput->gnCurLevel];
	RLOG_GetEvent(pInput, pInput->gnCurRank, pInput->gnCurLevel, 1, 
	    &pInput->gppCurEvent[pInput->gnCurRank][pInput->gnCurLevel]);
	pInput->ppCurGlobalEvent[pInput->gnCurRank][pInput->gnCurLevel] = 1;
	pInput->ppCurEvent[pInput->gnCurRank][pInput->gnCurLevel] = n;
	return -1;
    }
    pInput->gCurEvent = pInput->gppPrevEvent[pInput->gnCurRank][pInput->gnCurLevel];


    /* replace the previous event with its previous event */

    /* save the current position */
    n = pInput->ppCurEvent[pInput->gnCurRank][pInput->gnCurLevel];
    /* get the previous event */
    RLOG_GetEvent(pInput, pInput->gnCurRank, pInput->gnCurLevel, pInput->gnCurEvent-2, 
	&pInput->gppPrevEvent[pInput->gnCurRank][pInput->gnCurLevel]);
    /* reset the current position */
    pInput->ppCurEvent[pInput->gnCurRank][pInput->gnCurLevel] = n;


    /* return the new current event */
    *pEvent = pInput->gCurEvent;

    return 0;
}

int RLOG_GetCurrentGlobalEvent(RLOG_IOStruct *pInput, RLOG_EVENT *pEvent)
{
    if (pInput == NULL || pEvent == NULL)
	return -1;
    if (pInput->gnCurRank < 0 || pInput->gnCurRank >= pInput->nNumRanks)
	return -1;
    if (pInput->gnCurLevel < 0 || pInput->gnCurLevel >= pInput->pNumEventRecursions[pInput->gnCurRank])
	return -1;
    if (pInput->gnCurEvent < 0 || pInput->gnCurEvent >= pInput->ppNumEvents[pInput->gnCurRank][pInput->gnCurLevel])
	return -1;

    *pEvent = pInput->gCurEvent;

    return 0;
}

int RLOG_PrintGlobalState(RLOG_IOStruct *pInput)
{
    int i,j;

    for (i=0; i<pInput->nNumRanks; i++)
    {
	for (j=0; j<pInput->pNumEventRecursions[i]; j++)
	{
	    printf("[%d][%d] prev: (%g - %g) ", i, j, pInput->gppPrevEvent[i][j].start_time, pInput->gppPrevEvent[i][j].end_time);
	    printf("next: (%g - %g)\n", pInput->gppCurEvent[i][j].start_time, pInput->gppCurEvent[i][j].end_time);
	}
    }
    return 0;
}

int RLOG_FindGlobalEventBeforeTimestamp(RLOG_IOStruct *pInput, double timestamp, RLOG_EVENT *pEvent)
{
    int i,j, n;

    if (pInput == NULL || pEvent == NULL)
	return -1;

    pInput->gnCurRank = 0;
    pInput->gnCurLevel = 0;
    pInput->gnCurEvent = 0;

    /* set all the current and previous events for each rank */
    for (i=0; i<pInput->nNumRanks; i++)
    {
	for (j=0; j<pInput->pNumEventRecursions[i]; j++)
	{
	    n = pInput->ppCurEvent[i][j]; /* save iterator */

	    RLOG_FindEventBeforeTimestamp(pInput, 
		pInput->header.nMinRank + i, j, 
		timestamp, 
		&pInput->gppPrevEvent[i][j], 
		&pInput->ppCurGlobalEvent[i][j]);
	    if (pInput->gppPrevEvent[i][j].start_time > timestamp)
	    {
		/* the start time can only be after the timestamp if this event is the very first event at this level */
		/*
		if (pInput->ppCurGlobalEvent[i][j] != 0);
		{
		    printf("RLOG_FindGlobalEventBeforeTimestamp: Error, start_time > timestamp, %g > %g", pInput->gppPrevEvent[i][j].start_time, timestamp);
		    return -1;
		}
		*/
		pInput->gppCurEvent[i][j] = pInput->gppPrevEvent[i][j];
	    }
	    else
	    {
		pInput->ppCurGlobalEvent[i][j]++;
		RLOG_GetEvent(pInput, pInput->header.nMinRank + i, j,
		    pInput->ppCurGlobalEvent[i][j],
		    &pInput->gppCurEvent[i][j]);
	    }

	    pInput->ppCurEvent[i][j] = n; /* restore iterator */
	}
    }

    /* find the maximum of the previous events */
    FindMaxGlobalEvent(pInput, &pInput->gnCurRank, &pInput->gnCurLevel, &pInput->gnCurEvent);

    /* save this event as the global current event */
    pInput->gCurEvent = pInput->gppPrevEvent[pInput->gnCurRank][pInput->gnCurLevel];

    /* save the current position */
    n = pInput->ppCurEvent[pInput->gnCurRank][pInput->gnCurLevel];
    /* get the previous event */
    RLOG_GetEvent(pInput, pInput->gnCurRank, pInput->gnCurLevel, pInput->gnCurEvent-1, 
	&pInput->gppPrevEvent[pInput->gnCurRank][pInput->gnCurLevel]);
    /* reset the current position */
    pInput->ppCurEvent[pInput->gnCurRank][pInput->gnCurLevel] = n;

    /* return the new current event */
    *pEvent = pInput->gCurEvent;

    return 0;
}

int RLOG_FindArrowBeforeTimestamp(RLOG_IOStruct *pInput, double timestamp, RLOG_ARROW *pArrow, int *pIndex)
{
    RLOG_ARROW arrow;
    int low, high, mid;

    if (pInput == NULL || pArrow == NULL)
	return -1;

    low = 0;
    high = pInput->nNumArrows - 1;
    mid = high/2;

    for (;;)
    {
	RLOG_GetArrow(pInput, mid, &arrow);
	if (arrow.end_time < timestamp)
	{
	    low = mid;
	}
	else
	    high = mid;
	mid = (low + high) / 2;
	if (low == mid)
	{
	    if (arrow.end_time < timestamp)
	    {
		RLOG_GetArrow(pInput, low+1, &arrow);
		if (arrow.end_time < timestamp)
		    low++;
	    }
	    break;
	}
    }
    if (pIndex != NULL)
	*pIndex = low;
    return RLOG_GetArrow(pInput, low, pArrow);
}

int RLOG_HitTest(RLOG_IOStruct *pInput, int rank, int level, double timestamp, RLOG_EVENT *pEvent)
{
    int rank_index;
    if (pInput == NULL || pEvent == NULL || level < 0)
	return -1;
    if (rank < pInput->header.nMinRank || rank >= pInput->header.nMaxRank)
	return -1;
    rank_index = rank - pInput->header.nMinRank;
    if (level >= pInput->pNumEventRecursions[rank_index])
	return -1;
    return 0;
}