Merge pull request eclipse-score#48 from qorix-group/pawelrutkaq_efficient_wakeups

scheduler: use wakers efficiently

Author: vinodreddy-g

src/kyron/src/scheduler/safety_waker.rs

@@ -31,15 +31,13 @@ fn wake(data: *const ()) {
     let task_ref = unsafe { TaskRef::from_raw(task_header_ptr) };
 
     task_ref.schedule_safety();
-
-    drop(task_ref); // wake uses move semantic, so we are owner of data now, so we need to cleanup
 }
 
 fn wake_by_ref(data: *const ()) {
     let task_header_ptr = data as *const TaskHeader;
     let task_ref = unsafe { TaskRef::from_raw(task_header_ptr) };
 
-    task_ref.schedule_safety();
+    task_ref.schedule_safety_by_ref();
 
     ::core::mem::forget(task_ref); // don't touch refcount from our data since this is done by drop_waker
 }

src/kyron/src/scheduler/task/async_task.rs

@@ -543,23 +543,41 @@ impl TaskRef {
     }
 
     ///
-    /// Proxy to `AsyncTask<T>::schedule`
+    /// Proxy to `AsyncTask<T>::schedule_by_ref`
     ///
-    pub(crate) fn schedule(&self) {
+    pub(crate) fn schedule_by_ref(&self) {
         unsafe {
             (self.header.as_ref().vtable.schedule)(self.header, self.clone());
         }
     }
 
+    ///
+    /// Proxy to `AsyncTask<T>::schedule`
+    ///
+    pub(crate) fn schedule(self) {
+        unsafe {
+            (self.header.as_ref().vtable.schedule)(self.header, self);
+        }
+    }
+
     ///
     /// Proxy to `AsyncTask<T>::schedule_safety`
     ///
-    pub(crate) fn schedule_safety(&self) {
+    pub(crate) fn schedule_safety_by_ref(&self) {
         unsafe {
             (self.header.as_ref().vtable.schedule_safety)(self.header, self.clone());
         }
     }
 
+    ///
+    /// Proxy to `AsyncTask<T>::schedule_safety`
+    ///
+    pub(crate) fn schedule_safety(self) {
+        unsafe {
+            (self.header.as_ref().vtable.schedule_safety)(self.header, self);
+        }
+    }
+
     ///
     /// Proxy to `AsyncTask<T>::poll`
     ///

src/kyron/src/scheduler/waker.rs

@@ -33,15 +33,13 @@ fn wake(data: *const ()) {
     let task_ref = unsafe { TaskRef::from_raw(task_header_ptr) };
 
     task_ref.schedule();
-
-    drop(task_ref); // wake uses move semantic, so we are owner of data now, so we need to cleanup
 }
 
 fn wake_by_ref(data: *const ()) {
     let task_header_ptr = data as *const TaskHeader;
     let task_ref = unsafe { TaskRef::from_raw(task_header_ptr) };
 
-    task_ref.schedule();
+    task_ref.schedule_by_ref();
 
     ::core::mem::forget(task_ref); // don't touch refcount from our data since this is done by drop_waker
 }

src/kyron/src/time/mod.rs

@@ -256,13 +256,16 @@ impl Inner {
     fn process_expired(&mut self, info: &ExpireInfo) {
         let iter = self.levels[info.level as usize].aquire_slot(info);
 
-        for e in iter {
-            let data = unsafe { e.as_ref() };
+        for mut e in iter {
+            let data = unsafe { e.as_mut() };
 
             //TODO: We could keep waker list on side to fire them outside of the lock. This is next step improvement once we will connect this all into workers
             if data.data.expire_at <= info.deadline {
                 // Wake up the task
-                data.data.waker.wake_by_ref();
+
+                // Instead going over waker and waking by ref which is less efficient, we just replace with noop and wake by value
+                let waker = core::mem::replace(&mut data.data.waker, Waker::noop().clone());
+                waker.wake();
 
                 unsafe {
                     ::core::ptr::drop_in_place(e.as_ptr());