- name: Add r-universe to repos

run: |

shell: Rscript {0}

- uses: r-lib/actions/setup-r-dependencies@v2

- name: Add r-universe to repos

run: |

shell: Rscript {0}

- uses: r-lib/actions/setup-r-dependencies@v2

job-config: ${{ matrix.config.job-config }}

- name: Add r-universe to repos

run: |

shell: Rscript {0}

- uses: r-hub/actions/setup-deps@v1

with:

- name: Add r-universe to repos

run: |

shell: Rscript {0}

- uses: r-lib/actions/setup-r-dependencies@v2

Package: mirai

Type: Package

Title: Minimalist Async Evaluation Framework for R

Description: Designed for simplicity, a 'mirai' evaluates an R expression

asynchronously in a parallel process, locally or distributed over the

network, with the result automatically available upon completion. Modern

Depends:

R (>= 3.6)

Imports:

Enhances:

parallel,

promises

* `everywhere()` adds argument '.serial' to accept serialization configurations created by `serial_config()`. These allow normally non-exportable reference objects such as Arrow Tables or torch tensors to be used seamlessly across parallel processes without additional marshalling steps. Configurations apply on a per compute profile basis.

* `serialization()` is now deprecated in favour of the above usage of `everywhere()`, and will be removed in a future version.

* Collecting a 'mirai_map' no longer spuriously introduces empty names where none were present originally.

* Faster local `daemons(dispatcher = FALSE)` and `make_cluster()` by using asynchronous launches (thanks @mtmorgan #123).

* Local dispatcher daemons now synchronize with host, the same as non-dispatcher daemons (prevents use before all have connected).

* More efficient dispatcher startup by only loading the base package, in addition to not reading startup configurations (thanks @krlmlr).

* Removes hard dependency on `stats` and `utils` base packages.

.expr <- c(.register, .expr)

.args <- c(.args, list(.serial = .serial))

`opt<-`(envir[["sock"]], "serial", .serial)

}

if (is.null(envir[["sockc"]])) {

```{r unres}

```{r map}

``` r

unresolved(m)

``` r

m[]

As a mirai represents an async operation, it is never necessary to wait

``` r

df <- data.frame(

)

m <- mirai_map(df, sprintf, .args = list(fmt = "%s: $%d"))

m[.flat]

All errors are returned as ‘errorValues’, facilitating recovery from

``` r

unresolved(m)

``` r

m[]

As a mirai represents an async operation, it is never necessary to wait for it. Other code can continue to be run. Once it completes, the return value automatically becomes available at `$data`.

``` r

For easy programmatic use of `mirai()`, '.expr' accepts a pre-constructed language object, and also a list of named arguments passed via '.args'. So, the following would be equivalent to the above:

m <- mirai(.expr = expr, .args = args)

m[]

[&laquo; Back to ToC](#table-of-contents)

The default `dispatcher = TRUE` creates a `dispatcher()` background process that connects to individual daemon processes on the local machine. This ensures that tasks are dispatched efficiently on a first-in first-out (FIFO) basis to daemons for processing. Tasks are queued at the dispatcher and sent to a daemon as soon as it can accept the task for immediate execution.

This implementation sends tasks immediately, and ensures that tasks are evenly-distributed amongst daemons. This means that optimal scheduling is not guaranteed as the duration of tasks cannot be known *a priori*. As an example, tasks could be queued at a daemon behind a long-running task, whilst other daemons are idle having already completed their tasks.

m[]

``` r

daemons(url = host_url(), dispatcher = FALSE)

Note that above, calling `host_url()` without a port value uses the default of '0'. This is a wildcard value that will automatically cause a free ephemeral port to be assigned. The actual assigned port is provided in the return value of the call, or it may be queried at any time via `status()`.

To reset all connections and revert to default behaviour:

launch_remote(1:2)

daemons(0)

``` r

launch_remote(1)

The printed value may be deployed directly on a remote machine.

vec <- c(1, 1, 4, 4, 1, 1, 1, 1)

system.time(mirai_map(vec, Sys.sleep)[])

system.time(parLapply(cl, vec, Sys.sleep))

`.args` is used to specify further constant arguments to `.f` - the 'mean' and 'sd' in the example below:

mirai_map(1:3, rnorm, .args = list(mean = 20, sd = 2))[]

)

Use `...` to further specify objects referenced but not defined in `.f` - the 'do' in the anonymous function below:

ml[]

Use of `mirai_map()` assumes that `daemons()` have previously been set. If not then one (non-dispatcher) daemon is set to allow the function to proceed. This ensures safe behaviour, but is unlikely to be optimal, so please ensure daemons are set beforehand.

m

m$data

```

```{r unres}

unresolved(m)

```