Verilator

verilated_fst_c.cpp
359 строк · 14.6 Кб
Перенос по словам
1
// -*- mode: C++; c-file-style: "cc-mode" -*-
2
//=============================================================================
3
//
4
// Code available from: https://verilator.org
5
//
6
// Copyright 2001-2024 by Wilson Snyder. This program is free software; you
7
// can redistribute it and/or modify it under the terms of either the GNU
8
// Lesser General Public License Version 3 or the Perl Artistic License
9
// Version 2.0.
10
// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
11
//
12
//=============================================================================
13
///
14
/// \file
15
/// \brief Verilated C++ tracing in FST format implementation code
16
///
17
/// This file must be compiled and linked against all Verilated objects
18
/// that use --trace-fst.
19
///
20
/// Use "verilator --trace-fst" to add this to the Makefile for the linker.
21
///
22
//=============================================================================
23

24
// clang-format off
25

26
#include "verilated.h"
27
#include "verilated_fst_c.h"
28

29
// GTKWave configuration
30
#define HAVE_LIBPTHREAD
31
#define FST_WRITER_PARALLEL
32
#define LZ4_DISABLE_DEPRECATE_WARNINGS
33

34
// Include the GTKWave implementation directly
35
#define FST_CONFIG_INCLUDE "fst_config.h"
36
#include "gtkwave/fastlz.c"
37
#include "gtkwave/fstapi.c"
38
#include "gtkwave/lz4.c"
39

40
#include <algorithm>
41
#include <iterator>
42
#include <sstream>
43
#include <type_traits>
44

45
#if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
46
# include <io.h>
47
#else
48
# include <unistd.h>
49
#endif
50

51
// clang-format on
52

53
//=============================================================================
54
// Check that forward declared types matches the FST API types
55

56
static_assert(std::is_same<vlFstHandle, fstHandle>::value, "vlFstHandle mismatch");
57
static_assert(std::is_same<vlFstEnumHandle, fstEnumHandle>::value, "vlFstHandle mismatch");
58

59
//=============================================================================
60
// Specialization of the generics for this trace format
61

62
#define VL_SUB_T VerilatedFst
63
#define VL_BUF_T VerilatedFstBuffer
64
#include "verilated_trace_imp.h"
65
#undef VL_SUB_T
66
#undef VL_BUF_T
67

68
//=============================================================================
69
// VerilatedFst
70

71
VerilatedFst::VerilatedFst(void* /*fst*/) {}
72

73
VerilatedFst::~VerilatedFst() {
74
    if (m_fst) fstWriterClose(m_fst);
75
    if (m_symbolp) VL_DO_CLEAR(delete[] m_symbolp, m_symbolp = nullptr);
76
    if (m_strbufp) VL_DO_CLEAR(delete[] m_strbufp, m_strbufp = nullptr);
77
}
78

79
void VerilatedFst::open(const char* filename) VL_MT_SAFE_EXCLUDES(m_mutex) {
80
    const VerilatedLockGuard lock{m_mutex};
81
    m_fst = fstWriterCreate(filename, 1);
82
    fstWriterSetPackType(m_fst, FST_WR_PT_LZ4);
83
    fstWriterSetTimescaleFromString(m_fst, timeResStr().c_str());  // lintok-begin-on-ref
84
    if (m_useFstWriterThread) fstWriterSetParallelMode(m_fst, 1);
85
    constDump(true);  // First dump must contain the const signals
86
    fullDump(true);  // First dump must be full for fst
87

88
    Super::traceInit();
89

90
    // convert m_code2symbol into an array for fast lookup
91
    if (!m_symbolp) {
92
        m_symbolp = new fstHandle[nextCode()]{0};
93
        for (const auto& i : m_code2symbol) m_symbolp[i.first] = i.second;
94
    }
95
    m_code2symbol.clear();
96

97
    // Allocate string buffer for arrays
98
    if (!m_strbufp) m_strbufp = new char[maxBits() + 32];
99
}
100

101
void VerilatedFst::close() VL_MT_SAFE_EXCLUDES(m_mutex) {
102
    const VerilatedLockGuard lock{m_mutex};
103
    Super::closeBase();
104
    fstWriterClose(m_fst);
105
    m_fst = nullptr;
106
}
107

108
void VerilatedFst::flush() VL_MT_SAFE_EXCLUDES(m_mutex) {
109
    const VerilatedLockGuard lock{m_mutex};
110
    Super::flushBase();
111
    fstWriterFlushContext(m_fst);
112
}
113

114
void VerilatedFst::emitTimeChange(uint64_t timeui) { fstWriterEmitTimeChange(m_fst, timeui); }
115

116
//=============================================================================
117
// Decl
118

