Publicouse o lanzamento da linguaxe de programación de propósito xeral Rust 1.75, fundada polo proxecto Mozilla, pero agora desenvolvida baixo os auspicios da organización independente sen ánimo de lucro Rust Foundation. A linguaxe céntrase na seguridade da memoria e proporciona os medios para conseguir un alto paralelismo de traballos evitando o uso dun colector de lixo e o tempo de execución (o tempo de execución redúcese á inicialización básica e ao mantemento da biblioteca estándar).
Os métodos de manexo da memoria de Rust salvan ao desenvolvedor de erros ao manipular os punteiros e protexen contra os problemas que xurdan debido ao manexo de memoria de baixo nivel, como acceder a unha área de memoria despois de liberarse, desreferenciar punteiros nulos, exceder o búfer, etc. Para distribuír bibliotecas, proporcionar compilacións e xestionar dependencias, o proxecto desenvolve o xestor de paquetes Cargo. O repositorio crates.io é compatible para hospedar bibliotecas.
A seguridade da memoria ofrécese en Rust no momento da compilación mediante a comprobación de referencias, o seguimento da propiedade do obxecto, o seguimento da vida útil dos obxectos (ámbitos) e a avaliación da corrección do acceso á memoria durante a execución do código. Rust tamén ofrece protección contra desbordamentos de enteiros, require a inicialización obrigatoria dos valores variables antes do seu uso, manexa mellor os erros na biblioteca estándar, aplica o concepto de referencias e variables inmutables por defecto, ofrece unha forte escritura estática para minimizar os erros lóxicos.
Principais novidades:
- Engadida a capacidade de usar "async fn" e a notación "->impl Trait" en trazos privados. Por exemplo, usando “->impl Trait” pode escribir un método de trazo que devolva un iterador: trait Container { fn items(&self) -> impl Iterator; } impl Container para MyContainer { fn items(&self) -> impl Iterator { self.items.iter().cloned() } }
Tamén pode crear trazos usando "async fn": trait HttpService { async fn fetch(&self, url: Url) -> HtmlBody; // expandirase a: // fn fetch(&self, url: Url) -> impl Future; }
- Engadiuse a API para calcular as compensacións de bytes en relación aos punteiros. Cando se traballa con punteiros simples ("*const T" e "*mut T"), poden ser necesarias operacións para engadir un desplazamento ao punteiro. Anteriormente, para iso era posible utilizar unha construción como “::add(1)”, engadindo o número de bytes correspondentes ao tamaño de “size_of::()”. A nova API simplifica esta operación e fai posible manipular as compensacións de bytes sen emitir antes os tipos a "*const u8" ou "*mut u8".
- pointer::byte_add
- pointer::byte_offset
- pointer::byte_offset_from
- pointer::byte_sub
- pointer::wrapping_byte_add
- pointer::wrapping_byte_offset
- pointer::wrapping_byte_sub
- Traballo continuo para aumentar o rendemento do compilador rustc. Engadiuse o optimizador BOLT, que se executa na fase posterior á ligazón e utiliza información dun perfil de execución preparado previamente. Usar BOLT permítelle acelerar a execución do compilador nun 2% aproximadamente cambiando a disposición do código da biblioteca librustc_driver.so para un uso máis eficiente da caché do procesador.
Incluíuse a construción do compilador rustc coa opción "-Ccodegen-units=1" para mellorar a calidade da optimización en LLVM. As probas realizadas mostran un aumento do rendemento no caso da compilación "-Ccodegen-units=1" en aproximadamente un 1.5%. As optimizacións engadidas están habilitadas por defecto só para a plataforma x86_64-unknown-linux-gnu.
As optimizacións mencionadas anteriormente foron probadas por Google para reducir o tempo de construción dos compoñentes da plataforma Android escritos en Rust. Usar "-C codegen-units=1" ao crear Android permitiunos reducir o tamaño do conxunto de ferramentas nun 5.5 % e aumentar o seu rendemento nun 1.8 %, mentres que o tempo de construción do conxunto de ferramentas case se duplicou.
A habilitación da recollida de lixo en tempo de ligazón ("--gc-sections") levou a ganancia de rendemento ata o 1.9 %, permitindo a optimización do tempo de ligazón (LTO) ata o 7.7 % e as optimizacións baseadas en perfiles (PGO) ata o 19.8 %. Na final, aplicáronse optimizacións mediante a utilidade BOLT, que permitiu aumentar a velocidade de construción ata o 24.7%, pero o tamaño do conxunto de ferramentas aumentou un 10.9%.
- Unha nova parte da API trasladouse á categoría de estable, incluíndo os métodos e implementacións de trazos estabilizados:
- Atómico*::from_ptr
- FileTimes
- FileTimesExt
- Ficheiro::set_modified
- Ficheiro::set_times
- IpAddr::to_canonical
- Ipv6Addr::to_canonical
- Opción::as_slice
- Opción::as_mut_slice
- pointer::byte_add
- pointer::byte_offset
- pointer::byte_offset_from
- pointer::byte_sub
- pointer::wrapping_byte_add
- pointer::wrapping_byte_offset
- pointer::wrapping_byte_sub
- O atributo "const", que determina a posibilidade de usalo en calquera contexto en lugar de constantes, úsase nas funcións:
- Ipv6Addr::to_ipv4_mapped
- QuizaisUninit::assume_init_read
- QuizaisUninit::zeroed
- mem::discriminante
- mem::cero
- Implementouse o terceiro nivel de soporte para as plataformas csky-unknown-linux-gnuabiv2hf, i586-unknown-netbsd e mipsel-unknown-netbsd. O terceiro nivel implica soporte básico, pero sen probas automatizadas, publicación de compilacións oficiais ou comprobar se o código se pode construír.
Ademais, podemos sinalar unha nova versión do proxecto Hermit, que desenvolve un núcleo especializado (unikernel), escrito na linguaxe Rust, que proporciona ferramentas para construír aplicacións autónomas que poden executarse enriba dun hipervisor ou hardware sen capas adicionais. e sen sistema operativo. Cando se crea, a aplicación está ligada de forma estática a unha biblioteca, que implementa de forma independente todas as funcionalidades necesarias, sen estar vinculada ao núcleo do sistema operativo e ás bibliotecas do sistema. O código do proxecto distribúese baixo licenzas Apache 2.0 e MIT. O montaxe é compatible para a execución autónoma de aplicacións escritas en Rust, Go, Fortran, C e C++. O proxecto tamén está a desenvolver o seu propio cargador de arranque que che permite lanzar Hermit usando QEMU e KVM.
Fonte: opennet.ru