1 /*
2  * Copyright (C) 2020-2021 Intel Corporation
3  *
4  * SPDX-License-Identifier: MIT
5  *
6  */
7 
8 #pragma once
9 #include "level_zero/core/source/event/event.h"
10 #include <level_zero/zet_api.h>
11 
12 #include "metrics_discovery_api.h"
13 
14 #include <vector>
15 
16 struct _zet_metric_group_handle_t {};
17 struct _zet_metric_handle_t {};
18 struct _zet_metric_streamer_handle_t {};
19 struct _zet_metric_query_pool_handle_t {};
20 struct _zet_metric_query_handle_t {};
21 
22 namespace L0 {
23 struct MetricsLibrary;
24 struct CommandList;
25 struct MetricEnumeration;
26 struct MetricStreamer;
27 
28 struct MetricContext {
29     virtual ~MetricContext() = default;
30     static std::unique_ptr<MetricContext> create(struct Device &device);
31     static bool isMetricApiAvailable();
32     virtual bool loadDependencies() = 0;
33     virtual bool isInitialized() = 0;
34     virtual void setInitializationState(const ze_result_t state) = 0;
35     virtual Device &getDevice() = 0;
36     virtual MetricsLibrary &getMetricsLibrary() = 0;
37     virtual MetricEnumeration &getMetricEnumeration() = 0;
38     virtual MetricStreamer *getMetricStreamer() = 0;
39     virtual void setMetricStreamer(MetricStreamer *pMetricStreamer) = 0;
40     virtual void setMetricsLibrary(MetricsLibrary &metricsLibrary) = 0;
41     virtual void setMetricEnumeration(MetricEnumeration &metricEnumeration) = 0;
42 
43     // Called by zeInit.
44     static ze_result_t enableMetricApi();
45 
46     // Metric groups activation.
47     virtual ze_result_t activateMetricGroups() = 0;
48     virtual ze_result_t activateMetricGroupsDeferred(const uint32_t count,
49                                                      zet_metric_group_handle_t *phMetricGroups) = 0;
50     virtual bool isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) = 0;
51     virtual bool isMetricGroupActivated() = 0;
52 
53     virtual void setUseCompute(const bool useCompute) = 0;
54     virtual bool isComputeUsed() = 0;
55     virtual uint32_t getSubDeviceIndex() = 0;
56     virtual void setSubDeviceIndex(const uint32_t index) = 0;
57     virtual bool isImplicitScalingCapable() = 0;
58 };
59 
60 struct Metric : _zet_metric_handle_t {
61     virtual ~Metric() = default;
62 
63     virtual ze_result_t getProperties(zet_metric_properties_t *pProperties) = 0;
64 
65     static Metric *create(zet_metric_properties_t &properties);
fromHandleMetric66     static Metric *fromHandle(zet_metric_handle_t handle) { return static_cast<Metric *>(handle); }
toHandleMetric67     inline zet_metric_handle_t toHandle() { return this; }
68 };
69 
70 struct MetricGroup : _zet_metric_group_handle_t {
71     virtual ~MetricGroup() = default;
72 
73     virtual ze_result_t getProperties(zet_metric_group_properties_t *pProperties) = 0;
74     virtual ze_result_t getMetric(uint32_t *pCount, zet_metric_handle_t *phMetrics) = 0;
75     virtual ze_result_t calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
76                                               const uint8_t *pRawData, uint32_t *pMetricValueCount,
77                                               zet_typed_value_t *pMetricValues) = 0;
78     virtual ze_result_t calculateMetricValuesExp(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
79                                                  const uint8_t *pRawData, uint32_t *pSetCount,
80                                                  uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
81                                                  zet_typed_value_t *pMetricValues) = 0;
82 
83     static MetricGroup *create(zet_metric_group_properties_t &properties,
84                                MetricsDiscovery::IMetricSet_1_5 &metricSet,
85                                MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
86                                const std::vector<Metric *> &metrics);
fromHandleMetricGroup87     static MetricGroup *fromHandle(zet_metric_group_handle_t handle) {
88         return static_cast<MetricGroup *>(handle);
89     }
90     static zet_metric_group_properties_t getProperties(const zet_metric_group_handle_t handle);
91 
toHandleMetricGroup92     zet_metric_group_handle_t toHandle() { return this; }
93 
94     virtual uint32_t getRawReportSize() = 0;
95 
96     virtual bool activate() = 0;
97     virtual bool deactivate() = 0;
98 
99     virtual ze_result_t openIoStream(uint32_t &timerPeriodNs, uint32_t &oaBufferSize) = 0;
100     virtual ze_result_t waitForReports(const uint32_t timeoutMs) = 0;
101     virtual ze_result_t readIoStream(uint32_t &reportCount, uint8_t &reportData) = 0;
102     virtual ze_result_t closeIoStream() = 0;
103 };
104 
105 struct MetricGroupCalculateHeader {
106     static constexpr uint32_t magicValue = 0xFFFEDCBA;
107 
108     uint32_t magic;
109     uint32_t dataCount;
110     uint32_t rawDataOffsets;
111     uint32_t rawDataSizes;
112     uint32_t rawDataOffset;
113 };
114 
115 struct MetricStreamer : _zet_metric_streamer_handle_t {
116     virtual ~MetricStreamer() = default;
117 
118     virtual ze_result_t readData(uint32_t maxReportCount, size_t *pRawDataSize,
119                                  uint8_t *pRawData) = 0;
120     virtual ze_result_t close() = 0;
121     static ze_result_t openForDevice(Device *pDevice, zet_metric_group_handle_t hMetricGroup,
122                                      zet_metric_streamer_desc_t &desc,
123                                      zet_metric_streamer_handle_t *phMetricStreamer);
124     static ze_result_t open(zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
125                             zet_metric_streamer_desc_t &desc, ze_event_handle_t hNotificationEvent, zet_metric_streamer_handle_t *phMetricStreamer);
fromHandleMetricStreamer126     static MetricStreamer *fromHandle(zet_metric_streamer_handle_t handle) {
127         return static_cast<MetricStreamer *>(handle);
128     }
129 
130     virtual Event::State getNotificationState() = 0;
toHandleMetricStreamer131     inline zet_metric_streamer_handle_t toHandle() { return this; }
132 };
133 
134 struct MetricQueryPool : _zet_metric_query_pool_handle_t {
135     virtual ~MetricQueryPool() = default;
136 
137     virtual ze_result_t destroy() = 0;
138     virtual ze_result_t createMetricQuery(uint32_t index,
139                                           zet_metric_query_handle_t *phMetricQuery) = 0;
140 
141     static MetricQueryPool *fromHandle(zet_metric_query_pool_handle_t handle);
142 
143     zet_metric_query_pool_handle_t toHandle();
144 };
145 
146 struct MetricQuery : _zet_metric_query_handle_t {
147     virtual ~MetricQuery() = default;
148 
149     virtual ze_result_t appendBegin(CommandList &commandList) = 0;
150     virtual ze_result_t appendEnd(CommandList &commandList, ze_event_handle_t hSignalEvent,
151                                   uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents) = 0;
152 
153     static ze_result_t appendMemoryBarrier(CommandList &commandList);
154     static ze_result_t appendStreamerMarker(CommandList &commandList,
155                                             zet_metric_streamer_handle_t hMetricStreamer, uint32_t value);
156 
157     virtual ze_result_t getData(size_t *pRawDataSize, uint8_t *pRawData) = 0;
158 
159     virtual ze_result_t reset() = 0;
160     virtual ze_result_t destroy() = 0;
161 
162     static MetricQuery *fromHandle(zet_metric_query_handle_t handle);
163 
164     zet_metric_query_handle_t toHandle();
165 };
166 
167 // MetricGroup.
168 ze_result_t metricGroupGet(zet_device_handle_t hDevice, uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups);
169 
170 // MetricStreamer.
171 ze_result_t metricStreamerOpen(zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
172                                zet_metric_streamer_desc_t *pDesc, ze_event_handle_t hNotificationEvent,
173                                zet_metric_streamer_handle_t *phMetricStreamer);
174 
175 // MetricQueryPool.
176 ze_result_t metricQueryPoolCreate(zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
177                                   const zet_metric_query_pool_desc_t *pDesc, zet_metric_query_pool_handle_t *phMetricQueryPool);
178 
179 } // namespace L0
180