lscpu 1.0.9

Implementation of lscpu in rust
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
141
142
143
144
145
146

<div align="center">

# lscpu

[<img alt="crates.io" src="https://img.shields.io/crates/v/lscpu.svg?style=for-the-badge&color=fc8d62&logo=rust" height="20">](https://crates.io/crates/lscpu)
[<img alt="github" src="https://img.shields.io/badge/github-mateolafalce/lscpu-8da0cb?style=for-the-badge&labelColor=555555&logo=github" height="20">](https://github.com/mateolafalce/lscpu)
[<img alt="docs.rs" src="https://img.shields.io/badge/docs.rs-lscpu-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs" height="20">](https://docs.rs/lscpu)

A Rust implementation of the [lscpu](https://www.man7.org/linux/man-pages/man1/lscpu.1.html) command-line utility for displaying CPU architecture information.

</div>

## Features

- Written in pure Rust
- Fast and lightweight
- `no_std` compatible
- Easy to integrate as a library
- Cross-platform support (Linux focus)
- Zero external dependencies

## Installation

### As a Binary

Install the command-line tool directly from crates.io:

```bash
cargo install lscpu
```

After installation, you can run:

```bash
lscpu
```

### As a Library

Add this to your `Cargo.toml`:

```bash
cargo add lscpu
```

## Usage

### Command Line

Simply run the installed binary to get CPU information:

```bash
$ lscpu
Architecture:             x86_64
CPU op-mode(s):           32-bit, 64-bit
Address sizes:            48 bits physical, 48 bits virtual
Byte Order:               Little Endian
CPU(s):                   2
On-line CPU(s) list:      0,1
Vendor ID:                AuthenticAMD
Model name:               AMD A4-4000 APU with Radeon(tm) HD Graphics    
CPU family:               21
Model:                    19
Is hybrid:                no
Thread(s) per core:       2
Core(s) per socket:       1
Socket(s):                1
Stepping:                 1
Frequency boost:          enabled
```

### As a Library

```rust
use lscpu::Cpu;

fn main() {
    let cpu = Cpu::new();
    
    println!("Architecture: {}", cpu.architecture);
    println!("Model name: {}", cpu.model_name);
    println!("CPU count: {}", cpu.cpu_count);
    println!("Vendor ID: {}", cpu.vendor_id);
}
```

## Development

### Building from Source

```bash
git clone https://github.com/mateolafalce/lscpu.git
cd lscpu
cargo build --release
```

### Running Examples

Run the standard example:

```bash
cargo run --example std
```

This demonstrates basic usage and can also be run in a `no-std` environment.

## CPU Data Structure

The main `Cpu` struct provides comprehensive CPU information:

```rust
pub struct Cpu {
    pub architecture: &'static str,
    pub cpu_op_modes: &'static str,
    pub address_sizes: String,
    pub byte_order: &'static str,
    pub cpu_count: u32,
    pub on_line_cpu: u32,
    pub vendor_id: String,
    pub model_name: String,
    pub cpu_family: u32,
    pub cpu_model: u32,
    pub is_hybrid: &'static str,
    pub threads_per_core: u32,
    pub cores_per_socket: u32,
    pub sockets: u32,
    pub stepping: u32,
    pub boost_enabled: &'static str,
}
```

## Platform Support

Currently supports:
- Linux (primary target)
- Other Unix-like systems (limited support)
- Windows (not supported yet)

## License

This project is licensed under the GPL-3.0 License - see the [LICENSE](LICENSE) file for details.

## Acknowledgments

- Inspired by the original `lscpu` utility from util-linux
- Built with ❤️ in Rust