Background-Parallel Jobs • bakerrr

Elegant S7-based parallel job orchestration for R

{bakerrr} provides a clean, modern interface for running background parallel jobs using S7 classes, mirai daemon(s), and callr process management. Perfect for computationally intensive workflows that need robust error handling and progress monitoring.

Features

S7 Class System: Type-safe, modern R object system
Parallel Processing: Efficient daemon-based parallelization via mirai
Background Execution: Non-blocking job execution with callr::r_bg
Error Resilience: Built-in tryCatch error handling per job
Progress Monitoring: Console spinner with live status updates
Flexible Configuration: Customizable daemon count and cleanup options
Clean API: Intuitive print(), summary(), and run_jobs(wait_for_results) methods

Installation

You can install the development version of bakerrr from CRAN with:

install.packages("bakerrr")

Quick Start

# Define your function
compute_sum <- function(x, y) {
  Sys.sleep(1)  # Simulate work
  x + y
}

# Create argument lists for each job
args_list <- list(
  list(x = 1, y = 2),
  list(x = 3, y = 4),
  list(x = 5, y = 6),
  list(x = 7, y = 8)
)

# Create and run bakerrr job
job <- bakerrr::bakerrr(
  fun = compute_sum,
  args_list = args_list,
  n_daemons = 2
) |> 
  bakerrr::run_jobs(wait_for_results = TRUE)

# Check results
job@results
#> [[1]]
#> [1] 3
#> 
#> [[2]]
#> [1] 7
#> 
#> [[3]]
#> [1] 11
#> 
#> [[4]]
#> [1] 15

print(job)
#>    [01] function (x, y) { Sys.sleep(1) x + y }
#>    [02] function (x, y) { Sys.sleep(1) x + y }
#>    [03] function (x, y) { Sys.sleep(1) x + y }
#>    [04] function (x, y) { Sys.sleep(1) x + y }

Advanced Usage

Error Handling

# Function that may fail
risky_function <- function(x) {
  if (x == "error") stop("Intentional error")
  x * 2
}

args_list <- list(
  list(x = 5),
  list(x = "error"),  # This will fail gracefully
  list(x = 10)
)

job <- bakerrr::bakerrr(risky_function, args_list) |>
  bakerrr::run_jobs(wait_for_results = FALSE)
job@results
#> [1] "running"
#> [[1]] [1] 10
#> [[2]] [1] "Error in purrr::in_parallel: Intentional error"
#> [[3]] [1] 20

Background Job Arguments

# Custom logging and process options
compute_sum <- function(x, y) {
  Sys.sleep(1)  # Simulate work
  x + y
}

# Create argument lists for each job
args_list <- list(
  list(x = 1, y = 2),
  list(x = 3, y = 4),
  list(x = 5, y = 6),
  list(x = 7, y = 8)
)
job <- bakerrr::bakerrr(
  fun = compute_sum,
  args_list = args_list,
  bg_args = list(
    stdout = "job_output.log",
    stderr = "job_errors.log",
    supervise = TRUE
  )
) |>
  bakerrr::run_jobs(wait_for_results = FALSE)

Asynchronous Execution

long_running_function <- function() {
  Sys.sleep(5)
}
# Start job without waiting
job <- bakerrr::bakerrr(long_running_function, args_list) |> 
  bakerrr::run_jobs(wait_for_results = FALSE)

# Check status later
summary(job)
#>           Length           Class1           Class2             Mode 
#>                1 bakerrr::bakerrr        S7_object           object
#> ⏳ BackgroundParallelJob [running] - 4 daemon(s), 10 jobs

# Get results when ready
if (!job@bg_job_status$is_alive()) {
  results <- job@results
}

Multiple Functions in Parallel and in Background

You can run multiple different functions, each with their own arguments, in parallel background jobs using {bakerrr}. Just supply a list of functions and a matching list of argument sets:

# List of functions with different logic
fun_list <- list(
  function(x, y) x + y,
  function(x, y) x * y,
  function(x, y) x - y,
  function(x, y) x / y,
  function(x, y) x^y,
  function(x, y) x %% y,
  function(x, y) paste0(x, "-", y),
  function(x, y) mean(c(x, y)),
  function(x, y) max(x, y),
  function(x, y) min(x, y)
)

# Corresponding list of argument sets
set.seed(1)
args_list <- list(
  list(x = 3, y = 6),
  list(x = "p", y = 2),              # type error
  list(x = 5, y = 8),
  list(x = 10, y = 2),
  list(x = 2, y = 5),
  list(x = 13, y = 4),
  list(x = "A", y = 7),              # type error
  list(x = 6, y = 9),
  list(x = 3, y = 4),
  list(x = 1, y = 2)
)

# Run jobs in parallel
job <- bakerrr::bakerrr(
  fun = fun_list,
  args_list = args_list,
  n_daemons = 4
) |> bakerrr::run_jobs(wait_for_results = TRUE)

# Inspect results and status
job@results
#> [[1]]
#> [1] 9
#> 
#> [[2]]
#> Error in purrr::in_parallel: non-numeric argument to binary operator
#> 
#> [[3]]
#> [1] -3
#> 
#> [[4]]
#> [1] 5
#> 
#> [[5]]
#> [1] 32
#> 
#> [[6]]
#> [1] 1
#> 
#> [[7]]
#> [1] "A-7"
#> 
#> [[8]]
#> [1] 7.5
#> 
#> [[9]]
#> [1] 4
#> 
#> [[10]]
#> [1] 1
print(job)
#>    [01] function (x, y) x + y
#>    [02] function (x, y) x * y
#>    [03] function (x, y) x - y
#>    [04] function (x, y) x/y
#>    [05] function (x, y) x^y
#>    [06] function (x, y) x%%y
#>    [07] function (x, y) paste0(x, "-", y)
#>    [08] function (x, y) mean(c(x, y))
#>    [09] function (x, y) max(x, y)
#>    [10] function (x, y) min(x, y)
summary(job)
#>           Length           Class1           Class2             Mode 
#>                1 bakerrr::bakerrr        S7_object           object
bakerrr::status(job)
#> [1] "done"

Performance Tips

Optimal Daemon Count: Start with ceiling(cores / 5), adjust based on workload
Batch Size: Group small tasks to reduce overhead
Memory Usage: Monitor with bg_args = list(supervise = TRUE)
Error Recovery: Use tryCatch in your functions for custom error handling

Dependencies

S7: Modern object system
mirai: High-performance parallelization
callr: Background R processes
purrr: Functional programming toolkit
cli: Progress indicators
glue: String interpolation

Further Help & Documentation

For full documentation, visit the package website
API reference: Reference manual
Report issues: GitHub Issues

Troubleshooting

Windows: Make sure Rtools is installed for compilation.
Linux/macOS: Ensure system build tools (gcc, make, pandoc) are present.
Parallel/job failures: Check job@results for error output; validate function arguments.
Session Info: Please include output of sessionInfo() in bug reports.

Citation

To cite bakerrr in publications, run:

citation("bakerrr")
#> To cite package 'bakerrr' in publications use:
#> 
#>   Shaw A (2025). _bakerrr: Background-Parallel Jobs_. R package version
#>   0.2.0, <https://github.com/anirbanshaw24/bakerrr>.
#> 
#> A BibTeX entry for LaTeX users is
#> 
#>   @Manual{,
#>     title = {bakerrr: Background-Parallel Jobs},
#>     author = {Anirban Shaw},
#>     year = {2025},
#>     note = {R package version 0.2.0},
#>     url = {https://github.com/anirbanshaw24/bakerrr},
#>   }

bakerrr ⏲️