ixperfprofaccxcycle.c

有关ARM开发板上的IXP400网络驱动程序的源码以。

#ifdef __linuxapp
    priority = getpriority(PRIO_PROCESS,0);
    if(0 != setpriority( PRIO_PROCESS, 0,
            IX_PERFPROF_ACC_XCYCLE_LINUXAPP_PRIORITY_HIGHEST )
            )
    {
        ixPerfProfAccUnlock();
        return IX_PERFPROF_ACC_STATUS_XCYCLE_PRIORITY_SET_FAIL;
    }

#else

    result = ixOsalThreadIdGet (&threadId);
    if (IX_SUCCESS != result)
    {
        ixPerfProfAccUnlock();
        return IX_PERFPROF_ACC_STATUS_XCYCLE_PRIORITY_SET_FAIL;
    }
    taskPriorityGet (threadId, &priority);
    result = ixOsalThreadPrioritySet (
            &threadId,
            IX_PERFPROF_ACC_XCYCLE_VXWORKS_PRIORITY_HIGHEST );
    if (IX_SUCCESS != result)
    {
        return IX_PERFPROF_ACC_STATUS_XCYCLE_PRIORITY_SET_FAIL;
    }
#endif

    /*
     * Perform a measure of time needed for one measurement without
     * load.
     */
    startTime = ixPerfProfAccXcycleApbTimerGet();
    for (i = 0; IX_PERFPROF_ACC_XCYCLE_TIME_SLICES_PER_SEC > i; i++)
    {
        temp = ixNumLoopPerTimeSlice;
        ixPerfProfAccXcycleLoopIter(temp);
    }
    stopTime = ixPerfProfAccXcycleApbTimerGet();

    /*
     * Rollover situation is handled through the fact that the different
     * between start and stop time is a fraction of 32bit storage
     * The duration of time stored in 32 bits is 65 sec
     * We expect difference between start and stop time to be
     * ~ 1 sec
     */
    duration = stopTime - startTime;

    ixOsalIrqUnlock(interruptLockKey);

#ifdef __linuxapp
    if(setpriority(PRIO_PROCESS, 0, priority) != 0)
    {
        ixPerfProfAccUnlock();
        return IX_PERFPROF_ACC_STATUS_XCYCLE_PRIORITY_RESTORE_FAIL;
    }
#else /* ifdef __linuxapp */
    /*
     * Restore the calling thread to previous priority
     */
    result = ixOsalThreadPrioritySet (&threadId, priority);

    if (IX_SUCCESS != result)
    {
        ixPerfProfAccUnlock();
        return IX_PERFPROF_ACC_STATUS_XCYCLE_PRIORITY_RESTORE_FAIL;
    }

#endif /* ifdef __linuxapp */

    ixPerfProfAccXcycleCurrentBaseline = duration;
    *numBaselineCycle = duration;
    ixPerfProfAccUnlock();
    return IX_PERFPROF_ACC_STATUS_SUCCESS ;
} /* end of ixPerfProfAccXcycleBaselineRun() */

