Struct PerformanceHints 

pub struct PerformanceHints {
    pub complexity: ComplexityClass,
    pub simd_friendly: bool,
    pub parallelizable: bool,
    pub gpu_friendly: bool,
    pub memory_pattern: MemoryPattern,
    pub cache_behavior: CacheBehavior,
    pub io_pattern: IoPattern,
    pub optimization_level: OptimizationLevel,
    pub custom_hints: HashMap<String, String>,
    pub expected_duration: Option<DurationRange>,
    pub memory_requirements: Option<MemoryRequirements>,
}

Performance characteristics of a function

Fields

complexity: ComplexityClass

Expected computational complexity (e.g., O(n), O(n²), etc.)

simd_friendly: bool

Whether the function benefits from SIMD optimization

parallelizable: bool

Whether the function can be parallelized

gpu_friendly: bool

Whether the function benefits from GPU acceleration

memory_pattern: MemoryPattern

Expected memory usage pattern

cache_behavior: CacheBehavior

Cache behavior characteristics

io_pattern: IoPattern

I/O characteristics

optimization_level: OptimizationLevel

Preferred optimization level

custom_hints: HashMap<String, String>

Function-specific optimization hints

expected_duration: Option<DurationRange>

Expected execution time range

memory_requirements: Option<MemoryRequirements>

Memory requirements

Implementations

impl PerformanceHints

pub fn new() -> Self

Create a new set of performance hints

pub fn with_complexity(self, complexity: ComplexityClass) -> Self

Set the computational complexity

pub fn simd_friendly(self) -> Self

Mark as SIMD-friendly

pub fn parallelizable(self) -> Self

Mark as parallelizable

pub fn gpu_friendly(self) -> Self

Mark as GPU-friendly

pub fn with_memory_pattern(self, pattern: MemoryPattern) -> Self

Set memory access pattern

pub fn with_cache_behavior(self, behavior: CacheBehavior) -> Self

Set cache behavior

pub fn with_io_pattern(self, pattern: IoPattern) -> Self

Set I/O pattern

pub fn with_optimization_level(self, level: OptimizationLevel) -> Self

Set optimization level

pub fn with_custom_hint<K: Into<String>, V: Into<String>>( self, key: K, value: V, ) -> Self

Add a custom hint

pub fn with_expected_duration(self, range: DurationRange) -> Self

Set expected duration range

pub fn with_memory_requirements(self, requirements: MemoryRequirements) -> Self

Set memory requirements

pub fn get_custom_hint(&self, key: &str) -> Option<&String>

Get a specific custom hint

pub fn should_use_simd(&self) -> bool

Check if the function should use SIMD optimization

pub fn should_parallelize(&self) -> bool

Check if the function should be parallelized

pub fn should_use_gpu(&self) -> bool

Check if the function should use GPU acceleration

pub fn should_chunk(&self, inputsize: usize) -> bool

Estimate if the operation is suitable for chunking

Trait Implementations

impl Clone for PerformanceHints

fn clone(&self) -> PerformanceHints

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PerformanceHints

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PerformanceHints

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for PerformanceHints

fn eq(&self, other: &PerformanceHints) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for PerformanceHints