RUST

Question 1

Create an array

Answer 1

let arr: [i32; 5] = [1, 2, 3, 4, 5];

Question 2

Create a string

Answer 2

Only to read -> let s: &str;

To modify -> let s: String;
(String has string modification methods such as character insertion, string insertion, removal, clearing, contains, from str to String,…)

Question 3

Multi dimensional array

Answer 3

let array: [[i64; 6] ;2];

Question 4

Pass reference read-only

Answer 4

fn(&var)

Question 5

Pass reference to modify, without losing ownership

Answer 5

fn(&mut var)

Question 6

Passing and returning arrays

Answer 6

let mut arr: [i32, 5];

fn(arr)

fn function (mut arr: [i32 ; 5]) -> [i32 ; 5]{
return arr;
}

Question 7

How to create new asyncronous channel?

Answer 7

let (tx, rx) = mpsc::channel()

Question 8

Cosa fa clone?

Answer 8

Per Collezioni clone copia effettivamente il dato.

Per smart pointers copia solo indirizzo allo stesso blocco di memoria.

Question 9

vettore indicizzato da cui rimuovere o aggiungere in testa

Answer 9

VedDeque<T>
pop back, pop front, push front, push back</T>

Question 10

mappa normale?

Answer 10

HashMap<K,V>.
get(), get_mut()
trait: Eq + std::hash::Hash

Question 11

iterare lista

Answer 11

.iter o .iter_mut

Question 12

condivisione di ownership?

Answer 12

Rc<t> signle thread, Arc<t> multithread</t></t>

Question 13

mutabilità interna?

Answer 13

RefCell<T> single thread (.borrow(), .borrow_mut()).</T>

Mutex<T> multithread (.lock())
oppure RxLock<T> se più accessi il lettura che scrittura (.read(), .write())</T></T>

Question 14

Singola ownership?

Answer 14

Box<T> single thread</T>

per struct ricorsive o trait dinamici. Perché permette ad entrambi di non conoscere in compilazione la grandezza precisa di struct o trait, perché tanto in compilazione viene controllato lo stack e nello stack la box ha solo un puntatore di dimensione fissa.

A differenza di ownership normale che fa vivere i dati sullo stack, box li sposta sull’heap quindi è adatto per dati piu grandi.

Question 15

Accedere a valore di Arc?

Answer 15

&*var

Question 16

accedere a Result?

Answer 16

var.unwrap()

Question 17

Accedere a valore di MutexGuard?

Answer 17

*var

Question 18

Come gestire mutex?

Answer 18

prima di accederci fare sempre lock, poi fare drop esplicito nel caso di notify all.
Attenzione ad aggiornare la guard in caso di wait

Question 19

Impostando un problema a cosa stare attenti?

Answer 19

valore di ritorno delle funzioni

Question 20

Vedo vari riferimenti mutabili ed immutabili, a cosa devo stare attento?

Answer 20

che non possono esserci più riferimenti mutabili attivi insieme ad altri riferimenti immutabili attivi. in particolare scrittura->poi scrittura

Question 21

Quando serve la lifetime?

Answer 21

Quando una funzione prende più riferimenti e ne restituisce meno, dato che il compilatore non sa a quale dato il result farebbe riferimento.

oppure in una struct con riferimenti interni. (es &str)

Question 22

Dopo che uso lifetime…?

Answer 22

attenzione che i parametri lifetime devono vivere >= del result

Question 23

Prima cosa a cui stare attenti quando viene trasferita ownership?

Answer 23

Se il tipo è primitivo, quindi copy. non trasferisce MAI ownership nel caso

Question 24

Closure differenza move o non move?

Answer 24

move trasferisce ownership sempre.

senza move trasferisce ownership solo se NECESSARIO. NECESSARIO SE: valore ritornato, dichiarazione, metodi consumatori come drop, into_…, iteratori che modificano, Option/Result.

Question 25

Particolarità di Closure

Answer 25

