468 lines
13 KiB
TypeScript
468 lines
13 KiB
TypeScript
/**
|
||
* VCD (Value Change Dump) 解析器
|
||
* 纯 TypeScript 实现，参照 VerilogCoder 项目格式
|
||
*
|
||
* @deprecated 当前未使用，保留备用
|
||
* 目前使用 waveformTracer.ts 调用 Python 打包的 waveform_trace.exe
|
||
* 未来可能用此文件替换 Python 实现
|
||
*/
|
||
import * as fs from 'fs';
|
||
import * as path from 'path';
|
||
|
||
// ==================== 类型定义 ====================
|
||
|
||
/** 信号定义 */
|
||
export interface VcdSignal {
|
||
name: string; // 完整路径名，如 "tb.top_module.data"
|
||
shortName: string; // 短名，如 "data"
|
||
symbolId: string; // VCD 符号 ID，如 "!", "#"
|
||
width: number; // 位宽
|
||
varType: string; // 变量类型：wire, reg
|
||
module: string; // 所属模块
|
||
}
|
||
|
||
/** 时间-值对 */
|
||
export interface TimeValue {
|
||
time: number;
|
||
value: string;
|
||
}
|
||
|
||
/** 信号波形数据 */
|
||
export interface SignalWaveform {
|
||
signal: VcdSignal;
|
||
changes: TimeValue[];
|
||
}
|
||
|
||
/** VCD 解析结果 */
|
||
export interface VcdData {
|
||
date?: string;
|
||
version?: string;
|
||
timescale: string;
|
||
endTime: number;
|
||
signals: Map<string, VcdSignal>; // symbolId -> signal
|
||
waveforms: Map<string, TimeValue[]>; // symbolId -> changes
|
||
}
|
||
|
||
/** Mismatch 信息 */
|
||
export interface MismatchInfo {
|
||
time: number;
|
||
signal: string;
|
||
dutValue: string;
|
||
refValue: string;
|
||
}
|
||
|
||
// ==================== VCD 解析器 ====================
|
||
|
||
export class VcdParser {
|
||
private signals: Map<string, VcdSignal> = new Map();
|
||
private waveforms: Map<string, TimeValue[]> = new Map();
|
||
private scopeStack: string[] = [];
|
||
private timescale: string = '1ns';
|
||
private currentTime: number = 0;
|
||
private endTime: number = 0;
|
||
private date?: string;
|
||
private version?: string;
|
||
|
||
/**
|
||
* 解析 VCD 文件
|
||
*/
|
||
parse(filePath: string): VcdData {
|
||
const content = fs.readFileSync(filePath, 'utf-8');
|
||
return this.parseContent(content);
|
||
}
|
||
|
||
/**
|
||
* 解析 VCD 内容
|
||
*/
|
||
parseContent(content: string): VcdData {
|
||
// 预处理：将多行指令合并成单行
|
||
const normalizedContent = this.normalizeVcdContent(content);
|
||
const lines = normalizedContent.split('\n');
|
||
let inDefinitions = true;
|
||
|
||
for (const rawLine of lines) {
|
||
const line = rawLine.trim();
|
||
if (!line) continue;
|
||
|
||
if (inDefinitions) {
|
||
// 解析定义区
|
||
if (line.startsWith('$enddefinitions')) {
|
||
inDefinitions = false;
|
||
continue;
|
||
}
|
||
this.parseDefinition(line);
|
||
} else {
|
||
// 解析数据区
|
||
this.parseValueChange(line);
|
||
}
|
||
}
|
||
|
||
return {
|
||
date: this.date,
|
||
version: this.version,
|
||
timescale: this.timescale,
|
||
endTime: this.endTime,
|
||
signals: this.signals,
|
||
waveforms: this.waveforms
|
||
};
|
||
}
|
||
|
||
private parseDefinition(line: string): void {
|
||
if (line.startsWith('$date')) {
|
||
this.date = this.extractValue(line);
|
||
} else if (line.startsWith('$version')) {
|
||
this.version = this.extractValue(line);
|
||
} else if (line.startsWith('$timescale')) {
|
||
this.timescale = this.extractValue(line) || '1ns';
|
||
} else if (line.startsWith('$scope')) {
|
||
const match = line.match(/\$scope\s+\w+\s+(\S+)/);
|
||
if (match) {
|
||
this.scopeStack.push(match[1]);
|
||
}
|
||
} else if (line.startsWith('$upscope')) {
|
||
this.scopeStack.pop();
|
||
} else if (line.startsWith('$var')) {
|
||
this.parseVariable(line);
|
||
}
|
||
}
|
||
|
||
private parseVariable(line: string): void {
|
||
// $var wire 8 # data [7:0] $end
|
||
// $var reg 1 ! clk $end
|
||
const match = line.match(/\$var\s+(\w+)\s+(\d+)\s+(\S+)\s+(\S+)/);
|
||
if (!match) return;
|
||
|
||
const [, varType, widthStr, symbolId, name] = match;
|
||
const width = parseInt(widthStr, 10);
|
||
const module = this.scopeStack.join('.');
|
||
const fullName = module ? `${module}.${name}` : name;
|
||
|
||
const signal: VcdSignal = {
|
||
name: fullName,
|
||
shortName: name.replace(/\[\d+:\d+\]/, ''), // 移除位宽标注
|
||
symbolId,
|
||
width,
|
||
varType,
|
||
module
|
||
};
|
||
|
||
this.signals.set(symbolId, signal);
|
||
this.waveforms.set(symbolId, []);
|
||
}
|
||
|
||
private parseValueChange(line: string): void {
|
||
if (line.startsWith('#')) {
|
||
// 时间戳: #100
|
||
this.currentTime = parseInt(line.substring(1), 10);
|
||
this.endTime = Math.max(this.endTime, this.currentTime);
|
||
} else if (line.startsWith('b') || line.startsWith('B')) {
|
||
// 多位值: b10101010 #
|
||
const spaceIdx = line.indexOf(' ');
|
||
if (spaceIdx > 0) {
|
||
const value = line.substring(1, spaceIdx);
|
||
const symbolId = line.substring(spaceIdx + 1).trim();
|
||
this.addChange(symbolId, value);
|
||
}
|
||
} else if (line.length >= 2 && !line.startsWith('$')) {
|
||
// 单位值: 0! 或 1# 或 x$
|
||
const value = line[0];
|
||
const symbolId = line.substring(1).trim();
|
||
if (symbolId && this.signals.has(symbolId)) {
|
||
this.addChange(symbolId, value);
|
||
}
|
||
}
|
||
}
|
||
|
||
private addChange(symbolId: string, value: string): void {
|
||
const changes = this.waveforms.get(symbolId);
|
||
if (changes) {
|
||
changes.push({ time: this.currentTime, value });
|
||
}
|
||
}
|
||
|
||
private extractValue(line: string): string {
|
||
// 提取 $xxx value $end 中的 value
|
||
const match = line.match(/\$\w+\s+(.+?)\s*\$end/);
|
||
return match ? match[1].trim() : '';
|
||
}
|
||
|
||
/**
|
||
* 预处理 VCD 内容，将多行指令合并成单行
|
||
*/
|
||
private normalizeVcdContent(content: string): string {
|
||
// 将多行 $xxx ... $end 合并成单行
|
||
return content.replace(/(\$\w+)\s*\n\s*([^\$]+?)\s*\n\s*(\$end)/g, '$1 $2 $3');
|
||
}
|
||
}
|
||
|
||
// ==================== 波形分析工具 ====================
|
||
|
||
/**
|
||
* 二进制字符串转十六进制
|
||
*/
|
||
export function binaryToHex(binary: string): string {
|
||
if (binary === 'x' || binary === 'X' || binary.includes('x')) {
|
||
return 'xx';
|
||
}
|
||
if (binary === 'z' || binary === 'Z' || binary.includes('z')) {
|
||
return 'zz';
|
||
}
|
||
if (binary.length <= 1) {
|
||
return binary;
|
||
}
|
||
// 补齐到 4 的倍数
|
||
const padded = binary.padStart(Math.ceil(binary.length / 4) * 4, '0');
|
||
let hex = '';
|
||
for (let i = 0; i < padded.length; i += 4) {
|
||
hex += parseInt(padded.substring(i, i + 4), 2).toString(16);
|
||
}
|
||
return hex;
|
||
}
|
||
|
||
/**
|
||
* 获取信号在指定时间的值
|
||
*/
|
||
export function getValueAtTime(
|
||
changes: TimeValue[],
|
||
time: number
|
||
): string {
|
||
let value = 'x';
|
||
for (const change of changes) {
|
||
if (change.time <= time) {
|
||
value = change.value;
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
return value;
|
||
}
|
||
|
||
/**
|
||
* 查找 DUT 和 REF 信号的第一个 mismatch
|
||
*/
|
||
export function findFirstMismatch(
|
||
vcdData: VcdData,
|
||
dutSignals: string[],
|
||
refSignals: string[]
|
||
): MismatchInfo | null {
|
||
// 收集所有时间点
|
||
const allTimes = new Set<number>();
|
||
for (const changes of vcdData.waveforms.values()) {
|
||
for (const c of changes) {
|
||
allTimes.add(c.time);
|
||
}
|
||
}
|
||
const sortedTimes = Array.from(allTimes).sort((a, b) => a - b);
|
||
|
||
// 按信号名匹配 DUT 和 REF
|
||
for (const time of sortedTimes) {
|
||
for (let i = 0; i < dutSignals.length; i++) {
|
||
const dutSig = findSignalByName(vcdData, dutSignals[i]);
|
||
const refSig = findSignalByName(vcdData, refSignals[i]);
|
||
|
||
if (!dutSig || !refSig) continue;
|
||
|
||
const dutChanges = vcdData.waveforms.get(dutSig.symbolId) || [];
|
||
const refChanges = vcdData.waveforms.get(refSig.symbolId) || [];
|
||
|
||
const dutVal = getValueAtTime(dutChanges, time);
|
||
const refVal = getValueAtTime(refChanges, time);
|
||
|
||
// 跳过未知值
|
||
if (dutVal.includes('x') || refVal.includes('x')) continue;
|
||
|
||
if (dutVal !== refVal) {
|
||
return {
|
||
time,
|
||
signal: dutSig.shortName,
|
||
dutValue: binaryToHex(dutVal),
|
||
refValue: binaryToHex(refVal)
|
||
};
|
||
}
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* 按名称查找信号
|
||
*/
|
||
function findSignalByName(vcdData: VcdData, name: string): VcdSignal | null {
|
||
for (const signal of vcdData.signals.values()) {
|
||
if (signal.name.endsWith(name) || signal.shortName === name) {
|
||
return signal;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* 生成波形表格（参照 VerilogCoder 格式）
|
||
*/
|
||
export function generateWaveformTable(
|
||
vcdData: VcdData,
|
||
signalNames: string[],
|
||
startTime: number = 0,
|
||
endTime?: number,
|
||
windowSize: number = 20
|
||
): string {
|
||
const actualEndTime = endTime ?? vcdData.endTime;
|
||
|
||
// 查找信号
|
||
const signals: VcdSignal[] = [];
|
||
for (const name of signalNames) {
|
||
const sig = findSignalByName(vcdData, name);
|
||
if (sig) signals.push(sig);
|
||
}
|
||
|
||
if (signals.length === 0) {
|
||
return '未找到指定信号';
|
||
}
|
||
|
||
// 收集时间点
|
||
const times = new Set<number>();
|
||
for (const sig of signals) {
|
||
const changes = vcdData.waveforms.get(sig.symbolId) || [];
|
||
for (const c of changes) {
|
||
if (c.time >= startTime && c.time <= actualEndTime) {
|
||
times.add(c.time);
|
||
}
|
||
}
|
||
}
|
||
|
||
let sortedTimes = Array.from(times).sort((a, b) => a - b);
|
||
if (sortedTimes.length > windowSize) {
|
||
sortedTimes = sortedTimes.slice(0, windowSize);
|
||
}
|
||
|
||
// 生成表头
|
||
const headers = ['time(ns)', ...signals.map(s => s.shortName)];
|
||
const colWidths = headers.map(h => Math.max(h.length, 8));
|
||
|
||
let table = '### Waveform Trace ###\n';
|
||
table += headers.map((h, i) => h.padEnd(colWidths[i])).join(' ') + '\n';
|
||
table += colWidths.map(w => '─'.repeat(w)).join('──') + '\n';
|
||
|
||
// 生成数据行
|
||
for (const time of sortedTimes) {
|
||
const row = [time.toString()];
|
||
for (const sig of signals) {
|
||
const changes = vcdData.waveforms.get(sig.symbolId) || [];
|
||
const val = getValueAtTime(changes, time);
|
||
row.push(binaryToHex(val));
|
||
}
|
||
table += row.map((v, i) => v.padEnd(colWidths[i])).join(' ') + '\n';
|
||
}
|
||
|
||
table += '### Waveform Trace End ###\n';
|
||
return table;
|
||
}
|
||
|
||
/**
|
||
* 获取信号显示名称（模块.信号名[位宽]）
|
||
*/
|
||
function getSignalDisplayName(sig: VcdSignal): string {
|
||
const moduleParts = sig.module.split('.');
|
||
const moduleShort = moduleParts[moduleParts.length - 1] || '';
|
||
const bitInfo = sig.width > 1 ? `[${sig.width - 1}:0]` : '';
|
||
return moduleShort ? `${moduleShort}.${sig.shortName}${bitInfo}` : `${sig.shortName}${bitInfo}`;
|
||
}
|
||
|
||
/**
|
||
* 生成变化日志格式（只记录信号变化）
|
||
*/
|
||
export function generateChangeLog(vcdData: VcdData): string {
|
||
// 筛选信号（排除 parameter）
|
||
const signals: VcdSignal[] = [];
|
||
for (const sig of vcdData.signals.values()) {
|
||
if (sig.varType !== 'parameter') {
|
||
signals.push(sig);
|
||
}
|
||
}
|
||
|
||
// 收集所有时间点
|
||
const times = new Set<number>();
|
||
for (const sig of signals) {
|
||
const changes = vcdData.waveforms.get(sig.symbolId) || [];
|
||
for (const c of changes) {
|
||
times.add(c.time);
|
||
}
|
||
}
|
||
const sortedTimes = Array.from(times).sort((a, b) => a - b);
|
||
|
||
// 记录每个信号的上一个值
|
||
const lastValues = new Map<string, string | null>();
|
||
for (const sig of signals) {
|
||
lastValues.set(sig.symbolId, null);
|
||
}
|
||
|
||
let log = '';
|
||
|
||
for (const time of sortedTimes) {
|
||
const changes: string[] = [];
|
||
|
||
for (const sig of signals) {
|
||
const waveform = vcdData.waveforms.get(sig.symbolId) || [];
|
||
const currentVal = binaryToHex(getValueAtTime(waveform, time));
|
||
const lastVal = lastValues.get(sig.symbolId);
|
||
|
||
if (lastVal === null) {
|
||
changes.push(`${getSignalDisplayName(sig)}=${currentVal}`);
|
||
} else if (currentVal !== lastVal) {
|
||
changes.push(`${getSignalDisplayName(sig)} ${lastVal}→${currentVal}`);
|
||
}
|
||
|
||
lastValues.set(sig.symbolId, currentVal);
|
||
}
|
||
|
||
if (changes.length > 0) {
|
||
log += `#${time}: ${changes.join(', ')}\n`;
|
||
}
|
||
}
|
||
|
||
return log;
|
||
}
|
||
|
||
/**
|
||
* 分析 VCD 文件（主入口）
|
||
*/
|
||
export function analyzeVcdFile(
|
||
filePath: string,
|
||
signalFilter?: string,
|
||
checkpoint?: number
|
||
): string {
|
||
// 解析 VCD
|
||
const parser = new VcdParser();
|
||
const vcdData = parser.parse(filePath);
|
||
|
||
// 解析信号过滤器
|
||
const signalNames = signalFilter
|
||
? signalFilter.split(',').map(s => s.trim())
|
||
: Array.from(vcdData.signals.values()).map(s => s.shortName);
|
||
|
||
// 生成摘要
|
||
let result = `=== VCD 波形分析 ===\n`;
|
||
result += `文件: ${path.basename(filePath)}\n`;
|
||
result += `时间单位: ${vcdData.timescale}\n`;
|
||
result += `仿真时长: 0 - ${vcdData.endTime}${vcdData.timescale}\n\n`;
|
||
|
||
// 信号列表
|
||
result += `--- 信号列表 (${vcdData.signals.size} 个) ---\n`;
|
||
let idx = 1;
|
||
for (const sig of vcdData.signals.values()) {
|
||
if (idx <= 10) {
|
||
result += `${idx}. ${sig.shortName} (${sig.width}-bit, ${sig.varType})\n`;
|
||
}
|
||
idx++;
|
||
}
|
||
if (vcdData.signals.size > 10) {
|
||
result += `... 还有 ${vcdData.signals.size - 10} 个信号\n`;
|
||
}
|
||
result += '\n';
|
||
|
||
// 变化日志
|
||
result += generateChangeLog(vcdData);
|
||
|
||
return result;
|
||
}
|