AM263P4-Q1: Get runtime in microsec order

Okay, let's break down these questions about TaskP_loadGet and task run time.

Yes, the runTime field within the TaskP_Load struct represents the accumulated run time of the task in microseconds.

• Looking at the TaskP_Load struct definition:

typedef struct {

    const char  *name;     /**< Name of the task */
    uint64_t runTime;   /**< Amount of time the task has run, units of usec */
    uint64_t totalTime; /**< Amount of time that has elapsed so far, units of usec */
    uint32_t cpuLoad;   /**< CPU load in units of percentage with 2 decimal point precision, i.e 1234 means 12.34% */

} TaskP_Load;

• The calculation within TaskP_loadGet populates this field using taskObj->accRunTime:

    taskLoad->runTime = taskObj->accRunTime;

• taskObj->accRunTime is updated in TaskP_updateLoad by calculating the difference (delta) between consecutive readings of the FreeRTOS run time counter for the task.

static void TaskP_updateLoad(TaskP_Struct *taskObj)
{
#ifndef SMP_FREERTOS
#if (configGENERATE_RUN_TIME_STATS == 1)
    uint32_t runTimeCounter = ulTaskGetRunTimeCounter(taskObj->taskHndl);

    uint32_t delta = TaskP_calcCounterDiff(runTimeCounter, taskObj->lastRunTime);

    taskObj->accRunTime += delta;
    taskObj->lastRunTime = runTimeCounter;
#endif
#else
    uint32_t delta;
    TaskStatus_t taskStatus;

    vTaskGetInfo(taskObj->taskHndl, &taskStatus, pdFALSE, eReady);

    delta = TaskP_calcCounterDiff(taskStatus.ulRunTimeCounter, taskObj->lastRunTime);

    taskObj->accRunTime += delta;
    taskObj->lastRunTime = taskStatus.ulRunTimeCounter;
#endif
}

• The FreeRTOS run time counter itself (ulTaskGetRunTimeCounter or taskStatus.ulRunTimeCounter) relies on portGET_RUN_TIME_COUNTER_VALUE(), which is implemented via uiPortGetRunTimeCounterValue(). This function, in the provided ports, uses ClockP_getTimeUsec():

uint32_t uiPortGetRunTimeCounterValue()
{
    uint64_t timeInUsecs = ClockP_getTimeUsec();

    /* note, there is no overflow protection for this 32b value in FreeRTOS
     *
     * This value will overflow in
     * ((0xFFFFFFFF)/(1000000*60)) minutes ~ 71 minutes
     *
     * We call vApplicationLoadHook() in idle loop to accumlate the task load into a 64b value.
     * The implementation of vApplicationLoadHook() is in source\kernel\freertos\dpl\common\TaskP_freertos.c
     */
    return (uint32_t)(timeInUsecs);
}

(Similar implementations exist in other port.c files like source/kernel/freertos/portable/TI_ARM_CLANG/ARM_CR5F/port.c)

• ClockP_getTimeUsec() is designed to return the time in microseconds.
  

Therefore, the runTime field accumulates the task's execution time measured in microseconds.

No, the measurement itself is not limited to a 500ms granularity or duration.

• TaskP_LOAD_UPDATE_WINDOW_MSEC defines the interval at which the TaskP_loadUpdateAll function is typically called from the vApplicationLoadHook (which usually runs within the FreeRTOS Idle task).

void vApplicationLoadHook(void)
{
    static uint64_t lastUpdateTime = 0;
    uint64_t curUpdateTime = ClockP_getTimeUsec();

    if( (curUpdateTime > lastUpdateTime) && ((curUpdateTime - lastUpdateTime) > (TaskP_LOAD_UPDATE_WINDOW_MSEC*1000u )) )
    {
        TaskP_loadUpdateAll();
        lastUpdateTime = curUpdateTime;
    }
}

 * \brief The update rate at which TaskP_loadUpdateAll() is called
 */
#define TaskP_LOAD_UPDATE_WINDOW_MSEC   (500u)

• TaskP_loadUpdateAll updates the internal accumulated run time (taskObj->accRunTime) for all registered tasks based on the underlying microsecond timer.

void TaskP_loadUpdateAll(void)
{
    TaskP_Struct *taskObj;
    uint32_t i;

    vTaskSuspendAll();

    for(i=0; i<TaskP_REGISTRY_MAX_ENTRIES; i++)
    {
        taskObj = gTaskP_ctrl.taskRegistry[i];

        if(taskObj != NULL)
        {
            TaskP_updateLoad(taskObj);
        }
    }

    TaskP_updateIdleTaskLoad();
    TaskP_updateTotalRunTime();
    
    (void)xTaskResumeAll();
}

• When you call TaskP_loadGet, it reads the current value of this accRunTime (potentially forcing an update first if getting the load of the current task, or relying on the last update from the hook).

void TaskP_loadGet(TaskP_Object *obj, TaskP_Load *taskLoad)
{
    TaskP_Struct *taskObj = (TaskP_Struct *)obj;

    if(taskObj->taskHndl == xTaskGetCurrentTaskHandle())
    {
        /* Perform a force yield for the kernel to update the current task run time counter value. */
        taskYIELD();
    }

    vTaskSuspendAll();

    TaskP_updateLoad(taskObj);
    TaskP_updateTotalRunTime();

    taskLoad->runTime = taskObj->accRunTime;
    taskLoad->totalTime  = gTaskP_ctrl.accTotalTime;
    taskLoad->cpuLoad = TaskP_calcCpuLoad(taskObj->accRunTime, gTaskP_ctrl.accTotalTime);
    taskLoad->name = pcTaskGetName(taskObj->taskHndl);

    (void)xTaskResumeAll();
}

• The runTime field in TaskP_Load represents the total accumulated microseconds the task has run since the load statistics were last reset using TaskP_loadResetAll. It's not just the time run in the last 500ms window. The 500ms window only affects how frequently the accumulated value gets refreshed in the background by the hook. The underlying timer resolution is still microseconds.

Akshit Pareek said:

The FreeRTOS run time counter itself (ulTaskGetRunTimeCounter or taskStatus.ulRunTimeCounter) relies on portGET_RUN_TIME_COUNTER_VALUE(), which is implemented via uiPortGetRunTimeCounterValue(). This function, in the provided ports, uses ClockP_getTimeUsec():

Hi Mari,

As mentioned here, the FreeRTOS run time counter uses ClockP_getTimeUsec() under the hood.

So yes, the timing precision should be same!

Regards,
Akshit