W4.16.1 Refine the IP's UPF

HardImplementOpenPA + Icarus · serverReview the topic

A transmitter team owns the safe value on b. Integrate its contract into an active-low board without changing the IP file.

Hardware context: A PMU and two separately supplied accumulator sockets. Refine one IP contract across a board and a technology handoff.

The editor accepts one file. Define configure and implement so the layer files can call them without arguments. The two supplied layer files execute their respective bodies. Load board.upf first and the two layers in order.

Full specification
DecisionBoard requirement
IP handoffUse the supplied contract.upf unchanged through board.upf. Keep its original FLAG selection and clamp.
ConfigurationExtend the existing FLAG strategy with -update in configure. Keep a single strategy.
ControlUse iso_n as the active-low guard.
Independent powerUse AON so FLAG still drives b when TX collapses.
ImplementationIn implement, add parent location to FLAG with a later update. Keep signal and supply choices in configure.
Macro worksheetIn implement, draw the implementation-only load of detail.upf at u_tx. This describes a separate refinable-macro view. Use draw {...}.
Read-only IP delivery, SHA-256
06bb8bf451a65eebb3498547084ca5180d6902331df34b54a942f5fa8d286a62

What the Grader Checks

OpenPA reads your file. A refusal ends the check with OpenPA's message and line. Otherwise every row below must pass.

RowRule
Board sequencepublic scenario: Run shows it
Second board trialhidden scenario
Intent equals the referencethe domain of every instance; supply ports, nets and their connections; the primary supply of every domain; supply sets and switches; isolation cells (clamp, enable, sense, supply); where each isolation cell is placed; level shifters; retained registers and their controls; power states; switch names, acknowledge wires, supplies and delays

The Design

The power-unaware RTL your UPF describes (top boundary_soc). Open a file to read it.

island.sv
module island(input logic [4:0] d, output wire a, b, c, z, spare);
  assign a=d[0]; assign b=d[1]; assign c=d[2]; assign z=d[3]; assign spare=d[4];
endmodule
module boundary_soc(input logic [4:0] d, input logic iso, iso_n,
  output wire a,b,c,z,spare);
  island u_tx(.d(d),.a(a),.b(b),.c(c),.z(z),.spare(spare));
endmodule

Given UPF Files

Your file may load these with load_upf. The grader uses the same text.

board.upf
upf_version 4.0
set_design_top boundary_soc
create_power_domain PD_TOP -include_scope
create_power_domain PD_TX -elements {u_tx}
create_supply_port VA -direction in
create_supply_port VT -direction in
create_supply_port VG -direction in
create_supply_net NA
create_supply_net NT
create_supply_net NG
connect_supply_net NA -ports {VA}
connect_supply_net NT -ports {VT}
connect_supply_net NG -ports {VG}
create_supply_set AON -function {power NA} -function {ground NG}
create_supply_set TX -function {power NT} -function {ground NG}
associate_supply_set AON -handle PD_TOP.primary
associate_supply_set TX -handle PD_TX.primary
proc draw {card} {set_design_attributes -elements {.} -attribute [list handoff $card]}
load_upf contract.upf
contract.upf
set_isolation FLAG -domain PD_TX -elements {u_tx/b} -applies_to outputs -clamp_value 1
configuration.upf
set_design_attributes -elements {.} -attribute {phase configuration}
configure
implementation.upf
set_design_attributes -elements {.} -attribute {phase implementation}
implement

The Public Scenario

Board sequence. Run checks its output and shows the expected lines and any failure.

tb.sv (public scenario)
`timescale 1ns/1ps
module tb;
 import UPF::*;
 logic [4:0] d=5; logic iso=0,iso_n=1;
 wire a,b,c,z,spare;
 boundary_soc dut(.*);
 task sample(input string phase);
   #2; $display("%s request=%b raw=%b receiver=%b neighbor=%b",phase,iso_n,dut.u_tx.b,b,a);
 endtask
 initial begin
   void'(supply_on("VA")); void'(supply_on("VG",0.0)); void'(supply_on("VT"));
   sample("live"); iso_n=0; sample("guard");
   void'(supply_off("VT")); sample("sleep");
   void'(supply_on("VT")); iso_n=1; sample("wake"); $finish;
 end
endmodule

Examples

Example 1

Connected Supply Nets (Recorded)
Input
Read the complete board handoff.
OpenPA reports (recorded)
Supply network
  NA: port VA  {port:VA net:NA fn:AON.power fn:PD_TOP.primary.power}
  NT: port VT  {port:VT net:NT fn:TX.power fn:PD_TX.primary.power}
  NG: port VG  {port:VG net:NG fn:AON.ground fn:TX.ground fn:PD_TOP.primary.ground fn:PD_TX.primary.ground}

Follow each supply port to the net it drives.

Example 2

Domain Ownership (Recorded)
Input
Read the complete board handoff.
OpenPA reports (recorded)
Power domains
  PD_TOP (board.upf:3): boundary_soc
    primary supply AON: power NA, ground NG
  PD_TX (board.upf:4): u_tx
    primary supply TX: power NT, ground NG

Read the domain ownership and follow each primary supply.

Example 3

Board Sequence (Recorded)
Input
Apply the public bench stimulus.
The bench prints (recorded)
live request=1 raw=0 receiver=0 neighbor=1
guard request=0 raw=0 receiver=1 neighbor=1
sleep request=0 raw=0 receiver=1 neighbor=x
wake request=1 raw=0 receiver=0 neighbor=1

Follow the protected receiver and its unprotected neighbor as VT falls.

Constraints and Contract

  • Preserve the supplied board connections and use only the requested handoff entries.

Hints

Hint 1

Follow the board names through the supplied files.

Hint 2

Use the supplied contract.upf unchanged through board.upf. Keep its original FLAG selection and clamp.

Hint 3

Check the return path as well as the positive supply.

What the grader checks: OpenPA and Icarus run the abstract board. The worksheet checks cell or library choices independently.

Run checks the public scenario only and never accepts. Submit runs every row. OpenPA is our open power-aware tool: it reads the UPF, writes a power-aware copy of the RTL, and Icarus runs that copy.

See all 2 problems on this path
Your UPF file UPFSaved locally
Ln 1, Col 1Tab indents · Ctrl/⌘ + Enter runs
Not run yet

Run checks the public scenario. Submit checks every row in the description.

OpenPA + Icarus · server