Revert "Calculate CS timestamp based on OA timestamp and frequencies ratio"

This reverts commit 03c5283.

Signed-off-by: Compute-Runtime-Validation <[email protected]>

Author: Compute-Runtime-Validation

opencl/test/unit_test/device/windows/device_windows_tests.cpp

@@ -6,6 +6,9 @@
  */
 
 #include "shared/source/execution_environment/root_device_environment.h"
+#include "shared/test/common/mocks/mock_execution_environment.h"
+#include "shared/test/common/mocks/mock_ostime.h"
+#include "shared/test/common/mocks/mock_ostime_win.h"
 #include "shared/test/common/mocks/mock_wddm.h"
 #include "shared/test/common/test_macros/test.h"
 
@@ -15,6 +18,25 @@ using namespace NEO;
 
 namespace ULT {
 
+typedef ::testing::Test MockOSTimeWinTest;
+
+TEST_F(MockOSTimeWinTest, whenCreatingTimerThenResolutionIsSetCorrectly) {
+    MockExecutionEnvironment executionEnvironment;
+    RootDeviceEnvironment rootDeviceEnvironment(executionEnvironment);
+    auto wddmMock = new WddmMock(rootDeviceEnvironment);
+    auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+
+    wddmMock->init();
+
+    wddmMock->timestampFrequency = 1000;
+
+    std::unique_ptr<MockOSTimeWin> timeWin(new MockOSTimeWin(wddmMock));
+
+    double res = 0.0;
+    res = timeWin->getDynamicDeviceTimerResolution(device->getHardwareInfo());
+    EXPECT_EQ(res, 1e+06);
+}
+
 TEST(GetDeviceInfo, givenClDeviceWhenGettingDeviceInfoThenCorrectAdapterLuidIsReturned) {
     auto clDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
     clDevice->executionEnvironment->rootDeviceEnvironments[0]->osInterface.reset(new NEO::OSInterface);

shared/source/os_interface/hw_info_config.h

@@ -60,6 +60,7 @@ class HwInfoConfig {
     virtual uint64_t getSharedSystemMemCapabilities(const HardwareInfo *hwInfo) = 0;
     virtual void getKernelExtendedProperties(uint32_t *fp16, uint32_t *fp32, uint32_t *fp64) = 0;
     virtual std::vector<int32_t> getKernelSupportedThreadArbitrationPolicies() = 0;
+    virtual void convertTimestampsFromOaToCsDomain(uint64_t &timestampData) = 0;
     virtual uint32_t getDeviceMemoryMaxClkRate(const HardwareInfo &hwInfo, const OSInterface *osIface, uint32_t subDeviceIndex) = 0;
     virtual uint64_t getDeviceMemoryPhysicalSizeInBytes(const OSInterface *osIface, uint32_t subDeviceIndex) = 0;
     virtual uint64_t getDeviceMemoryMaxBandWidthInBytesPerSecond(const HardwareInfo &hwInfo, const OSInterface *osIface, uint32_t subDeviceIndex) = 0;
@@ -195,6 +196,7 @@ class HwInfoConfigHw : public HwInfoConfig {
     uint64_t getSharedSystemMemCapabilities(const HardwareInfo *hwInfo) override;
     void getKernelExtendedProperties(uint32_t *fp16, uint32_t *fp32, uint32_t *fp64) override;
     std::vector<int32_t> getKernelSupportedThreadArbitrationPolicies() override;
+    void convertTimestampsFromOaToCsDomain(uint64_t &timestampData) override;
     uint32_t getDeviceMemoryMaxClkRate(const HardwareInfo &hwInfo, const OSInterface *osIface, uint32_t subDeviceIndex) override;
     uint64_t getDeviceMemoryPhysicalSizeInBytes(const OSInterface *osIface, uint32_t subDeviceIndex) override;
     uint64_t getDeviceMemoryMaxBandWidthInBytesPerSecond(const HardwareInfo &hwInfo, const OSInterface *osIface, uint32_t subDeviceIndex) override;

shared/source/os_interface/hw_info_config.inl

@@ -42,6 +42,9 @@ std::vector<int32_t> HwInfoConfigHw<gfxProduct>::getKernelSupportedThreadArbitra
     return PreambleHelper<GfxFamily>::getSupportedThreadArbitrationPolicies();
 }
 
+template <PRODUCT_FAMILY gfxProduct>
+void HwInfoConfigHw<gfxProduct>::convertTimestampsFromOaToCsDomain(uint64_t &timestampData){};
+
 template <PRODUCT_FAMILY gfxProduct>
 void HwInfoConfigHw<gfxProduct>::adjustPlatformForProductFamily(HardwareInfo *hwInfo) {}
 

shared/source/os_interface/windows/device_time_gpu_cpu_drm_or_wddm.cpp

@@ -21,7 +21,9 @@ bool DeviceTimeWddm::getCpuGpuTime(TimeStampData *pGpuCpuTime, OSTime *osTime) {
     TimeStampDataHeader escapeInfo = {};
 
     if (runEscape(wddm, escapeInfo)) {
-        convertTimestampsFromOaToCsDomain(escapeInfo.m_Data.m_Out.gpuPerfTicks, escapeInfo.m_Data.m_Out.gpuPerfFreq, static_cast<uint64_t>(wddm->getTimestampFrequency()));
+        auto productFamily = wddm->getRootDeviceEnvironment().getHardwareInfo()->platform.eProductFamily;
+        auto *hwInfoConfig = HwInfoConfig::get(productFamily);
+        hwInfoConfig->convertTimestampsFromOaToCsDomain(escapeInfo.m_Data.m_Out.gpuPerfTicks);
 
         osTime->getCpuTime(&pGpuCpuTime->CPUTimeinNS);
         pGpuCpuTime->GPUTimeStamp = (unsigned long long)escapeInfo.m_Data.m_Out.gpuPerfTicks;

shared/source/os_interface/windows/device_time_gpu_cpu_wddm.cpp

@@ -21,7 +21,9 @@ bool DeviceTimeWddm::getCpuGpuTime(TimeStampData *pGpuCpuTime, OSTime *osTime) {
     TimeStampDataHeader escapeInfo = {};
 
     if (runEscape(wddm, escapeInfo)) {
-        convertTimestampsFromOaToCsDomain(escapeInfo.m_Data.m_Out.gpuPerfTicks, escapeInfo.m_Data.m_Out.gpuPerfFreq, static_cast<uint64_t>(wddm->getTimestampFrequency()));
+        auto productFamily = wddm->getRootDeviceEnvironment().getHardwareInfo()->platform.eProductFamily;
+        auto *hwInfoConfig = HwInfoConfig::get(productFamily);
+        hwInfoConfig->convertTimestampsFromOaToCsDomain(escapeInfo.m_Data.m_Out.gpuPerfTicks);
         double cpuNanoseconds = escapeInfo.m_Data.m_Out.cpuPerfTicks *
                                 (1000000000.0 / escapeInfo.m_Data.m_Out.cpuPerfFreq);
 

shared/source/os_interface/windows/device_time_wddm.cpp

@@ -70,10 +70,4 @@ uint64_t DeviceTimeWddm::getDynamicDeviceTimerClock(HardwareInfo const &hwInfo)
     return retVal;
 }
 
-void DeviceTimeWddm::convertTimestampsFromOaToCsDomain(uint64_t &timestampData, uint64_t freqOA, uint64_t freqCS) {
-    if (freqCS > 0) {
-        auto freqRatio = freqOA / freqCS;
-        timestampData /= freqRatio;
-    }
-};
 } // namespace NEO

shared/source/os_interface/windows/device_time_wddm.h

@@ -24,7 +24,6 @@ class DeviceTimeWddm : public DeviceTime {
 
   protected:
     MOCKABLE_VIRTUAL bool runEscape(Wddm *wddm, TimeStampDataHeader &escapeInfo);
-    void convertTimestampsFromOaToCsDomain(uint64_t &timestampData, uint64_t freqOA, uint64_t freqCS);
     Wddm *wddm = nullptr;
 };
 

shared/source/xe_hpg_core/dg2/os_agnostic_hw_info_config_dg2.inl

@@ -169,6 +169,11 @@ uint32_t HwInfoConfigHw<gfxProduct>::computeMaxNeededSubSliceSpace(const Hardwar
     return maxSubSlice;
 }
 
+template <>
+void HwInfoConfigHw<gfxProduct>::convertTimestampsFromOaToCsDomain(uint64_t &timestampData) {
+    timestampData >>= 1;
+}
+
 template <>
 bool HwInfoConfigHw<gfxProduct>::isFlushTaskAllowed() const {
     return true;

shared/test/common/mocks/mock_hw_info_config.cpp

@@ -18,6 +18,10 @@ template <>
 void HwInfoConfigHw<IGFX_UNKNOWN>::adjustSamplerState(void *sampler, const HardwareInfo &hwInfo) {
 }
 
+template <>
+void HwInfoConfigHw<IGFX_UNKNOWN>::convertTimestampsFromOaToCsDomain(uint64_t &timestampData) {
+}
+
 template <>
 uint32_t HwInfoConfigHw<IGFX_UNKNOWN>::getMaxThreadsForWorkgroupInDSSOrSS(const HardwareInfo &hwInfo, uint32_t maxNumEUsPerSubSlice, uint32_t maxNumEUsPerDualSubSlice) const {
     return 0;

shared/test/common/mocks/mock_ostime_win.h

@@ -10,16 +10,10 @@
 #include "shared/source/os_interface/windows/os_time_win.h"
 
 namespace NEO {
-struct MockDeviceTimeWddm : DeviceTimeWddm {
-    using DeviceTimeWddm::convertTimestampsFromOaToCsDomain;
-};
 class MockOSTimeWin : public OSTimeWin {
   public:
     MockOSTimeWin(Wddm *wddm) {
         this->deviceTime = std::make_unique<DeviceTimeWddm>(wddm);
     }
-    void convertTimestampsFromOaToCsDomain(uint64_t &timestampData, uint64_t freqOA, uint64_t freqCS) {
-        static_cast<MockDeviceTimeWddm *>(this->deviceTime.get())->convertTimestampsFromOaToCsDomain(timestampData, freqOA, freqCS);
-    }
 };
 } // namespace NEO