clang-format

Author: uditagarwal97

sycl/source/detail/error_handling/error_handling.hpp

@@ -31,8 +31,7 @@ void handleErrorOrWarning(ur_result_t, const device_impl &, ur_kernel_handle_t,
 
 namespace kernel_get_group_info {
 /// Analyzes error code of urKernelGetGroupInfo.
-void handleErrorOrWarning(ur_result_t, ur_kernel_group_info_t,
-                          adapter_impl &);
+void handleErrorOrWarning(ur_result_t, ur_kernel_group_info_t, adapter_impl &);
 } // namespace kernel_get_group_info
 
 } // namespace detail

sycl/source/detail/kernel_impl.hpp

@@ -76,7 +76,7 @@ class kernel_impl {
   cl_kernel get() const {
     ur_native_handle_t nativeHandle = 0;
     getAdapter().call<UrApiKind::urKernelGetNativeHandle>(MKernel,
-                                                           &nativeHandle);
+                                                          &nativeHandle);
     __SYCL_OCL_CALL(clRetainKernel, ur::cast<cl_kernel>(nativeHandle));
     return ur::cast<cl_kernel>(nativeHandle);
   }
@@ -373,10 +373,11 @@ kernel_impl::queryMaxNumWorkGroups(queue Queue,
     WG[2] = WorkGroupSize[2];
 
   uint32_t GroupCount{0};
-  if (auto Result = Adapter.call_nocheck<
-                    UrApiKind::urKernelSuggestMaxCooperativeGroupCount>(
-          Handle, DeviceHandleRef, Dimensions, WG, DynamicLocalMemorySize,
-          &GroupCount);
+  if (auto Result =
+          Adapter
+              .call_nocheck<UrApiKind::urKernelSuggestMaxCooperativeGroupCount>(
+                  Handle, DeviceHandleRef, Dimensions, WG,
+                  DynamicLocalMemorySize, &GroupCount);
       Result != UR_RESULT_ERROR_UNSUPPORTED_FEATURE &&
       Result != UR_RESULT_ERROR_INVALID_WORK_GROUP_SIZE) {
     // The feature is supported and the group size is valid. Check for other
@@ -513,8 +514,8 @@ ADD_TEMPLATE_METHOD_SPEC(3)
         getSyclObjImpl(Queue.get_device())->getHandleRef();                    \
     uint32_t KernelSubWGSize = 0;                                              \
     Adapter.call<UrApiKind::Kind>(MKernel, DeviceNativeHandle, Reg,            \
-                                   sizeof(uint32_t), &KernelSubWGSize,         \
-                                   nullptr);                                   \
+                                  sizeof(uint32_t), &KernelSubWGSize,          \
+                                  nullptr);                                    \
     return KernelSubWGSize;                                                    \
   }
 

sycl/source/detail/kernel_info.hpp

@@ -52,14 +52,14 @@ get_kernel_info(ur_kernel_handle_t Kernel, adapter_impl &Adapter) {
 
   // TODO catch an exception and put it to list of asynchronous exceptions
   Adapter.call<UrApiKind::urKernelGetInfo>(Kernel, UrInfoCode<Param>::value, 0,
-                                            nullptr, &ResultSize);
+                                           nullptr, &ResultSize);
   if (ResultSize == 0) {
     return "";
   }
   std::vector<char> Result(ResultSize);
   // TODO catch an exception and put it to list of asynchronous exceptions
   Adapter.call<UrApiKind::urKernelGetInfo>(Kernel, UrInfoCode<Param>::value,
-                                            ResultSize, Result.data(), nullptr);
+                                           ResultSize, Result.data(), nullptr);
   return std::string(Result.data());
 }
 
@@ -71,7 +71,7 @@ get_kernel_info(ur_kernel_handle_t Kernel, adapter_impl &Adapter) {
 
   // TODO catch an exception and put it to list of asynchronous exceptions
   Adapter.call<UrApiKind::urKernelGetInfo>(Kernel, UrInfoCode<Param>::value,
-                                            sizeof(uint32_t), &Result, nullptr);
+                                           sizeof(uint32_t), &Result, nullptr);
   return Result;
 }
 
@@ -92,7 +92,7 @@ get_kernel_device_specific_info_helper(
     ur_kernel_handle_t Kernel, [[maybe_unused]] ur_device_handle_t Device,
     adapter_impl &Adapter, void *Result, size_t Size) {
   Adapter.call<UrApiKind::urKernelGetInfo>(Kernel, UrInfoCode<Param>::value,
-                                            Size, Result, nullptr);
+                                           Size, Result, nullptr);
 }
 
 template <typename Param>
@@ -188,18 +188,18 @@ get_kernel_device_specific_info<
 
   ur_program_handle_t Program;
   Adapter.call<UrApiKind::urKernelGetInfo>(Kernel, UR_KERNEL_INFO_PROGRAM,
-                                            sizeof(ur_program_handle_t),
-                                            &Program, nullptr);
+                                           sizeof(ur_program_handle_t),
+                                           &Program, nullptr);
   // Retrieve the associated device list
   size_t URDevicesSize = 0;
-  Adapter.call<UrApiKind::urProgramGetInfo>(Program, UR_PROGRAM_INFO_DEVICES,
-                                             0, nullptr, &URDevicesSize);
+  Adapter.call<UrApiKind::urProgramGetInfo>(Program, UR_PROGRAM_INFO_DEVICES, 0,
+                                            nullptr, &URDevicesSize);
 
   std::vector<ur_device_handle_t> URDevices(URDevicesSize /
                                             sizeof(ur_device_handle_t));
   Adapter.call<UrApiKind::urProgramGetInfo>(Program, UR_PROGRAM_INFO_DEVICES,
-                                             URDevicesSize, URDevices.data(),
-                                             nullptr);
+                                            URDevicesSize, URDevices.data(),
+                                            nullptr);
   assert(Device2SpillMap.size() == URDevices.size());
 
   // Map the result back to the program devices. UR provides the following