Fixed benchmarks & formatting

Author: spirali

crates/hyperqueue/src/client/commands/autoalloc.rs

@@ -369,7 +369,7 @@ wasted allocation duration."
         ]);
     }
     if let Some(arg) = coupling {
-        worker_args.extend(["--coupling".to_string(), format!("\"{}\"", arg)])
+        worker_args.extend(["--coupling".to_string(), format!("\"{arg}\"")])
     }
     if let Some(group) = group {
         worker_args.extend(["--group".to_string(), group]);

crates/hyperqueue/src/server/event/streamer.rs

@@ -413,8 +413,8 @@ impl EventStreamer {
         let inner = self.inner.get();
         if let Some(ref streamer) = inner.storage_sender
             && streamer
-            .send(EventStreamMessage::ReplayJournal(history_sender))
-            .is_err()
+                .send(EventStreamMessage::ReplayJournal(history_sender))
+                .is_err()
         {
             log::error!("Event streaming queue has been closed.");
         }

crates/tako/benches/benchmarks/worker.rs

@@ -183,7 +183,7 @@ fn create_resource_queue(num_cpus: u32) -> ResourceWaitQueue {
                 kind: ResourceDescriptorKind::simple_indices(8),
             },
         ],
-        None,
+        Default::default(),
     );
     ResourceWaitQueue::new(res_allocator_from_descriptor(descriptor))
 }

crates/tako/benches/utils/mod.rs

@@ -38,7 +38,7 @@ pub fn create_worker(id: u64) -> Worker {
                     name: CPU_RESOURCE_NAME.to_string(),
                     kind: ResourceDescriptorKind::simple_indices(1),
                 }],
-                None,
+                Default::default(),
             ),
             listen_address: "".to_string(),
             hostname: "".to_string(),

crates/tako/src/internal/worker/resources/allocator.rs

@@ -155,7 +155,7 @@ impl ResourceAllocator {
         pools: &[ResourcePool],
         free: &ConciseFreeResources,
         request: &ResourceRequest,
-        running: impl Iterator<Item=&'b Rc<Allocation>>,
+        running: impl Iterator<Item = &'b Rc<Allocation>>,
         static_info: &AllocatorStaticInfo,
     ) -> Option<ConciseFreeResources> {
         let mut free = free.clone();
@@ -217,7 +217,7 @@ impl ResourceAllocator {
                 &coupling,
                 &static_info.coupling_weights,
             )
-                .unwrap();
+            .unwrap();
             cost -= 0.1;
             optimal_costs.insert(request.clone(), cost);
             cost
@@ -329,7 +329,7 @@ impl ResourceAllocator {
             &coupling,
             &self.static_info.coupling_weights,
         )
-            .unwrap();
+        .unwrap();
         for (entry, group_set) in coupling.into_iter().zip(groups.into_iter()) {
             allocation.add_resource_allocation(
                 self.pools[entry.resource_id].claim_resources_with_group_mask(
@@ -393,10 +393,10 @@ impl ResourceAllocator {
                     amount.total_fractions() as f32 / size.total_fractions() as f32
                 }
                 AllocationRequest::ForceCompact(amount) | AllocationRequest::ForceTight(amount)
-                if self.pools[entry.resource_id].n_groups() == 1 =>
-                    {
-                        amount.total_fractions() as f32 / size.total_fractions() as f32
-                    }
+                    if self.pools[entry.resource_id].n_groups() == 1 =>
+                {
+                    amount.total_fractions() as f32 / size.total_fractions() as f32
+                }
                 AllocationRequest::ForceCompact(amount) | AllocationRequest::ForceTight(amount) => {
                     (amount.total_fractions() * 2) as f32 / size.total_fractions() as f32
                 }

crates/tako/src/internal/worker/resources/test_allocator.rs

@@ -1,6 +1,6 @@
 use crate::internal::common::resources::descriptor::{ResourceDescriptor, ResourceDescriptorKind};
 use crate::internal::common::resources::{Allocation, ResourceId, ResourceRequestVariants};
-use crate::internal::tests::utils::resources::{cpus_compact, ResBuilder};
+use crate::internal::tests::utils::resources::{ResBuilder, cpus_compact};
 use crate::internal::tests::utils::shared::res_allocator_from_descriptor;
 use crate::internal::tests::utils::sorted_vec;
 use crate::internal::worker::resources::allocator::{AllocatorStaticInfo, ResourceAllocator};
@@ -143,14 +143,16 @@ fn test_compute_blocking_level() {
     let rq = ResBuilder::default().add(0, 3).add(1, 1).finish();
     let sinfo = test_static_info(free.clone());
     assert!(ResourceAllocator::compute_witness(&pools, &free, &rq, [].iter(), &sinfo).is_none());
-    assert!(ResourceAllocator::compute_witness(
-        &pools,
-        &free,
-        &rq,
-        [Rc::new(Allocation::new_simple(&[1]))].iter(),
-        &sinfo,
-    )
-    .is_none());
+    assert!(
+        ResourceAllocator::compute_witness(
+            &pools,
+            &free,
+            &rq,
+            [Rc::new(Allocation::new_simple(&[1]))].iter(),
+            &sinfo,
+        )
+        .is_none()
+    );
     assert_eq!(
         ResourceAllocator::compute_witness(
             &pools,