intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-03 14:55:24 +08:00
Code Issues Packages Projects Releases Wiki Activity

level-zero v1.0 (2/N)

Browse Source 
Change-Id: I1419231a721fab210e166d26a264cae04d661dcd
Signed-off-by: Jaime Arteaga <jaime.a.arteaga.molina@intel.com>
Signed-off-by: macabral <matias.a.cabral@intel.com>
Signed-off-by: davidoli <david.olien@intel.com>
Signed-off-by: Aravind Gopalakrishnan <Aravind.Gopalakrishnan@intel.com>
Signed-off-by: Spruit, Neil R <neil.r.spruit@intel.com>
Signed-off-by: Latif, Raiyan <raiyan.latif@intel.com>
Signed-off-by: Artur Harasimiuk <artur.harasimiuk@intel.com>
This commit is contained in:
Jaime Arteaga
2020-07-29 02:45:54 -07:00
committed by sys_ocldev
parent e8246a8179
commit 902fc2f6c4
255 changed files with 3200 additions and 12829 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
level_zero/tools/source/metrics/metric.cpp
View File

@@ -351,22 +351,7 @@ ze_result_t metricStreamerOpen(zet_context_handle_t hContext, zet_device_handle_
zet_metric_streamer_desc_t *pDesc, ze_event_handle_t hNotificationEvent,
zet_metric_streamer_handle_t *phMetricStreamer) {
return MetricStreamer::open(hDevice, hMetricGroup, *pDesc, hNotificationEvent, phMetricStreamer);
}
ze_result_t metricTracerOpen(zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
zet_metric_tracer_desc_t *pDesc, ze_event_handle_t hNotificationEvent,
zet_metric_tracer_handle_t *phMetricTracer) {
zet_metric_streamer_handle_t *phMetricStreamer = reinterpret_cast<zet_metric_streamer_handle_t *>(phMetricTracer);
zet_metric_streamer_desc_t metricStreamerDesc = {};
metricStreamerDesc.notifyEveryNReports = pDesc->notifyEveryNReports;
metricStreamerDesc.samplingPeriod = pDesc->samplingPeriod;
metricStreamerDesc.stype = ZET_STRUCTURE_TYPE_METRIC_STREAMER_DESC;
metricStreamerDesc.pNext = nullptr;
return MetricStreamer::open(hDevice, hMetricGroup, metricStreamerDesc, hNotificationEvent, phMetricStreamer);
return MetricStreamer::open(hContext, hDevice, hMetricGroup, *pDesc, hNotificationEvent, phMetricStreamer);
}
} // namespace L0

33
level_zero/tools/source/metrics/metric.h
View File

