09 Control Flow

1. Introduction to Control Flow

1.1 What is Control Flow?

Control flow refers to the order in which the instructions in a program are executed. Control flow structures allow you to branch or loop through code based on conditions, making your program more dynamic and adaptable.

1.2 Importance in Embedded Systems

In embedded systems, control flow is critical for managing real-time operations, responding to events, and optimizing system resources. Efficient control flow is necessary to meet timing constraints and ensure system reliability.

2. Conditional Statements

if, else if, else

If you don't know what an if statement is, you probably shouldn't be reading this guide.

Ternary operator (? :)

The ternary operator is a shorthand way to perform conditional assignments.

int result = (condition) ? value_if_true : value_if_false;

switch statement

The switch statement allows you to execute one of many code blocks based on the value of an expression.

switch (expression) {
    case value1:
        // Code block 1
    break;
    case value2:
        // Code block 2
    break;
    default:
        // Code block if no case is matched
}

This way, you can manage multiple conditions more efficiently than using a chain of if-else statements.

3. Optimization Techniques

3.1 Branch Prediction

Modern CPUs use branch prediction to guess the outcome of conditional statements and preload subsequent instructions to improve efficiency. Although the hardware often handles this, you can optimize your code for better branch prediction by placing the most likely conditions first.

if(likely_condition) {
    // Code block
} else {
    // Less likely to execute
}

3.2 Loop Unrolling

As mentioned earlier, loop unrolling increases the number of operations in the loop body while reducing the overhead of the loop control code. This is particularly useful in time-critical sections of embedded systems.

// Unrolled loop
for(int i = 0; i < 10; i+=4) {
    array[i] = i;
    array[i+1] = i+1;
    array[i+2] = i+2;
    array[i+3] = i+3;
}

However, this technique can increase code size and reduce cache performance, so it's not always the best option. Let the compiler do the work for you and only unroll loops when necessary.

3.3 Conditional Compilation

Sometimes, you'll want to include or exclude code based on compile-time conditions. This can be achieved through preprocessor directives like #ifdef and #ifndef.

#ifdef DEBUG_MODE
    printf("Debugging enabled\n");
#endif

4. Special Keywords in C for Embedded Systems

Embedded systems often deal with constrained resources, real-time requirements, and specific hardware characteristics. Hence, the use of special keywords can help write more efficient, robust, and maintainable code. Two such important keywords in C are static_assert and _Generic.

`static_assert`

The static_assert keyword allows you to insert assertions directly into the code that will be checked at compile time. This is an essential tool for catching issues before the code even gets onto the hardware. It can be particularly useful for:

Verifying assumptions about data sizes, which is critical when moving between platforms with different word sizes.

static_assert(sizeof(int) == 4, "This code assumes 4-byte integers");

Confirming hardware assumptions like register layouts or specific memory locations.

static_assert(MY_REGISTER_OFFSET < 1024, "Invalid register offset");

Enforcing coding guidelines, such as ensuring that a struct doesn't exceed a certain size.

static_assert(sizeof(myStruct) <= 128, "myStruct is too big");

`generic`

The _Generic keyword provides a way to implement type-generic macros or functions. It's especially useful in making your code more modular and reusable. You can use it for:

Creating type-independent utility functions. For instance, the myabs() macro works for int, float, and double.

#define myabs(x) _Generic((x), int: abs(x), float: fabsf(x), double: fabs(x))

Implementing type-safe wrappers around hardware operations where you might need to deal with various data types.

#define read_register(type, addr) _Generic((type), int: read_int_reg(addr), float: read_float_reg(addr))

Simplifying error handling by writing generic error-handling macros or routines.

#define log_error(x) _Generic((x), int: log_int_error(x), const char*: log_str_error(x))

5. Control Flow Keywords: `goto` and `do-while` in Embedded Systems

When programming embedded systems, you're often required to deal with low-level hardware interactions, error handling, and performance-critical code. This sometimes calls for unconventional control flows that the basic for, while, and if-else structures can't handle effectively. Two such control flow constructs are goto and do-while.

`goto`

The goto statement allows you to jump to another point in the function. It's often shunned for making code less readable and maintainable, but in embedded systems, it has some legitimate use-cases:

