const_sizes 0.1.54

提供友好可读的常量大小
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

//! 常量大小定义
//!
//! 对标 Linux `<linux/sizes.h>` 的 `SZ_*` 宏，2 的幂次序列。
//! 单位均为 power-of-2 binary（1K = 1024、1M = `1_048_576`、1G = `1_073_741_824`）。

#![no_std]

/// 1 byte
pub const SZ_1: usize = 0x1;
/// 2 bytes
pub const SZ_2: usize = 0x2;
/// 4 bytes
pub const SZ_4: usize = 0x4;
/// 8 bytes
pub const SZ_8: usize = 0x8;
/// 16 bytes
pub const SZ_16: usize = 0x10;
/// 32 bytes
pub const SZ_32: usize = 0x20;
/// 64 bytes（典型 cache line）
pub const SZ_64: usize = 0x40;
/// 128 bytes
pub const SZ_128: usize = 0x80;
/// 256 bytes
pub const SZ_256: usize = 0x100;
/// 512 bytes
pub const SZ_512: usize = 0x200;

/// 1 KiB (1024 bytes)
pub const SZ_1K: usize = 0x400;
/// 2 KiB
pub const SZ_2K: usize = 0x800;
/// 4 KiB（典型 page size）
pub const SZ_4K: usize = 0x1000;
/// 8 KiB
pub const SZ_8K: usize = 0x2000;
/// 16 KiB（典型 thread stack 起步）
pub const SZ_16K: usize = 0x4000;
/// 32 KiB
pub const SZ_32K: usize = 0x8000;
/// 64 KiB
pub const SZ_64K: usize = 0x1_0000;
/// 128 KiB
pub const SZ_128K: usize = 0x2_0000;
/// 256 KiB
pub const SZ_256K: usize = 0x4_0000;
/// 512 KiB
pub const SZ_512K: usize = 0x8_0000;

/// 1 MiB
pub const SZ_1M: usize = 0x10_0000;
/// 2 MiB（典型 huge page）
pub const SZ_2M: usize = 0x20_0000;
/// 4 MiB
pub const SZ_4M: usize = 0x40_0000;
/// 8 MiB
pub const SZ_8M: usize = 0x80_0000;
/// 16 MiB
pub const SZ_16M: usize = 0x100_0000;
/// 32 MiB
pub const SZ_32M: usize = 0x200_0000;
/// 64 MiB
pub const SZ_64M: usize = 0x400_0000;
/// 128 MiB
pub const SZ_128M: usize = 0x800_0000;
/// 256 MiB
pub const SZ_256M: usize = 0x1000_0000;
/// 512 MiB
pub const SZ_512M: usize = 0x2000_0000;

/// 1 GiB
pub const SZ_1G: usize = 0x4000_0000;
/// 2 GiB
pub const SZ_2G: usize = 0x8000_0000;
/// 4 GiB
pub const SZ_4G: usize = 0x1_0000_0000;
/// 8 GiB
pub const SZ_8G: usize = 0x2_0000_0000;
/// 16 GiB
pub const SZ_16G: usize = 0x4_0000_0000;
/// 32 GiB
pub const SZ_32G: usize = 0x8_0000_0000;

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

    #[test]
    fn sizes() {
        assert_eq!(SZ_1, 1);
        assert_eq!(SZ_2, 2);
        assert_eq!(SZ_4, 4);
        assert_eq!(SZ_8, 8);
        assert_eq!(SZ_16, 16);
        assert_eq!(SZ_32, 32);
        assert_eq!(SZ_64, 64);
        assert_eq!(SZ_128, 128);
        assert_eq!(SZ_256, 256);
        assert_eq!(SZ_512, 512);
        assert_eq!(SZ_1K, 1024);
        assert_eq!(SZ_2K, 2 * 1024);
        assert_eq!(SZ_4K, 4 * 1024);
        assert_eq!(SZ_8K, 8 * 1024);
        assert_eq!(SZ_16K, 16 * 1024);
        assert_eq!(SZ_32K, 32 * 1024);
        assert_eq!(SZ_64K, 64 * 1024);
        assert_eq!(SZ_128K, 128 * 1024);
        assert_eq!(SZ_256K, 256 * 1024);
        assert_eq!(SZ_512K, 512 * 1024);
        assert_eq!(SZ_1M, 1 * 1024 * 1024);
        assert_eq!(SZ_2M, 2 * 1024 * 1024);
        assert_eq!(SZ_4M, 4 * 1024 * 1024);
        assert_eq!(SZ_8M, 8 * 1024 * 1024);
        assert_eq!(SZ_16M, 16 * 1024 * 1024);
        assert_eq!(SZ_32M, 32 * 1024 * 1024);
        assert_eq!(SZ_64M, 64 * 1024 * 1024);
        assert_eq!(SZ_128M, 128 * 1024 * 1024);
        assert_eq!(SZ_256M, 256 * 1024 * 1024);
        assert_eq!(SZ_512M, 512 * 1024 * 1024);
        assert_eq!(SZ_1G, 1 * 1024 * 1024 * 1024);
        assert_eq!(SZ_2G, 2 * 1024 * 1024 * 1024);
        assert_eq!(SZ_4G, 4 * 1024 * 1024 * 1024);
        assert_eq!(SZ_8G, 8 * 1024 * 1024 * 1024);
        assert_eq!(SZ_16G, 16 * 1024 * 1024 * 1024);
        assert_eq!(SZ_32G, 32 * 1024 * 1024 * 1024);
    }
}