Small optimizations

Author: haoud

kernel/src/syscall/task.rs

@@ -2,7 +2,7 @@ use crate::{
     time::{timer::Timer, units::Nanosecond, uptime_fast},
     user::{
         self,
-        scheduler::{self, Scheduler, SCHEDULER},
+        scheduler::{self, round_robin::CURRENT_TASK, Scheduler, SCHEDULER},
         string::SyscallString,
         task,
     },
@@ -37,7 +37,7 @@ pub fn exit(code: usize) -> ! {
 /// never happen and is a bug).
 #[allow(clippy::cast_possible_truncation)]
 pub fn id() -> Result<usize, isize> {
-    Ok(SCHEDULER.current_task().id().0 as usize)
+    Ok(CURRENT_TASK.local().borrow().as_ref().unwrap().id().0 as usize)
 }
 
 /// Put the current task to sleep for at least the given number of nanoseconds. The task

kernel/src/user/task/preempt.rs

@@ -42,20 +42,36 @@ pub fn disable() {
 
 /// Disable preemption during the execution of the given closure. This function is useful to avoid
 /// race conditions when multiple threads are accessing the same data. This function is implemented
-/// by disabling interrupts and preemption before executing the closure, and then restoring the
-/// previous state after the closure has finished.
+/// preemption before executing the closure, and then restoring the previous state after the closure
+/// has finished.
 ///
 /// # Important
 /// Even if preemption is disabled, interrupts are still enabled. This means that the closure can
 /// still be interrupted by an IRQ handler. If you want to disable interrupts too, then you should
+/// use the `atomic` function instead.
 pub fn without<F, R>(f: F) -> R
 where
     F: FnOnce() -> R,
 {
-    x86_64::irq::without(|| {
+    {
         disable();
         let ret = f();
         enable();
         ret
-    })
+    }
+}
+
+/// Disable preemption and interrupts during the execution of the given closure. This function is
+/// useful
+///
+/// Important
+/// Since this function disable interrupts and preemption, it should be used with caution. If the
+/// closure takes too much time to execute, it could cause the system to miss interrupts and
+/// increase the latency of the system. This function should only be used with caution, and only
+/// when it is really needed for short periods of time.
+pub fn atomic<F, R>(f: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    x86_64::irq::without(|| without(f))
 }

user/shell/src/main.rs

@@ -9,4 +9,24 @@ fn main() {
     let size = syscall::vfs::get_cwd(&mut buffer).expect("get_cwd failed");
 
     println!("cwd: {}", core::str::from_utf8(&buffer[..size]).unwrap());
+
+    // Benchmark the get_pid syscall using the rdtsc
+    let mut start: u64;
+    let mut end: u64;
+    let mut total: u64 = 0;
+
+    for _ in 0..1_000_000 {
+        start = unsafe { core::arch::x86_64::_rdtsc() };
+        syscall::task::id();
+        end = unsafe { core::arch::x86_64::_rdtsc() };
+        total += end - start;
+    }
+
+    println!("Average get_pid syscall time: {} cycles", total / 1_000_000);
+
+    /// Convert cycles to nanoseconds, assuming a 4.2 GHz CPU
+    println!(
+        "Average get_pid syscall time: {} ns",
+        (total / 1_000_000) * 1000 / 4200
+    );
 }