Push 2024 12 03

src/cpucounters.cpp

@@ -1749,6 +1749,12 @@ void PCM::initEnergyMonitoring()
         pp_energy_status.push_back(std::make_shared<CounterWidthExtender>(
             new CounterWidthExtender::MsrHandleCounter(MSR[socketRefCore[0]], MSR_PP1_ENERGY_STATUS), 32, 10000));
     }
+
+    if (systemEnergyMetricAvailable() && MSR.size() && (system_energy_status.get() == nullptr))
+    {
+        system_energy_status = std::make_shared<CounterWidthExtender>(
+            new CounterWidthExtender::MsrHandleCounter(MSR[socketRefCore[0]], MSR_SYS_ENERGY_STATUS, 0x00000000FFFFFFFF), 32, 10000);
+    }
 }
 
 static const uint32 UBOX0_DEV_IDS[] = {
@@ -6964,6 +6970,11 @@ void PCM::getAllCounterStates(SystemCounterState & systemState, std::vector<Sock
         // aggregate socket uncore iMC, energy and package C state counters into system
         systemState += socketStates[s];
     }
+
+    if (systemEnergyMetricAvailable() && system_energy_status.get() != nullptr)
+    {
+        systemState.systemEnergyStatus = system_energy_status->read();
+    }
 }
 
 void PCM::getUncoreCounterStates(SystemCounterState & systemState, std::vector<SocketCounterState> & socketStates)

src/cpucounters.h

@@ -810,6 +810,7 @@ class PCM_API PCM
     std::vector<std::shared_ptr<CounterWidthExtender> > energy_status;
     std::vector<std::shared_ptr<CounterWidthExtender> > dram_energy_status;
     std::vector<std::shared_ptr<CounterWidthExtender> > pp_energy_status;
+    std::shared_ptr<CounterWidthExtender> system_energy_status;
     std::vector<std::vector<std::pair<UncorePMU, UncorePMU>>> cxlPMUs; // socket X CXL ports X UNIT {0,1}
 
     std::vector<std::shared_ptr<CounterWidthExtender> > memory_bw_local;
@@ -2510,6 +2511,25 @@ class PCM_API PCM
           );
     }
 
