clang-format

Author: szymon-zadworny

oneapi-rs-sys/include/event.hpp

@@ -20,7 +20,8 @@ enum class EventCommandStatus : std::uint8_t;
 
 namespace sycl_shims::event {
 void wait(std::unique_ptr<Event> &);
-void register_callback(std::unique_ptr<Queue> &, Event const &, rust::Box<Waker>);
+void register_callback(std::unique_ptr<Queue> &, Event const &,
+                       rust::Box<Waker>);
 EventCommandStatus get_command_execution_status(Event const &);
 std::unique_ptr<Event> clone(Event const &);
 } // namespace sycl_shims::event

oneapi-rs-sys/include/platform.hpp

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "rust/cxx.h"
 #include "oneapi-rs-sys/include/types.hpp"
+#include "rust/cxx.h"
 
 #include <sycl/sycl.hpp>
 
@@ -23,8 +23,8 @@ struct PlatformPtr;
 
 namespace sycl_shims::platform {
 rust::Vec<PlatformPtr> get_platforms();
-rust::Vec<DevicePtr> get_devices(Platform const&);
-rust::String get_version(Platform const&);
-rust::String get_name(Platform const&);
-rust::String get_vendor(Platform const&);
+rust::Vec<DevicePtr> get_devices(Platform const &);
+rust::String get_version(Platform const &);
+rust::String get_name(Platform const &);
+rust::String get_vendor(Platform const &);
 } // namespace sycl_shims::platform

oneapi-rs-sys/include/queue.hpp

@@ -22,13 +22,9 @@ std::unique_ptr<Queue> new_queue();
 std::unique_ptr<Queue> new_queue_immediate();
 std::unique_ptr<Queue> new_queue_from_device(Device const &);
 std::unique_ptr<Queue> clone(Queue const &);
-std::unique_ptr<Event> memset(
-  std::unique_ptr<Queue> &,
-  std::uint8_t * ptr,
-  int value,
-  std::size_t num_bytes,
-  rust::Vec<EventPtr>
-);
+std::unique_ptr<Event> memset(std::unique_ptr<Queue> &, std::uint8_t *ptr,
+                              int value, std::size_t num_bytes,
+                              rust::Vec<EventPtr>);
 std::unique_ptr<Event> barrier(std::unique_ptr<Queue> &, rust::Vec<EventPtr>);
 void wait(std::unique_ptr<Queue> &);
 } // namespace sycl_shims::queue

oneapi-rs-sys/include/types.hpp

@@ -15,4 +15,4 @@ using Device = sycl::device;
 using Platform = sycl::platform;
 using Queue = sycl::queue;
 using Event = sycl::event;
-}
+} // namespace sycl_shims

oneapi-rs-sys/include/usm.hpp

@@ -14,8 +14,11 @@
 #include <memory>
 
 namespace sycl_shims::usm {
-std::uint8_t* aligned_alloc_device(std::size_t alignment, std::size_t num_bytes, Queue const &);
-std::uint8_t* aligned_alloc_host(std::size_t alignment, std::size_t num_bytes, Queue const &);
-std::uint8_t* aligned_alloc_shared(std::size_t alignment, std::size_t num_bytes, Queue const &);
-void free(std::uint8_t*, Queue const &);
+std::uint8_t *aligned_alloc_device(std::size_t alignment, std::size_t num_bytes,
+                                   Queue const &);
+std::uint8_t *aligned_alloc_host(std::size_t alignment, std::size_t num_bytes,
+                                 Queue const &);
+std::uint8_t *aligned_alloc_shared(std::size_t alignment, std::size_t num_bytes,
+                                   Queue const &);
+void free(std::uint8_t *, Queue const &);
 } // namespace sycl_shims::usm

oneapi-rs-sys/src/event.cpp

