How can I time my code? | R FAQ

For many, R code that works properly is good enough. However, if you are planning to share, package, or use your code repeatedly, you might consider the efficiency of your code. Running your code and timing it is a good starting point.

This page will demonstrate two R commands for timing code: proc.time and system.time. It will also illustrate the first rule of making R code efficient: avoid loops! We will start with a vector of 100,000 values sampled randomly from a standard normal. We want to add 1 to each of these values. We will do this with and without looping, timing both.

The proc.time command essentially works as a stop-watch: you initialize it to a starting time, run all the code desired, and then stop it by subtracting the starting time from the ending time.

We can first use the slow, looping method to add 1 to each value in our vector:

g <- rnorm(100000)
h <- rep(NA, 100000)

# Start the clock!
ptm <- proc.time()

# Loop through the vector, adding one
for (i in 1:100000){
	h[i] <- g[i] + 1
}

# Stop the clock
proc.time() - ptm

   user  system elapsed 
   0.34    0.06    0.41

Alternatively, we can use a non-looping approach:

ptm <- proc.time()
h <- g + 1
proc.time() - ptm

   user  system elapsed 
   0.00    0.02    0.01

The values presented (user, system, and elapsed) will be defined by your operating system, but generally, the user time relates to the execution of the code, the system time relates to system processes such as opening and closing files, and the elapsed time is the difference in times since you started the stopwatch (and will be equal to the sum of user and system times if the chunk of code was run altogether and single-threaded). Note that the elapsed time may be shorter than the sum of the user time and system time if multiple threads were used to execute the expression. While the difference of .42 seconds may not seem like much, this gain in efficiency is huge!

The system.time command takes a single R expression as its argument. Thus, to repeat the steps above using system.time, we wrote function wrappers around our fast and slow methods. Again we see that the looping method is much slower. Note that system.time is simply calling proc.time! So the better one to use just depends on the nature of the code you wish to time.

quickadd <- function(g){ 
	return(g+1)
}

slowadd <- function(g){
	h <- rep(NA, length(g))
	for (i in 1:length(g)){
		h[i] <- g[i] + 1
	}
	return(h)
}

system.time(a <- slowadd(g))
   user  system elapsed 
   0.34    0.00    0.34

system.time(a <- quickadd(g))
   user  system elapsed 
      0       0       0

References