implement Intel PMT TelemetryArray on Linux

rdementi · rdementi · commit a61bd8659b46 · 2024-05-20T12:12:05.000+02:00
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -5,7 +5,7 @@
 # All pcm-* executables
 set(PROJECT_NAMES pcm pcm-numa pcm-latency pcm-power pcm-msr pcm-memory pcm-tsx pcm-pcie pcm-core pcm-iio pcm-lspci pcm-pcicfg pcm-mmio pcm-tpmi pcm-raw pcm-accel)
 
-file(GLOB COMMON_SOURCES pcm-accel-common.cpp msr.cpp cpucounters.cpp pci.cpp mmio.cpp tpmi.cpp bw.cpp utils.cpp topology.cpp debug.cpp threadpool.cpp uncore_pmu_discovery.cpp)
+file(GLOB COMMON_SOURCES pcm-accel-common.cpp msr.cpp cpucounters.cpp pci.cpp mmio.cpp tpmi.cpp pmt.cpp bw.cpp utils.cpp topology.cpp debug.cpp threadpool.cpp uncore_pmu_discovery.cpp)
 
 if (APPLE)
   file(GLOB UNUX_SOURCES dashboard.cpp)
diff --git a/src/cpucounters.h b/src/cpucounters.h
@@ -28,6 +28,7 @@
 #include "msr.h"
 #include "pci.h"
 #include "tpmi.h"
+#include "pmt.h"
 #include "bw.h"
 #include "width_extender.h"
 #include "exceptions/unsupported_processor_exception.hpp"
diff --git a/src/pmt.cpp b/src/pmt.cpp
@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: BSD-3-Clause
+// Copyright (c) 2024, Intel Corporation
+
+#include "pmt.h"
+#include "utils.h"
+#include <assert.h>
+#include <vector>
+#include <unordered_map>
+#include <iostream>
+
+namespace pcm {
+
+#ifdef __linux__
+class TelemetryArrayLinux : public TelemetryArrayInterface
+{
+    TelemetryArrayLinux() = delete;
+    typedef std::vector<std::FILE *> FileVector;
+    typedef std::unordered_map<uint64, FileVector> FileMap;
+    static std::shared_ptr<FileMap> TelemetryFiles;
+    static FileMap & getTelemetryFiles()
+    {
+        if (!TelemetryFiles.get())
+        {
+            std::shared_ptr<FileMap> TelemetryFilesTemp = std::make_shared<FileMap>();
+            auto paths = findPathsFromPattern("/sys/class/intel_pmt/telem*");
+            for (auto & path : paths)
+            {
+                const auto guid = read_number(readSysFS((path + "/guid").c_str()).c_str());
+                #if 0
+                auto size = read_number(readSysFS((path + "/size").c_str()).c_str());
+                std::cout << "path: " << path << " guid: 0x" << std::hex << guid << " size: "<< std::dec << size <<  std::endl;
+                #endif
+                auto file = std::fopen((path + "/telem").c_str(), "rb");
+                if (!file)
+                {
+                    std::cerr << "Error: failed to open " << path << "/telem" << std::endl;
+                    continue;
+                }
+                TelemetryFilesTemp->operator[](guid).push_back(file);
+            }
+            
+            // print the telemetry files
+            for (auto & guid : *TelemetryFilesTemp)
+            {
+                auto & files = guid.second;
+                for (auto & file : files)
+                {
+                    if (!file)
+                    {
+                        std::cerr << "Error: file is null" << std::endl;
+                        continue;
+                    }
+                    // std::cout << "guid: 0x" << std::hex << guid.first << " file: " << file << std::endl;
+                }
+            }
+
+            TelemetryFiles = TelemetryFilesTemp;
+        }
+        return *TelemetryFiles;
+    }
+    std::vector<unsigned char> data;
+    size_t uid, instance;
+public:
+    TelemetryArrayLinux(const size_t uid_, const size_t instance_): uid(uid_), instance(instance_)
+    {
+        assert(instance < numInstances(uid));
+        load();
+    }
+    static size_t numInstances(const size_t uid)
+    {
+        return getTelemetryFiles().at(uid).size();
+    }
+    virtual ~TelemetryArrayLinux() override
+    {
+    }
+    size_t size() override
+    {
+        return data.size();
+    }
+    void load() override
+    {
+        FILE * file = getTelemetryFiles().at(uid).at(instance);
+        assert(file);
+        // get the file size
+        fseek(file, 0, SEEK_END);
+        size_t fileSize = ftell(file);
+        fseek(file, 0, SEEK_SET);
+        data.resize(fileSize);
+        const size_t bytesRead = fread(data.data(), 1, fileSize, file);
+        if (bytesRead != fileSize)
+        {
+            std::cerr << "Error: failed to read " << fileSize << " bytes from telemetry file" << std::endl;
+        }
+    }
+    uint64 get(size_t qWordOffset, size_t lsb, size_t msb) override
+    {
+        assert(qWordOffset * sizeof(uint64) + sizeof(uint64) <= data.size());
+        return extract_bits(*reinterpret_cast<uint64 *>(&data[qWordOffset * sizeof(uint64)]), lsb, msb);
+    }
+};
+
+std::shared_ptr<TelemetryArrayLinux::FileMap> TelemetryArrayLinux::TelemetryFiles;
+
+#else
+
+class TelemetryArrayDummy : public TelemetryArrayInterface
+{
+    TelemetryArrayDummy() = delete;
+public:
+    TelemetryArrayDummy(const size_t /* uid */, const size_t /* instance */) {};
+    static size_t numInstances(const size_t /* uid */) { return 0; };
+    virtual ~TelemetryArrayDummy() override {};
+    size_t size() override { return 0;}; // in bytes
+    void load() override {};
+    uint64 get(size_t , size_t , size_t ) override { return 0;} ;
+};
+
+#endif
+
+TelemetryArray::TelemetryArray(const size_t uid, const size_t instance)
+{
+#ifdef __linux__
+    impl = std::make_shared<TelemetryArrayLinux>(uid, instance);
+#else
+    impl = std::make_shared<TelemetryArrayDummy>(uid, instance);
+#endif
+}
+
+size_t TelemetryArray::numInstances(const size_t uid)
+{
+#ifdef __linux__
+    return TelemetryArrayLinux::numInstances(uid);
+#else
+    return TelemetryArrayDummy::numInstances(uid);
+#endif
+}
+
+TelemetryArray::~TelemetryArray() {}
+
+size_t TelemetryArray::size()
+{
+    assert(impl.get());
+    return impl->size();
+}
+
+void TelemetryArray::load()
+{
+    assert(impl.get());
+    impl->load();
+}
+
+uint64 TelemetryArray::get(size_t qWordOffset, size_t lsb, size_t msb)
+{
+    assert(impl.get());
+    return impl->get(qWordOffset, lsb, msb);
+}
+
+}; // namespace pcm
diff --git a/src/pmt.h b/src/pmt.h
@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: BSD-3-Clause
+// Copyright (c) 2024, Intel Corporation
+
+#pragma once
+
+#include "types.h"
+#include <memory>
+
+namespace pcm {
+
+class TelemetryArrayInterface
+{
+public:
+    virtual size_t size() = 0; // in bytes
+    virtual size_t numQWords()
+    {
+        return size() / sizeof(uint64);
+    }
+    virtual void load() = 0;
+    virtual uint64 get(size_t qWordOffset, size_t lsb, size_t msb) = 0;
+    virtual ~TelemetryArrayInterface() {};
+};
+
+class TelemetryArray : public TelemetryArrayInterface
+{
+    TelemetryArray() = delete;
+    std::shared_ptr<TelemetryArrayInterface> impl;
+public:
+    TelemetryArray(const size_t /* uid */, const size_t /* instance */);
+    static size_t numInstances(const size_t /* uid */);
+    virtual ~TelemetryArray() override;
+    size_t size() override; // in bytes
+    void load() override;
+    uint64 get(size_t qWordOffset, size_t lsb, size_t msb) override;
+};
+
+} // namespace pcm
diff --git a/src/tpmi.cpp b/src/tpmi.cpp
@@ -10,7 +10,6 @@
 #include <unordered_map>
 #include <assert.h>
 #ifdef __linux__
