RTOS Interview Questions for Experienced Engineers

Hard real-time: Missing a deadline is a system failure. The consequences are catastrophic — physical harm, financial loss, or system crash. Examples: airbag deployment ECU, pacemaker, anti-lock braking system. A 1ms deadline missed could mean no airbag deployment.

Soft real-time: Missing a deadline degrades performance but does not cause catastrophic failure. Examples: audio/video streaming, UI responsiveness. A dropped audio frame causes a glitch, not a crash.

Firm real-time (less common in interviews): The result is useless if the deadline is missed but the system still runs. Example: weather radar — an outdated reading is discarded.

Priority inversion occurs when a high-priority task is blocked waiting for a resource held by a low-priority task, and a medium-priority task preempts the low-priority task — effectively inverting the intended priority order.

Classic scenario:

1. Low-priority task (L) acquires a mutex.
2. High-priority task (H) tries to acquire the same mutex → blocks.
3. Medium-priority task (M) becomes ready → preempts L (since M > L).
4. H is now blocked indefinitely waiting for L, which can't run because M is running.

Solution — Priority Inheritance: FreeRTOS mutexes (xSemaphoreCreateMutex()) implement priority inheritance. When H blocks on a mutex held by L, L's priority is temporarily raised to H's priority, preventing M from preempting L.

/* Priority Inheritance happens automatically with mutexes */
SemaphoreHandle_t xMutex = xSemaphoreCreateMutex();

/* Low priority task holds mutex — its priority is raised */
/* when a higher priority task blocks on the same mutex  */
xSemaphoreTake(xMutex, portMAX_DELAY);
/* critical section */
xSemaphoreGive(xMutex); /* priority restored here */

FreeRTOS tasks exist in one of four states:

State transitions: Running → Ready (preempted by higher priority) → Blocked (waits for resource) → Ready (event occurs) → Running (scheduler selects it).

A counting semaphore maintains a count that can range from 0 to a maximum value. Give increments the count; Take decrements it and blocks when count is 0.

Use cases:

• Resource pool management: 3 DMA channels available — counting semaphore initialized to 3. Tasks take one before using DMA, give it back when done.
• Event counting from ISR: Multiple ISR events fired before the task runs — counting semaphore ensures none are missed (unlike binary semaphore which saturates at 1).
• Producer-consumer with bounded buffer: Track number of available slots and number of filled slots.

/* Resource pool: 3 DMA channels */
SemaphoreHandle_t xDMASem = xSemaphoreCreateCounting(3, 3);

/* Acquire a DMA channel */
xSemaphoreTake(xDMASem, portMAX_DELAY);
/* use DMA... */
xSemaphoreGive(xDMASem); /* release */

Cortex-M supports interrupt nesting — a higher-priority interrupt can preempt a lower-priority ISR. FreeRTOS uses configMAX_SYSCALL_INTERRUPT_PRIORITY (also called configLIBRARY_MAX_ISR_PRIORITY) to define a safe boundary.

• Interrupts with priority at or below configMAX_SYSCALL_INTERRUPT_PRIORITY can safely call FreeRTOS FromISR() APIs.
• Interrupts with priority above this threshold must NOT call any FreeRTOS API — they are "RTOS-unaware" and can preempt FreeRTOS itself.

Jitter is the variation in timing of a periodic event — the difference between the intended and actual execution time of a task. In a 100ms periodic task, if it sometimes runs at 99ms and sometimes at 103ms, the jitter is ±3ms.

Sources of jitter in RTOS systems:

• Interrupt latency variability (longer ISRs delay task resumption)
• Higher-priority task interference
• Cache misses and bus contention
• Using vTaskDelay() instead of vTaskDelayUntil()
• Dynamic memory allocation (non-deterministic malloc)

Minimization strategies:

• Use vTaskDelayUntil() for periodic tasks
• Keep ISRs short (deferred processing)
• Assign appropriate priorities — critical tasks get highest priority
• Avoid dynamic memory allocation in time-critical paths
• Use a hardware timer interrupt directly for microsecond-level precision

FreeRTOS provides built-in run-time statistics. Enable them in FreeRTOSConfig.h:

/* Enable run-time stats */
#define configGENERATE_RUN_TIME_STATS        1
#define configUSE_STATS_FORMATTING_FUNCTIONS 1

/* Provide a high-resolution timer (10-100x faster than tick) */
#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS()  initStatsTimer()
#define portGET_RUN_TIME_COUNTER_VALUE()          getStatsTimerCount()

/* Print CPU usage of all tasks */
char statsBuffer[512];
vTaskGetRunTimeStats(statsBuffer);
printf("%s", statsBuffer);

/* Output example:
Task          Runtime     Percentage
SensorTask    45823       46%
UARTTask      22100       22%
IdleTask      30500       30%
*/