Struct RiDeviceScheduler 

pub struct RiDeviceScheduler { /* private fields */ }

Device Scheduler

This file implements a comprehensive device scheduler for Ri, responsible for:

1. Managing device resource allocation and scheduling
2. Implementing multiple scheduling algorithms
3. Recording allocation history and statistics
4. Providing scheduling recommendations based on historical data

Design Principles

1. Multiple Scheduling Algorithms: Supports FirstFit, BestFit, WorstFit, RoundRobin, PriorityBased, and LoadBalanced policies
2. Policy Per Device Type: Different device types can have different scheduling policies
3. Allocation History: Maintains detailed records of all allocations
4. Statistics and Recommendations: Provides insights into scheduling effectiveness and recommendations for optimization
5. Resource Pool Integration: Works closely with the resource pool manager
6. Thread Safety: Uses Arc and Mutex for thread-safe operations
7. Scalability: Designed to handle large numbers of devices and allocations

Usage Examples

use ri::device::{RiDeviceScheduler, RiAllocationRequest, RiDeviceType, RiDeviceCapabilities};
use ri::device::pool::RiResourcePoolManager;
use std::sync::{Arc, Mutex};
 
fn example() {
    // Create resource pool manager
    let pool_manager = Arc::new(Mutex::new(RiResourcePoolManager::new()));
     
    // Create device scheduler
    let mut scheduler = RiDeviceScheduler::new(pool_manager);
     
    // Set scheduling policy for GPUs
    scheduler.set_policy(RiDeviceType::GPU, ri::device::RiSchedulingPolicy::PriorityBased);
     
    // Create allocation request
    let request = RiAllocationRequest {
        device_type: RiDeviceType::GPU,
        capabilities: RiDeviceCapabilities {
            memory_gb: Some(16.0),
            compute_units: Some(512),
            storage_gb: None,
            bandwidth_gbps: None,
            custom_capabilities: HashMap::new(),
        },
        priority: 5,
        timeout_secs: 30,
    };
     
    // Allocate device
    if let Some(allocation_id) = scheduler.allocate(&request) {
        println!("Allocated device with ID: {}", allocation_id);
         
        // Record release when done
        scheduler.record_release(&allocation_id);
    }
     
    // Get statistics
    let stats = scheduler.get_statistics();
    println!("Total allocations: {}", stats.total_allocations);
}

Device scheduler - manages device resource allocation and scheduling

This struct implements a comprehensive device scheduling system that manages resource allocation using various scheduling algorithms. It works closely with the resource pool manager to access available devices and implements multiple scheduling policies per device type.

Implementations

impl RiDeviceScheduler

pub fn new(resource_pool_manager: Arc<RwLock<RiResourcePoolManager>>) -> Self

Create a new device scheduler with default policies and empty allocation history.

This method initializes the scheduler with default scheduling policies for each device type and connects it to the provided resource pool manager.

Parameters

• resource_pool_manager: Resource pool manager for accessing available devices

Returns

A new RiDeviceScheduler instance with default policies and settings.

pub fn get_policy(&self, device_type: &RiDeviceType) -> &RiSchedulingPolicy

Get the scheduling policy for a specific device type.

This method returns the scheduling policy configured for the specified device type. If no policy is configured, it returns the default FirstFit policy.

Parameters

• device_type: Device type to get the policy for

Returns

A reference to the RiSchedulingPolicy for the specified device type.

pub fn set_policy( &mut self, device_type: RiDeviceType, policy: RiSchedulingPolicy, )

Set the scheduling policy for a specific device type.

This method configures the scheduling policy for the specified device type.

Parameters

• device_type: Device type to set the policy for
• policy: Scheduling policy to use for this device type

pub async fn select_device( &self, request: &RiAllocationRequest, ) -> Option<Arc<RiDevice>>

Select a device based on the scheduling policy for the requested device type.

This method selects the best device for the allocation request by:

1. Getting the appropriate scheduling policy for the device type
2. Collecting available devices from the resource pool manager
3. Filtering devices that meet the requirements
4. Applying the scheduling policy to select the best device

Parameters

• request: Allocation request with device type, capabilities, priority, and timeout

Returns

An Arc<RiDevice> if a suitable device was found, or None if no device meets the requirements.

pub async fn allocate(&self, request: &RiAllocationRequest) -> Option<String>

Allocate a device based on the scheduling policy.

This method selects a device using the appropriate scheduling policy and records the allocation.

Parameters