119
void VerilatedFst::declDTypeEnum(int dtypenum, const char* name, uint32_t elements,
120
                                 unsigned int minValbits, const char** itemNamesp,
121
                                 const char** itemValuesp) {
122
    const fstEnumHandle enumNum
123
        = fstWriterCreateEnumTable(m_fst, name, elements, minValbits, itemNamesp, itemValuesp);
124
    m_local2fstdtype[dtypenum] = enumNum;
125
}
126

127
// TODO: should return std::optional<fstScopeType>, but I can't have C++17
128
static std::pair<bool, fstScopeType> toFstScopeType(VerilatedTracePrefixType type) {
129
    switch (type) {
130
    case VerilatedTracePrefixType::SCOPE_MODULE: return {true, FST_ST_VCD_MODULE};
131
    case VerilatedTracePrefixType::SCOPE_INTERFACE: return {true, FST_ST_VCD_INTERFACE};
132
    case VerilatedTracePrefixType::STRUCT_PACKED:
133
    case VerilatedTracePrefixType::STRUCT_UNPACKED: return {true, FST_ST_VCD_STRUCT};
134
    case VerilatedTracePrefixType::UNION_PACKED: return {true, FST_ST_VCD_UNION};
135
    default: return {false, /* unused so whatever, just need a value */ FST_ST_VCD_SCOPE};
136
    }
137
}
138

139
void VerilatedFst::pushPrefix(const std::string& name, VerilatedTracePrefixType type) {
140
    const std::string newPrefix = m_prefixStack.back().first + name;
141
    const auto pair = toFstScopeType(type);
142
    const bool properScope = pair.first;
143
    const fstScopeType scopeType = pair.second;
144
    m_prefixStack.emplace_back(newPrefix + (properScope ? " " : ""), type);
145
    if (properScope) {
146
        const std::string scopeName = lastWord(newPrefix);
147
        fstWriterSetScope(m_fst, scopeType, scopeName.c_str(), nullptr);
148
    }
149
}
150

151
void VerilatedFst::popPrefix() {
152
    const bool properScope = toFstScopeType(m_prefixStack.back().second).first;
153
    if (properScope) fstWriterSetUpscope(m_fst);
154
    m_prefixStack.pop_back();
155
    assert(!m_prefixStack.empty());
156
}
157

158
void VerilatedFst::declare(uint32_t code, const char* name, int dtypenum,
159
                           VerilatedTraceSigDirection direction, VerilatedTraceSigKind kind,
160
                           VerilatedTraceSigType type, bool array, int arraynum, bool bussed,
161
                           int msb, int lsb) {
162
    const int bits = ((msb > lsb) ? (msb - lsb) : (lsb - msb)) + 1;
163

164
    const std::string hierarchicalName = m_prefixStack.back().first + name;
165

166
    const bool enabled = Super::declCode(code, hierarchicalName, bits);
167
    if (!enabled) return;
168

169
    assert(hierarchicalName.rfind(' ') != std::string::npos);
170
    std::stringstream name_ss;
171
    name_ss << lastWord(hierarchicalName);
172
    if (array) name_ss << "[" << arraynum << "]";
173
    if (bussed) name_ss << " [" << msb << ":" << lsb << "]";
174
    const std::string name_str = name_ss.str();
175

176
    if (dtypenum > 0) fstWriterEmitEnumTableRef(m_fst, m_local2fstdtype[dtypenum]);
177

178
    fstVarDir varDir = FST_VD_IMPLICIT;
179
    switch (direction) {
180
    case VerilatedTraceSigDirection::INOUT: varDir = FST_VD_INOUT; break;
181
    case VerilatedTraceSigDirection::OUTPUT: varDir = FST_VD_OUTPUT; break;
182
    case VerilatedTraceSigDirection::INPUT: varDir = FST_VD_INPUT; break;
183
    case VerilatedTraceSigDirection::NONE: varDir = FST_VD_IMPLICIT; break;
184
    }
185

186
    fstVarType varType;
187
    // Doubles have special decoding properties, so must indicate if a double
188
    if (type == VerilatedTraceSigType::DOUBLE) {
189
        if (kind == VerilatedTraceSigKind::PARAMETER) {
190
            varType = FST_VT_VCD_REAL_PARAMETER;
191
        } else {
192
            varType = FST_VT_VCD_REAL;
193
        }
194
    }
195
    // clang-format off
196
    else if (kind == VerilatedTraceSigKind::PARAMETER) varType = FST_VT_VCD_PARAMETER;
197
    else if (kind == VerilatedTraceSigKind::SUPPLY0) varType = FST_VT_VCD_SUPPLY0;
198
    else if (kind == VerilatedTraceSigKind::SUPPLY1) varType = FST_VT_VCD_SUPPLY1;
199
    else if (kind == VerilatedTraceSigKind::TRI) varType = FST_VT_VCD_TRI;
200
    else if (kind == VerilatedTraceSigKind::TRI0) varType = FST_VT_VCD_TRI0;
201
    else if (kind == VerilatedTraceSigKind::TRI1) varType = FST_VT_VCD_TRI1;
202
    else if (kind == VerilatedTraceSigKind::WIRE) varType = FST_VT_VCD_WIRE;
203
    //
204
    else if (type == VerilatedTraceSigType::INTEGER) varType = FST_VT_VCD_INTEGER;
205
    else if (type == VerilatedTraceSigType::BIT) varType = FST_VT_SV_BIT;
206
    else if (type == VerilatedTraceSigType::LOGIC) varType = FST_VT_SV_LOGIC;
207
    else if (type == VerilatedTraceSigType::INT) varType = FST_VT_SV_INT;
208
    else if (type == VerilatedTraceSigType::SHORTINT) varType = FST_VT_SV_SHORTINT;
209
    else if (type == VerilatedTraceSigType::LONGINT) varType = FST_VT_SV_LONGINT;
210
    else if (type == VerilatedTraceSigType::BYTE) varType = FST_VT_SV_BYTE;
211
    else if (type == VerilatedTraceSigType::EVENT) varType = FST_VT_VCD_EVENT;
212
    else if (type == VerilatedTraceSigType::TIME) varType = FST_VT_VCD_TIME;
213
    else { assert(0); /* Unreachable */ }
214
    // clang-format on
215

216
    const auto it = vlstd::as_const(m_code2symbol).find(code);
217
    if (it == m_code2symbol.end()) {  // New
218
        m_code2symbol[code]
219
            = fstWriterCreateVar(m_fst, varType, varDir, bits, name_str.c_str(), 0);
220
    } else {  // Alias
221
        fstWriterCreateVar(m_fst, varType, varDir, bits, name_str.c_str(), it->second);
222
    }
223
}
224

