About Me

My R code is slow…

Why is my R code so slow?

There’s lots of ways to do things in R. Some are faster than others…

My R code is slow…

So why not use a compiled language?

Compiled languages convert code into machine language before running it, leading to faster execution.

Using compiled languages with R

• Identify the bottlenecks in your code (see Rprof()).

• For things that are very slow, rewrite the R function in a compiled language.

• Write an R function that calls the new function in the compiled language.

• Use the now faster R function.

Using compiled languages with R

C++

• C++ is a compiled, general purpose programming language.

• The {Rcpp} R package provides a C++ integration for R.

• {Rcpp} is used by over 2,500 packages on CRAN alone.

Rust

Writing functions in R and Rust

R

abs_value <- function(x) {
  abs_x <- if (x >= 0) { x } else { -x }
  return(abs_x)
}

Rust

fn abs_value(x: f64) -> f64 {
    let abs_x = if x>=0.0 { x } else { -1.0 * x };
    return abs_x;
}

Using Rust functions in R

Using Rust functions in R

library(rextendr)
rust_function(
  "fn abs_value_rust(x: f64) -> f64 {
    let abs_x = if x>=0.0 { x } else { -1.0 * x };
    return abs_x;
  }"
)

abs_value_rust(-3.45)

[1] 3.45

Using Rust functions in R

You might want use multiple Rust functions in R:

code <- r"(
#[extendr]
fn abs_value_rust(x: f64) -> f64 {
  let number = if x>=0.0 { x } else { -1.0 * x };
  return number;
}

#[extendr]
# More Rust code goes here!!!
)"

rust_source(code = code)

rust_source(file = "abs_value_rust.rs")

Applying functions multiple times

Although a lot of functions in R are vectorised, it isn’t always the case.

Options for applying a function to each element of a vector vec:

• for loops:

abs_x <- numeric(length = length(x))
for (i in seq_along(x)) {
  abs_x[i] <- abs_value_r(x[i])
}

• apply family of functions: sapply(x, abs_value_r)
• {purrr} package: purrr::map_vec(x, abs_value_r)
• …

Vectorising with Rust

fn abs_value_rust(x: f64) -> f64 {
    let abs_x = if x>=0.0 { x } else { -1.0 * x };
    return abs_x;
}

fn abs_value_iter(v: Vec<f64>) -> Vec<f64> {
    let abs_v: Vec<_> = v.iter().map(|x| abs_value_rust(*x)).collect();
    return abs_v;
}

Vectorising with Rust in R

code <- r"(
#[extendr]
fn abs_value_rust(x: f64) -> f64 {
  let number = if x>=0.0 { x } else { -1.0 * x };
  return number;
}

#[extendr]
fn abs_value_iter(v: Vec<f64>) -> Vec<f64> {
    let abs_v: Vec<_> = v.iter().map(|x| abs_value_rust(*x)).collect();
    return abs_v;
}
)"

rust_source(code = code)

Vectorising with Rust

set.seed(20240221)
z <- rnorm(20)
abs_value_iter(z)

Comparison of speed

Using Rust in an R package

• Create an R package as normal.

• Use rextendr::use_extendr() to set up scaffolding for using Rust.

• Edit src/rust/src/lib.rs to add your Rust functions.

• Run rextendr::document() to compile Rust code into R function.

• Run devtools::load_all() (or install and call library() as normal)

You might already be using Rust…

…without knowing it.

Closing thoughts

• Rust is fast (and user-friendly-ish…)

• R is a more user-friendly language, so an R wrapper means that users don’t have to learn Rust to get the speed increase.

• {rextendr} also enables the inclusion of Rust code in R packages.

• Similar approaches in Python also available.

Resources

• Slides: nrennie.rbind.io/talks/manchester-r-rust

• {rextendr} documentation: extendr.github.io/rextendr

• The Rust Programming Language book: doc.rust-lang.org/book

• See also github.com/dbdahl/cargo-framework.