312 lines
9.7 KiB
Python
312 lines
9.7 KiB
Python
"""Vivado TCL session manager - maintains persistent Vivado process using pexpect."""
|
|
|
|
import pexpect
|
|
import time
|
|
import re
|
|
from typing import Optional
|
|
from dataclasses import dataclass, field
|
|
from datetime import datetime
|
|
import threading
|
|
|
|
|
|
@dataclass
|
|
class CommandResult:
|
|
"""Result from a Vivado TCL command."""
|
|
command: str
|
|
output: str
|
|
return_value: str
|
|
success: bool
|
|
elapsed_ms: float
|
|
timestamp: str = field(default_factory=lambda: datetime.now().isoformat())
|
|
|
|
|
|
class VivadoSession:
|
|
"""
|
|
Manages a persistent Vivado TCL session using pexpect.
|
|
|
|
Vivado is started once and kept running. Commands are sent and output
|
|
is captured using pexpect's expect/sendline interface.
|
|
"""
|
|
|
|
# Unique marker to detect end of command output (use something that won't appear in normal output)
|
|
SENTINEL = "XYZZY_MCP_9f8e7d6c_DONE"
|
|
|
|
def __init__(self, vivado_path: str = "vivado", timeout: float = 300.0):
|
|
self.vivado_path = vivado_path
|
|
self.timeout = timeout
|
|
self.child: Optional[pexpect.spawn] = None
|
|
self.is_running = False
|
|
self.current_project: Optional[str] = None
|
|
self._lock = threading.Lock()
|
|
|
|
# Statistics
|
|
self.stats = {
|
|
"session_start": None,
|
|
"commands_run": 0,
|
|
"total_command_time_ms": 0,
|
|
"errors": 0,
|
|
"command_history": []
|
|
}
|
|
|
|
def start(self) -> CommandResult:
|
|
"""Start the Vivado TCL session."""
|
|
if self.is_running:
|
|
return CommandResult(
|
|
command="start",
|
|
output="Session already running",
|
|
return_value="0",
|
|
success=True,
|
|
elapsed_ms=0
|
|
)
|
|
|
|
start_time = time.time()
|
|
|
|
try:
|
|
# Start Vivado with pexpect
|
|
self.child = pexpect.spawn(
|
|
f'{self.vivado_path} -mode tcl -nojournal -nolog',
|
|
encoding='utf-8',
|
|
timeout=self.timeout,
|
|
echo=False # Don't echo commands back
|
|
)
|
|
|
|
# Wait for Vivado to start (look for startup banner)
|
|
self.child.expect('Start of session', timeout=120)
|
|
|
|
# Give it a moment to fully initialize
|
|
time.sleep(1)
|
|
|
|
# Drain any remaining startup output
|
|
try:
|
|
self.child.read_nonblocking(size=100000, timeout=1)
|
|
except (pexpect.TIMEOUT, pexpect.EOF):
|
|
pass
|
|
|
|
# Wait for prompt to confirm ready
|
|
self.child.sendline("") # Empty command to get prompt
|
|
self.child.expect('Vivado%', timeout=10)
|
|
|
|
self.is_running = True
|
|
self.stats["session_start"] = datetime.now().isoformat()
|
|
|
|
elapsed = (time.time() - start_time) * 1000
|
|
|
|
return CommandResult(
|
|
command="start",
|
|
output="Vivado session started successfully",
|
|
return_value="0",
|
|
success=True,
|
|
elapsed_ms=elapsed
|
|
)
|
|
|
|
except pexpect.TIMEOUT:
|
|
self.is_running = False
|
|
elapsed = (time.time() - start_time) * 1000
|
|
return CommandResult(
|
|
command="start",
|
|
output="Failed to start Vivado: Timeout waiting for startup",
|
|
return_value="1",
|
|
success=False,
|
|
elapsed_ms=elapsed
|
|
)
|
|
except Exception as e:
|
|
self.is_running = False
|
|
elapsed = (time.time() - start_time) * 1000
|
|
return CommandResult(
|
|
command="start",
|
|
output=f"Failed to start Vivado: {str(e)}",
|
|
return_value="1",
|
|
success=False,
|
|
elapsed_ms=elapsed
|
|
)
|
|
|
|
def run_tcl(self, command: str) -> CommandResult:
|
|
"""
|
|
Execute a TCL command and return the result.
|
|
|
|
Args:
|
|
command: TCL command to execute
|
|
|
|
Returns:
|
|
CommandResult with output and status
|
|
"""
|
|
if not self.is_running:
|
|
return CommandResult(
|
|
command=command,
|
|
output="Vivado session not running. Call start() first.",
|
|
return_value="1",
|
|
success=False,
|
|
elapsed_ms=0
|
|
)
|
|
|
|
with self._lock:
|
|
start_time = time.time()
|
|
|
|
try:
|
|
# Clear any pending output first
|
|
try:
|
|
self.child.read_nonblocking(size=100000, timeout=0.1)
|
|
except (pexpect.TIMEOUT, pexpect.EOF):
|
|
pass
|
|
|
|
# Send the command
|
|
self.child.sendline(command)
|
|
|
|
# Wait for Vivado prompt (indicates command completed)
|
|
self.child.expect('Vivado%', timeout=self.timeout)
|
|
|
|
# Get the output (everything before the prompt)
|
|
raw_output = self.child.before
|
|
|
|
# Parse output: extract content after command echo
|
|
lines = raw_output.replace('\r', '').split('\n')
|
|
clean_lines = []
|
|
found_command = False
|
|
|
|
# Normalize command for matching
|
|
cmd_normalized = command.strip()
|
|
|
|
for line in lines:
|
|
stripped = line.strip()
|
|
|
|
# Look for the command echo
|
|
if not found_command:
|
|
if cmd_normalized in stripped:
|
|
found_command = True
|
|
continue
|
|
|
|
# Skip Vivado prompts
|
|
if stripped == 'Vivado%' or stripped.startswith('Vivado%'):
|
|
continue
|
|
|
|
# Skip empty lines
|
|
if not stripped:
|
|
continue
|
|
|
|
clean_lines.append(stripped)
|
|
|
|
output = '\n'.join(clean_lines).strip()
|
|
|
|
elapsed = (time.time() - start_time) * 1000
|
|
|
|
# Check for errors in output
|
|
success = not any(err in output.lower() for err in
|
|
["error:", "invalid command", "can't read", "wrong # args"])
|
|
|
|
# Update stats
|
|
self.stats["commands_run"] += 1
|
|
self.stats["total_command_time_ms"] += elapsed
|
|
if not success:
|
|
self.stats["errors"] += 1
|
|
|
|
result = CommandResult(
|
|
command=command,
|
|
output=output,
|
|
return_value="0" if success else "1",
|
|
success=success,
|
|
elapsed_ms=elapsed
|
|
)
|
|
|
|
# Keep last 100 commands in history
|
|
self.stats["command_history"].append({
|
|
"command": command,
|
|
"success": success,
|
|
"elapsed_ms": elapsed,
|
|
"timestamp": result.timestamp
|
|
})
|
|
if len(self.stats["command_history"]) > 100:
|
|
self.stats["command_history"] = self.stats["command_history"][-100:]
|
|
|
|
return result
|
|
|
|
except pexpect.TIMEOUT:
|
|
elapsed = (time.time() - start_time) * 1000
|
|
self.stats["errors"] += 1
|
|
return CommandResult(
|
|
command=command,
|
|
output=f"Command timed out after {self.timeout}s",
|
|
return_value="1",
|
|
success=False,
|
|
elapsed_ms=elapsed
|
|
)
|
|
except Exception as e:
|
|
elapsed = (time.time() - start_time) * 1000
|
|
self.stats["errors"] += 1
|
|
return CommandResult(
|
|
command=command,
|
|
output=f"Error executing command: {str(e)}",
|
|
return_value="1",
|
|
success=False,
|
|
elapsed_ms=elapsed
|
|
)
|
|
|
|
def stop(self) -> CommandResult:
|
|
"""Stop the Vivado session."""
|
|
if not self.is_running:
|
|
return CommandResult(
|
|
command="stop",
|
|
output="Session not running",
|
|
return_value="0",
|
|
success=True,
|
|
elapsed_ms=0
|
|
)
|
|
|
|
start_time = time.time()
|
|
|
|
try:
|
|
self.child.sendline('exit')
|
|
self.child.expect(pexpect.EOF, timeout=30)
|
|
except Exception:
|
|
# Force close if graceful exit fails
|
|
try:
|
|
self.child.close(force=True)
|
|
except:
|
|
pass
|
|
|
|
self.is_running = False
|
|
self.current_project = None
|
|
elapsed = (time.time() - start_time) * 1000
|
|
|
|
return CommandResult(
|
|
command="stop",
|
|
output="Vivado session stopped",
|
|
return_value="0",
|
|
success=True,
|
|
elapsed_ms=elapsed
|
|
)
|
|
|
|
def get_stats(self) -> dict:
|
|
"""Get session statistics."""
|
|
stats = self.stats.copy()
|
|
stats["is_running"] = self.is_running
|
|
stats["current_project"] = self.current_project
|
|
if self.stats["commands_run"] > 0:
|
|
stats["avg_command_time_ms"] = self.stats["total_command_time_ms"] / self.stats["commands_run"]
|
|
return stats
|
|
|
|
def __enter__(self):
|
|
self.start()
|
|
return self
|
|
|
|
def __exit__(self, exc_type, exc_val, exc_tb):
|
|
self.stop()
|
|
|
|
|
|
# Singleton session instance
|
|
_session: Optional[VivadoSession] = None
|
|
|
|
|
|
def get_session() -> VivadoSession:
|
|
"""Get or create the global Vivado session."""
|
|
global _session
|
|
if _session is None:
|
|
_session = VivadoSession()
|
|
return _session
|
|
|
|
|
|
def reset_session():
|
|
"""Reset the global session (stop if running)."""
|
|
global _session
|
|
if _session is not None and _session.is_running:
|
|
_session.stop()
|
|
_session = None
|