42-wanshuiyin-aris-skills-skills-codex-dse-loop

brycewang-stanford/Auto-Empirical-Research-SkillsResearchAudit pendingSnapshot 905a276ce424

Summary

This source did not publish a separate summary. Review SKILL.md before using the skill.

SKILL.md

DSE Loop: Autonomous Design Space Exploration

Autonomously explore a design space: run → analyze → pick next parameters → repeat, until the objective is met or timeout is reached. Designed for computer architecture and EDA problems.

Context: $ARGUMENTS

Safety Rules — READ FIRST

NEVER do any of the following:

sudo anything
rm -rf, rm -r, or any recursive deletion
rm any file you did not create in this session
Overwrite existing source files without reading them first
git push, git reset --hard, or any destructive git operation
Kill processes you did not start

If a step requires any of the above, STOP and report to the user.

Constants (override via $ARGUMENTS)

Constant	Default	Description
`TIMEOUT`	2h	Total wall-clock budget. Stop exploring after this.
`MAX_ITERATIONS`	50	Hard cap on number of design points evaluated.
`PATIENCE`	10	Stop early if no improvement for this many consecutive iterations.
`OBJECTIVE`	minimize	`minimize` or `maximize` the target metric.

Override inline: /dse-loop "task desc — timeout: 4h, max_iterations: 100, patience: 15"

Typical Use Cases

Problem	Program	Parameters	Objective

Parse $ARGUMENTS to extract:
- Program: what to run (command, script, or Makefile target)
- Parameter space: which knobs to tune and their ranges/options (may be incomplete — see step 2)
- Objective metric: what to optimize (and how to extract it from output)
- Constraints: hard limits that must not be violated (e.g., timing must close)
- Timeout: wall-clock budget
- Success criteria: when is the result "good enough" to stop early?

Infer missing parameter ranges — If the user provides parameter names but NOT ranges/options, you MUST infer them before exploring:

a. Read the source code — search for the parameter names in the codebase:

Look for argparse/click definitions, config files, Makefile variables, module parameters, #define, parameter (SystemVerilog), localparam, etc.
Extract defaults, types, and any comments hinting at valid values

b. Apply domain knowledge to set reasonable ranges:

Parameter type	Inference strategy
Cache/memory sizes	Powers of 2, typically 1KB–16MB
Associativity	Powers of 2: 1, 2, 4, 8, 16
Pipeline width / issue width	Small integers: 1, 2, 4, 8
Buffer/queue/FIFO depth	Powers of 2: 4, 8, 16, 32, 64
Clock period / frequency	Based on technology node; try ±50% from default
Bound depth (BMC/formal)	Geometric: 5, 10, 20, 50, 100
Timeout values	Geometric: 10s, 30s, 60s, 120s, 300s
Boolean/enum flags	Enumerate all options found in source
Continuous (learning rate, threshold)	Log-scale sweep: 5 points spanning 2 orders of magnitude around default
Integer counts (threads, cores)	Linear: from 1 to hardware max

c. Start conservative — begin with 3-5 values per parameter. Expand range later if the best result is at a boundary.

d. Log inferred ranges — write the inferred parameter space to dse_results/inferred_params.md so the user can review:

# Inferred Parameter Space

| Parameter | Source | Default | Inferred Range | Reasoning |
|-----------|--------|---------|---------------|-----------|
| CACHE_SIZE | config.py:42 | 32768 | [8192, 16384, 32768, 65536, 131072] | powers of 2, ±2x from default |
| ASSOC | config.py:43 | 4 | [1, 2, 4, 8] | standard associativities |
| BMC_DEPTH | run_bmc.py:15 | 10 | [5, 10, 20, 50] | geometric, common BMC depths |

e. Boundary expansion — during the search, if the best result is at the min or max of a range, automatically extend that range by one step in that direction (but log the extension).

Read the project to understand:
- How to run the program
- Where results are produced (stdout, log files, reports)
- How to parse the objective metric from output
- Current/baseline configuration (if any)
Create working directory: dse_results/ in project root
- dse_results/dse_log.csv — one row per design point
- dse_results/DSE_REPORT.md — final report
- dse_results/DSE_STATE.json — state for recovery
- dse_results/inferred_params.md — inferred parameter space (if ranges were not provided)
- dse_results/configs/ — config files for each run
- dse_results/outputs/ — raw output for each run
Write a parameter extraction script (dse_results/parse_result.py or similar) that takes a run's output and returns the objective metric as a number. Test it on a baseline run first.
Run baseline (iteration 0): run the program with default/current parameters. Record the baseline metric. This is the point to beat.

Pick 5-10 diverse design points that span the parameter ranges
Run them (in parallel if independent, via background processes or sequential)

Record all results in dse_log.csv:

iteration,param1,param2,...,metric,constraint_met,timestamp,notes
0,default,default,...,baseline_val,yes,2026-03-13T10:00:00,baseline
1,val1a,val2a,...,result1,yes,2026-03-13T10:05:00,initial sweep
...