PUBLIC IxPerfProfAccStatus
ixPerfProfAccXcycleStart (UINT32 numMeasurementsRequested)
{

#ifdef __linuxapp
    UINT32 result;      /* result of thread creation */
    int priority;       /* used to remember priority of current process */
    pthread_attr_t threadAttribute; /* used to setup thread attribute */
#elif defined (__vxworks)
    IxOsalThreadAttr threadAttr;
    IX_STATUS retStatus;
#endif /* ifdef __linuxapp */

    ixPerfProfAccXcycleStopMeasurement = FALSE;

    /*
     * Check if baseline had been run. If not, terminate.
     */
    if (0 == ixPerfProfAccXcycleCurrentBaseline)
    {
        return IX_PERFPROF_ACC_STATUS_XCYCLE_NO_BASELINE;
    }

    /*
     * Range checking for numMeasurementsRequested
     */
    if (IX_PERFPROF_ACC_XCYCLE_MAX_NUM_OF_MEASUREMENTS < numMeasurementsRequested)
    {
        return IX_PERFPROF_ACC_STATUS_XCYCLE_MEASUREMENT_REQUEST_OUT_OF_RANGE;
    }

    /*
     * Check if Xcycle is already running, do not allow another start
     * if Xcycle is running.
     */
    if (ixPerfProfAccXcycleMeasurementInProgress)
    {
        return IX_PERFPROF_ACC_STATUS_XCYCLE_MEASUREMENT_IN_PROGRESS;
    }

    /*
     * Xcycle is not running, set the flag to indicate that
     * a measurement is in progress
     */
    else
    {
        ixPerfProfAccXcycleMeasurementInProgress = TRUE ;
    }

    /*
     * Check to see if any other PMU utilities besides Xcycle is running
     * If yes, we abort to avoid inaccurate results due to load introduce
     * by other tools.
     */
    if (IX_PERFPROF_ACC_STATUS_ANOTHER_UTIL_IN_PROGRESS
        == ixPerfProfAccLock())
    {
        return IX_PERFPROF_ACC_STATUS_ANOTHER_UTIL_IN_PROGRESS;
    }

#ifdef __linuxapp
    /*
     * Set current priority to lowest possible
     */
    priority = getpriority(PRIO_PROCESS,0);
    if(0 != setpriority (PRIO_PROCESS,
                         0,
                         IX_PERFPROF_ACC_XCYCLE_LINUXAPP_PRIORITY_LOWEST))
    {
        ixPerfProfAccUnlock();
        ixPerfProfAccXcycleMeasurementInProgress = FALSE ;
        return IX_PERFPROF_ACC_STATUS_XCYCLE_PRIORITY_SET_FAIL;
    }

    /*
     * Preparing to create a new thread of ixPerfProfAccXcycleNumPeriodRun()
     * Start with setting thread attribute with state DETACHED
     */
    result = pthread_attr_init (&threadAttribute);
    result |= pthread_attr_setdetachstate (&threadAttribute,
                                            PTHREAD_CREATE_DETACHED);
    result |= pthread_create (&xcycleThreadId,
                            &threadAttribute,
                            (void *) &ixPerfProfAccXcycleNumPeriodRun ,
                            (void *)numMeasurementsRequested);
    if (0 != result)
    {
        ixPerfProfAccUnlock();
        ixPerfProfAccXcycleMeasurementInProgress = FALSE ;
        return  IX_PERFPROF_ACC_STATUS_XCYCLE_THREAD_CREATE_FAIL;
    }/* end of if (result) */

    /*
     * Successful in creating a new thread with lowest priority.
     * Restore priority of calling thread to original level
     */
    if (0 != setpriority (PRIO_PROCESS, 0, priority))
    {
        ixPerfProfAccUnlock();
        return IX_PERFPROF_ACC_STATUS_XCYCLE_PRIORITY_SET_FAIL;
    }
#else /* ifdef __linuxapp */

    /*
     * Create a new thread of ixPerfProfAccXcycleNumPeriodRun()
     * Set the priority level of new thread to lowest possible
     * If fail, set ixPerfProfAccXcycleMeasurementInProgress
     * back to FALSE and return error.
     */
    threadAttr.name = "PerfProf Xcycle thread";
    threadAttr.stackSize = 0;
    threadAttr.priority = IX_PERFPROF_ACC_XCYCLE_VXWORKS_PRIORITY_LOWEST;
    if ((retStatus = ixOsalThreadCreate(
	           &xcycleThreadId,
		   &threadAttr, 
		   (IxOsalVoidFnVoidPtr) ixPerfProfAccXcycleNumPeriodRun,
		   (void*) numMeasurementsRequested)) ==
	  IX_SUCCESS)

    {
	if ((retStatus = ixOsalThreadStart(&xcycleThreadId)) != IX_SUCCESS)
	{
	    ixPerfProfAccUnlock();
	    ixPerfProfAccXcycleMeasurementInProgress = FALSE;
	    return  IX_PERFPROF_ACC_STATUS_XCYCLE_THREAD_CREATE_FAIL;
	}
    }	
    else
    {
        ixPerfProfAccUnlock();
        ixPerfProfAccXcycleMeasurementInProgress = FALSE ;
        return  IX_PERFPROF_ACC_STATUS_XCYCLE_THREAD_CREATE_FAIL;
    } /* end of if (result) */

#endif /* ifdef __linuxapp */

    return IX_PERFPROF_ACC_STATUS_SUCCESS;
} /* end of ixPerfProfAccXcycleStart() */

PUBLIC IxPerfProfAccStatus
ixPerfProfAccXcycleStop (void)
{
    if (ixPerfProfAccXcycleStopMeasurement == FALSE )
    {
        ixPerfProfAccXcycleStopMeasurement = TRUE;
		ixPerfProfAccUnlock();
        return IX_PERFPROF_ACC_STATUS_SUCCESS;
    }
    else
    {
        return IX_PERFPROF_ACC_STATUS_XCYCLE_MEASUREMENT_NOT_RUNNING;
    }

} /* end of ixPerfProfAccXcycleStop() */

