Skip to content

04 Hardware Architecture and Performance Optimization

1. Logic Devices vs. Sequential Devices

Understanding data types requires understanding the physical components that process and store them.

A. Combinational Logic (The ALU)

  • Role: The "Brain" or "Calculator" (e.g., Adder, Multiplier, Logic Gates).
  • Characteristics:
    • Stateless/Memoryless: It has no concept of "past" or "future." It only knows the current input.
    • Instantaneous: Output is determined immediately by input (ignoring propagation delay).
    • Logic: \(Output = f(Input)\).
    • C Equivalent: Operators (+, -, &, |, <<).

B. Sequential Logic (Registers and Memory)

  • Role: The "Memory" (e.g., Flip-Flops, RAM).
  • Characteristics:
    • Stateful: It retains data over time.
    • Clock-Driven: State updates only occur on a clock signal (e.g., rising edge).
    • Logic: \(NextState = f(Input, CurrentState)\).
    • C Equivalent: Variables (int a), Arrays.

C. The Interaction (The CPU Cycle)

A single line of C code (e.g., a = a + 1) orchestrates a dance between these two: 1. Fetch: Sequential logic (Register) provides the current value of a. 2. Compute: Combinational logic (ALU) calculates value + 1. 3. Store: On the next clock tick, Sequential logic captures the new result.

2. Integer Selection Strategy: Why int is King

Despite modern CPUs being 64-bit, int (usually 32-bit) remains the default and optimal choice for most integers.

A. The "Word Size" Alignment

  • Concept: The int type is historically designed to match the CPU's natural "Word Size"—the most efficient chunk of data the processor can handle in one go.
  • Integer Promotion: In C, types smaller than int (char, short) are automatically promoted to int during arithmetic operations. Using int natively avoids these implicit casting steps.

B. Why 32-bit int is Optimal on 64-bit Machines

One might assume 64-bit integers (long long) would be faster on 64-bit CPUs. However, 32-bit int is often superior due to "Transportation Costs":

  1. Cache Pressure (The Bottleneck):

    • CPU Cache (L1/L2) is extremely limited and fast.
    • Using 32-bit int instead of 64-bit long long doubles the number of elements that fit into the cache.
    • Result: Higher Cache Hit Rate, which is the primary factor in modern performance.

  2. Memory Bandwidth:

    • Memory buses have a fixed width.
    • Transferring 32-bit data consumes half the bandwidth of 64-bit data, effectively doubling the data throughput for array processing.

  3. Instruction Encoding (Code Size):

    • On x86-64 architectures, instructions operating on 64-bit registers often require an extra prefix byte (REX prefix).
    • Instructions for 32-bit int are shorter, resulting in smaller binary size and better utilization of the CPU's Instruction Cache.

  4. Hardware Zero-Extension (No Penalty):

    • On x86-64, writing to the lower 32 bits of a 64-bit register automatically clears the upper 32 bits to zero.
    • Result: There is no CPU cycle penalty for using 32-bit math on a 64-bit register.

3. Floating Point Selection Strategy: Why double is Default

Unlike integers, where smaller is often better, double (64-bit) is usually preferred over float (32-bit) for general-purpose computing.

A. The Precision Necessity

  • Float Limitation: With only ~7 significant decimal digits, float suffers from rapid precision loss in cumulative calculations.
  • Double Robustness: With ~15 significant digits, double provides a safety net for most engineering and financial calculations without requiring complex error analysis.

B. The C Standard Ecosystem

  • Literals: A decimal constant like 3.14 is implicitly double in C.
  • Functions: Standard math libraries (math.h) historically take and return double (e.g., sqrt, sin).

C. The Implicit Cost of float

If you use float in a double-centric environment without care: 1. Conversion: The CPU must convert float to double (promotion) to perform the math, then convert back to float (truncation) to store it. 2. Risk: This adds unnecessary CPU instructions and introduces potential truncation errors.

D. Exceptions: When to use float

  • Embedded Systems: Where memory is scarce (kB level) or the CPU lacks a hardware Floating Point Unit (FPU).
  • GPU/Graphics: Shaders and 3D coordinates often rely on float because GPUs are optimized for massive parallel processing of 32-bit data, and visual precision requirements are lower.
  • Massive Storage: When storing billions of data points where halving the disk/RAM usage outweighs precision concerns.

4. Summary of Best Practices

A. General Rule

  • Integers: Default to int.
  • Floating Point: Default to double.

B. Specific Overrides

  • Use long long only if values exceed \(\pm 2\) billion.
  • Use short/char only for massive arrays where memory saving is critical.
  • Use float only for graphics, storage of massive datasets, or hardware-constrained embedded systems.
  • Use size_t for memory indexing and object sizes.