greynet 0.11.0

High performance rule and constraint satisfaction engine
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

//resource_limits.rs
//! Resource management and limits for the Greynet engine

/// Resource limits to prevent unbounded growth and ensure system stability
#[derive(Debug, Clone)]
pub struct ResourceLimits {
    /// Maximum number of tuples in the system
    pub max_tuples: usize,
    /// Maximum operations processed in a single batch
    pub max_operations_per_batch: usize,
    /// Maximum memory usage in megabytes (estimated)
    pub max_memory_mb: usize,
    /// Maximum depth for operation cascades
    pub max_cascade_depth: usize,
    /// Maximum facts per type
    pub max_facts_per_type: usize,
}

impl Default for ResourceLimits {

    /// No limits by default
    fn default() -> Self {
        Self {
            max_tuples: std::usize::MAX,
            max_operations_per_batch: std::usize::MAX,
            max_memory_mb: std::usize::MAX,
            max_cascade_depth: std::usize::MAX,
            max_facts_per_type: std::usize::MAX,
        }
    }
}

impl ResourceLimits {
    /// Create conservative limits for small systems
    pub fn conservative() -> Self {
        Self {
            max_tuples: 100_000,
            max_operations_per_batch: 10_000,
            max_memory_mb: 256,
            max_cascade_depth: 100,
            max_facts_per_type: 50_000,
        }
    }
    
    /// Create aggressive limits for high-performance systems
    pub fn aggressive() -> Self {
        Self {
            max_tuples: 100_000_000,
            max_operations_per_batch: 1_000_000,
            max_memory_mb: 8192,
            max_cascade_depth: 10_000,
            max_facts_per_type: 10_000_000,
        }
    }
    
    /// Estimate memory usage for current tuple count
    #[inline]
    pub fn estimate_memory_usage(&self, tuple_count: usize, node_count: usize) -> usize {
        // Rough estimation: 200 bytes per tuple + 1KB per node
        (tuple_count * 200 + node_count * 1024) / (1024 * 1024)
    }
    
    /// Check if operation would exceed limits
    pub fn check_operation_limit(&self, current_ops: usize) -> crate::error::Result<()> {
        if current_ops > self.max_operations_per_batch {
            return Err(crate::error::GreynetError::resource_limit(
                "operations_per_batch",
                format!("Current: {}, Limit: {}", current_ops, self.max_operations_per_batch)
            ));
        }
        Ok(())
    }
    
    /// Check if tuple count would exceed limits
    pub fn check_tuple_limit(&self, current_tuples: usize) -> crate::error::Result<()> {
        if current_tuples > self.max_tuples {
            return Err(crate::error::GreynetError::resource_limit(
                "max_tuples",
                format!("Current: {}, Limit: {}", current_tuples, self.max_tuples)
            ));
        }
        Ok(())
    }
}