CC2538: Detecting CPU Utlization

Hi,

I did an analysis like this a while back for Z-Stack 1.2.2a, I will copy it below. Numbers for Z-Stack 3.0.1 should be very similar, the main differences between these two stacks are during the NWK commissioning procedure, which is a one-time process for a node joining a new network.

Here are the results of the CPU load tests I ran on the 1.2.2a stack. My setup was 2 SmartRF06 + CC2538EM.

Test 1: (Measuring ZC SampleLight, ZED SampleSwitch sending continuous 100ms toggle)
osal_systemClock: 136902
cpuUsageAccumulator: 20255
% utilized: 14.8%

Test 2: (Measuring ZC SampleLight, ZED SampleSwitch sending continuous 30ms toggle)
osal_systemClock: 94648
cpuUsageAccumulator: 41031
% utilized: 43.3%

Test 3: (Measuring ZC SampleSwitch, ZC SampleSwitch sending continuous 30ms toggle to ZR SampleLight)
osal_systemClock: 72448
cpuUsageAccumulator: 2633
% utilized: 3.6%

From these results, we can see that a device that is receiving commands utilizes much more of the CPU than a device that is transmitting commands. Keep in mind that sending toggle commands every 100ms or 30ms is probably unrealistically fast for a real application, but the point of this test was to see how the CPU performs under a heavy load.

Code modifications made for the test:

I added the following code to OSAL.c in the osal_run_system() loop (lines with +):

+ timeStamp1 = osal_GetSystemClock();

do {
if (tasksEvents[idx]) // Task is highest priority that is ready.
{
break;
}
} while (++idx < tasksCnt);

if (idx < tasksCnt)
{
uint16 events;
halIntState_t intState;

HAL_ENTER_CRITICAL_SECTION(intState);
events = tasksEvents[idx];
tasksEvents[idx] = 0; // Clear the Events for this task.
HAL_EXIT_CRITICAL_SECTION(intState);

activeTaskID = idx;
events = (tasksArr[idx])( idx, events );
activeTaskID = TASK_NO_TASK;

HAL_ENTER_CRITICAL_SECTION(intState);
tasksEvents[idx] |= events; // Add back unprocessed events to the current task.
HAL_EXIT_CRITICAL_SECTION(intState);

+ // CPU load testing
+ timeStamp2 = osal_GetSystemClock();
+ cpuUsageAccumulator += timeStamp2 - timeStamp1;
}

In Z-Stack, osal_run_system() is the function that is executed in the system's infinite loop, and each iteration through this function will execute the next pending task, if there is a pending task. Basically, if there is not a pending task, we do not enter the if() statement above, and the CPU will not be utilized by the stack during that iteration. If there is a pending task, we enter the if() statement and the next pending task is executed by (tasksArr[idx])( idx, events ).

To measure the CPU usage by the stack, I take a "timestamp" (osal_GetSystemClock() returns the current system tick in ms) each time I enter the osal_run_system() loop before any pending task is executed, and if there is a pending task, I take another timestamp after it has finished. The difference between these two timestamps is the amount of system time that the CPU was used to execute the stack task during this iteration, and I keep track of all this time by adding it to the cpuUsageAccumulator variable.

Let me know if you have any other questions.