splimes 0.1.0

Spline interpolation over irregularly sampled time series, on SIMD/parallel CPU or GPU (wgpu), with BigDecimal values.
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

use crate::gpu::buffer_pool::BufferPoolConfig;

/// Global GPU configuration for interpolation operations
#[derive(Debug, Clone)]
pub struct GpuConfig {
	/// Configuration for the buffer pool
	pub buffer_pool: BufferPoolConfig,
	/// Number of staging buffers to maintain (default: 3)
	pub num_staging_buffers: usize,
	/// Maximum command batch size (for future optimization)
	pub max_command_batch_size: usize,
}

impl Default for GpuConfig {
	fn default() -> Self {
		Self::default_config()
	}
}

impl GpuConfig {
	/// Default configuration for balanced performance and memory usage
	const fn default_config() -> Self {
		Self {
			buffer_pool: BufferPoolConfig {
				max_pool_memory: 512 * 1024 * 1024, // 512MB
				eviction_timeout_secs: 30,
			},
			num_staging_buffers: 3,
			max_command_batch_size: 16,
		}
	}

	/// Conservative configuration for low-memory systems
	///
	/// Uses smaller pool, fewer buffers, and smaller batches
	#[must_use]
	pub const fn low_memory() -> Self {
		Self {
			buffer_pool: BufferPoolConfig {
				max_pool_memory: 128 * 1024 * 1024, // 128MB
				eviction_timeout_secs: 20,
			},
			num_staging_buffers: 2,
			max_command_batch_size: 8,
		}
	}

	/// High-performance configuration for systems with abundant memory
	///
	/// Uses larger pool, more buffers, and larger batches
	#[must_use]
	pub const fn high_performance() -> Self {
		Self {
			buffer_pool: BufferPoolConfig {
				max_pool_memory: 1024 * 1024 * 1024, // 1GB
				eviction_timeout_secs: 45,
			},
			num_staging_buffers: 4,
			max_command_batch_size: 32,
		}
	}

	/// Minimal configuration for extremely constrained environments
	#[must_use]
	pub const fn minimal() -> Self {
		Self {
			buffer_pool: BufferPoolConfig {
				max_pool_memory: 64 * 1024 * 1024, // 64MB
				eviction_timeout_secs: 15,
			},
			num_staging_buffers: 1,
			max_command_batch_size: 4,
		}
	}
}

#[cfg(test)]
mod tests {
	use super::*;

	#[test]
	fn test_default_config() {
		let config = GpuConfig::default();
		assert_eq!(config.buffer_pool.max_pool_memory, 512 * 1024 * 1024);
		assert_eq!(config.num_staging_buffers, 3);
		assert_eq!(config.max_command_batch_size, 16);
	}

	#[test]
	fn test_low_memory_config() {
		let config = GpuConfig::low_memory();
		assert_eq!(config.buffer_pool.max_pool_memory, 128 * 1024 * 1024);
		assert_eq!(config.num_staging_buffers, 2);
		assert_eq!(config.max_command_batch_size, 8);
	}

	#[test]
	fn test_high_performance_config() {
		let config = GpuConfig::high_performance();
		assert_eq!(config.buffer_pool.max_pool_memory, 1024 * 1024 * 1024);
		assert_eq!(config.num_staging_buffers, 4);
		assert_eq!(config.max_command_batch_size, 32);
	}

	#[test]
	fn test_minimal_config() {
		let config = GpuConfig::minimal();
		assert_eq!(config.buffer_pool.max_pool_memory, 64 * 1024 * 1024);
		assert_eq!(config.num_staging_buffers, 1);
	}

	#[test]
	fn test_configs_are_cloneable() {
		let config = GpuConfig::default();
		let cloned = config.clone();
		assert_eq!(cloned.num_staging_buffers, config.num_staging_buffers);
	}
}