sysinfo

sysinfo

sysinfo es una caja utilizada para obtener la información de un sistema.

OSE apoyados

Actualmente es compatible con los siguientes sistemas operativos (ordenado alfabéticamente):

• Androide
• FreeBSD
• iOS
• Linux
• macosa
• Frambuesa pi
• Windows

Todavía puede usar sysinfo en OSE no apoyados, simplemente no hará nada y siempre devolverá valores vacíos. Puede verificar su programa directamente si se admite un sistema operativo verificando la constante [ IS_SUPPORTED_SYSTEM ].

La versión mínima de rustc es 1.74 .

Uso

Si desea migrar de una versión anterior, no dude en echar un vistazo al ChangeLog y a la Guía de migración.

️ Antes de cualquier intento de leer la información de las diferentes estructuras, debe actualizarlos para obtener información actualizada porque para la mayoría de ellos, funciona en la diferencia entre el valor actual y el anterior.

Por eso, es mucho mejor mantener la misma instancia de [ System ] en lugar de recrearla varias veces.

Tiene un ejemplo en la carpeta de examples . Puede ejecutarlo con cargo run --example simple .

De lo contrario, aquí hay una pequeña muestra de código:

 use sysinfo :: {
    Components , Disks , Networks , System ,
} ;

// Please note that we use "new_all" to ensure that all lists of
// CPUs and processes are filled!
let mut sys = System :: new_all ( ) ;

// First we update all information of our `System` struct.
sys . refresh_all ( ) ;

println ! ( "=> system:" ) ;
// RAM and swap information:
println ! ( "total memory: {} bytes" , sys . total_memory ( ) ) ;
println ! ( "used memory : {} bytes" , sys . used_memory ( ) ) ;
println ! ( "total swap  : {} bytes" , sys . total_swap ( ) ) ;
println ! ( "used swap   : {} bytes" , sys . used_swap ( ) ) ;

// Display system information:
println ! ( "System name:             {:?}" , System :: name ( ) ) ;
println ! ( "System kernel version:   {:?}" , System :: kernel_version ( ) ) ;
println ! ( "System OS version:       {:?}" , System :: os_version ( ) ) ;
println ! ( "System host name:        {:?}" , System :: host_name ( ) ) ;

// Number of CPUs:
println ! ( "NB CPUs: {}" , sys . cpus ( ) . len ( ) ) ;

// Display processes ID, name na disk usage:
for ( pid , process ) in sys . processes ( ) {
    println ! ( "[{pid}] {:?} {:?}" , process . name ( ) , process . disk_usage ( ) ) ;
}

// We display all disks' information:
println ! ( "=> disks:" ) ;
let disks = Disks :: new_with_refreshed_list ( ) ;
for disk in & disks {
    println ! ( "{disk:?}" ) ;
}

// Network interfaces name, total data received and total data transmitted:
let networks = Networks :: new_with_refreshed_list ( ) ;
println ! ( "=> networks:" ) ;
for ( interface_name , data ) in & networks {
    println ! (
        "{interface_name}: {} B (down) / {} B (up)" ,
        data . total_received ( ) ,
        data . total_transmitted ( ) ,
    ) ;
    // If you want the amount of data received/transmitted since last call
    // to `Networks::refresh`, use `received`/`transmitted`.
}

// Components temperature:
let components = Components :: new_with_refreshed_list ( ) ;
println ! ( "=> components:" ) ;
for component in & components {
    println ! ( "{component:?}" ) ;
}

Recuerde que para tener información actualizada, debe llamar al método refresh equivalente. Por ejemplo, para el uso de la CPU:

 use sysinfo :: System ;

let mut sys = System :: new ( ) ;

loop {
    sys . refresh_cpu_usage ( ) ; // Refreshing CPU usage.
    for cpu in sys . cpus ( ) {
        print ! ( "{}% " , cpu . cpu_usage ( ) ) ;
    }
    // Sleeping to let time for the system to run for long
    // enough to have useful information.
    std :: thread :: sleep ( sysinfo :: MINIMUM_CPU_UPDATE_INTERVAL ) ;
}

