GPU Kernel Baseline

Phase 4: Performance, Correctness, and Quality Gate

1. Run exactly one full-workload base-seed V0 measurement through the mandatory sandbox. Do not pass --multi-seed and do not launch a separate robustness run for V0:

python tools/sandbox.py --kind run --no-sync -- \
  python test_kernel.py --version v0 --no-memory

Parse the emitted [test_kernel] RESULT_JSON=..., use its performance result and accompanying correctness status for memory/v0.json, and avoid repeating the expensive baseline workload.

• Each individual test case must complete within 30 seconds (configurable via TEST_TIMEOUT_SEC env var).
• If a case exceeds the timeout, mark it as TIMEOUT_FAIL, kill the process, and record the failure in baseline_report.md.
• Common timeout causes: infinite loops in index calculation, deadlocks in synchronization, or excessive compilation time. Consult enabled knowledge tools with the failure mode to diagnose.

2. Verify all correctness cases pass and record max rel_err plus PASS/FAIL.
3. Measure baseline performance and record:

latency(us) | TFLOPS | bandwidth(GB/s) | TFLOPS peak utilization(%) | bandwidth peak utilization(%)

4. Use compute_utilization.py to calculate TFLOPS and bandwidth utilization:

python tools/compute_utilization.py   --gpu <gpu> --dtype <dtype>   --flops-expr '<expr>' --bytes-expr '<expr>'   --time-ms <ms> --grid-blocks <blocks>

5. Every theoretical peak, bandwidth, and utilization calculation must cite the auditable spec sources registered in Step 0.

6. Write baseline_report.md with:

   • Baseline kernel path
   • Correctness test path
   • PyTorch reference logic description
   • Stable source record ids consulted
   • Baseline configuration summary
   • Correctness results: case list, max rel_err, PASS/FAIL (include any TIMEOUT_FAIL cases)
   • Baseline performance: latency(us), TFLOPS, bandwidth(GB/s), and peak utilization percentages

7. Write baseline iteration data to memory/v0.json using tools/memory_manager.py:

   # Create the iteration file
   python tools/memory_manager.py create --workspace kernel_opt_<name> --version v0
   
   # Fill in performance and metadata
   python tools/memory_manager.py update --workspace kernel_opt_<name> --version v0 \
       --set 'performance.latency_us=<value>' \
       --set 'performance.tflops=<value>' \
       --set 'performance.bandwidth_gbps=<value>' \
       --set 'performance.tflops_peak_utilization_pct=<value>' \
       --set 'performance.bandwidth_peak_utilization_pct=<value>' \
       --set 'optimization.action_category=baseline' \
       --set 'optimization.action_description=<summary>' \
       --set 'correctness.rel_err=<value>' \
       --set 'correctness.status=PASS' \
       --set 'quality_gate.result=PASS'

   For array fields (pitfalls_and_fixes, references), update the JSON file directly or use read + manual edit + write-back. Fill in:

   • pitfalls_and_fixes: any errors encountered during implementation
   • references: stable source record ids and other docs referenced during learning

8. After the quality gate passes, commit:

git add kernel.py test_kernel.py baseline_report.md memory/v0.json README.md
git commit -m "V0: baseline kernel"

memory/ Requirements

Each iteration produces a memory/v<N>.json file following the schema defined in reference/v_iteration.schema.json. The JSON structure captures performance data, optimization actions, profile evidence, correctness results, ISA metric progress, search logs, pitfalls and fixes, and references.

Key rules:

• The masked field defaults to false. When set to true, the file is skipped during reads.
• ISA optimization target thresholds are stored in README.md and must be derived from documented best practices, hardware specs, and Step 0 Roofline conclusions. Do not fabricate thresholds from experience.

Deliverables

• Runnable and correct(using either CuteDSL or FlyDSL) kernel.py
• PyTorch reference.py
• test_kernel.py
• baseline_report.md
• Created memory/v0.json
• Git commit

Appendix: Prohibited Actions

• Do not use unspecified programming frameworks or import external projects.