Project 3 — Find the Redline

1The mission

Every chip has a redline — the clock speed where the slowest route stops keeping up and the finish camera starts photographing runners mid-stride. For our specimen you already know it cold: launch 30, route 300, settle 20, margin 10 — a 360 ps bill, so ticks can come no faster than once every 360 ps. That is 1 ÷ 360 ps ≈ 2.78 GHz, exactly Bench 5.1's number. Below it, every answer is clean. Past it, garbage — three billion times a second.

But Notes 11 changed the game: the bill is not carved in stone, it is written at a voltage. Raise the supply pressure and every tap fills faster — the whole bill shrinks, and the redline climbs. Lower the pressure and the redline sags. So the redline is not one number; it is a curve: one max safe clock for every setting of the dial. The provided script draws that curve, marks the nominal point, and then turns the question around: you name the clock you want, and the script finds the voltage that buys it.

Your one knob: the clock you want. The suggested target is 3.00 GHz — the course's favorite number, the 333 ps tick the specimen has been failing to make since Notes 10 — and the script finds the exact voltage that gets you there. Or play it the other way: pick a clock below 2.78 and find how far the dial can drop before the chip falls under your floor. Either way the script does the finding, marks the point on the curve, and prints the price in energy — because Notes 11's square law never sleeps.

Explicitly: no report, no write-up, no diagram. One script, one chart, one printed price line.

2The script (provided — copy it)

This is Bench 5.1's arithmetic with Notes 11's voltage dial bolted on — the same specimen, the same slices, the same taps-fill-slower-at-low-pressure rule the benches run on. Copy it into a file named redline.py:

"""Project 03 -- Find the Redline.

YOUR PART is one knob, marked below. Everything else is Notes 10's
specimen datapath with Notes 11's voltage dial bolted on.
"""
import numpy as np
import matplotlib.pyplot as plt

# ---- the specimen's bill at the nominal 1.0 V (Notes 10, eq 4.1) ---------
LAUNCH_PS = 30.0    # the starting block's clock-to-out
ROUTE_PS  = 300.0   # slowest route: 5+30+5+15+210+30+5 (the copper road)
SETTLE_PS = 20.0    # the finish camera's setup time
MARGIN_PS = 10.0    # the skew-and-jitter slice
BILL_PS   = LAUNCH_PS + ROUTE_PS + SETTLE_PS + MARGIN_PS    # = 360 ps

# ---- the voltage dial (Notes 11): taps fill slower at low pressure -------
V_NOM = 1.0   # nominal supply, volts
VT    = 0.3   # the barrier the pressure must clear, volts

def stretch(v):
    """How much every delay stretches at supply v (exactly 1 at nominal)."""
    return (v / (v - VT)**2) / (V_NOM / (V_NOM - VT)**2)

def bill(v):    return BILL_PS * stretch(v)   # the whole bill, in ps
def redline(v): return 1000.0 / bill(v)       # max safe clock, in GHz

# =================== YOUR PART -- the one knob =============================
MY_CLOCK_GHZ = 3.00   # the clock you want. Above 2.78 = overclock (dial up).
                      # Below 2.78 = undervolt (dial down). Pick either.
CHART_TITLE  = "Find the Redline"   # put your name here if you like
# ===========================================================================

# ---- find the dial setting for MY_CLOCK_GHZ (bisection, not eyeballing) ---
lo, hi = VT + 0.1, 1.5
for _ in range(60):
    mid = 0.5 * (lo + hi)
    if redline(mid) < MY_CLOCK_GHZ:
        lo = mid
    else:
        hi = mid
v_mine = 0.5 * (lo + hi)

# ---- the printed receipts -------------------------------------------------
print(f"nominal: bill {bill(V_NOM):.0f} ps at {V_NOM:.2f} V  ->  redline {redline(V_NOM):.2f} GHz  (Bench 5.1)")
print(f"to clock {MY_CLOCK_GHZ:.2f} GHz the dial must sit at {v_mine:.3f} V")
d_speed  = (MY_CLOCK_GHZ / redline(V_NOM) - 1.0) * 100.0
d_energy = ((v_mine / V_NOM)**2 - 1.0) * 100.0   # flip energy ~ V^2 (Notes 11)
print(f"square law says: {d_energy:+.1f}% flip energy for {d_speed:+.1f}% speed")

