Description Usage Arguments Note Author(s) See Also Examples

Rprof() is activated and started

1 | ```
RRprofStart(filename = "RRprof.out", interval = 0.02, numfiles = 100L, bufsize = 10000L)
``` |

`filename` |
The file to be used for recording the profiling results. |

`interval` |
real: time interval between samples. |

`numfiles` |
integers: line profiling memory |

`bufsize` |
allocation |

The profiler interrupts R asynchronously, and it cannot allocate memory to store results as it runs. This affects line profiling, which needs to store an unknown number of file pathnames. The numfiles and bufsize arguments control the size of pre-allocated buffers to hold these results: the former counts the maximum number of paths, the latter counts the numbers of bytes in them. If the profiler runs out of space it will skip recording the line information for new files, and issue a warning when Rprof(NULL) is called to finish profiling.

The timing interval cannot be too small, for the time spent in each profiling step is added to the interval. What is feasible is machine-dependent, but 10ms seemed as small as advisable on a 1GHz machine.

Fernando de Villar and Angel Rubio

`RRprofStop`

, `RRprofReport`

, `Rprof`

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 | ```
temp<-tempdir()
# Definition of two functions
normal.solve <- function(A,b) {
Output <- solve(crossprod(A), t(A)%*%b)
}
chol.solve <- function(A,b) {
L <- chol(crossprod(A))
Output1 <- backsolve(L, t(A)%*%b, transpose=TRUE)
Output2 <- backsolve(L, Output1)
}
compareMethods <- function() {
library(MASS)
# Call the functions
source(paste(temp,"/normal.solve.R",sep=""))
source(paste(temp,"/chol.solve.R",sep=""))
# Solving a big system of equations
nrows <- 1000
ncols <- 500
A <- matrix(rnorm(nrows*ncols),nrows,ncols)
b <- rnorm(nrows)
# Testing different possibilities
Sol1 <- qr.solve(A,b) # Using QR factorization
Sol2 <- coefficients(lm.fit(A,b)) # lm.fit, based on QR but with some overhead
Sol3 <- ginv(A) %*% b # Using the pseudoinverse based on SVD
Sol4 <- normal.solve(A,b) # Using a function based on the normal equations.
Sol5 <- chol.solve(A,b) # Using a function based on the Choleski factorization.
}
# Dump these functions to three different files
dump("normal.solve",file=paste(temp,"/normal.solve.R",sep=""))
dump("chol.solve",file=paste(temp,"/chol.solve.R",sep=""))
dump("compareMethods",file=paste(temp,"/compareMethods.R",sep=""))
source(paste(temp,"/compareMethods.R",sep=""))
# Profile the code
RRprofStart()
compareMethods()
RRprofStop()
# Uncomment to open the report
#RRprofReport()
``` |

```
Loading required package: Nozzle.R1
Loading required package: MASS
Loading required package: proftools
Loading required package: Rgraphviz
Loading required package: graph
Loading required package: BiocGenerics
Loading required package: parallel
Attaching package: 'BiocGenerics'
The following objects are masked from 'package:parallel':
clusterApply, clusterApplyLB, clusterCall, clusterEvalQ,
clusterExport, clusterMap, parApply, parCapply, parLapply,
parLapplyLB, parRapply, parSapply, parSapplyLB
The following objects are masked from 'package:stats':
IQR, mad, sd, var, xtabs
The following objects are masked from 'package:base':
Filter, Find, Map, Position, Reduce, anyDuplicated, append,
as.data.frame, cbind, colMeans, colSums, colnames, do.call,
duplicated, eval, evalq, get, grep, grepl, intersect, is.unsorted,
lapply, lengths, mapply, match, mget, order, paste, pmax, pmax.int,
pmin, pmin.int, rank, rbind, rowMeans, rowSums, rownames, sapply,
setdiff, sort, table, tapply, union, unique, unsplit, which,
which.max, which.min
Loading required package: grid
```

GUIProfiler documentation built on May 2, 2019, 12:54 a.m.

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.