refactor(Echo/Scheduler): expose scheduler APIs and optimize worker task polling

- Made `Share` struct and `Steal` method public in `StealingQueue` to enable cross-component integration with `Track` dispatcher
- Changed `Scheduler::Create` visibility to public for proper builder pattern usage in `Mountain` initialization
- Refactored `Worker::Run` to implement prioritized local polling and system stealing strategies, improving task distribution efficiency
- Fixed module import paths to align with finalized `Element/Echo` crate structure
- Updated task imports to use absolute paths ensuring consistency across scheduler components

These changes strengthen the foundation for `Mountain`'s task execution system, directly supporting Land's requirement for low-latency command processing between Tauri frontend and native backend. The worker optimization particularly enhances performance during concurrent operations like extension host communication and file I/O handling.

Author: NikolaRHristov

Source/Queue/StealingQueue.rs

@@ -31,11 +31,11 @@ pub enum Priority {
 ///
 /// This includes global injectors for submitting new tasks and stealers for
 /// taking tasks from other workers, organized by priority level.
-struct Share<T> {
+pub struct Share<T> {
 	/// Global, multi-producer queues for each priority.
-	Injector:(Injector<T>, Injector<T>, Injector<T>),
+	pub Injector:(Injector<T>, Injector<T>, Injector<T>),
 	/// Share handles for stealing tasks from each worker's queue.
-	Stealer:(Vec<Stealer<T>>, Vec<Stealer<T>>, Vec<Stealer<T>>),
+	pub Stealer:(Vec<Stealer<T>>, Vec<Stealer<T>>, Vec<Stealer<T>>),
 }
 
 /// A generic, priority-aware, work-stealing queue.
@@ -55,9 +55,9 @@ pub struct Context<T> {
 	/// A unique identifier for the worker, used to avoid self-stealing.
 	pub Identifier:usize,
 	/// Thread-local work queues for each priority level.
-	Local:(Worker<T>, Worker<T>, Worker<T>),
+	pub Local:(Worker<T>, Worker<T>, Worker<T>),
 	/// A reference to the shared components of the entire queue system.
-	Share:Arc<Share<T>>,
+	pub Share:Arc<Share<T>>,
 }
 
 impl<T:Prioritized<Kind = Priority>> StealingQueue<T> {
@@ -157,7 +157,7 @@ impl<T> Context<T> {
 	/// It first tries to steal a batch from the global injector queue. If that
 	/// fails, it attempts to steal from a randomly chosen peer worker to ensure
 	/// fair distribution and avoid contention hotspots.
-	fn Steal<'a>(&self, Injector:&'a Injector<T>, Stealers:&'a [Stealer<T>], Local:&'a Worker<T>) -> Option<T> {
+	pub fn Steal<'a>(&self, Injector:&'a Injector<T>, Stealers:&'a [Stealer<T>], Local:&'a Worker<T>) -> Option<T> {
 		if Injector.steal_batch_and_pop(Local).is_success() {
 			return Local.pop();
 		}

Source/Scheduler/Scheduler.rs

@@ -36,7 +36,7 @@ impl Scheduler {
 	///
 	/// This is a crate-private function, intended to be called only by the
 	/// `SchedulerBuilder`'s `Build` method.
-	pub(crate) fn Create(Count:usize, _Configuration:HashMap<String, Concurrency>) -> Self {
+	pub fn Create(Count:usize, _Configuration:HashMap<String, Concurrency>) -> Self {
 		info!("[Scheduler] Create with {} workers.", Count);
 		let Running = Arc::new(AtomicBool::new(true));
 

Source/Scheduler/SchedulerBuilder.rs

@@ -6,7 +6,7 @@ use std::collections::HashMap;
 
 use log::warn;
 
-use super::Scheduler::Scheduler;
+use crate::Scheduler::Scheduler::Scheduler;
 
 /// Defines concurrency limits for named queues. (For future use)
 #[derive(Debug, Clone, Copy)]

Source/Scheduler/Worker.rs

@@ -13,9 +13,6 @@ use tokio::time::{Duration, sleep};
 use crate::{Queue::StealingQueue::Context, Task::Task::Task};
 
 /// Represents a worker that executes tasks from its assigned context.
-///
-/// Each worker runs in a dedicated asynchronous task, continuously polling for
-/// work from its local queues or stealing from its peers.
 pub struct Worker {
 	/// The worker's execution context, which contains its private queues
 	/// and a reference to the shared queue system.
@@ -30,26 +27,50 @@ impl Worker {
 	pub fn Create(Context:Context<Task>, Running:Arc<AtomicBool>) -> Self { Self { Context, Running } }
 
 	/// The main execution loop for the worker.
-	///
-	/// This method consumes the `Worker` instance, taking full ownership of its
-	/// fields. This design is critical for making the resulting `Future` safe
-	/// to send across threads as required by `tokio::spawn`.
 	pub async fn Run(self) {
 		trace!("[Worker {}] Starting.", self.Context.Identifier);
 
 		while self.Running.load(Ordering::Relaxed) {
-			// Attempt to find a task from any available source.
-			if let Some(Task) = self.Context.Next() {
-				trace!("[Worker {}] Execute: {:?}.", self.Context.Identifier, Task.Priority);
-				// Execute the task's future to completion.
+			// First, try to get a task from the local queues.
+			let TaskOption = self.PopLocal();
+
+			if let Some(Task) = TaskOption {
+				trace!("[Worker {}] Execute Local: {:?}.", self.Context.Identifier, Task.Priority);
+				Task.Operation.await;
+				continue; // Immediately loop back to check for more local work.
+			}
+
+			// If no local work, try to steal from the system.
+			// This attempts to get a batch and executes the first task.
+			// The rest of the batch now populates the local queue for the next loops.
+			let TaskOption = self.StealFromSystem();
+
+			if let Some(Task) = TaskOption {
+				trace!("[Worker {}] Execute Stolen: {:?}.", self.Context.Identifier, Task.Priority);
 				Task.Operation.await;
 			} else {
-				// If no work is found, yield to the OS to prevent busy-waiting
-				// and conserve CPU resources.
+				// If there's truly no work anywhere, yield.
 				sleep(Duration::from_millis(1)).await;
 			}
 		}
 
 		trace!("[Worker {}] Finished.", self.Context.Identifier);
 	}
+
+	/// Attempts to pop a single task from the local deques, honoring priority.
+	fn PopLocal(&self) -> Option<Task> {
+		self.Context.Local.0.pop() // High
+			.or_else(|| self.Context.Local.1.pop()) // Normal
+			.or_else(|| self.Context.Local.2.pop()) // Low
+	}
+
+	/// Attempts to steal a batch of work from the system.
+	///
+	/// It steals from the highest-priority queue that has work, populating its
+	/// own local queue and returning the first task immediately.
+	fn StealFromSystem(&self) -> Option<Task> {
+		self.Context.Steal(&self.Context.Share.Injector.0, &self.Context.Share.Stealer.0, &self.Context.Local.0) // Steal High
+			.or_else(|| self.Context.Steal(&self.Context.Share.Injector.1, &self.Context.Share.Stealer.1, &self.Context.Local.1)) // Steal Normal
+			.or_else(|| self.Context.Steal(&self.Context.Share.Injector.2, &self.Context.Share.Stealer.2, &self.Context.Local.2)) // Steal Low
+	}
 }

Source/Task/Task.rs

@@ -4,8 +4,10 @@
 
 use std::{future::Future, pin::Pin};
 
-use super::Priority::Priority;
-use crate::Queue::StealingQueue::{Prioritized, Priority as QueuePriority};
+use crate::{
+	Queue::StealingQueue::{Prioritized, Priority as QueuePriority},
+	Task::Priority::Priority,
+};
 
 /// Defines a dynamic, asynchronous operation that can be sent between threads.
 pub type Operation = Pin<Box<dyn Future<Output = ()> + Send>>;

Target/debug/libEcho.rlib

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cf6fed20c4874669f6eb11c2a43493b19f8d32d80eb5d47900d91aa846b2a499
-size 12084896
+oid sha256:05c2fdc8ee692f6e433b6886988245653b49d59ff361e2c4867ebb58fc7beaff
+size 12134460

Target/release/libEcho.rlib

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6c5a8c60c99ff4ac42395e90d999a62af63bc125f614110c47199b6a230478f2
-size 271132
+oid sha256:98c54fa2c4be0f49dca74c1faf8412cb56ff1598cb3b6cbf3c024b80410eee02
+size 286990