-#include <glob.h>
 #include <algorithm>
 #endif
 
@@ -331,21 +330,6 @@ bool TPMIHandleDriver::isAvailable()
 {
     if (available < 0) // not initialized yet
     {
-        auto findPathsFromPattern = [](const char* pattern)
-        {
-            std::vector<std::string> result;
-            glob_t glob_result;
-            memset(&glob_result, 0, sizeof(glob_result));
-            if (glob(pattern, GLOB_TILDE, nullptr, &glob_result) == 0)
-            {
-                for (size_t i = 0; i < glob_result.gl_pathc; ++i)
-                {
-                    result.push_back(glob_result.gl_pathv[i]);
-                }
-            }
-            globfree(&glob_result);
-            return result;
-        };
         instancePaths = findPathsFromPattern("/sys/kernel/debug/tpmi-*");
         std::sort(instancePaths.begin(), instancePaths.end());
         for (size_t i = 0; i < instancePaths.size(); ++i)
diff --git a/src/utils.cpp b/src/utils.cpp
@@ -23,6 +23,9 @@
 #ifndef _MSC_VER
 #include <execinfo.h>
 #endif
+#ifdef __linux__
+#include <glob.h>
+#endif
 
 namespace pcm {
 
@@ -101,6 +104,24 @@ void print_cpu_details()
     std::cerr << "\n";
 }
 
+#ifdef __linux__
+std::vector<std::string> findPathsFromPattern(const char* pattern)
+{
+            std::vector<std::string> result;
+            glob_t glob_result;
+            memset(&glob_result, 0, sizeof(glob_result));
+            if (glob(pattern, GLOB_TILDE, nullptr, &glob_result) == 0)
+            {
+                for (size_t i = 0; i < glob_result.gl_pathc; ++i)
+                {
+                    result.push_back(glob_result.gl_pathv[i]);
+                }
+            }
+            globfree(&glob_result);
+            return result;
+};
+#endif
+
 #ifdef _MSC_VER
 
 ThreadGroupTempAffinity::ThreadGroupTempAffinity(uint32 core_id, bool checkStatus, const bool restore_)
diff --git a/src/utils.h b/src/utils.h
@@ -612,6 +612,9 @@ inline void extractBitsPrintHelper(const std::pair<int64,int64> & bits, T & valu
 void restrictDriverAccessNative(LPCTSTR path);
 #endif
 
+#ifdef __linux__
+std::vector<std::string> findPathsFromPattern(const char* pattern);
+#endif
 
 class TemporalThreadAffinity  // speedup trick for Linux, FreeBSD, DragonFlyBSD, Windows
 {

Original file line number	Diff line number	Diff line change
`@@ -612,6 +612,9 @@ inline void extractBitsPrintHelper(const std::pair<int64,int64> & bits, T & valu`
`612`	`612`	`void restrictDriverAccessNative(LPCTSTR path);`
`613`	`613`	`#endif`
`614`	`614`
	`615`	`+#ifdef __linux__`
	`616`	`+std::vector<std::string> findPathsFromPattern(const char* pattern);`
	`617`	`+#endif`
`615`	`618`
`616`	`619`	`class TemporalThreadAffinity // speedup trick for Linux, FreeBSD, DragonFlyBSD, Windows`
`617`	`620`	`{`