feat: SSA dataflow analysis with Graphviz DOT export

[sii-xinglong]

Summary

• Add --dataflow-output CLI flag to generate Graphviz DOT files showing SSA def-use dependency graphs
• Extract data flow from simulated OpEvent tree with time-partitioned layout, hardware swim lanes (VPU/DMA), loop clusters, and cross-stream edge highlighting
• Persist SSA inputs/outputs on OpEvent attributes during simulation for downstream analysis

Design

See docs/plans/2026-05-01-dataflow-analysis-design.md for the full design document.

RFC: primatrix/wiki#143

Changes

• dataflow.py — DFNode/DFEdge/DataFlowGraph data model + extract_dataflow() extraction
• dataflow_exporter.py — DataFlowDotExporter renders DOT with time buckets, hardware clusters, loop nesting
• simulator.py — persist SSA boundary info on scheduled events
• cli.py — --dataflow-output flag

Usage

python -m strix.cli path/to/post-finalize-llo.txt \
  --default-sld-value 128 \
  --dataflow-output dataflow.dot

dot -Tsvg dataflow.dot -o dataflow.svg

Test plan

• 24 tests (unit + integration), all passing
• Smoke test on real fused-moe kernel: 8,419 nodes, 779 cross-stream edges
• Spec compliance + code quality reviews passed

🤖 Generated with Claude Code

[gemini-code-assist]

Code Review

This pull request implements SSA dataflow analysis and Graphviz DOT visualization. It adds a data model for dataflow graphs, extraction logic from simulated events, and a DOT exporter featuring hardware/loop clustering and time-bucketed alignment. The simulator now persists SSA metadata, and a --dataflow-output CLI flag is introduced. Review feedback highlights a bug in edge construction when variable names are reused, the omission of control-flow nodes in the graph extraction, and an escaping issue in the DOT exporter that breaks multi-line labels.

[gemini-code-assist]

The current implementation of _build_edges builds a global map of producers (producer) before iterating to create edges. This logic is incorrect for programs where variable names are reused, such as in expanded loops where the same SSA name appears in multiple iterations. In such cases, every consumer of a variable will incorrectly point to the last definition in the entire program rather than the most recent one in execution order.

To fix this, you should build the producer map while iterating through the nodes, ensuring that each use links to the definition that was most recently encountered.

Suggested change

	# Map variable name -> producer node id (last writer wins)
	producer: Dict[str, int] = {}
	for node in nodes:
	for var in node.ssa_outputs:
	producer[var] = node.id
	seen: Set[Tuple[int, int, str]] = set()
	edges: List[DFEdge] = []
	for node in nodes:
	for var in node.ssa_inputs:
	src_id = producer.get(var)
	if src_id is None:
	continue # external input (e.g. %arg0)
	key = (src_id, node.id, var)
	if key in seen:
	continue
	seen.add(key)
	edges.append(DFEdge(src=src_id, dst=node.id, variable=var))
	producer: Dict[str, int] = {}
	seen: Set[Tuple[int, int, str]] = set()
	edges: List[DFEdge] = []
	for node in nodes:
	# 1. Find producers for inputs using the current state of the map
	for var in node.ssa_inputs:
	src_id = producer.get(var)
	if src_id is not None:
	key = (src_id, node.id, var)
	if key not in seen:
	seen.add(key)
	edges.append(DFEdge(src=src_id, dst=node.id, variable=var))
	# 2. Update the map with this node's outputs for subsequent consumers
	for var in node.ssa_outputs:
	producer[var] = node.id
	return edges

[sii-xinglong]

Good catch — accepted. The incremental producer map correctly handles expanded loops where SSA names are reused across iterations. Fixed in the next commit.

[gemini-code-assist]

The _walk function currently treats LOOP and IF events as containers but not as nodes in the dataflow graph. However, the design document specifies that control-flow operations should be represented as nodes (e.g., as diamonds) to capture dependencies like loop bounds or branch conditions.

Additionally, the current logic returns early when an event kind is in _NODE_KINDS, which would prevent recursion into loop or branch bodies if those kinds were added to the set. The function should be restructured to both create a node for the event and recurse into its children when appropriate.

[sii-xinglong]

Intentional design decision: LOOP/IF events are pure containers in the OpEvent tree — they don't define or use SSA variables themselves. Adding them as DFNodes would create orphan diamond nodes with no data-dependency edges, adding visual noise without information. The diamond styling for `OpStream.CONTROL` in the exporter targets leaf/block control operations (e.g. `scf.yield`) that do carry SSA semantics, not structural containers. Loop structure is already represented via `subgraph cluster_loop_N` clusters.

[gemini-code-assist]

The _escape_dot function escapes backslashes, which transforms the \n newline sequences used in _node_label into \\n. This causes Graphviz to render a literal backslash and 'n' instead of a newline in the node labels.

Since DOT labels allow literal newlines and the \n sequence is specifically intended for Graphviz, you should avoid escaping backslashes here, or only escape them if they are not part of a known escape sequence.

Suggested change

	def _escape_dot(text: str) -> str:
	"""Escape characters that are special inside DOT label strings."""
	return text.replace("\\", "\\\\").replace('"', '\\"')
	def _escape_dot(text: str) -> str:
	"""Escape characters that are special inside DOT label strings."""
	return text.replace('"', '\\"')

[sii-xinglong]

Good catch — the backslash escaping indeed breaks the `\n` DOT newline sequences produced by `_node_label`. Fixed by removing the backslash replacement; only double-quote escaping is needed for our labels.