• request: Allocation request with device type, capabilities, priority, and timeout

Returns

An allocation ID if successful, or None if no suitable device was found.

pub async fn record_allocation( &self, allocation_id: String, device_id: String, device_type: RiDeviceType, capabilities_required: RiDeviceCapabilities, )

Record an allocation in the history.

This method records a new allocation in the history, including device information, capabilities required, and allocation time.

Parameters

• allocation_id: Unique allocation identifier
• device_id: ID of the allocated device
• device_type: Type of the allocated device
• capabilities_required: Capabilities required for this allocation

pub async fn record_release(&self, allocation_id: &str)

Record the release of an allocation.

This method updates an allocation record to mark it as released, including the release time and duration of the allocation.

Parameters

• allocation_id: ID of the allocation to release

pub async fn get_statistics(&self) -> RiAllocationStatistics

Get allocation statistics and metrics.

This method calculates comprehensive statistics about allocations, including:

• Total and successful allocations
• Success rate
• Average allocation duration
• Statistics by device type

Returns

A RiAllocationStatistics struct containing comprehensive allocation statistics.

pub async fn get_recommendations( &self, device_type: &RiDeviceType, ) -> Vec<RiSchedulingRecommendation>

Get scheduling recommendations based on historical data.

Trait Implementations

impl<'py> IntoPyObject<'py> for RiDeviceScheduler

type Target = RiDeviceScheduler

The Python output type

type Output = Bound<'py, <RiDeviceScheduler as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PyClass for RiDeviceScheduler

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for RiDeviceScheduler

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = c"# Device Scheduler\n\nThis file implements a comprehensive device scheduler for Ri, responsible for:\n1. Managing device resource allocation and scheduling\n2. Implementing multiple scheduling algorithms\n3. Recording allocation history and statistics\n4. Providing scheduling recommendations based on historical data\n\n## Design Principles\n\n1. **Multiple Scheduling Algorithms**: Supports FirstFit, BestFit, WorstFit, RoundRobin, PriorityBased, and LoadBalanced policies\n2. **Policy Per Device Type**: Different device types can have different scheduling policies\n3. **Allocation History**: Maintains detailed records of all allocations\n4. **Statistics and Recommendations**: Provides insights into scheduling effectiveness and recommendations for optimization\n5. **Resource Pool Integration**: Works closely with the resource pool manager\n6. **Thread Safety**: Uses Arc and Mutex for thread-safe operations\n7. **Scalability**: Designed to handle large numbers of devices and allocations\n\n## Usage Examples\n\n```rust\nuse ri::device::{RiDeviceScheduler, RiAllocationRequest, RiDeviceType, RiDeviceCapabilities};\nuse ri::device::pool::RiResourcePoolManager;\nuse std::sync::{Arc, Mutex};\n\nfn example() {\n // Create resource pool manager\n let pool_manager = Arc::new(Mutex::new(RiResourcePoolManager::new()));\n \n // Create device scheduler\n let mut scheduler = RiDeviceScheduler::new(pool_manager);\n \n // Set scheduling policy for GPUs\n scheduler.set_policy(RiDeviceType::GPU, ri::device::RiSchedulingPolicy::PriorityBased);\n \n // Create allocation request\n let request = RiAllocationRequest {\n device_type: RiDeviceType::GPU,\n capabilities: RiDeviceCapabilities {\n memory_gb: Some(16.0),\n compute_units: Some(512),\n storage_gb: None,\n bandwidth_gbps: None,\n custom_capabilities: HashMap::new(),\n },\n priority: 5,\n timeout_secs: 30,\n };\n \n // Allocate device\n if let Some(allocation_id) = scheduler.allocate(&request) {\n println!(\"Allocated device with ID: {}\", allocation_id);\n \n // Record release when done\n scheduler.record_release(&allocation_id);\n }\n \n // Get statistics\n let stats = scheduler.get_statistics();\n println!(\"Total allocations: {}\", stats.total_allocations);\n}\n```\nDevice scheduler - manages device resource allocation and scheduling\n\nThis struct implements a comprehensive device scheduling system that manages\nresource allocation using various scheduling algorithms. It works closely with\nthe resource pool manager to access available devices and implements multiple\nscheduling policies per device type.\x00"

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<RiDeviceScheduler>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyTypeInfo for RiDeviceScheduler

const NAME: &'static str = "RiDeviceScheduler"

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl DerefToPyAny for RiDeviceScheduler

impl ExtractPyClassWithClone for RiDeviceScheduler