Qualsiasi riferimento dopo fun() muore SUBITO. In closure: - riferimento muore solo dopo l'ultima chiamata alla closure. - se non consuma effettivamente il dato, allroa può essere richiamato più volte la closure prechè il dato rimane valido INTERNAMENTE - i dati usati da closure non sono soggetti a cambiamenti DOPO la definizione della closure.

Question 26

Come creare threads?

Answer 26

Thread::spawn. Possibile condividere dati attraverso Fun() o Closure() solo se si trasferisce ownership, alternativamente da usare static. Thread::scope. Possibile condividere dati & e &mut anche senza trasferire ownership.

Question 27

Cosa succede se Thread spawn usa dati senza condividerne ownership?

Answer 27

errore di data race. dovrebbe essere infatti usato per thread autonomi, a differenza di thread scope

Question 28

Errori più comuni nell'uso di threads?

Answer 28

wait invece di wait_while. cicli infiniti senza condizioni di uscita.

Question 29

trait deref?

Question 30

trait copy?

Question 31

trait send?

Answer 31

Serve per trasferire ownership di un dato tra thread. Serve a collezioni single thread. unsafe impl Send for s {}

Question 32

trait sync?

Answer 32

Serve per permettere la lettura di un dato tra thread. Serve a collezioni single thread. unsafe impl Sync for s {}

Question 33

trait iterator?

Question 34

trait drop?

Question 35

lunghezza di Arc,Rc?

Answer 35

1 word su stack: puntatore che punta a control block in heap in heap: 1 word di contatore strong + 1 word di contatore weak + dimensione dato puntato

Question 36

Lunghezza Vec< T>

Answer 36

in stack: 1 word di puntatore ai dati + 1 word lunghezza vec + 1 word capacity in heap: lunghezza dati puntati

Question 37

Lunghezza fat pointer? e chi sono fat pointer?

Answer 37

fat pointer sono Slices di array, Slices di strings o Trait object dinamici (Box, dyn Trait) in stack: 1 word puntatore a dati + (1 word di vtable per i trait OPPURE 1 word di lunghezza per i Slice) in heap o stack: dimensione dati puntati

Question 38

Pattern fan out fan in

Answer 38

coppia di canali, uno invia dati ai worker, l'altro riceve output. tutti i thread fanno lo stesso lavoro. 1 producer ed 1 un consumer finale.

Question 39

Pattern pipeline?

Answer 39

fasi separate collegate da canali. 1 producer ed 1 consumer

Question 40

Pattern producer-consumer?

Answer 40

un solo canale che connette più producer o più consumer. Gestisce turno in base a chi arriva prima

Question 41

thread pool e barrier?

Answer 41

thread pool crea un gruppo di n thread lavoratori, è come spawnarne tanti singolarmente, ma è più adatto thread pool se si parla di task veloci dato che i task vengono messi in coda ed i thread restano in vita pescando i task da fare dalla coda. a differenza di thread spawn che crea e distrugge thread ogni volta. thread pool ha un solo sender ed n receiver clonati Barrier sincronizza i thread, tutti aspettano al .wait()

Question 42

In canali sincroni o asincroni a cosa devo stare attento se si fa drop di un receiver?

Answer 42

Devo eliminare il corrispettivo Sender con remove() o retain()

Question 43

Binaryheap?

Answer 43

Albero binario che ha come elemento al top l'elemento massimo. .push(), .peek() e .pop(). Adatto a Scheduling. + T: Ord

Question 44

Cos'è Scheduling?

Answer 44

è un pattern di alto livello come faninfanout, pipeline e producer-consumer. Scheduler serve a gestire come eseguire vari thread, assegnando ad ognuno una priorità. per questo problema è adatto usare una BinaryHeap

Question 45

Come capire quando è da fare il thread pool?

Answer 45

type Job = Box;

Question 46

come testare?

Answer 46

#[cfg(test)] mod tests {...} e funzione asser_eq!

Question 47

monorfizzazione?

Answer 47

