Skip to content
DenseChip
Learn
PracticeCode labInterview

DenseChip

Navigate

Menu

LearnPracticeCode labInterview

Tools

All toolsSV editorCode repoResume
DenseChip

Practice, courses, and chip-design tools in one focused workspace.

LearnPracticeCode labInterviewToolsLearning paths

© 2026 DenseChip

AboutContactPrivacyTerms
Skip to lesson

Course contents

  • Architecture Metrics Reference
  • Workload Taxonomy for Architects
  • Architecture Glossary
  • Computer Architecture Cheatsheet
  • Pipeline Fundamentals14
    • Pipeline Throughput
    • Branch Prediction and Fetch
    • Out-of-Order Superscalar Execution
      • Superscalar Issue Width
      • In-Order Versus Out-of-Order
      • Register Renaming
      • Reorder Buffer and Commit
      • Why IPC Saturates
  • Memory Hierarchy15
  • NoC and Interconnect Architecture6
  • Coherency and Memory Ordering9
  • Performance Analysis9
  • Accelerator Architectures6
  • SoC Architecture Tradeoffs9
  • Architecture Interview Prep14
Loading lesson

‹Out-of-Order Superscalar Execution
  1. Topics
  2. Computer Architecture
  3. Pipeline Fundamentals
  4. Out-of-Order Superscalar Execution
  5. Why IPC Saturates

Computer Architecture · All levels

Why IPC Saturates

Dependencies, memory latency and branches cap useful IPC no matter the width.

On this page

    True dependencies serialize

    A chain of dependent instructions issues one step per producer latency. No width or scheduling shortens the chain itself.

    A pointer chase is the extreme case. With each load feeding the next address, the chain runs at memory latency per step: one dependent load every 10 cycles sustains at most 0.1 IPC from that chain, stated parameters.

    Memory sets a latency floor

    A load miss stalls its dependents for the full miss latency. Overlapping misses and non-blocking caches hide some of it, but the floor stays.

    Wider issue helps only while independent misses overlap. Once the miss handlers or bandwidth saturate, extra slots wait on the same memory system.

    Branches drain the window

    A mispredict flushes the speculative window and refills it from the correct path. The cost is the mispredict rate times the resolution depth in cycles.

    Deeper speculation windows lose more per mispredict. That is why branch behavior caps the useful window, covered in the branch prediction topic.

    Reading a CPI stack

    A CPI stack splits every cycle into useful work plus stall classes. Its percentages must sum to 100, up to stated rounding.

    The example below uses stated parameters, not measured data.

    Diagram
    4-wide core, stated cycle breakdown (shares sum to 100 percent)
    useful issue ......... 30 percent
    data-dependency stall  25 percent
    branch waste ......... 15 percent
    memory stall ......... 30 percent
    check: 30 + 25 + 15 + 30 = 100
    sustained IPC = width x useful share = 4 x 0.30 = 1.2
    at 3 GHz: throughput = 1.2 x 3.0 GHz = 3.6 GIPS

    Limiter

    Signature in counters

    Design direction

    True dependencies

    High RAW stall share, idle slots behind chains

    Larger window, better scheduling, lower producer latency

    Memory latency

    Load-miss replay and queue-full stalls

    Prefetch, locality, more outstanding misses

    Branch mispredicts

    Flush events tracking MPKI

    Better prediction, shorter resolution depth

    Common pitfall

    Tuning one limiter past the next bottleneck. Check the CPI stack after each fix: the largest remaining share decides the next experiment.

    Interview

    Likely probes: the three caps and how to tell them apart.

    • Dependencies show as RAW stalls with the window partly full.

    • Memory shows as miss-driven replays with queues full.

    • Branches show as flush bursts correlated with MPKI, not with issue pressure.

    Check yourself Useful issue is 30 percent on a 4-wide core. What is sustained IPC, and what does doubling width give if the share stays 30 percent?

    IPC is 1.2. Doubling width at the same share gives 2.4, but in practice the share usually falls as the window and memory pressure grow.

    Check yourself MPKI falls but IPC barely moves and memory stalls dominate the stack. What do you conclude?

    Branches were not the binding limiter. The next experiment targets memory behavior, not the predictor.

    Related topics

    • Superscalar issue width

    • Reorder buffer and commit

    • Memory bandwidth and latency

    • Roofline and tuning

    • Branch prediction and fetch

    Previous

    18 / 86

    Next: Memory Hierarchy

    Up next

    Up nextMemory Hierarchy

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Superscalar Issue Width
    • In-Order Versus Out-of-Order
    • Register Renaming