+    bool systemEnergyMetricAvailable() const
+    {
+        return (
+               useSKLPath()
+            || cpu_family_model == PCM::SKX
+            || cpu_family_model == PCM::ICX
+            || cpu_family_model == PCM::ADL
+            || cpu_family_model == PCM::RPL
+            || cpu_family_model == PCM::MTL
+            || cpu_family_model == PCM::LNL
+            || cpu_family_model == PCM::ARL
+            || cpu_family_model == PCM::SPR
+            || cpu_family_model == PCM::EMR
+            || cpu_family_model == PCM::GNR
+            || cpu_family_model == PCM::SRF
+            || cpu_family_model == PCM::GRR
+            );
+    }
+
     bool packageThermalMetricsAvailable() const
     {
         return packageEnergyMetricsAvailable();
@@ -3368,6 +3388,25 @@ uint64 getConsumedEnergy(const int powerPlane, const CounterStateType& before, c
     return after.PPEnergyStatus[powerPlane] - before.PPEnergyStatus[powerPlane];
 }
 
+/*!  \brief Returns energy consumed by system
+    \param before CPU counter state before the experiment
+    \param after CPU counter state after the experiment
+*/
+template <class CounterStateType>
+uint64 getSystemConsumedEnergy(const CounterStateType& before, const CounterStateType& after)
+{
+    return after.systemEnergyStatus - before.systemEnergyStatus;
+}
+
+/*!  \brief Checks is systemEnergyStatusValid is valid in the state
+*   \param s CPU counter state
+*/
+template <class CounterStateType>
+bool systemEnergyStatusValid(const CounterStateType& s)
+{
+    return s.systemEnergyStatus != 0;
+}
+
 /*!  \brief Returns energy consumed by DRAM (measured in internal units)
     \param before CPU counter state before the experiment
     \param after CPU counter state after the experiment
@@ -3435,6 +3474,31 @@ double getConsumedJoules(const int powerPlane, const CounterStateType& before, c
     return double(getConsumedEnergy(powerPlane, before, after)) * m->getJoulesPerEnergyUnit();
 }
 
+/*!  \brief Returns Joules consumed by system
+    \param before CPU counter state before the experiment
+    \param after CPU counter state after the experiment
+*/
+template <class CounterStateType>
+double getSystemConsumedJoules(const CounterStateType& before, const CounterStateType& after)
+{
+    PCM* m = PCM::getInstance();
+    if (!m) return -1.;
+
+    auto unit = m->getJoulesPerEnergyUnit();
+
+    switch (m->getCPUFamilyModel())
+    {
+           case PCM::SPR:
+           case PCM::EMR:
+           case PCM::GNR:
+           case PCM::SRF:
+                   unit = 1.0;
+                   break;
+    }
+
+    return double(getSystemConsumedEnergy(before, after)) * unit;
+}
+
 /*!  \brief Returns Joules consumed by DRAM
     \param before CPU counter state before the experiment
     \param after CPU counter state after the experiment
@@ -3860,11 +3924,14 @@ class SystemCounterState : public SocketCounterState
     friend std::vector<uint64> getPCICFGEvent(const PCM::RawEventEncoding& eventEnc, const SystemCounterState& before, const SystemCounterState& after);
     friend std::vector<uint64> getMMIOEvent(const PCM::RawEventEncoding& eventEnc, const SystemCounterState& before, const SystemCounterState& after);
     friend std::vector<uint64> getPMTEvent(const PCM::RawEventEncoding& eventEnc, const SystemCounterState& before, const SystemCounterState& after);
+    template <class CounterStateType> friend bool systemEnergyStatusValid(const CounterStateType& s);
+    template <class CounterStateType> friend uint64 getSystemConsumedEnergy(const CounterStateType& before, const CounterStateType& after);
 
     std::vector<std::vector<uint64> > incomingQPIPackets; // each 64 byte
     std::vector<std::vector<uint64> > outgoingQPIFlits; // idle or data/non-data flits depending on the architecture
     std::vector<std::vector<uint64> > TxL0Cycles;
     uint64 uncoreTSC;
+    uint64 systemEnergyStatus;
     std::unordered_map<PCM::RawEventEncoding, std::vector<uint64> , PCM::PCICFGRegisterEncodingHash, PCM::PCICFGRegisterEncodingCmp> PCICFGValues{};
     std::unordered_map<PCM::RawEventEncoding, std::vector<uint64>, PCM::MMIORegisterEncodingHash, PCM::MMIORegisterEncodingCmp> MMIOValues{};
     std::unordered_map<PCM::RawEventEncoding, std::vector<uint64>, PCM::PMTRegisterEncodingHash2> PMTValues{};
@@ -3890,7 +3957,8 @@ class SystemCounterState : public SocketCounterState
     friend uint64 getOutgoingQPILinkBytes(uint32 socketNr, uint32 linkNr, const SystemCounterState & now);
 
     SystemCounterState() :
-        uncoreTSC(0)
+        uncoreTSC(0),
+        systemEnergyStatus(0)
     {
         PCM * m = PCM::getInstance();
         accel_counters.resize(m->getNumberofAccelCounters());
@@ -3922,6 +3990,7 @@ class SystemCounterState : public SocketCounterState
 
         return *this;
     }
+
     virtual ~ SystemCounterState() {}
 };
 

src/pcm.cpp

@@ -334,19 +334,25 @@ void print_output(PCM * m,
 
         cout << setNextColor() << "     N/A\n";
         cout << resetColor();
-        cout << setNextColor() <<"\n Instructions retired: " << unit_format(getInstructionsRetired(sstate1, sstate2)) << " ;"
-             << setNextColor() <<" Active cycles: " << unit_format(getCycles(sstate1, sstate2)) << " ;"
-             << setNextColor() <<" Time (TSC): " << unit_format(getInvariantTSC(cstates1[0], cstates2[0])) << "ticks ;"
-             << setNextColor() << " C0 (active,non-halted) core residency: " << (getCoreCStateResidency(0, sstate1, sstate2)*100.) << " %\n";
-        cout << "\n";
+        cout << setNextColor() << "\n Instructions retired: " << unit_format(getInstructionsRetired(sstate1, sstate2)) << " ;"
+            << setNextColor() << " Active cycles: " << unit_format(getCycles(sstate1, sstate2)) << " ;"
+            << setNextColor() << " Time (TSC): " << unit_format(getInvariantTSC(cstates1[0], cstates2[0])) << "ticks;";
+        if (m->systemEnergyMetricAvailable() && systemEnergyStatusValid(sstate1) && systemEnergyStatusValid(sstate2))
+        {
+            cout << setNextColor() << " SYS energy: " << getSystemConsumedJoules(sstate1, sstate2) << " J;";
+        }
+        cout << "\n\n";
+
+        cout << resetColor() << setNextColor() << " Core C-state residencies: "<< setNextColor() << "C0 (active,non-halted): " << (getCoreCStateResidency(0, sstate1, sstate2)*100.) << " %;";
         for (int s = 1; s <= PCM::MAX_C_STATE; ++s)
         {
             if (m->isCoreCStateResidencySupported(s))
             {
-                std::cout << setNextColor() << " C" << s << " core residency: " << (getCoreCStateResidency(s, sstate1, sstate2)*100.) << " %;";
+                std::cout << setNextColor() << " C" << s << ": " << (getCoreCStateResidency(s, sstate1, sstate2)*100.) << " %;";
             }
         }
         cout << "\n" ;
+        cout << resetColor() << setNextColor() << " Package C-state residencies: ";
         std::vector<StackedBarItem> CoreCStateStackedBar, PackageCStateStackedBar;
         for (int s = 0; s <= PCM::MAX_C_STATE; ++s)
         {
@@ -359,7 +365,7 @@ void print_output(PCM * m,
             }
             if (m->isPackageCStateResidencySupported(s))
             {
-                std::cout << setNextColor() << " C" << s << " package residency: " << (getPackageCStateResidency(s, sstate1, sstate2)*100.) << " %;";
+                std::cout << setNextColor() << " C" << s << ": " << (getPackageCStateResidency(s, sstate1, sstate2)*100.) << " %;";
                 PackageCStateStackedBar.push_back(StackedBarItem(getPackageCStateResidency(s, sstate1, sstate2), "", fill));
             }
         }
@@ -760,6 +766,8 @@ void print_csv_header(PCM * m,
             print_csv_header_helper(header, 2);
         if (m->dramEnergyMetricsAvailable())
             print_csv_header_helper(header);
+        if (m->systemEnergyMetricAvailable())
+            print_csv_header_helper(header);
         if (m->LLCReadMissLatencyMetricsAvailable())
             print_csv_header_helper(header);
         if (m->uncoreFrequencyMetricAvailable())
@@ -940,6 +948,8 @@ void print_csv_header(PCM * m,
         }
         if (m->dramEnergyMetricsAvailable())
             cout << "DRAM Energy (Joules),";
+        if (m->systemEnergyMetricAvailable())
+            cout << "SYSTEM Energy (Joules),";
         if (m->LLCReadMissLatencyMetricsAvailable())
             cout << "LLCRDMISSLAT (ns),";
         if (m->uncoreFrequencyMetricAvailable())
@@ -1194,6 +1204,8 @@ void print_csv(PCM * m,
             cout << getConsumedJoules(0, sstate1, sstate2) << "," << getConsumedJoules(1, sstate1, sstate2) << ",";
         if (m->dramEnergyMetricsAvailable())
             cout << getDRAMConsumedJoules(sstate1, sstate2) << ",";
+        if (m->systemEnergyMetricAvailable())
+            cout << getSystemConsumedJoules(sstate1, sstate2) << ",";
         if (m->LLCReadMissLatencyMetricsAvailable())
             cout << getLLCReadMissLatency(sstate1, sstate2) << ",";
         if (m->uncoreFrequencyMetricAvailable())

src/types.h

@@ -506,6 +506,7 @@ constexpr auto MSR_SMI_COUNT = 0x34;
 */
 
 constexpr auto MSR_PKG_ENERGY_STATUS = 0x611;
+constexpr auto MSR_SYS_ENERGY_STATUS = 0x64D;
 constexpr auto MSR_RAPL_POWER_UNIT = 0x606;
 constexpr auto MSR_PKG_POWER_INFO = 0x614;
 

src/width_extender.h

@@ -40,12 +40,20 @@ class CounterWidthExtender
     {
         std::shared_ptr<SafeMsrHandle> msr;
         uint64 msr_addr;
-        MsrHandleCounter(std::shared_ptr<SafeMsrHandle> msr_, uint64 msr_addr_) : msr(msr_), msr_addr(msr_addr_) { }
+        uint64 msr_mask;
+        MsrHandleCounter(   std::shared_ptr<SafeMsrHandle> msr_,
+                            const uint64 msr_addr_,
+                            const uint64 msr_mask_ = ~uint64(0ULL)) :
+            msr(msr_),
+            msr_addr(msr_addr_),
+            msr_mask(msr_mask_)
+        {
+        }
         uint64 operator () ()
         {
             uint64 value = 0;
             msr->read(msr_addr, &value);
-            return value;
+            return value & msr_mask;
         }
     };