225
void VerilatedFst::declEvent(uint32_t code, uint32_t fidx, const char* name, int dtypenum,
226
                             VerilatedTraceSigDirection direction, VerilatedTraceSigKind kind,
227
                             VerilatedTraceSigType type, bool array, int arraynum) {
228
    declare(code, name, dtypenum, direction, kind, type, array, arraynum, false, 0, 0);
229
}
230
void VerilatedFst::declBit(uint32_t code, uint32_t fidx, const char* name, int dtypenum,
231
                           VerilatedTraceSigDirection direction, VerilatedTraceSigKind kind,
232
                           VerilatedTraceSigType type, bool array, int arraynum) {
233
    declare(code, name, dtypenum, direction, kind, type, array, arraynum, false, 0, 0);
234
}
235
void VerilatedFst::declBus(uint32_t code, uint32_t fidx, const char* name, int dtypenum,
236
                           VerilatedTraceSigDirection direction, VerilatedTraceSigKind kind,
237
                           VerilatedTraceSigType type, bool array, int arraynum, int msb,
238
                           int lsb) {
239
    declare(code, name, dtypenum, direction, kind, type, array, arraynum, true, msb, lsb);
240
}
241
void VerilatedFst::declQuad(uint32_t code, uint32_t fidx, const char* name, int dtypenum,
242
                            VerilatedTraceSigDirection direction, VerilatedTraceSigKind kind,
243
                            VerilatedTraceSigType type, bool array, int arraynum, int msb,
244
                            int lsb) {
245
    declare(code, name, dtypenum, direction, kind, type, array, arraynum, true, msb, lsb);
246
}
247
void VerilatedFst::declArray(uint32_t code, uint32_t fidx, const char* name, int dtypenum,
248
                             VerilatedTraceSigDirection direction, VerilatedTraceSigKind kind,
249
                             VerilatedTraceSigType type, bool array, int arraynum, int msb,
250
                             int lsb) {
251
    declare(code, name, dtypenum, direction, kind, type, array, arraynum, true, msb, lsb);
252
}
253
void VerilatedFst::declDouble(uint32_t code, uint32_t fidx, const char* name, int dtypenum,
254
                              VerilatedTraceSigDirection direction, VerilatedTraceSigKind kind,
255
                              VerilatedTraceSigType type, bool array, int arraynum) {
256
    declare(code, name, dtypenum, direction, kind, type, array, arraynum, false, 63, 0);
257
}
258

259
//=============================================================================
260
// Get/commit trace buffer
261

262
VerilatedFst::Buffer* VerilatedFst::getTraceBuffer(uint32_t fidx) {
263
    if (offload()) return new OffloadBuffer{*this};
264
    return new Buffer{*this};
265
}
266

