Author: NikolaRHristov

Source/Library.rs

@@ -1,15 +1,5 @@
-// @module Echo Crate
-// @description A high-performance, structured concurrency and task scheduling
-// library for Rust, built on top of `tokio` and a work-stealing queue. Echo is
-// designed to natively execute `Future`s, providing a robust runtime for
-// complex, asynchronous applications.
-//
-
 #![allow(non_snake_case, non_camel_case_types)]
 
-// --- Public API ---
+pub mod Queue;
 pub mod Scheduler;
 pub mod Task;
-
-// --- Internal Implementation ---
-pub mod Queue;

Source/Queue/StealingQueue.rs

@@ -1,23 +1,16 @@
-// @module StealingQueue
-// @description A generic, priority-aware, work-stealing queue implementation.
-// This module is self-contained and can be used by any scheduler or application
-// to manage and distribute tasks of any type `T`.
-
 #![allow(non_snake_case, non_camel_case_types)]
 
 use std::sync::Arc;
 
 use crossbeam_deque::{Injector, Stealer, Worker};
 use rand::seq::SliceRandom;
 
-// The task must have a way to specify its priority. We define a trait for this.
 pub trait Prioritized {
 	type P: PartialEq + Eq + Copy;
 
 	fn GetPriority(&self) -> Self::P;
 }
 
-// A simple enum for the library to use. The consumer's task must map to this.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Priority {
 	High,
@@ -27,58 +20,40 @@ pub enum Priority {
 	Low,
 }
 
-// The parts of the queue that can be safely shared across all threads.
 struct Share<T> {
-	// High, Normal, Low
 	Injector:(Injector<T>, Injector<T>, Injector<T>),
 
-	// High, Normal, Low
 	Stealer:(Vec<Stealer<T>>, Vec<Stealer<T>>, Vec<Stealer<T>>),
 }
 
-/// The public-facing work-stealing queue. It is generic over the task type `T`.
-/// This object is held by the task submitter.
 pub struct StealingQueue<T:Prioritized<P = Priority>> {
 	Share:Arc<Share<T>>,
 }
 
