Hands-On: Performance Profiling Project

/* Profile CAN signal decode loop using STM hardware counter */
#include 

#define STM_TICKS_PER_US  300u
#define PROFILE_ITERATIONS  1000u

typedef struct {
    uint32_t min_ticks;
    uint32_t max_ticks;
    uint64_t total_ticks;
    uint32_t count;
} PerfProfile_t;

static PerfProfile_t g_decode_profile;

void profile_can_decode(void)
{
    uint8_t test_frame[8] = {0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0};
    CanSignals_t signals;

    g_decode_profile = (PerfProfile_t){UINT32_MAX, 0u, 0u, 0u};

    for (uint32_t i = 0u; i < PROFILE_ITERATIONS; i++) {
        uint32_t t_start = STM0_TIM0;
        Can_DecodeSignals(test_frame, &signals);   /* function under test */
        uint32_t elapsed = STM0_TIM0 - t_start;

        if (elapsed < g_decode_profile.min_ticks) g_decode_profile.min_ticks = elapsed;
        if (elapsed > g_decode_profile.max_ticks) g_decode_profile.max_ticks = elapsed;
        g_decode_profile.total_ticks += elapsed;
        g_decode_profile.count++;
    }

    uint32_t avg = (uint32_t)(g_decode_profile.total_ticks / PROFILE_ITERATIONS);
    /* Report via DID or SWO trace:
       min=%u µs, avg=%u µs, max=%u µs
       values in ticks/300 = µs */
}

/* Before: decode each signal with bit shifts and divisions */
float decode_engine_speed_slow(const uint8_t *data)
{
    uint16_t raw = ((uint16_t)data[3] << 8u) | (uint16_t)data[4];
    return (float)raw * 0.25f;  /* float multiply: 3–20 cycles on softfp */
}

/* After: Q7.8 fixed-point pre-scaled LUT (if range is known) */
/* Or: integer scaling avoiding float */
uint16_t decode_engine_speed_fast_rpm4(const uint8_t *data)
{
    /* Result in units of 0.25 rpm to avoid float — caller scales if needed */
    uint16_t raw = ((uint16_t)data[3] << 8u) | (uint16_t)data[4];
    return raw;  /* raw × 1 in 0.25 rpm units; no multiply needed */
}

/* Bulk decode all signals in one pass (cache-friendly: one pass over data) */
void Can_DecodeSignals_Optimised(const uint8_t *data, CanSignals_t *out)
{
    /* Process all signals in byte order: temporal locality for CPU cache */
    out->engine_speed_rpm4 = ((uint16_t)data[3] << 8u) | (uint16_t)data[4];
    out->vehicle_speed_ms8 = (uint16_t)data[2] | ((uint16_t)data[3] << 8u);
    out->coolant_temp_raw  = data[1];
    out->throttle_pct      = data[0];
    /* Single pass through 8 bytes: all signals decoded with minimal branching */
}

#!/bin/bash
# Verification pipeline: optimisation must not break correctness or MISRA compliance

set -e
echo "=== Step 1: Build and run unit tests ==="
cmake --build build --target unit_tests
./build/unit_tests --reporter compact  # must be 0 failures

echo "=== Step 2: MISRA compliance check ==="
cppcheck --addon=misra.py --misra-c=2012 src/can_decode.c 2>&1 | tee misra_results.txt
MANDATORY=$(grep -c "mandatory" misra_results.txt 2>/dev/null || echo 0)
[ "$MANDATORY" -eq "0" ] || { echo "FAIL: mandatory MISRA violations"; exit 1; }

echo "=== Step 3: Code size check (flash must not grow by >5%) ==="
BASELINE_SIZE=98304   # bytes from before optimisation
CURRENT_SIZE=$(arm-none-eabi-size build/app.elf | awk 'NR==2{print $1}')
MAX_SIZE=$((BASELINE_SIZE * 105 / 100))
[ "$CURRENT_SIZE" -le "$MAX_SIZE" ] || { echo "FAIL: code grew too large"; exit 1; }

echo "=== Step 4: Performance benchmark ==="
# Run on target via JTAG; check profile DID via CAN
# python3 ci/read_profile_did.py --can vcan0 --did 0xFF01 --max-wcet-us 5
echo "All checks PASSED"
echo "Baseline: $BASELINE_SIZE bytes  Current: $CURRENT_SIZE bytes