cleanup2

Author: EuphoricThinking

unified-runtime/source/adapters/level_zero/v2/command_list_manager.cpp

@@ -94,8 +94,6 @@ wait_list_view::wait_list_view(const ur_event_handle_t *phWaitEvents,
 // At most one additional event might be added after creating the given waitlist
 void wait_list_view::addEvent(ur_event_handle_t Event) {
   if (Event) {
-    // printf("I have an event\n");
-    // Event->onWaitListUse();
     if (handles) {
       assert(num != max_size);
       handles[num] = Event->getZeEvent();
@@ -839,14 +837,12 @@ ur_result_t ur_command_list_manager::appendUSMAllocHelper(
   auto asyncAlloc = pPool->allocateEnqueued(hContext.get(), Queue, true, device,
                                             nullptr, type, size);
   if (!asyncAlloc) {
-    // printf("not async\n");
     auto Ret =
         pPool->allocate(hContext.get(), device, nullptr, type, size, ppMem);
     if (Ret) {
       return Ret;
     }
   } else {
-    // printf("async\n");
     std::tie(*ppMem, originAllocEvent) = *asyncAlloc;
   }
 

unified-runtime/source/adapters/level_zero/v2/queue_batched.cpp

@@ -71,7 +71,7 @@ ur_queue_batched_t::ur_queue_batched_t(
                          .borrow(hDevice->Id.value(), v2::EVENT_FLAGS_COUNTER);
 
   eventPoolImmediate = hContext->getEventPoolCache(PoolCacheType::Immediate)
-                    .borrow(hDevice->Id.value(), eventFlags);
+                           .borrow(hDevice->Id.value(), eventFlags);
 }
 
 ur_event_handle_t ur_queue_batched_t::createEventIfRequestedRegular(
@@ -862,7 +862,7 @@ ur_result_t ur_queue_batched_t::enqueueUSMHostAllocExp(
   //     createEventIfRequestedRegular(phEvent,
   //                                   lockedBatch->getCurrentGeneration()),
   //     UR_USM_TYPE_HOST);
-  
+
   UR_CALL(lockedBatch->getActiveBatch().appendUSMAllocHelper(
       this, pPool, size, pProperties, waitListView, ppMem,
       createEventIfRequestedRegular(phEvent,

unified-runtime/source/adapters/level_zero/v2/queue_batched.hpp

@@ -108,7 +108,7 @@ struct batch_manager {
 
   ur_command_list_manager &getActiveBatch() { return activeBatch; }
 
-  ur_command_list_manager &getImmediateManager() {return immediateList; }
+  ur_command_list_manager &getImmediateManager() { return immediateList; }
 
   ur_event_generation_t getCurrentGeneration() {
     return regularGenerationNumber;

unified-runtime/test/adapters/level_zero/enqueue_alloc.cpp

@@ -352,7 +352,6 @@ TEST_P(urL0EnqueueAllocMultiQueueSameDeviceTest, SuccessMt) {
       std::get<1>(this->GetParam()).funcParams.enqueueUSMAllocFunc;
   const auto checkUSMSupportFunc =
       std::get<1>(this->GetParam()).funcParams.checkUSMSupportFunc;
-      // std::cout << enqueueUSMAllocFunc << std::endl;;
 
   ur_device_usm_access_capability_flags_t USMSupport = 0;
   ASSERT_SUCCESS(checkUSMSupportFunc(device, USMSupport));
@@ -366,37 +365,27 @@ TEST_P(urL0EnqueueAllocMultiQueueSameDeviceTest, SuccessMt) {
     threads.emplace_back([&, idx, iterations] {
       std::vector<void *> ptrs(iterations);
       for (size_t i = 0; i < iterations; i++) {
-        // printf("bef\n");
-        ASSERT_SUCCESS(
-        enqueueUSMAllocFunc(queues[idx], nullptr, allocSize,
+        ASSERT_SUCCESS(enqueueUSMAllocFunc(queues[idx], nullptr, allocSize,
                                            nullptr, 0, nullptr, &ptrs[i],
-                                           nullptr)
-        );
+                                           nullptr));
         ASSERT_NE(ptrs[i], nullptr);
       }
 
       ASSERT_SUCCESS(urQueueFinish(queues[idx]));
-      // printf("here4\n");
 
       uint8_t fillPattern = 0xAF;
       for (size_t i = 0; i < iterations; i++) {
-        ASSERT_SUCCESS(
-          urEnqueueUSMFill(queues[idx], ptrs[i], 1, &fillPattern,
-                                        allocSize, 0, nullptr, nullptr)
-                                      );
+        ASSERT_SUCCESS(urEnqueueUSMFill(queues[idx], ptrs[i], 1, &fillPattern,
+                                        allocSize, 0, nullptr, nullptr));
       }
-// printf("here3\n");
+
       ASSERT_SUCCESS(urQueueFinish(queues[idx]));
-      // printf("here2\n");
 
       for (size_t i = 0; i < iterations; i++) {
-        // THIS
-        // printf("here\n");
-        ASSERT_SUCCESS(
-          urEnqueueUSMFreeExp(queues[idx], nullptr, ptrs[i], 0,
-                                           nullptr, nullptr)
-                                          );
+        ASSERT_SUCCESS(urEnqueueUSMFreeExp(queues[idx], nullptr, ptrs[i], 0,
+                                           nullptr, nullptr));
       }
+
       ASSERT_SUCCESS(urQueueFinish(queues[idx]));
     });
   }