What are the various Design constraints used while performing Synthesis for a design ?

Various Design Changes to Meet Power Targets

To achieve specific power targets, engineers employ a combination of Architectural/RTL, Clocking, Datapath/Activity Reduction, and Implementation/Library strategies. Below is a comprehensive list of design changes categorized by their primary impact.

Key Insight: Power is primarily driven by Dynamic Power (switching activity, capacitance, voltage squared, frequency) and Static Power (leakage). Most high-level design changes target Dynamic Power, while library and voltage changes often target both.

1. Reduce Switching Activity (Dynamic Power)

Reducing the number of logic transitions per cycle directly lowers dynamic power ($P_{dyn} = \alpha C V^2 f$).

• Clock Gating: Insert clock gating cells (ICG) to disable clocks to flops when data is not changing or when the block is idle.
  • RTL level: Use enable signals on flip-flops.
  • Implementation: Tool inserts integrated clock gating cells.
• Data Gating / Operand Isolation: Prevent useless toggling in combinational logic (e.g., adders, multipliers) when the output is not used.
  • Example: If a multiplier result is ignored, isolate the inputs to prevent internal switching.
• Glitch Reduction:
  • Retime pipeline registers to reduce long combinational paths.
  • Balance logic paths to reduce reconvergence glitches.
  • Use one-hot encoding instead of binary for control signals if it reduces toggling.
• Encoding Optimization:
  • Use Gray Code for counters and FIFO pointers to minimize bit flips per step.
  • Use Bus Inversion to minimize average switching activity on buses.

2. Lower Frequency or Active Time

Since dynamic power is linearly proportional to frequency ($f$), reducing clock speed or active time saves power.

• DVFS (Dynamic Voltage and Frequency Scaling): Design the system to support multiple performance modes. Run at low frequency/voltage when full speed is not needed.
• Race-to-Sleep: If the workload is bursty, optimize the design to complete tasks quickly and enter a low-power idle state, rather than running continuously.
• Reduced Over-Pipelining: While more pipelines allow higher frequency, they increase clock tree power and register count. Sometimes, fewer stages (lower frequency) are more energy-efficient for a given task.

3. Reduce Capacitance ($C$) Being Switched

Lower capacitance on wires and input pins reduces energy per switch.

• Reduce Fanout: Minimize the number of loads on a net. Use fanout trees or buffer trees to avoid large fanout on single drivers.
• Datapath Width Optimization:
  • Trim unused bits (e.g., use 16-bit instead of 32-bit if data range allows).
  • Use saturation arithmetic to reduce bit-width requirements.
• Memory Hierarchy:
  • Replace large arrays of flip-flops with SRAM macros. SRAM cells are smaller and have lower energy per bit than standard cells.

4. Reduce Supply Voltage & Leakage (Static Power)

Voltage is squared in the dynamic power equation, making it the most powerful lever. Static power is critical in modern deep-nanometer nodes.

• Multi-Voltage Domains (MPV):
  • Partition the design into high-speed (high voltage) and low-speed (low voltage) blocks.
  • Run non-critical blocks (e.g., debug logic, slow interfaces) at a lower $V_{DD}$.
  • Requires level shifters and isolation cells at domain boundaries.
• Power Gating:
  • Completely shut off power to idle blocks using power switches.
  • Requires state retention registers to save context.
  • Note: Clock gating does not reduce leakage; only power gating does.
• Library Cell Selection:
  • Use High-Vt (High Threshold) cells for non-timing-critical paths to reduce leakage.
  • Use Multi-Vt libraries to balance performance and power.
• Multi-Bit Flops:
  • Use DFF2, DFF4, etc., instead of single DFFs. This reduces the total number of clock pins and associated capacitance.

5. Optimize Arithmetic & Architecture

Algorithmic and architectural changes can significantly reduce the hardware required for computation.

• Approximate Computing: If the application tolerates errors (e.g., audio, image processing), use approximate multipliers/adders with fewer bits or simplified logic.
• Resource Sharing:
  • Time-multiplex functional units (ALUs, multipliers) across different parts of the design.
  • Trade-off: Reduced area and power, but potentially lower throughput.
• Efficient Arithmetic:
  • Use shift-and-add operations instead of hardware multipliers where possible.
  • Replace wide MUX trees with hierarchical or encoded selects to reduce switching in selection logic.

6. Memory & Interface Power Optimization

Memory accesses and I/O toggling are often major power contributors.

• Memory Access Optimization:
  • Implement Caching to reduce off-chip memory accesses.
  • Batch reads/writes to reduce transaction overhead.
  • Enable clock enables on RAM ports to prevent internal switching when idle.
  • Avoid redundant reads/writes of the same data.
• I/O Power Reduction:
  • Use slower slew-rate I/O cells if timing allows (reduces overshoot/undershoot energy).
  • Reduce drive strength on I/O pins where possible.
  • Use bus encoding to minimize toggling on external interfaces.

7. Synthesis & Implementation Knobs

These are applied during the synthesis and P&R stages to refine power.

• Power-Driven Compilation:
  • Set set_max_dynamic_power and set_max_leakage_power constraints.
  • Enable set_power_optimization in synthesis tools (e.g., Design Compiler, Genus).
• DRC Compliance:
  • Ensure max_capacitance, max_fanout, and max_transition are met. Violations often force the tool to insert larger, higher-power buffers.
• Corner Analysis:
  • Optimize for Typical conditions for power, not just Worst-Case for timing. Over-designing for worst-case timing can increase area and power unnecessarily.

8. Verification & Measurement-Driven Iteration

Blind optimization is inefficient. Use data to guide changes.

• SAIF/VCD-Based Power Estimation:
  • Run simulations with realistic test vectors to generate activity files (SAIF/VCD).
  • Feed these into the power estimation tool to identify hotspots.
• Top Contributor Analysis:
  • Focus on the top 3-5 contributors: usually the clock tree, high-activity buses, large combinational blocks, or memory interfaces.

Summary: Power Optimization Levers by Domain

Domain	Technique	Primary Power Target
RTL / Architecture	Clock Gating	Dynamic
	Operand Isolation	Dynamic
	Resource Sharing / Approximate Computing	Dynamic + Area
System Level	DVFS / Multi-Voltage	Dynamic + Static
	Power Gating	Static (Leakage)
Implementation	High-Vt Cells	Static (Leakage)
	Multi-Bit Flops / SRAMs	Dynamic (Capacitance)
Verification	SAIF/VCD Analysis	Guides all above

Final Recommendation: Always start with Architectural/RTL changes (Clock gating, operand isolation) as they offer the largest relative improvement with minimal cost. Follow with Implementation strategies (Multi-Vt, Power Gating) to fine-tune the remaining gap. Use SAIF/VCD data to prioritize efforts on the most active parts of the design.