循环调用rmarkdown::render()时出现无法分配向量空间错误

It sounds like you're hitting a classic memory accumulation issue—even though individual renders work fine, running them in a loop causes R to hold onto memory from each iteration until it can't allocate more after the 9th file. That large params list you're passing every time is almost certainly a big contributor here, since R might be copying those objects repeatedly without releasing them properly.

Here are actionable fixes to resolve this:

1. Force Garbage Collection After Each Render #

Start with the simplest quick fix: explicitly trigger R's garbage collector right after each render call. This tells R to clean up unused objects immediately instead of waiting until it's desperate for memory.

library(rmarkdown)

# Get list of your Rmd files
rmd_paths <- list.files("your_target_directory", pattern = "\\.Rmd$", full.names = TRUE)
large_params <- your_big_params_list_here

for (rmd in rmd_paths) {
  cat("Rendering:", rmd, "\n")
  rmarkdown::render(rmd, params = large_params)
  # Force garbage collection (set verbose=TRUE to see what's being freed)
  gc(verbose = FALSE)
}

2. Render Each File in an Isolated Process #

The most reliable fix for memory leaks in loops is to run each render in a separate, dedicated R process. This way, when the process finishes, the operating system reclaims all its memory automatically—no accumulation in your main session.

Use the callr package to launch isolated processes easily:

library(rmarkdown)
library(callr)

rmd_paths <- list.files("your_target_directory", pattern = "\\.Rmd$", full.names = TRUE)
large_params <- your_big_params_list_here

for (rmd in rmd_paths) {
  cat("Rendering:", rmd, "\n")
  # Run render in a completely separate process
  r(
    func = function(file, params) {
      rmarkdown::render(file, params = params)
    },
    args = list(file = rmd, params = large_params)
  )
}

If you want to speed things up with parallel processing, use future with a multisession plan (works across Windows, macOS, and Linux):

library(rmarkdown)
library(future)

plan(multisession) # Spawns separate processes for each task
rmd_paths <- list.files("your_target_directory", pattern = "\\.Rmd$", full.names = TRUE)
large_params <- your_big_params_list_here

# Map over files with parallel futures
future_lapply(rmd_paths, function(rmd) {
  rmarkdown::render(rmd, params = large_params)
})

3. Optimize Your params List #

If your params contains large objects (like big datasets), passing them to every render call creates duplicate copies in memory. Instead:

• Load data directly in the Rmd: Replace params$large_dataset with readRDS("path/to/large_data.rds") or read.csv("path/to/large_data.csv") inside your Rmd file. This avoids copying the dataset across iterations entirely.
• Trim unnecessary params: Remove any objects in params that aren't actually used in the Rmd—every extra large object adds to memory bloat.

4. Clean Up Memory Inside Your Rmd Files #

Even if you fix the loop, your Rmd might be leaving large objects in memory during rendering. Add these lines at the end of each Rmd to clean up:

# Remove all objects from the Rmd's session
rm(list = ls())
# Force garbage collection within the Rmd's context
gc()

5. Increase R's Memory Limit (Last Resort) #

If you're on Windows, you can bump up R's maximum allowed memory with:

memory.limit(size = 16384) # Sets limit to 16GB (adjust based on your system's RAM)

On macOS/Linux, you'll need to adjust system-level memory limits (or upgrade your RAM) since R doesn't have a hard memory cap there. Note this is a temporary band-aid—fixing the root memory accumulation issue is better for long-term stability.

内容的提问来源于stack exchange，提问作者Adrian