The hardware and bandwidth for this mirror is donated by METANET, the Webhosting and Full Service-Cloud Provider.
If you wish to report a bug, or if you are interested in having us mirror your free-software or open-source project, please feel free to contact us at mirror[@]metanet.ch.

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)

These binaries (installable software) and packages are in development.
They may not be fully stable and should be used with caution. We make no claims about them.