Metric Api: Renamed MetricTracer to MetricStreamer

Change-Id: I7de16b230685201b0f91b227f17713c3cd49d497
Signed-off-by: Robert Krzemien <[email protected]>

Author: RobertKrzemien

level_zero/api/tools/zet_metric.cpp

@@ -10,6 +10,8 @@
 #include "level_zero/tools/source/metrics/metric.h"
 #include <level_zero/zet_api.h>
 
+#include "third_party/level_zero/zet_api_ext.h"
+
 extern "C" {
 
 __zedllexport ze_result_t __zecall
@@ -93,6 +95,39 @@ zetMetricTracerReadData(
     return L0::MetricTracer::fromHandle(hMetricTracer)->readData(maxReportCount, pRawDataSize, pRawData);
 }
 
+ZE_APIEXPORT ze_result_t ZE_APICALL
+zetMetricStreamerOpen(
+    zet_device_handle_t hDevice,
+    zet_metric_group_handle_t hMetricGroup,
+    zet_metric_streamer_desc_t *pDesc,
+    ze_event_handle_t hNotificationEvent,
+    zet_metric_streamer_handle_t *phMetricStreamer) {
+    return L0::metricStreamerOpen(hDevice, hMetricGroup, pDesc, hNotificationEvent, phMetricStreamer);
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL
+zetCommandListAppendMetricStreamerMarker(
+    ze_command_list_handle_t hCommandList,
+    zet_metric_streamer_handle_t hMetricStreamer,
+    uint32_t value) {
+    return L0::CommandList::fromHandle(hCommandList)->appendMetricStreamerMarker(hMetricStreamer, value);
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL
+zetMetricStreamerClose(
+    zet_metric_streamer_handle_t hMetricStreamer) {
+    return L0::MetricStreamer::fromHandle(hMetricStreamer)->close();
+}
+
+ZE_APIEXPORT ze_result_t ZE_APICALL
+zetMetricStreamerReadData(
+    zet_metric_streamer_handle_t hMetricStreamer,
+    uint32_t maxReportCount,
+    size_t *pRawDataSize,
+    uint8_t *pRawData) {
+    return L0::MetricStreamer::fromHandle(hMetricStreamer)->readData(maxReportCount, pRawDataSize, pRawData);
+}
+
 __zedllexport ze_result_t __zecall
 zetMetricQueryPoolCreate(
     zet_device_handle_t hDevice,

level_zero/core/source/cmdlist/cmdlist.h

@@ -16,6 +16,8 @@
 #include <level_zero/ze_api.h>
 #include <level_zero/zet_api.h>
 
+#include "third_party/level_zero/zet_api_ext.h"
+
 #include <vector>
 
 struct _ze_command_list_handle_t {};
@@ -104,6 +106,8 @@ struct CommandList : _ze_command_list_handle_t {
     virtual ze_result_t reset() = 0;
 
     virtual ze_result_t appendMetricMemoryBarrier() = 0;
+    virtual ze_result_t appendMetricStreamerMarker(zet_metric_streamer_handle_t hMetricStreamer,
+                                                   uint32_t value) = 0;
     virtual ze_result_t appendMetricTracerMarker(zet_metric_tracer_handle_t hMetricTracer,
                                                  uint32_t value) = 0;
     virtual ze_result_t appendMetricQueryBegin(zet_metric_query_handle_t hMetricQuery) = 0;

level_zero/core/source/cmdlist/cmdlist_imp.cpp

@@ -35,9 +35,17 @@ ze_result_t CommandListImp::appendMetricMemoryBarrier() {
     return MetricQuery::appendMemoryBarrier(*this);
 }
 
+ze_result_t CommandListImp::appendMetricStreamerMarker(zet_metric_streamer_handle_t hMetricStreamer,
+                                                       uint32_t value) {
+    return MetricQuery::appendStreamerMarker(*this, hMetricStreamer, value);
+}
+
 ze_result_t CommandListImp::appendMetricTracerMarker(zet_metric_tracer_handle_t hMetricTracer,
                                                      uint32_t value) {
-    return MetricQuery::appendTracerMarker(*this, hMetricTracer, value);
+
+    zet_metric_streamer_handle_t hMetricStreamer = reinterpret_cast<zet_metric_streamer_handle_t>(hMetricTracer);
+
+    return MetricQuery::appendStreamerMarker(*this, hMetricStreamer, value);
 }
 
 ze_result_t CommandListImp::appendMetricQueryBegin(zet_metric_query_handle_t hMetricQuery) {

level_zero/core/source/cmdlist/cmdlist_imp.h

@@ -18,6 +18,8 @@ struct CommandListImp : CommandList {
     ze_result_t destroy() override;
 
     ze_result_t appendMetricMemoryBarrier() override;
+    ze_result_t appendMetricStreamerMarker(zet_metric_streamer_handle_t hMetricStreamer,
+                                           uint32_t value) override;
     ze_result_t appendMetricTracerMarker(zet_metric_tracer_handle_t hMetricTracer,
                                          uint32_t value) override;
     ze_result_t appendMetricQueryBegin(zet_metric_query_handle_t hMetricQuery) override;

level_zero/core/source/event/event.cpp

@@ -42,8 +42,8 @@ struct EventImp : public Event {
         uint64_t *hostAddr = static_cast<uint64_t *>(hostAddress);
         uint32_t queryVal = Event::STATE_CLEARED;
 
-        if (metricTracer != nullptr) {
-            *hostAddr = metricTracer->getNotificationState();
+        if (metricStreamer != nullptr) {
+            *hostAddr = metricStreamer->getNotificationState();
         }
 
         this->csr->downloadAllocations();

level_zero/core/source/event/event.h

@@ -19,7 +19,7 @@ struct _ze_event_pool_handle_t {};
 namespace L0 {
 typedef uint64_t FlushStamp;
 struct EventPool;
-struct MetricTracer;
+struct MetricStreamer;
 
 struct Event : _ze_event_handle_t {
     virtual ~Event() = default;
@@ -55,8 +55,8 @@ struct Event : _ze_event_handle_t {
 
     bool isTimestampEvent = false;
 
-    // Metric tracer instance associated with the event.
-    MetricTracer *metricTracer = nullptr;
+    // Metric streamer instance associated with the event.
+    MetricStreamer *metricStreamer = nullptr;
 
     NEO::CommandStreamReceiver *csr = nullptr;
 

level_zero/core/test/unit_tests/mocks/mock_cmdlist.h

@@ -239,6 +239,10 @@ struct MockCommandList : public CommandList {
 
     ADDMETHOD_NOBASE(appendMetricMemoryBarrier, ze_result_t, ZE_RESULT_SUCCESS, ());
 
+    ADDMETHOD_NOBASE(appendMetricStreamerMarker, ze_result_t, ZE_RESULT_SUCCESS,
+                     (zet_metric_streamer_handle_t hMetricStreamer,
+                      uint32_t value));
+
     ADDMETHOD_NOBASE(appendMetricTracerMarker, ze_result_t, ZE_RESULT_SUCCESS,
                      (zet_metric_tracer_handle_t hMetricTracer,
                       uint32_t value));

level_zero/tools/source/metrics/CMakeLists.txt

@@ -10,7 +10,7 @@ set(L0_SRCS_TOOLS_METRICS
 list(APPEND L0_SRCS_TOOLS_METRICS
     ${CMAKE_CURRENT_SOURCE_DIR}/metric.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/metric_enumeration_imp.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/metric_tracer_imp.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/metric_streamer_imp.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/metric_query_imp.cpp)
 
 if(UNIX)

level_zero/tools/source/metrics/metric.cpp

@@ -53,8 +53,8 @@ struct MetricContextImp : public MetricContext {
     Device &getDevice() override;
     MetricsLibrary &getMetricsLibrary() override;
     MetricEnumeration &getMetricEnumeration() override;
-    MetricTracer *getMetricTracer() override;
-    void setMetricTracer(MetricTracer *pMetricTracer) override;
+    MetricStreamer *getMetricStreamer() override;
+    void setMetricStreamer(MetricStreamer *pMetricStreamer) override;
     void setMetricsLibrary(MetricsLibrary &metricsLibrary) override;
     void setMetricEnumeration(MetricEnumeration &metricEnumeration) override;
 
@@ -72,7 +72,7 @@ struct MetricContextImp : public MetricContext {
     std::unique_ptr<MetricEnumeration> metricEnumeration = nullptr;
     std::unique_ptr<MetricsLibrary> metricsLibrary = nullptr;
     MetricGroupDomains metricGroupDomains;
-    MetricTracer *pMetricTracer = nullptr;
+    MetricStreamer *pMetricStreamer = nullptr;
     bool useCompute = false;
 };
 
@@ -118,10 +118,10 @@ MetricsLibrary &MetricContextImp::getMetricsLibrary() { return *metricsLibrary;
 
 MetricEnumeration &MetricContextImp::getMetricEnumeration() { return *metricEnumeration; }
 
-MetricTracer *MetricContextImp::getMetricTracer() { return pMetricTracer; }
+MetricStreamer *MetricContextImp::getMetricStreamer() { return pMetricStreamer; }
 
-void MetricContextImp::setMetricTracer(MetricTracer *pMetricTracer) {
-    this->pMetricTracer = pMetricTracer;
+void MetricContextImp::setMetricStreamer(MetricStreamer *pMetricStreamer) {
+    this->pMetricStreamer = pMetricStreamer;
 }
 
 void MetricContextImp::setMetricsLibrary(MetricsLibrary &metricsLibrary) {
@@ -146,7 +146,7 @@ ze_result_t
 MetricContextImp::activateMetricGroupsDeferred(const uint32_t count,
                                                zet_metric_group_handle_t *phMetricGroups) {
 
-    // Activation: postpone until zetMetricTracerOpen or zeCommandQueueExecuteCommandLists
+    // Activation: postpone until zetMetricStreamerOpen or zeCommandQueueExecuteCommandLists
     // Deactivation: execute immediately.
     return phMetricGroups ? metricGroupDomains.activateDeferred(count, phMetricGroups)
                           : metricGroupDomains.deactivate();
@@ -250,7 +250,7 @@ bool MetricGroupDomains::activateMetricGroupDeferred(const zet_metric_group_hand
 
     // Associate metric group with domain and mark it as not active.
     // Activation will be performed during zeCommandQueueExecuteCommandLists (query)
-    // or zetMetricTracerOpen (time based sampling).
+    // or zetMetricStreamerOpen (time based sampling).
     domains[domain].first = hMetricGroup;
     domains[domain].second = false;
 
@@ -269,7 +269,7 @@ ze_result_t MetricGroupDomains::activate() {
                                 ZET_METRIC_GROUP_SAMPLING_TYPE_EVENT_BASED;
 
         // Activate only event based metric groups.
-        // Time based metric group will be activated during zetMetricTracerOpen.
+        // Time based metric group will be activated during zetMetricStreamerOpen.
         if (metricGroupEventBased && !metricGroupActive) {
 
             metricGroupActive = activateEventMetricGroup(hMetricGroup);
@@ -347,11 +347,26 @@ ze_result_t metricGroupGet(zet_device_handle_t hDevice, uint32_t *pCount, zet_me
                                                                             phMetricGroups);
 }
 
+ze_result_t metricStreamerOpen(zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
+                               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) {
 
-    return MetricTracer::open(hDevice, hMetricGroup, *pDesc, hNotificationEvent, 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);
 }
 
 } // namespace L0

level_zero/tools/source/metrics/metric.h

@@ -9,10 +9,13 @@
 #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 {};
@@ -26,7 +29,7 @@ namespace L0 {
 struct MetricsLibrary;
 struct CommandList;
 struct MetricEnumeration;
-struct MetricTracer;
+struct MetricStreamer;
 
 struct MetricContext {
     virtual ~MetricContext() = default;
@@ -38,8 +41,8 @@ struct MetricContext {
     virtual Device &getDevice() = 0;
     virtual MetricsLibrary &getMetricsLibrary() = 0;
     virtual MetricEnumeration &getMetricEnumeration() = 0;
-    virtual MetricTracer *getMetricTracer() = 0;
-    virtual void setMetricTracer(MetricTracer *pMetricTracer) = 0;
+    virtual MetricStreamer *getMetricStreamer() = 0;
+    virtual void setMetricStreamer(MetricStreamer *pMetricStreamer) = 0;
     virtual void setMetricsLibrary(MetricsLibrary &metricsLibrary) = 0;
     virtual void setMetricEnumeration(MetricEnumeration &metricEnumeration) = 0;
 
@@ -97,21 +100,29 @@ struct MetricGroup : _zet_metric_group_handle_t {
     virtual ze_result_t closeIoStream() = 0;
 };
 
-struct MetricTracer : _zet_metric_tracer_handle_t {
-    virtual ~MetricTracer() = default;
+struct MetricStreamer : _zet_metric_streamer_handle_t {
+    virtual ~MetricStreamer() = default;
 
     virtual ze_result_t readData(uint32_t maxReportCount, size_t *pRawDataSize,
                                  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,
-                            zet_metric_tracer_desc_t &desc, ze_event_handle_t hNotificationEvent, zet_metric_tracer_handle_t *phMetricTracer);
-    static MetricTracer *fromHandle(zet_metric_tracer_handle_t handle) {
-        return static_cast<MetricTracer *>(handle);
+                            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);
     }
 
     virtual Event::State getNotificationState() = 0;
-    inline zet_metric_tracer_handle_t toHandle() { return this; }
+    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 {
@@ -134,8 +145,8 @@ struct MetricQuery : _zet_metric_query_handle_t {
     virtual ze_result_t appendEnd(CommandList &commandList, ze_event_handle_t hCompletionEvent) = 0;
 
     static ze_result_t appendMemoryBarrier(CommandList &commandList);
-    static ze_result_t appendTracerMarker(CommandList &commandList,
-                                          zet_metric_tracer_handle_t hMetricTracer, uint32_t value);
+    static ze_result_t appendStreamerMarker(CommandList &commandList,
+                                            zet_metric_streamer_handle_t hMetricStreamer, uint32_t value);
 
     virtual ze_result_t getData(size_t *pRawDataSize, uint8_t *pRawData) = 0;
 
@@ -150,7 +161,11 @@ struct MetricQuery : _zet_metric_query_handle_t {
 // MetricGroup.
 ze_result_t metricGroupGet(zet_device_handle_t hDevice, uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups);
 
-// MetricTracer.
+// MetricStreamer.
+ze_result_t metricStreamerOpen(zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup,
+                               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);