⚡ Embedded Modern C++ Section 4 • #4.04
Portal Home / Section 4 / Project 4.04: TwiceNumbers
Project 4.04 Section 4 ⚡ Embedded Relevance: Core In-Place Mutation SIMD ARM DSP Data Hazards Cache Locality

4.04 In-Place Array Mutation, Data Hazards & Microcontroller SIMD Instructions

Executive Summary: Populating arrays through algorithmic generation and mutating elements in place. We explore ARM Cortex-M4/M7 DSP SIMD instructions (e.g. SADD16, PKHBT) that process multiple array elements in a single clock cycle.

💻 1. Annotated Source Code 

#include <iostream>
#include <array>
using namespace std;

int main() {

	array<int, 10> myNums;

	for (int i = 0; i < myNums.size(); i++) {
		myNums[i] = i * 2;
	}

	for (int element : myNums) {
		cout << element << endl;
	}

	return 0;
}

📐 2. Architecture & UML Class Model

📐 Array Element Transformation & SIMD Scaling Model
+ Public - Private # Protected
<<compilation-unit>> ArrayTransformer Transformation Engine
Attributes / Data Members
-numbers[5] : int32_t
Operations / Methods
+doubleElements(arr: int*, size: size_t) : void
+printArray(arr: const int*, size: size_t) : void

📚 3. Core C++ Concepts Deep-Dive

1. In-Place Transformation

In-place mutation updates array elements directly in their existing memory locations (arr[i] *= 2), requiring $O(1)$ auxiliary memory.

2. Contiguous Access and Vectorization

Sequential memory access allows modern compilers to auto-vectorize loops, generating SIMD (Single Instruction Multiple Data) machine instructions.

⚡ 4. Embedded Systems & Hardware Reality

1. ARM Cortex-M4/M7 DSP SIMD Extensions

ARM Cortex-M4 and M7 cores include hardware DSP instructions that operate on packed 16-bit or 8-bit integers inside a 32-bit register simultaneously (e.g. two 16-bit multiplications in 1 cycle).

2. Memory Alignment for Vector Loads

SIMD vector load/store instructions require 4-byte or 8-byte aligned addresses. Unaligned data forces the CPU into slower multiple load cycles.

💡 5. Production-Ready Embedded Refactoring

In-place scaling using modern C++ algorithms:

💡 Production-Ready Refactor 
#include <cstdint>
#include <array>
#include <algorithm>

template <size_t N>
void doubleValues(std::array<uint32_t, N>& arr) noexcept {
    std::transform(arr.begin(), arr.end(), arr.begin(), [](uint32_t val) {
        return val * 2;
    });
}

📝 Knowledge Verification Quiz

Test your understanding of the C++ concepts and embedded microcontroller trade-offs covered in this guide. Click any option for instant feedback.

Q1. What is 'SIMD' in microcontroller CPU architectures?
A Single Instruction Multiple Data: performing the same arithmetic operation on multiple data elements in a single clock cycle
B System Interrupt Memory Dispatcher
C Serial Interface Mode Driver
D Synchronous Instruction Multiplexer
Detailed Explanation: SIMD instructions allow a single CPU instruction to compute operations on multiple packed data values (e.g., two 16-bit integers in one 32-bit register) in parallel.
Q2. What is the memory complexity of transforming an array in-place?
A O(1) auxiliary memory space
B O(N) memory space
C O(N^2) memory space
D O(log N) memory space
Detailed Explanation: In-place algorithms modify the input array directly without allocating extra buffers, requiring $O(1)$ auxiliary memory.
Q3. Which ARM Cortex-M processor family first introduced hardware DSP and SIMD instructions?
A ARM Cortex-M4 / Cortex-M7
B ARM Cortex-M0
C ARM Cortex-M0+
D ARM Cortex-M3
Detailed Explanation: The ARM Cortex-M4 and M7 architectures feature dedicated hardware DSP extensions and packed SIMD instructions.
Q4. Why is sequential array access faster than random array access on cached microcontrollers?
A Sequential access maximizes spatial cache locality, loading full cache lines that satisfy upcoming reads without memory stalls
B Sequential access bypasses the memory bus
C Random access turns off CPU clock gating
D Random access causes the CPU to overheat
Detailed Explanation: CPUs fetch memory in multi-byte cache lines (e.g. 32 bytes). Sequential access hits cached data on consecutive iterations, avoiding high-latency RAM reads.