Author: NikolaRHristov

Example/Sequence.rs

@@ -66,8 +66,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 	// Wait for a moment to allow actions to complete
 	tokio::time::sleep(std::time::Duration::from_secs(10)).await;
 
-	// Shutdown the sequence
-	Sequence.Shutdown().await;
+	// ShutDown the sequence
+	Sequence.ShutDown().await;
 
 	println!("Sequence completed");
 

Example/Tauri.rs

@@ -96,8 +96,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 		}
 	}
 
-	// Shutdown the sequence
-	Sequence.Shutdown().await;
+	// ShutDown the sequence
+	Sequence.ShutDown().await;
 
 	println!("Application completed");
 

Example/WorkSteal.rs

@@ -105,7 +105,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 	let Running = Arc::new(Mutex::new(true));
 
 	// Spawn worker tasks
-	let Handles: Vec<_> = Workers
+	let Handle: Vec<_> = Workers
 		.iter()
 		.map(|Worker| {
 			let Worker = Worker.clone();
@@ -139,7 +139,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 	*Running.lock().await = false;
 
 	// Wait for all worker tasks to complete
-	for Handle in Handles {
+	for Handle in Handle {
 		Handle.await?;
 	}
 

Source/Queue/StealingQueue.rs

@@ -4,19 +4,19 @@
 use crossbeam_deque::{Injector, Stealer, Worker};
 use rand::seq::SliceRandom;
 
-use crate::Task::{Priority::Priority, Task::Task};
+use crate::Task::{Priority::Enum, Task::Struct};
 
 /// A container for a set of queues for a single priority level.
 struct PriorityQueueSet {
-	GlobalInjector:Injector<Task>,
-	WorkerQueue:Vec<Worker<Task>>,
-	Stealer:Vec<Stealer<Task>>,
+	GlobalInjector:Injector<Struct>,
+	WorkerQueue:Vec<Worker<Struct>>,
+	Stealer:Vec<Stealer<Struct>>,
 }
 
 impl PriorityQueueSet {
 	/// Creates a new set of queues for a given number of workers.
 	fn New(NumberOfWorker:usize) -> Self {
-		let WorkerQueue:Vec<Worker<Task>> = (0..NumberOfWorker).map(|_| Worker::new_fifo()).collect();
+		let WorkerQueue:Vec<Worker<Struct>> = (0..NumberOfWorker).map(|_| Worker::new_fifo()).collect();
 		Self {
 			GlobalInjector:Injector::new(),
 			Stealer:WorkerQueue.iter().map(|w| w.stealer()).collect(),
@@ -49,33 +49,33 @@ impl StealingQueue {
 
 	/// Submits a task to the appropriate global injection queue based on its
 	/// priority.
-	pub fn Push(&self, Task:Task) {
+	pub fn Push(&self, Task:Struct) {
 		match Task.Priority {
-			Priority::High => self.High.GlobalInjector.push(Task),
-			Priority::Normal => self.Normal.GlobalInjector.push(Task),
-			Priority::Low => self.Low.GlobalInjector.push(Task),
+			Enum::High => self.High.GlobalInjector.push(Task),
+			Enum::Normal => self.Normal.GlobalInjector.push(Task),
+			Enum::Low => self.Low.GlobalInjector.push(Task),
 		}
 	}
 
 	/// Attempts to find a task for a given worker, always prioritizing
 	/// `High` > `Normal` > `Low`.
-	pub fn StealForWorker(&self, WorkerId:usize) -> Option<Task> {
+	pub fn StealForWorker(&self, WorkerId:usize) -> Option<Struct> {
 		self.FindTaskInSet(&self.High, WorkerId)
 			.or_else(|| self.FindTaskInSet(&self.Normal, WorkerId))
 			.or_else(|| self.FindTaskInSet(&self.Low, WorkerId))
 	}
 
 	/// Implements the core work-finding logic for a specific priority level.
 	/// It first checks the worker's local queue, then attempts to steal.
-	fn FindTaskInSet(&self, Set:&PriorityQueueSet, WorkerId:usize) -> Option<Task> {
+	fn FindTaskInSet(&self, Set:&PriorityQueueSet, WorkerId:usize) -> Option<Struct> {
 		Set.WorkerQueue[WorkerId]
 			.pop()
 			.or_else(|| self.StealFromSetGlobalOrPeer(Set, WorkerId))
 	}
 
 	/// Attempts to steal work for a specific priority level, first from the
 	/// global queue, then from peer workers.
-	fn StealFromSetGlobalOrPeer(&self, Set:&PriorityQueueSet, WorkerId:usize) -> Option<Task> {
+	fn StealFromSetGlobalOrPeer(&self, Set:&PriorityQueueSet, WorkerId:usize) -> Option<Struct> {
 		// Try stealing from the global injector for this priority set.
 		if Set.GlobalInjector.steal_batch_and_pop(&Set.WorkerQueue[WorkerId]).is_success() {
 			return Set.WorkerQueue[WorkerId].pop();

Source/Scheduler/Scheduler.rs

@@ -17,7 +17,7 @@ use super::Worker::Worker;
 use crate::{
 	Queue::StealingQueue::StealingQueue,
 	Scheduler::SchedulerBuilder::Concurrency,
-	Task::{Priority::Priority, Task::Task},
+	Task::{Priority::Enum, Task::Struct},
 };
 
 /// Manages a pool of worker threads and a work-stealing queue to execute tasks
@@ -36,21 +36,25 @@ impl Scheduler {
 	/// This is a crate-private function, intended to be called only by the
 	/// `SchedulerBuilder`.
 	///
-	/// @param NumberOfWorkers - The number of worker threads to spawn.
-	/// @param QueueConfigs - Configuration for named queues with concurrency
+	/// @param number_of_workers - The number of worker threads to spawn.
+	/// @param _queue_configs - Configuration for named queues with concurrency
 	/// limits (future use).
-	pub(crate) fn Start(NumberOfWorkers:usize, _QueueConfigs:HashMap<String, Concurrency>) -> Self {
-		info!("[Scheduler] Starting scheduler with {} worker threads.", NumberOfWorkers);
+	pub(crate) fn Start(number_of_workers:usize, _queue_configs:HashMap<String, Concurrency>) -> Self {
+		info!("[Scheduler] Starting scheduler with {} worker threads.", number_of_workers);
 		let IsRunning = Arc::new(AtomicBool::new(true));
-		let Queue = Arc::new(StealingQueue::New(NumberOfWorkers));
+		let Queue = Arc::new(StealingQueue::New(number_of_workers));
 
-		let mut WorkerHandles = Vec::with_capacity(NumberOfWorkers);
+		let mut WorkerHandles = Vec::with_capacity(number_of_workers);
+
+		for WorkerIdentifier in 0..number_of_workers {
+			let CloneQueue = Queue.clone();
+			let CloneIsRunning = IsRunning.clone();
 
-		for WorkerId in 0..NumberOfWorkers {
-			let WorkerInstance = Worker::New(WorkerId, Queue.clone(), IsRunning.clone());
 			let WorkerHandle = tokio::spawn(async move {
+				let WorkerInstance = Worker::New(WorkerIdentifier, CloneQueue, CloneIsRunning);
 				WorkerInstance.Run().await;
 			});
+
 			WorkerHandles.push(WorkerHandle);
 		}
 
@@ -60,28 +64,28 @@ impl Scheduler {
 	/// Submits a new task (as a `Future`) to the scheduler's global queue.
 	/// The task will be picked up by the next available worker.
 	///
-	/// @param FutureInstance - The async block or function to execute.
-	/// @param TaskPriority - The priority of the task.
-	pub fn Submit<F>(&self, FutureInstance:F, TaskPriority:Priority)
+	/// @param future_instance - The async block or function to execute.
+	/// @param task_priority - The priority of the task.
+	pub fn submit<F>(&self, future_instance:F, task_priority:Enum)
 	where
 		F: Future<Output = ()> + Send + 'static, {
-		let NewTask = Task::New(FutureInstance, TaskPriority);
-		self.Queue.Push(NewTask);
+		let new_task = Struct::New(future_instance, task_priority);
+		self.Queue.Push(new_task);
 	}
 
 	/// Asynchronously shuts down the scheduler.
 	///
 	/// This signals all worker threads to stop their loops and then waits for
 	/// them to complete their current tasks and exit gracefully.
-	pub async fn Shutdown(&mut self) {
+	pub async fn ShutDown(&mut self) {
 		if !self.IsRunning.swap(false, Ordering::Relaxed) {
-			info!("[Scheduler] Shutdown already initiated.");
+			info!("[Scheduler] ShutDown already initiated.");
 			return;
 		}
 
 		info!("[Scheduler] Shutting down worker threads...");
-		for Handle in self.WorkerHandles.drain(..) {
-			if let Err(e) = Handle.await {
+		for handle in self.WorkerHandles.drain(..) {
+			if let Err(e) = handle.await {
 				error!("[Scheduler] Error joining worker task during shutdown: {}", e);
 			}
 		}

Source/Task/Priority.rs

@@ -8,7 +8,7 @@
 /// Schedulers and workers can use this to ensure that high-priority,
 /// user-facing tasks are executed before long-running background tasks.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub enum Priority {
+pub enum Enum {
 	/// For background tasks that are not time-sensitive, such as logging,
 	/// telemetry, or non-critical file indexing.
 	Low,

Source/Task/Task.rs

@@ -3,7 +3,7 @@ use std::{future::Future, pin::Pin};
 /// @module Task
 /// @description Defines the `Task` struct, which is the internal unit of work
 /// for the Echo scheduler.
-use super::Priority::Priority;
+use super::Priority::Enum;
 
 /// A type alias for a boxed, send-able, pinned future that returns no value.
 /// This is the standard way to handle dynamic, async operations in Rust.
@@ -14,20 +14,20 @@ type BoxedFuture = Pin<Box<dyn Future<Output = ()> + Send>>;
 /// It encapsulates an asynchronous operation (`Future`) along with metadata,
 /// such as its `Priority`, that the scheduler can use to determine execution
 /// order.
-pub struct Task {
+pub struct Struct {
 	/// The asynchronous operation to be executed by a worker.
 	pub Future:BoxedFuture,
 	/// The priority level of this task, used by the scheduler's queue.
-	pub Priority:Priority,
+	pub Priority:Enum,
 }
 
-impl Task {
+impl Struct {
 	/// Creates a new `Task` from a given future and priority level.
 	///
 	/// @param FutureInstance - Any `Future` that is `Send` and has a `'static`
 	///   lifetime. The future is automatically boxed and pinned.
 	/// @param PriorityValue - The `Priority` of the task.
-	pub fn New<F>(FutureInstance:F, PriorityValue:Priority) -> Self
+	pub fn New<F>(FutureInstance:F, PriorityValue:Enum) -> Self
 	where
 		F: Future<Output = ()> + Send + 'static, {
 		Self { Future:Box::pin(FutureInstance), Priority:PriorityValue }