Devo essere preoccupato per il sovraccarico di `Rc`?

Question

Ho ragione di presumere che l'unica cosa che "rallenta" Rc s è che controlla se rilasciare l'oggetto quando cade? Oltre a ciò, "quanto" è il sovraccarico del dereferenziamento a Rc, cioè dovrei preoccuparmene?
Queste due funzioni sono quasi altrettanto veloci? O c'è una notevole differenza di velocità?

fn test_with_box() { 
    let b = Box::new(1.0); 
    let x = b * 2; 
} 

fn test_with_rc() { 
    let rc = Rc::new(1.0); 
    let x = rc * 2; 
} 

Poiché l'oggetto di riferimento in test_with_rc() sempre ha un solo riferimento e si comporta come un Box a quella funzione (vista dall'esterno, non internamente, ovviamente).

Ho il sospetto che gli Rc s siano effettivamente più veloci di quanto penso.

PS: Quando si parla di "veloce" intendo sia il dereferenziamento che l'allocazione/deallocazione.

Answer 1

Rc<T> è molto, molto economico. Non è economico come lo T da un po '(i valori di boxing sono relativamente costosi in termini di micro-ottimizzazione), ma non è meno efficiente di Box<T>.

E 'proprio come Box, ma con un ulteriore paio di parole per i forti e deboli i conteggi di riferimento, e le uniche cose che hanno bisogno di toccare, che stanno creando un Rc (inizializza i valori), la clonazione di un Rc (incrementa il refcount) e rilasciare un Rc (diminuisce il Refcount ed esegue il distruttore se appropriato). Nel codice instabile è anche in corso il downgrade a/upgrade da Weak (roba altrettanto banale).

Il dereferenziamento è una semplice operazione di memoria proprio come con lo Box.

Answer 2

Per rispondere alla tua domanda, è possibile rivolgersi al test cassa, che contiene una soluzione di benchmarking (questo ha bisogno di una notte):

#![feature(test)] 
extern crate test; 

use std::rc::Rc; 

fn test_with_box() { 
    let b = Box::new(1.0); 
    test::black_box(*b * 2.0); 
} 

fn test_with_rc() { 
    let rc = Rc::new(1.0); 
    test::black_box(*rc * 2.0); 
} 

#[bench] 
fn bench_box(b: &mut test::Bencher) { 
    b.iter(test_with_box) 
} 

#[bench] 
fn bench_rc(b: &mut test::Bencher) { 
    b.iter(test_with_rc) 
} 

Ora compilazione & l'esecuzione di questo:

$ rustc --test -O rc.rs && ./rc --bench 

running 2 tests 
test bench_box ... bench:   22 ns/iter (+/- 0) 
test bench_rc ... bench:   22 ns/iter (+/- 0) 

test result: ok. 0 passed; 0 failed; 0 ignored; 2 measured 

Cosa è accaduto? Apparentemente la RC è stata completamente compilata. Come dovrebbe essere, perché non abbiamo clonato it. Così cambia la rispettiva fn a:

fn test_with_rc() { 
    let rc = Rc::new(1.0); 
    test::black_box(*rc.clone() * 2.0); 
} 

Otteniamo la seguente:

running 2 tests 
test bench_box ... bench:   23 ns/iter (+/- 1) 
test bench_rc ... bench:   25 ns/iter (+/- 1) 

test result: ok. 0 passed; 0 failed; 0 ignored; 2 measured 

Quindi, basti dire, avrete probabilmente bisogno di preoccuparsi di altre cose prima di guardare in alto RC-indotta.