Compare and branch patterns in ARM Architecture - Time & Space Complexity

Time Complexity: Compare and branch patterns

O(n)

Understanding Time Complexity

When using compare and branch instructions in ARM assembly, it's important to understand how the number of comparisons affects execution time.

We want to see how the program's running time changes as the number of comparisons grows.

Scenario Under Consideration

Analyze the time complexity of the following ARM code snippet.

    MOV R0, #0          ; Initialize counter
LOOP:
    CMP R0, R1          ; Compare counter with limit
    BGE END             ; Branch if counter >= limit
    ADD R0, R0, #1      ; Increment counter
    B LOOP              ; Repeat loop
END:
    

This code counts from 0 up to a limit stored in R1, comparing and branching each time.

Identify Repeating Operations

Look for repeated instructions that affect execution time.

• Primary operation: The compare (CMP) and branch (BGE, B) instructions inside the loop.
• How many times: These run once per loop iteration, which depends on the value in R1.

How Execution Grows With Input

As the limit in R1 increases, the loop runs more times, so the number of compare and branch operations grows.

Input Size (limit in R1)	Approx. Operations (CMP + Branch)
10	About 10 times
100	About 100 times
1000	About 1000 times

Pattern observation: The number of compare and branch operations grows directly with the input size.

Final Time Complexity

Time Complexity: O(n)

This means the execution time increases in a straight line as the number of comparisons grows.

Common Mistake

[X] Wrong: "Branch instructions take constant time regardless of how many times they run."

[OK] Correct: Each branch is executed every loop iteration, so more iterations mean more branches and longer total time.

Interview Connect

Understanding how compare and branch instructions scale helps you reason about loops and conditions in low-level code, a useful skill for many programming and debugging tasks.

Self-Check

"What if the branch instruction was replaced with a conditional execution that avoids branching? How would the time complexity change?"

Practice

1. What is the main purpose of the CMP instruction in ARM assembly?

easy

A. To jump to a different part of the program unconditionally

B. To compare two values and set condition flags

C. To add two numbers and store the result

D. To load a value from memory into a register

Solution

1. Step 1: Understand the role of CMP

   The CMP instruction compares two values by subtracting one from the other without storing the result, but it sets flags based on the outcome.

2. Step 2: Identify what CMP affects

   These flags are then used by conditional branch instructions to decide program flow.

3. Final Answer:

   To compare two values and set condition flags -> Option B

4. Quick Check:

   CMP sets flags for branching decisions [OK]

Hint: CMP sets flags after comparing values for branching [OK]

Common Mistakes:

• Thinking CMP jumps directly
• Confusing CMP with arithmetic instructions
• Assuming CMP stores the subtraction result

2. Which of the following is the correct syntax for a conditional branch in ARM assembly that jumps if two values are equal?

easy

A. BGT label

B. BNE label

C. BEQ label

D. BLT label

Solution

1. Step 1: Recall condition codes for branching

   BEQ stands for 'Branch if Equal', which means it jumps if the zero flag is set after a CMP instruction.

2. Step 2: Match condition with instruction

   BNE means 'Branch if Not Equal', BGT is 'Branch if Greater Than', and BLT is 'Branch if Less Than'. Only BEQ matches the condition for equality.

3. Final Answer:

   BEQ label -> Option C

4. Quick Check:

   BEQ jumps when values are equal [OK]

Hint: BEQ means branch if equal (zero flag set) [OK]

Common Mistakes:

• Using BNE instead of BEQ for equality
• Confusing greater than and equal conditions
• Forgetting to use CMP before branch

3. Given the following ARM assembly code snippet, what will be the value in register r2 after execution?

CMP r0, r1
BEQ equal_label
MOV r2, #0
B end_label
equal_label:
MOV r2, #1
end_label:

Assume r0 = 5 and r1 = 5.

medium

A. Undefined

B. 0

C. 5

D. 1

Solution

1. Step 1: Analyze the CMP and BEQ instructions

   CMP compares r0 and r1. Since both are 5, they are equal, so the zero flag is set. BEQ will branch to equal_label.

2. Step 2: Follow the branch and MOV instructions

   The code jumps to equal_label and executes MOV r2, #1, setting r2 to 1. The instructions after BEQ are skipped.

3. Final Answer:

   1 -> Option D

4. Quick Check:

   Equal values cause BEQ to set r2 to 1 [OK]

Hint: If CMP finds equal, BEQ jumps to set r2=1 [OK]

Common Mistakes:

• Ignoring the branch and setting r2 to 0
• Confusing BEQ with BNE
• Assuming MOV after BEQ always runs

4. Identify the error in this ARM assembly snippet:

CMP r3, r4
BGT greater_label
MOV r5, #10
greater_label:
MOV r5, #20

What is the problem?

medium

A. Missing unconditional branch to skip MOV after BGT

B. CMP instruction is incorrect

C. MOV instructions use wrong registers

D. BGT should be BGE for correct branching

Solution

1. Step 1: Understand the flow of conditional branch

   BGT branches to greater_label if r3 > r4. If not, execution continues to MOV r5, #10.

2. Step 2: Identify missing jump to skip unwanted instruction

   After executing MOV r5, #10, the code falls through to greater_label and executes MOV r5, #20, overwriting the previous value. To avoid this, an unconditional branch is needed after MOV r5, #10.

3. Final Answer:

   Missing unconditional branch to skip MOV after BGT -> Option A

4. Quick Check:

   Need unconditional branch to prevent fall-through [OK]

Hint: Add unconditional branch after conditional MOV to avoid fall-through [OK]

Common Mistakes:

• Thinking CMP is wrong
• Assuming MOV instructions are incorrect
• Confusing BGT with BGE

5. You want to write ARM assembly code that sets r0 to 1 if r1 is less than r2, and to 0 otherwise. Which sequence correctly implements this using compare and branch patterns?

hard

A. CMP r1, r2
BLT set_one
MOV r0, #0
B end
set_one:
MOV r0, #1
end:

B. CMP r1, r2
BGT set_one
MOV r0, #0
B end
set_one:
MOV r0, #1
end:

C. CMP r2, r1
BLT set_one
MOV r0, #0
B end
set_one:
MOV r0, #1
end:

D. CMP r1, r2
BEQ set_one
MOV r0, #0
B end
set_one:
MOV r0, #1
end:

Solution

1. Step 1: Understand the comparison needed

   We want to check if r1 < r2. The CMP instruction compares r1 and r2, setting flags accordingly.

2. Step 2: Use the correct branch condition

   BLT (Branch if Less Than) jumps if r1 < r2. If true, branch to set_one to set r0 to 1. Otherwise, set r0 to 0.

3. Step 3: Confirm the flow

   If BLT is taken, r0 = 1; else r0 = 0. The unconditional branch after MOV r0, #0 skips the set_one label to avoid overwriting.

4. Final Answer:

   CMP r1, r2 BLT set_one MOV r0, #0 B end set_one: MOV r0, #1 end: -> Option A

5. Quick Check:

   Use CMP + BLT for less than check [OK]

Hint: Use CMP then BLT to branch if less, else set zero [OK]

Common Mistakes:

• Swapping operands in CMP
• Using BGT instead of BLT
• Forgetting unconditional branch after MOV 0