Por defecto, sysinfo usa múltiples hilos. Sin embargo, esto puede aumentar el uso de la memoria en algunas plataformas (macOS, por ejemplo). El comportamiento se puede deshabilitar configurando default-features = false en Cargo.toml (que deshabilita la función de carga multithread ).

Buenas prácticas / consejos de rendimiento

La mayoría de las veces, no desea toda la información proporcionada por sysinfo , sino solo un subconjunto de ella. En este caso, se recomienda usar métodos refresh_specifics(...) con solo lo que necesita para tener un rendimiento mucho mejor.

Otros problemas con frecuencia se encuentran: a menos que sepa lo que está haciendo, es casi todo el tiempo mejor instanciar la estructura System una vez y usar esta instancia a través de su programa. La razón es porque mucha información necesita calcular una medida anterior para calcularse (el uso de la CPU, por ejemplo). Otro ejemplo por el cual es mucho mejor: en caso de que desee enumerar todos los procesos en ejecución, sysinfo necesita asignar toda la memoria para la lista de estructuras de Process , lo que lleva bastante tiempo en la primera ejecución.

Si su programa necesita usar muchos descriptores de archivos, es mejor que use:

sysinfo :: set_open_files_limit ( 0 ) ;

ya que sysinfo mantiene una serie de descriptores de archivos abiertos para tener un mejor rendimiento en algunos objetivos al actualizar procesos.

Corriendo en Raspberry Pi

Será difícil construir en Raspberry Pi. Una buena manera de construir, luego enviar el ejecutable a su Raspberry Pi.

Primero instale la cadena de herramientas del brazo, por ejemplo en Ubuntu:

 > sudo apt-get install gcc-multilib-arm-linux-gnueabihf

Luego configure la carga para usar la cadena de herramientas correspondiente:

cat << EOF > ~/.cargo/config
[target.armv7-unknown-linux-gnueabihf]
linker = "arm-linux-gnueabihf-gcc"
EOF

Finalmente, compile Cross:

rustup target add armv7-unknown-linux-gnueabihf
cargo build --target=armv7-unknown-linux-gnueabihf

Linux en el subsistema Docker & Windows para Linux (WSL)

Los sistemas virtuales de Linux, como los que se ejecutan a través del subsistema Docker y Windows para Linux (WSL), no reciben información de hardware de host a través de /sys/class/hwmon o /sys/class/thermal . Como tal, la consulta de componentes no puede devolver resultados (o resultados inesperados) al usar esta biblioteca en sistemas virtuales.

Usar en binarios que se ejecutan dentro del sandbox/tiendas de Sandbox de iOS

Apple tiene restricciones sobre qué API se pueden vincular a binarios que se distribuyen a través de la App Store. Por defecto, sysinfo no es compatible con estas restricciones. Puede usar el indicador de funciones apple-app-store para deshabilitar las características de Apple prohibidas. Esto también permite la función apple-sandbox . En el caso de las aplicaciones que usan el Sandbox fuera de la App Store, la función apple-sandbox se puede usar sola para evitar causar violaciones de políticas en tiempo de ejecución.

Cómo funciona

Escribí una publicación de blog que puedes encontrar aquí que explica cómo sysinfo extrae información sobre los diferentes sistemas.

Interfaz C

Es posible usar esta caja directamente desde C. Eche un vistazo al Makefile y el archivo examples/simple.c .

Para construir el ejemplo de C, simplemente ejecute:

 > make
> ./simple
# If needed:
> LD_LIBRARY_PATH=target/debug/ ./simple

Puntos de referencia

Puede ejecutar los puntos de referencia localmente con Rust Nightly haciendo:

 > cargo bench

Donaciones

Si aprecias mi trabajo y quieres apoyarme, puedes hacerlo con patrocinadores de GitHub o con Patreon.