Executing `koma` in Parallel

library(koma)

Introduction

This vignette demonstrates how to use the future::plan function to run koma package functions either sequentially or in parallel, depending on your operating system and other preferences.

For more details, see the future package documentation.

Preliminaries

Install the future and parallelly packages:

install.packages("future")
install.packages("parallelly")

We will use the simulated data contained in koma to illustrate the use of future::plan. The setup is the following:

library(koma)

equations <- "consumption ~ gdp + consumption.L(1),
investment ~ investment.L(1),
exports ~ world_gdp + exports.L(1),
imports ~ domestic_demand + imports.L(1),
prices ~ exchange_rate + oil_price + prices.L(1),
interest_rate ~ prices + interest_rate_germany + prices.L(1),
gdp == 0.6*consumption + 0.6*domestic_demand + 0.5*exports - 0.4*imports,
domestic_demand == 0.6*consumption + 0.4*investment"

exogenous_variables <- c("world_gdp", "interest_rate_germany", "exchange_rate", "oil_price")

dates <- list(
    estimation = list(start = c(1996, 1), end = c(2019, 4)),
    forecast = list(start = c(2023, 1), end = c(2023, 4))
)

sys_eq <- system_of_equations(equations, exogenous_variables)

series <- names(small_open_economy)
series <- series[!series %in% c("interest_rate", "interest_rate_germany")]

ts_data <- lapply(series, function(x) {
    as_ets(small_open_economy[[x]],
        series_type = "level", method = "diff_log"
    )
})
names(ts_data) <- series

ts_data$interest_rate <- as_ets(small_open_economy$interest_rate,
    series_type = "rate", method = "none"
)
ts_data$interest_rate_germany <- as_ets(small_open_economy$interest_rate_germany,
    series_type = "rate", method = "none"
)

Sequential Execution

By default, R executes code sequentially. For example:

estimates <- estimate(ts_data, sys_eq, dates)

Parallel Execution with future::plan

To enable parallel execution, you can use future::plan. The type of parallel execution depends on your operating system or whether you are running the code on a cluster.

Worker Setup

You need to define the number of workers that your parallel job to run on. Here we use all cores except one.

# Get the available workers
workers <- parallelly::availableCores(omit = 1)

Windows

For Windows, you can use multisession:

future::plan("future::multisession", workers = workers)

estimates <- estimate(ts_data, sys_eq, dates)

Linux

On Linux, you can use multicore (fork-based, lower overhead):

future::plan("future::multicore", workers = workers)

estimates <- estimate(ts_data, sys_eq, dates)

macOS

On macOS, do not use multicore. Apple’s Accelerate framework (the BLAS/LAPACK backend used by eigen()) relies on Grand Central Dispatch internally, which is not fork-safe. Forked workers will segfault with “invalid permissions” inside eigen().

Use multisession instead — it spawns fresh R processes rather than forking:

future::plan("future::multisession", workers = workers)

estimates <- estimate(ts_data, sys_eq, dates)