oxirs-core 0.3.1

Core RDF and SPARQL functionality for OxiRS - native Rust implementation with zero dependencies
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

//! Advanced optimization configuration: SIMD, zero-copy, prefetching, caching.

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::Duration;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OptimizationConfig {
    pub simd: SimdConfig,
    pub zero_copy: ZeroCopyConfig,
    pub prefetching: PrefetchingConfig,
    pub caching: CachingConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SimdConfig {
    pub enabled: bool,
    pub instruction_set: SimdInstructionSet,
    pub fallback_to_scalar: bool,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum SimdInstructionSet {
    None,
    SSE2,
    AVX,
    AVX2,
    AVX512,
    NEON,
    Auto,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ZeroCopyConfig {
    pub enabled: bool,
    pub arena_size: usize,
    pub reference_counting: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PrefetchingConfig {
    pub enabled: bool,
    pub distance: usize,
    pub strategy: PrefetchStrategy,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum PrefetchStrategy {
    Sequential,
    Random,
    Adaptive,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CachingConfig {
    pub caches: HashMap<String, CacheConfig>,
    pub global: GlobalCacheConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CacheConfig {
    pub name: String,
    pub cache_type: CacheType,
    pub max_size: usize,
    pub ttl: Duration,
    pub eviction_policy: EvictionPolicy,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum CacheType {
    LRU,
    LFU,
    FIFO,
    Random,
    Adaptive,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum EvictionPolicy {
    LRU,
    LFU,
    TTL,
    Size,
    Custom,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GlobalCacheConfig {
    pub memory_limit: usize,
    pub enable_statistics: bool,
    pub enable_warming: bool,
}

impl Default for OptimizationConfig {
    fn default() -> Self {
        Self {
            simd: SimdConfig::default(),
            zero_copy: ZeroCopyConfig::default(),
            prefetching: PrefetchingConfig::default(),
            caching: CachingConfig::default(),
        }
    }
}

impl Default for SimdConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            instruction_set: SimdInstructionSet::Auto,
            fallback_to_scalar: true,
        }
    }
}

impl Default for ZeroCopyConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            arena_size: 1024 * 1024,
            reference_counting: true,
        }
    }
}

impl Default for PrefetchingConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            distance: 64,
            strategy: PrefetchStrategy::Adaptive,
        }
    }
}

impl Default for CachingConfig {
    fn default() -> Self {
        Self {
            caches: HashMap::new(),
            global: GlobalCacheConfig::default(),
        }
    }
}

impl Default for GlobalCacheConfig {
    fn default() -> Self {
        Self {
            memory_limit: 256 * 1024 * 1024,
            enable_statistics: true,
            enable_warming: true,
        }
    }
}