@@ -13,27 +13,26 @@ using sycl::info::event_command_status;
 namespace syclintel = sycl::ext::intel;
 
 namespace sycl_shims::event {
-void wait(std::unique_ptr<Event> & event) {
-  event->wait();
-}
-std::unique_ptr<Event> clone(Event const & event) {
+void wait(std::unique_ptr<Event> &event) { event->wait(); }
+std::unique_ptr<Event> clone(Event const &event) {
   return std::make_unique<Event>(sycl::event(event));
 }
-EventCommandStatus get_command_execution_status(Event const & event) {
+EventCommandStatus get_command_execution_status(Event const &event) {
   auto status = event.get_info<sycl::info::event::command_execution_status>();
   switch (status) {
-    case event_command_status::submitted:
-      return EventCommandStatus::Submitted;
-    case event_command_status::running:
-      return EventCommandStatus::Running;
-    case event_command_status::complete:
-      return EventCommandStatus::Complete;
-    default:
-      return EventCommandStatus::Unknown;
+  case event_command_status::submitted:
+    return EventCommandStatus::Submitted;
+  case event_command_status::running:
+    return EventCommandStatus::Running;
+  case event_command_status::complete:
+    return EventCommandStatus::Complete;
+  default:
+    return EventCommandStatus::Unknown;
   }
 }
-void register_callback(std::unique_ptr<Queue> & queue, Event const & event, rust::Box<Waker> waker) {
-  queue->submit([waker = std::move(waker), event](sycl::handler& cgh) {
+void register_callback(std::unique_ptr<Queue> &queue, Event const &event,
+                       rust::Box<Waker> waker) {
+  queue->submit([waker = std::move(waker), event](sycl::handler &cgh) {
     cgh.depends_on(event);
     cgh.host_task([&]() { wake(waker); });
   });

oneapi-rs-sys/src/queue.cpp

@@ -9,46 +9,37 @@
 #include "oneapi-rs-sys/include/queue.hpp"
 #include "oneapi-rs-sys/src/queue-sys.rs.h"
 
-using sycl::property::queue::in_order;
 using sycl::ext::intel::property::queue::immediate_command_list;
+using sycl::property::queue::in_order;
 
 namespace sycl_shims::queue {
 std::unique_ptr<Queue> new_queue() {
-  return std::make_unique<Queue>(sycl::queue({
-    in_order()
-  }));
+  return std::make_unique<Queue>(sycl::queue({in_order()}));
 }
 std::unique_ptr<Queue> new_queue_immediate() {
-  return std::make_unique<Queue>(sycl::queue({
-    in_order(),
-    immediate_command_list()
-  }));
+  return std::make_unique<Queue>(
+      sycl::queue({in_order(), immediate_command_list()}));
 }
-std::unique_ptr<Queue> new_queue_from_device(Device const & device) {
+std::unique_ptr<Queue> new_queue_from_device(Device const &device) {
   return std::make_unique<Queue>(sycl::queue(device, {in_order()}));
 }
-std::unique_ptr<Queue> clone(Queue const & queue) {
+std::unique_ptr<Queue> clone(Queue const &queue) {
   return std::make_unique<Queue>(sycl::queue(queue));
 }
-std::unique_ptr<Event> memset(
-  std::unique_ptr<Queue> & queue,
-  std::uint8_t * ptr,
-  int value,
-  std::size_t num_bytes,
-  rust::Vec<EventPtr> dep_events
-) {
+std::unique_ptr<Event> memset(std::unique_ptr<Queue> &queue, std::uint8_t *ptr,
+                              int value, std::size_t num_bytes,
+                              rust::Vec<EventPtr> dep_events) {
   std::vector<sycl::event> deps;
-  for (auto&& e: dep_events)
+  for (auto &&e : dep_events)
     deps.push_back(std::move(*e.ptr.release()));
   return std::make_unique<Event>(queue->memset(ptr, value, num_bytes, deps));
 }
-std::unique_ptr<Event> barrier(std::unique_ptr<Queue> & queue, rust::Vec<EventPtr> dep_events) {
+std::unique_ptr<Event> barrier(std::unique_ptr<Queue> &queue,
+                               rust::Vec<EventPtr> dep_events) {
   std::vector<sycl::event> deps;
-  for (auto&& e: dep_events)
+  for (auto &&e : dep_events)
     deps.push_back(std::move(*e.ptr.release()));
   return std::make_unique<Event>(queue->ext_oneapi_submit_barrier(deps));
 }
-void wait(std::unique_ptr<Queue> & queue) {
-  queue->wait();
-}
+void wait(std::unique_ptr<Queue> &queue) { queue->wait(); }
 } // namespace sycl_shims::queue

oneapi-rs-sys/src/usm.cpp

@@ -10,19 +10,25 @@
 #include "oneapi-rs-sys/src/usm-sys.rs.h"
 
 namespace sycl_shims::usm {
-std::uint8_t* aligned_alloc_device(std::size_t alignment, std::size_t num_bytes, Queue const & queue) {
-  return static_cast<std::uint8_t*>(sycl::aligned_alloc_device(alignment, num_bytes, queue));
+std::uint8_t *aligned_alloc_device(std::size_t alignment, std::size_t num_bytes,
+                                   Queue const &queue) {
+  return static_cast<std::uint8_t *>(
+      sycl::aligned_alloc_device(alignment, num_bytes, queue));
 }
 
-std::uint8_t* aligned_alloc_host(std::size_t alignment, std::size_t num_bytes, Queue const & queue) {
-  return static_cast<std::uint8_t*>(sycl::aligned_alloc_host(alignment, num_bytes, queue));
+std::uint8_t *aligned_alloc_host(std::size_t alignment, std::size_t num_bytes,
+                                 Queue const &queue) {
+  return static_cast<std::uint8_t *>(
+      sycl::aligned_alloc_host(alignment, num_bytes, queue));
 }
 
-std::uint8_t* aligned_alloc_shared(std::size_t alignment, std::size_t num_bytes, Queue const & queue) {
-  return static_cast<std::uint8_t*>(sycl::aligned_alloc_shared(alignment, num_bytes, queue));
+std::uint8_t *aligned_alloc_shared(std::size_t alignment, std::size_t num_bytes,
+                                   Queue const &queue) {
+  return static_cast<std::uint8_t *>(
+      sycl::aligned_alloc_shared(alignment, num_bytes, queue));
 }
 
-void free(std::uint8_t* memory, Queue const & queue) {
-  sycl::free(static_cast<void*>(memory), queue);
+void free(std::uint8_t *memory, Queue const &queue) {
+  sycl::free(static_cast<void *>(memory), queue);
 }
 } // namespace sycl_shims::usm