ros666/task/
pid.rs

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
//! 进程 ID(PID)分配器

use core::{cell::RefCell, ops::Range};

use alloc::vec::Vec;
use lazy_static::lazy_static;

use crate::utils::safety::SyncRefCell;

lazy_static! {
    /// 全局 PID 分配器
    pub static ref PID_ALLOCATOR: SyncRefCell<PidAllocator> = SyncRefCell {
        ref_cell: RefCell::new(PidAllocator::new())
    };
}

/// PID 句柄
///
/// 当 PID 句柄被丢弃时,自动释放 PID
pub struct PidHandler(pub usize);

/// PID 分配器
///
/// PID 分配器基于栈分配 PID,维护了未使用的 PID 范围和回收的 PID 列表。
pub struct PidAllocator {
    /// 未使用的 PID 范围
    unused: Range<usize>,
    /// 回收的 PID 列表
    recycled: Vec<usize>,
}

impl PidAllocator {
    /// 创建一个新的 PID 分配器
    fn new() -> Self {
        Self {
            unused: 0..(usize::MAX - 256), // 保留 256 个 PID
            recycled: Vec::new(),
        }
    }

    /// 分配一个新的 PID
    fn alloc(&mut self) -> Option<PidHandler> {
        // 优先使用回收的 PID
        if let Some(pid) = self.recycled.pop() {
            return Some(PidHandler(pid));
        }
        // 如果没有回收的 PID,则使用未使用的 PID
        if self.unused.start < self.unused.end {
            let pid = self.unused.start;
            self.unused.start += 1;
            return Some(PidHandler(pid));
        }
        None
    }

    /// 释放一个 PID
    fn dealloc(&mut self, pid: usize) {
        // 检查 PID 是否在未使用的范围内并且是否已经在回收列表中
        if pid >= self.unused.start {
            panic!("尝试释放未分配的 PID: {:?}", pid);
        }
        if self.recycled.iter().any(|&f| f == pid) {
            panic!("尝试释放已释放的 PID: {:?}", pid);
        }
        // 将 PID 添加到回收列表中
        self.recycled.push(pid);
    }

    /// 分配一个新的 PID 并返回处理器
    pub fn alloc_pid() -> PidHandler {
        PID_ALLOCATOR.ref_cell.borrow_mut().alloc().unwrap()
    }
}

impl Drop for PidHandler {
    /// 当 PID 处理器被丢弃时,自动释放 PID
    fn drop(&mut self) {
        PID_ALLOCATOR.ref_cell.borrow_mut().dealloc(self.0);
    }
}