È il processo in cui il compilatore sostituisce i parametri generici (T) con tipi concreti (i32, String, ecc.) e genera versioni specifiche del codice per ogni tipo usato. Passaggi: Type checking sui generici Rust controlla il codice della funzione generica una volta sola, senza sapere ancora i tipi reali. Sostituzione dei tipi nei punti di uso Quando chiami la funzione con un tipo specifico (i32, String, ...), Rust sostituisce T con il tipo reale. Generazione MIR specializzato Il compilatore crea una versione ottimizzata (Mid-level IR) per ogni tipo usato. LLVM IR: traduzione del MIR in codice macchina ottimizzato TRADEOFF: c'è il contro che è possibile che la funzione può essere usata con molti tipi diversi, creando quindi un lungo codice binario. MA comunque la performance rimane ottima, essendo che è zero-cost abstraction.

Question 48

Definizione V-Table?

Answer 48

è una tabella usata per supportare trait dinamici. c'è una vtable per ogni tipo di dato **concreto**. Contiene: - Puntatori alle funzioni implementate dal tipo per quel trait - Metadati fissi: size_of, align_of, drop

Question 49

Cosa sono i metadati?

Answer 49

In Rust i metadati sono informazioni addizionali necessarie per gestire tipi non "Sized" (cioè di cui non si conosce a compile-time la dimensione esatta), come ad esempio i due tipi di fat pointer. ad esempio: len,vtable

Question 50

cosa cambia da generics a dyn traits?

Answer 50

Generici (fn f(…)) → T è noto a compile-time, il compilatore genera (monomorfizza) una versione di f per ogni T. dyn Trait → il tipo concreto non è noto a compile-time: &dyn Trait è un fat pointer contenente solo un puntatore ai dati e uno alla vtable. Serve ad esempio per collezioni eterogenee.

Question 51

cos'è dispatch statico o dinamico?

Answer 51

Static dispatch: Usato con i generics (W: Trait) Il compilatore genera una funzione specifica per ogni tipo (monomorfizzazione) Le chiamate sono dirette → no indirection inlining possibile → massimo delle performance Dynamic dispatch: Usato con dyn Trait Il puntatore è un fat pointer con: dati + vtable Le chiamate vanno via vtable → indirection, no inlining → leggero overhead Inlining: sostituire il corpo della funzione nel chiamante, evita salto di funzione Indirection: accedere a una funzione o dato passando da un puntatore (es. vtable)

Question 52

cos'è zero cost abstraction in rust?

Answer 52

Rust garantisce che le sue astrazioni ad alto livello vengano compilate in codice efficiente quanto le implementazioni manuali equivalenti in C/C++. Meccanismi Chiave: - Inlining e LTO: Il compilatore incorpora aggressivamente le funzioni piccole direttamente nel codice chiamante. - Adattatori di iteratori: Le catene di operazioni come .map(..).filter(..).collect() vengono ottimizzate dal compilatore LLVM, vede tutta la catena e la fonde in un singolo ciclo - Pattern matching ed enum: Vengono tradotti in jump table o operazioni su bitmask senza allocazioni aggiuntive in memoria. quindi le enum vengono memorizzate solo come numeri in memoria, non come oggetti, in modo che il compilatore riesce in fretta a fare pattern matching.

Question 53

Unsafe cos'è?

Answer 53

permette di fare un contratto tra programmatore e compilatore,per aggirare regole di borrow checker e permettere: unsafe in Rust serve per: - Dereferenziare puntatori raw (*const T, *mut T) - Accedere a unsafe functions o traits - Modificare stati condivisi senza sincronizzazione

Question 54

box?

Question 55

&T?

Question 56

RefCell?

Question 57

Cell?

Question 58

Mutex?

Question 59

enum?

Question 60

Option?

Question 61

Lifetime definizione?

Answer 61

è un etichetta che rappresenta l'intervallo di validità di un riferimento (&T o &mut T), cioè quanto a lungo può vivere quel riferimento senza diventare dangling (non valido). Serve ad assicurarsi che il risultato non viva più a lungo dei dati a cui punta.