# ---- the redline curve (this chart IS the deliverable) --------------------
v = np.linspace(0.6, 1.3, 400)
plt.figure(figsize=(8, 5))
plt.fill_between(v, redline(v), 4.6, color="#9E3320", alpha=0.08)
plt.text(0.62, 4.42, "past the redline: garbage grabbed at the tick",
         color="#9E3320", fontsize=9, alpha=0.8)
plt.plot(v, redline(v), color="#A2542A", lw=2.5, label="the redline -- max safe clock")
plt.scatter([V_NOM], [redline(V_NOM)], color="#131A21", zorder=5)
plt.annotate(f"nominal: {redline(V_NOM):.2f} GHz at {V_NOM:.2f} V\n(the 360 ps bill)",
             xy=(V_NOM, redline(V_NOM)), xytext=(0.64, 2.55),
             arrowprops=dict(arrowstyle="->", color="#5A6772"))
plt.scatter([v_mine], [MY_CLOCK_GHZ], color="#0E7C86", zorder=5)
plt.annotate(f"my clock: {MY_CLOCK_GHZ:.2f} GHz\nneeds {v_mine:.3f} V",
             xy=(v_mine, MY_CLOCK_GHZ), xytext=(0.72, 3.55),
             arrowprops=dict(arrowstyle="->", color="#0E7C86"))
plt.xlabel("supply voltage (V)")
plt.ylabel("max safe clock (GHz)")
plt.title(CHART_TITLE)
plt.legend(loc="lower right")
plt.grid(alpha=0.3)
plt.savefig("redline.png", dpi=150)
plt.show()

Three tiny functions — stretch is Notes 11's dial, bill is Notes 10's eq (4.1), redline is one divided by the bill — then a bisection loop and matplotlib. The route tags 5+30+5+15+210+30+5 are Fig 3.1's price tags, verbatim.

3Your whole job, in three moves

1. Run the stock redline. python redline.py — done in a second. The first printed line must read bill 360 ps and redline 2.78 GHz: Bench 5.1's numbers, exactly. The chart saves itself as redline.png with the nominal point marked in ink and your clock marked in teal.
2. Own the knob. MY_CLOCK_GHZ comes set to 3.00 — the 333 ps tick. Keep it, or pick your own: anything above 2.78 is an overclock (the script dials the voltage up to buy it), anything below is an undervolt (the script finds how low the dial can drop before your floor gives out). The script bisects its way to the exact voltage — you never eyeball it.
3. Read the price tag. The last printed line is the square law doing business: with the stock knob, +8.8% flip energy for +8.0% speed. Speed is never free; the printout says precisely what it costs. Screenshot the chart. Done.

4Hand in

5Grading — five checkboxes, 20 points each

6Micro-FAQ

Python says No module named matplotlib (or numpy).

pip install numpy matplotlib (on some machines: py -m pip install numpy matplotlib or pip3). That is everything the script needs.

Can I use Google Colab instead?

Yes. Paste the script into a cell, run it, and screenshot the chart there. Nothing to install.

Why not crank the dial to 2 volts and clock 5 GHz?

The square law. Flip energy grows with voltage squared, every flipped bucket's charge comes out as heat, and the curve only holds where the model holds — which is why real overclockers travel with liquid nitrogen and warranty-void stickers. The script's sweep stops at 1.3 V on purpose.

Can my clock be below 2.78?

Yes — that is the undervolt game, and it is just as good a project. The printed line flips sign: energy saved for speed given up. Phones play this exact game many times a second (Notes 11 called it DVFS).

My run printed 1.043 V. Is that right?

For the stock 3.00 GHz knob, exactly right: the dial goes up about 4% and the 360 ps bill shrinks to the 333 ps tick. A different knob gives a different voltage, and whatever the bisection finds is the correct answer for your knob.

Do I write anything?

No. The script and the chart are the answer. The only typing is your knob — one number inside YOUR PART.

Can I make it prettier? Mark more clocks? Shade the undervolt zone?

Yes. Joy is allowed. Just know that the five checkboxes are what's graded, so get those green first.