Struct nando_lib::nando_scheduler::NandoScheduler

pub struct NandoScheduler {
    _scheduler_submission_thread: JoinHandle<()>,
    _scheduler_completion_threads: Vec<JoinHandle<()>>,
    sender: Sender<SchedulerInputKind>,
    nando_libraries: DashMap<String, Library>,
    epic_control_registry: Arc<DashMap<EcbId, ControlRegistryEntry>>,
    cached_functions: DashMap<String, Arc<ActivationFunction>>,
    cached_metadata: DashMap<String, NandoMetadata>,
    physical_plan_manager: Arc<PhysicalPlanManager>,
}

Fields

_scheduler_submission_thread: JoinHandle<()>

_scheduler_completion_threads: Vec<JoinHandle<()>>

sender: Sender<SchedulerInputKind>

nando_libraries: DashMap<String, Library>

epic_control_registry: Arc<DashMap<EcbId, ControlRegistryEntry>>

cached_functions: DashMap<String, Arc<ActivationFunction>>

cached_metadata: DashMap<String, NandoMetadata>

physical_plan_manager: Arc<PhysicalPlanManager>

Implementations

impl NandoScheduler

fn new( object_tracker: Arc<ObjectTracker>, config: SchedulerConfig, num_worker_threads: u16 ) -> Self

pub fn get_nando_scheduler( maybe_object_tracker: Option<Arc<ObjectTracker>>, maybe_nando_lib_config: Option<Config> ) -> &'static NandoScheduler

pub fn get_nando_scheduler_mut( maybe_object_tracker: Option<Arc<ObjectTracker>>, maybe_nando_lib_config: Option<Config> ) -> &'static mut NandoScheduler

pub fn handle_subtask_completion( &self, task_id: EcbId, tasks_to_notify: &Vec<(DownstreamTaskDependency, Option<NandoResult>)>, submit_local: bool ) -> SubtaskCompletionResult

pub fn get_nando_metadata_external( nando_name: &String ) -> Result<NandoMetadata, String>

fn get_nando_metadata( &self, full_name: &String ) -> Result<NandoMetadata, String>

fn get_nando_function( &self, full_name: &String ) -> Result<Arc<ActivationFunction>, String>

pub fn schedule_activation( &self, txn_id: TxnId, activation_intent: NandoActivationIntent, with_plan: Option<String> ) -> Result<ScheduleResult, String>

pub fn schedule_externally_spawned_task( &self, txn_id: TxnId, spawned_task: SpawnedTask ) -> Result<ScheduleResult, String>

pub fn schedule_parkable_entry(&self, entry: ControlRegistryEntry)

pub fn store_externally_spawned_task(&self, spawned_task: SpawnedTask)

pub fn get_ecb_result_and_status( &self, ecb_id: EcbId ) -> Option<(Option<NandoResult>, TaskStatus)>

fn get_safe_majority(worker_allocations: &Vec<(u16, f32)>) -> u16

fn compute_activation_dependencies( activation: &NandoActivation, stats_map: &mut HashMap<ObjectId, Rc<RefCell<ObjectStats>>>, num_executors: usize, existing_cores: &mut Vec<(u16, f32)>, dependency_stats: &mut Vec<(ObjectId, Rc<RefCell<ObjectStats>>)>, rng: &mut SmallRng, aggregate_executor_stats: Arc<AggregateExecutorStats> ) -> (usize, Option<Vec<ActivationId>>)

const EXECUTOR_DEPTH_THRESHOLD: f64 = 0.94999999999999996f64

fn at_capacity(aggregate_executor_stats: Arc<AggregateExecutorStats>) -> bool

pub fn poll_and_schedule( external_queue_recv: Receiver<SchedulerInputKind>, pending_txn_dependencies: Arc<DashMap<ActivationId, TxnDependency>>, aggregate_executor_stats: Arc<AggregateExecutorStats>, executor_channels: Vec<Producer<NandoActivation>>, executor_queue_capacity: usize )

fn poll_log_queue( log_queue_recv: Consumer<NandoActivation>, scheduler_queue_send: Sender<SchedulerInputKind>, aggregate_executor_stats: Arc<AggregateExecutorStats>, epic_control_registry: Arc<DashMap<EcbId, ControlRegistryEntry>> )

fn dependency_is_local(&self, dependency: &DownstreamTaskDependency) -> bool

fn handle_task_completion_for_dependency( &self, task_id: EcbId, dependency: &DownstreamTaskDependency, result: Option<NandoResult> ) -> Option<(TaskCompletionPropagationResult, Option<EcbId>, Option<NandoResult>)>

Note that the below operation is a no-op if called on a dependency that is not owned by the current host. It is the responsibility of the caller of this function to perform the ownership checks necessary to ensure that the dependency is local, and to also check if the result can be further processed locally or need to be propagated to other workers.