The amount of memory available to R can be obtained with the memory.limit command. This command can also be used to increase the memory available by telling R to use a certain amount of virtual memory. Here, we see about 6 GB of memory available (the amount of RAM in the computer) and tell R to use up to 8 GB, as follows:

> memory.limit()
[1] 5999
> memory.limit(8000)
[1] 8000
> memory.limit()
[1] 8000

If we close the R session and then reopen it, R will reset its memory limit to the default of the total available RAM, and will no longer have this virtual memory available to it.

Using virtual memory can significantly slow down R, so if memory use is a concern, it is best to do a couple of other things before resorting to this.

When performing large computations, the first thing to do is delete all unnecessary objects in memory with the rm() command. We can remove a particular element or all elements.

First, we create three reasonably large vectors and then tell R to delete one of them, as follows:

> A <- c(1:2E8)
> B <- c(1:2E8)
> C <- c(1:2E8)
> ls()
[1] "A" "B" "C"
> rm(A)
> ls()
[1] "B" "C"

If we want to clear all objects from memory, we can use the following code:

rm(list=ls()) 

Some people will point out that not all objects have really been deleted from memory, because garbage collection still has to happen. R will do this on its own, but if the user wants to force R's garbage collection to happen, this can be done with the gc() command.

If we want to look at the size of memory used already, we can call R's memory.size command. Here, we recreate the same two objects and examine the amount of size occupied. Let's have a look at the following code:

> A <- c(1:2E8)
> B <- c(1:2E8)
> memory.size()
[1] 2333.96

Regardless of dataset size, one easy mistake to make in R that will slow down the handling of even relatively small datasets is constantly recreating the object. This is in effect what is done with object resizing, and this is often what is responsible for slowing down R's notoriously slow loops so much.

For example, if we want to look at the NHANES data and don't want all five ordinal responses, but want to condense things to binary responses, we can do this in a relatively straightforward manner in R. We will go through three different looping functions that do this in the following sections. The first and third functions dynamically resize the vector of interest. The second function creates a vector of the appropriate size, and then it simply replaces it with the appropriate values.

Quite possibly one of the worst ways to create a vector in R is as shown in the following code:

physical.data <- read.csv('phys_func.txt')[-1]
condense.to.binary <- function(input.vector) {
  output.vector <- c()
  a <- 0
  
  for (i in 1:length(input.vector)) {
    if (input.vector[i] == 1) {a <- 0}
    if (input.vector[i] > 1){a <- 1}
    
    output.vector <- c(output.vector, a)
  }
  
  return(output.vector)
}

Here, we create the vector and fill it with some arbitrary values early on, then simply change a value of the vector with each iteration of the loop. No copying of the vector or resizing is needed, as shown in the following code:

condense.to.binary.2 <- function(input.vector) {
  output.vector <- rep(NA, length(input.vector))
  a <- 0
  
  for (i in 1:length(input.vector)) {
    if (input.vector[i] == 1) {a <- 0}
    if (input.vector[i] > 1){a <- 1}
    
    output.vector[i] <- a
  }
  
  return(output.vector)
}

In the preceding example, we declare the vector early on and use R's index method to grow it implicitly. Since the vector is still growing with each iteration, this requires dynamic resizing and will still run slowly, as shown in the following code:

condense.to.binary.3 <- function(input.vector) {
  output.vector <- c()
  a <- 0
  
  for (i in 1:length(input.vector)) {
    if (input.vector[i] == 1) {a <- 0}
    if (input.vector[i] > 1){a <- 1}
    
    output.vector[i] <- a
  }
  
  return(output.vector)
}

We can use the system.time command to compare performances. As we can see, the second method runs much faster than the other two. Here, we use a vector that repeats the first variable of the data frame 20 times just to exaggerate the impact of the difference in coding styles, as shown in the following screenshot:

Dynamically resizing objects in R is a major bottleneck in code performance, because it requires memory reallocation of the entire vector in each iteration. Sometimes, it has to be done, but it should be done as rarely as possible.