Error Handling: In a function with multiple resource allocations or initialization steps, goto can help in cleaning up efficiently when an error occurs.

int my_function() {
    int err = allocate_resource1();
    if (err) goto cleanup;

    err = allocate_resource2();
    if (err) goto cleanup_resource1;

    // Do something useful

cleanup_resource1:
    free_resource1();

cleanup:
    return err;
}

State Machines: In the absence of higher-level abstractions, goto can be used to create state machines.

void state_machine() {
start_state:
    // Do something
    goto next_state;

next_state:
    // Do something else
    goto start_state;
}

`do-while`

The do-while loop is an exit-condition loop, which means that it always executes its block at least once. This is particularly useful for:

Polling Hardware: When you need to check a hardware register repeatedly until a specific condition is met.

do {
    val = read_register();
} while (val == 0);

Post-Processing: Sometimes, you need to process data at least once and then check for conditions.

do {
    process_data();
} while (more_data_available());

Both goto and do-while are indispensable tools when used wisely in the context of embedded systems. They can make your code more efficient and suited to the unique challenges posed by resource-constrained and real-time environments. However, they should be used judiciously and commented adequately to maintain code readability and maintainability.

6. Q&A

1. Question: Explain how the static_assert directive can be used to enforce compile-time conditions.

Answer: static_assert allows for compile-time assertion checks. This is especially useful in embedded systems, where certain conditions like data type sizes or configuration parameters need to be verified during compile time to ensure correct system behavior. Example:

static_assert(sizeof(int) == 4, "Integers are not 4 bytes on this platform!");

If the condition fails, a compile-time error will be triggered with the given message.

2. Question: What's the key difference between switch and generic in C?

Answer: While both switch and generic provide a form of conditional branching, they operate differently: - switch tests integer or enumerated values against cases. - generic is introduced in C11 and is a way to perform selection based on the type of an expression, not its value. It's useful for writing type-generic macros.

3. Question: In what situations would using goto be considered good practice in C?

Answer: While goto is often discouraged because it can lead to unreadable or spaghetti code, there are specific scenarios where it's beneficial: - For error handling in a function with multiple points of failure where resources need to be cleaned up. - Breaking out of deeply nested loops.

4. Question: How can the do-while loop be advantageous over the regular while loop?

Answer: A do-while loop ensures that the loop body executes at least once since the condition is checked after executing the loop body. This is useful when the loop's action must be performed at least once before checking the continuation condition.

5. Question: Discuss how "loop unrolling" can optimize loops.

Answer: Loop unrolling is a technique where the number of iterations of a loop is decreased by increasing the number of operations in the loop body. This reduces the overhead of the loop control code. Especially in embedded systems, where cycles are precious, loop unrolling can help achieve faster execution times at the expense of increased code size.

6. Question: What is Duff's device in the context of control flow?

Answer: Duff's device is an optimized technique used for copying memory in C using loop unrolling combined with a switch statement. It's an example of how you can intermix a switch and a loop structure to achieve more efficient operations.

7. Question: How do you handle multiple conditions in a switch statement?

Answer: You can use "fall through" behavior in C's switch statement. When one case doesn't have a break at the end, it'll "fall through" to the next case.

switch(value) {
    case 1:
    case 2:
        // action for both 1 and 2
        break;
    default:
        // default action
}

8. Question: Explain the concept of "short-circuit evaluation" in C.

Answer: Short-circuit evaluation is when the second operand in logical AND (&&) or OR (||) operations is evaluated only if necessary. For instance, in the expression (x == 0) || (y / x > 1), the second condition will not be evaluated if x is 0 since the entire expression's value can be determined from the first condition.

9. Question: How can you prevent an if condition from being optimized out by the compiler?

Answer: To prevent compiler optimization on specific variables, you can declare them as volatile. This tells the compiler that the variable can change unexpectedly, so it won't optimize away any checks involving that variable.

10. Question: What's the use of the _Generic keyword introduced in C11?

Answer: The _Generic keyword allows for type-generic programming in C. It selects one of the expressions based on the type of a controlling expression, providing a way to simulate function overloading in C.

For instance:

