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

//! Concurrency configuration for OxiRS Core.

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

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConcurrencyConfig {
    pub thread_pool: ThreadPoolConfig,
    pub locks: LockConfig,
    pub async_runtime: AsyncRuntimeConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThreadPoolConfig {
    pub worker_threads: usize,
    pub stack_size: usize,
    pub priority: ThreadPriority,
    pub work_stealing: bool,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ThreadPriority {
    Low,
    Normal,
    High,
    Realtime,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LockConfig {
    pub default_type: LockType,
    pub timeout: Duration,
    pub enable_debugging: bool,
    pub deadlock_detection: bool,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum LockType {
    Mutex,
    RwLock,
    SpinLock,
    AtomicLock,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AsyncRuntimeConfig {
    pub runtime_type: AsyncRuntimeType,
    pub enable_io: bool,
    pub enable_time: bool,
    pub worker_config: AsyncWorkerConfig,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum AsyncRuntimeType {
    CurrentThread,
    MultiThread,
    MultiThreadAlt,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AsyncWorkerConfig {
    pub core_threads: usize,
    pub max_threads: usize,
    pub keep_alive: Duration,
    pub thread_name_prefix: String,
}

impl Default for ConcurrencyConfig {
    fn default() -> Self {
        Self {
            thread_pool: ThreadPoolConfig::default(),
            locks: LockConfig::default(),
            async_runtime: AsyncRuntimeConfig::default(),
        }
    }
}

impl Default for ThreadPoolConfig {
    fn default() -> Self {
        Self {
            worker_threads: 0,
            stack_size: 2 * 1024 * 1024,
            priority: ThreadPriority::Normal,
            work_stealing: true,
        }
    }
}

impl Default for LockConfig {
    fn default() -> Self {
        Self {
            default_type: LockType::RwLock,
            timeout: Duration::from_secs(30),
            enable_debugging: false,
            deadlock_detection: true,
        }
    }
}

impl Default for AsyncRuntimeConfig {
    fn default() -> Self {
        Self {
            runtime_type: AsyncRuntimeType::MultiThread,
            enable_io: true,
            enable_time: true,
            worker_config: AsyncWorkerConfig::default(),
        }
    }
}

impl Default for AsyncWorkerConfig {
    fn default() -> Self {
        Self {
            core_threads: num_cpus::get(),
            max_threads: num_cpus::get() * 4,
            keep_alive: Duration::from_secs(60),
            thread_name_prefix: "oxirs-async".to_string(),
        }
    }
}