267
void VerilatedFst::commitTraceBuffer(VerilatedFst::Buffer* bufp) {
268
    if (offload()) {
269
        OffloadBuffer* const offloadBufferp = static_cast<OffloadBuffer*>(bufp);
270
        if (offloadBufferp->m_offloadBufferWritep) {
271
            m_offloadBufferWritep = offloadBufferp->m_offloadBufferWritep;
272
            return;  // Buffer will be deleted by the offload thread
273
        }
274
    }
275
    delete bufp;
276
}
277

278
//=============================================================================
279
// Configure
280

281
void VerilatedFst::configure(const VerilatedTraceConfig& config) {
282
    // If at least one model requests the FST writer thread, then use it
283
    m_useFstWriterThread |= config.m_useFstWriterThread;
284
}
285

286
//=============================================================================
287
// VerilatedFstBuffer implementation
288

289
//=============================================================================
290
// Trace rendering primitives
291

292
// Note: emit* are only ever called from one place (full* in
293
// verilated_trace_imp.h, which is included in this file at the top),
294
// so always inline them.
295

296
VL_ATTR_ALWINLINE
297
void VerilatedFstBuffer::emitEvent(uint32_t code, const VlEventBase* newval) {
298
    VL_DEBUG_IFDEF(assert(m_symbolp[code]););
299
    fstWriterEmitValueChange(m_fst, m_symbolp[code], "1");
300
}
301

302
VL_ATTR_ALWINLINE
303
void VerilatedFstBuffer::emitBit(uint32_t code, CData newval) {
304
    VL_DEBUG_IFDEF(assert(m_symbolp[code]););
305
    fstWriterEmitValueChange(m_fst, m_symbolp[code], newval ? "1" : "0");
306
}
307

308
VL_ATTR_ALWINLINE
309
void VerilatedFstBuffer::emitCData(uint32_t code, CData newval, int bits) {
310
    char buf[VL_BYTESIZE];
311
    VL_DEBUG_IFDEF(assert(m_symbolp[code]););
312
    cvtCDataToStr(buf, newval << (VL_BYTESIZE - bits));
313
    fstWriterEmitValueChange(m_fst, m_symbolp[code], buf);
314
}
315

316
VL_ATTR_ALWINLINE
317
void VerilatedFstBuffer::emitSData(uint32_t code, SData newval, int bits) {
318
    char buf[VL_SHORTSIZE];
319
    VL_DEBUG_IFDEF(assert(m_symbolp[code]););
320
    cvtSDataToStr(buf, newval << (VL_SHORTSIZE - bits));
321
    fstWriterEmitValueChange(m_fst, m_symbolp[code], buf);
322
}
323

324
VL_ATTR_ALWINLINE
325
void VerilatedFstBuffer::emitIData(uint32_t code, IData newval, int bits) {
326
    char buf[VL_IDATASIZE];
327
    VL_DEBUG_IFDEF(assert(m_symbolp[code]););
328
    cvtIDataToStr(buf, newval << (VL_IDATASIZE - bits));
329
    fstWriterEmitValueChange(m_fst, m_symbolp[code], buf);
330
}
331

332
VL_ATTR_ALWINLINE
333
void VerilatedFstBuffer::emitQData(uint32_t code, QData newval, int bits) {
334
    char buf[VL_QUADSIZE];
335
    VL_DEBUG_IFDEF(assert(m_symbolp[code]););
336
    cvtQDataToStr(buf, newval << (VL_QUADSIZE - bits));
337
    fstWriterEmitValueChange(m_fst, m_symbolp[code], buf);
338
}
339

340
VL_ATTR_ALWINLINE
341
void VerilatedFstBuffer::emitWData(uint32_t code, const WData* newvalp, int bits) {
342
    int words = VL_WORDS_I(bits);
343
    char* wp = m_strbufp;
344
    // Convert the most significant word
345
    const int bitsInMSW = VL_BITBIT_E(bits) ? VL_BITBIT_E(bits) : VL_EDATASIZE;
346
    cvtEDataToStr(wp, newvalp[--words] << (VL_EDATASIZE - bitsInMSW));
347
    wp += bitsInMSW;
348
    // Convert the remaining words
349
    while (words > 0) {
350
        cvtEDataToStr(wp, newvalp[--words]);
351
        wp += VL_EDATASIZE;
352
    }
353
    fstWriterEmitValueChange(m_fst, m_symbolp[code], m_strbufp);
354
}
355

356
VL_ATTR_ALWINLINE
357
void VerilatedFstBuffer::emitDouble(uint32_t code, double newval) {
358
    fstWriterEmitValueChange(m_fst, m_symbolp[code], &newval);
359
}
360
Verilator

Использование cookies
