luke
/
verilator
mirror of https://github.com/verilator/verilator.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[#74021] add VerilatedSaif prefix to helper classes

This commit is contained in:
Mateusz Gancarz 2025-03-04 13:42:35 +01:00
parent dc94cb2c5c
commit 72787320e7
2 changed files with 35 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
include/verilated_saif_c.cpp
View File

@ -62,17 +62,17 @@
//============================================================================= //=============================================================================
//============================================================================= //=============================================================================
//============================================================================= //=============================================================================
// ActivityVar // VerilatedSaifActivityVar
VL_ATTR_ALWINLINE VL_ATTR_ALWINLINE
void ActivityVar::emitBit(uint64_t time, CData newval) { void VerilatedSaifActivityVar::emitBit(uint64_t time, CData newval) {
assert(m_lastTime <= time); assert(m_lastTime <= time);
m_bits[0].aggregateVal(time - m_lastTime, newval); m_bits[0].aggregateVal(time - m_lastTime, newval);
updateLastTime(time); updateLastTime(time);
} }
VL_ATTR_ALWINLINE VL_ATTR_ALWINLINE
void ActivityVar::emitWData(uint64_t time, const WData* newvalp, uint32_t bits) { void VerilatedSaifActivityVar::emitWData(uint64_t time, const WData* newvalp, uint32_t bits) {
assert(m_lastTime <= time); assert(m_lastTime <= time);
uint64_t dt = time - m_lastTime; uint64_t dt = time - m_lastTime;
for (std::size_t i = 0; i < std::min(m_width, bits); ++i) { for (std::size_t i = 0; i < std::min(m_width, bits); ++i) {
@ -83,7 +83,7 @@ void ActivityVar::emitWData(uint64_t time, const WData* newvalp, uint32_t bits)
updateLastTime(time); updateLastTime(time);
} }
ActivityBit& ActivityVar::getBit(std::size_t index) { VerilatedSaifActivityBit& VerilatedSaifActivityVar::getBit(std::size_t index) {
assert(index < m_width); assert(index < m_width);
return m_bits[index]; return m_bits[index];
} }
@ -256,7 +256,7 @@ void VerilatedSaif::finalizeSaifFileContents() {
} }
void VerilatedSaif::recursivelyPrintScopes(uint32_t scopeIndex) { void VerilatedSaif::recursivelyPrintScopes(uint32_t scopeIndex) {
const ActivityScope& scope = m_scopes.at(scopeIndex); const VerilatedSaifActivityScope& scope = m_scopes.at(scopeIndex);
openInstanceScope(scope.getName()); openInstanceScope(scope.getName());
@ -283,7 +283,7 @@ void VerilatedSaif::closeInstanceScope() {
printStr(")\n"); printStr(")\n");
} }
void VerilatedSaif::printScopeActivities(const ActivityScope& scope) { void VerilatedSaif::printScopeActivities(const VerilatedSaifActivityScope& scope) {
bool anyNetValid{false}; bool anyNetValid{false};
for (auto& childSignal : scope.getChildActivities()) { for (auto& childSignal : scope.getChildActivities()) {
uint32_t code = childSignal.first; uint32_t code = childSignal.first;
@ -308,9 +308,9 @@ void VerilatedSaif::closeNetScope() {
bool VerilatedSaif::printActivityStats(uint32_t activityCode, const char* activityName, bool VerilatedSaif::printActivityStats(uint32_t activityCode, const char* activityName,
bool anyNetValid) { bool anyNetValid) {
ActivityVar& activity = m_activity.at(activityCode); VerilatedSaifActivityVar& activity = m_activity.at(activityCode);
for (size_t i = 0; i < activity.getWidth(); i++) { for (size_t i = 0; i < activity.getWidth(); i++) {
ActivityBit& bit = activity.getBit(i); VerilatedSaifActivityBit& bit = activity.getBit(i);
if (bit.getToggleCount() <= 0) { if (bit.getToggleCount() <= 0) {
// Skip bits with no toggles // Skip bits with no toggles
@ -444,7 +444,7 @@ void VerilatedSaif::declare(uint32_t code, const char* name, const char* wirep,
m_scopes.at(m_currentScope).addActivityVar(code, std::move(finalName)); m_scopes.at(m_currentScope).addActivityVar(code, std::move(finalName));
m_activity.emplace( m_activity.emplace(
code, ActivityVar{static_cast<uint32_t>(bits), m_activityArena.back().data() + bitsIdx}); code, VerilatedSaifActivityVar{static_cast<uint32_t>(bits), m_activityArena.back().data() + bitsIdx});
} }
void VerilatedSaif::declEvent(uint32_t code, uint32_t fidx, const char* name, int dtypenum, void VerilatedSaif::declEvent(uint32_t code, uint32_t fidx, const char* name, int dtypenum,
@ -504,42 +504,42 @@ void VerilatedSaifBuffer::emitEvent(uint32_t code) {
VL_ATTR_ALWINLINE VL_ATTR_ALWINLINE
void VerilatedSaifBuffer::emitBit(uint32_t code, CData newval) { void VerilatedSaifBuffer::emitBit(uint32_t code, CData newval) {
assert(m_owner.m_activity.count(code) && "Activity must be declared earlier"); assert(m_owner.m_activity.count(code) && "Activity must be declared earlier");
ActivityVar& activity = m_owner.m_activity.at(code); VerilatedSaifActivityVar& activity = m_owner.m_activity.at(code);
activity.emitBit(m_owner.getCurrentTime(), newval); activity.emitBit(m_owner.getCurrentTime(), newval);
} }
VL_ATTR_ALWINLINE VL_ATTR_ALWINLINE
void VerilatedSaifBuffer::emitCData(uint32_t code, CData newval, int bits) { void VerilatedSaifBuffer::emitCData(uint32_t code, CData newval, int bits) {
assert(m_owner.m_activity.count(code) && "Activity must be declared earlier"); assert(m_owner.m_activity.count(code) && "Activity must be declared earlier");
ActivityVar& activity = m_owner.m_activity.at(code); VerilatedSaifActivityVar& activity = m_owner.m_activity.at(code);
activity.emitData<CData>(m_owner.getCurrentTime(), newval, bits); activity.emitData<CData>(m_owner.getCurrentTime(), newval, bits);
} }
VL_ATTR_ALWINLINE VL_ATTR_ALWINLINE
void VerilatedSaifBuffer::emitSData(uint32_t code, SData newval, int bits) { void VerilatedSaifBuffer::emitSData(uint32_t code, SData newval, int bits) {
assert(m_owner.m_activity.count(code) && "Activity must be declared earlier"); assert(m_owner.m_activity.count(code) && "Activity must be declared earlier");
ActivityVar& activity = m_owner.m_activity.at(code); VerilatedSaifActivityVar& activity = m_owner.m_activity.at(code);
activity.emitData<SData>(m_owner.getCurrentTime(), newval, bits); activity.emitData<SData>(m_owner.getCurrentTime(), newval, bits);
} }
VL_ATTR_ALWINLINE VL_ATTR_ALWINLINE
void VerilatedSaifBuffer::emitIData(uint32_t code, IData newval, int bits) { void VerilatedSaifBuffer::emitIData(uint32_t code, IData newval, int bits) {
assert(m_owner.m_activity.count(code) && "Activity must be declared earlier"); assert(m_owner.m_activity.count(code) && "Activity must be declared earlier");
ActivityVar& activity = m_owner.m_activity.at(code); VerilatedSaifActivityVar& activity = m_owner.m_activity.at(code);
activity.emitData<IData>(m_owner.getCurrentTime(), newval, bits); activity.emitData<IData>(m_owner.getCurrentTime(), newval, bits);
} }
VL_ATTR_ALWINLINE VL_ATTR_ALWINLINE
void VerilatedSaifBuffer::emitQData(uint32_t code, QData newval, int bits) { void VerilatedSaifBuffer::emitQData(uint32_t code, QData newval, int bits) {
assert(m_owner.m_activity.count(code) && "Activity must be declared earlier"); assert(m_owner.m_activity.count(code) && "Activity must be declared earlier");
ActivityVar& activity = m_owner.m_activity.at(code); VerilatedSaifActivityVar& activity = m_owner.m_activity.at(code);
activity.emitData<QData>(m_owner.getCurrentTime(), newval, bits); activity.emitData<QData>(m_owner.getCurrentTime(), newval, bits);
} }
VL_ATTR_ALWINLINE VL_ATTR_ALWINLINE
void VerilatedSaifBuffer::emitWData(uint32_t code, const WData* newvalp, int bits) { void VerilatedSaifBuffer::emitWData(uint32_t code, const WData* newvalp, int bits) {
assert(m_owner.m_activity.count(code) && "Activity must be declared earlier"); assert(m_owner.m_activity.count(code) && "Activity must be declared earlier");
ActivityVar& activity = m_owner.m_activity.at(code); VerilatedSaifActivityVar& activity = m_owner.m_activity.at(code);
activity.emitWData(m_owner.getCurrentTime(), newvalp, bits); activity.emitWData(m_owner.getCurrentTime(), newvalp, bits);
} }

40
include/verilated_saif_c.h
View File

@ -32,9 +32,9 @@ class VerilatedSaifBuffer;
class VerilatedSaifFile; class VerilatedSaifFile;
//============================================================================= //=============================================================================
// ActivityBit // VerilatedSaifActivityBit
class ActivityBit final { class VerilatedSaifActivityBit final {
public: public:
// METHODS // METHODS
VL_ATTR_ALWINLINE VL_ATTR_ALWINLINE
@ -57,17 +57,17 @@ private:
}; };
//============================================================================= //=============================================================================
// ActivityVar // VerilatedSaifActivityVar
class ActivityVar final { class VerilatedSaifActivityVar final {
public: public:
// CONSTRUCTORS // CONSTRUCTORS
ActivityVar(uint32_t width, ActivityBit* bits) VerilatedSaifActivityVar(uint32_t width, VerilatedSaifActivityBit* bits)
: m_bits{bits} : m_bits{bits}
, m_width{width} {} , m_width{width} {}
ActivityVar(ActivityVar&&) = default; VerilatedSaifActivityVar(VerilatedSaifActivityVar&&) = default;
ActivityVar& operator=(ActivityVar&&) = default; VerilatedSaifActivityVar& operator=(VerilatedSaifActivityVar&&) = default;
// METHODS // METHODS
VL_ATTR_ALWINLINE void emitBit(uint64_t time, CData newval); VL_ATTR_ALWINLINE void emitBit(uint64_t time, CData newval);
@ -89,31 +89,31 @@ public:
// ACCESSORS // ACCESSORS
VL_ATTR_ALWINLINE uint32_t getWidth() const { return m_width; } VL_ATTR_ALWINLINE uint32_t getWidth() const { return m_width; }
VL_ATTR_ALWINLINE ActivityBit& getBit(std::size_t index); VL_ATTR_ALWINLINE VerilatedSaifActivityBit& getBit(std::size_t index);
VL_ATTR_ALWINLINE uint64_t getLastUpdateTime() const { return m_lastTime; } VL_ATTR_ALWINLINE uint64_t getLastUpdateTime() const { return m_lastTime; }
private: private:
// CONSTRUCTORS // CONSTRUCTORS
VL_UNCOPYABLE(ActivityVar); VL_UNCOPYABLE(VerilatedSaifActivityVar);
// MEMBERS // MEMBERS
uint64_t m_lastTime{0}; uint64_t m_lastTime{0};
ActivityBit* m_bits; VerilatedSaifActivityBit* m_bits;
uint32_t m_width; uint32_t m_width;
}; };
//============================================================================= //=============================================================================
// ActivityScope // VerilatedSaifActivityScope
class ActivityScope final { class VerilatedSaifActivityScope final {
public: public:
// CONSTRUCTORS // CONSTRUCTORS
ActivityScope(std::string name, int32_t parentScopeIndex = -1) VerilatedSaifActivityScope(std::string name, int32_t parentScopeIndex = -1)
: m_scopeName{std::move(name)} : m_scopeName{std::move(name)}
, m_parentScopeIndex{parentScopeIndex} {} , m_parentScopeIndex{parentScopeIndex} {}
ActivityScope(ActivityScope&&) = default; VerilatedSaifActivityScope(VerilatedSaifActivityScope&&) = default;
ActivityScope& operator=(ActivityScope&&) = default; VerilatedSaifActivityScope& operator=(VerilatedSaifActivityScope&&) = default;
// METHODS // METHODS
VL_ATTR_ALWINLINE void addChildScopeIndex(int32_t index) { VL_ATTR_ALWINLINE void addChildScopeIndex(int32_t index) {
@ -137,7 +137,7 @@ public:
private: private:
// CONSTRUCTORS // CONSTRUCTORS
VL_UNCOPYABLE(ActivityScope); VL_UNCOPYABLE(VerilatedSaifActivityScope);
// MEMBERS // MEMBERS
std::string m_scopeName{}; std::string m_scopeName{};
@ -172,7 +172,7 @@ private:
void recursivelyPrintScopes(uint32_t scopeIndex); void recursivelyPrintScopes(uint32_t scopeIndex);
void openInstanceScope(const std::string& instanceName); void openInstanceScope(const std::string& instanceName);
void closeInstanceScope(); void closeInstanceScope();
void printScopeActivities(const ActivityScope& scope); void printScopeActivities(const VerilatedSaifActivityScope& scope);
void openNetScope(); void openNetScope();
void closeNetScope(); void closeNetScope();
bool printActivityStats(uint32_t activityCode, const char* activityName, bool anyNetValid); bool printActivityStats(uint32_t activityCode, const char* activityName, bool anyNetValid);
@ -189,11 +189,11 @@ private:
void clearCurrentlyCollectedData(); void clearCurrentlyCollectedData();
int32_t m_currentScope{-1}; int32_t m_currentScope{-1};
std::vector<ActivityScope> m_scopes{}; std::vector<VerilatedSaifActivityScope> m_scopes{};
std::vector<int32_t> m_topScopes{}; std::vector<int32_t> m_topScopes{};
std::unordered_map<uint32_t, ActivityVar> m_activity; std::unordered_map<uint32_t, VerilatedSaifActivityVar> m_activity;
std::vector<std::vector<ActivityBit>> m_activityArena; std::vector<std::vector<VerilatedSaifActivityBit>> m_activityArena;
VL_ATTR_ALWINLINE uint64_t getCurrentTime() const { return m_totalTime - m_currentTimeOrigin; } VL_ATTR_ALWINLINE uint64_t getCurrentTime() const { return m_totalTime - m_currentTimeOrigin; }