amberjs 1.16.1

JavaScript/TypeScript runtime built with Rust and V8
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

// 批处理器实现
// 智能批处理网络请求，减少系统调用开销

use crate::network::{NetworkConfig, NetworkError};
use std::collections::{BTreeMap, HashMap};
use std::sync::{Arc, Mutex};
use std::time::Instant;

/// 批处理请求
#[derive(Debug, Clone)]
pub struct BatchRequest {
    /// 请求 ID
    pub id: u64,
    /// 请求数据
    pub data: Vec<u8>,
    /// 创建时间
    pub created_at: Instant,
    /// 优先级 (0-255, 数值越高优先级越高)
    pub priority: u8,
}
/// 批处理统计信息
#[derive(Debug, Clone)]
pub struct BatchProcessorStats {
    /// 总处理请求数
    pub total_requests: u64,
    /// 批处理次数
    pub batch_operations: usize,
    /// 平均批处理大小
    pub average_batch_size: f64,
    /// 批处理延迟 (微秒)
    pub batch_latency_us: u64,
    /// 丢弃的请求数
    pub dropped_requests: u64,
}
/// 批处理器
pub struct BatchProcessor {
    config: NetworkConfig,
    requests: Arc<Mutex<Vec<BatchRequest>>>,
    pending_count: Arc<Mutex<usize>>,
    stats: Arc<Mutex<BatchProcessorStats>>,
    next_request_id: Arc<Mutex<u64>>,
}
impl BatchProcessor {
    /// 创建新的批处理器
    pub fn new(config: NetworkConfig) -> Result<Self, NetworkError> {
        Ok(Self {
            config,
            requests: Arc::new(Mutex::new(Vec::new())),
            pending_count: Arc::new(Mutex::new(0)),
            stats: Arc::new(Mutex::new(BatchProcessorStats {
                total_requests: 0,
                batch_operations: 0,
                average_batch_size: 0.0,
                batch_latency_us: 0,
                dropped_requests: 0,
            })),
            next_request_id: Arc::new(Mutex::new(0)),
        })
    }
    /// 添加请求到批处理队列
    pub fn add_request(&mut self, data: Vec<u8>, priority: u8) -> Result<u64, NetworkError> {
        let mut requests = self.requests.lock().unwrap();
        let mut count = self.pending_count.lock().unwrap();
        let mut next_id = self.next_request_id.lock().unwrap();
        // 检查是否超过最大队列大小
        if requests.len() >= self.config.batch_size {
            let mut stats = self.stats.lock().unwrap();
            stats.dropped_requests += 1;
            return Err(NetworkError::ResourceExhausted);
        }
        let request: _ = BatchRequest {
            id: *next_id,
            data,
            priority,
            created_at: Instant::now(),
        };
        *next_id += 1;
        requests.push(request);
        *count += 1;
        Ok(*next_id - 1)
    }
    /// 添加请求 (简化版本，默认优先级)
    pub fn add_simple_request(&mut self, data: Vec<u8>) -> Result<u64, NetworkError> {
        self.add_request(data, 128) // 默认中等优先级
    }
    /// 处理批处理队列
    pub fn process_batch(&mut self) -> Result<Vec<BatchRequest>, NetworkError> {
        let mut requests = self.requests.lock().unwrap();
        let mut count = self.pending_count.lock().unwrap();
        let mut stats = self.stats.lock().unwrap();
        if requests.is_empty() {
            return Ok(Vec::new());
        }
        // 按优先级排序 (高优先级在前)
        requests.sort_by(|a, b| b.priority.cmp(&a.priority));
        let batch_size: _ = std::cmp::min(requests.len(), self.config.batch_size);
        let processed_requests: _ = requests.drain(0..batch_size).collect();
        *count = requests.len();
        // 更新统计信息
        stats.total_requests += batch_size as u64;
        stats.batch_operations += 1;
        stats.average_batch_size = stats.total_requests as f64 / stats.batch_operations as f64;
        Ok(processed_requests)
    }
    /// 获取待处理请求数量
    pub fn pending_count(&self) -> usize {
        *self.pending_count.lock().unwrap()
    }
    /// 获取统计信息
    pub fn get_stats(&self) -> BatchProcessorStats {
        self.stats.lock().unwrap().clone()
    }
    /// 清空批处理队列
    pub fn clear(&mut self) {
        let mut requests = self.requests.lock().unwrap();
        let mut count = self.pending_count.lock().unwrap();
        requests.clear();
        *count = 0;
    }
    /// 检查是否应该触发批处理
    pub fn should_process(&self) -> bool {
        let count: _ = *self.pending_count.lock().unwrap();
        count >= self.config.batch_size / 2 || // 达到批处理大小的一半
           count > 0 && self.is_timeout()      // 有待处理请求且超时
    }
    /// 检查是否超时
    fn is_timeout(&self) -> bool {
        let requests: _ = self.requests.lock().unwrap();
        if let Some(oldest) = requests.first() {
            oldest.created_at.elapsed() >= self.config.batch_timeout
        } else {
            false
        }
    }
}
impl Default for BatchProcessor {
    fn default() -> Self {
        BatchProcessor::new(NetworkConfig::default()).unwrap()
    }
}