UINT32
ixPerfProfAccXcycleComputeLoopsPerSlice (void)
{
    UINT32  startTime,          /* used to store start time */
            stopTime,           /* used to store stop time */
            ulLoopsPerTimeSlice,/* unsigned long to return results */
            fixNumLoop = IX_PERFPROF_ACC_XCYCLE_SEED_FOR_BASELINE;

    float   timeInSeconds,
            numLoopsPerSecond,
            numLoopsPerTimeSlice;

    startTime = ixPerfProfAccXcycleApbTimerGet ();

    /*
     * Run for IX_PERFPROF_ACC_XCYCLE_SEED_FOR_BASELINE times
     */
    ixPerfProfAccXcycleLoopIter (fixNumLoop);

    stopTime = ixPerfProfAccXcycleApbTimerGet ();

    /*
     * It takes (stopTime-startTime) to complete
     * IX_PERFPROF_ACC_XCYCLE_SEED_FOR_BASELINE iterations
     * Compute number of loops needed for 1 sec divided by
     * IX_PERFPROF_ACC_XCYCLE_TIME_SLICES_PER_SEC
     */
    timeInSeconds = ((float) (stopTime - startTime))/
                    ((float)IX_PERFPROF_ACC_XCYCLE_TIMER_FREQ);
    numLoopsPerSecond = ((float)fixNumLoop)/timeInSeconds;
    numLoopsPerTimeSlice = numLoopsPerSecond /
                        IX_PERFPROF_ACC_XCYCLE_TIME_SLICES_PER_SEC;
    ulLoopsPerTimeSlice = (UINT32) numLoopsPerTimeSlice;
    return (ulLoopsPerTimeSlice);
} /* end of ixPerfProfAccXcycleComputeLoopsPerSlice */

PUBLIC IxPerfProfAccStatus
ixPerfProfAccXcycleResultsGet (
                   IxPerfProfAccXcycleResults *xcycleResult)
{
    UINT32 i ;
    UINT32 duration ;
    float fPercentage,
          fPercentageMax = 0 ,
          fPercentageMin= 1000,
          fPercentageTotal=0 ;

    /*error check the parameter*/
    if (NULL == xcycleResult)
    {
	/* report the error */ 
        IX_PERFPROF_ACC_LOG(
            IX_OSAL_LOG_LVL_ERROR, IX_OSAL_LOG_DEV_STDERR,
            "ixPerfProfAccXcycleResultsGet - xcycleResult is invalid\n",
            0, 0, 0, 0, 0, 0);
	/* return error */
        return IX_PERFPROF_ACC_STATUS_FAIL;
    }

    if (0 == ixPerfProfAccXcycleCurrentBaseline)
    {
        return IX_PERFPROF_ACC_STATUS_XCYCLE_NO_BASELINE;
    }

    if (ixPerfProfAccXcycleMeasurementInProgress)
    {
        return IX_PERFPROF_ACC_STATUS_XCYCLE_MEASUREMENT_IN_PROGRESS;
    }

    /*
     * No measurement has been performed
     */
    if (0 == ixPerfProfAccTotalMeasurementMade)
    {
        return IX_PERFPROF_ACC_STATUS_FAIL;
    }

    /*
     * Compute average, minimum and maximum percentage from measurement
     * made.
     */
    for (i = 0 ; i < ixPerfProfAccTotalMeasurementMade ; i ++)
    {
        duration = ixPerfProfAccXcycleResults[i].xcycleCountStop -
            ixPerfProfAccXcycleResults[i].xcycleCountStart;

        fPercentage = ((float)ixPerfProfAccXcycleCurrentBaseline /
            (float)IX_PERFPROF_ACC_XCYCLE_TIME_SLICES_PER_SEC) /
            ((float)duration/ ixPerfProfAccXcycleResults[i].totalTimeSlices)
            * 100.00f;  /* covert to percentage by multiplying with 100 */

        fPercentageTotal += fPercentage;

        if ( fPercentage > fPercentageMax)
        {
            fPercentageMax = fPercentage;
        }

        if (fPercentage < fPercentageMin)
        {
            fPercentageMin = fPercentage;
        }
    } /* end for i loop */

    xcycleResult->maxIdlePercentage = fPercentageMax;
    xcycleResult->minIdlePercentage = fPercentageMin;
    xcycleResult->aveIdlePercentage = fPercentageTotal/
        (float)ixPerfProfAccTotalMeasurementMade;
    xcycleResult->totalMeasurements = ixPerfProfAccTotalMeasurementMade;
    return IX_PERFPROF_ACC_STATUS_SUCCESS;
} /* end of ixPerfProfAccXcycleResultsGet() */

PUBLIC BOOL
ixPerfProfAccXcycleInProgress (void)
{
    return (ixPerfProfAccXcycleMeasurementInProgress);
} /* end of ixPerfProfAccXcycleInProgress() */