style: Apply cargo fmt

Author: “thucydides”

rustorch-core/src/storage.rs

@@ -3,10 +3,10 @@ use std::sync::{Arc, RwLock, RwLockReadGuard, RwLockWriteGuard};
 
 #[cfg(feature = "cuda")]
 use cudarc::driver::CudaSlice;
-#[cfg(feature = "wgpu_backend")]
-use wgpu;
 #[cfg(feature = "vulkan_backend")]
 use vulkano::buffer::Subbuffer;
+#[cfg(feature = "wgpu_backend")]
+use wgpu;
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum Device {

rustorch-pytorch/src/lib.rs

@@ -1,7 +1,7 @@
-use rustorch_core::Tensor;
-use tch::{self, Kind, Device as TchDevice};
 use anyhow::Result;
+use rustorch_core::Tensor;
 use std::path::Path;
+use tch::{self, Device as TchDevice, Kind};
 
 pub struct PyTorchAdapter;
 
@@ -11,7 +11,7 @@ impl PyTorchAdapter {
         let storage = tensor.storage();
         let data = storage.data(); // Read lock
         let shape: Vec<i64> = tensor.shape().iter().map(|&x| x as i64).collect();
-        
+
         // Create a PyTorch tensor from the data
         // Currently assumes f32 and CPU
         let t = tch::Tensor::from_slice(&data);
@@ -21,10 +21,10 @@ impl PyTorchAdapter {
     /// Convert a PyTorch Tensor to a RusTorch Tensor
     pub fn from_torch(tensor: &tch::Tensor) -> Result<Tensor> {
         let size: Vec<usize> = tensor.size().iter().map(|&x| x as usize).collect();
-        
+
         // Ensure the tensor is on CPU and is contiguous
         let cpu_tensor = tensor.to_device(TchDevice::Cpu).contiguous();
-        
+
         // Check if the tensor is Float (f32)
         if cpu_tensor.kind() != Kind::Float {
             // Cast to float if not
@@ -43,28 +43,34 @@ impl PyTorchAdapter {
     }
 
     /// Load a PyTorch model (.pth) and return a dictionary of tensors (state_dict)
-    pub fn load_state_dict<P: AsRef<Path>>(path: P) -> Result<std::collections::HashMap<String, Tensor>> {
+    pub fn load_state_dict<P: AsRef<Path>>(
+        path: P,
+    ) -> Result<std::collections::HashMap<String, Tensor>> {
         let tensors = tch::Tensor::load_multi(path)?;
         let mut result = std::collections::HashMap::new();
-        
+
         for (name, tensor) in tensors {
             let rt_tensor = Self::from_torch(&tensor)?;
             result.insert(name, rt_tensor);
         }
-        
+
         Ok(result)
     }
 
     /// Save a dictionary of RusTorch tensors to a .pth file
-    pub fn save_state_dict<P: AsRef<Path>>(tensors: &std::collections::HashMap<String, Tensor>, path: P) -> Result<()> {
+    pub fn save_state_dict<P: AsRef<Path>>(
+        tensors: &std::collections::HashMap<String, Tensor>,
+        path: P,
+    ) -> Result<()> {
         let mut named_tensors = Vec::new();
         for (name, tensor) in tensors {
             let t = Self::to_torch(tensor);
             named_tensors.push((name.clone(), t));
         }
-        
+
         // Convert to slice of (&str, Tensor)
-        let named_tensors_refs: Vec<(&str, tch::Tensor)> = named_tensors.iter()
+        let named_tensors_refs: Vec<(&str, tch::Tensor)> = named_tensors
+            .iter()
             .map(|(n, t)| (n.as_str(), t.shallow_clone())) // shallow_clone is cheap
             .collect();
 
@@ -132,12 +138,12 @@ mod tests {
         assert_eq!(rt_tensor_back.shape(), shape.as_slice());
         assert_eq!(*rt_tensor_back.storage().data(), data);
     }
-    
+
     #[test]
     fn test_ops() {
         let t1 = Tensor::new(&vec![1.0, 2.0, 3.0, 4.0], &[2, 2]);
         let t2 = Tensor::new(&vec![1.0, 1.0, 1.0, 1.0], &[2, 2]);
-        
+
         let res = ops::add(&t1, &t2).unwrap();
         assert_eq!(*res.storage().data(), vec![2.0, 3.0, 4.0, 5.0]);
     }

rustorch-vulkan/src/lib.rs

@@ -1,13 +1,13 @@
-use rustorch_core::{Tensor, Storage};
-use vulkano::device::{Device, Queue, DeviceCreateInfo, QueueCreateInfo, QueueFlags};
-use vulkano::instance::{Instance, InstanceCreateInfo, InstanceExtensions};
-use vulkano::memory::allocator::{StandardMemoryAllocator, AllocationCreateInfo, MemoryTypeFilter};
+use anyhow::{Context, Result};
+use rustorch_core::{Storage, Tensor};
+use std::sync::Arc;
 use vulkano::buffer::{Buffer, BufferCreateInfo, BufferUsage};
 use vulkano::command_buffer::allocator::StandardCommandBufferAllocator;
 use vulkano::descriptor_set::allocator::StandardDescriptorSetAllocator;
+use vulkano::device::{Device, DeviceCreateInfo, Queue, QueueCreateInfo, QueueFlags};
+use vulkano::instance::{Instance, InstanceCreateInfo, InstanceExtensions};
+use vulkano::memory::allocator::{AllocationCreateInfo, MemoryTypeFilter, StandardMemoryAllocator};
 use vulkano::VulkanLibrary;
-use std::sync::Arc;
-use anyhow::{Result, Context};
 
 pub struct VulkanContext {
     pub device: Arc<Device>,
@@ -29,7 +29,8 @@ impl VulkanContext {
                 },
                 ..Default::default()
             },
-        ).context("Failed to create instance")?;
+        )
+        .context("Failed to create instance")?;
 
         let physical_device = instance
             .enumerate_physical_devices()
@@ -52,12 +53,19 @@ impl VulkanContext {
                 }],
                 ..Default::default()
             },
-        ).context("Failed to create device")?;
+        )
+        .context("Failed to create device")?;
 
         let queue = queues.next().unwrap();
         let memory_allocator = Arc::new(StandardMemoryAllocator::new_default(device.clone()));
-        let command_buffer_allocator = Arc::new(StandardCommandBufferAllocator::new(device.clone(), Default::default()));
-        let descriptor_set_allocator = Arc::new(StandardDescriptorSetAllocator::new(device.clone(), Default::default()));
+        let command_buffer_allocator = Arc::new(StandardCommandBufferAllocator::new(
+            device.clone(),
+            Default::default(),
+        ));
+        let descriptor_set_allocator = Arc::new(StandardDescriptorSetAllocator::new(
+            device.clone(),
+            Default::default(),
+        ));
 
         Ok(Self {
             device,
@@ -76,11 +84,13 @@ impl VulkanContext {
                 ..Default::default()
             },
             AllocationCreateInfo {
-                memory_type_filter: MemoryTypeFilter::PREFER_DEVICE | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
+                memory_type_filter: MemoryTypeFilter::PREFER_DEVICE
+                    | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
                 ..Default::default()
             },
             data.iter().cloned(),
-        ).context("Failed to create buffer")?;
+        )
+        .context("Failed to create buffer")?;
 
         let storage = Storage::new_vulkan(Arc::new(buffer), 0);
         Ok(Tensor::new_with_storage(storage, shape))