Fix/type mismatch warnings (#290)

Fixes several hundred type mismatch warnings during build on Windows and Linux. See the related Jira task comments for details about the warning types.

Related-To: VLCLJ-2555

Signed-off-by: Eric Mortensen <[email protected]>

Author: enm-intel

CMakeLists.txt

@@ -348,6 +348,11 @@ else()
     set(CMAKE_NEWLINE "\n")
 endif()
 
+if (MSVC)
+    add_compile_options(/W4)
+else()
+    add_compile_options(-Wsign-compare -Wnarrowing -Wsign-conversion -Wfloat-conversion -Wconversion)
+endif()
 
 option(ENABLE_ZESYSMAN
   "Enables build of zesysman"

conformance_tests/core/test_barrier/src/test_barrier.cpp

@@ -17,6 +17,8 @@ namespace lzt = level_zero_tests;
 
 namespace {
 
+using lzt::to_u32;
+
 class zeCommandListAppendBarrierTests : public ::testing::Test {
 public:
   void run(bool isImmediate) {
@@ -79,7 +81,7 @@ void RunAppendingBarrierWithEvents(bool isImmediate) {
   auto bundle = lzt::create_command_bundle(context, device, 0, isImmediate);
 
   EXPECT_ZE_RESULT_SUCCESS(zeCommandListAppendBarrier(
-      bundle.list, nullptr, events.size(), events.data()));
+      bundle.list, nullptr, to_u32(events.size()), events.data()));
   for (auto &ev : events) {
     lzt::signal_event_from_host(ev);
   }
@@ -114,11 +116,11 @@ void RunAppendingBarrierWithSignalEventAndWaitEvents(bool isImmediate) {
   auto bundle = lzt::create_command_bundle(context, device, 0, isImmediate);
   auto events_initial = events;
   EXPECT_ZE_RESULT_SUCCESS(zeCommandListAppendBarrier(
-      bundle.list, event, events.size(), events.data()));
+      bundle.list, event, to_u32(events.size()), events.data()));
   for (auto &ev : events) {
     lzt::signal_event_from_host(ev);
   }
-  for (int i = 0; i < events.size(); i++) {
+  for (size_t i = 0U; i < events.size(); i++) {
     ASSERT_EQ(events[i], events_initial[i]);
   }
   ep.destroy_events(events);
@@ -151,8 +153,8 @@ void AppendMemoryRangesBarrierTest(
                                   context)};
 
   EXPECT_ZE_RESULT_SUCCESS(zeCommandListAppendMemoryRangesBarrier(
-      command_list, ranges.size(), range_sizes.data(), ranges.data(),
-      signaling_event, waiting_events.size(), waiting_events.data()));
+      command_list, to_u32(ranges.size()), range_sizes.data(), ranges.data(),
+      signaling_event, to_u32(waiting_events.size()), waiting_events.data()));
 
   for (auto &ev : waiting_events) {
     lzt::signal_event_from_host(ev);
@@ -233,7 +235,7 @@ void RunAppendingMemoryRangesBarrierWaitEvents(bool isImmediate) {
   auto wait_events_initial = waiting_events;
   AppendMemoryRangesBarrierTest(context, device, bundle.list, nullptr,
                                 waiting_events);
-  for (int i = 0; i < waiting_events.size(); i++) {
+  for (size_t i = 0U; i < waiting_events.size(); i++) {
     ASSERT_EQ(waiting_events[i], wait_events_initial[i]);
   }
   ep.destroy_events(waiting_events);
@@ -427,7 +429,7 @@ void RunEventSignaledWhenAppendingMemoryRangesBarrierThenHostDetectsEvent(
                   ZE_EVENT_SCOPE_FLAG_HOST);
   lzt::append_memory_copy(bundle.list, dev_mem, inpa.data(), xfer_size,
                           nullptr);
-  lzt::append_memory_ranges_barrier(bundle.list, ranges.size(),
+  lzt::append_memory_ranges_barrier(bundle.list, to_u32(ranges.size()),
                                     range_sizes.data(), ranges.data(),
                                     event_barrier_to_host, 0, nullptr);
   lzt::append_memory_copy(bundle.list, host_mem, dev_mem, xfer_size, nullptr);
@@ -484,7 +486,7 @@ void RunAppendingMemoryRangesBarrierWaitsForEventsWhenHostAndSendSignals(
   lzt::append_memory_copy(bundle.list, dev_mem, inpa.data(), xfer_size,
                           nullptr);
   lzt::append_signal_event(bundle.list, events_to_barrier[1]);
-  lzt::append_memory_ranges_barrier(bundle.list, ranges.size(),
+  lzt::append_memory_ranges_barrier(bundle.list, to_u32(ranges.size()),
                                     range_sizes.data(), ranges.data(), nullptr,
                                     num_events, events_to_barrier.data());
   lzt::append_memory_copy(bundle.list, host_mem, dev_mem, xfer_size, nullptr);
@@ -546,7 +548,7 @@ LZT_TEST_P(
   auto bundle = lzt::create_command_bundle(
       context, device, 0, ZE_COMMAND_QUEUE_MODE_DEFAULT,
       ZE_COMMAND_QUEUE_PRIORITY_NORMAL, 0, 0, 0, isImmediate);
-  size_t num_int = 1000;
+  uint32_t num_int = 1000;
   void *dev_buff = lzt::allocate_device_memory((num_int * sizeof(int)), 1, 0, 0,
                                                device, context);
   void *host_buff =
@@ -559,7 +561,7 @@ LZT_TEST_P(
   const int addval_1 = -100;
   const int val_1 = 50000;
   int val = val_1;
-  for (size_t i = 0; i < num_int; i++) {
+  for (uint32_t i = 0; i < num_int; i++) {
     p_host[i] = val;
     val += addval_1;
   }
@@ -616,7 +618,7 @@ LZT_TEST_P(
     const std::vector<size_t> range_sizes{num_int * sizeof(int),
                                           num_int * sizeof(int)};
     std::vector<const void *> ranges{dev_buff, host_buff};
-    lzt::append_memory_ranges_barrier(bundle.list, ranges.size(),
+    lzt::append_memory_ranges_barrier(bundle.list, to_u32(ranges.size()),
                                       range_sizes.data(), ranges.data(),
                                       nullptr, 0, nullptr);
   } else if (barrier_type == BT_GLOBAL_BARRIER) {
@@ -640,7 +642,7 @@ LZT_TEST_P(
   lzt::close_command_list(bundle.list);
   lzt::execute_and_sync_command_bundle(bundle, UINT64_MAX);
   val = (2 * val_1) + addval_2;
-  for (size_t i = 0; i < num_int; i++) {
+  for (uint32_t i = 0; i < num_int; i++) {
     EXPECT_EQ(p_host[i], val);
     val += (2 * addval_1);
   }

conformance_tests/core/test_cmdlist/src/test_cmdlist.cpp

@@ -22,6 +22,10 @@ namespace lzt = level_zero_tests;
 
 namespace {
 
+using lzt::to_int;
+using lzt::to_u32;
+using lzt::to_u8;
+
 using cmdListVec = std::vector<ze_command_list_handle_t>;
 using cmdQueueVec = std::vector<ze_command_queue_handle_t>;
 
@@ -158,7 +162,7 @@ class zeCommandListResetTests : public ::testing::Test {
     lzt::append_barrier(bundle.list);
 
     uint8_t pattern = 0xAA;
-    int pattern_size = 1;
+    size_t pattern_size = 1;
     auto memory_fill_mem = lzt::allocate_shared_memory(size);
     memset(memory_fill_mem, 0, size);
     lzt::append_memory_fill(bundle.list, memory_fill_mem, &pattern,
@@ -186,7 +190,7 @@ class zeCommandListResetTests : public ::testing::Test {
     ze_kernel_handle_t kernel =
         lzt::create_function(module, "cmdlist_add_constant");
     lzt::set_group_size(kernel, 1, 1, 1);
-    ze_group_count_t args = {static_cast<uint32_t>(size), 1, 1};
+    ze_group_count_t args = {to_u32(size), 1, 1};
 
     const int addval = 10;
     auto kernel_buffer = lzt::allocate_shared_memory(size * sizeof(int));
@@ -231,12 +235,12 @@ class zeCommandListResetTests : public ::testing::Test {
     if (execute_all_commands || is_immediate) {
       lzt::validate_data_pattern(host_mem, size, 1);
       if (lzt::image_support()) {
-        EXPECT_EQ(0, compare_data_pattern(*dest_host_image_ptr,
-                                          img_ptr->dflt_host_image_, 0, 0,
-                                          img_ptr->dflt_host_image_.width(),
-                                          img_ptr->dflt_host_image_.height(), 0,
-                                          0, img_ptr->dflt_host_image_.width(),
-                                          img_ptr->dflt_host_image_.height()));
+        EXPECT_EQ(0, compare_data_pattern(
+                         *dest_host_image_ptr, img_ptr->dflt_host_image_, 0U,
+                         0U, img_ptr->dflt_host_image_.width(),
+                         img_ptr->dflt_host_image_.height(), 0U, 0U,
+                         img_ptr->dflt_host_image_.width(),
+                         img_ptr->dflt_host_image_.height()));
         delete img_ptr;
         delete dest_host_image_ptr;
       }
@@ -252,12 +256,12 @@ class zeCommandListResetTests : public ::testing::Test {
         EXPECT_EQ(static_cast<uint8_t *>(memory_fill_mem)[i], 0);
       }
       if (lzt::image_support()) {
-        EXPECT_NE(0, compare_data_pattern(*dest_host_image_ptr,
-                                          img_ptr->dflt_host_image_, 0, 0,
-                                          img_ptr->dflt_host_image_.width(),
-                                          img_ptr->dflt_host_image_.height(), 0,
-                                          0, img_ptr->dflt_host_image_.width(),
-                                          img_ptr->dflt_host_image_.height()));
+        EXPECT_NE(0, compare_data_pattern(
+                         *dest_host_image_ptr, img_ptr->dflt_host_image_, 0U,
+                         0U, img_ptr->dflt_host_image_.width(),
+                         img_ptr->dflt_host_image_.height(), 0U, 0U,
+                         img_ptr->dflt_host_image_.width(),
+                         img_ptr->dflt_host_image_.height()));
         delete img_ptr;
         delete dest_host_image_ptr;
       }
@@ -343,17 +347,17 @@ LZT_TEST(zeCommandListReuseTests,
   lzt::append_memory_copy(cmdlist_mem_zero, host_buffer, device_buffer, size);
   lzt::close_command_list(cmdlist_mem_zero);
 
-  const int num_execute = 5;
-  for (int i = 0; i < num_execute; i++) {
+  const uint32_t num_execute = 5;
+  for (uint32_t i = 0U; i < num_execute; i++) {
     lzt::execute_command_lists(cmdq, 1, &cmdlist_mem_zero, nullptr);
     lzt::synchronize(cmdq, UINT64_MAX);
-    for (int j = 0; j < size; j++)
+    for (size_t j = 0U; j < size; j++)
       ASSERT_EQ(static_cast<uint8_t *>(host_buffer)[j], 0x0)
           << "Memory Set did not match.";
 
     lzt::execute_command_lists(cmdq, 1, &cmdlist_mem_set, nullptr);
     lzt::synchronize(cmdq, UINT64_MAX);
-    for (int j = 0; j < size; j++)
+    for (size_t j = 0U; j < size; j++)
       ASSERT_EQ(static_cast<uint8_t *>(host_buffer)[j], 0x1)
           << "Memory Set did not match.";
   }
@@ -447,7 +451,7 @@ void RunWhenResetThenVerifyOnlySubsequentInstructionsExecuted(
   std::vector<uint8_t> val;
   for (size_t i = 0; i < num_instr; i++) {
     buffer.push_back(lzt::allocate_shared_memory(size));
-    val.push_back(static_cast<uint8_t>(i + 1));
+    val.push_back(to_u8(i + 1));
   }
 
   // Begin with num_instr command list instructions, reset and reduce by one
@@ -525,7 +529,7 @@ LZT_TEST_P(zeCommandListFlagTests,
   auto host_memory = lzt::allocate_host_memory(size);
   auto device = lzt::zeDevice::get_instance()->get_device();
   uint8_t pattern = 0xAB;
-  const int pattern_size = 1;
+  const size_t pattern_size = 1;
   ze_command_list_flags_t flags = std::get<0>(GetParam());
   bool is_immediate = std::get<1>(GetParam());
   auto cmd_bundle = lzt::create_command_bundle(device, flags, is_immediate);
@@ -597,7 +601,7 @@ RunGivenCommandListWithMultipleAppendMemoryCopiesFollowedByResetInLoopTest(
     temp1 = static_cast<uint8_t *>(host_memory_src);
     temp2 = static_cast<uint8_t *>(host_memory_dst);
     for (uint32_t i = 0; i < max_copy_count; i++) {
-      temp1[i] = i;
+      temp1[i] = to_u8(i);
       temp2[i] = 0;
     }
     for (uint32_t i = 0; i < max_copy_count; i++) {
@@ -635,7 +639,7 @@ LZT_TEST(
     zeCommandListAppendMemoryCopyTest,
     GivenCommandListWithMultipleAppendMemoryCopiesFollowedByResetInLoopThenSuccessIsReturnedWithSharedSystemAllocator) {
   SKIP_IF_SHARED_SYSTEM_ALLOC_UNSUPPORTED();
-  for (int i = 1; i < 4; ++i) {
+  for (uint32_t i = 1; i < 4; ++i) {
     std::bitset<2> bits(i);
     RunGivenCommandListWithMultipleAppendMemoryCopiesFollowedByResetInLoopTest(
         bits[1], bits[0]);
@@ -722,7 +726,7 @@ RunGivenTwoCommandQueuesHavingCommandListsWithScratchSpaceThenSuccessIsReturnedT
       size, is_shared_system_dst);
 
   uint8_t pattern = 0xAB;
-  const int pattern_size = 1;
+  const size_t pattern_size = 1;
   uint32_t num_iterations = 2;
 
   auto context = lzt::get_default_context();
@@ -765,7 +769,8 @@ RunGivenTwoCommandQueuesHavingCommandListsWithScratchSpaceThenSuccessIsReturnedT
                           &offsetBuffer);
   // if groupSize is greater then memory count, then at least one thread group
   // should be dispatched
-  uint32_t threadGroup = arraySize / groupSize > 1 ? arraySize / groupSize : 1;
+  uint32_t threadGroup =
+      arraySize / groupSize > 1 ? to_u32(arraySize / groupSize) : 1;
   ze_group_count_t thread_group_dimensions = {threadGroup, 1, 1};
 
   for (uint32_t i = 0; i < num_iterations; i++) {
@@ -863,7 +868,7 @@ LZT_TEST(
     zeCommandListAppendMemoryCopyTest,
     GivenTwoCommandQueuesHavingCommandListsWithScratchSpaceThenSuccessIsReturnedWithSharedSystemAllocator) {
   SKIP_IF_SHARED_SYSTEM_ALLOC_UNSUPPORTED();
-  for (int i = 1; i < 8; ++i) {
+  for (uint32_t i = 1; i < 8; ++i) {
     std::bitset<3> bits(i);
     RunGivenTwoCommandQueuesHavingCommandListsWithScratchSpaceThenSuccessIsReturnedTest(
         bits[2], bits[1], bits[0]);
@@ -930,11 +935,12 @@ class zeCommandListEventCounterTests : public lzt::zeEventPoolTests {
 };
 
 static void RunAppendLaunchKernelEvent(cmdListVec cmdlist, cmdQueueVec cmdqueue,
-                                       ze_event_handle_t event, int num_cmdlist,
-                                       void *buffer, const size_t size) {
+                                       ze_event_handle_t event,
+                                       size_t num_cmdlist, void *buffer,
+                                       const size_t size) {
 
   const int addval = 10;
-  const int num_iterations = 100;
+  const uint32_t num_iterations = 100;
   int addval2 = 0;
   const uint64_t timeout = UINT64_MAX - 1;
 
@@ -949,28 +955,28 @@ static void RunAppendLaunchKernelEvent(cmdListVec cmdlist, cmdQueueVec cmdqueue,
 
   memset(buffer, 0x0, num_cmdlist * size * sizeof(int));
 
-  for (int n = 0; n < num_cmdlist; n++) {
+  for (size_t n = 0; n < num_cmdlist; n++) {
     int *p_dev = static_cast<int *>(buffer);
     p_dev += (n * size);
     lzt::set_argument_value(kernel, 0, sizeof(p_dev), &p_dev);
     lzt::set_argument_value(kernel, 1, sizeof(addval), &addval);
     ze_group_count_t tg;
-    tg.groupCountX = static_cast<uint32_t>(size);
+    tg.groupCountX = to_u32(size);
     tg.groupCountY = 1;
     tg.groupCountZ = 1;
 
     lzt::append_launch_function(cmdlist[n], kernel, &tg, nullptr, 0, nullptr);
 
     totalVal[n] = 0;
-    for (int i = 0; i < (num_iterations - 1); i++) {
+    for (uint32_t i = 0; i < (num_iterations - 1); i++) {
       addval2 = lzt::generate_value<int>() & 0xFFFF;
       totalVal[n] += addval2;
       lzt::set_argument_value(kernel, 1, sizeof(addval2), &addval2);
 
       lzt::append_launch_function(cmdlist[n], kernel, &tg, nullptr, 0, nullptr);
     }
     addval2 = lzt::generate_value<int>() & 0xFFFF;
-    ;
+
     totalVal[n] += addval2;
     lzt::set_argument_value(kernel, 1, sizeof(addval2), &addval2);
     if (n == 0) {
@@ -985,7 +991,7 @@ static void RunAppendLaunchKernelEvent(cmdListVec cmdlist, cmdQueueVec cmdqueue,
 
   EXPECT_ZE_RESULT_SUCCESS(zeEventHostSynchronize(event, timeout));
 
-  for (int n = 0; n < num_cmdlist; n++) {
+  for (uint32_t n = 0; n < num_cmdlist; n++) {
     for (size_t i = 0; i < size; i++) {
       EXPECT_EQ(static_cast<int *>(buffer)[(n * size) + i],
                 (addval + totalVal[n]));
@@ -999,7 +1005,7 @@ static void RunAppendLaunchKernelEvent(cmdListVec cmdlist, cmdQueueVec cmdqueue,
 static void RunAppendLaunchKernelEventL0SharedAlloc(cmdListVec cmdlist,
                                                     cmdQueueVec cmdqueue,
                                                     ze_event_handle_t event,
-                                                    int num_cmdlist,
+                                                    size_t num_cmdlist,
                                                     const size_t size) {
   void *buffer = lzt::allocate_shared_memory(num_cmdlist * size * sizeof(int));
   RunAppendLaunchKernelEvent(cmdlist, cmdqueue, event, num_cmdlist, buffer,
@@ -1010,7 +1016,7 @@ static void RunAppendLaunchKernelEventL0SharedAlloc(cmdListVec cmdlist,
 static void RunAppendLaunchKernelEventHostMalloc(cmdListVec cmdlist,
                                                  cmdQueueVec cmdqueue,
                                                  ze_event_handle_t event,
-                                                 int num_cmdlist,
+                                                 size_t num_cmdlist,
                                                  const size_t size) {
   void *buffer = malloc(num_cmdlist * size * sizeof(int));
   ASSERT_NE(nullptr, buffer);
@@ -1022,7 +1028,7 @@ static void RunAppendLaunchKernelEventHostMalloc(cmdListVec cmdlist,
 static void RunAppendLaunchKernelEventHostNew(cmdListVec cmdlist,
                                               cmdQueueVec cmdqueue,
                                               ze_event_handle_t event,
-                                              int num_cmdlist,
+                                              size_t num_cmdlist,
                                               const size_t size) {
   int *buffer = new int[num_cmdlist * size];
   ASSERT_NE(nullptr, buffer);
@@ -1034,7 +1040,7 @@ static void RunAppendLaunchKernelEventHostNew(cmdListVec cmdlist,
 static void RunAppendLaunchKernelEventHostUniquePtr(cmdListVec cmdlist,
                                                     cmdQueueVec cmdqueue,
                                                     ze_event_handle_t event,
-                                                    int num_cmdlist,
+                                                    size_t num_cmdlist,
                                                     const size_t size) {
   std::unique_ptr<int[]> buffer(new int[num_cmdlist * size]);
   ASSERT_NE(nullptr, buffer);
@@ -1045,7 +1051,7 @@ static void RunAppendLaunchKernelEventHostUniquePtr(cmdListVec cmdlist,
 static void RunAppendLaunchKernelEventHostSharedPtr(cmdListVec cmdlist,
                                                     cmdQueueVec cmdqueue,
                                                     ze_event_handle_t event,
-                                                    int num_cmdlist,
+                                                    size_t num_cmdlist,
                                                     const size_t size) {
   std::shared_ptr<int[]> buffer(new int[num_cmdlist * size]);
   ASSERT_NE(nullptr, buffer);
@@ -1054,7 +1060,7 @@ static void RunAppendLaunchKernelEventHostSharedPtr(cmdListVec cmdlist,
 }
 
 typedef void (*RunAppendLaunchKernelEventFunc)(cmdListVec, cmdQueueVec,
-                                               ze_event_handle_t, int,
+                                               ze_event_handle_t, size_t,
                                                const size_t);
 
 static void
@@ -1068,7 +1074,7 @@ RunAppendLaunchKernelEventLoop(cmdListVec cmdlist, cmdQueueVec cmdqueue,
   }
 
   constexpr size_t size = 16;
-  for (int i = 1; i <= cmdlist.size(); i++) {
+  for (size_t i = 1; i <= cmdlist.size(); i++) {
     LOG_INFO << "Testing " << i << " command list(s)";
     func(cmdlist, cmdqueue, event, i, size);
   }