#define cbrt(X) _Generic((X), long double: cbrtl, \
                          default: cbrt, \
                          float: cbrtf)(X)

This chooses the appropriate cube root function based on the type of X.

11. Question: Describe a scenario in embedded systems where you'd prefer using goto instead of a structured loop or conditional.

Answer: One common scenario in embedded systems for using goto is in error handling. If there are multiple resources being allocated or multiple conditions being checked, and if any of them fails, you might need to clean up the resources. Instead of having multiple nested if statements with repeated cleanup code, a goto can be used to jump to a cleanup or error handling label.

12. Question: What are the dangers of relying too heavily on switch case "fall through"?

Answer: Over-reliance on fall-through can make code hard to read and maintain. If someone else modifies the code later, they might inadvertently break the intended flow by inserting a break statement or reordering the cases. Also, without comments, the intended behavior might not be clear to other developers.

13. Question: Why would you use static_assert in an embedded system?

Answer: static_assert is used for compile-time assertions. In embedded systems, where specific hardware constraints must be met, static_assert can be used to ensure conditions like data type sizes or alignment requirements are met at compile time.

14. Question: Explain a situation where the do-while loop would be more appropriate than a while loop.

Answer: do-while is preferred when you want the loop body to execute at least once regardless of the condition. For instance, reading a sensor value until a valid reading is obtained.

15. Question: What is the difference between if-else if-else chains and switch-case?

Answer: if-else if-else chains evaluate boolean expressions sequentially, whereas switch-case tests a variable against constant values. The switch-case structure can be more efficient in some scenarios due to jump table optimizations, but it's limited to integer or enumerated types. if-else chains are more flexible in terms of conditions but can be less efficient with long chains.

16. Question: How would you avoid "magic numbers" in your conditional logic?

