[PTI-SDK] Add minimal testing of full and hybrid modes (#480)

- improves ze_collector.h code-coverage + 2% on lines, +3% on branches

---------

Signed-off-by: jfedorov <[email protected]>

Author: jfedorov

sdk/test/main_vecsqadd_fixture.cc

@@ -328,24 +328,32 @@ void RunVecsqadd(TestType a_test_type) {
   ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
 }
 
+enum CollectionMode { kModeFull = 0, kModeHybrid = 1, kModeLocal = 2 };
+
 }  // namespace
 
-class VecsqaddFixtureTest : public ::testing::Test {
+class VecsqaddFixtureTest : public ::testing::TestWithParam<CollectionMode> {
  protected:
   void SetUp() override {
     timestamps_monotonic = true;
     a_append_timestamp = 0;
     external_corr_map.clear();
     runtime_enq_2_gpu_kernel_name_map.clear();
     runtime_enq_2_gpu_mem_op_name_map.clear();
+    CollectionMode _collection_mode = GetParam();
+    // while passed ModeLocal local it is expected it will be selected automatically of course
+    // in case introspection API is available
+    if (_collection_mode != CollectionMode::kModeLocal) {
+      utils::SetEnv("PTI_COLLECTION_MODE", std::to_string(_collection_mode).c_str());
+    }
   }
 
   void TearDown() override {
     // Called right before destructor after each test
   }
 };
 
-TEST_F(VecsqaddFixtureTest, CorrelationIdsAndExternalCorrelationMatchForSq) {
+TEST_P(VecsqaddFixtureTest, CorrelationIdsAndExternalCorrelationMatchForSq) {
   EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
   RunVecsqadd(TestType::kExternalCorrId);
   uint64_t correlation_id = kernel_corr_id[0];
@@ -371,7 +379,7 @@ void EnableIndividualRuntimeApis() {
             pti_result::PTI_SUCCESS);
 }
 
-TEST_F(VecsqaddFixtureTest, CorrelationIdsAndExternalCorrelationMatchForSqReducedOps) {
+TEST_P(VecsqaddFixtureTest, CorrelationIdsAndExternalCorrelationMatchForSqReducedOps) {
   utils::SetEnv("PTI_VIEW_RUNTIME_API", "1");
   EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
   EnableIndividualRuntimeApis();
@@ -393,7 +401,7 @@ TEST_F(VecsqaddFixtureTest, CorrelationIdsAndExternalCorrelationMatchForSqReduce
   }
 }
 
-TEST_F(VecsqaddFixtureTest, CorrelationIdsMatchForAdd) {
+TEST_P(VecsqaddFixtureTest, CorrelationIdsMatchForAdd) {
   EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
   RunVecsqadd(TestType::kExternalCorrId);
   // Check that the correlation id of runtime and kernel matches
@@ -402,7 +410,7 @@ TEST_F(VecsqaddFixtureTest, CorrelationIdsMatchForAdd) {
   EXPECT_LE(sycl_kernel_start_time[1], kernel_append_time[1]);
 }
 
-TEST_F(VecsqaddFixtureTest, CorrelationIdsMatchForAddReducedOps) {
+TEST_P(VecsqaddFixtureTest, CorrelationIdsMatchForAddReducedOps) {
   utils::SetEnv("PTI_VIEW_RUNTIME_API", "1");
   EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
   EnableIndividualRuntimeApis();
@@ -413,7 +421,7 @@ TEST_F(VecsqaddFixtureTest, CorrelationIdsMatchForAddReducedOps) {
   EXPECT_LE(sycl_kernel_start_time[1], kernel_append_time[1]);
 }
 
-TEST_F(VecsqaddFixtureTest, TimestampWrapAroundOnOverflow) {
+TEST_P(VecsqaddFixtureTest, TimestampWrapAroundOnOverflow) {
   // TODO: Move this to the fixture if we get more stress tests. However, for now this is our only
   // one so we will soft disable it until it is enabled in CI.
   const auto result = utils::GetEnv("PTI_ENABLE_STRESS_TESTS");
@@ -427,3 +435,7 @@ TEST_F(VecsqaddFixtureTest, TimestampWrapAroundOnOverflow) {
   RunVecsqadd(TestType::kOverflowStress);
   EXPECT_EQ(timestamps_monotonic, true);
 }
+
+INSTANTIATE_TEST_SUITE_P(VecSqAddSuite, VecsqaddFixtureTest,
+                         ::testing::Values(CollectionMode::kModeFull, CollectionMode::kModeLocal,
+                                           CollectionMode::kModeHybrid));

sdk/test/no_kernel_overlap.cc

@@ -111,13 +111,16 @@ void TestCore(bool do_immediate) {
     std::cerr << "Error: Unknown exception caught." << '\n';
   }
 }
-}  // namespace
 
 bool ComparePair(std::pair<uint64_t, uint64_t> a_stamps, std::pair<uint64_t, uint64_t> b_stamps) {
   return a_stamps.first < b_stamps.first;
 }
+enum CollectionMode { kModeFull = 0, kModeHybrid = 1, kModeLocal = 2 };
+
+}  // namespace
 
-class NoKernelOverlapParametrizedTestFixture : public ::testing::TestWithParam<bool> {
+class NoKernelOverlapParametrizedTestFixture
+    : public ::testing::TestWithParam<std::tuple<bool, CollectionMode>> {
  protected:
   NoKernelOverlapParametrizedTestFixture() {
     // Setup work for each test
@@ -130,20 +133,28 @@ class NoKernelOverlapParametrizedTestFixture : public ::testing::TestWithParam<b
   static uint32_t times_buffer_completed;
   static std::vector<uint64_t> kernel_device_timestamps;
   static std::vector<uint64_t> kernel_host_timestamps;
-
-  static std::vector<std::pair<uint64_t, uint64_t> > kernel_device_timestamps_pairs;
+  static std::vector<std::pair<uint64_t, uint64_t>> kernel_device_timestamps_pairs;
+  static bool do_immediate;
 
   void SetUp() override {  // Called right after constructor before each test
     kernel_device_timestamps_pairs.clear();
     kernel_host_timestamps.clear();
     times_buffer_completed = 0;
+
+    auto [immediate, collection_mode] = GetParam();
+    do_immediate = immediate;
+    // while passed ModeLocal local it is expected it will be selected automatically of course
+    // in case introspection API is available
+    if (collection_mode != CollectionMode::kModeLocal) {
+      utils::SetEnv("PTI_COLLECTION_MODE", std::to_string(collection_mode).c_str());
+    }
   }
 
   void TearDown() override {
     // Called right before destructor after each test
   }
 
-  bool TestForDeviceKernelsOverlap(std::vector<std::pair<uint64_t, uint64_t> >& timestamps) {
+  bool TestForDeviceKernelsOverlap(std::vector<std::pair<uint64_t, uint64_t>>& timestamps) {
     if (timestamps.size() == 0) {
       std::cerr << "--->  ERROR: Empty kernel timestamps array - Not expected " << std::endl;
       return false;
@@ -161,16 +172,16 @@ class NoKernelOverlapParametrizedTestFixture : public ::testing::TestWithParam<b
                 << std::endl;
       */
       if (timestamps[item].first <= timestamps[item - 1].second) {
-        std::cerr << "--->  ERROR: Device kernel timestamps overlap start_of_i < end_of_i-1, at i: "
-                  << item << ", start_of_i: " << timestamps[item].first
-                  << ", end_of_i-1: " << timestamps[item - 1].second << std::endl;
+        std::cerr << "--->  ERROR: Device kernel timestamps overlap end_of_i < start_of_i-1, at i: "
+                  << item << ", end_of_i: " << timestamps[item].first
+                  << ", start_of_i-1: " << timestamps[item - 1].second << std::endl;
         return false;
       }
     }
     return true;
   }
 
-  bool TestForDeviceKernelDurationNonZero(std::vector<std::pair<uint64_t, uint64_t> >& timestamps) {
+  bool TestForDeviceKernelDurationNonZero(std::vector<std::pair<uint64_t, uint64_t>>& timestamps) {
     if (timestamps.size() == 0) {
       std::cerr << "--->  ERROR: Empty kernel timestamps array - Not expected " << std::endl;
       return false;
@@ -301,11 +312,11 @@ class NoKernelOverlapParametrizedTestFixture : public ::testing::TestWithParam<b
 // static members initialization
 uint32_t NoKernelOverlapParametrizedTestFixture::times_buffer_completed = 0;
 std::vector<uint64_t> NoKernelOverlapParametrizedTestFixture::kernel_host_timestamps{};
-std::vector<std::pair<uint64_t, uint64_t> >
+std::vector<std::pair<uint64_t, uint64_t>>
     NoKernelOverlapParametrizedTestFixture::kernel_device_timestamps_pairs{};
+bool NoKernelOverlapParametrizedTestFixture::do_immediate = true;
 
 TEST_P(NoKernelOverlapParametrizedTestFixture, NoKernelOverlapImmediate) {
-  bool do_immediate = GetParam();
   EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
 
   RunTest(do_immediate);
@@ -323,4 +334,9 @@ TEST_P(NoKernelOverlapParametrizedTestFixture, NoKernelOverlapImmediate) {
 }
 
 INSTANTIATE_TEST_SUITE_P(NoKernelOverlapTests, NoKernelOverlapParametrizedTestFixture,
-                         ::testing::Values(true, false));
+                         ::testing::Values(std::make_tuple(true, CollectionMode::kModeFull),
+                                           std::make_tuple(false, CollectionMode::kModeFull),
+                                           std::make_tuple(true, CollectionMode::kModeHybrid),
+                                           std::make_tuple(false, CollectionMode::kModeHybrid),
+                                           std::make_tuple(true, CollectionMode::kModeLocal),
+                                           std::make_tuple(false, CollectionMode::kModeLocal)));