-/// A context object that contains everything a single worker thread needs to
-/// operate. This includes its own private, thread-local deques.
 pub struct Context<T> {
 	pub Identifier:usize,
 
-	// High, Normal, Low
 	Local:(Worker<T>, Worker<T>, Worker<T>),
 
 	Share:Arc<Share<T>>,
 }
 
 impl<T:Prioritized<P = Priority>> StealingQueue<T> {
-	/// Creates a new work-stealing queue system.
-	///
-	/// Returns a tuple containing:
-	/// 1. The `StealingQueue` for submitting tasks.
-	/// 2. A `Vec` of `WorkerContext`s, one for each worker to be spawned.
 	pub fn New(Count:usize) -> (Self, Vec<Context<T>>) {
 		let mut High:Vec<Worker<T>> = Vec::with_capacity(Count);
 
 		let mut Normal:Vec<Worker<T>> = Vec::with_capacity(Count);
 
 		let mut Low:Vec<Worker<T>> = Vec::with_capacity(Count);
 
-		// --- FIX: Use the documented API for creating Worker/Stealer pairs ---
 		let StealerHigh:Vec<Stealer<T>> = (0..Count)
 			.map(|_| {
-				// 1. Create the Worker.
 				let Worker = Worker::new_fifo();
 
-				// 2. Get its Stealer.
 				let Stealer = Worker.stealer();
 
-				// 3. Store the Worker part.
 				High.push(Worker);
 
-				// 4. Return the Stealer part.
 				Stealer
 			})
 			.collect();
@@ -116,7 +91,6 @@ impl<T:Prioritized<P = Priority>> StealingQueue<T> {
 		let mut Context = Vec::with_capacity(Count);
 
 		for Id in 0..Count {
-			// We use remove(0) because we built the Vecs in order and need to consume them.
 			Context.push(Context {
 				Identifier:Id,
 
@@ -131,8 +105,6 @@ impl<T:Prioritized<P = Priority>> StealingQueue<T> {
 		(Queue, Context)
 	}
 
-	/// Submits a new task to the queue.
-	/// This is thread-safe and can be called from anywhere.
 	pub fn Submit(&self, Task:T) {
 		match Task.GetPriority() {
 			Priority::High => self.Share.Injector.0.push(Task),
@@ -145,20 +117,14 @@ impl<T:Prioritized<P = Priority>> StealingQueue<T> {
 }
 
 impl<T> Context<T> {
-	/// Finds the next available task for this worker.
-	/// Implements the full priority-aware, work-stealing logic.
 	pub fn NextTask(&self) -> Option<T> {
-		// Pop from local High
-		self.Local.0.pop()
-			// Pop from local Normal
+		self.Local
+			.0
+			.pop()
 			.or_else(|| self.Local.1.pop())
-			// Pop from local Low
 			.or_else(|| self.Local.2.pop())
-			// Steal High
 			.or_else(|| self.Steal(&self.Share.Injector.0, &self.Share.Stealer.0, &self.Local.0))
-			// Steal Normal
 			.or_else(|| self.Steal(&self.Share.Injector.1, &self.Share.Stealer.1, &self.Local.1))
-			// Steal Low
 			.or_else(|| self.Steal(&self.Share.Injector.2, &self.Share.Stealer.2, &self.Local.2))
 	}
 

Source/Queue/mod.rs

@@ -1,15 +1,3 @@
-// @module queue
-// @description This module provides the high-performance, concurrent queueing
-// implementations used by the Echo scheduler. These are internal components
-// of the library.
-//
-
 #![allow(non_snake_case, non_camel_case_types)]
 
 pub mod StealingQueue;
-
-// Re-exports the `StealingQueue` for use within the `Echo` crate, but keeps it
-// private from external consumers.
-// @see StealingQueue
-//
-// pub use self::StealingQueue::StealingQueue;

Source/Scheduler/Scheduler.rs

@@ -17,8 +17,6 @@ use crate::{
 	Task::{Priority::Enum as PriorityEnum, Task::Struct as TaskStruct},
 };
 
-/// Manages a pool of worker threads and a work-stealing queue to execute tasks
-/// efficiently. This struct is the public-facing API of the Echo scheduler.
 pub struct Scheduler {
 	Queue:StealingQueueStruct<TaskStruct>,
 

Source/Scheduler/SchedulerBuilder.rs

@@ -1,50 +1,29 @@
-// Defines the fluent builder for creating and configuring a `Scheduler`
-// instance.
-
 use std::collections::HashMap;
 
 use log::warn;
 
 use super::Scheduler::Scheduler;
 
-/// An enum to define concurrency limits for named queues.
 #[derive(Debug, Clone, Copy)]
 pub enum Concurrency {
-	/// Specifies a maximum number of concurrent tasks for a queue.
 	Limit(usize),
 
-	/// Allows an unlimited number of concurrent tasks for a queue.
 	Unlimited,
 }
 
-/// A fluent builder for creating a `Scheduler`.
-///
-/// This pattern provides a clear and readable API for configuring complex
-/// objects, such as a multi-queue, multi-threaded scheduler, before they are
-/// constructed.
 pub struct SchedulerBuilder {
 	WorkerCount:usize,
 
-	/// Stores the configuration for named queues.
 	QueueConfiguration:HashMap<String, Concurrency>,
 }
 
 impl SchedulerBuilder {
-	/// Creates a new `SchedulerBuilder` with default settings.
-	///
-	/// By default, the worker count is set to the number of logical CPUs on the
-	/// system, with a minimum of 2.
 	pub fn New() -> Self {
 		let DefaultWorkerCount = num_cpus::get().max(2);
 
 		Self { WorkerCount:DefaultWorkerCount, QueueConfiguration:HashMap::new() }
 	}
 
-	/// Sets the total number of worker threads for the scheduler's pool.
-	///
-	/// # Arguments
-	/// * `WorkerCount` - The desired number of workers. If `0`, it defaults
-	/// to the number of logical CPUs on the system.
 	pub fn WithWorkerCount(mut self, WorkerCount:usize) -> Self {
 		if WorkerCount == 0 {
 			warn!("[SchedulerBuilder] Worker count of 0 is invalid. Defaulting to number of logical CPUs.");
@@ -57,31 +36,15 @@ impl SchedulerBuilder {
 		self
 	}
 
-	/// Configures a named queue with a specific concurrency limit.
-	/// Tasks can later be submitted to this specific queue.
-	///
-	/// # Arguments
-	/// * `QueueName` - The name of the queue (e.g., "DiskIO", "Network").
-	/// * `ConcurrencyLimit` - The concurrency configuration for this queue.
 	pub fn WithQueue(mut self, QueueName:&str, ConcurrencyLimit:Concurrency) -> Self {
 		self.QueueConfiguration.insert(QueueName.to_string(), ConcurrencyLimit);
 
 		self
 	}
 
-	/// Builds and starts the `Scheduler` with the specified configuration.
-	/// This consumes the builder.
-	///
-	/// # Returns
-	/// A new, running `Scheduler` instance.
-	pub fn Build(self) -> Scheduler {
-		// The Scheduler's internal `Start` method will receive this
-		// configuration and set up the corresponding queues and worker logic.
-		Scheduler::Start(self.WorkerCount, self.QueueConfiguration)
-	}
+	pub fn Build(self) -> Scheduler { Scheduler::Start(self.WorkerCount, self.QueueConfiguration) }
 }
 
 impl Default for SchedulerBuilder {
-	/// Provides a default `SchedulerBuilder` instance.
 	fn default() -> Self { Self::New() }
 }

Source/Scheduler/Worker.rs

@@ -17,8 +17,7 @@ pub struct Worker {
 impl Worker {
 	pub fn New(Context:Context<TaskStruct>, IsRunning:Arc<AtomicBool>) -> Self { Self { Context, Running:IsRunning } }
 
-	/// The main execution loop for the worker.
-	pub async fn Run(&self) {
+	pub async fn Run(self) {
 		trace!("[Worker {}] Starting execution loop.", self.Context.Identifier);
 
 		while self.Running.load(Ordering::Relaxed) {

Source/Scheduler/mod.rs

@@ -1,23 +1,5 @@
-// @module scheduler
-// @description This module defines the core public API for the Echo task
-// scheduler. It provides the `SchedulerBuilder` for configuration and the
-// `Scheduler` itself for managing the worker pool and submitting tasks.
-//
-
 #![allow(non_snake_case, non_camel_case_types)]
 
-// --- Sub-modules (Internal Implementation) ---
 pub mod Scheduler;
 pub mod SchedulerBuilder;
 pub mod Worker;
-
-// --- Public Re-exports ---
-
-// The main scheduler struct that manages the worker pool and task execution.
-// @see Scheduler
-//
-// pub use self::Scheduler::Scheduler;
-// The fluent builder for creating and configuring a `Scheduler` instance.
-// This is the primary entry point for using the Echo library.
-// @see SchedulerBuilder
-// pub use self::SchedulerBuilder::SchedulerBuilder;

Source/Task/Priority.rs

@@ -1,22 +1,8 @@
-/// @module Priority
-/// @description Defines the `Priority` enum for task scheduling within the Echo
-/// system.
-
-/// Represents the priority of a task to be executed by the scheduler.
-/// This enum implements `Ord`, allowing tasks to be sorted by priority.
-/// 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 Enum {
-	/// For background tasks that are not time-sensitive, such as logging,
-	/// telemetry, or non-critical file indexing.
 	Low,
 
-	/// The default priority for most standard operations.
 	Normal,
 
-	/// For tasks that directly impact perceived performance or are critical to
-	/// responsiveness, such as handling user input, providing code completions,
-	/// or responding to a "Go to Definition" request.
 	High,
 }

Source/Task/Task.rs

@@ -1,35 +1,17 @@
 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::Enum;
 use crate::Queue::StealingQueue::{Prioritized, Priority};
 
-/// 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.
 type BoxedFuture = Pin<Box<dyn Future<Output = ()> + Send>>;
 
-/// Represents a single, schedulable unit of work.
-///
-/// It encapsulates an asynchronous operation (`Future`) along with metadata,
-///
-/// such as its `Priority`, that the scheduler can use to determine execution
-/// order.
 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:Enum,
 }
 
 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:Enum) -> Self
 	where
 		F: Future<Output = ()> + Send + 'static, {

Source/Task/mod.rs

@@ -1,20 +1,4 @@
-// @module task
-// @description This module defines the core data structures for the Echo
-// scheduler, including the `Task` itself and its `Priority`.
-//
-
 #![allow(non_snake_case, non_camel_case_types)]
 
-// --- Sub-modules ---
 pub mod Priority;
 pub mod Task;
-
-// --- Public Re-exports ---
-
-// The enum representing the priority of a task.
-// @see Priority
-//
-// pub use self::Priority::Priority;
-// The struct representing a single unit of work for the scheduler.
-// @see Task
-// pub use self::Task::Task;