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
  • Memory Hierarchy15
  • NoC and Interconnect Architecture6
  • Coherency and Memory Ordering9
  • Performance Analysis9
  • Accelerator Architectures6
  • SoC Architecture Tradeoffs9
  • Architecture Interview Prep14
    • Interview Method and Worked Scenarios
      • Architecture Whiteboard Framework
      • Scenario: Cache MPKI Storm
      • Scenario: NoC Deadlock Under Load
      • Scenario: Accelerator Starvation
      • Scenario: Coherency Traffic Storm
      • Validation, PPA and the Close
    • Architecture Interview Q&A Bank
Loading lesson

‹Interview Method and Worked Scenarios
  1. Topics
  2. Computer Architecture
  3. Architecture Interview Prep
  4. Interview Method and Worked Scenarios
  5. Scenario: Accelerator Starvation

Computer Architecture · All levels

Scenario: Accelerator Starvation

A slow NPU explained with compute, byte and overhead time, then tiled and overlapped.

On this page

    Measure end to end, not peak

    The NPU reaches peak TOPs in isolation, yet end-to-end inference misses target by a wide margin. Isolation hides transfers, launch and sync.

    Assume 16 GOP of work, 32 TOPS of peak compute, 8 MB of weights, 16 GB/s of DMA and 0.15 ms of launch plus sync. Target latency is 0.8 ms.

    1. 0-5 min: define the end-to-end metric and the exact workload.

    2. 5-15 min: split wall time into compute, bytes and overhead.

    3. 15-25 min: rank tiling, double buffering and contract hypotheses.

    4. 25-35 min: propose SRAM tile, DMA and software contract options.

    5. 35-45 min: state which metric is safe to publish and which misleads.

    Split time into compute, bytes and overhead

    Compute time is 16 GOP / 32 TOPS = 0.5 ms. Weight time is 8 MB / 16 GB/s = 0.5 ms.

    Naive total is 0.5 + 0.5 + 0.15 = 1.15 ms against a 0.8 ms target, about 44 percent over. The accelerator is active 0.5 / 1.15 = 0.43, about 43 percent.

    Diagram
    Compute:  16 GOP / 32 TOPS = 0.5 ms
    Bytes:    8 MB / 16 GB/s = 0.5 ms
    Naive:    0.5 + 0.5 + 0.15 = 1.15 ms vs 0.8 ms target
    Over:     1.15 / 0.8 = 1.44, about 44 percent over target
    Active:   0.5 / 1.15 = 0.43, about 43 percent utilization
    Check yourself Peak TOPs are met, yet the kernel is slow. What single ratio decides the story?

    Active fraction: compute time over end-to-end time. A low fraction moves the debug to bytes and overhead, not the array.

    Tile and double-buffer the weights

    Four tiles cut each transfer to 0.125 ms. Double buffering overlaps each tile fetch with the previous tile compute.

    Pipelined total is 0.125 fill + 0.5 compute + 0.15 overhead = 0.775 ms, inside the 0.8 ms target. The fix is schedule and SRAM, not a faster array.

    Schedule

    Time (ms)

    Meets 0.8 ms

    Naive serial

    1.15

    No

    Tiled, no overlap

    1.15

    No

    Tiled double-buffered

    0.775

    Yes

    Publish the roofline number

    Peak TOPs describe the array, not the workload. The publishable number is sustained throughput at the measured arithmetic intensity.

    Name the contract: tile size, DMA reservation and launch budget. Marketing gets the roofline point, not the peak.

    Common pitfall

    Clocking the accelerator or quoting peak TOPs answers a different question. Starvation is a bytes-and-schedule problem until the active fraction says otherwise.

    Interview

    Likely traps and the calm replies.

    • Trap: publish peak TOPs. Reply: publish sustained latency at stated intensity.

    • Trap: blame the compiler without data. Reply: split time first, then point at the largest piece.

    • Trap: ignore host sync. Reply: launch and sync are line items with owners.

    Check yourself Double buffering still misses target and the active fraction is now 0.9. What changed?

    Bytes are hidden, so the array itself is the bound. Now array throughput or intensity is the lever.

    Related topics

    • Accelerators for the architect

    • Roofline and tuning

    • Memory bandwidth and latency

    Previous

    76 / 86

    Next: Scenario: Coherency Traffic Storm

    Up next

    Up nextScenario: Coherency Traffic Storm

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Architecture Whiteboard Framework
    • Scenario: Cache MPKI Storm
    • Validation, PPA and the Close