È stato pubblicato il rilascio del linguaggio di programmazione generale Rust 1.75, inizialmente sviluppato da Mozilla, ora sostenuto da un'organizzazione no-profit indipendente, la Rust Foundation. Il linguaggio si concentra sulla sicurezza nella gestione della memoria e offre strumenti per raggiungere un alto grado di parallelismo nell'esecuzione dei compiti, senza l'uso di garbage collector e runtime (il runtime si limita a una inizializzazione di base e al supporto della libreria standard).
I metodi di gestione della memoria in Rust liberano gli sviluppatori dagli errori nella manipolazione dei puntatori e li proteggono da problematiche derivanti dal lavoro a basso livello con la memoria, come l'accesso a zone di memoria dopo la loro liberazione, la dereferenziazione di puntatori nulli, il superamento dei limiti del buffer, e così via. Per la distribuzione delle librerie, la gestione della compilazione e delle dipendenze, si è sviluppato un gestore di pacchetti chiamato Cargo. Le librerie sono ospitate nel repository crates.io.
La gestione sicura della memoria in Rust è garantita durante la compilazione tramite il controllo dei riferimenti, il tracciamento della proprietà degli oggetti, la gestione della durata degli oggetti (scope) e la valutazione della correttezza dell'accesso alla memoria durante l'esecuzione del codice. Rust offre anche strumenti per proteggere da overflow interi, richiede l'inizializzazione obbligatoria dei valori delle variabili prima dell'uso, gestisce meglio gli errori nella libreria standard, applica il concetto di riferimenti e variabili immutabili per impostazione predefinita e offre una forte tipizzazione statica per ridurre al minimo gli errori logici.
Novità principali:
- È stata aggiunta la possibilità di utilizzare «async fn» e la notazione «->impl Trait» in trait privati. Ad esempio, utilizzando «->impl Trait» è possibile scrivere un metodo di trait che restituisce un iteratore: trait Container { fn items(&self) -> impl Iterator; } impl Container per MyContainer { fn items(&self) -> impl Iterator { self.items.iter().cloned() } }
È anche possibile creare trait che utilizzano «async fn»: trait HttpService { async fn fetch(&self, url: Url) -> HtmlBody; // si espanderà in: // fn fetch(&self, url: Url) -> impl Future; }
- È stata aggiunta un'API per calcolare gli offset in byte rispetto ai puntatori. Quando si lavora con puntatori raw («*const T» e «*mut T») potrebbero essere necessarie operazioni di aggiunta di offset al puntatore. In precedenza, si poteva utilizzare una costruzione del tipo «::add(1)», che aggiunge un numero di byte corrispondente alla dimensione «size_of::()». La nuova API semplifica quest'operazione e consente di gestire gli offset in byte senza la necessità di conversioni di tipo a «*const u8» o «*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
- Continua il lavoro per migliorare le prestazioni del compilatore rustc. È stata inclusa l'ottimizzatore BOLT, che opera in una fase successiva alla compilazione e utilizza informazioni provenienti da un profilo di esecuzione precompilato. L'uso di BOLT consente di migliorare le prestazioni del compilatore di circa il 2% grazie a una ristrutturazione del codice della libreria librustc_driver.so per un utilizzo più efficiente della cache del processore.
È stata attivata la compilazione del compilatore rustc con l'opzione «-Ccodegen-units=1», che consente di migliorare la qualità dell'ottimizzazione in LLVM. I test effettuati mostrano un aumento delle prestazioni della compilazione «-Ccodegen-units=1» di circa il 1.5%. Le ottimizzazioni aggiunte sono attivate di default solo per la piattaforma x86_64-unknown-linux-gnu.
Le ottimizzazioni sopra menzionate sono state testate da Google per ridurre i tempi di compilazione dei componenti della piattaforma Android scritti in Rust. L'uso di «-C codegen-units=1» durante la compilazione di Android ha permesso di ridurre la dimensione degli strumenti del 5.5% e di aumentare le prestazioni del 1.8%, mentre il tempo di compilazione degli strumenti stessi è raddoppiato.
L'attivazione della raccolta dei rifiuti durante il linking («—gc-sections») ha portato a un aumento delle prestazioni fino all'1.9%, l’ottimizzazione durante il linking (LTO) ha incrementato le prestazioni fino al 7.7%, e le ottimizzazioni basate sul profilo di esecuzione del codice (PGO) hanno raggiunto un aumento del 19.8%. Infine, sono state applicate ottimizzazioni tramite l'utility BOLT, che ha consentito di aumentare il guadagno in velocità di compilazione fino al 24.7%, sebbene la dimensione degli strumenti sia aumentata del 10.9%.
- Una nuova serie di API è stata traslata nella categoria stabile, stabilizzando i metodi e le implementazioni dei tipi:
- Atomic*::from_ptr
- FileTimes
- FileTimesExt
- File::set_modified
- File::set_times
- IpAddr::to_canonical
- Ipv6Addr::to_canonical
- Option::as_slice
- Option::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
- L'indicatore «const», che determina la possibilità di utilizzo in qualsiasi contesto al posto delle costanti, è stato applicato nelle funzioni:
- Ipv6Addr::to_ipv4_mapped
- MaybeUninit::assume_init_read
- MaybeUninit::zeroed
- mem::discriminant
- mem::zeroed
- È stato implementato un terzo livello di supporto per le piattaforme csky-unknown-linux-gnuabiv2hf, i586-unknown-netbsd e mipsel-unknown-netbsd. Il terzo livello prevede un supporto di base, ma senza test automatizzati, pubblicazione di build ufficiali e verifica della possibilità di compilare codice.
Inoltre, va menzionata la nuova versione del progetto Hermit, che sta sviluppando un kernel specializzato (unikernel) scritto in Rust, fornendo strumenti per costruire applicazioni autonome capaci di operare sopra un hypervisor o hardware nudo senza strati aggiuntivi e senza un sistema operativo. Durante la compilazione, l'applicazione si collega staticamente a una libreria che implementa autonomamente tutta la funzionalità necessaria, senza legarsi al kernel OS e alle librerie di sistema. Il codice del progetto è distribuito sotto le licenze Apache 2.0 e MIT. È supportata la compilazione per l'esecuzione isolata di applicazioni scritte in Rust, Go, Fortran, C e C++. Inoltre, il progetto sta sviluppando un bootloader per avviare Hermit utilizzando QEMU e. KVM.
Fonte: opennet.ru