@@ -9,14 +9,11 @@
#include "level_zero/core/source/event/event.h"
#include <level_zero/zet_api.h>
#include "third_party/level_zero/zet_api_ext.h"
#include <vector>
struct _zet_metric_group_handle_t {};
struct _zet_metric_handle_t {};
struct _zet_metric_streamer_handle_t {};
struct _zet_metric_tracer_handle_t {};
struct _zet_metric_query_pool_handle_t {};
struct _zet_metric_query_handle_t {};
@@ -63,9 +60,8 @@ struct Metric : _zet_metric_handle_t {
virtual ~Metric() = default;
virtual ze_result_t getProperties(zet_metric_properties_t *pProperties) = 0;
virtual ze_result_t getPropertiesExt(zet_metric_properties_ext_t *pProperties) = 0;
static Metric *create(zet_metric_properties_ext_t &properties);
static Metric *create(zet_metric_properties_t &properties);
static Metric *fromHandle(zet_metric_handle_t handle) { return static_cast<Metric *>(handle); }
inline zet_metric_handle_t toHandle() { return this; }
};
@@ -74,20 +70,19 @@ struct MetricGroup : _zet_metric_group_handle_t {
virtual ~MetricGroup() = default;
virtual ze_result_t getProperties(zet_metric_group_properties_t *pProperties) = 0;
virtual ze_result_t getPropertiesExt(zet_metric_group_properties_ext_t *pProperties) = 0;
virtual ze_result_t getMetric(uint32_t *pCount, zet_metric_handle_t *phMetrics) = 0;
virtual ze_result_t calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
const uint8_t *pRawData, uint32_t *pMetricValueCount,
zet_typed_value_t *pMetricValues) = 0;
static MetricGroup *create(zet_metric_group_properties_ext_t &properties,
static MetricGroup *create(zet_metric_group_properties_t &properties,
MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
const std::vector<Metric *> &metrics);
static MetricGroup *fromHandle(zet_metric_group_handle_t handle) {
return static_cast<MetricGroup *>(handle);
}
static zet_metric_group_properties_ext_t getProperties(const zet_metric_group_handle_t handle);
static zet_metric_group_properties_t getProperties(const zet_metric_group_handle_t handle);
zet_metric_group_handle_t toHandle() { return this; }
@@ -109,7 +104,7 @@ struct MetricStreamer : _zet_metric_streamer_handle_t {
uint8_t *pRawData) = 0;
virtual ze_result_t close() = 0;
static ze_result_t open(zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
static ze_result_t open(zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
zet_metric_streamer_desc_t &desc, ze_event_handle_t hNotificationEvent, zet_metric_streamer_handle_t *phMetricStreamer);
static MetricStreamer *fromHandle(zet_metric_streamer_handle_t handle) {
return static_cast<MetricStreamer *>(handle);
@@ -119,14 +114,6 @@ struct MetricStreamer : _zet_metric_streamer_handle_t {
inline zet_metric_streamer_handle_t toHandle() { return this; }
};
struct MetricTracer : _zet_metric_tracer_handle_t {
virtual ~MetricTracer() = default;
static MetricStreamer *fromHandle(zet_metric_tracer_handle_t handle) {
return MetricStreamer::fromHandle(reinterpret_cast<zet_metric_streamer_handle_t>(handle));
}
};
struct MetricQueryPool : _zet_metric_query_pool_handle_t {
virtual ~MetricQueryPool() = default;
@@ -134,7 +121,7 @@ struct MetricQueryPool : _zet_metric_query_pool_handle_t {
virtual ze_result_t createMetricQuery(uint32_t index,
zet_metric_query_handle_t *phMetricQuery) = 0;
static MetricQueryPool *create(zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup, const zet_metric_query_pool_desc_ext_t &desc);
static MetricQueryPool *create(zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup, const zet_metric_query_pool_desc_t &desc);
static MetricQueryPool *fromHandle(zet_metric_query_pool_handle_t handle);
zet_metric_query_pool_handle_t toHandle();
@@ -169,14 +156,8 @@ ze_result_t metricStreamerOpen(zet_context_handle_t hContext, zet_device_handle_
zet_metric_streamer_desc_t *pDesc, ze_event_handle_t hNotificationEvent,
zet_metric_streamer_handle_t *phMetricStreamer);
ze_result_t metricTracerOpen(zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
zet_metric_tracer_desc_t *pDesc, ze_event_handle_t hNotificationEvent,
zet_metric_tracer_handle_t *phMetricTracer);
// MetricQueryPool.
ze_result_t metricQueryPoolCreate(zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup, const zet_metric_query_pool_desc_t *pDesc,
zet_metric_query_pool_handle_t *phMetricQueryPool);
ze_result_t metricQueryPoolCreateExt(zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
const zet_metric_query_pool_desc_ext_t *pDesc, zet_metric_query_pool_handle_t *phMetricQueryPool);
ze_result_t metricQueryPoolCreate(zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
const zet_metric_query_pool_desc_t *pDesc, zet_metric_query_pool_handle_t *phMetricQueryPool);
} // namespace L0

59
level_zero/tools/source/metrics/metric_enumeration_imp.cpp
View File

@@ -194,7 +194,7 @@ MetricEnumeration::cacheMetricGroup(MetricsDiscovery::IMetricSet_1_5 &metricSet,
// Obtain params once again - updated after SetApiFiltering
pMetricSetParams = metricSet.GetParams();
zet_metric_group_properties_ext_t properties = {};
zet_metric_group_properties_t properties = {};
properties.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
snprintf(properties.name, sizeof(properties.name), "%s",
pMetricSetParams->SymbolName); // To always have null-terminated string
@@ -235,7 +235,7 @@ ze_result_t MetricEnumeration::createMetrics(MetricsDiscovery::IMetricSet_1_5 &m
MetricsDiscovery::TMetricParams_1_0 *pSourceMetricParams = pSourceMetric->GetParams();
DEBUG_BREAK_IF(pSourceMetricParams == nullptr);
zet_metric_properties_ext_t properties = {};
zet_metric_properties_t properties = {};
properties.stype = ZET_STRUCTURE_TYPE_METRIC_PROPERTIES;
snprintf(properties.name, sizeof(properties.name), "%s",
pSourceMetricParams->SymbolName); // To always have a null-terminated string
@@ -264,7 +264,7 @@ ze_result_t MetricEnumeration::createMetrics(MetricsDiscovery::IMetricSet_1_5 &m
pSourceInformation->GetParams();
DEBUG_BREAK_IF(pSourceInformationParams == nullptr);
zet_metric_properties_ext_t properties = {};
zet_metric_properties_t properties = {};
properties.stype = ZET_STRUCTURE_TYPE_METRIC_PROPERTIES;
snprintf(properties.name, sizeof(properties.name), "%s",
pSourceInformationParams->SymbolName); // To always have a null-terminated string
@@ -378,32 +378,16 @@ MetricGroupImp ::~MetricGroupImp() {
};
ze_result_t MetricGroupImp::getProperties(zet_metric_group_properties_t *pProperties) {
pProperties->version = zet_metric_group_properties_version_t::ZET_METRIC_GROUP_PROPERTIES_VERSION_CURRENT;
pProperties->domain = properties.domain;
pProperties->maxCommandQueueOrdinal = 0xFFFFFFFF;
pProperties->metricCount = properties.metricCount;
pProperties->samplingType = static_cast<zet_metric_group_sampling_type_t>(properties.samplingType);
memcpy(pProperties->name,
properties.name, sizeof(pProperties->name));
memcpy(pProperties->description,
properties.description, sizeof(pProperties->description));
return ZE_RESULT_SUCCESS;
}
ze_result_t MetricGroupImp::getPropertiesExt(zet_metric_group_properties_ext_t *pProperties) {
copyProperties(properties, *pProperties);
return ZE_RESULT_SUCCESS;
}
zet_metric_group_properties_ext_t MetricGroup::getProperties(const zet_metric_group_handle_t handle) {
zet_metric_group_properties_t MetricGroup::getProperties(const zet_metric_group_handle_t handle) {
auto metricGroup = MetricGroup::fromHandle(handle);
UNRECOVERABLE_IF(!metricGroup);
zet_metric_group_properties_ext_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES};
metricGroup->getPropertiesExt(&properties);
zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES};
metricGroup->getProperties(&properties);
return properties;
}
@@ -573,7 +557,7 @@ bool MetricGroupImp::getCalculatedMetricValues(const zet_metric_group_calculatio
return result;
}
ze_result_t MetricGroupImp::initialize(const zet_metric_group_properties_ext_t &sourceProperties,
ze_result_t MetricGroupImp::initialize(const zet_metric_group_properties_t &sourceProperties,
MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
const std::vector<Metric *> &groupMetrics) {
@@ -592,8 +576,8 @@ uint32_t MetricGroupImp::getRawReportSize() {
: pMetricSetParams->QueryReportSize;
}
void MetricGroupImp::copyProperties(const zet_metric_group_properties_ext_t &source,
zet_metric_group_properties_ext_t &destination) {
void MetricGroupImp::copyProperties(const zet_metric_group_properties_t &source,
zet_metric_group_properties_t &destination) {
destination = source;
memcpy_s(destination.name, sizeof(destination.name),
source.name, sizeof(destination.name));
@@ -636,32 +620,17 @@ void MetricGroupImp::copyValue(const MetricsDiscovery::TTypedValue_1_0 &source,
}
ze_result_t MetricImp::getProperties(zet_metric_properties_t *pProperties) {
pProperties->version = ZET_METRIC_PROPERTIES_VERSION_CURRENT;
pProperties->tierNumber = properties.tierNumber;
pProperties->metricType = properties.metricType;
pProperties->resultType = properties.resultType;
memcpy(pProperties->name, properties.name, sizeof(pProperties->name));
memcpy(pProperties->description, properties.description, sizeof(pProperties->description));
memcpy(pProperties->component, properties.component, sizeof(pProperties->component));
memcpy(pProperties->resultUnits, properties.resultUnits, sizeof(pProperties->resultUnits));
return ZE_RESULT_SUCCESS;
}
ze_result_t MetricImp::getPropertiesExt(zet_metric_properties_ext_t *pProperties) {
copyProperties(properties, *pProperties);
return ZE_RESULT_SUCCESS;
}
ze_result_t MetricImp::initialize(const zet_metric_properties_ext_t &sourceProperties) {
ze_result_t MetricImp::initialize(const zet_metric_properties_t &sourceProperties) {
copyProperties(sourceProperties, properties);
return ZE_RESULT_SUCCESS;
}
void MetricImp::copyProperties(const zet_metric_properties_ext_t &source,
zet_metric_properties_ext_t &destination) {
void MetricImp::copyProperties(const zet_metric_properties_t &source,
zet_metric_properties_t &destination) {
destination = source;
memcpy_s(destination.name, sizeof(destination.name),
source.name, sizeof(destination.name));
@@ -673,7 +642,7 @@ void MetricImp::copyProperties(const zet_metric_properties_ext_t &source,
source.resultUnits, sizeof(destination.resultUnits));
}
MetricGroup *MetricGroup::create(zet_metric_group_properties_ext_t &properties,
MetricGroup *MetricGroup::create(zet_metric_group_properties_t &properties,
MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
const std::vector<Metric *> &metrics) {
@@ -683,7 +652,7 @@ MetricGroup *MetricGroup::create(zet_metric_group_properties_ext_t &properties,
return pMetricGroup;
}
Metric *Metric::create(zet_metric_properties_ext_t &properties) {
Metric *Metric::create(zet_metric_properties_t &properties) {
auto pMetric = new MetricImp();
UNRECOVERABLE_IF(pMetric == nullptr);
pMetric->initialize(properties);

18
level_zero/tools/source/metrics/metric_enumeration_imp.h
View File

@@ -73,13 +73,12 @@ struct MetricGroupImp : MetricGroup {
~MetricGroupImp() override;
ze_result_t getProperties(zet_metric_group_properties_t *pProperties) override;
ze_result_t getPropertiesExt(zet_metric_group_properties_ext_t *pProperties) override;
ze_result_t getMetric(uint32_t *pCount, zet_metric_handle_t *phMetrics) override;
ze_result_t calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize, const uint8_t *pRawData,
uint32_t *pMetricValueCount,
zet_typed_value_t *pCalculatedData) override;
ze_result_t initialize(const zet_metric_group_properties_ext_t &sourceProperties,
ze_result_t initialize(const zet_metric_group_properties_t &sourceProperties,
MetricsDiscovery::IMetricSet_1_5 &metricSet,
MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
const std::vector<Metric *> &groupMetrics);
@@ -98,8 +97,8 @@ struct MetricGroupImp : MetricGroup {
ze_result_t closeIoStream() override;
protected:
void copyProperties(const zet_metric_group_properties_ext_t &source,
zet_metric_group_properties_ext_t &destination);
void copyProperties(const zet_metric_group_properties_t &source,
zet_metric_group_properties_t &destination);
void copyValue(const MetricsDiscovery::TTypedValue_1_0 &source,
zet_typed_value_t &destination) const;
@@ -112,7 +111,7 @@ struct MetricGroupImp : MetricGroup {
// Cached metrics.
std::vector<Metric *> metrics;
zet_metric_group_properties_ext_t properties{
zet_metric_group_properties_t properties{
ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES,
};
MetricsDiscovery::IMetricSet_1_5 *pReferenceMetricSet = nullptr;
@@ -123,15 +122,14 @@ struct MetricImp : Metric {
~MetricImp() override{};
ze_result_t getProperties(zet_metric_properties_t *pProperties) override;
ze_result_t getPropertiesExt(zet_metric_properties_ext_t *pProperties) override;
ze_result_t initialize(const zet_metric_properties_ext_t &sourceProperties);
ze_result_t initialize(const zet_metric_properties_t &sourceProperties);
protected:
void copyProperties(const zet_metric_properties_ext_t &source,
zet_metric_properties_ext_t &destination);
void copyProperties(const zet_metric_properties_t &source,
zet_metric_properties_t &destination);
zet_metric_properties_ext_t properties{
zet_metric_properties_t properties{
ZET_STRUCTURE_TYPE_METRIC_PROPERTIES};
};

24
level_zero/tools/source/metrics/metric_query_imp.cpp
View File

@@ -303,7 +303,7 @@ bool MetricsLibrary::getGpuCommands(CommandList &commandList,
ConfigurationHandle_1_0
MetricsLibrary::createConfiguration(const zet_metric_group_handle_t metricGroupHandle,
const zet_metric_group_properties_ext_t properties) {
const zet_metric_group_properties_t properties) {
// Metric group internal data.
auto metricGroup = MetricGroup::fromHandle(metricGroupHandle);
auto metricGroupDummy = ConfigurationHandle_1_0{};
@@ -376,21 +376,8 @@ void MetricsLibrary::deleteAllConfigurations() {
configurations.clear();
}
ze_result_t metricQueryPoolCreate(zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup, const zet_metric_query_pool_desc_t *pDesc,
zet_metric_query_pool_handle_t *phMetricQueryPool) {
zet_metric_query_pool_desc_ext_t descExt = {};
descExt.stype = ZET_STRUCTURE_TYPE_METRIC_QUERY_POOL_DESC;
descExt.type = (pDesc->flags == ZET_METRIC_QUERY_POOL_FLAG_PERFORMANCE)
? ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE
: ZET_METRIC_QUERY_POOL_TYPE_EXECUTION;
descExt.count = pDesc->count;
return metricQueryPoolCreateExt(nullptr, hDevice, hMetricGroup, &descExt, phMetricQueryPool);
}
ze_result_t metricQueryPoolCreateExt(zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
const zet_metric_query_pool_desc_ext_t *pDesc, zet_metric_query_pool_handle_t *phMetricQueryPool) {
ze_result_t metricQueryPoolCreate(zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
const zet_metric_query_pool_desc_t *pDesc, zet_metric_query_pool_handle_t *phMetricQueryPool) {
auto device = Device::fromHandle(hDevice);
auto &metricContext = device->getMetricContext();
@@ -410,7 +397,7 @@ ze_result_t metricQueryPoolCreateExt(zet_context_handle_t hContext, zet_device_h
MetricQueryPool *MetricQueryPool::create(zet_device_handle_t hDevice,
zet_metric_group_handle_t hMetricGroup,
const zet_metric_query_pool_desc_ext_t &desc) {
const zet_metric_query_pool_desc_t &desc) {
auto device = Device::fromHandle(hDevice);
auto metricPoolImp = new MetricQueryPoolImp(device->getMetricContext(), hMetricGroup, desc);
@@ -424,7 +411,7 @@ MetricQueryPool *MetricQueryPool::create(zet_device_handle_t hDevice,
MetricQueryPoolImp::MetricQueryPoolImp(MetricContext &metricContextInput,
zet_metric_group_handle_t hEventMetricGroupInput,
const zet_metric_query_pool_desc_ext_t &poolDescription)
const zet_metric_query_pool_desc_t &poolDescription)
: metricContext(metricContextInput), metricsLibrary(metricContext.getMetricsLibrary()),
description(poolDescription),
hMetricGroup(hEventMetricGroupInput) {}
@@ -499,7 +486,6 @@ MetricQueryImp::MetricQueryImp(MetricContext &metricContextInput, MetricQueryPoo
pool(poolInput), slot(slotInput) {}
ze_result_t MetricQueryImp::appendBegin(CommandList &commandList) {
switch (pool.description.type) {
case ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE:
return writeMetricQuery(commandList, nullptr, 0, nullptr, true);

6
level_zero/tools/source/metrics/metric_query_imp.h
View File

@@ -74,7 +74,7 @@ struct MetricsLibrary {
virtual bool getContextData(Device &device, ContextCreateData_1_0 &contextData);
ConfigurationHandle_1_0 createConfiguration(const zet_metric_group_handle_t metricGroup,
const zet_metric_group_properties_ext_t properties);
const zet_metric_group_properties_t properties);
ConfigurationHandle_1_0 addConfiguration(const zet_metric_group_handle_t metricGroup);
ClientGen getGenType(const uint32_t gen) const;
@@ -123,7 +123,7 @@ struct MetricQueryImp : MetricQuery {
struct MetricQueryPoolImp : MetricQueryPool {
public:
MetricQueryPoolImp(MetricContext &metricContext, zet_metric_group_handle_t hEventMetricGroup, const zet_metric_query_pool_desc_ext_t &poolDescription);
MetricQueryPoolImp(MetricContext &metricContext, zet_metric_group_handle_t hEventMetricGroup, const zet_metric_query_pool_desc_t &poolDescription);
bool create();
ze_result_t destroy() override;
@@ -138,7 +138,7 @@ struct MetricQueryPoolImp : MetricQueryPool {
MetricsLibrary &metricsLibrary;
std::vector<MetricQueryImp> pool;
NEO::GraphicsAllocation *pAllocation = nullptr;
zet_metric_query_pool_desc_ext_t description = {};
zet_metric_query_pool_desc_t description = {};
zet_metric_group_handle_t hMetricGroup = nullptr;
QueryHandle_1_0 query = {};
};

2
level_zero/tools/source/metrics/metric_streamer_imp.cpp
View File

@@ -147,7 +147,7 @@ uint32_t MetricStreamerImp::getRequiredBufferSize(const uint32_t maxReportCount)
: maxReportCount * rawReportSize;
}
ze_result_t MetricStreamer::open(zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
ze_result_t MetricStreamer::open(zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
zet_metric_streamer_desc_t &desc, ze_event_handle_t hNotificationEvent,
zet_metric_streamer_handle_t *phMetricStreamer) {
auto pDevice = Device::fromHandle(hDevice);

25
level_zero/tools/source/sysman/engine/engine.cpp
View File

@@ -19,15 +19,6 @@ EngineHandleContext::~EngineHandleContext() {
}
}
void EngineHandleContext::createHandle(zet_engine_group_t type) {
Engine *pEngine = new EngineImp(pOsSysman, type);
if (pEngine->initSuccess == true) {
handleList.push_back(pEngine);
} else {
delete pEngine;
}
}
void EngineHandleContext::createHandle(zes_engine_group_t type) {
Engine *pEngine = new EngineImp(pOsSysman, type);
if (pEngine->initSuccess == true) {
@@ -46,21 +37,7 @@ void EngineHandleContext::init() {
}
return;
}
createHandle(ZET_ENGINE_GROUP_COMPUTE_ALL);
}
ze_result_t EngineHandleContext::engineGet(uint32_t *pCount, zet_sysman_engine_handle_t *phEngine) {
uint32_t handleListSize = static_cast<uint32_t>(handleList.size());
uint32_t numToCopy = std::min(*pCount, handleListSize);
if (0 == *pCount || *pCount > handleListSize) {
*pCount = handleListSize;
}
if (nullptr != phEngine) {
for (uint32_t i = 0; i < numToCopy; i++) {
phEngine[i] = handleList[i]->toZetHandle();
}
}
return ZE_RESULT_SUCCESS;
createHandle(ZES_ENGINE_GROUP_COMPUTE_ALL);
}
ze_result_t EngineHandleContext::engineGet(uint32_t *pCount, zes_engine_handle_t *phEngine) {

19
level_zero/tools/source/sysman/engine/engine.h
View File

@@ -6,16 +6,10 @@
*/
#pragma once
#include <level_zero/zet_api.h>
#include "third_party/level_zero/zes_api_ext.h"
#include <level_zero/zes_api.h>
#include <vector>
struct _zet_sysman_engine_handle_t {
virtual ~_zet_sysman_engine_handle_t() = default;
};
struct _zes_engine_handle_t {
virtual ~_zes_engine_handle_t() = default;
};
@@ -24,21 +18,14 @@ namespace L0 {
struct OsSysman;
class Engine : _zet_sysman_engine_handle_t, _zes_engine_handle_t {
class Engine : _zes_engine_handle_t {
public:
virtual ze_result_t engineGetProperties(zet_engine_properties_t *pProperties) = 0;
virtual ze_result_t engineGetActivity(zet_engine_stats_t *pStats) = 0;
virtual ze_result_t engineGetProperties(zes_engine_properties_t *pProperties) = 0;
virtual ze_result_t engineGetActivity(zes_engine_stats_t *pStats) = 0;
static Engine *fromHandle(zet_sysman_engine_handle_t handle) {
return static_cast<Engine *>(handle);
}
static Engine *fromHandle(zes_engine_handle_t handle) {
return static_cast<Engine *>(handle);
}
inline zet_sysman_engine_handle_t toZetHandle() { return this; }
inline zes_engine_handle_t toHandle() { return this; }
bool initSuccess = false;
};
@@ -49,14 +36,12 @@ struct EngineHandleContext {
void init();
ze_result_t engineGet(uint32_t *pCount, zet_sysman_engine_handle_t *phEngine);
ze_result_t engineGet(uint32_t *pCount, zes_engine_handle_t *phEngine);
OsSysman *pOsSysman = nullptr;
std::vector<Engine *> handleList = {};
private:
void createHandle(zet_engine_group_t type);
void createHandle(zes_engine_group_t type);
};

29
level_zero/tools/source/sysman/engine/engine_imp.cpp
View File

@@ -11,14 +11,6 @@
namespace L0 {
ze_result_t EngineImp::engineGetActivity(zet_engine_stats_t *pStats) {
ze_result_t result = pOsEngine->getActiveTime(pStats->activeTime);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
return pOsEngine->getTimeStamp(pStats->timestamp);
}
ze_result_t EngineImp::engineGetActivity(zes_engine_stats_t *pStats) {
ze_result_t result = pOsEngine->getActiveTime(pStats->activeTime);
if (result != ZE_RESULT_SUCCESS) {
@@ -27,27 +19,11 @@ ze_result_t EngineImp::engineGetActivity(zes_engine_stats_t *pStats) {
return pOsEngine->getTimeStamp(pStats->timestamp);
}
ze_result_t EngineImp::engineGetProperties(zet_engine_properties_t *pProperties) {
*pProperties = zetEngineProperties;
return ZE_RESULT_SUCCESS;
}
ze_result_t EngineImp::engineGetProperties(zes_engine_properties_t *pProperties) {
*pProperties = engineProperties;
return ZE_RESULT_SUCCESS;
}
void EngineImp::init(zet_engine_group_t type) {
if (pOsEngine->getEngineGroup(type) == ZE_RESULT_SUCCESS) {
this->initSuccess = true;
} else {
this->initSuccess = false;
}
zetEngineProperties.type = type;
zetEngineProperties.onSubdevice = false;
zetEngineProperties.subdeviceId = 0;
}
void EngineImp::init(zes_engine_group_t type) {
if (pOsEngine->getEngineGroup(type) == ZE_RESULT_SUCCESS) {
this->initSuccess = true;
@@ -59,11 +35,6 @@ void EngineImp::init(zes_engine_group_t type) {
engineProperties.subdeviceId = 0;
}
EngineImp::EngineImp(OsSysman *pOsSysman, zet_engine_group_t type) {
pOsEngine = OsEngine::create(pOsSysman);
init(type);
}
EngineImp::EngineImp(OsSysman *pOsSysman, zes_engine_group_t type) {
pOsEngine = OsEngine::create(pOsSysman);
init(type);

8
level_zero/tools/source/sysman/engine/engine_imp.h
View File

@@ -11,27 +11,21 @@
#include "level_zero/tools/source/sysman/engine/engine.h"
#include "level_zero/tools/source/sysman/engine/os_engine.h"
#include <level_zero/zet_api.h>
#include <level_zero/zes_api.h>
namespace L0 {
class EngineImp : public Engine, NEO::NonCopyableOrMovableClass {
public:
ze_result_t engineGetProperties(zet_engine_properties_t *pProperties) override;
ze_result_t engineGetActivity(zet_engine_stats_t *pStats) override;
ze_result_t engineGetProperties(zes_engine_properties_t *pProperties) override;
ze_result_t engineGetActivity(zes_engine_stats_t *pStats) override;
EngineImp() = default;
EngineImp(OsSysman *pOsSysman, zet_engine_group_t type);
EngineImp(OsSysman *pOsSysman, zes_engine_group_t type);
~EngineImp() override;
OsEngine *pOsEngine = nullptr;
void init(zet_engine_group_t type);
void init(zes_engine_group_t type);
private:
zet_engine_properties_t zetEngineProperties = {};
zes_engine_properties_t engineProperties = {};
};
} // namespace L0

16
level_zero/tools/source/sysman/engine/linux/os_engine_imp.cpp
View File

@@ -24,22 +24,6 @@ ze_result_t LinuxEngineImp::getTimeStamp(uint64_t &timeStamp) {
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxEngineImp::getEngineGroup(zet_engine_group_t &engineGroup) {
std::string strVal;
ze_result_t result = pSysfsAccess->read(computeEngineGroupFile, strVal);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
if (strVal.compare(computeEngineGroupName) == 0) {
engineGroup = ZET_ENGINE_GROUP_COMPUTE_ALL;
} else {
engineGroup = ZET_ENGINE_GROUP_ALL;
return ZE_RESULT_ERROR_UNKNOWN;
}
return result;
}
ze_result_t LinuxEngineImp::getEngineGroup(zes_engine_group_t &engineGroup) {
std::string strVal;
ze_result_t result = pSysfsAccess->read(computeEngineGroupFile, strVal);

1
level_zero/tools/source/sysman/engine/linux/os_engine_imp.h
View File

@@ -16,7 +16,6 @@ class LinuxEngineImp : public OsEngine, NEO::NonCopyableOrMovableClass {
public:
ze_result_t getActiveTime(uint64_t &activeTime) override;
ze_result_t getTimeStamp(uint64_t &timeStamp) override;
ze_result_t getEngineGroup(zet_engine_group_t &engineGroup) override;
ze_result_t getEngineGroup(zes_engine_group_t &engineGroup) override;
LinuxEngineImp() = default;
LinuxEngineImp(OsSysman *pOsSysman);

5
level_zero/tools/source/sysman/engine/os_engine.h
View File

@@ -7,9 +7,7 @@
#pragma once
#include <level_zero/zet_api.h>
#include "third_party/level_zero/zes_api_ext.h"
#include <level_zero/zes_api.h>
namespace L0 {
@@ -18,7 +16,6 @@ class OsEngine {
public:
virtual ze_result_t getActiveTime(uint64_t &activeTime) = 0;
virtual ze_result_t getTimeStamp(uint64_t &timeStamp) = 0;
virtual ze_result_t getEngineGroup(zet_engine_group_t &engineGroup) = 0;
virtual ze_result_t getEngineGroup(zes_engine_group_t &engineGroup) = 0;
static OsEngine *create(OsSysman *pOsSysman);
virtual ~OsEngine() = default;

5
level_zero/tools/source/sysman/engine/windows/os_engine_imp.cpp
View File

@@ -13,7 +13,6 @@ class WddmEngineImp : public OsEngine {
public:
ze_result_t getActiveTime(uint64_t &activeTime) override;
ze_result_t getTimeStamp(uint64_t &timeStamp) override;
ze_result_t getEngineGroup(zet_engine_group_t &engineGroup) override;
ze_result_t getEngineGroup(zes_engine_group_t &engineGroup) override;
};
@@ -25,10 +24,6 @@ ze_result_t WddmEngineImp::getTimeStamp(uint64_t &timeStamp) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmEngineImp::getEngineGroup(zet_engine_group_t &engineGroup) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmEngineImp::getEngineGroup(zes_engine_group_t &engineGroup) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}

14
level_zero/tools/source/sysman/fabric_port/fabric_port.cpp
View File

@@ -56,18 +56,4 @@ ze_result_t FabricPortHandleContext::fabricPortGet(uint32_t *pCount, zes_fabric_
return ZE_RESULT_SUCCESS;
}
ze_result_t FabricPortHandleContext::fabricPortGet(uint32_t *pCount, zet_sysman_fabric_port_handle_t *phPort) {
uint32_t handleListSize = static_cast<uint32_t>(handleList.size());
uint32_t numToCopy = std::min(*pCount, handleListSize);
if (0 == *pCount || *pCount > handleListSize) {
*pCount = handleListSize;
}
if (nullptr != phPort) {
for (uint32_t i = 0; i < numToCopy; i++) {
phPort[i] = handleList[i]->toHandle();
}
}
return ZE_RESULT_SUCCESS;
}
} // namespace L0

22
level_zero/tools/source/sysman/fabric_port/fabric_port.h
View File

@@ -8,15 +8,10 @@
#pragma once
#include "shared/source/helpers/non_copyable_or_moveable.h"
#include <level_zero/zet_api.h>
#include "third_party/level_zero/zes_api_ext.h"
#include <level_zero/zes_api.h>
#include <vector>
struct _zet_sysman_fabric_port_handle_t {
virtual ~_zet_sysman_fabric_port_handle_t() = default;
};
struct _zes_fabric_port_handle_t {
virtual ~_zes_fabric_port_handle_t() = default;
};
@@ -33,7 +28,7 @@ class FabricDevice {
virtual uint32_t getNumPorts() = 0;
};
class FabricPort : _zet_sysman_fabric_port_handle_t, _zes_fabric_port_handle_t {
class FabricPort : _zes_fabric_port_handle_t {
public:
virtual ~FabricPort() = default;
virtual ze_result_t fabricPortGetProperties(zes_fabric_port_properties_t *pProperties) = 0;
@@ -43,20 +38,8 @@ class FabricPort : _zet_sysman_fabric_port_handle_t, _zes_fabric_port_handle_t {
virtual ze_result_t fabricPortGetState(zes_fabric_port_state_t *pState) = 0;
virtual ze_result_t fabricPortGetThroughput(zes_fabric_port_throughput_t *pThroughput) = 0;
virtual ze_result_t fabricPortGetProperties(zet_fabric_port_properties_t *pProperties) = 0;
virtual ze_result_t fabricPortGetLinkType(ze_bool_t verbose, zet_fabric_link_type_t *pLinkType) = 0;
virtual ze_result_t fabricPortGetConfig(zet_fabric_port_config_t *pConfig) = 0;
virtual ze_result_t fabricPortSetConfig(const zet_fabric_port_config_t *pConfig) = 0;
virtual ze_result_t fabricPortGetState(zet_fabric_port_state_t *pState) = 0;
virtual ze_result_t fabricPortGetThroughput(zet_fabric_port_throughput_t *pThroughput) = 0;
inline zet_sysman_fabric_port_handle_t toHandle() { return this; }
inline zes_fabric_port_handle_t toZesHandle() { return this; }
static FabricPort *fromHandle(zet_sysman_fabric_port_handle_t handle) {
return static_cast<FabricPort *>(handle);
}
static FabricPort *fromHandle(zes_fabric_port_handle_t handle) {
return static_cast<FabricPort *>(handle);
}
@@ -69,7 +52,6 @@ struct FabricPortHandleContext : NEO::NonCopyableOrMovableClass {
ze_result_t init();
ze_result_t fabricPortGet(uint32_t *pCount, zes_fabric_port_handle_t *phPort);
ze_result_t fabricPortGet(uint32_t *pCount, zet_sysman_fabric_port_handle_t *phPort);
FabricDevice *pFabricDevice = nullptr;
std::vector<FabricPort *> handleList = {};

31
level_zero/tools/source/sysman/fabric_port/fabric_port_imp.cpp
View File

@@ -65,37 +65,6 @@ ze_result_t FabricPortImp::fabricPortGetThroughput(zes_fabric_port_throughput_t
return pOsFabricPort->getThroughput(pThroughput);
}
ze_result_t FabricPortImp::fabricPortGetProperties(zet_fabric_port_properties_t *pProperties) {
pOsFabricPort->getModel(pProperties->model);
pProperties->onSubdevice = onSubdevice;
pProperties->subdeviceId = subdeviceId;
pOsFabricPort->getPortUuid(pProperties->portUuid);
pOsFabricPort->getMaxRxSpeed(pProperties->maxRxSpeed);
pOsFabricPort->getMaxTxSpeed(pProperties->maxTxSpeed);
return ZE_RESULT_SUCCESS;
}
ze_result_t FabricPortImp::fabricPortGetLinkType(ze_bool_t verbose, zet_fabric_link_type_t *pLinkType) {
return pOsFabricPort->getLinkType(verbose, pLinkType);
}
ze_result_t FabricPortImp::fabricPortGetConfig(zet_fabric_port_config_t *pConfig) {
return pOsFabricPort->getConfig(pConfig);
}
ze_result_t FabricPortImp::fabricPortSetConfig(const zet_fabric_port_config_t *pConfig) {
return pOsFabricPort->setConfig(pConfig);
}
ze_result_t FabricPortImp::fabricPortGetState(zet_fabric_port_state_t *pState) {
return pOsFabricPort->getState(pState);
}
ze_result_t FabricPortImp::fabricPortGetThroughput(zet_fabric_port_throughput_t *pThroughput) {
fabricPortGetTimestamp(pThroughput->timestamp);
return pOsFabricPort->getThroughput(pThroughput);
}
void FabricPortImp::init() {
onSubdevice = false;
subdeviceId = 0L;

11
level_zero/tools/source/sysman/fabric_port/fabric_port_imp.h
View File

@@ -11,9 +11,7 @@
#include "level_zero/tools/source/sysman/fabric_port/fabric_port.h"
#include "level_zero/tools/source/sysman/fabric_port/os_fabric_port.h"
#include <level_zero/zet_api.h>
#include "third_party/level_zero/zes_api_ext.h"
#include <level_zero/zes_api.h>
namespace L0 {
@@ -38,13 +36,6 @@ class FabricPortImp : public FabricPort, NEO::NonCopyableOrMovableClass {
ze_result_t fabricPortGetState(zes_fabric_port_state_t *pState) override;
ze_result_t fabricPortGetThroughput(zes_fabric_port_throughput_t *pThroughput) override;
ze_result_t fabricPortGetProperties(zet_fabric_port_properties_t *pProperties) override;
ze_result_t fabricPortGetLinkType(ze_bool_t verbose, zet_fabric_link_type_t *pLinkType) override;
ze_result_t fabricPortGetConfig(zet_fabric_port_config_t *pConfig) override;
ze_result_t fabricPortSetConfig(const zet_fabric_port_config_t *pConfig) override;
ze_result_t fabricPortGetState(zet_fabric_port_state_t *pState) override;
ze_result_t fabricPortGetThroughput(zet_fabric_port_throughput_t *pThroughput) override;
FabricPortImp() = delete;
FabricPortImp(FabricDevice *pFabricDevice, uint32_t portNum);
~FabricPortImp() override;

60
level_zero/tools/source/sysman/fabric_port/linux/os_fabric_port_imp.cpp
View File

@@ -22,7 +22,7 @@ LinuxFabricDeviceImp::~LinuxFabricDeviceImp() {
}
ze_result_t LinuxFabricPortImp::getLinkType(zes_fabric_link_type_t *pLinkType) {
::snprintf(pLinkType->desc, ZET_MAX_FABRIC_LINK_TYPE_SIZE, "%s", "SAMPLE LINK, VERBOSE");
::snprintf(pLinkType->desc, ZES_MAX_FABRIC_LINK_TYPE_SIZE, "%s", "SAMPLE LINK, VERBOSE");
return ZE_RESULT_SUCCESS;
}
@@ -57,7 +57,6 @@ ze_result_t LinuxFabricPortImp::getThroughput(zes_fabric_port_throughput_t *pThr
}
void LinuxFabricPortImp::getModel(char *model) {
::snprintf(model, ZET_MAX_FABRIC_PORT_MODEL_SIZE, "%s", this->model.c_str());
}
void LinuxFabricPortImp::getPortId(zes_fabric_port_id_t &portId) {
@@ -72,66 +71,9 @@ void LinuxFabricPortImp::getMaxTxSpeed(zes_fabric_port_speed_t &maxTxSpeed) {
maxTxSpeed = this->maxTxSpeed;
}
ze_result_t LinuxFabricPortImp::getLinkType(ze_bool_t verbose, zet_fabric_link_type_t *pLinkType) {
if (verbose) {
::snprintf(reinterpret_cast<char *>(pLinkType->desc), ZET_MAX_FABRIC_LINK_TYPE_SIZE, "%s", "SAMPLE LINK, VERBOSE");
} else {
::snprintf(reinterpret_cast<char *>(pLinkType->desc), ZET_MAX_FABRIC_LINK_TYPE_SIZE, "%s", "SAMPLE LINK");
}
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFabricPortImp::getConfig(zet_fabric_port_config_t *pConfig) {
*pConfig = zetConfig;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFabricPortImp::setConfig(const zet_fabric_port_config_t *pConfig) {
zetConfig = *pConfig;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFabricPortImp::getState(zet_fabric_port_state_t *pState) {
pState->status = ZET_FABRIC_PORT_STATUS_BLACK;
pState->qualityIssues = ZET_FABRIC_PORT_QUAL_ISSUES_NONE;
pState->stabilityIssues = ZET_FABRIC_PORT_STAB_ISSUES_NONE;
pState->rxSpeed.bitRate = 0LU;
pState->rxSpeed.width = 0U;
pState->rxSpeed.maxBandwidth = 0LU;
pState->txSpeed.bitRate = 0LU;
pState->txSpeed.width = 0U;
pState->txSpeed.maxBandwidth = 0LU;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFabricPortImp::getThroughput(zet_fabric_port_throughput_t *pThroughput) {
pThroughput->rxCounter = 0LU;
pThroughput->txCounter = 0LU;
pThroughput->rxMaxBandwidth = 0LU;
pThroughput->txMaxBandwidth = 0LU;
return ZE_RESULT_SUCCESS;
}
void LinuxFabricPortImp::getModel(int8_t *model) {
::snprintf(reinterpret_cast<char *>(model), ZET_MAX_FABRIC_PORT_MODEL_SIZE, "%s", this->zetModel.c_str());
}
void LinuxFabricPortImp::getPortUuid(zet_fabric_port_uuid_t &portUuid) {
portUuid = this->zetPortUuid;
}
void LinuxFabricPortImp::getMaxRxSpeed(zet_fabric_port_speed_t &maxRxSpeed) {
maxRxSpeed = this->zetMaxRxSpeed;
}
void LinuxFabricPortImp::getMaxTxSpeed(zet_fabric_port_speed_t &maxTxSpeed) {
maxTxSpeed = this->zetMaxTxSpeed;
}
LinuxFabricPortImp::LinuxFabricPortImp(OsFabricDevice *pOsFabricDevice, uint32_t portNum) {
this->portNum = portNum;
model = std::string("EXAMPLE");
zetModel = std::string("EXAMPLE");
}
LinuxFabricPortImp::~LinuxFabricPortImp() {

16
level_zero/tools/source/sysman/fabric_port/linux/os_fabric_port_imp.h
View File

@@ -38,16 +38,6 @@ class LinuxFabricPortImp : public OsFabricPort, NEO::NonCopyableOrMovableClass {
void getMaxRxSpeed(zes_fabric_port_speed_t &maxRxSpeed) override;
void getMaxTxSpeed(zes_fabric_port_speed_t &maxTxSpeed) override;
ze_result_t getLinkType(ze_bool_t verbose, zet_fabric_link_type_t *pLinkType) override;
ze_result_t getConfig(zet_fabric_port_config_t *pConfig) override;
ze_result_t setConfig(const zet_fabric_port_config_t *pConfig) override;
ze_result_t getState(zet_fabric_port_state_t *pState) override;
ze_result_t getThroughput(zet_fabric_port_throughput_t *pThroughput) override;
void getModel(int8_t *model) override;
void getPortUuid(zet_fabric_port_uuid_t &portUuid) override;
void getMaxRxSpeed(zet_fabric_port_speed_t &maxRxSpeed) override;
void getMaxTxSpeed(zet_fabric_port_speed_t &maxTxSpeed) override;
LinuxFabricPortImp() = delete;
LinuxFabricPortImp(OsFabricDevice *pOsFabricDevice, uint32_t portNum);
~LinuxFabricPortImp() override;
@@ -59,12 +49,6 @@ class LinuxFabricPortImp : public OsFabricPort, NEO::NonCopyableOrMovableClass {
zes_fabric_port_speed_t maxRxSpeed = {};
zes_fabric_port_speed_t maxTxSpeed = {};
zes_fabric_port_config_t config = {};
std::string zetModel = "";
zet_fabric_port_uuid_t zetPortUuid = {};
zet_fabric_port_speed_t zetMaxRxSpeed = {};
zet_fabric_port_speed_t zetMaxTxSpeed = {};
zet_fabric_port_config_t zetConfig = {};
};
} // namespace L0

14
level_zero/tools/source/sysman/fabric_port/os_fabric_port.h
View File

@@ -8,9 +8,7 @@
#pragma once
#include "level_zero/tools/source/sysman/os_sysman.h"
#include <level_zero/zet_api.h>
#include "third_party/level_zero/zes_api_ext.h"
#include <level_zero/zes_api.h>
namespace L0 {
@@ -35,16 +33,6 @@ class OsFabricPort {
virtual void getMaxRxSpeed(zes_fabric_port_speed_t &maxRxSpeed) = 0;
virtual void getMaxTxSpeed(zes_fabric_port_speed_t &maxTxSpeed) = 0;
virtual ze_result_t getLinkType(ze_bool_t verbose, zet_fabric_link_type_t *pLinkType) = 0;
virtual ze_result_t getConfig(zet_fabric_port_config_t *pConfig) = 0;
virtual ze_result_t setConfig(const zet_fabric_port_config_t *pConfig) = 0;
virtual ze_result_t getState(zet_fabric_port_state_t *pState) = 0;
virtual ze_result_t getThroughput(zet_fabric_port_throughput_t *pThroughput) = 0;
virtual void getModel(int8_t *model) = 0;
virtual void getPortUuid(zet_fabric_port_uuid_t &portUuid) = 0;
virtual void getMaxRxSpeed(zet_fabric_port_speed_t &maxRxSpeed) = 0;
virtual void getMaxTxSpeed(zet_fabric_port_speed_t &maxTxSpeed) = 0;
static OsFabricPort *create(OsFabricDevice *pOsFabricDevice, uint32_t portNum);
virtual ~OsFabricPort() = default;

12
level_zero/tools/source/sysman/fabric_port/windows/CMakeLists.txt
View File

@@ -5,17 +5,17 @@
#
set(L0_SRCS_TOOLS_SYSMAN_FABRICPORT_WINDOWS
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/os_fabric_port_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/os_fabric_port_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/os_fabric_port_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/os_fabric_port_imp.h
)
if(WIN32)
target_sources(${L0_STATIC_LIB_NAME}
PRIVATE
${L0_SRCS_TOOLS_SYSMAN_FABRICPORT_WINDOWS}
PRIVATE
${L0_SRCS_TOOLS_SYSMAN_FABRICPORT_WINDOWS}
)
endif()
# Make our source files visible to parent
## Make our source files visible to parent
set_property(GLOBAL PROPERTY L0_SRCS_TOOLS_SYSMAN_FABRICPORT_WINDOWS ${L0_SRCS_TOOLS_SYSMAN_FABRICPORT_WINDOWS})

36
level_zero/tools/source/sysman/fabric_port/windows/os_fabric_port_imp.cpp
View File

@@ -57,42 +57,6 @@ void WddmFabricPortImp::getMaxTxSpeed(zes_fabric_port_speed_t &maxTxSpeed) {
::memset(&maxTxSpeed, '\0', sizeof(maxTxSpeed));
}
ze_result_t WddmFabricPortImp::getLinkType(ze_bool_t verbose, zet_fabric_link_type_t *pLinkType) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFabricPortImp::getConfig(zet_fabric_port_config_t *pConfig) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFabricPortImp::setConfig(const zet_fabric_port_config_t *pConfig) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFabricPortImp::getState(zet_fabric_port_state_t *pState) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFabricPortImp::getThroughput(zet_fabric_port_throughput_t *pThroughput) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
void WddmFabricPortImp::getModel(int8_t *model) {
::memset(model, '\0', ZET_MAX_FABRIC_PORT_MODEL_SIZE);
}
void WddmFabricPortImp::getPortUuid(zet_fabric_port_uuid_t &portUuid) {
::memset(&portUuid, '\0', sizeof(portUuid));
}
void WddmFabricPortImp::getMaxRxSpeed(zet_fabric_port_speed_t &maxRxSpeed) {
::memset(&maxRxSpeed, '\0', sizeof(maxRxSpeed));
}
void WddmFabricPortImp::getMaxTxSpeed(zet_fabric_port_speed_t &maxTxSpeed) {
::memset(&maxTxSpeed, '\0', sizeof(maxTxSpeed));
}
WddmFabricPortImp::WddmFabricPortImp(OsFabricDevice *pOsFabricDevice, uint32_t portNum) {
}

10
level_zero/tools/source/sysman/fabric_port/windows/os_fabric_port_imp.h
View File

@@ -39,16 +39,6 @@ class WddmFabricPortImp : public OsFabricPort, NEO::NonCopyableOrMovableClass {
void getMaxRxSpeed(zes_fabric_port_speed_t &maxRxSpeed) override;
void getMaxTxSpeed(zes_fabric_port_speed_t &maxTxSpeed) override;
ze_result_t getLinkType(ze_bool_t verbose, zet_fabric_link_type_t *pLinkType) override;
ze_result_t getConfig(zet_fabric_port_config_t *pConfig) override;
ze_result_t setConfig(const zet_fabric_port_config_t *pConfig) override;
ze_result_t getState(zet_fabric_port_state_t *pState) override;
ze_result_t getThroughput(zet_fabric_port_throughput_t *pThroughput) override;
void getModel(int8_t *model) override;
void getPortUuid(zet_fabric_port_uuid_t &portUuid) override;
void getMaxRxSpeed(zet_fabric_port_speed_t &maxRxSpeed) override;
void getMaxTxSpeed(zet_fabric_port_speed_t &maxTxSpeed) override;
WddmFabricPortImp() = delete;
WddmFabricPortImp(OsFabricDevice *pOsFabricDevice, uint32_t portNum);
~WddmFabricPortImp() override;

14
level_zero/tools/source/sysman/frequency/frequency.cpp
View File

@@ -25,20 +25,6 @@ ze_result_t FrequencyHandleContext::init() {
return ZE_RESULT_SUCCESS;
}
ze_result_t FrequencyHandleContext::frequencyGet(uint32_t *pCount, zet_sysman_freq_handle_t *phFrequency) {
uint32_t handleListSize = static_cast<uint32_t>(handleList.size());
uint32_t numToCopy = std::min(*pCount, handleListSize);
if (0 == *pCount || *pCount > handleListSize) {
*pCount = handleListSize;
}
if (nullptr != phFrequency) {
for (uint32_t i = 0; i < numToCopy; i++) {
phFrequency[i] = handleList[i]->toHandle();
}
}
return ZE_RESULT_SUCCESS;
}
ze_result_t FrequencyHandleContext::frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency) {
uint32_t handleListSize = static_cast<uint32_t>(handleList.size());
uint32_t numToCopy = std::min(*pCount, handleListSize);

20
level_zero/tools/source/sysman/frequency/frequency.h
View File

@@ -6,16 +6,10 @@
*/
#pragma once
#include <level_zero/zet_api.h>
#include "third_party/level_zero/zes_api_ext.h"
#include <level_zero/zes_api.h>
#include <vector>
struct _zet_sysman_freq_handle_t {
virtual ~_zet_sysman_freq_handle_t() = default;
};
struct _zes_freq_handle_t {
virtual ~_zes_freq_handle_t() = default;
};
@@ -24,14 +18,9 @@ namespace L0 {
struct OsSysman;
class Frequency : _zet_sysman_freq_handle_t, _zes_freq_handle_t {
class Frequency : _zes_freq_handle_t {
public:
virtual ~Frequency() {}
virtual ze_result_t frequencyGetProperties(zet_freq_properties_t *pProperties) = 0;
virtual ze_result_t frequencyGetAvailableClocks(uint32_t *pCount, double *phFrequency) = 0;
virtual ze_result_t frequencyGetRange(zet_freq_range_t *pLimits) = 0;
virtual ze_result_t frequencySetRange(const zet_freq_range_t *pLimits) = 0;
virtual ze_result_t frequencyGetState(zet_freq_state_t *pState) = 0;
virtual ze_result_t frequencyGetProperties(zes_freq_properties_t *pProperties) = 0;
virtual ze_result_t frequencyGetRange(zes_freq_range_t *pLimits) = 0;
@@ -39,13 +28,9 @@ class Frequency : _zet_sysman_freq_handle_t, _zes_freq_handle_t {
virtual ze_result_t frequencyGetState(zes_freq_state_t *pState) = 0;
virtual ze_result_t frequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) = 0;
static Frequency *fromHandle(zet_sysman_freq_handle_t handle) {
return static_cast<Frequency *>(handle);
}
static Frequency *fromHandle(zes_freq_handle_t handle) {
return static_cast<Frequency *>(handle);
}
inline zet_sysman_freq_handle_t toHandle() { return this; }
inline zes_freq_handle_t toZesFreqHandle() { return this; }
};
@@ -55,7 +40,6 @@ struct FrequencyHandleContext {
ze_result_t init();
ze_result_t frequencyGet(uint32_t *pCount, zet_sysman_freq_handle_t *phFrequency);
ze_result_t frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency);
OsSysman *pOsSysman;

117
level_zero/tools/source/sysman/frequency/frequency_imp.cpp
View File

@@ -98,124 +98,7 @@ ze_result_t FrequencyImp::frequencyGetThrottleTime(zes_freq_throttle_time_t *pTh
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t FrequencyImp::frequencyGetProperties(zet_freq_properties_t *pProperties) {
*pProperties = frequencyProperties;
return ZE_RESULT_SUCCESS;
}
ze_result_t FrequencyImp::frequencyGetAvailableClocks(uint32_t *pCount, double *phFrequency) {
if (*pCount == 0) {
*pCount = numClocks;
return ZE_RESULT_SUCCESS;
}
if (*pCount > numClocks) {
*pCount = numClocks;
}
if (phFrequency != nullptr) {
for (unsigned int i = 0; i < *pCount; i++) {
phFrequency[i] = pClocks[i];
}
}
return ZE_RESULT_SUCCESS;
}
ze_result_t FrequencyImp::frequencyGetRange(zet_freq_range_t *pLimits) {
ze_result_t result = pOsFrequency->getMax(pLimits->max);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
return pOsFrequency->getMin(pLimits->min);
}
ze_result_t FrequencyImp::frequencySetRange(const zet_freq_range_t *pLimits) {
double newMin = round(pLimits->min);
double newMax = round(pLimits->max);
bool newMinValid = false, newMaxValid = false;
for (unsigned int i = 0; i < numClocks; i++) {
if (newMin == pClocks[i]) {
newMinValid = true;
}
if (newMax == pClocks[i]) {
newMaxValid = true;
}
}
if (newMin > newMax || !newMinValid || !newMaxValid) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
double currentMax;
pOsFrequency->getMax(currentMax);
if (newMin > currentMax) {
// set the max first
ze_result_t result = pOsFrequency->setMax(newMax);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
return pOsFrequency->setMin(newMin);
}
// set the min first
ze_result_t result = pOsFrequency->setMin(newMin);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
return pOsFrequency->setMax(newMax);
}
ze_result_t FrequencyImp::frequencyGetState(zet_freq_state_t *pState) {
ze_result_t result;
result = pOsFrequency->getRequest(pState->request);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
result = pOsFrequency->getTdp(pState->tdp);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
result = pOsFrequency->getEfficient(pState->efficient);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
result = pOsFrequency->getActual(pState->actual);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
result = pOsFrequency->getThrottleReasons(pState->throttleReasons);
if (ZE_RESULT_ERROR_UNKNOWN == result) {
// Throttle Reason is optional, set to none for now.
pState->throttleReasons = ZET_FREQ_THROTTLE_REASONS_NONE;
result = ZE_RESULT_SUCCESS;
}
return result;
}
void FrequencyImp::init() {
frequencyProperties.type = ZET_FREQ_DOMAIN_GPU;
frequencyProperties.onSubdevice = false;
frequencyProperties.subdeviceId = 0;
frequencyProperties.canControl = canControl;
ze_result_t result1 = pOsFrequency->getMinVal(frequencyProperties.min);
ze_result_t result2 = pOsFrequency->getMaxVal(frequencyProperties.max);
// If can't figure out the valid range, then can't control it.
if (ZE_RESULT_SUCCESS != result1 || ZE_RESULT_SUCCESS != result2) {
frequencyProperties.canControl = false;
frequencyProperties.min = 0.0;
frequencyProperties.max = 0.0;
}
frequencyProperties.step = step;
double freqRange = frequencyProperties.max - frequencyProperties.min;
numClocks = static_cast<uint32_t>(round(freqRange / frequencyProperties.step)) + 1;
pClocks = new double[numClocks];
for (unsigned int i = 0; i < numClocks; i++) {
pClocks[i] = round(frequencyProperties.min + (frequencyProperties.step * i));
}
frequencyProperties.isThrottleEventSupported = false;
zesFrequencyProperties.stype = ZES_STRUCTURE_TYPE_FREQ_PROPERTIES;
zesFrequencyProperties.pNext = nullptr;
zesFrequencyProperties.type = ZES_FREQ_DOMAIN_GPU;

9
level_zero/tools/source/sysman/frequency/frequency_imp.h
View File

@@ -11,18 +11,12 @@
#include "level_zero/tools/source/sysman/frequency/frequency.h"
#include "level_zero/tools/source/sysman/frequency/os_frequency.h"
#include <level_zero/zet_api.h>
#include <level_zero/zes_api.h>
namespace L0 {
class FrequencyImp : public Frequency, NEO::NonCopyableOrMovableClass {
public:
ze_result_t frequencyGetProperties(zet_freq_properties_t *pProperties) override;
ze_result_t frequencyGetAvailableClocks(uint32_t *pCount, double *phFrequency) override;
ze_result_t frequencyGetRange(zet_freq_range_t *pLimits) override;
ze_result_t frequencySetRange(const zet_freq_range_t *pLimits) override;
ze_result_t frequencyGetState(zet_freq_state_t *pState) override;
ze_result_t frequencyGetProperties(zes_freq_properties_t *pProperties) override;
ze_result_t frequencyGetRange(zes_freq_range_t *pLimits) override;
ze_result_t frequencySetRange(const zes_freq_range_t *pLimits) override;
@@ -39,7 +33,6 @@ class FrequencyImp : public Frequency, NEO::NonCopyableOrMovableClass {
static const double step;
static const bool canControl;
zet_freq_properties_t frequencyProperties = {};
zes_freq_properties_t zesFrequencyProperties = {};
double *pClocks = nullptr;
uint32_t numClocks = 0;

2
level_zero/tools/source/sysman/frequency/linux/os_frequency_imp.cpp
View File

@@ -125,7 +125,7 @@ ze_result_t LinuxFrequencyImp::getMinVal(double &minVal) {
}
ze_result_t LinuxFrequencyImp::getThrottleReasons(uint32_t &throttleReasons) {
throttleReasons = ZET_FREQ_THROTTLE_REASONS_NONE;
throttleReasons = 0u;
return ZE_RESULT_SUCCESS;
}

1
level_zero/tools/source/sysman/frequency/os_frequency.h
View File

@@ -8,7 +8,6 @@
#pragma once
#include "level_zero/tools/source/sysman/os_sysman.h"
#include <level_zero/zet_api.h>
namespace L0 {

5
level_zero/tools/source/sysman/global_operations/global_operations.h
View File

@@ -6,16 +6,15 @@
*/
#pragma once
#include <level_zero/zet_api.h>
#include <level_zero/zes_api.h>
namespace L0 {
class GlobalOperations {
public:
virtual ~GlobalOperations(){};
virtual ze_result_t deviceGetProperties(zet_sysman_properties_t *pProperties) = 0;
virtual ze_result_t reset() = 0;
virtual ze_result_t processesGetState(uint32_t *pCount, zet_process_state_t *pProcesses) = 0;
virtual ze_result_t processesGetState(uint32_t *pCount, zes_process_state_t *pProcesses) = 0;
virtual void init() = 0;
};

23
level_zero/tools/source/sysman/global_operations/global_operations_imp.cpp
View File

@@ -14,8 +14,8 @@
namespace L0 {
ze_result_t GlobalOperationsImp::processesGetState(uint32_t *pCount, zet_process_state_t *pProcesses) {
std::vector<zet_process_state_t> pProcessList;
ze_result_t GlobalOperationsImp::processesGetState(uint32_t *pCount, zes_process_state_t *pProcesses) {
std::vector<zes_process_state_t> pProcessList;
ze_result_t result = pOsGlobalOperations->scanProcessesState(pProcessList);
if (result != ZE_RESULT_SUCCESS) {
return result;
@@ -37,19 +37,6 @@ ze_result_t GlobalOperationsImp::processesGetState(uint32_t *pCount, zet_process
return result;
}
ze_result_t GlobalOperationsImp::deviceGetProperties(zet_sysman_properties_t *pProperties) {
Device *device = L0::Device::fromHandle(hCoreDevice);
ze_device_properties_t deviceProperties;
device->getProperties(&deviceProperties);
sysmanProperties.core = deviceProperties;
uint32_t count = 0;
device->getSubDevices(&count, nullptr);
sysmanProperties.numSubdevices = count;
*pProperties = sysmanProperties;
return ZE_RESULT_SUCCESS;
}
ze_result_t GlobalOperationsImp::reset() {
return pOsGlobalOperations->reset();
}
@@ -59,12 +46,6 @@ void GlobalOperationsImp::init() {
pOsGlobalOperations = OsGlobalOperations::create(pOsSysman);
}
UNRECOVERABLE_IF(nullptr == pOsGlobalOperations);
pOsGlobalOperations->getVendorName(sysmanProperties.vendorName);
pOsGlobalOperations->getDriverVersion(sysmanProperties.driverVersion);
pOsGlobalOperations->getModelName(sysmanProperties.modelName);
pOsGlobalOperations->getBrandName(sysmanProperties.brandName);
pOsGlobalOperations->getBoardNumber(sysmanProperties.boardNumber);
pOsGlobalOperations->getSerialNumber(sysmanProperties.serialNumber);
}
GlobalOperationsImp::~GlobalOperationsImp() {

4
level_zero/tools/source/sysman/global_operations/global_operations_imp.h
View File

@@ -20,9 +20,8 @@ namespace L0 {
class GlobalOperationsImp : public GlobalOperations, NEO::NonCopyableOrMovableClass {
public:
void init() override;
ze_result_t deviceGetProperties(zet_sysman_properties_t *pProperties) override;
ze_result_t reset() override;
ze_result_t processesGetState(uint32_t *pCount, zet_process_state_t *pProcesses) override;
ze_result_t processesGetState(uint32_t *pCount, zes_process_state_t *pProcesses) override;
OsGlobalOperations *pOsGlobalOperations = nullptr;
ze_device_handle_t hCoreDevice = {};
@@ -34,7 +33,6 @@ class GlobalOperationsImp : public GlobalOperations, NEO::NonCopyableOrMovableCl
private:
OsSysman *pOsSysman = nullptr;
zet_sysman_properties_t sysmanProperties = {};
};
} // namespace L0

32
level_zero/tools/source/sysman/global_operations/linux/os_global_operations_imp.cpp
View File

@@ -31,24 +31,24 @@ const std::string LinuxGlobalOperationsImp::clientsDir("clients");
// with engine enum defined in leve-zero spec
// Note that entries with int 2 and 3(represented by i915 as CLASS_VIDEO and CLASS_VIDEO_ENHANCE)
// are both mapped to MEDIA, as CLASS_VIDEO represents any media fixed-function hardware.
const std::map<int, zet_engine_type_t> engineMap = {
{0, ZET_ENGINE_TYPE_3D},
{1, ZET_ENGINE_TYPE_DMA},
{2, ZET_ENGINE_TYPE_MEDIA},
{3, ZET_ENGINE_TYPE_MEDIA},
{4, ZET_ENGINE_TYPE_COMPUTE}};
const std::map<int, zes_engine_type_flags_t> engineMap = {
{0, ZES_ENGINE_TYPE_FLAG_3D},
{1, ZES_ENGINE_TYPE_FLAG_DMA},
{2, ZES_ENGINE_TYPE_FLAG_MEDIA},
{3, ZES_ENGINE_TYPE_FLAG_MEDIA},
{4, ZES_ENGINE_TYPE_FLAG_COMPUTE}};
void LinuxGlobalOperationsImp::getSerialNumber(int8_t (&serialNumber)[ZET_STRING_PROPERTY_SIZE]) {
void LinuxGlobalOperationsImp::getSerialNumber(int8_t (&serialNumber)[ZES_STRING_PROPERTY_SIZE]) {
std::copy(unknown.begin(), unknown.end(), serialNumber);
serialNumber[unknown.size()] = '\0';
}
void LinuxGlobalOperationsImp::getBoardNumber(int8_t (&boardNumber)[ZET_STRING_PROPERTY_SIZE]) {
void LinuxGlobalOperationsImp::getBoardNumber(int8_t (&boardNumber)[ZES_STRING_PROPERTY_SIZE]) {
std::copy(unknown.begin(), unknown.end(), boardNumber);
boardNumber[unknown.size()] = '\0';
}
void LinuxGlobalOperationsImp::getBrandName(int8_t (&brandName)[ZET_STRING_PROPERTY_SIZE]) {
void LinuxGlobalOperationsImp::getBrandName(int8_t (&brandName)[ZES_STRING_PROPERTY_SIZE]) {
std::string strVal;
ze_result_t result = pSysfsAccess->read(subsystemVendorFile, strVal);
if (ZE_RESULT_SUCCESS != result) {
@@ -65,7 +65,7 @@ void LinuxGlobalOperationsImp::getBrandName(int8_t (&brandName)[ZET_STRING_PROPE
brandName[unknown.size()] = '\0';
}
void LinuxGlobalOperationsImp::getModelName(int8_t (&modelName)[ZET_STRING_PROPERTY_SIZE]) {
void LinuxGlobalOperationsImp::getModelName(int8_t (&modelName)[ZES_STRING_PROPERTY_SIZE]) {
std::string strVal;
ze_result_t result = pSysfsAccess->read(deviceFile, strVal);
if (ZE_RESULT_SUCCESS != result) {
@@ -78,7 +78,7 @@ void LinuxGlobalOperationsImp::getModelName(int8_t (&modelName)[ZET_STRING_PROPE
modelName[strVal.size()] = '\0';
}
void LinuxGlobalOperationsImp::getVendorName(int8_t (&vendorName)[ZET_STRING_PROPERTY_SIZE]) {
void LinuxGlobalOperationsImp::getVendorName(int8_t (&vendorName)[ZES_STRING_PROPERTY_SIZE]) {
std::string strVal;
ze_result_t result = pSysfsAccess->read(vendorFile, strVal);
if (ZE_RESULT_SUCCESS != result) {
@@ -95,7 +95,7 @@ void LinuxGlobalOperationsImp::getVendorName(int8_t (&vendorName)[ZET_STRING_PRO
vendorName[unknown.size()] = '\0';
}
void LinuxGlobalOperationsImp::getDriverVersion(int8_t (&driverVersion)[ZET_STRING_PROPERTY_SIZE]) {
void LinuxGlobalOperationsImp::getDriverVersion(int8_t (&driverVersion)[ZES_STRING_PROPERTY_SIZE]) {
std::copy(unknown.begin(), unknown.end(), driverVersion);
driverVersion[unknown.size()] = '\0';
}
@@ -228,7 +228,7 @@ ze_result_t LinuxGlobalOperationsImp::reset() {
// accumulated nanoseconds each client spent on engines.
// Thus we traverse each file in busy dir for non-zero time and if we find that file say 0,then we could say that
// this engine 0 is used by process.
ze_result_t LinuxGlobalOperationsImp::scanProcessesState(std::vector<zet_process_state_t> &pProcessList) {
ze_result_t LinuxGlobalOperationsImp::scanProcessesState(std::vector<zes_process_state_t> &pProcessList) {
std::vector<std::string> clientIds;
struct engineMemoryPairType {
int64_t engineTypeField;
@@ -282,7 +282,7 @@ ze_result_t LinuxGlobalOperationsImp::scanProcessesState(std::vector<zet_process
if (timeSpent > 0) {
int i915EnginNumber = stoi(engineNum);
auto i915MapToL0EngineType = engineMap.find(i915EnginNumber);
zet_engine_type_t val = ZET_ENGINE_TYPE_OTHER;
zes_engine_type_flags_t val = ZES_ENGINE_TYPE_FLAG_OTHER;
if (i915MapToL0EngineType != engineMap.end()) {
// Found a valid map
val = i915MapToL0EngineType->second;
@@ -320,10 +320,10 @@ ze_result_t LinuxGlobalOperationsImp::scanProcessesState(std::vector<zet_process
// iterate through all elements of pidClientMap
for (auto itr = pidClientMap.begin(); itr != pidClientMap.end(); ++itr) {
zet_process_state_t process;
zes_process_state_t process;
process.processId = static_cast<uint32_t>(itr->first);
process.memSize = itr->second.deviceMemorySizeField;
process.engines = itr->second.engineTypeField;
process.engines = static_cast<uint32_t>(itr->second.engineTypeField);
pProcessList.push_back(process);
}
return result;

14
level_zero/tools/source/sysman/global_operations/linux/os_global_operations_imp.h
View File

@@ -14,14 +14,14 @@ class SysfsAccess;
class LinuxGlobalOperationsImp : public OsGlobalOperations, NEO::NonCopyableOrMovableClass {
public:
void getSerialNumber(int8_t (&serialNumber)[ZET_STRING_PROPERTY_SIZE]) override;
void getBoardNumber(int8_t (&boardNumber)[ZET_STRING_PROPERTY_SIZE]) override;
void getBrandName(int8_t (&brandName)[ZET_STRING_PROPERTY_SIZE]) override;
void getModelName(int8_t (&modelName)[ZET_STRING_PROPERTY_SIZE]) override;
void getVendorName(int8_t (&vendorName)[ZET_STRING_PROPERTY_SIZE]) override;
void getDriverVersion(int8_t (&driverVersion)[ZET_STRING_PROPERTY_SIZE]) override;
void getSerialNumber(int8_t (&serialNumber)[ZES_STRING_PROPERTY_SIZE]) override;
void getBoardNumber(int8_t (&boardNumber)[ZES_STRING_PROPERTY_SIZE]) override;
void getBrandName(int8_t (&brandName)[ZES_STRING_PROPERTY_SIZE]) override;
void getModelName(int8_t (&modelName)[ZES_STRING_PROPERTY_SIZE]) override;
void getVendorName(int8_t (&vendorName)[ZES_STRING_PROPERTY_SIZE]) override;
void getDriverVersion(int8_t (&driverVersion)[ZES_STRING_PROPERTY_SIZE]) override;
ze_result_t reset() override;
ze_result_t scanProcessesState(std::vector<zet_process_state_t> &pProcessList) override;
ze_result_t scanProcessesState(std::vector<zes_process_state_t> &pProcessList) override;
LinuxGlobalOperationsImp() = default;
LinuxGlobalOperationsImp(OsSysman *pOsSysman);
~LinuxGlobalOperationsImp() override = default;

16
level_zero/tools/source/sysman/global_operations/os_global_operations.h
View File

@@ -8,7 +8,7 @@
#pragma once
#include "level_zero/tools/source/sysman/os_sysman.h"
#include <level_zero/zet_api.h>
#include <level_zero/zes_api.h>
#include <string>
#include <vector>
@@ -17,14 +17,14 @@ namespace L0 {
class OsGlobalOperations {
public:
virtual void getSerialNumber(int8_t (&serialNumber)[ZET_STRING_PROPERTY_SIZE]) = 0;
virtual void getBoardNumber(int8_t (&boardNumber)[ZET_STRING_PROPERTY_SIZE]) = 0;
virtual void getBrandName(int8_t (&brandName)[ZET_STRING_PROPERTY_SIZE]) = 0;
virtual void getModelName(int8_t (&modelName)[ZET_STRING_PROPERTY_SIZE]) = 0;
virtual void getVendorName(int8_t (&vendorName)[ZET_STRING_PROPERTY_SIZE]) = 0;
virtual void getDriverVersion(int8_t (&driverVersion)[ZET_STRING_PROPERTY_SIZE]) = 0;
virtual void getSerialNumber(int8_t (&serialNumber)[ZES_STRING_PROPERTY_SIZE]) = 0;
virtual void getBoardNumber(int8_t (&boardNumber)[ZES_STRING_PROPERTY_SIZE]) = 0;
virtual void getBrandName(int8_t (&brandName)[ZES_STRING_PROPERTY_SIZE]) = 0;
virtual void getModelName(int8_t (&modelName)[ZES_STRING_PROPERTY_SIZE]) = 0;
virtual void getVendorName(int8_t (&vendorName)[ZES_STRING_PROPERTY_SIZE]) = 0;
virtual void getDriverVersion(int8_t (&driverVersion)[ZES_STRING_PROPERTY_SIZE]) = 0;
virtual ze_result_t reset() = 0;
virtual ze_result_t scanProcessesState(std::vector<zet_process_state_t> &pProcessList) = 0;
virtual ze_result_t scanProcessesState(std::vector<zes_process_state_t> &pProcessList) = 0;
static OsGlobalOperations *create(OsSysman *pOsSysman);
virtual ~OsGlobalOperations() {}
};

28
level_zero/tools/source/sysman/global_operations/windows/os_global_operations_imp.cpp
View File

@@ -12,14 +12,14 @@ namespace L0 {
class WddmGlobalOperationsImp : public OsGlobalOperations {
public:
void getSerialNumber(int8_t (&serialNumber)[ZET_STRING_PROPERTY_SIZE]) override;
void getBoardNumber(int8_t (&boardNumber)[ZET_STRING_PROPERTY_SIZE]) override;
void getBrandName(int8_t (&brandName)[ZET_STRING_PROPERTY_SIZE]) override;
void getModelName(int8_t (&modelName)[ZET_STRING_PROPERTY_SIZE]) override;
void getVendorName(int8_t (&vendorName)[ZET_STRING_PROPERTY_SIZE]) override;
void getDriverVersion(int8_t (&driverVersion)[ZET_STRING_PROPERTY_SIZE]) override;
void getSerialNumber(int8_t (&serialNumber)[ZES_STRING_PROPERTY_SIZE]) override;
void getBoardNumber(int8_t (&boardNumber)[ZES_STRING_PROPERTY_SIZE]) override;
void getBrandName(int8_t (&brandName)[ZES_STRING_PROPERTY_SIZE]) override;
void getModelName(int8_t (&modelName)[ZES_STRING_PROPERTY_SIZE]) override;
void getVendorName(int8_t (&vendorName)[ZES_STRING_PROPERTY_SIZE]) override;
void getDriverVersion(int8_t (&driverVersion)[ZES_STRING_PROPERTY_SIZE]) override;
ze_result_t reset() override;
ze_result_t scanProcessesState(std::vector<zet_process_state_t> &pProcessList) override;
ze_result_t scanProcessesState(std::vector<zes_process_state_t> &pProcessList) override;
WddmGlobalOperationsImp(OsSysman *pOsSysman);
~WddmGlobalOperationsImp() = default;
@@ -29,29 +29,29 @@ class WddmGlobalOperationsImp : public OsGlobalOperations {
WddmGlobalOperationsImp &operator=(const WddmGlobalOperationsImp &obj) = delete;
};
void WddmGlobalOperationsImp::getSerialNumber(int8_t (&serialNumber)[ZET_STRING_PROPERTY_SIZE]) {
void WddmGlobalOperationsImp::getSerialNumber(int8_t (&serialNumber)[ZES_STRING_PROPERTY_SIZE]) {
}
void WddmGlobalOperationsImp::getBoardNumber(int8_t (&boardNumber)[ZET_STRING_PROPERTY_SIZE]) {
void WddmGlobalOperationsImp::getBoardNumber(int8_t (&boardNumber)[ZES_STRING_PROPERTY_SIZE]) {
}
void WddmGlobalOperationsImp::getBrandName(int8_t (&brandName)[ZET_STRING_PROPERTY_SIZE]) {
void WddmGlobalOperationsImp::getBrandName(int8_t (&brandName)[ZES_STRING_PROPERTY_SIZE]) {
}
void WddmGlobalOperationsImp::getModelName(int8_t (&modelName)[ZET_STRING_PROPERTY_SIZE]) {
void WddmGlobalOperationsImp::getModelName(int8_t (&modelName)[ZES_STRING_PROPERTY_SIZE]) {
}
void WddmGlobalOperationsImp::getVendorName(int8_t (&vendorName)[ZET_STRING_PROPERTY_SIZE]) {
void WddmGlobalOperationsImp::getVendorName(int8_t (&vendorName)[ZES_STRING_PROPERTY_SIZE]) {
}
void WddmGlobalOperationsImp::getDriverVersion(int8_t (&driverVersion)[ZET_STRING_PROPERTY_SIZE]) {
void WddmGlobalOperationsImp::getDriverVersion(int8_t (&driverVersion)[ZES_STRING_PROPERTY_SIZE]) {
}
ze_result_t WddmGlobalOperationsImp::reset() {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmGlobalOperationsImp::scanProcessesState(std::vector<zet_process_state_t> &pProcessList) {
ze_result_t WddmGlobalOperationsImp::scanProcessesState(std::vector<zes_process_state_t> &pProcessList) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}

13
level_zero/tools/source/sysman/linux/os_sysman_imp.cpp
View File

@@ -21,9 +21,7 @@ ze_result_t LinuxSysmanImp::init() {
UNRECOVERABLE_IF(nullptr == pProcfsAccess);
Device *pDevice = nullptr;
if (pParentSysmanImp != nullptr) {
pDevice = Device::fromHandle(pParentSysmanImp->hCoreDevice);
} else if (pParentSysmanDeviceImp != nullptr) {
if (pParentSysmanDeviceImp != nullptr) {
pDevice = Device::fromHandle(pParentSysmanDeviceImp->hCoreDevice);
} else {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
@@ -77,10 +75,6 @@ PlatformMonitoringTech &LinuxSysmanImp::getPlatformMonitoringTechAccess() {
return *pPmt;
}
LinuxSysmanImp::LinuxSysmanImp(SysmanImp *pParentSysmanImp) {
this->pParentSysmanImp = pParentSysmanImp;
}
LinuxSysmanImp::LinuxSysmanImp(SysmanDeviceImp *pParentSysmanDeviceImp) {
this->pParentSysmanDeviceImp = pParentSysmanDeviceImp;
}
@@ -108,11 +102,6 @@ LinuxSysmanImp::~LinuxSysmanImp() {
}
}
OsSysman *OsSysman::create(SysmanImp *pParentSysmanImp) {
LinuxSysmanImp *pLinuxSysmanImp = new LinuxSysmanImp(pParentSysmanImp);
return static_cast<OsSysman *>(pLinuxSysmanImp);
}
OsSysman *OsSysman::create(SysmanDeviceImp *pParentSysmanDeviceImp) {
LinuxSysmanImp *pLinuxSysmanImp = new LinuxSysmanImp(pParentSysmanDeviceImp);
return static_cast<OsSysman *>(pLinuxSysmanImp);

2
level_zero/tools/source/sysman/linux/os_sysman_imp.h
View File

@@ -20,7 +20,6 @@ namespace L0 {
class LinuxSysmanImp : public OsSysman, NEO::NonCopyableOrMovableClass {
public:
LinuxSysmanImp(SysmanImp *pParentSysmanImp);
LinuxSysmanImp(SysmanDeviceImp *pParentSysmanDeviceImp);
~LinuxSysmanImp() override;
@@ -42,7 +41,6 @@ class LinuxSysmanImp : public OsSysman, NEO::NonCopyableOrMovableClass {
private:
LinuxSysmanImp() = delete;
SysmanImp *pParentSysmanImp = nullptr;
SysmanDeviceImp *pParentSysmanDeviceImp = nullptr;
NEO::Drm *pDrm = nullptr;
};

4
level_zero/tools/source/sysman/memory/linux/dg1/os_memory_imp.cpp
View File

@@ -35,8 +35,8 @@ ze_result_t LinuxMemoryImp::getMemorySize(uint64_t &maxSize, uint64_t &allocSize
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxMemoryImp::getMemHealth(zet_mem_health_t &memHealth) {
memHealth = ZET_MEM_HEALTH_OK;
ze_result_t LinuxMemoryImp::getMemHealth(zes_mem_health_t &memHealth) {
memHealth = ZES_MEM_HEALTH_OK;
return ZE_RESULT_SUCCESS;
}

2
level_zero/tools/source/sysman/memory/linux/dg1/os_memory_imp.h
View File

@@ -18,7 +18,7 @@ class SysfsAccess;
class LinuxMemoryImp : public OsMemory, NEO::NonCopyableOrMovableClass {
public:
ze_result_t getMemorySize(uint64_t &maxSize, uint64_t &allocSize) override;
ze_result_t getMemHealth(zet_mem_health_t &memHealth) override;
ze_result_t getMemHealth(zes_mem_health_t &memHealth) override;
LinuxMemoryImp(OsSysman *pOsSysman);
LinuxMemoryImp() = default;
~LinuxMemoryImp() override = default;

2
level_zero/tools/source/sysman/memory/linux/os_memory_imp.cpp
View File

@@ -13,7 +13,7 @@ ze_result_t LinuxMemoryImp::getMemorySize(uint64_t &maxSize, uint64_t &allocSize
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxMemoryImp::getMemHealth(zet_mem_health_t &memHealth) {
ze_result_t LinuxMemoryImp::getMemHealth(zes_mem_health_t &memHealth) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}

2
level_zero/tools/source/sysman/memory/linux/os_memory_imp.h
View File

@@ -17,7 +17,7 @@ class SysfsAccess;
class LinuxMemoryImp : public OsMemory, NEO::NonCopyableOrMovableClass {
public:
ze_result_t getMemorySize(uint64_t &maxSize, uint64_t &allocSize) override;
ze_result_t getMemHealth(zet_mem_health_t &memHealth) override;
ze_result_t getMemHealth(zes_mem_health_t &memHealth) override;
LinuxMemoryImp(OsSysman *pOsSysman);
LinuxMemoryImp() = default;
~LinuxMemoryImp() override = default;

2
level_zero/tools/source/sysman/memory/memory.cpp
View File

@@ -31,7 +31,7 @@ ze_result_t MemoryHandleContext::init() {
return ZE_RESULT_SUCCESS;
}
ze_result_t MemoryHandleContext::memoryGet(uint32_t *pCount, zet_sysman_mem_handle_t *phMemory) {
ze_result_t MemoryHandleContext::memoryGet(uint32_t *pCount, zes_mem_handle_t *phMemory) {
uint32_t handleListSize = static_cast<uint32_t>(handleList.size());
uint32_t numToCopy = std::min(*pCount, handleListSize);
if (0 == *pCount || *pCount > handleListSize) {

20
level_zero/tools/source/sysman/memory/memory.h
View File

@@ -6,28 +6,28 @@
*/
#pragma once
#include <level_zero/zet_api.h>
#include <level_zero/zes_api.h>
#include <vector>
struct _zet_sysman_mem_handle_t {
virtual ~_zet_sysman_mem_handle_t() = default;
struct _zes_mem_handle_t {
virtual ~_zes_mem_handle_t() = default;
};
namespace L0 {
struct OsSysman;
class Memory : _zet_sysman_mem_handle_t {
class Memory : _zes_mem_handle_t {
public:
virtual ze_result_t memoryGetProperties(zet_mem_properties_t *pProperties) = 0;
virtual ze_result_t memoryGetBandwidth(zet_mem_bandwidth_t *pBandwidth) = 0;
virtual ze_result_t memoryGetState(zet_mem_state_t *pState) = 0;
virtual ze_result_t memoryGetProperties(zes_mem_properties_t *pProperties) = 0;
virtual ze_result_t memoryGetBandwidth(zes_mem_bandwidth_t *pBandwidth) = 0;
virtual ze_result_t memoryGetState(zes_mem_state_t *pState) = 0;
static Memory *fromHandle(zet_sysman_mem_handle_t handle) {
static Memory *fromHandle(zes_mem_handle_t handle) {
return static_cast<Memory *>(handle);
}
inline zet_sysman_mem_handle_t toHandle() { return this; }
inline zes_mem_handle_t toHandle() { return this; }
};
struct MemoryHandleContext {
@@ -36,7 +36,7 @@ struct MemoryHandleContext {
ze_result_t init();
ze_result_t memoryGet(uint32_t *pCount, zet_sysman_mem_handle_t *phMemory);
ze_result_t memoryGet(uint32_t *pCount, zes_mem_handle_t *phMemory);
OsSysman *pOsSysman = nullptr;
bool isLmemSupported = false;

10
level_zero/tools/source/sysman/memory/memory_imp.cpp
View File

@@ -9,25 +9,25 @@
namespace L0 {
ze_result_t MemoryImp::memoryGetBandwidth(zet_mem_bandwidth_t *pBandwidth) {
ze_result_t MemoryImp::memoryGetBandwidth(zes_mem_bandwidth_t *pBandwidth) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t MemoryImp::memoryGetState(zet_mem_state_t *pState) {
ze_result_t result = pOsMemory->getMemorySize(pState->maxSize, pState->allocatedSize);
ze_result_t MemoryImp::memoryGetState(zes_mem_state_t *pState) {
ze_result_t result = pOsMemory->getMemorySize(pState->size, pState->size);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
return pOsMemory->getMemHealth(pState->health);
}
ze_result_t MemoryImp::memoryGetProperties(zet_mem_properties_t *pProperties) {
ze_result_t MemoryImp::memoryGetProperties(zes_mem_properties_t *pProperties) {
*pProperties = memoryProperties;
return ZE_RESULT_SUCCESS;
}
void MemoryImp::init() {
memoryProperties.type = ZET_MEM_TYPE_DDR;
memoryProperties.type = ZES_MEM_TYPE_DDR;
memoryProperties.onSubdevice = false;
memoryProperties.subdeviceId = 0;
memoryProperties.physicalSize = 0;

10
level_zero/tools/source/sysman/memory/memory_imp.h
View File

@@ -10,15 +10,15 @@
#include "level_zero/tools/source/sysman/memory/memory.h"
#include "level_zero/tools/source/sysman/memory/os_memory.h"
#include <level_zero/zet_api.h>
#include <level_zero/zes_api.h>
namespace L0 {
class MemoryImp : public Memory, NEO::NonCopyableOrMovableClass {
public:
ze_result_t memoryGetProperties(zet_mem_properties_t *pProperties) override;
ze_result_t memoryGetBandwidth(zet_mem_bandwidth_t *pBandwidth) override;
ze_result_t memoryGetState(zet_mem_state_t *pState) override;
ze_result_t memoryGetProperties(zes_mem_properties_t *pProperties) override;
ze_result_t memoryGetBandwidth(zes_mem_bandwidth_t *pBandwidth) override;
ze_result_t memoryGetState(zes_mem_state_t *pState) override;
MemoryImp(OsSysman *pOsSysman, ze_device_handle_t hDevice);
~MemoryImp() override;
@@ -28,7 +28,7 @@ class MemoryImp : public Memory, NEO::NonCopyableOrMovableClass {
OsMemory *pOsMemory = nullptr;
private:
zet_mem_properties_t memoryProperties = {};
zes_mem_properties_t memoryProperties = {};
ze_device_handle_t hCoreDevice = {};
};

4
level_zero/tools/source/sysman/memory/os_memory.h
View File

@@ -7,7 +7,7 @@
#pragma once
#include <level_zero/zet_api.h>
#include <level_zero/zes_api.h>
namespace L0 {
@@ -15,7 +15,7 @@ struct OsSysman;
class OsMemory {
public:
virtual ze_result_t getMemorySize(uint64_t &maxSize, uint64_t &allocSize) = 0;
virtual ze_result_t getMemHealth(zet_mem_health_t &memHealth) = 0;
virtual ze_result_t getMemHealth(zes_mem_health_t &memHealth) = 0;
static OsMemory *create(OsSysman *pOsSysman);
virtual ~OsMemory() {}
};

4
level_zero/tools/source/sysman/memory/windows/os_memory_imp.cpp
View File

@@ -13,14 +13,14 @@ class WddmMemoryImp : public OsMemory {
public:
ze_result_t getMemorySize(uint64_t &maxSize, uint64_t &allocSize) override;
ze_result_t getMemHealth(zet_mem_health_t &memHealth) override;
ze_result_t getMemHealth(zes_mem_health_t &memHealth) override;
};
ze_result_t WddmMemoryImp::getMemorySize(uint64_t &maxSize, uint64_t &allocSize) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmMemoryImp::getMemHealth(zet_mem_health_t &memHealth) {
ze_result_t WddmMemoryImp::getMemHealth(zes_mem_health_t &memHealth) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}

5
level_zero/tools/source/sysman/os_sysman.h
View File

@@ -6,18 +6,15 @@
*/
#pragma once
#include <level_zero/zet_api.h>
#include <level_zero/zes_api.h>
namespace L0 {
struct SysmanImp;
struct SysmanDeviceImp;
struct OsSysman {
virtual ~OsSysman(){};
virtual ze_result_t init() = 0;
static OsSysman *create(SysmanImp *pSysmanImp);
static OsSysman *create(SysmanDeviceImp *pSysmanImp);
};

8
level_zero/tools/source/sysman/pci/linux/os_pci_imp.cpp
View File

@@ -143,7 +143,7 @@ void getBarBaseAndSize(std::string readBytes, uint64_t &baseAddr, uint64_t &barS
barSize = end - start + 1;
}
ze_result_t LinuxPciImp::initializeBarProperties(std::vector<zet_pci_bar_properties_t *> &pBarProperties) {
ze_result_t LinuxPciImp::initializeBarProperties(std::vector<zes_pci_bar_properties_t *> &pBarProperties) {
std::vector<std::string> ReadBytes;
ze_result_t result = pSysfsAccess->read(resourceFile, ReadBytes);
if (result != ZE_RESULT_SUCCESS) {
@@ -153,7 +153,7 @@ ze_result_t LinuxPciImp::initializeBarProperties(std::vector<zet_pci_bar_propert
uint64_t baseAddr, barSize, barFlags;
getBarBaseAndSize(ReadBytes[i], baseAddr, barSize, barFlags);
if (baseAddr) {
zet_pci_bar_properties_t *pBarProp = new zet_pci_bar_properties_t;
zes_pci_bar_properties_t *pBarProp = new zes_pci_bar_properties_t;
pBarProp->index = i;
pBarProp->base = baseAddr;
pBarProp->size = barSize;
@@ -163,9 +163,9 @@ ze_result_t LinuxPciImp::initializeBarProperties(std::vector<zet_pci_bar_propert
// Bit-1 - Reserved
// Bit-2 - Valid only for MMIO type BAR
// Value 0x1 -> 64bit BAR*/
pBarProp->type = (barFlags & 0x1) ? ZET_PCI_BAR_TYPE_VGA_IO : ZET_PCI_BAR_TYPE_MMIO;
pBarProp->type = ZES_PCI_BAR_TYPE_MMIO;
if (i == 6) { // the 7th entry of resource file is expected to be ROM BAR
pBarProp->type = ZET_PCI_BAR_TYPE_ROM;
pBarProp->type = ZES_PCI_BAR_TYPE_ROM;
}
pBarProperties.push_back(pBarProp);
}

2
level_zero/tools/source/sysman/pci/linux/os_pci_imp.h
View File

@@ -22,7 +22,7 @@ class LinuxPciImp : public OsPci, NEO::NonCopyableOrMovableClass {
ze_result_t getMaxLinkWidth(uint32_t &maxLinkwidth) override;
ze_result_t getLinkGen(uint32_t &linkGen) override;
void setLmemSupport(bool val) override;
ze_result_t initializeBarProperties(std::vector<zet_pci_bar_properties_t *> &pBarProperties) override;
ze_result_t initializeBarProperties(std::vector<zes_pci_bar_properties_t *> &pBarProperties) override;
LinuxPciImp() = default;
LinuxPciImp(OsSysman *pOsSysman);
~LinuxPciImp() override = default;

2
level_zero/tools/source/sysman/pci/os_pci.h
View File

@@ -22,7 +22,7 @@ class OsPci {
virtual ze_result_t getMaxLinkWidth(uint32_t &maxLinkWidth) = 0;
virtual ze_result_t getLinkGen(uint32_t &linkGen) = 0;
virtual void setLmemSupport(bool val) = 0;
virtual ze_result_t initializeBarProperties(std::vector<zet_pci_bar_properties_t *> &pBarProperties) = 0;
virtual ze_result_t initializeBarProperties(std::vector<zes_pci_bar_properties_t *> &pBarProperties) = 0;
static OsPci *create(OsSysman *pOsSysman);
virtual ~OsPci() = default;
};

6
level_zero/tools/source/sysman/pci/pci.h
View File

@@ -6,15 +6,15 @@
*/
#pragma once
#include <level_zero/zet_api.h>
#include <level_zero/zes_api.h>
namespace L0 {
class Pci {
public:
virtual ~Pci(){};
virtual ze_result_t pciStaticProperties(zet_pci_properties_t *pProperties) = 0;
virtual ze_result_t pciGetInitializedBars(uint32_t *pCount, zet_pci_bar_properties_t *pProperties) = 0;
virtual ze_result_t pciStaticProperties(zes_pci_properties_t *pProperties) = 0;
virtual ze_result_t pciGetInitializedBars(uint32_t *pCount, zes_pci_bar_properties_t *pProperties) = 0;
virtual void init() = 0;
};

6
level_zero/tools/source/sysman/pci/pci_imp.cpp
View File

@@ -42,12 +42,12 @@ uint64_t convertPcieSpeedFromGTsToBs(double maxLinkSpeedInGt) {
return static_cast<uint64_t>(pcieSpeedWithEnc);
}
ze_result_t PciImp::pciStaticProperties(zet_pci_properties_t *pProperties) {
ze_result_t PciImp::pciStaticProperties(zes_pci_properties_t *pProperties) {
*pProperties = pciProperties;
return ZE_RESULT_SUCCESS;
}
ze_result_t PciImp::pciGetInitializedBars(uint32_t *pCount, zet_pci_bar_properties_t *pProperties) {
ze_result_t PciImp::pciGetInitializedBars(uint32_t *pCount, zes_pci_bar_properties_t *pProperties) {
if (pProperties == nullptr) {
*pCount = static_cast<uint32_t>(pciBarProperties.size());
return ZE_RESULT_SUCCESS;
@@ -95,7 +95,7 @@ void PciImp::init() {
}
PciImp::~PciImp() {
for (zet_pci_bar_properties_t *pProperties : pciBarProperties) {
for (zes_pci_bar_properties_t *pProperties : pciBarProperties) {
delete pProperties;
pProperties = nullptr;
}

8
level_zero/tools/source/sysman/pci/pci_imp.h
View File

@@ -22,8 +22,8 @@ namespace L0 {
class PciImp : public Pci, NEO::NonCopyableOrMovableClass {
public:
void init() override;
ze_result_t pciStaticProperties(zet_pci_properties_t *pProperties) override;
ze_result_t pciGetInitializedBars(uint32_t *pCount, zet_pci_bar_properties_t *pProperties) override;
ze_result_t pciStaticProperties(zes_pci_properties_t *pProperties) override;
ze_result_t pciGetInitializedBars(uint32_t *pCount, zes_pci_bar_properties_t *pProperties) override;
PciImp() = default;
PciImp(OsSysman *pOsSysman, ze_device_handle_t hDevice) : pOsSysman(pOsSysman) {
@@ -36,8 +36,8 @@ class PciImp : public Pci, NEO::NonCopyableOrMovableClass {
private:
OsSysman *pOsSysman = nullptr;
zet_pci_properties_t pciProperties = {};
std::vector<zet_pci_bar_properties_t *> pciBarProperties = {};
zes_pci_properties_t pciProperties = {};
std::vector<zes_pci_bar_properties_t *> pciBarProperties = {};
};
} // namespace L0

4
level_zero/tools/source/sysman/pci/windows/os_pci_imp.cpp
View File

@@ -17,7 +17,7 @@ class WddmPciImp : public OsPci {
ze_result_t getMaxLinkWidth(uint32_t &maxLinkwidth) override;
ze_result_t getLinkGen(uint32_t &linkGen) override;
void setLmemSupport(bool val) override;
ze_result_t initializeBarProperties(std::vector<zet_pci_bar_properties_t *> &pBarProperties) override;
ze_result_t initializeBarProperties(std::vector<zes_pci_bar_properties_t *> &pBarProperties) override;
~WddmPciImp() override = default;
};
@@ -39,7 +39,7 @@ ze_result_t WddmPciImp::getLinkGen(uint32_t &linkGen) {
void WddmPciImp::setLmemSupport(bool val) {}
ze_result_t WddmPciImp::initializeBarProperties(std::vector<zet_pci_bar_properties_t *> &pBarProperties) {
ze_result_t WddmPciImp::initializeBarProperties(std::vector<zes_pci_bar_properties_t *> &pBarProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}

4
level_zero/tools/source/sysman/power/linux/os_power_imp.cpp
View File

@@ -13,10 +13,6 @@
namespace L0 {
constexpr uint64_t convertJouleToMicroJoule = 1000000u;
ze_result_t LinuxPowerImp::getEnergyThreshold(zet_energy_threshold_t *pThreshold) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxPowerImp::getEnergyThreshold(zes_energy_threshold_t *pThreshold) {

1
level_zero/tools/source/sysman/power/linux/os_power_imp.h
View File

@@ -17,7 +17,6 @@ class PlatformMonitoringTech;
class LinuxPowerImp : public OsPower, NEO::NonCopyableOrMovableClass {
public:
ze_result_t getEnergyCounter(uint64_t &energy) override;
ze_result_t getEnergyThreshold(zet_energy_threshold_t *pThreshold) override;
ze_result_t getEnergyThreshold(zes_energy_threshold_t *pThreshold) override;
ze_result_t setEnergyThreshold(double threshold) override;
bool isPowerModuleSupported() override;

7
level_zero/tools/source/sysman/power/os_power.h
View File

@@ -7,9 +7,7 @@
#pragma once
#include <level_zero/zet_api.h>
#include "third_party/level_zero/zes_api_ext.h"
#include <level_zero/zes_api.h>
namespace L0 {
@@ -17,9 +15,8 @@ struct OsSysman;
class OsPower {
public:
virtual ze_result_t getEnergyCounter(uint64_t &energy) = 0;
virtual ze_result_t getEnergyThreshold(zet_energy_threshold_t *pThreshold) = 0;
virtual ze_result_t setEnergyThreshold(double threshold) = 0;
virtual ze_result_t getEnergyThreshold(zes_energy_threshold_t *pThreshold) = 0;
virtual ze_result_t setEnergyThreshold(double threshold) = 0;
virtual bool isPowerModuleSupported() = 0;
static OsPower *create(OsSysman *pOsSysman);
virtual ~OsPower() = default;

16
level_zero/tools/source/sysman/power/power.cpp
View File

@@ -28,7 +28,7 @@ void PowerHandleContext::init() {
}
}
ze_result_t PowerHandleContext::powerGet(uint32_t *pCount, zet_sysman_pwr_handle_t *phPower) {
ze_result_t PowerHandleContext::powerGet(uint32_t *pCount, zes_pwr_handle_t *phPower) {
uint32_t handleListSize = static_cast<uint32_t>(handleList.size());
uint32_t numToCopy = std::min(*pCount, handleListSize);
if (0 == *pCount || *pCount > handleListSize) {
@@ -42,18 +42,4 @@ ze_result_t PowerHandleContext::powerGet(uint32_t *pCount, zet_sysman_pwr_handle
return ZE_RESULT_SUCCESS;
}
ze_result_t PowerHandleContext::powerGet(uint32_t *pCount, zes_pwr_handle_t *phPower) {
uint32_t handleListSize = static_cast<uint32_t>(handleList.size());
uint32_t numToCopy = std::min(*pCount, handleListSize);
if (0 == *pCount || *pCount > handleListSize) {
*pCount = handleListSize;
}
if (nullptr != phPower) {
for (uint32_t i = 0; i < numToCopy; i++) {
phPower[i] = handleList[i]->toZesPwrHandle();
}
}
return ZE_RESULT_SUCCESS;
}
} // namespace L0

19
level_zero/tools/source/sysman/power/power.h
View File

@@ -6,9 +6,7 @@
*/
#pragma once
#include <level_zero/zet_api.h>
#include "third_party/level_zero/zes_api_ext.h"
#include <level_zero/zes_api.h>
#include <vector>
@@ -25,27 +23,17 @@ namespace L0 {
struct OsSysman;
class Power : _zet_sysman_pwr_handle_t, _zes_pwr_handle_t {
public:
virtual ze_result_t powerGetProperties(zet_power_properties_t *pProperties) = 0;
virtual ze_result_t powerGetEnergyCounter(zet_power_energy_counter_t *pEnergy) = 0;
virtual ze_result_t powerGetLimits(zet_power_sustained_limit_t *pSustained, zet_power_burst_limit_t *pBurst, zet_power_peak_limit_t *pPeak) = 0;
virtual ze_result_t powerSetLimits(const zet_power_sustained_limit_t *pSustained, const zet_power_burst_limit_t *pBurst, const zet_power_peak_limit_t *pPeak) = 0;
virtual ze_result_t powerGetEnergyThreshold(zet_energy_threshold_t *pThreshold) = 0;
virtual ze_result_t powerSetEnergyThreshold(double threshold) = 0;
virtual ze_result_t powerGetProperties(zes_power_properties_t *pProperties) = 0;
virtual ze_result_t powerGetEnergyCounter(zes_power_energy_counter_t *pEnergy) = 0;
virtual ze_result_t powerGetLimits(zes_power_sustained_limit_t *pSustained, zes_power_burst_limit_t *pBurst, zes_power_peak_limit_t *pPeak) = 0;
virtual ze_result_t powerSetLimits(const zes_power_sustained_limit_t *pSustained, const zes_power_burst_limit_t *pBurst, const zes_power_peak_limit_t *pPeak) = 0;
virtual ze_result_t powerGetEnergyThreshold(zes_energy_threshold_t *pThreshold) = 0;
virtual ze_result_t powerSetEnergyThreshold(double threshold) = 0;
static Power *fromHandle(zet_sysman_pwr_handle_t handle) {
return static_cast<Power *>(handle);
}
static Power *fromHandle(zes_pwr_handle_t handle) {
return static_cast<Power *>(handle);
}
inline zet_sysman_pwr_handle_t toHandle() { return this; }
inline zes_pwr_handle_t toZesPwrHandle() { return this; }
inline zes_pwr_handle_t toHandle() { return this; }
bool initSuccess = false;
};
struct PowerHandleContext {
@@ -54,7 +42,6 @@ struct PowerHandleContext {
void init();
ze_result_t powerGet(uint32_t *pCount, zet_sysman_pwr_handle_t *phPower);
ze_result_t powerGet(uint32_t *pCount, zes_pwr_handle_t *phPower);
OsSysman *pOsSysman = nullptr;

27
level_zero/tools/source/sysman/power/power_imp.cpp
View File

@@ -20,33 +20,6 @@ void powerGetTimestamp(uint64_t &timestamp) {
timestamp = std::chrono::duration_cast<std::chrono::microseconds>(ts.time_since_epoch()).count();
}
ze_result_t PowerImp::powerGetProperties(zet_power_properties_t *pProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t PowerImp::powerGetEnergyCounter(zet_power_energy_counter_t *pEnergy) {
ze_result_t result = pOsPower->getEnergyCounter(pEnergy->energy);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
powerGetTimestamp(pEnergy->timestamp);
return result;
}
ze_result_t PowerImp::powerGetLimits(zet_power_sustained_limit_t *pSustained, zet_power_burst_limit_t *pBurst, zet_power_peak_limit_t *pPeak) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t PowerImp::powerSetLimits(const zet_power_sustained_limit_t *pSustained, const zet_power_burst_limit_t *pBurst, const zet_power_peak_limit_t *pPeak) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t PowerImp::powerGetEnergyThreshold(zet_energy_threshold_t *pThreshold) {
return (pOsPower->getEnergyThreshold(pThreshold));
}
ze_result_t PowerImp::powerSetEnergyThreshold(double threshold) {
return (pOsPower->setEnergyThreshold(threshold));
}

5
level_zero/tools/source/sysman/power/power_imp.h
View File

@@ -15,11 +15,6 @@
namespace L0 {
class PowerImp : public Power, NEO::NonCopyableOrMovableClass {
public:
ze_result_t powerGetProperties(zet_power_properties_t *pProperties) override;
ze_result_t powerGetEnergyCounter(zet_power_energy_counter_t *pEnergy) override;
ze_result_t powerGetLimits(zet_power_sustained_limit_t *pSustained, zet_power_burst_limit_t *pBurst, zet_power_peak_limit_t *pPeak) override;
ze_result_t powerSetLimits(const zet_power_sustained_limit_t *pSustained, const zet_power_burst_limit_t *pBurst, const zet_power_peak_limit_t *pPeak) override;
ze_result_t powerGetEnergyThreshold(zet_energy_threshold_t *pThreshold) override;
ze_result_t powerSetEnergyThreshold(double threshold) override;
ze_result_t powerGetProperties(zes_power_properties_t *pProperties) override;

6
level_zero/tools/source/sysman/power/windows/os_power_imp.cpp
View File

@@ -12,7 +12,6 @@ namespace L0 {
class WddmPowerImp : public OsPower {
public:
ze_result_t getEnergyCounter(uint64_t &energy) override;
ze_result_t getEnergyThreshold(zet_energy_threshold_t *pThreshold) override;
ze_result_t getEnergyThreshold(zes_energy_threshold_t *pThreshold) override;
ze_result_t setEnergyThreshold(double threshold) override;
bool isPowerModuleSupported() override;
@@ -23,11 +22,6 @@ ze_result_t WddmPowerImp::getEnergyCounter(uint64_t &energy) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmPowerImp::getEnergyThreshold(zet_energy_threshold_t *pThreshold) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmPowerImp::getEnergyThreshold(zes_energy_threshold_t *pThreshold) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;

15
level_zero/tools/source/sysman/ras/linux/os_ras_imp.cpp
View File

@@ -15,14 +15,14 @@ const std::string LinuxRasImp::rasCounterDir("/var/lib/libze_intel_gpu/");
const std::string LinuxRasImp::resetCounter("ras_reset_count");
const std::string LinuxRasImp::resetCounterFile = rasCounterDir + resetCounter;
void LinuxRasImp::setRasErrorType(zet_ras_error_type_t type) {
void LinuxRasImp::setRasErrorType(zes_ras_error_type_t type) {
osRasErrorType = type;
}
bool LinuxRasImp::isRasSupported(void) {
if (false == pFsAccess->fileExists(rasCounterDir)) {
return false;
}
if (osRasErrorType == ZET_RAS_ERROR_TYPE_CORRECTABLE) {
if (osRasErrorType == ZES_RAS_ERROR_TYPE_CORRECTABLE) {
return false;
} else {
// i915 support for UNCORRECTABLE errors is assumed true
@@ -30,20 +30,11 @@ bool LinuxRasImp::isRasSupported(void) {
return true;
}
}
ze_result_t LinuxRasImp::getCounterValues(zet_ras_details_t *pDetails) {
uint64_t counterValue = 0;
ze_result_t result = pFsAccess->read(resetCounterFile, counterValue);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
pDetails->numResets = counterValue;
return result;
}
LinuxRasImp::LinuxRasImp(OsSysman *pOsSysman) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
pFsAccess = &pLinuxSysmanImp->getFsAccess();
osRasErrorType = ZET_RAS_ERROR_TYPE_UNCORRECTABLE;
osRasErrorType = ZES_RAS_ERROR_TYPE_UNCORRECTABLE;
}
OsRas *OsRas::create(OsSysman *pOsSysman) {

5
level_zero/tools/source/sysman/ras/linux/os_ras_imp.h
View File

@@ -21,13 +21,12 @@ class LinuxRasImp : public OsRas, NEO::NonCopyableOrMovableClass {
LinuxRasImp(OsSysman *pOsSysman);
LinuxRasImp() = default;
~LinuxRasImp() override = default;
ze_result_t getCounterValues(zet_ras_details_t *pDetails) override;
bool isRasSupported(void) override;
void setRasErrorType(zet_ras_error_type_t rasErrorType) override;
void setRasErrorType(zes_ras_error_type_t rasErrorType) override;
protected:
FsAccess *pFsAccess = nullptr;
zet_ras_error_type_t osRasErrorType;
zes_ras_error_type_t osRasErrorType;
private:
static const std::string rasCounterDir;

5
level_zero/tools/source/sysman/ras/os_ras.h
View File

@@ -7,16 +7,15 @@
#pragma once
#include <level_zero/zet_api.h>
#include <level_zero/zes_api.h>
namespace L0 {
struct OsSysman;
class OsRas {
public:
virtual ze_result_t getCounterValues(zet_ras_details_t *pDetails) = 0;
virtual bool isRasSupported(void) = 0;
virtual void setRasErrorType(zet_ras_error_type_t type) = 0;
virtual void setRasErrorType(zes_ras_error_type_t type) = 0;
static OsRas *create(OsSysman *pOsSysman);
virtual ~OsRas() = default;
};

8
level_zero/tools/source/sysman/ras/ras.cpp
View File

@@ -16,7 +16,7 @@ RasHandleContext::~RasHandleContext() {
delete pRas;
}
}
void RasHandleContext::createHandle(zet_ras_error_type_t type) {
void RasHandleContext::createHandle(zes_ras_error_type_t type) {
Ras *pRas = new RasImp(pOsSysman, type);
if (pRas->isRasErrorSupported == true) {
handleList.push_back(pRas);
@@ -25,11 +25,11 @@ void RasHandleContext::createHandle(zet_ras_error_type_t type) {
}
}
void RasHandleContext::init() {
createHandle(ZET_RAS_ERROR_TYPE_UNCORRECTABLE);
createHandle(ZET_RAS_ERROR_TYPE_CORRECTABLE);
createHandle(ZES_RAS_ERROR_TYPE_UNCORRECTABLE);
createHandle(ZES_RAS_ERROR_TYPE_CORRECTABLE);
}
ze_result_t RasHandleContext::rasGet(uint32_t *pCount,
zet_sysman_ras_handle_t *phRas) {
zes_ras_handle_t *phRas) {
uint32_t handleListSize = static_cast<uint32_t>(handleList.size());
uint32_t numToCopy = std::min(*pCount, handleListSize);
if (0 == *pCount || *pCount > handleListSize) {

25
level_zero/tools/source/sysman/ras/ras.h
View File

@@ -6,31 +6,30 @@
*/
#pragma once
#include <level_zero/zet_api.h>
#include <level_zero/zes_api.h>
#include <vector>
struct _zet_sysman_ras_handle_t {
virtual ~_zet_sysman_ras_handle_t() = default;
struct _zes_ras_handle_t {
virtual ~_zes_ras_handle_t() = default;
};
namespace L0 {
struct OsSysman;
class Ras : _zet_sysman_ras_handle_t {
class Ras : _zes_ras_handle_t {
public:
virtual ze_result_t rasGetProperties(zet_ras_properties_t *pProperties) = 0;
virtual ze_result_t rasGetConfig(zet_ras_config_t *pConfig) = 0;
virtual ze_result_t rasSetConfig(const zet_ras_config_t *pConfig) = 0;
virtual ze_result_t rasGetState(ze_bool_t clear, uint64_t *pTotalErrors, zet_ras_details_t *pDetails) = 0;
virtual ze_result_t rasGetProperties(zes_ras_properties_t *pProperties) = 0;
virtual ze_result_t rasGetConfig(zes_ras_config_t *pConfig) = 0;
virtual ze_result_t rasSetConfig(const zes_ras_config_t *pConfig) = 0;
static Ras *fromHandle(zet_sysman_ras_handle_t handle) {
static Ras *fromHandle(zes_ras_handle_t handle) {
return static_cast<Ras *>(handle);
}
inline zet_sysman_ras_handle_t toHandle() { return this; }
inline zes_ras_handle_t toHandle() { return this; }
bool isRasErrorSupported = false;
zet_ras_error_type_t rasErrorType;
zes_ras_error_type_t rasErrorType;
};
struct RasHandleContext {
@@ -39,13 +38,13 @@ struct RasHandleContext {
void init();
ze_result_t rasGet(uint32_t *pCount, zet_sysman_ras_handle_t *phRas);
ze_result_t rasGet(uint32_t *pCount, zes_ras_handle_t *phRas);
OsSysman *pOsSysman = nullptr;
std::vector<Ras *> handleList = {};
private:
void createHandle(zet_ras_error_type_t type);
void createHandle(zes_ras_error_type_t type);
};
} // namespace L0

32
level_zero/tools/source/sysman/ras/ras_imp.cpp
View File

@@ -14,17 +14,7 @@
namespace L0 {
uint64_t getTotalErrors(zet_ras_details_t pDetails) {
return (pDetails.numResets +
pDetails.numProgrammingErrors +
pDetails.numNonComputeErrors +
pDetails.numComputeErrors +
pDetails.numDriverErrors +
pDetails.numDisplayErrors +
pDetails.numCacheErrors);
}
ze_result_t RasImp::rasGetProperties(zet_ras_properties_t *pProperties) {
ze_result_t RasImp::rasGetProperties(zes_ras_properties_t *pProperties) {
rasProperties.type = this->rasErrorType;
rasProperties.onSubdevice = false;
rasProperties.subdeviceId = 0;
@@ -32,34 +22,20 @@ ze_result_t RasImp::rasGetProperties(zet_ras_properties_t *pProperties) {
return ZE_RESULT_SUCCESS;
}
ze_result_t RasImp::rasGetConfig(zet_ras_config_t *pConfig) {
ze_result_t RasImp::rasGetConfig(zes_ras_config_t *pConfig) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t RasImp::rasSetConfig(const zet_ras_config_t *pConfig) {
ze_result_t RasImp::rasSetConfig(const zes_ras_config_t *pConfig) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t RasImp::rasGetState(ze_bool_t clear, uint64_t *pTotalErrors, zet_ras_details_t *pDetails) {
zet_ras_details_t pDetailsInternal;
memset(&pDetailsInternal, 0, sizeof(zet_ras_details_t));
ze_result_t result = pOsRas->getCounterValues(&pDetailsInternal);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
*pTotalErrors = getTotalErrors(pDetailsInternal);
if (pDetails != nullptr) {
memcpy_s(pDetails, sizeof(zet_ras_details_t), &pDetailsInternal, sizeof(zet_ras_details_t));
}
return result;
}
void RasImp::init() {
pOsRas->setRasErrorType(this->rasErrorType);
isRasErrorSupported = pOsRas->isRasSupported();
}
RasImp::RasImp(OsSysman *pOsSysman, zet_ras_error_type_t type) {
RasImp::RasImp(OsSysman *pOsSysman, zes_ras_error_type_t type) {
pOsRas = OsRas::create(pOsSysman);
this->rasErrorType = type;
init();

11
level_zero/tools/source/sysman/ras/ras_imp.h
View File

@@ -16,20 +16,19 @@ namespace L0 {
class RasImp : public Ras, NEO::NonCopyableOrMovableClass {
public:
ze_result_t rasGetProperties(zet_ras_properties_t *pProperties) override;
ze_result_t rasGetConfig(zet_ras_config_t *pConfig) override;
ze_result_t rasSetConfig(const zet_ras_config_t *pConfig) override;
ze_result_t rasGetState(ze_bool_t clear, uint64_t *pTotalErrors, zet_ras_details_t *pDetails) override;
ze_result_t rasGetProperties(zes_ras_properties_t *pProperties) override;
ze_result_t rasGetConfig(zes_ras_config_t *pConfig) override;
ze_result_t rasSetConfig(const zes_ras_config_t *pConfig) override;
RasImp() = default;
RasImp(OsSysman *pOsSysman, zet_ras_error_type_t type);
RasImp(OsSysman *pOsSysman, zes_ras_error_type_t type);
~RasImp() override;
OsRas *pOsRas = nullptr;
void init();
private:
zet_ras_properties_t rasProperties = {};
zes_ras_properties_t rasProperties = {};
};
} // namespace L0

9
level_zero/tools/source/sysman/ras/windows/os_ras_imp.cpp
View File

@@ -10,20 +10,15 @@
namespace L0 {
class WddmRasImp : public OsRas {
ze_result_t getCounterValues(zet_ras_details_t *pDetails) override;
bool isRasSupported(void) override;
void setRasErrorType(zet_ras_error_type_t type) override;
void setRasErrorType(zes_ras_error_type_t type) override;
};
ze_result_t WddmRasImp::getCounterValues(zet_ras_details_t *pDetails) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
bool WddmRasImp::isRasSupported(void) {
return false;
}
void WddmRasImp::setRasErrorType(zet_ras_error_type_t type) {}
void WddmRasImp::setRasErrorType(zes_ras_error_type_t type) {}
OsRas *OsRas::create(OsSysman *pOsSysman) {
WddmRasImp *pWddmRasImp = new WddmRasImp();

6
level_zero/tools/source/sysman/scheduler/linux/os_scheduler_imp.h
View File

@@ -14,9 +14,9 @@ namespace L0 {
class SysfsAccess;
// Following below mappings of scheduler properties with sysfs nodes
// zet_sched_timeslice_properties_t.interval = timeslice_duration_ms
// zet_sched_timeslice_properties_t.yieldTimeout = preempt_timeout_ms
// zet_sched_timeout_properties_t. watchdogTimeout = heartbeat_interval_ms
// zes_sched_timeslice_properties_t.interval = timeslice_duration_ms
// zes_sched_timeslice_properties_t.yieldTimeout = preempt_timeout_ms
// zes_sched_timeout_properties_t. watchdogTimeout = heartbeat_interval_ms
class LinuxSchedulerImp : public OsScheduler, NEO::NonCopyableOrMovableClass {
public:
ze_result_t getPreemptTimeout(uint64_t &timeout, ze_bool_t getDefault) override;

12
level_zero/tools/source/sysman/scheduler/scheduler.h
View File

@@ -6,18 +6,18 @@
*/
#pragma once
#include <level_zero/zet_api.h>
#include <level_zero/zes_api.h>
namespace L0 {
class Scheduler {
public:
virtual ~Scheduler(){};
virtual ze_result_t getCurrentMode(zet_sched_mode_t *pMode) = 0;
virtual ze_result_t getTimeoutModeProperties(ze_bool_t getDefaults, zet_sched_timeout_properties_t *pConfig) = 0;
virtual ze_result_t getTimesliceModeProperties(ze_bool_t getDefaults, zet_sched_timeslice_properties_t *pConfig) = 0;
virtual ze_result_t setTimeoutMode(zet_sched_timeout_properties_t *pProperties, ze_bool_t *pNeedReboot) = 0;
virtual ze_result_t setTimesliceMode(zet_sched_timeslice_properties_t *pProperties, ze_bool_t *pNeedReboot) = 0;
virtual ze_result_t getCurrentMode(zes_sched_mode_t *pMode) = 0;
virtual ze_result_t getTimeoutModeProperties(ze_bool_t getDefaults, zes_sched_timeout_properties_t *pConfig) = 0;
virtual ze_result_t getTimesliceModeProperties(ze_bool_t getDefaults, zes_sched_timeslice_properties_t *pConfig) = 0;
virtual ze_result_t setTimeoutMode(zes_sched_timeout_properties_t *pProperties, ze_bool_t *pNeedReboot) = 0;
virtual ze_result_t setTimesliceMode(zes_sched_timeslice_properties_t *pProperties, ze_bool_t *pNeedReboot) = 0;
virtual ze_result_t setExclusiveMode(ze_bool_t *pNeedReboot) = 0;
virtual ze_result_t setComputeUnitDebugMode(ze_bool_t *pNeedReboot) = 0;
virtual void init() = 0;

20
level_zero/tools/source/sysman/scheduler/scheduler_imp.cpp
View File

@@ -14,7 +14,7 @@ namespace L0 {
constexpr uint64_t minTimeoutModeHeartbeat = 5000u;
constexpr uint64_t minTimeoutInMicroSeconds = 1000u;
ze_result_t SchedulerImp::getCurrentMode(zet_sched_mode_t *pMode) {
ze_result_t SchedulerImp::getCurrentMode(zes_sched_mode_t *pMode) {
uint64_t timeout = 0;
uint64_t timeslice = 0;
ze_result_t result = pOsScheduler->getPreemptTimeout(timeout, false);
@@ -26,18 +26,18 @@ ze_result_t SchedulerImp::getCurrentMode(zet_sched_mode_t *pMode) {
return result;
}
if (timeslice > 0) {
*pMode = ZET_SCHED_MODE_TIMESLICE;
*pMode = ZES_SCHED_MODE_TIMESLICE;
} else {
if (timeout > 0) {
*pMode = ZET_SCHED_MODE_TIMEOUT;
*pMode = ZES_SCHED_MODE_TIMEOUT;
} else {
*pMode = ZET_SCHED_MODE_EXCLUSIVE;
*pMode = ZES_SCHED_MODE_EXCLUSIVE;
}
}
return result;
}
ze_result_t SchedulerImp::getTimeoutModeProperties(ze_bool_t getDefaults, zet_sched_timeout_properties_t *pConfig) {
ze_result_t SchedulerImp::getTimeoutModeProperties(ze_bool_t getDefaults, zes_sched_timeout_properties_t *pConfig) {
uint64_t heartbeat = 0;
ze_result_t result = pOsScheduler->getHeartbeatInterval(heartbeat, getDefaults);
if (result != ZE_RESULT_SUCCESS) {
@@ -48,7 +48,7 @@ ze_result_t SchedulerImp::getTimeoutModeProperties(ze_bool_t getDefaults, zet_sc
return result;
}
ze_result_t SchedulerImp::getTimesliceModeProperties(ze_bool_t getDefaults, zet_sched_timeslice_properties_t *pConfig) {
ze_result_t SchedulerImp::getTimesliceModeProperties(ze_bool_t getDefaults, zes_sched_timeslice_properties_t *pConfig) {
uint64_t timeout = 0, timeslice = 0;
ze_result_t result = pOsScheduler->getPreemptTimeout(timeout, getDefaults);
if (result != ZE_RESULT_SUCCESS) {
@@ -63,8 +63,8 @@ ze_result_t SchedulerImp::getTimesliceModeProperties(ze_bool_t getDefaults, zet_
return result;
}
ze_result_t SchedulerImp::setTimeoutMode(zet_sched_timeout_properties_t *pProperties, ze_bool_t *pNeedReboot) {
zet_sched_mode_t currMode;
ze_result_t SchedulerImp::setTimeoutMode(zes_sched_timeout_properties_t *pProperties, ze_bool_t *pNeedReboot) {
zes_sched_mode_t currMode;
ze_result_t result = getCurrentMode(&currMode);
if (result != ZE_RESULT_SUCCESS) {
return result;
@@ -78,7 +78,7 @@ ze_result_t SchedulerImp::setTimeoutMode(zet_sched_timeout_properties_t *pProper
}
*pNeedReboot = false;
result = pOsScheduler->setHeartbeatInterval(pProperties->watchdogTimeout);
if ((currMode == ZET_SCHED_MODE_TIMEOUT) || (result != ZE_RESULT_SUCCESS)) {
if ((currMode == ZES_SCHED_MODE_TIMEOUT) || (result != ZE_RESULT_SUCCESS)) {
return result;
}
@@ -96,7 +96,7 @@ ze_result_t SchedulerImp::setTimeoutMode(zet_sched_timeout_properties_t *pProper
return result;
}
ze_result_t SchedulerImp::setTimesliceMode(zet_sched_timeslice_properties_t *pProperties, ze_bool_t *pNeedReboot) {
ze_result_t SchedulerImp::setTimesliceMode(zes_sched_timeslice_properties_t *pProperties, ze_bool_t *pNeedReboot) {
if (pProperties->interval < minTimeoutInMicroSeconds) {
// interval(in usec) less than 1000 would be computed to
// 0 milli seconds interval.

12
level_zero/tools/source/sysman/scheduler/scheduler_imp.h
View File

@@ -8,7 +8,7 @@
#pragma once
#include "shared/source/helpers/non_copyable_or_moveable.h"
#include <level_zero/zet_api.h>
#include <level_zero/zes_api.h>
#include "os_scheduler.h"
#include "scheduler.h"
@@ -18,11 +18,11 @@ namespace L0 {
class SchedulerImp : public Scheduler, NEO::NonCopyableOrMovableClass {
public:
void init() override;
ze_result_t getCurrentMode(zet_sched_mode_t *pMode) override;
ze_result_t getTimeoutModeProperties(ze_bool_t getDefaults, zet_sched_timeout_properties_t *pConfig) override;
ze_result_t getTimesliceModeProperties(ze_bool_t getDefaults, zet_sched_timeslice_properties_t *pConfig) override;
ze_result_t setTimeoutMode(zet_sched_timeout_properties_t *pProperties, ze_bool_t *pNeedReboot) override;
ze_result_t setTimesliceMode(zet_sched_timeslice_properties_t *pProperties, ze_bool_t *pNeedReboot) override;
ze_result_t getCurrentMode(zes_sched_mode_t *pMode) override;
ze_result_t getTimeoutModeProperties(ze_bool_t getDefaults, zes_sched_timeout_properties_t *pConfig) override;
ze_result_t getTimesliceModeProperties(ze_bool_t getDefaults, zes_sched_timeslice_properties_t *pConfig) override;
ze_result_t setTimeoutMode(zes_sched_timeout_properties_t *pProperties, ze_bool_t *pNeedReboot) override;
ze_result_t setTimesliceMode(zes_sched_timeslice_properties_t *pProperties, ze_bool_t *pNeedReboot) override;
ze_result_t setExclusiveMode(ze_bool_t *pNeedReboot) override;
ze_result_t setComputeUnitDebugMode(ze_bool_t *pNeedReboot) override;

23
level_zero/tools/source/sysman/standby/linux/os_standby_imp.cpp
View File

@@ -18,29 +18,6 @@ bool LinuxStandbyImp::isStandbySupported(void) {
return false;
}
}
ze_result_t LinuxStandbyImp::getMode(zet_standby_promo_mode_t &mode) {
int currentMode = -1;
ze_result_t result = pSysfsAccess->read(standbyModeFile, currentMode);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
if (standbyModeDefault == currentMode) {
mode = ZET_STANDBY_PROMO_MODE_DEFAULT;
} else if (standbyModeNever == currentMode) {
mode = ZET_STANDBY_PROMO_MODE_NEVER;
} else {
result = ZE_RESULT_ERROR_UNKNOWN;
}
return result;
}
ze_result_t LinuxStandbyImp::setMode(zet_standby_promo_mode_t mode) {
// standbyModeFile is not writable.
// Mode cannot be set from L0.
// To set the mode, user must reload
// the i915 module and set module parameter
// enable_rc6 appropriately.
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxStandbyImp::getMode(zes_standby_promo_mode_t &mode) {
int currentMode = -1;

3
level_zero/tools/source/sysman/standby/linux/os_standby_imp.h
View File

@@ -16,9 +16,6 @@ namespace L0 {
class LinuxStandbyImp : public OsStandby, NEO::NonCopyableOrMovableClass {
public:
ze_result_t getMode(zet_standby_promo_mode_t &mode) override;
ze_result_t setMode(zet_standby_promo_mode_t mode) override;
ze_result_t getMode(zes_standby_promo_mode_t &mode) override;
ze_result_t setMode(zes_standby_promo_mode_t mode) override;

7
level_zero/tools/source/sysman/standby/os_standby.h
View File

@@ -8,17 +8,12 @@
#pragma once
#include "level_zero/tools/source/sysman/os_sysman.h"
#include <level_zero/zet_api.h>
#include "third_party/level_zero/zes_api_ext.h"
#include <level_zero/zes_api.h>
namespace L0 {
class OsStandby {
public:
virtual ze_result_t getMode(zet_standby_promo_mode_t &mode) = 0;
virtual ze_result_t setMode(zet_standby_promo_mode_t mode) = 0;
virtual ze_result_t getMode(zes_standby_promo_mode_t &mode) = 0;
virtual ze_result_t setMode(zes_standby_promo_mode_t mode) = 0;

14
level_zero/tools/source/sysman/standby/standby.cpp
View File

@@ -28,20 +28,6 @@ void StandbyHandleContext::init() {
}
}
ze_result_t StandbyHandleContext::standbyGet(uint32_t *pCount, zet_sysman_standby_handle_t *phStandby) {
uint32_t handleListSize = static_cast<uint32_t>(handleList.size());
uint32_t numToCopy = std::min(*pCount, handleListSize);
if (0 == *pCount || *pCount > handleListSize) {
*pCount = handleListSize;
}
if (nullptr != phStandby) {
for (uint32_t i = 0; i < numToCopy; i++) {
phStandby[i] = handleList[i]->toHandle();
}
}
return ZE_RESULT_SUCCESS;
}
ze_result_t StandbyHandleContext::standbyGet(uint32_t *pCount, zes_standby_handle_t *phStandby) {
uint32_t handleListSize = static_cast<uint32_t>(handleList.size());
uint32_t numToCopy = std::min(*pCount, handleListSize);

19
level_zero/tools/source/sysman/standby/standby.h
View File

@@ -6,15 +6,10 @@
*/
#pragma once
#include <level_zero/zet_api.h>
#include "third_party/level_zero/zes_api_ext.h"
#include <level_zero/zes_api.h>
#include <vector>
struct _zet_sysman_standby_handle_t {
virtual ~_zet_sysman_standby_handle_t() = default;
};
struct _zes_standby_handle_t {
virtual ~_zes_standby_handle_t() = default;
};
@@ -23,24 +18,15 @@ namespace L0 {
struct OsSysman;
class Standby : _zet_sysman_standby_handle_t, _zes_standby_handle_t {
class Standby : _zes_standby_handle_t {
public:
virtual ~Standby() {}
virtual ze_result_t standbyGetProperties(zet_standby_properties_t *pProperties) = 0;
virtual ze_result_t standbyGetMode(zet_standby_promo_mode_t *pMode) = 0;
virtual ze_result_t standbySetMode(const zet_standby_promo_mode_t mode) = 0;
virtual ze_result_t standbyGetProperties(zes_standby_properties_t *pProperties) = 0;
virtual ze_result_t standbyGetMode(zes_standby_promo_mode_t *pMode) = 0;
virtual ze_result_t standbySetMode(const zes_standby_promo_mode_t mode) = 0;
inline zet_sysman_standby_handle_t toHandle() { return this; }
inline zes_standby_handle_t toStandbyHandle() { return this; }
static Standby *fromHandle(zet_sysman_standby_handle_t handle) {
return static_cast<Standby *>(handle);
}
static Standby *fromHandle(zes_standby_handle_t handle) {
return static_cast<Standby *>(handle);
}
@@ -53,7 +39,6 @@ struct StandbyHandleContext {
void init();
ze_result_t standbyGet(uint32_t *pCount, zet_sysman_standby_handle_t *phStandby);
ze_result_t standbyGet(uint32_t *pCount, zes_standby_handle_t *phStandby);
OsSysman *pOsSysman;

21
level_zero/tools/source/sysman/standby/standby_imp.cpp
View File

@@ -13,21 +13,8 @@
namespace L0 {
ze_result_t StandbyImp::standbyGetProperties(zet_standby_properties_t *pProperties) {
*pProperties = standbyProperties;
return ZE_RESULT_SUCCESS;
}
ze_result_t StandbyImp::standbyGetMode(zet_standby_promo_mode_t *pMode) {
return pOsStandby->getMode(*pMode);
}
ze_result_t StandbyImp::standbySetMode(const zet_standby_promo_mode_t mode) {
return pOsStandby->setMode(mode);
}
ze_result_t StandbyImp::standbyGetProperties(zes_standby_properties_t *pProperties) {
*pProperties = zesStandbyProperties;
*pProperties = standbyProperties;
return ZE_RESULT_SUCCESS;
}
@@ -40,13 +27,9 @@ ze_result_t StandbyImp::standbySetMode(const zes_standby_promo_mode_t mode) {
}
void StandbyImp::init() {
standbyProperties.type = ZET_STANDBY_TYPE_GLOBAL; // Currently the only defined type
standbyProperties.type = ZES_STANDBY_TYPE_GLOBAL; // Currently the only defined type
standbyProperties.onSubdevice = false;
standbyProperties.subdeviceId = 0;
zesStandbyProperties.type = ZES_STANDBY_TYPE_GLOBAL;
zesStandbyProperties.onSubdevice = false;
zesStandbyProperties.subdeviceId = 0;
zesStandbyProperties.pNext = nullptr;
this->isStandbyEnabled = pOsStandby->isStandbySupported();
}

10
level_zero/tools/source/sysman/standby/standby_imp.h
View File

@@ -8,20 +8,15 @@
#pragma once
#include "shared/source/helpers/non_copyable_or_moveable.h"
#include <level_zero/zet_api.h>
#include <level_zero/zes_api.h>
#include "os_standby.h"
#include "standby.h"
#include "third_party/level_zero/zes_api_ext.h"
namespace L0 {
class StandbyImp : public Standby, NEO::NonCopyableOrMovableClass {
public:
ze_result_t standbyGetProperties(zet_standby_properties_t *pProperties) override;
ze_result_t standbyGetMode(zet_standby_promo_mode_t *pMode) override;
ze_result_t standbySetMode(const zet_standby_promo_mode_t mode) override;
ze_result_t standbyGetProperties(zes_standby_properties_t *pProperties) override;
ze_result_t standbyGetMode(zes_standby_promo_mode_t *pMode) override;
ze_result_t standbySetMode(const zes_standby_promo_mode_t mode) override;
@@ -34,8 +29,7 @@ class StandbyImp : public Standby, NEO::NonCopyableOrMovableClass {
void init();
private:
zet_standby_properties_t standbyProperties = {};
zes_standby_properties_t zesStandbyProperties = {};
zes_standby_properties_t standbyProperties = {};
};
} // namespace L0

12
level_zero/tools/source/sysman/standby/windows/os_standby_imp.cpp
View File

@@ -11,18 +11,12 @@ namespace L0 {
class WddmStandbyImp : public OsStandby {
public:
ze_result_t getMode(zet_standby_promo_mode_t &mode) override;
ze_result_t setMode(zet_standby_promo_mode_t mode) override;
ze_result_t getMode(zes_standby_promo_mode_t &mode) override;
ze_result_t setMode(zes_standby_promo_mode_t mode) override;
bool isStandbySupported(void) override;
};
ze_result_t WddmStandbyImp::getMode(zet_standby_promo_mode_t &mode) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmStandbyImp::setMode(zet_standby_promo_mode_t mode) {
ze_result_t WddmStandbyImp::setMode(zes_standby_promo_mode_t mode) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
@@ -30,10 +24,6 @@ ze_result_t WddmStandbyImp::getMode(zes_standby_promo_mode_t &mode) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmStandbyImp::setMode(zes_standby_promo_mode_t mode) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
bool WddmStandbyImp::isStandbySupported(void) {
return false;
}

36
level_zero/tools/source/sysman/sysman.cpp
View File

@@ -16,42 +16,6 @@
namespace L0 {
static SysmanHandleContext *SysmanHandleContextInstance = nullptr;
void SysmanHandleContext::init(ze_init_flag_t flag) {
if (SysmanHandleContextInstance == nullptr) {
SysmanHandleContextInstance = new SysmanHandleContext();
}
}
SysmanHandleContext::SysmanHandleContext() {
DriverHandle *dH = L0::DriverHandle::fromHandle(GlobalDriverHandle);
uint32_t count = 0;
dH->getDevice(&count, nullptr);
std::vector<ze_device_handle_t> devices(count);
dH->getDevice(&count, devices.data());
for (auto device : devices) {
SysmanImp *sysman = new SysmanImp(device);
UNRECOVERABLE_IF(!sysman);
sysman->init();
handle_map[device] = sysman;
}
}
ze_result_t SysmanHandleContext::sysmanGet(zet_device_handle_t hDevice, zet_sysman_handle_t *phSysman) {
if (SysmanHandleContextInstance == nullptr) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
auto got = SysmanHandleContextInstance->handle_map.find(hDevice);
if (got == SysmanHandleContextInstance->handle_map.end()) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
*phSysman = got->second;
return ZE_RESULT_SUCCESS;
}
SysmanDevice *SysmanDeviceHandleContext::init(ze_device_handle_t device) {
auto isSysmanEnabled = getenv("ZES_ENABLE_SYSMAN");
if ((isSysmanEnabled == nullptr) || (device == nullptr)) {

52
level_zero/tools/source/sysman/sysman.h
View File

@@ -18,10 +18,8 @@
#include "level_zero/tools/source/sysman/scheduler/scheduler.h"
#include "level_zero/tools/source/sysman/standby/standby.h"
#include "level_zero/tools/source/sysman/temperature/temperature.h"
#include <level_zero/zes_api.h>
#include <level_zero/zet_api.h>
#include <level_zero/zet_sysman.h>
#include "third_party/level_zero/zes_api_ext.h"
#include <unordered_map>
@@ -29,54 +27,6 @@ struct _zet_sysman_handle_t {};
namespace L0 {
struct Sysman : _zet_sysman_handle_t {
static Sysman *fromHandle(zet_sysman_handle_t handle) { return static_cast<Sysman *>(handle); }
inline zet_sysman_handle_t toHandle() { return this; }
virtual ze_result_t deviceGetProperties(zet_sysman_properties_t *pProperties) = 0;
virtual ze_result_t schedulerGetCurrentMode(zet_sched_mode_t *pMode) = 0;
virtual ze_result_t schedulerGetTimeoutModeProperties(ze_bool_t getDefaults, zet_sched_timeout_properties_t *pConfig) = 0;
virtual ze_result_t schedulerGetTimesliceModeProperties(ze_bool_t getDefaults, zet_sched_timeslice_properties_t *pConfig) = 0;
virtual ze_result_t schedulerSetTimeoutMode(zet_sched_timeout_properties_t *pProperties, ze_bool_t *pNeedReboot) = 0;
virtual ze_result_t schedulerSetTimesliceMode(zet_sched_timeslice_properties_t *pProperties, ze_bool_t *pNeedReboot) = 0;
virtual ze_result_t schedulerSetExclusiveMode(ze_bool_t *pNeedReboot) = 0;
virtual ze_result_t schedulerSetComputeUnitDebugMode(ze_bool_t *pNeedReboot) = 0;
virtual ze_result_t processesGetState(uint32_t *pCount, zet_process_state_t *pProcesses) = 0;
virtual ze_result_t deviceReset() = 0;
virtual ze_result_t deviceGetRepairStatus(zet_repair_status_t *pRepairStatus) = 0;
virtual ze_result_t pciGetProperties(zet_pci_properties_t *pProperties) = 0;
virtual ze_result_t pciGetState(zet_pci_state_t *pState) = 0;
virtual ze_result_t pciGetBars(uint32_t *pCount, zet_pci_bar_properties_t *pProperties) = 0;
virtual ze_result_t pciGetStats(zet_pci_stats_t *pStats) = 0;
virtual ze_result_t powerGet(uint32_t *pCount, zet_sysman_pwr_handle_t *phPower) = 0;
virtual ze_result_t frequencyGet(uint32_t *pCount, zet_sysman_freq_handle_t *phFrequency) = 0;
virtual ze_result_t engineGet(uint32_t *pCount, zet_sysman_engine_handle_t *phEngine) = 0;
virtual ze_result_t standbyGet(uint32_t *pCount, zet_sysman_standby_handle_t *phStandby) = 0;
virtual ze_result_t firmwareGet(uint32_t *pCount, zet_sysman_firmware_handle_t *phFirmware) = 0;
virtual ze_result_t memoryGet(uint32_t *pCount, zet_sysman_mem_handle_t *phMemory) = 0;
virtual ze_result_t fabricPortGet(uint32_t *pCount, zet_sysman_fabric_port_handle_t *phPort) = 0;
virtual ze_result_t temperatureGet(uint32_t *pCount, zet_sysman_temp_handle_t *phTemperature) = 0;
virtual ze_result_t psuGet(uint32_t *pCount, zet_sysman_psu_handle_t *phPsu) = 0;
virtual ze_result_t fanGet(uint32_t *pCount, zet_sysman_fan_handle_t *phFan) = 0;
virtual ze_result_t ledGet(uint32_t *pCount, zet_sysman_led_handle_t *phLed) = 0;
virtual ze_result_t rasGet(uint32_t *pCount, zet_sysman_ras_handle_t *phRas) = 0;
virtual ze_result_t eventGet(zet_sysman_event_handle_t *phEvent) = 0;
virtual ze_result_t diagnosticsGet(uint32_t *pCount, zet_sysman_diag_handle_t *phDiagnostics) = 0;
virtual ~Sysman() = default;
};
class SysmanHandleContext {
public:
SysmanHandleContext();
static void init(ze_init_flag_t flag);
static ze_result_t sysmanGet(zet_device_handle_t hDevice, zet_sysman_handle_t *phSysman);
private:
std::unordered_map<zet_device_handle_t, zet_sysman_handle_t> handle_map;
};
struct SysmanDevice : _ze_device_handle_t {
static SysmanDevice *fromHandle(zes_device_handle_t handle) { return Device::fromHandle(handle)->getSysmanHandle(); }

210
level_zero/tools/source/sysman/sysman_imp.cpp
View File

@@ -62,234 +62,28 @@ void SysmanDeviceImp::init() {
}
}
SysmanImp::SysmanImp(ze_device_handle_t hDevice) {
hCoreDevice = hDevice;
pOsSysman = OsSysman::create(this);
UNRECOVERABLE_IF(nullptr == pOsSysman);
pPci = new PciImp(pOsSysman, hCoreDevice);
pSched = new SchedulerImp(pOsSysman);
pGlobalOperations = new GlobalOperationsImp(pOsSysman, hCoreDevice);
pFrequencyHandleContext = new FrequencyHandleContext(pOsSysman);
pStandbyHandleContext = new StandbyHandleContext(pOsSysman);
pMemoryHandleContext = new MemoryHandleContext(pOsSysman, hCoreDevice);
pEngineHandleContext = new EngineHandleContext(pOsSysman);
pRasHandleContext = new RasHandleContext(pOsSysman);
pTempHandleContext = new TemperatureHandleContext(pOsSysman);
pPowerHandleContext = new PowerHandleContext(pOsSysman);
pFabricPortHandleContext = new FabricPortHandleContext(pOsSysman);
}
SysmanImp::~SysmanImp() {
freeResource(pFabricPortHandleContext);
freeResource(pPowerHandleContext);
freeResource(pTempHandleContext);
freeResource(pRasHandleContext);
freeResource(pEngineHandleContext);
freeResource(pMemoryHandleContext);
freeResource(pStandbyHandleContext);
freeResource(pFrequencyHandleContext);
freeResource(pGlobalOperations);
freeResource(pPci);
freeResource(pSched);
freeResource(pOsSysman);
}
void SysmanImp::init() {
pOsSysman->init();
if (pFrequencyHandleContext) {
pFrequencyHandleContext->init();
}
if (pStandbyHandleContext) {
pStandbyHandleContext->init();
}
if (pMemoryHandleContext) {
pMemoryHandleContext->init();
}
if (pEngineHandleContext) {
pEngineHandleContext->init();
}
if (pRasHandleContext) {
pRasHandleContext->init();
}
if (pTempHandleContext) {
pTempHandleContext->init();
}
if (pPowerHandleContext) {
pPowerHandleContext->init();
}
if (pFabricPortHandleContext) {
pFabricPortHandleContext->init();
}
if (pPci) {
pPci->init();
}
if (pSched) {
pSched->init();
}
if (pGlobalOperations) {
pGlobalOperations->init();
}
}
ze_result_t SysmanImp::deviceGetProperties(zet_sysman_properties_t *pProperties) {
return pGlobalOperations->deviceGetProperties(pProperties);
}
ze_result_t SysmanImp::schedulerGetCurrentMode(zet_sched_mode_t *pMode) {
if (pSched) {
return pSched->getCurrentMode(pMode);
}
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t SysmanImp::schedulerGetTimeoutModeProperties(ze_bool_t getDefaults, zet_sched_timeout_properties_t *pConfig) {
if (pSched) {
return pSched->getTimeoutModeProperties(getDefaults, pConfig);
}
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t SysmanImp::schedulerGetTimesliceModeProperties(ze_bool_t getDefaults, zet_sched_timeslice_properties_t *pConfig) {
if (pSched) {
return pSched->getTimesliceModeProperties(getDefaults, pConfig);
}
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t SysmanImp::schedulerSetTimeoutMode(zet_sched_timeout_properties_t *pProperties, ze_bool_t *pNeedReboot) {
if (pSched) {
return pSched->setTimeoutMode(pProperties, pNeedReboot);
}
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t SysmanImp::schedulerSetTimesliceMode(zet_sched_timeslice_properties_t *pProperties, ze_bool_t *pNeedReboot) {
if (pSched) {
return pSched->setTimesliceMode(pProperties, pNeedReboot);
}
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t SysmanImp::schedulerSetExclusiveMode(ze_bool_t *pNeedReboot) {
if (pSched) {
return pSched->setExclusiveMode(pNeedReboot);
}
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t SysmanImp::schedulerSetComputeUnitDebugMode(ze_bool_t *pNeedReboot) {
if (pSched) {
return pSched->setComputeUnitDebugMode(pNeedReboot);
}
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t SysmanImp::processesGetState(uint32_t *pCount, zet_process_state_t *pProcesses) {
return pGlobalOperations->processesGetState(pCount, pProcesses);
}
ze_result_t SysmanImp::deviceReset() {
return pGlobalOperations->reset();
}
ze_result_t SysmanImp::deviceGetRepairStatus(zet_repair_status_t *pRepairStatus) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t SysmanImp::pciGetProperties(zet_pci_properties_t *pProperties) {
return pPci->pciStaticProperties(pProperties);
}
ze_result_t SysmanImp::pciGetState(zet_pci_state_t *pState) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t SysmanImp::pciGetBars(uint32_t *pCount, zet_pci_bar_properties_t *pProperties) {
return pPci->pciGetInitializedBars(pCount, pProperties);
}
ze_result_t SysmanImp::pciGetStats(zet_pci_stats_t *pStats) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t SysmanImp::powerGet(uint32_t *pCount, zet_sysman_pwr_handle_t *phPower) {
return pPowerHandleContext->powerGet(pCount, phPower);
ze_result_t SysmanDeviceImp::frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency) {
return pFrequencyHandleContext->frequencyGet(pCount, phFrequency);
}
ze_result_t SysmanDeviceImp::powerGet(uint32_t *pCount, zes_pwr_handle_t *phPower) {
return pPowerHandleContext->powerGet(pCount, phPower);
}
ze_result_t SysmanImp::frequencyGet(uint32_t *pCount, zet_sysman_freq_handle_t *phFrequency) {
return pFrequencyHandleContext->frequencyGet(pCount, phFrequency);
}
ze_result_t SysmanDeviceImp::frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency) {
return pFrequencyHandleContext->frequencyGet(pCount, phFrequency);
}
ze_result_t SysmanImp::engineGet(uint32_t *pCount, zet_sysman_engine_handle_t *phEngine) {
return pEngineHandleContext->engineGet(pCount, phEngine);
}
ze_result_t SysmanDeviceImp::engineGet(uint32_t *pCount, zes_engine_handle_t *phEngine) {
return pEngineHandleContext->engineGet(pCount, phEngine);
}
ze_result_t SysmanImp::standbyGet(uint32_t *pCount, zet_sysman_standby_handle_t *phStandby) {
return pStandbyHandleContext->standbyGet(pCount, phStandby);
}
ze_result_t SysmanDeviceImp::standbyGet(uint32_t *pCount, zes_standby_handle_t *phStandby) {
return pStandbyHandleContext->standbyGet(pCount, phStandby);
}
ze_result_t SysmanImp::firmwareGet(uint32_t *pCount, zet_sysman_firmware_handle_t *phFirmware) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t SysmanImp::memoryGet(uint32_t *pCount, zet_sysman_mem_handle_t *phMemory) {
return pMemoryHandleContext->memoryGet(pCount, phMemory);
}
ze_result_t SysmanDeviceImp::fabricPortGet(uint32_t *pCount, zes_fabric_port_handle_t *phPort) {
return pFabricPortHandleContext->fabricPortGet(pCount, phPort);
}
ze_result_t SysmanImp::fabricPortGet(uint32_t *pCount, zet_sysman_fabric_port_handle_t *phPort) {
return pFabricPortHandleContext->fabricPortGet(pCount, phPort);
}
ze_result_t SysmanDeviceImp::temperatureGet(uint32_t *pCount, zes_temp_handle_t *phTemperature) {
return pTempHandleContext->temperatureGet(pCount, phTemperature);
}
ze_result_t SysmanImp::temperatureGet(uint32_t *pCount, zet_sysman_temp_handle_t *phTemperature) {
return pTempHandleContext->temperatureGet(pCount, phTemperature);
}
ze_result_t SysmanImp::psuGet(uint32_t *pCount, zet_sysman_psu_handle_t *phPsu) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t SysmanImp::fanGet(uint32_t *pCount, zet_sysman_fan_handle_t *phFan) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t SysmanImp::ledGet(uint32_t *pCount, zet_sysman_led_handle_t *phLed) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t SysmanImp::rasGet(uint32_t *pCount, zet_sysman_ras_handle_t *phRas) {
return pRasHandleContext->rasGet(pCount, phRas);
}
ze_result_t SysmanImp::eventGet(zet_sysman_event_handle_t *phEvent) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t SysmanImp::diagnosticsGet(uint32_t *pCount, zet_sysman_diag_handle_t *phDiagnostics) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
} // namespace L0

67
level_zero/tools/source/sysman/sysman_imp.h
View File

@@ -10,77 +10,12 @@
#include "level_zero/tools/source/sysman/os_sysman.h"
#include "level_zero/tools/source/sysman/sysman.h"
#include <level_zero/zet_api.h>
#include <level_zero/zet_sysman.h>
#include <level_zero/zes_api.h>
#include <unordered_map>
namespace L0 {
struct SysmanImp : Sysman, NEO::NonCopyableOrMovableClass {
SysmanImp(ze_device_handle_t hDevice);
~SysmanImp() override;
SysmanImp() = delete;
void init();
ze_device_handle_t hCoreDevice;
OsSysman *pOsSysman = nullptr;
Pci *pPci = nullptr;
Scheduler *pSched = nullptr;
GlobalOperations *pGlobalOperations = nullptr;
FrequencyHandleContext *pFrequencyHandleContext = nullptr;
StandbyHandleContext *pStandbyHandleContext = nullptr;
MemoryHandleContext *pMemoryHandleContext = nullptr;
EngineHandleContext *pEngineHandleContext = nullptr;
RasHandleContext *pRasHandleContext = nullptr;
TemperatureHandleContext *pTempHandleContext = nullptr;
PowerHandleContext *pPowerHandleContext = nullptr;
FabricPortHandleContext *pFabricPortHandleContext = nullptr;
ze_result_t deviceGetProperties(zet_sysman_properties_t *pProperties) override;
ze_result_t schedulerGetCurrentMode(zet_sched_mode_t *pMode) override;
ze_result_t schedulerGetTimeoutModeProperties(ze_bool_t getDefaults, zet_sched_timeout_properties_t *pConfig) override;
ze_result_t schedulerGetTimesliceModeProperties(ze_bool_t getDefaults, zet_sched_timeslice_properties_t *pConfig) override;
ze_result_t schedulerSetTimeoutMode(zet_sched_timeout_properties_t *pProperties, ze_bool_t *pNeedReboot) override;
ze_result_t schedulerSetTimesliceMode(zet_sched_timeslice_properties_t *pProperties, ze_bool_t *pNeedReboot) override;
ze_result_t schedulerSetExclusiveMode(ze_bool_t *pNeedReboot) override;
ze_result_t schedulerSetComputeUnitDebugMode(ze_bool_t *pNeedReboot) override;
ze_result_t processesGetState(uint32_t *pCount, zet_process_state_t *pProcesses) override;
ze_result_t deviceReset() override;
ze_result_t deviceGetRepairStatus(zet_repair_status_t *pRepairStatus) override;
ze_result_t pciGetProperties(zet_pci_properties_t *pProperties) override;
ze_result_t pciGetState(zet_pci_state_t *pState) override;
ze_result_t pciGetBars(uint32_t *pCount, zet_pci_bar_properties_t *pProperties) override;
ze_result_t pciGetStats(zet_pci_stats_t *pStats) override;
ze_result_t powerGet(uint32_t *pCount, zet_sysman_pwr_handle_t *phPower) override;
ze_result_t frequencyGet(uint32_t *pCount, zet_sysman_freq_handle_t *phFrequency) override;
ze_result_t engineGet(uint32_t *pCount, zet_sysman_engine_handle_t *phEngine) override;
ze_result_t standbyGet(uint32_t *pCount, zet_sysman_standby_handle_t *phStandby) override;
ze_result_t firmwareGet(uint32_t *pCount, zet_sysman_firmware_handle_t *phFirmware) override;
ze_result_t memoryGet(uint32_t *pCount, zet_sysman_mem_handle_t *phMemory) override;
ze_result_t fabricPortGet(uint32_t *pCount, zet_sysman_fabric_port_handle_t *phPort) override;
ze_result_t temperatureGet(uint32_t *pCount, zet_sysman_temp_handle_t *phTemperature) override;
ze_result_t psuGet(uint32_t *pCount, zet_sysman_psu_handle_t *phPsu) override;
ze_result_t fanGet(uint32_t *pCount, zet_sysman_fan_handle_t *phFan) override;
ze_result_t ledGet(uint32_t *pCount, zet_sysman_led_handle_t *phLed) override;
ze_result_t rasGet(uint32_t *pCount, zet_sysman_ras_handle_t *phRas) override;
ze_result_t eventGet(zet_sysman_event_handle_t *phEvent) override;
ze_result_t diagnosticsGet(uint32_t *pCount, zet_sysman_diag_handle_t *phDiagnostics) override;
private:
template <typename T>
void inline freeResource(T *&resource) {
if (resource) {
delete resource;
resource = nullptr;
}
}
};
struct SysmanDeviceImp : SysmanDevice, NEO::NonCopyableOrMovableClass {
SysmanDeviceImp(ze_device_handle_t hDevice);

14
level_zero/tools/source/sysman/temperature/linux/os_temperature_imp.cpp
View File

@@ -27,9 +27,9 @@ ze_result_t LinuxTemperatureImp::getSensorTemperature(double *pTemperature) {
// GT temperature could be read via 8th to 15th bit in the value read in temperature
computeTemperature = (computeTemperature >> 8) & 0xff;
if ((zetType == ZET_TEMP_SENSORS_GPU) || (type == ZES_TEMP_SENSORS_GPU)) {
if ((zetType == ZES_TEMP_SENSORS_GPU) || (type == ZES_TEMP_SENSORS_GPU)) {
*pTemperature = static_cast<double>(computeTemperature);
} else if ((zetType == ZET_TEMP_SENSORS_GLOBAL) || (type == ZES_TEMP_SENSORS_GLOBAL)) {
} else if ((zetType == ZES_TEMP_SENSORS_GLOBAL) || (type == ZES_TEMP_SENSORS_GLOBAL)) {
key = "SOC_TEMPERATURES";
result = pPmt->readValue(key, socTemperature);
if (result != ZE_RESULT_SUCCESS) {
@@ -70,10 +70,6 @@ bool LinuxTemperatureImp::isTempModuleSupported() {
return pPmt->isPmtSupported();
}
void LinuxTemperatureImp::setSensorType(zet_temp_sensors_t sensorType) {
zetType = sensorType;
}
void LinuxTemperatureImp::setSensorType(zes_temp_sensors_t sensorType) {
type = sensorType;
}
@@ -83,12 +79,6 @@ LinuxTemperatureImp::LinuxTemperatureImp(OsSysman *pOsSysman) {
pPmt = &pLinuxSysmanImp->getPlatformMonitoringTechAccess();
}
OsTemperature *OsTemperature::create(OsSysman *pOsSysman, zet_temp_sensors_t sensorType) {
LinuxTemperatureImp *pLinuxTemperatureImp = new LinuxTemperatureImp(pOsSysman);
pLinuxTemperatureImp->setSensorType(sensorType);
return static_cast<OsTemperature *>(pLinuxTemperatureImp);
}
OsTemperature *OsTemperature::create(OsSysman *pOsSysman, zes_temp_sensors_t sensorType) {
LinuxTemperatureImp *pLinuxTemperatureImp = new LinuxTemperatureImp(pOsSysman);
pLinuxTemperatureImp->setSensorType(sensorType);

3
level_zero/tools/source/sysman/temperature/linux/os_temperature_imp.h
View File

@@ -18,7 +18,6 @@ class LinuxTemperatureImp : public OsTemperature, NEO::NonCopyableOrMovableClass
public:
ze_result_t getSensorTemperature(double *pTemperature) override;
bool isTempModuleSupported() override;
void setSensorType(zet_temp_sensors_t sensorType);
void setSensorType(zes_temp_sensors_t sensorType);
LinuxTemperatureImp(OsSysman *pOsSysman);
LinuxTemperatureImp() = default;
@@ -27,6 +26,6 @@ class LinuxTemperatureImp : public OsTemperature, NEO::NonCopyableOrMovableClass
protected:
PlatformMonitoringTech *pPmt = nullptr;
int zetType = 0x7fffffff;
zes_temp_sensors_t type = ZES_TEMP_SENSORS_FORCE_UINT32;
zes_temp_sensors_t type = ZES_TEMP_SENSORS_GLOBAL;
};
} // namespace L0

5
level_zero/tools/source/sysman/temperature/os_temperature.h
View File

@@ -7,9 +7,7 @@
#pragma once
#include <level_zero/zet_api.h>
#include "third_party/level_zero/zes_api_ext.h"
#include <level_zero/zes_api.h>
namespace L0 {
@@ -18,7 +16,6 @@ class OsTemperature {
public:
virtual ze_result_t getSensorTemperature(double *pTemperature) = 0;
virtual bool isTempModuleSupported() = 0;
static OsTemperature *create(OsSysman *pOsSysman, zet_temp_sensors_t sensorType);
static OsTemperature *create(OsSysman *pOsSysman, zes_temp_sensors_t sensorType);
virtual ~OsTemperature() = default;
};

27
level_zero/tools/source/sysman/temperature/temperature.cpp
View File

@@ -17,15 +17,6 @@ TemperatureHandleContext::~TemperatureHandleContext() {
}
}
void TemperatureHandleContext::createHandle(zet_temp_sensors_t type) {
Temperature *pTemperature = new TemperatureImp(pOsSysman, type);
if (pTemperature->initSuccess == true) {
handleList.push_back(pTemperature);
} else {
delete pTemperature;
}
}
void TemperatureHandleContext::createHandle(zes_temp_sensors_t type) {
Temperature *pTemperature = new TemperatureImp(pOsSysman, type);
if (pTemperature->initSuccess == true) {
@@ -45,22 +36,8 @@ void TemperatureHandleContext::init() {
}
return;
}
createHandle(ZET_TEMP_SENSORS_GLOBAL);
createHandle(ZET_TEMP_SENSORS_GPU);
}
ze_result_t TemperatureHandleContext::temperatureGet(uint32_t *pCount, zet_sysman_temp_handle_t *phTemperature) {
uint32_t handleListSize = static_cast<uint32_t>(handleList.size());
uint32_t numToCopy = std::min(*pCount, handleListSize);
if (0 == *pCount || *pCount > handleListSize) {
*pCount = handleListSize;
}
if (nullptr != phTemperature) {
for (uint32_t i = 0; i < numToCopy; i++) {
phTemperature[i] = handleList[i]->toZetHandle();
}
}
return ZE_RESULT_SUCCESS;
createHandle(ZES_TEMP_SENSORS_GLOBAL);
createHandle(ZES_TEMP_SENSORS_GPU);
}
ze_result_t TemperatureHandleContext::temperatureGet(uint32_t *pCount, zes_temp_handle_t *phTemperature) {

22
level_zero/tools/source/sysman/temperature/temperature.h
View File

@@ -6,16 +6,10 @@
*/
#pragma once
#include <level_zero/zet_api.h>
#include "third_party/level_zero/zes_api_ext.h"
#include <level_zero/zes_api.h>
#include <vector>
struct _zet_sysman_temp_handle_t {
virtual ~_zet_sysman_temp_handle_t() = default;
};
struct _zes_temp_handle_t {
virtual ~_zes_temp_handle_t() = default;
};
@@ -23,24 +17,16 @@ struct _zes_temp_handle_t {
namespace L0 {
struct OsSysman;
class Temperature : _zet_sysman_temp_handle_t, _zes_temp_handle_t {
class Temperature : _zes_temp_handle_t {
public:
virtual ze_result_t temperatureGetProperties(zet_temp_properties_t *pProperties) = 0;
virtual ze_result_t temperatureGetConfig(zet_temp_config_t *pConfig) = 0;
virtual ze_result_t temperatureSetConfig(const zet_temp_config_t *pConfig) = 0;
virtual ze_result_t temperatureGetState(double *pTemperature) = 0;
virtual ze_result_t temperatureGetProperties(zes_temp_properties_t *pProperties) = 0;
virtual ze_result_t temperatureGetConfig(zes_temp_config_t *pConfig) = 0;
virtual ze_result_t temperatureSetConfig(const zes_temp_config_t *pConfig) = 0;
virtual ze_result_t temperatureGetState(double *pTemperature) = 0;
static Temperature *fromHandle(zet_sysman_temp_handle_t handle) {
return static_cast<Temperature *>(handle);
}
static Temperature *fromHandle(zes_temp_handle_t handle) {
return static_cast<Temperature *>(handle);
}
inline zet_sysman_temp_handle_t toZetHandle() { return this; }
inline zes_temp_handle_t toHandle() { return this; }
bool initSuccess = false;
};
@@ -51,14 +37,12 @@ struct TemperatureHandleContext {
void init();
ze_result_t temperatureGet(uint32_t *pCount, zet_sysman_temp_handle_t *phTemperature);
ze_result_t temperatureGet(uint32_t *pCount, zes_temp_handle_t *phTemperature);
OsSysman *pOsSysman = nullptr;
std::vector<Temperature *> handleList = {};
private:
void createHandle(zet_temp_sensors_t type);
void createHandle(zes_temp_sensors_t type);
};

17
level_zero/tools/source/sysman/temperature/temperature_imp.cpp
View File

@@ -23,18 +23,6 @@ ze_result_t TemperatureImp::temperatureSetConfig(const zes_temp_config_t *pConfi
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t TemperatureImp::temperatureGetProperties(zet_temp_properties_t *pProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t TemperatureImp::temperatureGetConfig(zet_temp_config_t *pConfig) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t TemperatureImp::temperatureSetConfig(const zet_temp_config_t *pConfig) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t TemperatureImp::temperatureGetState(double *pTemperature) {
return pOsTemperature->getSensorTemperature(pTemperature);
}
@@ -43,11 +31,6 @@ void TemperatureImp::init() {
this->initSuccess = pOsTemperature->isTempModuleSupported();
}
TemperatureImp::TemperatureImp(OsSysman *pOsSysman, zet_temp_sensors_t type) {
pOsTemperature = OsTemperature::create(pOsSysman, type);
init();
}
TemperatureImp::TemperatureImp(OsSysman *pOsSysman, zes_temp_sensors_t type) {
pOsTemperature = OsTemperature::create(pOsSysman, type);
init();

5
level_zero/tools/source/sysman/temperature/temperature_imp.h
View File

@@ -14,17 +14,12 @@
namespace L0 {
class TemperatureImp : public Temperature, NEO::NonCopyableOrMovableClass {
public:
ze_result_t temperatureGetProperties(zet_temp_properties_t *pProperties) override;
ze_result_t temperatureGetConfig(zet_temp_config_t *pConfig) override;
ze_result_t temperatureSetConfig(const zet_temp_config_t *pConfig) override;
ze_result_t temperatureGetProperties(zes_temp_properties_t *pProperties) override;
ze_result_t temperatureGetConfig(zes_temp_config_t *pConfig) override;
ze_result_t temperatureSetConfig(const zes_temp_config_t *pConfig) override;
ze_result_t temperatureGetState(double *pTemperature) override;
TemperatureImp() = default;
TemperatureImp(OsSysman *pOsSysman, zet_temp_sensors_t type);
TemperatureImp(OsSysman *pOsSysman, zes_temp_sensors_t type);
~TemperatureImp() override;

5
level_zero/tools/source/sysman/temperature/windows/os_temperature_imp.cpp
View File

@@ -23,11 +23,6 @@ bool WddmTemperatureImp::isTempModuleSupported() {
return false;
}
OsTemperature *OsTemperature::create(OsSysman *pOsSysman, zet_temp_sensors_t sensorType) {
WddmTemperatureImp *pWddmTemperatureImp = new WddmTemperatureImp();
return static_cast<OsTemperature *>(pWddmTemperatureImp);
}
OsTemperature *OsTemperature::create(OsSysman *pOsSysman, zes_temp_sensors_t sensorType) {
WddmTemperatureImp *pWddmTemperatureImp = new WddmTemperatureImp();
return static_cast<OsTemperature *>(pWddmTemperatureImp);

9
level_zero/tools/source/sysman/windows/os_sysman_imp.cpp
View File

@@ -11,9 +11,7 @@ namespace L0 {
ze_result_t WddmSysmanImp::init() {
Device *pDevice = nullptr;
if (pParentSysmanImp != nullptr) {
pDevice = Device::fromHandle(pParentSysmanImp->hCoreDevice);
} else if (pParentSysmanDeviceImp != nullptr) {
if (pParentSysmanDeviceImp != nullptr) {
pDevice = Device::fromHandle(pParentSysmanDeviceImp->hCoreDevice);
} else {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
@@ -45,11 +43,6 @@ WddmSysmanImp::~WddmSysmanImp() {
}
}
OsSysman *OsSysman::create(SysmanImp *pParentSysmanImp) {
WddmSysmanImp *pWddmSysmanImp = new WddmSysmanImp(pParentSysmanImp);
return static_cast<OsSysman *>(pWddmSysmanImp);
}
OsSysman *OsSysman::create(SysmanDeviceImp *pParentSysmanDeviceImp) {
WddmSysmanImp *pWddmSysmanImp = new WddmSysmanImp(pParentSysmanDeviceImp);
return static_cast<OsSysman *>(pWddmSysmanImp);

2
level_zero/tools/source/sysman/windows/os_sysman_imp.h
View File

@@ -19,7 +19,6 @@ namespace L0 {
class WddmSysmanImp : public OsSysman, NEO::NonCopyableOrMovableClass {
public:
WddmSysmanImp() = default;
WddmSysmanImp(SysmanImp *pParentSysmanImp) : pParentSysmanImp(pParentSysmanImp){};
WddmSysmanImp(SysmanDeviceImp *pParentSysmanDeviceImp) : pParentSysmanDeviceImp(pParentSysmanDeviceImp){};
~WddmSysmanImp() override;
@@ -32,7 +31,6 @@ class WddmSysmanImp : public OsSysman, NEO::NonCopyableOrMovableClass {
KmdSysManager *pKmdSysManager = nullptr;
private:
SysmanImp *pParentSysmanImp = nullptr;
SysmanDeviceImp *pParentSysmanDeviceImp = nullptr;
NEO::Wddm *pWddm = nullptr;
};

Some files were not shown because too many files have changed in this diff Show More