Analyze: which parameters have the most impact on the objective?
Narrow the search to the most sensitive parameters

Select next design point based on results so far:
- Look at the trend: which direction improves the metric?
- Avoid re-running configurations already evaluated
- Balance exploration (untested regions) vs exploitation (near current best)
Modify parameters: edit config file, command-line args, or source constants
Run the program: execute and capture output
Parse results: extract the objective metric and check constraints
Log to dse_log.csv: append the new row
Check stopping conditions:
- Timeout reached? → stop
- Max iterations reached? → stop
- Patience exhausted (no improvement in N iterations)? → stop
- Success criteria met (metric is "good enough")? → stop
- Constraint violation pattern detected? → adjust search bounds

Update DSE_STATE.json:

{
  "iteration": 15,
  "status": "in_progress",
  "best_metric": 1.23,
  "best_params": {"cache_size": 32768, "assoc": 4, "pipeline_width": 2},
  "total_iterations": 15,
  "start_time": "2026-03-13T10:00:00",
  "timeout": "2h",
  "patience_counter": 3
}

Decide next step → back to step 1

# Design Space Exploration Report

**Task**: [description]
**Date**: [start] → [end]
**Total iterations**: N
**Wall-clock time**: X hours Y minutes

## Objective
- **Metric**: [what was optimized]
- **Direction**: minimize / maximize
- **Baseline**: [value]
- **Best found**: [value] ([improvement]% better than baseline)

## Best Configuration
| Parameter | Baseline | Best |
|-----------|----------|------|
| param1    | default  | best_val |
| param2    | default  | best_val |
| ...       | ...      | ... |

## Search Trajectory
| Iteration | param1 | param2 | ... | Metric | Notes |
|-----------|--------|--------|-----|--------|-------|
| 0 (baseline) | ... | ... | ... | ... | baseline |
| 1 | ... | ... | ... | ... | initial sweep |
| ... | ... | ... | ... | ... | ... |
| N (best) | ... | ... | ... | ... | ★ best |

## Parameter Sensitivity
- **param1**: [high/medium/low impact] — [brief explanation]
- **param2**: [high/medium/low impact] — [brief explanation]

## Pareto Frontier (if multi-objective)
[Table or description of non-dominated points]

## Stopping Reason
[timeout / max_iterations / patience / success_criteria_met]

## Recommendations
- [actionable insights from the exploration]
- [which parameters matter most]
- [suggested follow-up explorations]

# Minimal — just name the parameters, let the agent figure out ranges
/dse-loop "Run gem5 mcf benchmark. Tune: L1D_SIZE, L2_SIZE, ROB_ENTRIES. Objective: maximize IPC. Timeout: 3h"

# Partial — some ranges given, some not
/dse-loop "Run make synth. Tune: CLOCK_PERIOD [5ns, 4ns, 3ns, 2ns], FLATTEN, ABC_SCRIPT. Objective: minimize area at timing closure. Timeout: 1h"

# Fully specified — explicit ranges for everything
/dse-loop "Simulate processor with FIFO_DEPTH [4,8,16,32], ISSUE_WIDTH [1,2,4], PREFETCH [on,off]. Run: make sim. Objective: max throughput/area. Timeout: 2h"

# Real-world: PDAG-SFA formal verification tuning
/dse-loop "Run python run_bmc.py. Tune: BMC_DEPTH, ENGINE, TIMEOUT_PER_PROP. Objective: maximize properties proved. Timeout: 2h"

Microarch DSE	gem5 simulation	cache size, assoc, pipeline width, ROB size, branch predictor	maximize IPC or minimize area×delay
Synthesis tuning	yosys/DC script	optimization passes, target freq, effort level	minimize area at timing closure
RTL parameterization	verilator sim	data width, FIFO depth, pipeline stages, buffer sizes	meet throughput target at min area
Compiler flags	gcc/llvm build + benchmark	-O levels, unroll factor, vectorization, scheduling	minimize runtime or code size
Placement/routing	openroad/innovus	utilization, aspect ratio, layer config	minimize wirelength / timing
Formal verification	abc/sby	bound depth, engine, timeout per property	maximize coverage in time budget
Memory subsystem	cacti / ramulator	bank count, row buffer policy, scheduling	optimize bandwidth/energy

42-wanshuiyin-aris-skills-skills-codex-dse-loop

Summary

SKILL.md

DSE Loop: Autonomous Design Space Exploration

Context: $ARGUMENTS

Safety Rules — READ FIRST

Constants (override via $ARGUMENTS)

Typical Use Cases

Workflow

Phase 0: Parse Task & Setup

Phase 1: Initial Exploration

Phase 2: Directed Search

Phase 3: Refinement (if time allows)

Phase 4: Report

State Recovery

Key Rules

Example Invocations

Related skills