Answer: Magic numbers can be avoided by using named constants (#define or const variables) or enumerations. This makes the code more readable and easier to maintain because the named constants provide context.

17. Question: In what situation would you avoid using loop unrolling as an optimization technique?

Answer: While loop unrolling can speed up the execution, it also increases code size. In embedded systems with limited memory, the increased code size might not be desirable. So, one would avoid loop unrolling when memory space is more critical than execution speed.

18. Question: Why is short-circuit evaluation important to be aware of in embedded systems?

Answer: In embedded systems, certain operations might have side effects. For instance, reading a register value might clear it. If we rely on short-circuiting behavior, and the first condition in an && or || operation makes the overall result evident, the second condition might never be evaluated, and those side effects would not occur. Being aware of this ensures that the code behaves as intended.

19. Question: How can the generic keyword be useful in creating type-independent macros in C?

Answer: The generic keyword allows selection of an expression based on the type of a given controlling expression. This enables the creation of macros that work across different data types by selecting the appropriate function or expression based on the data type, simulating a form of function overloading.

20. Question: What could be a potential issue with deeply nested control structures, and how would you mitigate it?

Answer: Deeply nested control structures can make code hard to read and maintain. It can also increase the risk of errors as it becomes challenging to track the various conditions and loops. To mitigate this, one can: - Use helper functions to break down complex logic. - Avoid excessive branching by using lookup tables or other techniques. - Refactor the code to simplify the logic.

21. Question: Consider the following code:

#define TIMEOUT 1000
unsigned long currentTime = 0;
unsigned long previousTime = 0;

// ... some code ...

if (currentTime - previousTime > TIMEOUT) {
    // Do something
}

What potential issue might arise from this logic when dealing with timer overflows?

Answer: The potential issue is timer overflow. If currentTime overflows and wraps around, the subtraction will produce an incorrect result. However, the logic is inherently safe against overflow if both variables are of unsigned type due to the properties of modular arithmetic. It will still give the correct duration even when currentTime wraps around.

22. Question: What is the problem with the following:

for (float i = 0.0; i != 1.0; i += 0.1) {
    // Do something
}

Answer: Floating point representation isn't exact for all numbers, and 0.1 cannot be precisely represented. This loop might either miss the termination condition or might never reach 1.0 at all, becoming an infinite loop.

23. Question: Why might you use the inline keyword in a function and how does it relate to embedded systems optimization?

Answer: Using inline suggests to the compiler that the function's body should be placed inline where the function is called, eliminating the function call overhead. In embedded systems, where every cycle can count, this can be an optimization. However, excessive inlining can also increase code size.

24. Question: Consider this piece of code:

switch(variable) {
    case 1: 
        foo();
    case 2:
        bar();
        break;
}

What would happen if variable is 1?

Answer: If variable is 1, both foo() and bar() will be executed due to the lack of a break statement after the foo() call, causing a "fall through".

25. Question: How would you refactor the following piece of code for better readability and performance?

if (isTrue(a) == 1) {
    if (isTrue(b) == 1) {
        if (isTrue(c) == 1) {
            executeFunction();
        }
    }
}

Answer: The code can be refactored using logical ANDs:

if (isTrue(a) && isTrue(b) && isTrue(c)) {
    executeFunction();
}

26. Question: In the context of embedded systems, how would you implement a state machine using switch-case?

Answer: A state machine can be implemented by defining an enumeration for states, using a variable to hold the current state, and then using a switch-case to process each state:

typedef enum { STATE_INIT, STATE_RUN, STATE_STOP } State_t;
State_t currentState = STATE_INIT;

// In some function or loop:
switch (currentState) {
    case STATE_INIT:
        // Initialization code
        currentState = STATE_RUN;
        break;
    case STATE_RUN:
        // Running code
        // Transitions to other states based on conditions
        break;
    case STATE_STOP:
        // Stop or cleanup code
        break;
}

27. Question: How can static_assert be used to enforce struct size in embedded C?

Answer: To ensure that a struct doesn't exceed a certain size, you could use static_assert like this:

typedef struct {
    int a;
    char b;
    float c;
} MyStruct;

static_assert(sizeof(MyStruct) <= 16, "MyStruct is too large!");

28. Question: How can you ensure that a specific block of code is executed atomically in embedded C?

Answer: One common way to ensure atomicity is by disabling interrupts before the critical section and re-enabling them afterward:

disableInterrupts();
// Critical section
enableInterrupts();

29. Question: How would you write a loop in C that runs exactly seven times without using any literal or variable for the count?

Answer: A trick could be using an array and looping through its size:

for (char _unusedArray[7], *p = _unusedArray; p < &_unusedArray[7]; ++p) {
    // Code to be executed
}

30. Question: In embedded systems, why might recursion be discouraged, and how can you implement a factorial function without using recursion?

Answer: Recursion can lead to stack overflow, especially in embedded systems with limited stack memory. A non-recursive factorial function can be:

unsigned long factorial(unsigned int n) {
    unsigned long result = 1;
    for (unsigned int i = 1; i <= n; ++i) {
        result *= i;
    }
    return result;
}

31. Question: Examine the following code:

if (x = 10) {
    // Do something
}

What's wrong?

Answer: The code is using an assignment (=) instead of a comparison (==). The statement will always evaluate as true since x is assigned the value 10. It should be if (x == 10).

32. Question: Here's a piece of code:

switch(x) {
    case 1: foo();
    case 2: bar();
    break;
}

What's the potential issue?

Answer: There's a fall-through in the switch-case. If x is 1, both foo() and bar() will be executed. Each case should generally end with a break to prevent unintended behavior.

33. Question: Inspect this code snippet:

do {
    // Code
} while(x > 0);

Is there a potential issue here?

Answer: If x isn't modified within the loop, this will become an infinite loop when x is initially greater than 0.

34. Question: Consider this:

for (int i = 0; i < 10; i++);
{
    printf("%d\n", i);
}

What's wrong?

Answer: There's a semicolon after the for loop definition, which makes the loop body empty and the printf statement outside of the loop. Also, i will be out of scope outside the loop.

35. Question: Look at this code:

int x = 10;
if (x > 5)
    printf("Greater");
    printf(" than 5");

What's the issue?

Answer: There's a logical error. Without braces, only the first printf is inside the if statement. This will print "Greater" and then "than 5" regardless of x's value.

36. Question: What's wrong with this?

goto labelA;
labelB:
    // Some code
labelA:
    // Some other code
goto labelB;

Answer: It creates an infinite loop without any conditions. It will continuously jump between labelA and labelB.

37. Question: Observe the following:

int x = 0;
while(++x < 5);
{
    printf("%d", x);
}

What will this print?

Answer: The loop has a semicolon at the end, making its body empty. The printf statement is not inside the loop. It will print 5.

38. Question: Consider this code:

#define SQUARE(a) a * a

int y = SQUARE(1 + 2);

What's the potential problem here?

Answer: Macro replacement will result in 1 + 2 * 1 + 2 which is 5, not 9 as might be expected. Parentheses should be used in the macro definition: #define SQUARE(a) ((a) * (a)).

39. Question: Here's a piece of code:

int x = 10;
if (x & 2 == 2) {
    // Some code
}

What might be the issue?

Answer: The == operator has higher precedence than the & operator. It should be wrapped with parentheses for clarity and correctness: if ((x & 2) == 2).

40. Question: Inspect this snippet:

if (x > 10)
    x++;
else if (x < 5)
    x--;
else
    x = 0;

What's the logical error?

Answer: There isn't a logical error, but there is redundancy. If x is greater than 10, the second condition will never be true. Thus, the else attached to the second condition is unnecessary and can be removed for clarity.

41. Question: Check out this code snippet:

while (x > 0)
    x--;
    y++;

What's the problem?

Answer: Due to the absence of braces {}, only x-- is inside the while loop. The statement y++ will execute only once after the loop finishes.

42. Question: Look at this:

for (int i = 0; i < 10; i++);
{
    // Some code
}

What's the issue?

Answer: There's an unnecessary semicolon after the for loop. It means the loop will execute with an empty body, and the code inside the curly braces will run just once, outside the loop.

43. Question: Observe the following code:

if (x = 5)
    printf("x is 5");

What might go wrong?

Answer: The = is an assignment, not a comparison. This code will set x to 5 and always print "x is 5". It should be if (x == 5).

44. Question: Consider this:

switch(x) 
{
    case 1:
        y = 10;
    case 2:
        y = 20;
    default:
        y = 30;
}

What's the issue here?

Answer: There's a fall-through between the cases. If x is 1, y will be set to 20 because there's no break statement before case 2.

45. Question: Look at this snippet:

if (x > 10)
    printf("Greater than 10");
else if (x < 5);
{
    printf("Less than 5");
}

What's wrong?

Answer: There's an unintended semicolon after the second if statement, making its body empty. The printf("Less than 5") statement will always execute, regardless of x's value.

46. Question: Consider the following:

int x = 5;
if (x & 2 == 2)
    printf("Bit set");

What's the potential issue?

Answer: The == operator has higher precedence than the & operator. It should be if ((x & 2) == 2) for correct evaluation.

47. Question: Look at this:

do {
    x++;
} while (x = 10);

What's the problem?

Answer: The condition in the while uses =, an assignment, instead of ==, a comparison. This code will set x to 10 and exit the loop immediately.

48. Question: Examine this code:

#define MULTIPLY(a, b) a * b

int result = MULTIPLY(1 + 2, 3);

What will result be and why?

Answer: Macro expansion will lead to the expression 1 + 2 * 3, which equals 7 due to operator precedence. The correct macro definition should be #define MULTIPLY(a, b) ((a) * (b)).

49. Question: Check this out:

if (x > y)
else
    printf("y is greater or equal");

What's wrong?

Answer: There's an if statement without any corresponding code block, making the code syntactically incorrect.

50. Question: Look at this snippet:

for (int i = 0; i < 10; i++)
    int x = i;

What's the mistake?

Answer: Variable declarations are not allowed as the sole statement in a loop or conditional without braces. The code will throw a compile-time error.

09 Control Flow

1. Introduction to Control Flow

1.1 What is Control Flow?

1.2 Importance in Embedded Systems

2. Conditional Statements

if, else if, else

Ternary operator (? :)

switch statement

3. Optimization Techniques

3.1 Branch Prediction

3.2 Loop Unrolling

3.3 Conditional Compilation

4. Special Keywords in C for Embedded Systems

static_assert

generic

5. Control Flow Keywords: goto and do-while in Embedded Systems

goto

do-while

6. Q&A

`static_assert`

`generic`

5. Control Flow Keywords: `goto` and `do-while` in Embedded Systems

`goto`

`do-while`