Merge pull request #7 from szymon-zadworny/formatting

Formatting

Author: bratpiorka

oneapi-rs-sys/build.rs

@@ -68,7 +68,7 @@ fn get_compiler_path() -> Result<PathBuf, Error> {
     if let Ok(path) = std::env::var("CMPLR_ROOT") {
         let path = PathBuf::from(path).join("bin/icpx");
         if path.exists() {
-            return Ok(path)
+            return Ok(path);
         }
     }
     if let Ok(path) = which("icpx") {
@@ -81,5 +81,8 @@ fn get_compiler_path() -> Result<PathBuf, Error> {
         return Ok(path);
     }
 
-    Err(Error::new(std::io::ErrorKind::NotFound, "No DPC++ compiler found"))
+    Err(Error::new(
+        std::io::ErrorKind::NotFound,
+        "No DPC++ compiler found",
+    ))
 }

oneapi-rs-sys/include/device.hpp

@@ -8,12 +8,11 @@
 
 #pragma once
 
+#include <memory>
+
 #include "oneapi-rs-sys/include/types.hpp"
 #include "rust/cxx.h"
 
-#include <memory>
-#include <vector>
-
 namespace sycl_shims {
 struct DevicePtr;
 struct PlatformPtr;

oneapi-rs-sys/include/event.hpp

@@ -8,19 +8,20 @@
 
 #pragma once
 
+#include <memory>
+
 #include "oneapi-rs-sys/include/types.hpp"
 #include "oneapi-rs-sys/src/event-sys.rs.h"
 #include "rust/cxx.h"
 
-#include <memory>
-
 namespace sycl_shims {
 enum class EventCommandStatus : std::uint8_t;
 } // namespace sycl_shims
 
 namespace sycl_shims::event {
 void wait(std::unique_ptr<Event> &);
-void register_callback(std::unique_ptr<Queue> &, Event const &, SharedWaker const *);
+void register_callback(std::unique_ptr<Queue> &, Event const &,
+                       SharedWaker const *);
 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,13 +8,12 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include "oneapi-rs-sys/include/types.hpp"
+#include <memory>
 
 #include <sycl/sycl.hpp>
 
-#include <memory>
-#include <vector>
+#include "oneapi-rs-sys/include/types.hpp"
+#include "rust/cxx.h"
 
 namespace sycl_shims {
 struct DevicePtr;
@@ -23,8 +22,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

@@ -8,11 +8,11 @@
 
 #pragma once
 
+#include <memory>
+
 #include "oneapi-rs-sys/include/types.hpp"
 #include "rust/cxx.h"
 
-#include <memory>
-
 namespace sycl_shims {
 struct EventPtr;
 } // namespace sycl_shims
@@ -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

@@ -8,14 +8,17 @@
 
 #pragma once
 
+#include <memory>
+
 #include "oneapi-rs-sys/include/types.hpp"
 #include "rust/cxx.h"
 
-#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-sys.rs

@@ -26,7 +26,11 @@ pub mod ffi {
         type Queue = crate::types::ffi::Queue;
 
         fn wait(event: &mut UniquePtr<Event>);
-        unsafe fn register_callback(queue: &mut UniquePtr<Queue>, event: &Event, waker: *const SharedWaker);
+        unsafe fn register_callback(
+            queue: &mut UniquePtr<Queue>,
+            event: &Event,
+            waker: *const SharedWaker,
+        );
         fn get_command_execution_status(event: &Event) -> EventCommandStatus;
         fn clone(event: &Event) -> UniquePtr<Event>;
     }

oneapi-rs-sys/src/event.cpp

@@ -13,27 +13,28 @@ 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, SharedWaker const * waker) {
-  queue->submit([=](sycl::handler& cgh) {
+
+void register_callback(std::unique_ptr<Queue> &queue, Event const &event,
+                       SharedWaker const *waker) {
+  queue->submit([=](sycl::handler &cgh) {
     cgh.depends_on(event);
     cgh.host_task([=]() { waker->wake(); });
   });

oneapi-rs-sys/src/queue-sys.rs

@@ -33,7 +33,7 @@ pub mod ffi {
             ptr: *mut u8,
             value: i32,
             num_bytes: usize,
-            dep_events: Vec<EventPtr>
+            dep_events: Vec<EventPtr>,
         ) -> UniquePtr<Event>;
         fn barrier(queue: &mut UniquePtr<Queue>, dep_events: Vec<EventPtr>) -> UniquePtr<Event>;
         fn wait(queue: &mut UniquePtr<Queue>);