formatting

Author: reble

sycl/source/detail/graph/graph_impl.cpp

@@ -1026,8 +1026,8 @@ EventImplPtr exec_graph_impl::enqueuePartitionDirectly(
 
   if (!EventNeeded) {
     Queue.getAdapter().call<sycl::detail::UrApiKind::urEnqueueCommandBufferExp>(
-            Queue.getHandleRef(), Partition->MCommandBuffer,
-            UrEnqueueWaitListSize, UrEnqueueWaitList, nullptr);
+        Queue.getHandleRef(), Partition->MCommandBuffer, UrEnqueueWaitListSize,
+        UrEnqueueWaitList, nullptr);
     return nullptr;
   } else {
     auto NewEvent = sycl::detail::event_impl::create_device_event(Queue);
@@ -1036,8 +1036,8 @@ EventImplPtr exec_graph_impl::enqueuePartitionDirectly(
     NewEvent->setSubmissionTime();
     ur_event_handle_t UrEvent = nullptr;
     Queue.getAdapter().call<sycl::detail::UrApiKind::urEnqueueCommandBufferExp>(
-            Queue.getHandleRef(), Partition->MCommandBuffer,
-            UrEventHandles.size(), UrEnqueueWaitList, &UrEvent);
+        Queue.getHandleRef(), Partition->MCommandBuffer, UrEventHandles.size(),
+        UrEnqueueWaitList, &UrEvent);
     NewEvent->setHandle(UrEvent);
     NewEvent->setEventFromSubmittedExecCommandBuffer(true);
     return NewEvent;

sycl/source/detail/handler_impl.hpp

@@ -204,7 +204,7 @@ class handler_impl {
 
   /// If we are submitting a graph using ext_oneapi_graph this will be the graph
   /// to be executed.
-  ext::oneapi::experimental::detail::exec_graph_impl* MExecGraph;
+  ext::oneapi::experimental::detail::exec_graph_impl *MExecGraph;
   /// Storage for the CG created when handling graph nodes added explicitly.
   std::unique_ptr<detail::CG> MGraphNodeCG;
   /// Storage for node dependencies passed when adding a graph node explicitly

sycl/source/detail/queue_impl.hpp

@@ -276,7 +276,8 @@ class queue_impl : public std::enable_shared_from_this<queue_impl> {
     ur_native_handle_t nativeHandle = 0;
     getAdapter().call<UrApiKind::urQueueGetNativeHandle>(MQueue, nullptr,
                                                          &nativeHandle);
-    __SYCL_OCL_CALL(clRetainCommandQueue, ur::cast<cl_command_queue>(nativeHandle));
+    __SYCL_OCL_CALL(clRetainCommandQueue,
+                    ur::cast<cl_command_queue>(nativeHandle));
     return ur::cast<cl_command_queue>(nativeHandle);
   }
 
@@ -1052,9 +1053,7 @@ class queue_impl : public std::enable_shared_from_this<queue_impl> {
     }
 
     // To use when the queue is already acquired a mutex lock.
-    DataType read_unlocked() {
-      return MData;
-    }
+    DataType read_unlocked() { return MData; }
   };
 
   const bool MIsInorder;

sycl/source/handler.cpp

@@ -483,8 +483,7 @@ event handler::finalize() {
   // According to 4.7.6.9 of SYCL2020 spec, if a placeholder accessor is passed
   // to a command without being bound to a command group, an exception should
   // be thrown.
-  if (!IsGraphEnqueue)
-  {
+  if (!IsGraphEnqueue) {
     for (const auto &arg : impl->MArgs) {
       if (arg.MType != detail::kernel_param_kind_t::kind_accessor)
         continue;
@@ -585,8 +584,8 @@ event handler::finalize() {
       // the graph is not changed, then this faster path is used to submit
       // kernel bypassing scheduler and avoiding CommandGroup, Command objects
       // creation.
-      std::vector<ur_event_handle_t> RawEvents = detail::Command::getUrEvents(
-          impl->CGData.MEvents, Queue, false);
+      std::vector<ur_event_handle_t> RawEvents =
+          detail::Command::getUrEvents(impl->CGData.MEvents, Queue, false);
 
       bool DiscardEvent =
           !impl->MEventNeeded && impl->get_queue().supportsDiscardingPiEvents();
@@ -616,9 +615,8 @@ event handler::finalize() {
           StreamID = xptiRegisterStream(detail::SYCL_STREAM_NAME);
           std::tie(CmdTraceEvent, InstanceID) = emitKernelInstrumentationData(
               StreamID, MKernel, MCodeLoc, impl->MIsTopCodeLoc,
-              MKernelName.data(), impl->MKernelNameBasedCachePtr,
-              Queue, impl->MNDRDesc, KernelBundleImpPtr,
-              impl->MArgs);
+              MKernelName.data(), impl->MKernelNameBasedCachePtr, Queue,
+              impl->MNDRDesc, KernelBundleImpPtr, impl->MArgs);
           detail::emitInstrumentationGeneral(StreamID, InstanceID,
                                              CmdTraceEvent,
                                              xpti::trace_task_begin, nullptr);
@@ -816,7 +814,8 @@ event handler::finalize() {
       // pass the exec_graph_impl and event dependencies. Since this subgraph CG
       // will not be executed this is fine.
       CommandGroup.reset(new sycl::detail::CGExecCommandBuffer(
-          nullptr, impl->MExecGraph->shared_from_this(), std::move(impl->CGData)));
+          nullptr, impl->MExecGraph->shared_from_this(),
+          std::move(impl->CGData)));
 
     } else {
       bool DiscardEvent = !impl->MEventNeeded &&

sycl/test-e2e/Graph/RecordReplay/ext_oneapi_enqueue_functions.cpp

@@ -15,8 +15,6 @@ int main() {
 
   using namespace std::chrono;
 
-
-
   queue InOrderQueue{property::queue::in_order{}};
 
   using T = int;
@@ -65,8 +63,6 @@ int main() {
   free(PtrB, InOrderQueue);
   free(PtrC, InOrderQueue);
 
-
-
   for (size_t i = 0; i < Size; i++) {
     T Ref = Pattern * i;
     assert(check_value(i, Ref, Output[i], "Output"));

sycl/unittests/scheduler/InOrderQueueSyncCheck.cpp

@@ -61,7 +61,7 @@ class LimitedHandler {
     handler_impl(std::shared_ptr<MockQueueImpl> Queue) : MQueue(Queue) {}
     std::shared_ptr<MockQueueImpl> MQueue;
     MockQueueImpl &get_queue() { return *MQueue; }
-    ext::oneapi::experimental::detail::exec_graph_impl* MExecGraph;
+    ext::oneapi::experimental::detail::exec_graph_impl *MExecGraph;
   };
   std::shared_ptr<handler_impl> impl;
   std::shared_ptr<detail::kernel_impl> MKernel;