Differenza tra rscript e più piccolo

Question

... oltre al fatto che rscript viene richiamato con #!/usr/bin/env Rscript e Littler con #!/usr/local/bin/r (sul mio sistema) nella prima riga del file di script. Ho trovato alcune differenze nella velocità di esecuzione (sembra che littler sia un po 'più lento).

Ho creato due script fittizi, eseguito ogni 1000 volte e confrontato il tempo medio di esecuzione.

Ecco il file rscript:

#!/usr/bin/env Rscript 

btime <- proc.time() 
x <- rnorm(100) 
print(x) 
print(plot(x)) 
etime <- proc.time() 
tm <- etime - btime 
sink(file = "rscript.r.out", append = TRUE) 
cat(paste(tm[1:3], collapse = ";"), "\n") 
sink() 
print(tm) 

ed è il file più piccolo qui:

#!/usr/local/bin/r 

btime <- proc.time() 
x <- rnorm(100) 
print(x) 
print(plot(x)) 
etime <- proc.time() 
tm <- etime - btime 
sink(file = "little.r.out", append = TRUE) 
cat(paste(tm[1:3], collapse = ";"), "\n") 
sink() 
print(tm) 

Come si può vedere, sono quasi identici (prima riga e affondano argomento file differiscono). L'output è sink ed è un file di testo, quindi importato in R con read.table. Ho creato script bash per eseguire ogni script 1000 volte, quindi medie calcolate.

Ecco script bash:

for i in `seq 1000` 
do 
./$1 
echo "####################" 
echo "Iteration #$i" 
echo "####################" 
done 

E i risultati sono:

# littler script 
> mean(lit) 
    user system elapsed 
0.489327 0.035458 0.588647 
> sapply(lit, median) 
    L1 L2 L3 
0.490 0.036 0.609 
# Rscript 
> mean(rsc) 
    user system elapsed 
0.219334 0.008042 0.274017 
> sapply(rsc, median) 
    R1 R2 R3 
0.220 0.007 0.258 

farla breve: a lato (ovvio) differenza di tempo di esecuzione, c'è qualche altra differenza? La domanda più importante è: perché dovrei/non preferiresti littler su Rscript (o viceversa)?

Answer 1

Coppia commenti rapidi:

1. Il percorso /usr/local/bin/r è arbitraria, è possibile utilizzare /usr/bin/env r così come facciamo in alcuni esempi. Se non ricordo male, si limita ciò che altri argomenti che si possono dare ai r come ci vuole solo un quando viene richiamato tramite env

2. Non capisco il tuo punto di riferimento, e perché si farebbe in questo modo. Noi do abbiamo confronti temporali nelle fonti, vedere tests/timing.sh e tests/timing2.sh. Forse vuoi dividere il test tra l'avvio e la creazione del grafico o qualsiasi altra cosa tu stia cercando.

3. Ogni volta che eseguivamo questi test, il più piccolo ha vinto. (Ha vinto ancora quando li ho ripresi proprio adesso.) Il che aveva senso per noi perché se si guardano le fonti a Rscript.exe, funziona diversamente impostando l'ambiente e una stringa di comando prima di chiamare infine execv(cmd, av). Littler può iniziare un po 'più veloce.

4. Il prezzo principale è portabilità. Il modo in cui è costruito littler, non lo farà a Windows. O almeno non facilmente. OTOH abbiamo portato RINside così se qualcuno volesse davvero ...

5. Littler è arrivato per la prima volta nel settembre 2006 rispetto a Rscript che è arrivato con R 2.5.0 nell'aprile 2007.

6. Rscript è ora ovunque in cui R è. Questo è un grande vantaggio.

7. Le opzioni della riga di comando sono un po 'più sensibili per il più piccolo a mio avviso.

8. Entrambi funzionano con i pacchetti CRAN getopt e optparse per l'analisi delle opzioni.

Quindi è una preferenza personale. Ho co-scritto più piccolo, ho imparato molto a farlo (ad esempio per RInside) e lo trovo ancora utile - quindi lo uso dozzine di volte al giorno. Guida CRANberries. Guida cran2deb. Il tuo chilometraggio può, come dice, variare.

Disclaimer: littler è uno dei miei progetti.

Postscriptum: avrei scritto il test come

avrei scritto questo come

fun <- function { X <- rnorm(100); print(x); print(plot(x)) } 
    replicate(N, system.time(fun)["elapsed"]) 

o anche

mean(replicate(N, system.time(fun)["elapsed"]), trim=0.05) 

per sbarazzarsi dei valori anomali. Inoltre, si misura essenzialmente I/O (una stampa e un grafico) che entrambi otterranno dalla libreria R quindi mi aspetterei una piccola differenza.