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

  • Logic Synthesis Glossary
  • Logic Synthesis Cheatsheet
  • Synthesis Foundations14
  • Logic Optimisation and Mapping20
  • Constraints and Timing15
  • Sequential, FSM and Memory19
    • Flops, Resets and Enables
    • FSM Synthesis
    • Memory and Macro Inference
      • Flop Arrays or RAM Macros
      • Read and Write Port Styles
      • Byte Enables and Bypass Wrappers
      • Compilers, Macros and Wrappers
    • Retiming and Pipelining
  • Datapath Synthesis14
  • Area, Power and Test14
  • Verification, ECO and Handoff15
  • Flows and Debugging15
  • Interview and Judgment11
Loading lesson

‹Sequential, FSM and Memory
  1. Topics
  2. Logic Synthesis
  3. Sequential, FSM and Memory
  4. Memory and Macro Inference

Part 4 · Sequential, FSM and Memory · Intermediate

Memory and Macro Inference

When arrays become flops and when they become RAM macros.

  • 4topics
  • 4lessons

Arrays in RTL become either flop arrays or RAM macros. Size, port count and read style decide which one fits.

Question

Flop array

RAM macro

Best size

Small tables, tens of entries

Large tables, thousands of entries

Read style

Sync or async read

Sync read in most compiled macros

Port count

Many ports stay cheap while the memory is small

One or two ports; more ports cost area fast

Reset

Per-bit reset is natural

No per-bit reset; reset needs a wrapper

Flow

Mapped with the logic

Black box with a timing model plus a wrapper

Flop array or RAM macro decision.
Large tables with few ports and sync reads suit macros; the rest stays flops.

Lesson

What it covers

Flop arrays or RAM macros

Capacity arithmetic and when a table should stay flops.

Read and write port styles

Sync and async reads, write ports, and read-during-write rules.

Byte enables and bypass wrappers

Write masks and bypass wrappers around sync-read RAM.

Compilers, macros and wrappers

Memory compilers, black-box macros, wrappers, and port arithmetic.

Check yourself A 32-entry table of 8-bit values: flops or macro, and why?

Flops. At 256 bits the macro overhead exceeds the flop cost, and a flop array needs no wrapper or timing model.

Interview

Carry one sentence per lesson: small tables stay flops, sync reads suit macros while async reads do not, byte enables mask writes and bypass fixes same-cycle reads, and macros arrive as black boxes with wrappers.

PreviousNext: Flop Arrays or RAM Macros

Up next

Up nextFlop Arrays or RAM Macros

Sign in to save progress

Practice this lessonReport an error

See also

  • Flops, Resets and Enables
  • FSM Synthesis
  • Retiming and Pipelining