R Under development (unstable) (2024-03-25 r86192 ucrt) -- "Unsuffered Consequences"
Copyright (C) 2024 The R Foundation for Statistical Computing
Platform: x86_64-w64-mingw32/x64

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.

> source("incl/start.R")
[17:26:18.929] plan(): Setting new future strategy stack:
[17:26:18.930] List of future strategies:
[17:26:18.930] 1. sequential:
[17:26:18.930]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:18.930]    - tweaked: FALSE
[17:26:18.930]    - call: future::plan("sequential")
[17:26:18.946] plan(): nbrOfWorkers() = 1
> 
> message("*** Demos ...")
*** Demos ...
> 
> message("*** Fibonacci demo of the 'future' package ...")
*** Fibonacci demo of the 'future' package ...
> demo("fibonacci", package = "future", ask = FALSE)


	demo(fibonacci)
	---- ~~~~~~~~~

> library("future")

> library("listenv")

> ## IMPORTANT:
> ## 1. The below usage of lazy futures will only work when they are
> ##    all evaluated in the same process.
> ## 2. We disable the capturing of standard output (stdout=NA) to avoid
> ##    'sink stack is full' errors
> ## 3. We disable the capturing of most conditions (condition="error") to
> ##    avoid stacking up too many conditions
> oplan <- plan(sequential)
[17:26:18.960] plan(): Setting new future strategy stack:
[17:26:18.961] List of future strategies:
[17:26:18.961] 1. sequential:
[17:26:18.961]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:18.961]    - tweaked: FALSE
[17:26:18.961]    - call: plan(sequential)
[17:26:18.975] plan(): nbrOfWorkers() = 1

> ## Defines the first 100 Fibonacci numbers
> ## (0, 1, 1, 2, 3, 5, 8, ...)
> ## but calculate only the ones need when
> ## a number is actually requested.
> 
> x <- listenv()

> x[[1]] <- 0

> x[[2]] <- 1

> for (i in 3:100) {
+   x[[i]] %<-% { x[[i - 2]] + x[[i - 1]] } %lazy% TRUE %stdout% NA %conditions% "error"
+ }
[17:26:18.983] getGlobalsAndPackages() ...
[17:26:18.983] Searching for globals...
[17:26:18.990] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:18.991] Searching for globals ... DONE
[17:26:18.991] Resolving globals: FALSE
[17:26:18.992] The total size of the 2 globals is 224 bytes (224 bytes)
[17:26:18.993] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 224 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (168 bytes of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:18.993] - globals: [2] 'x', 'i'
[17:26:18.993] 
[17:26:18.993] getGlobalsAndPackages() ... DONE
[17:26:18.994] getGlobalsAndPackages() ...
[17:26:18.994] Searching for globals...
[17:26:18.996] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:18.997] Searching for globals ... DONE
[17:26:18.997] Resolving globals: FALSE
[17:26:18.998] The total size of the 2 globals is 8.29 KiB (8488 bytes)
[17:26:18.998] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 8.29 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (8.23 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:18.999] - globals: [2] 'x', 'i'
[17:26:18.999] 
[17:26:18.999] getGlobalsAndPackages() ... DONE
[17:26:18.999] getGlobalsAndPackages() ...
[17:26:19.000] Searching for globals...
[17:26:19.002] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.002] Searching for globals ... DONE
[17:26:19.002] Resolving globals: FALSE
[17:26:19.003] The total size of the 2 globals is 16.52 KiB (16920 bytes)
[17:26:19.005] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 16.52 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (16.47 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.005] - globals: [2] 'x', 'i'
[17:26:19.006] 
[17:26:19.006] getGlobalsAndPackages() ... DONE
[17:26:19.006] getGlobalsAndPackages() ...
[17:26:19.007] Searching for globals...
[17:26:19.008] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.009] Searching for globals ... DONE
[17:26:19.009] Resolving globals: FALSE
[17:26:19.010] The total size of the 2 globals is 24.76 KiB (25352 bytes)
[17:26:19.011] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 24.76 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (24.70 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.011] - globals: [2] 'x', 'i'
[17:26:19.011] 
[17:26:19.011] getGlobalsAndPackages() ... DONE
[17:26:19.012] getGlobalsAndPackages() ...
[17:26:19.012] Searching for globals...
[17:26:19.014] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.014] Searching for globals ... DONE
[17:26:19.015] Resolving globals: FALSE
[17:26:19.016] The total size of the 2 globals is 32.99 KiB (33784 bytes)
[17:26:19.017] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 32.99 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (32.94 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.017] - globals: [2] 'x', 'i'
[17:26:19.017] 
[17:26:19.018] getGlobalsAndPackages() ... DONE
[17:26:19.018] getGlobalsAndPackages() ...
[17:26:19.018] Searching for globals...
[17:26:19.020] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.020] Searching for globals ... DONE
[17:26:19.021] Resolving globals: FALSE
[17:26:19.023] The total size of the 2 globals is 41.23 KiB (42216 bytes)
[17:26:19.023] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 41.23 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (41.17 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.023] - globals: [2] 'x', 'i'
[17:26:19.024] 
[17:26:19.024] getGlobalsAndPackages() ... DONE
[17:26:19.024] getGlobalsAndPackages() ...
[17:26:19.025] Searching for globals...
[17:26:19.026] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.027] Searching for globals ... DONE
[17:26:19.027] Resolving globals: FALSE
[17:26:19.030] The total size of the 2 globals is 49.46 KiB (50648 bytes)
[17:26:19.031] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 49.46 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (49.41 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.031] - globals: [2] 'x', 'i'
[17:26:19.031] 
[17:26:19.031] getGlobalsAndPackages() ... DONE
[17:26:19.032] getGlobalsAndPackages() ...
[17:26:19.032] Searching for globals...
[17:26:19.034] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.034] Searching for globals ... DONE
[17:26:19.035] Resolving globals: FALSE
[17:26:19.037] The total size of the 2 globals is 57.70 KiB (59080 bytes)
[17:26:19.038] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 57.70 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (57.64 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.038] - globals: [2] 'x', 'i'
[17:26:19.038] 
[17:26:19.039] getGlobalsAndPackages() ... DONE
[17:26:19.039] getGlobalsAndPackages() ...
[17:26:19.039] Searching for globals...
[17:26:19.041] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.042] Searching for globals ... DONE
[17:26:19.042] Resolving globals: FALSE
[17:26:19.045] The total size of the 2 globals is 65.93 KiB (67512 bytes)
[17:26:19.045] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 65.93 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (65.88 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.046] - globals: [2] 'x', 'i'
[17:26:19.046] 
[17:26:19.046] getGlobalsAndPackages() ... DONE
[17:26:19.047] getGlobalsAndPackages() ...
[17:26:19.047] Searching for globals...
[17:26:19.049] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.049] Searching for globals ... DONE
[17:26:19.049] Resolving globals: FALSE
[17:26:19.053] The total size of the 2 globals is 74.16 KiB (75944 bytes)
[17:26:19.054] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 74.16 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (74.11 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.054] - globals: [2] 'x', 'i'
[17:26:19.054] 
[17:26:19.054] getGlobalsAndPackages() ... DONE
[17:26:19.055] getGlobalsAndPackages() ...
[17:26:19.055] Searching for globals...
[17:26:19.057] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.057] Searching for globals ... DONE
[17:26:19.057] Resolving globals: FALSE
[17:26:19.061] The total size of the 2 globals is 82.40 KiB (84376 bytes)
[17:26:19.062] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 82.40 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (82.34 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.062] - globals: [2] 'x', 'i'
[17:26:19.062] 
[17:26:19.062] getGlobalsAndPackages() ... DONE
[17:26:19.063] getGlobalsAndPackages() ...
[17:26:19.063] Searching for globals...
[17:26:19.065] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.065] Searching for globals ... DONE
[17:26:19.065] Resolving globals: FALSE
[17:26:19.069] The total size of the 2 globals is 90.63 KiB (92808 bytes)
[17:26:19.070] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 90.63 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (90.58 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.070] - globals: [2] 'x', 'i'
[17:26:19.070] 
[17:26:19.071] getGlobalsAndPackages() ... DONE
[17:26:19.071] getGlobalsAndPackages() ...
[17:26:19.071] Searching for globals...
[17:26:19.074] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.074] Searching for globals ... DONE
[17:26:19.074] Resolving globals: FALSE
[17:26:19.079] The total size of the 2 globals is 98.87 KiB (101240 bytes)
[17:26:19.079] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 98.87 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (98.81 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.080] - globals: [2] 'x', 'i'
[17:26:19.080] 
[17:26:19.080] getGlobalsAndPackages() ... DONE
[17:26:19.080] getGlobalsAndPackages() ...
[17:26:19.081] Searching for globals...
[17:26:19.082] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.083] Searching for globals ... DONE
[17:26:19.083] Resolving globals: FALSE
[17:26:19.088] The total size of the 2 globals is 107.10 KiB (109672 bytes)
[17:26:19.088] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 107.10 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (107.05 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.088] - globals: [2] 'x', 'i'
[17:26:19.089] 
[17:26:19.089] getGlobalsAndPackages() ... DONE
[17:26:19.089] getGlobalsAndPackages() ...
[17:26:19.090] Searching for globals...
[17:26:19.091] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.092] Searching for globals ... DONE
[17:26:19.092] Resolving globals: FALSE
[17:26:19.098] The total size of the 2 globals is 115.34 KiB (118104 bytes)
[17:26:19.098] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 115.34 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (115.28 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.098] - globals: [2] 'x', 'i'
[17:26:19.098] 
[17:26:19.099] getGlobalsAndPackages() ... DONE
[17:26:19.099] getGlobalsAndPackages() ...
[17:26:19.099] Searching for globals...
[17:26:19.101] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.101] Searching for globals ... DONE
[17:26:19.102] Resolving globals: FALSE
[17:26:19.107] The total size of the 2 globals is 123.57 KiB (126536 bytes)
[17:26:19.108] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 123.57 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (123.52 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.108] - globals: [2] 'x', 'i'
[17:26:19.108] 
[17:26:19.108] getGlobalsAndPackages() ... DONE
[17:26:19.109] getGlobalsAndPackages() ...
[17:26:19.109] Searching for globals...
[17:26:19.111] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.111] Searching for globals ... DONE
[17:26:19.111] Resolving globals: FALSE
[17:26:19.118] The total size of the 2 globals is 131.80 KiB (134968 bytes)
[17:26:19.118] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 131.80 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (131.75 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.118] - globals: [2] 'x', 'i'
[17:26:19.119] 
[17:26:19.119] getGlobalsAndPackages() ... DONE
[17:26:19.119] getGlobalsAndPackages() ...
[17:26:19.120] Searching for globals...
[17:26:19.121] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.122] Searching for globals ... DONE
[17:26:19.122] Resolving globals: FALSE
[17:26:19.128] The total size of the 2 globals is 140.04 KiB (143400 bytes)
[17:26:19.128] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 140.04 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (139.98 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.129] - globals: [2] 'x', 'i'
[17:26:19.129] 
[17:26:19.129] getGlobalsAndPackages() ... DONE
[17:26:19.130] getGlobalsAndPackages() ...
[17:26:19.130] Searching for globals...
[17:26:19.132] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.132] Searching for globals ... DONE
[17:26:19.133] Resolving globals: FALSE
[17:26:19.139] The total size of the 2 globals is 148.27 KiB (151832 bytes)
[17:26:19.140] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 148.27 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (148.22 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.140] - globals: [2] 'x', 'i'
[17:26:19.140] 
[17:26:19.140] getGlobalsAndPackages() ... DONE
[17:26:19.141] getGlobalsAndPackages() ...
[17:26:19.141] Searching for globals...
[17:26:19.143] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.143] Searching for globals ... DONE
[17:26:19.143] Resolving globals: FALSE
[17:26:19.152] The total size of the 2 globals is 156.51 KiB (160264 bytes)
[17:26:19.153] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 156.51 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (156.45 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.153] - globals: [2] 'x', 'i'
[17:26:19.153] 
[17:26:19.153] getGlobalsAndPackages() ... DONE
[17:26:19.154] getGlobalsAndPackages() ...
[17:26:19.154] Searching for globals...
[17:26:19.157] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.157] Searching for globals ... DONE
[17:26:19.157] Resolving globals: FALSE
[17:26:19.165] The total size of the 2 globals is 164.74 KiB (168696 bytes)
[17:26:19.166] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 164.74 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (164.69 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.166] - globals: [2] 'x', 'i'
[17:26:19.166] 
[17:26:19.167] getGlobalsAndPackages() ... DONE
[17:26:19.167] getGlobalsAndPackages() ...
[17:26:19.167] Searching for globals...
[17:26:19.169] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.170] Searching for globals ... DONE
[17:26:19.170] Resolving globals: FALSE
[17:26:19.178] The total size of the 2 globals is 172.98 KiB (177128 bytes)
[17:26:19.179] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 172.98 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (172.92 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.179] - globals: [2] 'x', 'i'
[17:26:19.179] 
[17:26:19.179] getGlobalsAndPackages() ... DONE
[17:26:19.180] getGlobalsAndPackages() ...
[17:26:19.180] Searching for globals...
[17:26:19.182] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.182] Searching for globals ... DONE
[17:26:19.182] Resolving globals: FALSE
[17:26:19.190] The total size of the 2 globals is 181.21 KiB (185560 bytes)
[17:26:19.190] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 181.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (181.16 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.191] - globals: [2] 'x', 'i'
[17:26:19.191] 
[17:26:19.191] getGlobalsAndPackages() ... DONE
[17:26:19.192] getGlobalsAndPackages() ...
[17:26:19.192] Searching for globals...
[17:26:19.194] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.195] Searching for globals ... DONE
[17:26:19.195] Resolving globals: FALSE
[17:26:19.203] The total size of the 2 globals is 189.45 KiB (193992 bytes)
[17:26:19.203] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 189.45 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (189.39 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.204] - globals: [2] 'x', 'i'
[17:26:19.204] 
[17:26:19.204] getGlobalsAndPackages() ... DONE
[17:26:19.204] getGlobalsAndPackages() ...
[17:26:19.205] Searching for globals...
[17:26:19.206] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.207] Searching for globals ... DONE
[17:26:19.207] Resolving globals: FALSE
[17:26:19.216] The total size of the 2 globals is 197.68 KiB (202424 bytes)
[17:26:19.216] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 197.68 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (197.62 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.217] - globals: [2] 'x', 'i'
[17:26:19.217] 
[17:26:19.217] getGlobalsAndPackages() ... DONE
[17:26:19.218] getGlobalsAndPackages() ...
[17:26:19.218] Searching for globals...
[17:26:19.220] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.220] Searching for globals ... DONE
[17:26:19.220] Resolving globals: FALSE
[17:26:19.229] The total size of the 2 globals is 205.91 KiB (210856 bytes)
[17:26:19.230] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 205.91 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (205.86 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.230] - globals: [2] 'x', 'i'
[17:26:19.230] 
[17:26:19.230] getGlobalsAndPackages() ... DONE
[17:26:19.231] getGlobalsAndPackages() ...
[17:26:19.231] Searching for globals...
[17:26:19.233] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.233] Searching for globals ... DONE
[17:26:19.233] Resolving globals: FALSE
[17:26:19.243] The total size of the 2 globals is 214.15 KiB (219288 bytes)
[17:26:19.243] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 214.15 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (214.09 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.243] - globals: [2] 'x', 'i'
[17:26:19.243] 
[17:26:19.244] getGlobalsAndPackages() ... DONE
[17:26:19.244] getGlobalsAndPackages() ...
[17:26:19.244] Searching for globals...
[17:26:19.247] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.247] Searching for globals ... DONE
[17:26:19.247] Resolving globals: FALSE
[17:26:19.257] The total size of the 2 globals is 222.38 KiB (227720 bytes)
[17:26:19.257] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 222.38 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (222.33 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.258] - globals: [2] 'x', 'i'
[17:26:19.258] 
[17:26:19.258] getGlobalsAndPackages() ... DONE
[17:26:19.259] getGlobalsAndPackages() ...
[17:26:19.259] Searching for globals...
[17:26:19.261] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.261] Searching for globals ... DONE
[17:26:19.261] Resolving globals: FALSE
[17:26:19.271] The total size of the 2 globals is 230.62 KiB (236152 bytes)
[17:26:19.272] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 230.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (230.56 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.272] - globals: [2] 'x', 'i'
[17:26:19.272] 
[17:26:19.272] getGlobalsAndPackages() ... DONE
[17:26:19.273] getGlobalsAndPackages() ...
[17:26:19.273] Searching for globals...
[17:26:19.275] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.275] Searching for globals ... DONE
[17:26:19.275] Resolving globals: FALSE
[17:26:19.286] The total size of the 2 globals is 238.85 KiB (244584 bytes)
[17:26:19.287] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 238.85 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (238.80 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.287] - globals: [2] 'x', 'i'
[17:26:19.287] 
[17:26:19.287] getGlobalsAndPackages() ... DONE
[17:26:19.288] getGlobalsAndPackages() ...
[17:26:19.288] Searching for globals...
[17:26:19.290] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.290] Searching for globals ... DONE
[17:26:19.290] Resolving globals: FALSE
[17:26:19.301] The total size of the 2 globals is 247.09 KiB (253016 bytes)
[17:26:19.302] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 247.09 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (247.03 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.302] - globals: [2] 'x', 'i'
[17:26:19.302] 
[17:26:19.302] getGlobalsAndPackages() ... DONE
[17:26:19.303] getGlobalsAndPackages() ...
[17:26:19.303] Searching for globals...
[17:26:19.305] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.305] Searching for globals ... DONE
[17:26:19.305] Resolving globals: FALSE
[17:26:19.317] The total size of the 2 globals is 255.32 KiB (261448 bytes)
[17:26:19.317] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 255.32 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (255.27 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.318] - globals: [2] 'x', 'i'
[17:26:19.318] 
[17:26:19.318] getGlobalsAndPackages() ... DONE
[17:26:19.319] getGlobalsAndPackages() ...
[17:26:19.319] Searching for globals...
[17:26:19.321] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.321] Searching for globals ... DONE
[17:26:19.321] Resolving globals: FALSE
[17:26:19.355] The total size of the 2 globals is 263.55 KiB (269880 bytes)
[17:26:19.356] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 263.55 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (263.50 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.356] - globals: [2] 'x', 'i'
[17:26:19.356] 
[17:26:19.356] getGlobalsAndPackages() ... DONE
[17:26:19.357] getGlobalsAndPackages() ...
[17:26:19.357] Searching for globals...
[17:26:19.359] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.359] Searching for globals ... DONE
[17:26:19.359] Resolving globals: FALSE
[17:26:19.371] The total size of the 2 globals is 271.79 KiB (278312 bytes)
[17:26:19.372] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 271.79 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (271.73 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.372] - globals: [2] 'x', 'i'
[17:26:19.372] 
[17:26:19.373] getGlobalsAndPackages() ... DONE
[17:26:19.373] getGlobalsAndPackages() ...
[17:26:19.373] Searching for globals...
[17:26:19.375] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.375] Searching for globals ... DONE
[17:26:19.376] Resolving globals: FALSE
[17:26:19.388] The total size of the 2 globals is 280.02 KiB (286744 bytes)
[17:26:19.388] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 280.02 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (279.97 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.389] - globals: [2] 'x', 'i'
[17:26:19.389] 
[17:26:19.389] getGlobalsAndPackages() ... DONE
[17:26:19.389] getGlobalsAndPackages() ...
[17:26:19.390] Searching for globals...
[17:26:19.392] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.392] Searching for globals ... DONE
[17:26:19.393] Resolving globals: FALSE
[17:26:19.405] The total size of the 2 globals is 288.26 KiB (295176 bytes)
[17:26:19.405] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 288.26 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (288.20 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.406] - globals: [2] 'x', 'i'
[17:26:19.406] 
[17:26:19.406] getGlobalsAndPackages() ... DONE
[17:26:19.407] getGlobalsAndPackages() ...
[17:26:19.407] Searching for globals...
[17:26:19.409] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.409] Searching for globals ... DONE
[17:26:19.410] Resolving globals: FALSE
[17:26:19.422] The total size of the 2 globals is 296.49 KiB (303608 bytes)
[17:26:19.423] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 296.49 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (296.44 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.423] - globals: [2] 'x', 'i'
[17:26:19.423] 
[17:26:19.423] getGlobalsAndPackages() ... DONE
[17:26:19.424] getGlobalsAndPackages() ...
[17:26:19.424] Searching for globals...
[17:26:19.427] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.427] Searching for globals ... DONE
[17:26:19.427] Resolving globals: FALSE
[17:26:19.440] The total size of the 2 globals is 304.73 KiB (312040 bytes)
[17:26:19.441] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 304.73 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (304.67 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.441] - globals: [2] 'x', 'i'
[17:26:19.441] 
[17:26:19.441] getGlobalsAndPackages() ... DONE
[17:26:19.442] getGlobalsAndPackages() ...
[17:26:19.442] Searching for globals...
[17:26:19.445] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.445] Searching for globals ... DONE
[17:26:19.445] Resolving globals: FALSE
[17:26:19.458] The total size of the 2 globals is 312.96 KiB (320472 bytes)
[17:26:19.459] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 312.96 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (312.91 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.459] - globals: [2] 'x', 'i'
[17:26:19.459] 
[17:26:19.459] getGlobalsAndPackages() ... DONE
[17:26:19.460] getGlobalsAndPackages() ...
[17:26:19.460] Searching for globals...
[17:26:19.463] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.463] Searching for globals ... DONE
[17:26:19.463] Resolving globals: FALSE
[17:26:19.477] The total size of the 2 globals is 321.20 KiB (328904 bytes)
[17:26:19.478] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 321.20 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (321.14 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.478] - globals: [2] 'x', 'i'
[17:26:19.478] 
[17:26:19.478] getGlobalsAndPackages() ... DONE
[17:26:19.479] getGlobalsAndPackages() ...
[17:26:19.479] Searching for globals...
[17:26:19.481] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.481] Searching for globals ... DONE
[17:26:19.481] Resolving globals: FALSE
[17:26:19.496] The total size of the 2 globals is 329.43 KiB (337336 bytes)
[17:26:19.497] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 329.43 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (329.38 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.497] - globals: [2] 'x', 'i'
[17:26:19.497] 
[17:26:19.497] getGlobalsAndPackages() ... DONE
[17:26:19.498] getGlobalsAndPackages() ...
[17:26:19.498] Searching for globals...
[17:26:19.500] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.500] Searching for globals ... DONE
[17:26:19.500] Resolving globals: FALSE
[17:26:19.515] The total size of the 2 globals is 337.66 KiB (345768 bytes)
[17:26:19.516] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 337.66 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (337.61 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.516] - globals: [2] 'x', 'i'
[17:26:19.516] 
[17:26:19.516] getGlobalsAndPackages() ... DONE
[17:26:19.517] getGlobalsAndPackages() ...
[17:26:19.517] Searching for globals...
[17:26:19.519] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.519] Searching for globals ... DONE
[17:26:19.519] Resolving globals: FALSE
[17:26:19.535] The total size of the 2 globals is 345.90 KiB (354200 bytes)
[17:26:19.535] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 345.90 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (345.84 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.535] - globals: [2] 'x', 'i'
[17:26:19.535] 
[17:26:19.536] getGlobalsAndPackages() ... DONE
[17:26:19.536] getGlobalsAndPackages() ...
[17:26:19.536] Searching for globals...
[17:26:19.538] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.539] Searching for globals ... DONE
[17:26:19.539] Resolving globals: FALSE
[17:26:19.554] The total size of the 2 globals is 354.13 KiB (362632 bytes)
[17:26:19.555] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 354.13 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (354.08 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.555] - globals: [2] 'x', 'i'
[17:26:19.555] 
[17:26:19.555] getGlobalsAndPackages() ... DONE
[17:26:19.556] getGlobalsAndPackages() ...
[17:26:19.556] Searching for globals...
[17:26:19.558] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.558] Searching for globals ... DONE
[17:26:19.558] Resolving globals: FALSE
[17:26:19.574] The total size of the 2 globals is 362.37 KiB (371064 bytes)
[17:26:19.575] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 362.37 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (362.31 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.575] - globals: [2] 'x', 'i'
[17:26:19.575] 
[17:26:19.575] getGlobalsAndPackages() ... DONE
[17:26:19.576] getGlobalsAndPackages() ...
[17:26:19.576] Searching for globals...
[17:26:19.578] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.578] Searching for globals ... DONE
[17:26:19.578] Resolving globals: FALSE
[17:26:19.595] The total size of the 2 globals is 370.60 KiB (379496 bytes)
[17:26:19.596] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 370.60 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (370.55 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.596] - globals: [2] 'x', 'i'
[17:26:19.596] 
[17:26:19.596] getGlobalsAndPackages() ... DONE
[17:26:19.597] getGlobalsAndPackages() ...
[17:26:19.597] Searching for globals...
[17:26:19.599] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.599] Searching for globals ... DONE
[17:26:19.599] Resolving globals: FALSE
[17:26:19.616] The total size of the 2 globals is 378.84 KiB (387928 bytes)
[17:26:19.617] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 378.84 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (378.78 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.617] - globals: [2] 'x', 'i'
[17:26:19.617] 
[17:26:19.617] getGlobalsAndPackages() ... DONE
[17:26:19.618] getGlobalsAndPackages() ...
[17:26:19.618] Searching for globals...
[17:26:19.620] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.620] Searching for globals ... DONE
[17:26:19.620] Resolving globals: FALSE
[17:26:19.637] The total size of the 2 globals is 387.07 KiB (396360 bytes)
[17:26:19.638] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 387.07 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (387.02 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.638] - globals: [2] 'x', 'i'
[17:26:19.638] 
[17:26:19.638] getGlobalsAndPackages() ... DONE
[17:26:19.639] getGlobalsAndPackages() ...
[17:26:19.639] Searching for globals...
[17:26:19.641] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.641] Searching for globals ... DONE
[17:26:19.641] Resolving globals: FALSE
[17:26:19.659] The total size of the 2 globals is 395.30 KiB (404792 bytes)
[17:26:19.660] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 395.30 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (395.25 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.660] - globals: [2] 'x', 'i'
[17:26:19.660] 
[17:26:19.660] getGlobalsAndPackages() ... DONE
[17:26:19.661] getGlobalsAndPackages() ...
[17:26:19.661] Searching for globals...
[17:26:19.663] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.663] Searching for globals ... DONE
[17:26:19.663] Resolving globals: FALSE
[17:26:19.681] The total size of the 2 globals is 403.54 KiB (413224 bytes)
[17:26:19.682] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 403.54 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (403.48 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.682] - globals: [2] 'x', 'i'
[17:26:19.682] 
[17:26:19.682] getGlobalsAndPackages() ... DONE
[17:26:19.683] getGlobalsAndPackages() ...
[17:26:19.683] Searching for globals...
[17:26:19.685] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.685] Searching for globals ... DONE
[17:26:19.685] Resolving globals: FALSE
[17:26:19.704] The total size of the 2 globals is 411.77 KiB (421656 bytes)
[17:26:19.704] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 411.77 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (411.72 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.704] - globals: [2] 'x', 'i'
[17:26:19.704] 
[17:26:19.705] getGlobalsAndPackages() ... DONE
[17:26:19.705] getGlobalsAndPackages() ...
[17:26:19.705] Searching for globals...
[17:26:19.707] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.707] Searching for globals ... DONE
[17:26:19.708] Resolving globals: FALSE
[17:26:19.727] The total size of the 2 globals is 420.01 KiB (430088 bytes)
[17:26:19.728] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 420.01 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (419.95 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.728] - globals: [2] 'x', 'i'
[17:26:19.728] 
[17:26:19.728] getGlobalsAndPackages() ... DONE
[17:26:19.729] getGlobalsAndPackages() ...
[17:26:19.729] Searching for globals...
[17:26:19.731] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.731] Searching for globals ... DONE
[17:26:19.731] Resolving globals: FALSE
[17:26:19.750] The total size of the 2 globals is 428.24 KiB (438520 bytes)
[17:26:19.751] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 428.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (428.19 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.751] - globals: [2] 'x', 'i'
[17:26:19.751] 
[17:26:19.751] getGlobalsAndPackages() ... DONE
[17:26:19.752] getGlobalsAndPackages() ...
[17:26:19.752] Searching for globals...
[17:26:19.754] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.754] Searching for globals ... DONE
[17:26:19.754] Resolving globals: FALSE
[17:26:19.774] The total size of the 2 globals is 436.48 KiB (446952 bytes)
[17:26:19.775] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 436.48 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (436.42 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.775] - globals: [2] 'x', 'i'
[17:26:19.775] 
[17:26:19.775] getGlobalsAndPackages() ... DONE
[17:26:19.776] getGlobalsAndPackages() ...
[17:26:19.776] Searching for globals...
[17:26:19.778] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.778] Searching for globals ... DONE
[17:26:19.778] Resolving globals: FALSE
[17:26:19.798] The total size of the 2 globals is 444.71 KiB (455384 bytes)
[17:26:19.798] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 444.71 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (444.66 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.799] - globals: [2] 'x', 'i'
[17:26:19.799] 
[17:26:19.799] getGlobalsAndPackages() ... DONE
[17:26:19.800] getGlobalsAndPackages() ...
[17:26:19.800] Searching for globals...
[17:26:19.802] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.802] Searching for globals ... DONE
[17:26:19.802] Resolving globals: FALSE
[17:26:19.823] The total size of the 2 globals is 452.95 KiB (463816 bytes)
[17:26:19.823] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 452.95 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (452.89 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.823] - globals: [2] 'x', 'i'
[17:26:19.824] 
[17:26:19.824] getGlobalsAndPackages() ... DONE
[17:26:19.824] getGlobalsAndPackages() ...
[17:26:19.824] Searching for globals...
[17:26:19.826] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.827] Searching for globals ... DONE
[17:26:19.827] Resolving globals: FALSE
[17:26:19.847] The total size of the 2 globals is 461.18 KiB (472248 bytes)
[17:26:19.848] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 461.18 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (461.12 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.848] - globals: [2] 'x', 'i'
[17:26:19.848] 
[17:26:19.848] getGlobalsAndPackages() ... DONE
[17:26:19.849] getGlobalsAndPackages() ...
[17:26:19.849] Searching for globals...
[17:26:19.851] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.851] Searching for globals ... DONE
[17:26:19.851] Resolving globals: FALSE
[17:26:19.873] The total size of the 2 globals is 469.41 KiB (480680 bytes)
[17:26:19.873] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 469.41 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (469.36 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.873] - globals: [2] 'x', 'i'
[17:26:19.873] 
[17:26:19.874] getGlobalsAndPackages() ... DONE
[17:26:19.874] getGlobalsAndPackages() ...
[17:26:19.874] Searching for globals...
[17:26:19.876] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.877] Searching for globals ... DONE
[17:26:19.877] Resolving globals: FALSE
[17:26:19.898] The total size of the 2 globals is 477.65 KiB (489112 bytes)
[17:26:19.898] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 477.65 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (477.59 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.898] - globals: [2] 'x', 'i'
[17:26:19.899] 
[17:26:19.899] getGlobalsAndPackages() ... DONE
[17:26:19.899] getGlobalsAndPackages() ...
[17:26:19.900] Searching for globals...
[17:26:19.901] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.902] Searching for globals ... DONE
[17:26:19.902] Resolving globals: FALSE
[17:26:19.924] The total size of the 2 globals is 485.88 KiB (497544 bytes)
[17:26:19.924] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 485.88 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (485.83 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.925] - globals: [2] 'x', 'i'
[17:26:19.925] 
[17:26:19.925] getGlobalsAndPackages() ... DONE
[17:26:19.926] getGlobalsAndPackages() ...
[17:26:19.926] Searching for globals...
[17:26:19.928] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.928] Searching for globals ... DONE
[17:26:19.928] Resolving globals: FALSE
[17:26:19.950] The total size of the 2 globals is 494.12 KiB (505976 bytes)
[17:26:19.951] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 494.12 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (494.06 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.951] - globals: [2] 'x', 'i'
[17:26:19.951] 
[17:26:19.951] getGlobalsAndPackages() ... DONE
[17:26:19.952] getGlobalsAndPackages() ...
[17:26:19.952] Searching for globals...
[17:26:19.954] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.954] Searching for globals ... DONE
[17:26:19.954] Resolving globals: FALSE
[17:26:19.977] The total size of the 2 globals is 502.35 KiB (514408 bytes)
[17:26:19.977] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 502.35 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (502.30 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:19.977] - globals: [2] 'x', 'i'
[17:26:19.978] 
[17:26:19.978] getGlobalsAndPackages() ... DONE
[17:26:19.978] getGlobalsAndPackages() ...
[17:26:19.979] Searching for globals...
[17:26:19.981] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:19.981] Searching for globals ... DONE
[17:26:19.982] Resolving globals: FALSE
[17:26:20.004] The total size of the 2 globals is 510.59 KiB (522840 bytes)
[17:26:20.005] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 510.59 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (510.53 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.005] - globals: [2] 'x', 'i'
[17:26:20.005] 
[17:26:20.005] getGlobalsAndPackages() ... DONE
[17:26:20.006] getGlobalsAndPackages() ...
[17:26:20.006] Searching for globals...
[17:26:20.008] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.008] Searching for globals ... DONE
[17:26:20.008] Resolving globals: FALSE
[17:26:20.032] The total size of the 2 globals is 518.82 KiB (531272 bytes)
[17:26:20.032] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 518.82 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (518.77 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.032] - globals: [2] 'x', 'i'
[17:26:20.033] 
[17:26:20.033] getGlobalsAndPackages() ... DONE
[17:26:20.033] getGlobalsAndPackages() ...
[17:26:20.034] Searching for globals...
[17:26:20.035] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.036] Searching for globals ... DONE
[17:26:20.036] Resolving globals: FALSE
[17:26:20.060] The total size of the 2 globals is 527.05 KiB (539704 bytes)
[17:26:20.061] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 527.05 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (527.00 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.061] - globals: [2] 'x', 'i'
[17:26:20.061] 
[17:26:20.061] getGlobalsAndPackages() ... DONE
[17:26:20.062] getGlobalsAndPackages() ...
[17:26:20.062] Searching for globals...
[17:26:20.064] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.064] Searching for globals ... DONE
[17:26:20.064] Resolving globals: FALSE
[17:26:20.088] The total size of the 2 globals is 535.29 KiB (548136 bytes)
[17:26:20.089] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 535.29 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (535.23 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.089] - globals: [2] 'x', 'i'
[17:26:20.089] 
[17:26:20.090] getGlobalsAndPackages() ... DONE
[17:26:20.090] getGlobalsAndPackages() ...
[17:26:20.090] Searching for globals...
[17:26:20.092] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.092] Searching for globals ... DONE
[17:26:20.092] Resolving globals: FALSE
[17:26:20.115] The total size of the 2 globals is 543.52 KiB (556568 bytes)
[17:26:20.116] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 543.52 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (543.47 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.116] - globals: [2] 'x', 'i'
[17:26:20.116] 
[17:26:20.116] getGlobalsAndPackages() ... DONE
[17:26:20.117] getGlobalsAndPackages() ...
[17:26:20.117] Searching for globals...
[17:26:20.119] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.120] Searching for globals ... DONE
[17:26:20.120] Resolving globals: FALSE
[17:26:20.143] The total size of the 2 globals is 551.76 KiB (565000 bytes)
[17:26:20.143] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 551.76 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (551.70 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.143] - globals: [2] 'x', 'i'
[17:26:20.143] 
[17:26:20.144] getGlobalsAndPackages() ... DONE
[17:26:20.144] getGlobalsAndPackages() ...
[17:26:20.144] Searching for globals...
[17:26:20.146] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.146] Searching for globals ... DONE
[17:26:20.146] Resolving globals: FALSE
[17:26:20.171] The total size of the 2 globals is 559.99 KiB (573432 bytes)
[17:26:20.171] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 559.99 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (559.94 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.172] - globals: [2] 'x', 'i'
[17:26:20.172] 
[17:26:20.172] getGlobalsAndPackages() ... DONE
[17:26:20.172] getGlobalsAndPackages() ...
[17:26:20.173] Searching for globals...
[17:26:20.174] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.175] Searching for globals ... DONE
[17:26:20.175] Resolving globals: FALSE
[17:26:20.200] The total size of the 2 globals is 568.23 KiB (581864 bytes)
[17:26:20.201] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 568.23 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (568.17 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.201] - globals: [2] 'x', 'i'
[17:26:20.201] 
[17:26:20.201] getGlobalsAndPackages() ... DONE
[17:26:20.202] getGlobalsAndPackages() ...
[17:26:20.202] Searching for globals...
[17:26:20.204] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.204] Searching for globals ... DONE
[17:26:20.204] Resolving globals: FALSE
[17:26:20.230] The total size of the 2 globals is 576.46 KiB (590296 bytes)
[17:26:20.231] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 576.46 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (576.41 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.231] - globals: [2] 'x', 'i'
[17:26:20.231] 
[17:26:20.231] getGlobalsAndPackages() ... DONE
[17:26:20.232] getGlobalsAndPackages() ...
[17:26:20.232] Searching for globals...
[17:26:20.234] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.234] Searching for globals ... DONE
[17:26:20.234] Resolving globals: FALSE
[17:26:20.261] The total size of the 2 globals is 584.70 KiB (598728 bytes)
[17:26:20.261] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 584.70 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (584.64 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.261] - globals: [2] 'x', 'i'
[17:26:20.262] 
[17:26:20.262] getGlobalsAndPackages() ... DONE
[17:26:20.262] getGlobalsAndPackages() ...
[17:26:20.263] Searching for globals...
[17:26:20.264] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.265] Searching for globals ... DONE
[17:26:20.265] Resolving globals: FALSE
[17:26:20.292] The total size of the 2 globals is 592.93 KiB (607160 bytes)
[17:26:20.292] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 592.93 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (592.88 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.292] - globals: [2] 'x', 'i'
[17:26:20.293] 
[17:26:20.293] getGlobalsAndPackages() ... DONE
[17:26:20.293] getGlobalsAndPackages() ...
[17:26:20.294] Searching for globals...
[17:26:20.296] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.296] Searching for globals ... DONE
[17:26:20.296] Resolving globals: FALSE
[17:26:20.324] The total size of the 2 globals is 601.16 KiB (615592 bytes)
[17:26:20.324] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 601.16 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (601.11 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.324] - globals: [2] 'x', 'i'
[17:26:20.325] 
[17:26:20.325] getGlobalsAndPackages() ... DONE
[17:26:20.325] getGlobalsAndPackages() ...
[17:26:20.326] Searching for globals...
[17:26:20.328] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.328] Searching for globals ... DONE
[17:26:20.328] Resolving globals: FALSE
[17:26:20.356] The total size of the 2 globals is 609.40 KiB (624024 bytes)
[17:26:20.356] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 609.40 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (609.34 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.357] - globals: [2] 'x', 'i'
[17:26:20.357] 
[17:26:20.357] getGlobalsAndPackages() ... DONE
[17:26:20.358] getGlobalsAndPackages() ...
[17:26:20.358] Searching for globals...
[17:26:20.360] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.360] Searching for globals ... DONE
[17:26:20.360] Resolving globals: FALSE
[17:26:20.388] The total size of the 2 globals is 617.63 KiB (632456 bytes)
[17:26:20.388] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 617.63 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (617.58 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.389] - globals: [2] 'x', 'i'
[17:26:20.389] 
[17:26:20.389] getGlobalsAndPackages() ... DONE
[17:26:20.390] getGlobalsAndPackages() ...
[17:26:20.390] Searching for globals...
[17:26:20.392] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.392] Searching for globals ... DONE
[17:26:20.392] Resolving globals: FALSE
[17:26:20.420] The total size of the 2 globals is 625.87 KiB (640888 bytes)
[17:26:20.421] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 625.87 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (625.81 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.421] - globals: [2] 'x', 'i'
[17:26:20.421] 
[17:26:20.421] getGlobalsAndPackages() ... DONE
[17:26:20.422] getGlobalsAndPackages() ...
[17:26:20.422] Searching for globals...
[17:26:20.424] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.424] Searching for globals ... DONE
[17:26:20.424] Resolving globals: FALSE
[17:26:20.453] The total size of the 2 globals is 634.10 KiB (649320 bytes)
[17:26:20.454] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 634.10 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (634.05 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.454] - globals: [2] 'x', 'i'
[17:26:20.454] 
[17:26:20.454] getGlobalsAndPackages() ... DONE
[17:26:20.455] getGlobalsAndPackages() ...
[17:26:20.455] Searching for globals...
[17:26:20.457] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.457] Searching for globals ... DONE
[17:26:20.457] Resolving globals: FALSE
[17:26:20.487] The total size of the 2 globals is 642.34 KiB (657752 bytes)
[17:26:20.487] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 642.34 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (642.28 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.487] - globals: [2] 'x', 'i'
[17:26:20.488] 
[17:26:20.488] getGlobalsAndPackages() ... DONE
[17:26:20.488] getGlobalsAndPackages() ...
[17:26:20.489] Searching for globals...
[17:26:20.490] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.491] Searching for globals ... DONE
[17:26:20.491] Resolving globals: FALSE
[17:26:20.520] The total size of the 2 globals is 650.57 KiB (666184 bytes)
[17:26:20.521] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 650.57 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (650.52 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.521] - globals: [2] 'x', 'i'
[17:26:20.521] 
[17:26:20.521] getGlobalsAndPackages() ... DONE
[17:26:20.522] getGlobalsAndPackages() ...
[17:26:20.522] Searching for globals...
[17:26:20.524] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.524] Searching for globals ... DONE
[17:26:20.524] Resolving globals: FALSE
[17:26:20.554] The total size of the 2 globals is 658.80 KiB (674616 bytes)
[17:26:20.555] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 658.80 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (658.75 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.555] - globals: [2] 'x', 'i'
[17:26:20.555] 
[17:26:20.555] getGlobalsAndPackages() ... DONE
[17:26:20.556] getGlobalsAndPackages() ...
[17:26:20.556] Searching for globals...
[17:26:20.558] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.558] Searching for globals ... DONE
[17:26:20.558] Resolving globals: FALSE
[17:26:20.589] The total size of the 2 globals is 667.04 KiB (683048 bytes)
[17:26:20.589] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 667.04 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (666.98 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.590] - globals: [2] 'x', 'i'
[17:26:20.590] 
[17:26:20.590] getGlobalsAndPackages() ... DONE
[17:26:20.591] getGlobalsAndPackages() ...
[17:26:20.591] Searching for globals...
[17:26:20.593] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.593] Searching for globals ... DONE
[17:26:20.593] Resolving globals: FALSE
[17:26:20.624] The total size of the 2 globals is 675.27 KiB (691480 bytes)
[17:26:20.624] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 675.27 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (675.22 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.624] - globals: [2] 'x', 'i'
[17:26:20.625] 
[17:26:20.625] getGlobalsAndPackages() ... DONE
[17:26:20.625] getGlobalsAndPackages() ...
[17:26:20.626] Searching for globals...
[17:26:20.627] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.628] Searching for globals ... DONE
[17:26:20.628] Resolving globals: FALSE
[17:26:20.660] The total size of the 2 globals is 683.51 KiB (699912 bytes)
[17:26:20.660] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 683.51 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (683.45 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.660] - globals: [2] 'x', 'i'
[17:26:20.661] 
[17:26:20.661] getGlobalsAndPackages() ... DONE
[17:26:20.661] getGlobalsAndPackages() ...
[17:26:20.662] Searching for globals...
[17:26:20.664] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.664] Searching for globals ... DONE
[17:26:20.664] Resolving globals: FALSE
[17:26:20.695] The total size of the 2 globals is 691.74 KiB (708344 bytes)
[17:26:20.696] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 691.74 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (691.69 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.696] - globals: [2] 'x', 'i'
[17:26:20.696] 
[17:26:20.697] getGlobalsAndPackages() ... DONE
[17:26:20.697] getGlobalsAndPackages() ...
[17:26:20.697] Searching for globals...
[17:26:20.699] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.699] Searching for globals ... DONE
[17:26:20.700] Resolving globals: FALSE
[17:26:20.732] The total size of the 2 globals is 699.98 KiB (716776 bytes)
[17:26:20.733] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 699.98 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (699.92 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.733] - globals: [2] 'x', 'i'
[17:26:20.733] 
[17:26:20.733] getGlobalsAndPackages() ... DONE
[17:26:20.734] getGlobalsAndPackages() ...
[17:26:20.734] Searching for globals...
[17:26:20.736] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.736] Searching for globals ... DONE
[17:26:20.737] Resolving globals: FALSE
[17:26:20.769] The total size of the 2 globals is 708.21 KiB (725208 bytes)
[17:26:20.769] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 708.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (708.16 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.769] - globals: [2] 'x', 'i'
[17:26:20.770] 
[17:26:20.770] getGlobalsAndPackages() ... DONE
[17:26:20.770] getGlobalsAndPackages() ...
[17:26:20.771] Searching for globals...
[17:26:20.772] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.773] Searching for globals ... DONE
[17:26:20.773] Resolving globals: FALSE
[17:26:20.806] The total size of the 2 globals is 716.45 KiB (733640 bytes)
[17:26:20.807] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 716.45 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (716.39 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.807] - globals: [2] 'x', 'i'
[17:26:20.807] 
[17:26:20.808] getGlobalsAndPackages() ... DONE
[17:26:20.808] getGlobalsAndPackages() ...
[17:26:20.808] Searching for globals...
[17:26:20.810] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.810] Searching for globals ... DONE
[17:26:20.811] Resolving globals: FALSE
[17:26:20.844] The total size of the 2 globals is 724.68 KiB (742072 bytes)
[17:26:20.844] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 724.68 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (724.62 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.844] - globals: [2] 'x', 'i'
[17:26:20.845] 
[17:26:20.845] getGlobalsAndPackages() ... DONE
[17:26:20.845] getGlobalsAndPackages() ...
[17:26:20.846] Searching for globals...
[17:26:20.848] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.848] Searching for globals ... DONE
[17:26:20.848] Resolving globals: FALSE
[17:26:20.882] The total size of the 2 globals is 732.91 KiB (750504 bytes)
[17:26:20.883] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 732.91 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (732.86 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.883] - globals: [2] 'x', 'i'
[17:26:20.883] 
[17:26:20.883] getGlobalsAndPackages() ... DONE
[17:26:20.884] getGlobalsAndPackages() ...
[17:26:20.884] Searching for globals...
[17:26:20.886] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.886] Searching for globals ... DONE
[17:26:20.886] Resolving globals: FALSE
[17:26:20.921] The total size of the 2 globals is 741.15 KiB (758936 bytes)
[17:26:20.922] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 741.15 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (741.09 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.922] - globals: [2] 'x', 'i'
[17:26:20.922] 
[17:26:20.922] getGlobalsAndPackages() ... DONE
[17:26:20.923] getGlobalsAndPackages() ...
[17:26:20.923] Searching for globals...
[17:26:20.925] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.925] Searching for globals ... DONE
[17:26:20.925] Resolving globals: FALSE
[17:26:20.983] The total size of the 2 globals is 749.38 KiB (767368 bytes)
[17:26:20.984] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 749.38 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (749.33 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:20.984] - globals: [2] 'x', 'i'
[17:26:20.984] 
[17:26:20.984] getGlobalsAndPackages() ... DONE
[17:26:20.985] getGlobalsAndPackages() ...
[17:26:20.985] Searching for globals...
[17:26:20.987] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:20.987] Searching for globals ... DONE
[17:26:20.987] Resolving globals: FALSE
[17:26:21.027] The total size of the 2 globals is 757.62 KiB (775800 bytes)
[17:26:21.028] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 757.62 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (757.56 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:21.028] - globals: [2] 'x', 'i'
[17:26:21.028] 
[17:26:21.028] getGlobalsAndPackages() ... DONE
[17:26:21.029] getGlobalsAndPackages() ...
[17:26:21.029] Searching for globals...
[17:26:21.032] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:21.032] Searching for globals ... DONE
[17:26:21.032] Resolving globals: FALSE
[17:26:21.069] The total size of the 2 globals is 765.85 KiB (784232 bytes)
[17:26:21.070] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 765.85 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (765.80 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:21.070] - globals: [2] 'x', 'i'
[17:26:21.070] 
[17:26:21.070] getGlobalsAndPackages() ... DONE
[17:26:21.071] getGlobalsAndPackages() ...
[17:26:21.071] Searching for globals...
[17:26:21.073] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:21.073] Searching for globals ... DONE
[17:26:21.073] Resolving globals: FALSE
[17:26:21.109] The total size of the 2 globals is 774.09 KiB (792664 bytes)
[17:26:21.110] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 774.09 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (774.03 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:21.110] - globals: [2] 'x', 'i'
[17:26:21.110] 
[17:26:21.110] getGlobalsAndPackages() ... DONE
[17:26:21.111] getGlobalsAndPackages() ...
[17:26:21.111] Searching for globals...
[17:26:21.113] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:21.113] Searching for globals ... DONE
[17:26:21.113] Resolving globals: FALSE
[17:26:21.150] The total size of the 2 globals is 782.32 KiB (801096 bytes)
[17:26:21.150] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 782.32 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (782.27 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:21.150] - globals: [2] 'x', 'i'
[17:26:21.151] 
[17:26:21.151] getGlobalsAndPackages() ... DONE
[17:26:21.151] getGlobalsAndPackages() ...
[17:26:21.152] Searching for globals...
[17:26:21.154] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:21.154] Searching for globals ... DONE
[17:26:21.154] Resolving globals: FALSE
[17:26:21.192] The total size of the 2 globals is 790.55 KiB (809528 bytes)
[17:26:21.192] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 790.55 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (790.50 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:21.193] - globals: [2] 'x', 'i'
[17:26:21.193] 
[17:26:21.193] getGlobalsAndPackages() ... DONE
[17:26:21.194] getGlobalsAndPackages() ...
[17:26:21.194] Searching for globals...
[17:26:21.196] - globals found: [6] '{', '+', '[[', 'x', '-', 'i'
[17:26:21.196] Searching for globals ... DONE
[17:26:21.196] Resolving globals: FALSE
[17:26:21.232] The total size of the 2 globals is 798.79 KiB (817960 bytes)
[17:26:21.233] The total size of the 2 globals exported for future expression ('{; x[[i - 2]] + x[[i - 1]]; }') is 798.79 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'x' (798.73 KiB of class 'environment') and 'i' (56 bytes of class 'numeric')
[17:26:21.233] - globals: [2] 'x', 'i'
[17:26:21.233] 
[17:26:21.233] getGlobalsAndPackages() ... DONE

> ## At this point nothing has been calculated,
> ## because lazy evaluation is in place.
> 
> ## Get the 7:th Fibonnaci numbers (should be 8)
> print(x[[7]])
[17:26:21.235] run() for 'Future' ...
[17:26:21.235] - state: 'created'
[17:26:21.235] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:21.236] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:21.236] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:21.236]   - Field: 'label'
[17:26:21.236]   - Field: 'local'
[17:26:21.236]   - Field: 'owner'
[17:26:21.237]   - Field: 'envir'
[17:26:21.238]   - Field: 'packages'
[17:26:21.238]   - Field: 'gc'
[17:26:21.238]   - Field: 'conditions'
[17:26:21.238]   - Field: 'expr'
[17:26:21.238]   - Field: 'uuid'
[17:26:21.239]   - Field: 'seed'
[17:26:21.239]   - Field: 'version'
[17:26:21.239]   - Field: 'result'
[17:26:21.239]   - Field: 'asynchronous'
[17:26:21.239]   - Field: 'calls'
[17:26:21.239]   - Field: 'globals'
[17:26:21.240]   - Field: 'stdout'
[17:26:21.240]   - Field: 'earlySignal'
[17:26:21.240]   - Field: 'lazy'
[17:26:21.240]   - Field: 'state'
[17:26:21.240] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:21.240] - Launch lazy future ...
[17:26:21.241] Packages needed by the future expression (n = 0): <none>
[17:26:21.241] Packages needed by future strategies (n = 0): <none>
[17:26:21.242] {
[17:26:21.242]     {
[17:26:21.242]         {
[17:26:21.242]             ...future.startTime <- base::Sys.time()
[17:26:21.242]             {
[17:26:21.242]                 {
[17:26:21.242]                   {
[17:26:21.242]                     base::local({
[17:26:21.242]                       has_future <- base::requireNamespace("future", 
[17:26:21.242]                         quietly = TRUE)
[17:26:21.242]                       if (has_future) {
[17:26:21.242]                         ns <- base::getNamespace("future")
[17:26:21.242]                         version <- ns[[".package"]][["version"]]
[17:26:21.242]                         if (is.null(version)) 
[17:26:21.242]                           version <- utils::packageVersion("future")
[17:26:21.242]                       }
[17:26:21.242]                       else {
[17:26:21.242]                         version <- NULL
[17:26:21.242]                       }
[17:26:21.242]                       if (!has_future || version < "1.8.0") {
[17:26:21.242]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:21.242]                           "", base::R.version$version.string), 
[17:26:21.242]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:21.242]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:21.242]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:21.242]                             "release", "version")], collapse = " "), 
[17:26:21.242]                           hostname = base::Sys.info()[["nodename"]])
[17:26:21.242]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:21.242]                           info)
[17:26:21.242]                         info <- base::paste(info, collapse = "; ")
[17:26:21.242]                         if (!has_future) {
[17:26:21.242]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:21.242]                             info)
[17:26:21.242]                         }
[17:26:21.242]                         else {
[17:26:21.242]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:21.242]                             info, version)
[17:26:21.242]                         }
[17:26:21.242]                         base::stop(msg)
[17:26:21.242]                       }
[17:26:21.242]                     })
[17:26:21.242]                   }
[17:26:21.242]                   ...future.strategy.old <- future::plan("list")
[17:26:21.242]                   options(future.plan = NULL)
[17:26:21.242]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:21.242]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:21.242]                 }
[17:26:21.242]                 ...future.workdir <- getwd()
[17:26:21.242]             }
[17:26:21.242]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:21.242]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:21.242]         }
[17:26:21.242]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:21.242]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:21.242]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:21.242]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:21.242]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:21.242]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:21.242]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:21.242]             base::names(...future.oldOptions))
[17:26:21.242]     }
[17:26:21.242]     if (TRUE) {
[17:26:21.242]     }
[17:26:21.242]     else {
[17:26:21.242]         if (NA) {
[17:26:21.242]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:21.242]                 open = "w")
[17:26:21.242]         }
[17:26:21.242]         else {
[17:26:21.242]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:21.242]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:21.242]         }
[17:26:21.242]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:21.242]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:21.242]             base::sink(type = "output", split = FALSE)
[17:26:21.242]             base::close(...future.stdout)
[17:26:21.242]         }, add = TRUE)
[17:26:21.242]     }
[17:26:21.242]     ...future.frame <- base::sys.nframe()
[17:26:21.242]     ...future.conditions <- base::list()
[17:26:21.242]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:21.242]     if (FALSE) {
[17:26:21.242]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:21.242]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:21.242]     }
[17:26:21.242]     ...future.result <- base::tryCatch({
[17:26:21.242]         base::withCallingHandlers({
[17:26:21.242]             ...future.value <- base::withVisible(base::local({
[17:26:21.242]                 x[[i - 2]] + x[[i - 1]]
[17:26:21.242]             }))
[17:26:21.242]             future::FutureResult(value = ...future.value$value, 
[17:26:21.242]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:21.242]                   ...future.rng), globalenv = if (FALSE) 
[17:26:21.242]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:21.242]                     ...future.globalenv.names))
[17:26:21.242]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:21.242]         }, condition = base::local({
[17:26:21.242]             c <- base::c
[17:26:21.242]             inherits <- base::inherits
[17:26:21.242]             invokeRestart <- base::invokeRestart
[17:26:21.242]             length <- base::length
[17:26:21.242]             list <- base::list
[17:26:21.242]             seq.int <- base::seq.int
[17:26:21.242]             signalCondition <- base::signalCondition
[17:26:21.242]             sys.calls <- base::sys.calls
[17:26:21.242]             `[[` <- base::`[[`
[17:26:21.242]             `+` <- base::`+`
[17:26:21.242]             `<<-` <- base::`<<-`
[17:26:21.242]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:21.242]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:21.242]                   3L)]
[17:26:21.242]             }
[17:26:21.242]             function(cond) {
[17:26:21.242]                 is_error <- inherits(cond, "error")
[17:26:21.242]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:21.242]                   NULL)
[17:26:21.242]                 if (is_error) {
[17:26:21.242]                   sessionInformation <- function() {
[17:26:21.242]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:21.242]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:21.242]                       search = base::search(), system = base::Sys.info())
[17:26:21.242]                   }
[17:26:21.242]                   ...future.conditions[[length(...future.conditions) + 
[17:26:21.242]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:21.242]                     cond$call), session = sessionInformation(), 
[17:26:21.242]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:21.242]                   signalCondition(cond)
[17:26:21.242]                 }
[17:26:21.242]                 else if (!ignore && TRUE && inherits(cond, c("error", 
[17:26:21.242]                 "immediateCondition"))) {
[17:26:21.242]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:21.242]                   ...future.conditions[[length(...future.conditions) + 
[17:26:21.242]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:21.242]                   if (TRUE && !signal) {
[17:26:21.242]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:21.242]                     {
[17:26:21.242]                       inherits <- base::inherits
[17:26:21.242]                       invokeRestart <- base::invokeRestart
[17:26:21.242]                       is.null <- base::is.null
[17:26:21.242]                       muffled <- FALSE
[17:26:21.242]                       if (inherits(cond, "message")) {
[17:26:21.242]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:21.242]                         if (muffled) 
[17:26:21.242]                           invokeRestart("muffleMessage")
[17:26:21.242]                       }
[17:26:21.242]                       else if (inherits(cond, "warning")) {
[17:26:21.242]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:21.242]                         if (muffled) 
[17:26:21.242]                           invokeRestart("muffleWarning")
[17:26:21.242]                       }
[17:26:21.242]                       else if (inherits(cond, "condition")) {
[17:26:21.242]                         if (!is.null(pattern)) {
[17:26:21.242]                           computeRestarts <- base::computeRestarts
[17:26:21.242]                           grepl <- base::grepl
[17:26:21.242]                           restarts <- computeRestarts(cond)
[17:26:21.242]                           for (restart in restarts) {
[17:26:21.242]                             name <- restart$name
[17:26:21.242]                             if (is.null(name)) 
[17:26:21.242]                               next
[17:26:21.242]                             if (!grepl(pattern, name)) 
[17:26:21.242]                               next
[17:26:21.242]                             invokeRestart(restart)
[17:26:21.242]                             muffled <- TRUE
[17:26:21.242]                             break
[17:26:21.242]                           }
[17:26:21.242]                         }
[17:26:21.242]                       }
[17:26:21.242]                       invisible(muffled)
[17:26:21.242]                     }
[17:26:21.242]                     muffleCondition(cond, pattern = "^muffle")
[17:26:21.242]                   }
[17:26:21.242]                 }
[17:26:21.242]                 else {
[17:26:21.242]                   if (TRUE) {
[17:26:21.242]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:21.242]                     {
[17:26:21.242]                       inherits <- base::inherits
[17:26:21.242]                       invokeRestart <- base::invokeRestart
[17:26:21.242]                       is.null <- base::is.null
[17:26:21.242]                       muffled <- FALSE
[17:26:21.242]                       if (inherits(cond, "message")) {
[17:26:21.242]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:21.242]                         if (muffled) 
[17:26:21.242]                           invokeRestart("muffleMessage")
[17:26:21.242]                       }
[17:26:21.242]                       else if (inherits(cond, "warning")) {
[17:26:21.242]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:21.242]                         if (muffled) 
[17:26:21.242]                           invokeRestart("muffleWarning")
[17:26:21.242]                       }
[17:26:21.242]                       else if (inherits(cond, "condition")) {
[17:26:21.242]                         if (!is.null(pattern)) {
[17:26:21.242]                           computeRestarts <- base::computeRestarts
[17:26:21.242]                           grepl <- base::grepl
[17:26:21.242]                           restarts <- computeRestarts(cond)
[17:26:21.242]                           for (restart in restarts) {
[17:26:21.242]                             name <- restart$name
[17:26:21.242]                             if (is.null(name)) 
[17:26:21.242]                               next
[17:26:21.242]                             if (!grepl(pattern, name)) 
[17:26:21.242]                               next
[17:26:21.242]                             invokeRestart(restart)
[17:26:21.242]                             muffled <- TRUE
[17:26:21.242]                             break
[17:26:21.242]                           }
[17:26:21.242]                         }
[17:26:21.242]                       }
[17:26:21.242]                       invisible(muffled)
[17:26:21.242]                     }
[17:26:21.242]                     muffleCondition(cond, pattern = "^muffle")
[17:26:21.242]                   }
[17:26:21.242]                 }
[17:26:21.242]             }
[17:26:21.242]         }))
[17:26:21.242]     }, error = function(ex) {
[17:26:21.242]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:21.242]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:21.242]                 ...future.rng), started = ...future.startTime, 
[17:26:21.242]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:21.242]             version = "1.8"), class = "FutureResult")
[17:26:21.242]     }, finally = {
[17:26:21.242]         if (!identical(...future.workdir, getwd())) 
[17:26:21.242]             setwd(...future.workdir)
[17:26:21.242]         {
[17:26:21.242]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:21.242]                 ...future.oldOptions$nwarnings <- NULL
[17:26:21.242]             }
[17:26:21.242]             base::options(...future.oldOptions)
[17:26:21.242]             if (.Platform$OS.type == "windows") {
[17:26:21.242]                 old_names <- names(...future.oldEnvVars)
[17:26:21.242]                 envs <- base::Sys.getenv()
[17:26:21.242]                 names <- names(envs)
[17:26:21.242]                 common <- intersect(names, old_names)
[17:26:21.242]                 added <- setdiff(names, old_names)
[17:26:21.242]                 removed <- setdiff(old_names, names)
[17:26:21.242]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:21.242]                   envs[common]]
[17:26:21.242]                 NAMES <- toupper(changed)
[17:26:21.242]                 args <- list()
[17:26:21.242]                 for (kk in seq_along(NAMES)) {
[17:26:21.242]                   name <- changed[[kk]]
[17:26:21.242]                   NAME <- NAMES[[kk]]
[17:26:21.242]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:21.242]                     next
[17:26:21.242]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:21.242]                 }
[17:26:21.242]                 NAMES <- toupper(added)
[17:26:21.242]                 for (kk in seq_along(NAMES)) {
[17:26:21.242]                   name <- added[[kk]]
[17:26:21.242]                   NAME <- NAMES[[kk]]
[17:26:21.242]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:21.242]                     next
[17:26:21.242]                   args[[name]] <- ""
[17:26:21.242]                 }
[17:26:21.242]                 NAMES <- toupper(removed)
[17:26:21.242]                 for (kk in seq_along(NAMES)) {
[17:26:21.242]                   name <- removed[[kk]]
[17:26:21.242]                   NAME <- NAMES[[kk]]
[17:26:21.242]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:21.242]                     next
[17:26:21.242]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:21.242]                 }
[17:26:21.242]                 if (length(args) > 0) 
[17:26:21.242]                   base::do.call(base::Sys.setenv, args = args)
[17:26:21.242]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:21.242]             }
[17:26:21.242]             else {
[17:26:21.242]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:21.242]             }
[17:26:21.242]             {
[17:26:21.242]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:21.242]                   0L) {
[17:26:21.242]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:21.242]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:21.242]                   base::options(opts)
[17:26:21.242]                 }
[17:26:21.242]                 {
[17:26:21.242]                   {
[17:26:21.242]                     NULL
[17:26:21.242]                     RNGkind("Mersenne-Twister")
[17:26:21.242]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:21.242]                       inherits = FALSE)
[17:26:21.242]                   }
[17:26:21.242]                   options(future.plan = NULL)
[17:26:21.242]                   if (is.na(NA_character_)) 
[17:26:21.242]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:21.242]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:21.242]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:21.242]                     .init = FALSE)
[17:26:21.242]                 }
[17:26:21.242]             }
[17:26:21.242]         }
[17:26:21.242]     })
[17:26:21.242]     if (FALSE) {
[17:26:21.242]         base::sink(type = "output", split = FALSE)
[17:26:21.242]         if (NA) {
[17:26:21.242]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:21.242]         }
[17:26:21.242]         else {
[17:26:21.242]             ...future.result["stdout"] <- base::list(NULL)
[17:26:21.242]         }
[17:26:21.242]         base::close(...future.stdout)
[17:26:21.242]         ...future.stdout <- NULL
[17:26:21.242]     }
[17:26:21.242]     ...future.result$conditions <- ...future.conditions
[17:26:21.242]     ...future.result$finished <- base::Sys.time()
[17:26:21.242]     ...future.result
[17:26:21.242] }
[17:26:21.246] assign_globals() ...
[17:26:21.247] List of 2
[17:26:21.247]  $ x:Classes 'listenv', 'environment' <environment: 0x0000018351abfd88> 
[17:26:21.247]  $ i: int 7
[17:26:21.247]  - attr(*, "where")=List of 2
[17:26:21.247]   ..$ x:<environment: R_EmptyEnv> 
[17:26:21.247]   ..$ i:<environment: R_EmptyEnv> 
[17:26:21.247]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:26:21.247]  - attr(*, "resolved")= logi FALSE
[17:26:21.247]  - attr(*, "total_size")= num 33784
[17:26:21.247]  - attr(*, "already-done")= logi TRUE
[17:26:21.252] - copied 'x' to environment
[17:26:21.252] - copied 'i' to environment
[17:26:21.253] assign_globals() ... done
[17:26:21.253] plan(): Setting new future strategy stack:
[17:26:21.253] List of future strategies:
[17:26:21.253] 1. sequential:
[17:26:21.253]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:21.253]    - tweaked: FALSE
[17:26:21.253]    - call: NULL
[17:26:21.254] plan(): nbrOfWorkers() = 1
[17:26:21.363] plan(): Setting new future strategy stack:
[17:26:21.363] List of future strategies:
[17:26:21.363] 1. sequential:
[17:26:21.363]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:21.363]    - tweaked: FALSE
[17:26:21.363]    - call: plan(sequential)
[17:26:21.363] plan(): nbrOfWorkers() = 1
[17:26:21.364] SequentialFuture started (and completed)
[17:26:21.364] - Launch lazy future ... done
[17:26:21.364] run() for 'SequentialFuture' ... done
[1] 8

> ## At this point x[1:7] have been calculated,
> ## but nothing beyond.
> 
> ## Let's get the 50:th number.
> print(x[[50]])
[17:26:21.365] run() for 'Future' ...
[17:26:21.365] - state: 'created'
[17:26:21.365] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:21.365] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:21.366] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:21.366]   - Field: 'label'
[17:26:21.366]   - Field: 'local'
[17:26:21.366]   - Field: 'owner'
[17:26:21.366]   - Field: 'envir'
[17:26:21.366]   - Field: 'packages'
[17:26:21.367]   - Field: 'gc'
[17:26:21.367]   - Field: 'conditions'
[17:26:21.367]   - Field: 'expr'
[17:26:21.367]   - Field: 'uuid'
[17:26:21.367]   - Field: 'seed'
[17:26:21.368]   - Field: 'version'
[17:26:21.368]   - Field: 'result'
[17:26:21.368]   - Field: 'asynchronous'
[17:26:21.368]   - Field: 'calls'
[17:26:21.368]   - Field: 'globals'
[17:26:21.368]   - Field: 'stdout'
[17:26:21.369]   - Field: 'earlySignal'
[17:26:21.369]   - Field: 'lazy'
[17:26:21.369]   - Field: 'state'
[17:26:21.369] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:21.369] - Launch lazy future ...
[17:26:21.370] Packages needed by the future expression (n = 0): <none>
[17:26:21.370] Packages needed by future strategies (n = 0): <none>
[17:26:21.370] {
[17:26:21.370]     {
[17:26:21.370]         {
[17:26:21.370]             ...future.startTime <- base::Sys.time()
[17:26:21.370]             {
[17:26:21.370]                 {
[17:26:21.370]                   {
[17:26:21.370]                     base::local({
[17:26:21.370]                       has_future <- base::requireNamespace("future", 
[17:26:21.370]                         quietly = TRUE)
[17:26:21.370]                       if (has_future) {
[17:26:21.370]                         ns <- base::getNamespace("future")
[17:26:21.370]                         version <- ns[[".package"]][["version"]]
[17:26:21.370]                         if (is.null(version)) 
[17:26:21.370]                           version <- utils::packageVersion("future")
[17:26:21.370]                       }
[17:26:21.370]                       else {
[17:26:21.370]                         version <- NULL
[17:26:21.370]                       }
[17:26:21.370]                       if (!has_future || version < "1.8.0") {
[17:26:21.370]                         info <- base::c(r_version = base::gsub("R version ", 
[17:26:21.370]                           "", base::R.version$version.string), 
[17:26:21.370]                           platform = base::sprintf("%s (%s-bit)", 
[17:26:21.370]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:21.370]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:21.370]                             "release", "version")], collapse = " "), 
[17:26:21.370]                           hostname = base::Sys.info()[["nodename"]])
[17:26:21.370]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:26:21.370]                           info)
[17:26:21.370]                         info <- base::paste(info, collapse = "; ")
[17:26:21.370]                         if (!has_future) {
[17:26:21.370]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:21.370]                             info)
[17:26:21.370]                         }
[17:26:21.370]                         else {
[17:26:21.370]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:21.370]                             info, version)
[17:26:21.370]                         }
[17:26:21.370]                         base::stop(msg)
[17:26:21.370]                       }
[17:26:21.370]                     })
[17:26:21.370]                   }
[17:26:21.370]                   ...future.strategy.old <- future::plan("list")
[17:26:21.370]                   options(future.plan = NULL)
[17:26:21.370]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:21.370]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:21.370]                 }
[17:26:21.370]                 ...future.workdir <- getwd()
[17:26:21.370]             }
[17:26:21.370]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:21.370]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:21.370]         }
[17:26:21.370]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:21.370]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:21.370]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:21.370]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:21.370]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:21.370]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:21.370]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:21.370]             base::names(...future.oldOptions))
[17:26:21.370]     }
[17:26:21.370]     if (TRUE) {
[17:26:21.370]     }
[17:26:21.370]     else {
[17:26:21.370]         if (NA) {
[17:26:21.370]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:21.370]                 open = "w")
[17:26:21.370]         }
[17:26:21.370]         else {
[17:26:21.370]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:21.370]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:21.370]         }
[17:26:21.370]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:21.370]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:21.370]             base::sink(type = "output", split = FALSE)
[17:26:21.370]             base::close(...future.stdout)
[17:26:21.370]         }, add = TRUE)
[17:26:21.370]     }
[17:26:21.370]     ...future.frame <- base::sys.nframe()
[17:26:21.370]     ...future.conditions <- base::list()
[17:26:21.370]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:21.370]     if (FALSE) {
[17:26:21.370]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:21.370]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:21.370]     }
[17:26:21.370]     ...future.result <- base::tryCatch({
[17:26:21.370]         base::withCallingHandlers({
[17:26:21.370]             ...future.value <- base::withVisible(base::local({
[17:26:21.370]                 x[[i - 2]] + x[[i - 1]]
[17:26:21.370]             }))
[17:26:21.370]             future::FutureResult(value = ...future.value$value, 
[17:26:21.370]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:21.370]                   ...future.rng), globalenv = if (FALSE) 
[17:26:21.370]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:21.370]                     ...future.globalenv.names))
[17:26:21.370]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:21.370]         }, condition = base::local({
[17:26:21.370]             c <- base::c
[17:26:21.370]             inherits <- base::inherits
[17:26:21.370]             invokeRestart <- base::invokeRestart
[17:26:21.370]             length <- base::length
[17:26:21.370]             list <- base::list
[17:26:21.370]             seq.int <- base::seq.int
[17:26:21.370]             signalCondition <- base::signalCondition
[17:26:21.370]             sys.calls <- base::sys.calls
[17:26:21.370]             `[[` <- base::`[[`
[17:26:21.370]             `+` <- base::`+`
[17:26:21.370]             `<<-` <- base::`<<-`
[17:26:21.370]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:21.370]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:21.370]                   3L)]
[17:26:21.370]             }
[17:26:21.370]             function(cond) {
[17:26:21.370]                 is_error <- inherits(cond, "error")
[17:26:21.370]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:21.370]                   NULL)
[17:26:21.370]                 if (is_error) {
[17:26:21.370]                   sessionInformation <- function() {
[17:26:21.370]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:21.370]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:21.370]                       search = base::search(), system = base::Sys.info())
[17:26:21.370]                   }
[17:26:21.370]                   ...future.conditions[[length(...future.conditions) + 
[17:26:21.370]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:21.370]                     cond$call), session = sessionInformation(), 
[17:26:21.370]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:21.370]                   signalCondition(cond)
[17:26:21.370]                 }
[17:26:21.370]                 else if (!ignore && TRUE && inherits(cond, c("error", 
[17:26:21.370]                 "immediateCondition"))) {
[17:26:21.370]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:21.370]                   ...future.conditions[[length(...future.conditions) + 
[17:26:21.370]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:21.370]                   if (TRUE && !signal) {
[17:26:21.370]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:21.370]                     {
[17:26:21.370]                       inherits <- base::inherits
[17:26:21.370]                       invokeRestart <- base::invokeRestart
[17:26:21.370]                       is.null <- base::is.null
[17:26:21.370]                       muffled <- FALSE
[17:26:21.370]                       if (inherits(cond, "message")) {
[17:26:21.370]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:21.370]                         if (muffled) 
[17:26:21.370]                           invokeRestart("muffleMessage")
[17:26:21.370]                       }
[17:26:21.370]                       else if (inherits(cond, "warning")) {
[17:26:21.370]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:21.370]                         if (muffled) 
[17:26:21.370]                           invokeRestart("muffleWarning")
[17:26:21.370]                       }
[17:26:21.370]                       else if (inherits(cond, "condition")) {
[17:26:21.370]                         if (!is.null(pattern)) {
[17:26:21.370]                           computeRestarts <- base::computeRestarts
[17:26:21.370]                           grepl <- base::grepl
[17:26:21.370]                           restarts <- computeRestarts(cond)
[17:26:21.370]                           for (restart in restarts) {
[17:26:21.370]                             name <- restart$name
[17:26:21.370]                             if (is.null(name)) 
[17:26:21.370]                               next
[17:26:21.370]                             if (!grepl(pattern, name)) 
[17:26:21.370]                               next
[17:26:21.370]                             invokeRestart(restart)
[17:26:21.370]                             muffled <- TRUE
[17:26:21.370]                             break
[17:26:21.370]                           }
[17:26:21.370]                         }
[17:26:21.370]                       }
[17:26:21.370]                       invisible(muffled)
[17:26:21.370]                     }
[17:26:21.370]                     muffleCondition(cond, pattern = "^muffle")
[17:26:21.370]                   }
[17:26:21.370]                 }
[17:26:21.370]                 else {
[17:26:21.370]                   if (TRUE) {
[17:26:21.370]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:21.370]                     {
[17:26:21.370]                       inherits <- base::inherits
[17:26:21.370]                       invokeRestart <- base::invokeRestart
[17:26:21.370]                       is.null <- base::is.null
[17:26:21.370]                       muffled <- FALSE
[17:26:21.370]                       if (inherits(cond, "message")) {
[17:26:21.370]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:21.370]                         if (muffled) 
[17:26:21.370]                           invokeRestart("muffleMessage")
[17:26:21.370]                       }
[17:26:21.370]                       else if (inherits(cond, "warning")) {
[17:26:21.370]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:21.370]                         if (muffled) 
[17:26:21.370]                           invokeRestart("muffleWarning")
[17:26:21.370]                       }
[17:26:21.370]                       else if (inherits(cond, "condition")) {
[17:26:21.370]                         if (!is.null(pattern)) {
[17:26:21.370]                           computeRestarts <- base::computeRestarts
[17:26:21.370]                           grepl <- base::grepl
[17:26:21.370]                           restarts <- computeRestarts(cond)
[17:26:21.370]                           for (restart in restarts) {
[17:26:21.370]                             name <- restart$name
[17:26:21.370]                             if (is.null(name)) 
[17:26:21.370]                               next
[17:26:21.370]                             if (!grepl(pattern, name)) 
[17:26:21.370]                               next
[17:26:21.370]                             invokeRestart(restart)
[17:26:21.370]                             muffled <- TRUE
[17:26:21.370]                             break
[17:26:21.370]                           }
[17:26:21.370]                         }
[17:26:21.370]                       }
[17:26:21.370]                       invisible(muffled)
[17:26:21.370]                     }
[17:26:21.370]                     muffleCondition(cond, pattern = "^muffle")
[17:26:21.370]                   }
[17:26:21.370]                 }
[17:26:21.370]             }
[17:26:21.370]         }))
[17:26:21.370]     }, error = function(ex) {
[17:26:21.370]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:21.370]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:21.370]                 ...future.rng), started = ...future.startTime, 
[17:26:21.370]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:21.370]             version = "1.8"), class = "FutureResult")
[17:26:21.370]     }, finally = {
[17:26:21.370]         if (!identical(...future.workdir, getwd())) 
[17:26:21.370]             setwd(...future.workdir)
[17:26:21.370]         {
[17:26:21.370]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:21.370]                 ...future.oldOptions$nwarnings <- NULL
[17:26:21.370]             }
[17:26:21.370]             base::options(...future.oldOptions)
[17:26:21.370]             if (.Platform$OS.type == "windows") {
[17:26:21.370]                 old_names <- names(...future.oldEnvVars)
[17:26:21.370]                 envs <- base::Sys.getenv()
[17:26:21.370]                 names <- names(envs)
[17:26:21.370]                 common <- intersect(names, old_names)
[17:26:21.370]                 added <- setdiff(names, old_names)
[17:26:21.370]                 removed <- setdiff(old_names, names)
[17:26:21.370]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:21.370]                   envs[common]]
[17:26:21.370]                 NAMES <- toupper(changed)
[17:26:21.370]                 args <- list()
[17:26:21.370]                 for (kk in seq_along(NAMES)) {
[17:26:21.370]                   name <- changed[[kk]]
[17:26:21.370]                   NAME <- NAMES[[kk]]
[17:26:21.370]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:21.370]                     next
[17:26:21.370]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:21.370]                 }
[17:26:21.370]                 NAMES <- toupper(added)
[17:26:21.370]                 for (kk in seq_along(NAMES)) {
[17:26:21.370]                   name <- added[[kk]]
[17:26:21.370]                   NAME <- NAMES[[kk]]
[17:26:21.370]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:21.370]                     next
[17:26:21.370]                   args[[name]] <- ""
[17:26:21.370]                 }
[17:26:21.370]                 NAMES <- toupper(removed)
[17:26:21.370]                 for (kk in seq_along(NAMES)) {
[17:26:21.370]                   name <- removed[[kk]]
[17:26:21.370]                   NAME <- NAMES[[kk]]
[17:26:21.370]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:21.370]                     next
[17:26:21.370]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:21.370]                 }
[17:26:21.370]                 if (length(args) > 0) 
[17:26:21.370]                   base::do.call(base::Sys.setenv, args = args)
[17:26:21.370]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:21.370]             }
[17:26:21.370]             else {
[17:26:21.370]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:21.370]             }
[17:26:21.370]             {
[17:26:21.370]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:21.370]                   0L) {
[17:26:21.370]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:21.370]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:21.370]                   base::options(opts)
[17:26:21.370]                 }
[17:26:21.370]                 {
[17:26:21.370]                   {
[17:26:21.370]                     NULL
[17:26:21.370]                     RNGkind("Mersenne-Twister")
[17:26:21.370]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:21.370]                       inherits = FALSE)
[17:26:21.370]                   }
[17:26:21.370]                   options(future.plan = NULL)
[17:26:21.370]                   if (is.na(NA_character_)) 
[17:26:21.370]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:21.370]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:21.370]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:21.370]                     .init = FALSE)
[17:26:21.370]                 }
[17:26:21.370]             }
[17:26:21.370]         }
[17:26:21.370]     })
[17:26:21.370]     if (FALSE) {
[17:26:21.370]         base::sink(type = "output", split = FALSE)
[17:26:21.370]         if (NA) {
[17:26:21.370]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:21.370]         }
[17:26:21.370]         else {
[17:26:21.370]             ...future.result["stdout"] <- base::list(NULL)
[17:26:21.370]         }
[17:26:21.370]         base::close(...future.stdout)
[17:26:21.370]         ...future.stdout <- NULL
[17:26:21.370]     }
[17:26:21.370]     ...future.result$conditions <- ...future.conditions
[17:26:21.370]     ...future.result$finished <- base::Sys.time()
[17:26:21.370]     ...future.result
[17:26:21.370] }
[17:26:21.374] assign_globals() ...
[17:26:21.374] List of 2
[17:26:21.374]  $ x:Classes 'listenv', 'environment' <environment: 0x0000018351abfd88> 
[17:26:21.374]  $ i: int 50
[17:26:21.374]  - attr(*, "where")=List of 2
[17:26:21.374]   ..$ x:<environment: R_EmptyEnv> 
[17:26:21.374]   ..$ i:<environment: R_EmptyEnv> 
[17:26:21.374]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:26:21.374]  - attr(*, "resolved")= logi FALSE
[17:26:21.374]  - attr(*, "total_size")= num 396360
[17:26:21.374]  - attr(*, "already-done")= logi TRUE
[17:26:21.378] - copied 'x' to environment
[17:26:21.378] - copied 'i' to environment
[17:26:21.378] assign_globals() ... done
[17:26:21.378] plan(): Setting new future strategy stack:
[17:26:21.379] List of future strategies:
[17:26:21.379] 1. sequential:
[17:26:21.379]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:21.379]    - tweaked: FALSE
[17:26:21.379]    - call: NULL
[17:26:21.379] plan(): nbrOfWorkers() = 1
[17:26:22.552] plan(): Setting new future strategy stack:
[17:26:22.552] List of future strategies:
[17:26:22.552] 1. sequential:
[17:26:22.552]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:22.552]    - tweaked: FALSE
[17:26:22.552]    - call: plan(sequential)
[17:26:22.553] plan(): nbrOfWorkers() = 1
[17:26:22.553] SequentialFuture started (and completed)
[17:26:22.553] - Launch lazy future ... done
[17:26:22.553] run() for 'SequentialFuture' ... done
[1] 7778742049

> ## Reset plan
> plan(oplan)
[17:26:22.554] plan(): Setting new future strategy stack:
[17:26:22.554] List of future strategies:
[17:26:22.554] 1. sequential:
[17:26:22.554]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:22.554]    - tweaked: FALSE
[17:26:22.554]    - call: future::plan("sequential")
[17:26:22.555] plan(): nbrOfWorkers() = 1
> message("*** Fibonacci demo of the 'future' package ... DONE")
*** Fibonacci demo of the 'future' package ... DONE
> 
> 
> message("*** Mandelbrot demo of the 'future' package ...")
*** Mandelbrot demo of the 'future' package ...
> if (getRversion() >= "3.2.0" && !isWin32) {
+   options(future.demo.mandelbrot.nrow = 2L)
+   options(future.demo.mandelbrot.resolution = 50L)
+   options(future.demo.mandelbrot.delay = FALSE)
+   
+   for (cores in 1:availCores) {
+     message(sprintf("Testing with %d cores ...", cores))
+     options(mc.cores = cores)
+   
+     for (strategy in supportedStrategies(cores)) {
+       message(sprintf("- plan('%s') ...", strategy))
+       plan(strategy)
+       demo("mandelbrot", package = "future", ask = FALSE)
+       message(sprintf("- plan('%s') ... DONE", strategy))
+     }
+   
+     message(sprintf("Testing with %d cores ... DONE", cores))
+   } ## for (cores ...)
+ } else {
+   message(" - This demo requires R (>= 3.2.0). Skipping test. (Skipping also on Win32 i386 for speed)")
+ }
Testing with 1 cores ...
- plan('sequential') ...
[17:26:22.562] plan(): Setting new future strategy stack:
[17:26:22.562] List of future strategies:
[17:26:22.562] 1. sequential:
[17:26:22.562]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:22.562]    - tweaked: FALSE
[17:26:22.562]    - call: plan(strategy)
[17:26:22.563] plan(): nbrOfWorkers() = 1


	demo(mandelbrot)
	---- ~~~~~~~~~~

> library("future")

> library("graphics")

> plot_what_is_done <- function(counts) {
+   for (kk in seq_along(counts)) {
+     f <- counts[[kk]]
+ 
+     ## Already plotted?
+     if (!inherits(f, "Future")) next
+ 
+     ## Not resolved?
+     if (!resolved(f)) next
+ 
+     message(sprintf("Plotting tile #%d of %d ...", kk, n))
+     counts[[kk]] <- value(f)
+     screen(kk)
+     plot(counts[[kk]])
+   }
+ 
+   counts
+ }

> ## Options
> region <- getOption("future.demo.mandelbrot.region", 1L)

> if (!is.list(region)) {
+   if (region == 1L) {
+     region <- list(xmid = -0.75, ymid = 0.0, side = 3.0)
+   } else if (region == 2L) {
+     region <- list(xmid = 0.283, ymid = -0.0095, side = 0.00026)
+   } else if (region == 3L) {
+     region <- list(xmid = 0.282989, ymid = -0.01, side = 3e-8)
+   }
+ }

> nrow <- getOption("future.demo.mandelbrot.nrow", 3L)

> resolution <- getOption("future.demo.mandelbrot.resolution", 400L)

> delay <- getOption("future.demo.mandelbrot.delay", interactive())

> if (isTRUE(delay)) {
+   delay <- function(counts) Sys.sleep(1.0)
+ } else if (!is.function(delay)) {
+   delay <- function(counts) {}
+ }

> ## Generate Mandelbrot tiles to be computed
> Cs <- mandelbrot_tiles(xmid = region$xmid, ymid = region$ymid,
+                        side = region$side, nrow = nrow,
+                        resolution = resolution)

> if (interactive()) {
+   dev.new()
+   plot.new()
+   split.screen(dim(Cs))
+   for (ii in seq_along(Cs)) {
+     screen(ii)
+     par(mar = c(0, 0, 0, 0))
+     text(x = 1 / 2, y = 1 / 2, sprintf("Future #%d\nunresolved", ii), cex = 2)
+   }
+ } else {
+   split.screen(dim(Cs))
+ }
[1] 1 2 3 4

> ## Create all Mandelbrot tiles via lazy futures
> n <- length(Cs)

> message(sprintf("Creating %d Mandelbrot tiles:", n), appendLF = FALSE)
Creating 4 Mandelbrot tiles:
> counts <- lapply(seq_along(Cs), FUN=function(ii) {
+   message(" ", ii, appendLF = FALSE)
+   C <- Cs[[ii]]
+   future({
+     message(sprintf("Calculating tile #%d of %d ...", ii, n), appendLF = FALSE)
+     fit <- mandelbrot(C)
+ 
+     ## Emulate slowness
+     delay(fit)
+ 
+     message(" done")
+     fit
+   }, lazy = TRUE)
+ })
 1[17:26:22.607] getGlobalsAndPackages() ...
[17:26:22.607] Searching for globals...
[17:26:22.611] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
[17:26:22.611] Searching for globals ... DONE
[17:26:22.612] Resolving globals: FALSE
[17:26:22.612] The total size of the 4 globals is 14.24 KiB (14584 bytes)
[17:26:22.613] The total size of the 4 globals exported for future expression ('{; message(sprintf("Calculating tile #%d of %d ...", ii, n),; appendLF = FALSE); fit <- mandelbrot(C); delay(fit); message(" done"); fit; }') is 14.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'C' (10.72 KiB of class 'complex'), 'delay' (3.41 KiB of class 'function') and 'ii' (56 bytes of class 'numeric')
[17:26:22.613] - globals: [4] 'ii', 'n', 'C', 'delay'
[17:26:22.613] - packages: [1] 'future'
[17:26:22.613] getGlobalsAndPackages() ... DONE
 2[17:26:22.617] getGlobalsAndPackages() ...
[17:26:22.617] Searching for globals...
[17:26:22.621] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
[17:26:22.621] Searching for globals ... DONE
[17:26:22.621] Resolving globals: FALSE
[17:26:22.622] The total size of the 4 globals is 14.24 KiB (14584 bytes)
[17:26:22.622] The total size of the 4 globals exported for future expression ('{; message(sprintf("Calculating tile #%d of %d ...", ii, n),; appendLF = FALSE); fit <- mandelbrot(C); delay(fit); message(" done"); fit; }') is 14.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'C' (10.72 KiB of class 'complex'), 'delay' (3.41 KiB of class 'function') and 'ii' (56 bytes of class 'numeric')
[17:26:22.623] - globals: [4] 'ii', 'n', 'C', 'delay'
[17:26:22.623] - packages: [1] 'future'
[17:26:22.623] getGlobalsAndPackages() ... DONE
 3[17:26:22.623] getGlobalsAndPackages() ...
[17:26:22.623] Searching for globals...
[17:26:22.627] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
[17:26:22.627] Searching for globals ... DONE
[17:26:22.627] Resolving globals: FALSE
[17:26:22.628] The total size of the 4 globals is 14.24 KiB (14584 bytes)
[17:26:22.629] The total size of the 4 globals exported for future expression ('{; message(sprintf("Calculating tile #%d of %d ...", ii, n),; appendLF = FALSE); fit <- mandelbrot(C); delay(fit); message(" done"); fit; }') is 14.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'C' (10.72 KiB of class 'complex'), 'delay' (3.41 KiB of class 'function') and 'ii' (56 bytes of class 'numeric')
[17:26:22.629] - globals: [4] 'ii', 'n', 'C', 'delay'
[17:26:22.629] - packages: [1] 'future'
[17:26:22.629] getGlobalsAndPackages() ... DONE
 4[17:26:22.632] getGlobalsAndPackages() ...
[17:26:22.632] Searching for globals...
[17:26:22.635] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
[17:26:22.635] Searching for globals ... DONE
[17:26:22.636] Resolving globals: FALSE
[17:26:22.636] The total size of the 4 globals is 14.24 KiB (14584 bytes)
[17:26:22.637] The total size of the 4 globals exported for future expression ('{; message(sprintf("Calculating tile #%d of %d ...", ii, n),; appendLF = FALSE); fit <- mandelbrot(C); delay(fit); message(" done"); fit; }') is 14.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'C' (10.72 KiB of class 'complex'), 'delay' (3.41 KiB of class 'function') and 'ii' (56 bytes of class 'numeric')
[17:26:22.637] - globals: [4] 'ii', 'n', 'C', 'delay'
[17:26:22.637] - packages: [1] 'future'
[17:26:22.637] getGlobalsAndPackages() ... DONE

> message(".")
.

> ## Calculate and plot tiles
> repeat {
+   counts <- plot_what_is_done(counts)
+   if (!any(sapply(counts, FUN = inherits, "Future"))) break
+ }
[17:26:22.646] resolved() for 'Future' ...
[17:26:22.646] - state: 'created'
[17:26:22.646] - run: TRUE
[17:26:22.646] - run() ...
[17:26:22.647] run() for 'Future' ...
[17:26:22.647] - state: 'created'
[17:26:22.647] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:22.647] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:22.647] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:22.648]   - Field: 'label'
[17:26:22.648]   - Field: 'local'
[17:26:22.648]   - Field: 'owner'
[17:26:22.648]   - Field: 'envir'
[17:26:22.648]   - Field: 'packages'
[17:26:22.648]   - Field: 'gc'
[17:26:22.648]   - Field: 'conditions'
[17:26:22.649]   - Field: 'expr'
[17:26:22.649]   - Field: 'uuid'
[17:26:22.649]   - Field: 'seed'
[17:26:22.649]   - Field: 'version'
[17:26:22.649]   - Field: 'result'
[17:26:22.649]   - Field: 'asynchronous'
[17:26:22.649]   - Field: 'calls'
[17:26:22.650]   - Field: 'globals'
[17:26:22.650]   - Field: 'stdout'
[17:26:22.650]   - Field: 'earlySignal'
[17:26:22.650]   - Field: 'lazy'
[17:26:22.650]   - Field: 'state'
[17:26:22.650] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:22.650] - Launch lazy future ...
[17:26:22.651] Packages needed by the future expression (n = 1): 'future'
[17:26:22.651] Packages needed by future strategies (n = 0): <none>
[17:26:22.651] {
[17:26:22.651]     {
[17:26:22.651]         {
[17:26:22.651]             ...future.startTime <- base::Sys.time()
[17:26:22.651]             {
[17:26:22.651]                 {
[17:26:22.651]                   {
[17:26:22.651]                     {
[17:26:22.651]                       base::local({
[17:26:22.651]                         has_future <- base::requireNamespace("future", 
[17:26:22.651]                           quietly = TRUE)
[17:26:22.651]                         if (has_future) {
[17:26:22.651]                           ns <- base::getNamespace("future")
[17:26:22.651]                           version <- ns[[".package"]][["version"]]
[17:26:22.651]                           if (is.null(version)) 
[17:26:22.651]                             version <- utils::packageVersion("future")
[17:26:22.651]                         }
[17:26:22.651]                         else {
[17:26:22.651]                           version <- NULL
[17:26:22.651]                         }
[17:26:22.651]                         if (!has_future || version < "1.8.0") {
[17:26:22.651]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:22.651]                             "", base::R.version$version.string), 
[17:26:22.651]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:22.651]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:22.651]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:22.651]                               "release", "version")], collapse = " "), 
[17:26:22.651]                             hostname = base::Sys.info()[["nodename"]])
[17:26:22.651]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:22.651]                             info)
[17:26:22.651]                           info <- base::paste(info, collapse = "; ")
[17:26:22.651]                           if (!has_future) {
[17:26:22.651]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:22.651]                               info)
[17:26:22.651]                           }
[17:26:22.651]                           else {
[17:26:22.651]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:22.651]                               info, version)
[17:26:22.651]                           }
[17:26:22.651]                           base::stop(msg)
[17:26:22.651]                         }
[17:26:22.651]                       })
[17:26:22.651]                     }
[17:26:22.651]                     base::local({
[17:26:22.651]                       for (pkg in "future") {
[17:26:22.651]                         base::loadNamespace(pkg)
[17:26:22.651]                         base::library(pkg, character.only = TRUE)
[17:26:22.651]                       }
[17:26:22.651]                     })
[17:26:22.651]                   }
[17:26:22.651]                   ...future.strategy.old <- future::plan("list")
[17:26:22.651]                   options(future.plan = NULL)
[17:26:22.651]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:22.651]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:22.651]                 }
[17:26:22.651]                 ...future.workdir <- getwd()
[17:26:22.651]             }
[17:26:22.651]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:22.651]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:22.651]         }
[17:26:22.651]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:22.651]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:22.651]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:22.651]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:22.651]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:22.651]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:22.651]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:22.651]             base::names(...future.oldOptions))
[17:26:22.651]     }
[17:26:22.651]     if (FALSE) {
[17:26:22.651]     }
[17:26:22.651]     else {
[17:26:22.651]         if (TRUE) {
[17:26:22.651]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:22.651]                 open = "w")
[17:26:22.651]         }
[17:26:22.651]         else {
[17:26:22.651]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:22.651]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:22.651]         }
[17:26:22.651]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:22.651]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:22.651]             base::sink(type = "output", split = FALSE)
[17:26:22.651]             base::close(...future.stdout)
[17:26:22.651]         }, add = TRUE)
[17:26:22.651]     }
[17:26:22.651]     ...future.frame <- base::sys.nframe()
[17:26:22.651]     ...future.conditions <- base::list()
[17:26:22.651]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:22.651]     if (FALSE) {
[17:26:22.651]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:22.651]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:22.651]     }
[17:26:22.651]     ...future.result <- base::tryCatch({
[17:26:22.651]         base::withCallingHandlers({
[17:26:22.651]             ...future.value <- base::withVisible(base::local({
[17:26:22.651]                 message(sprintf("Calculating tile #%d of %d ...", 
[17:26:22.651]                   ii, n), appendLF = FALSE)
[17:26:22.651]                 fit <- mandelbrot(C)
[17:26:22.651]                 delay(fit)
[17:26:22.651]                 message(" done")
[17:26:22.651]                 fit
[17:26:22.651]             }))
[17:26:22.651]             future::FutureResult(value = ...future.value$value, 
[17:26:22.651]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:22.651]                   ...future.rng), globalenv = if (FALSE) 
[17:26:22.651]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:22.651]                     ...future.globalenv.names))
[17:26:22.651]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:22.651]         }, condition = base::local({
[17:26:22.651]             c <- base::c
[17:26:22.651]             inherits <- base::inherits
[17:26:22.651]             invokeRestart <- base::invokeRestart
[17:26:22.651]             length <- base::length
[17:26:22.651]             list <- base::list
[17:26:22.651]             seq.int <- base::seq.int
[17:26:22.651]             signalCondition <- base::signalCondition
[17:26:22.651]             sys.calls <- base::sys.calls
[17:26:22.651]             `[[` <- base::`[[`
[17:26:22.651]             `+` <- base::`+`
[17:26:22.651]             `<<-` <- base::`<<-`
[17:26:22.651]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:22.651]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:22.651]                   3L)]
[17:26:22.651]             }
[17:26:22.651]             function(cond) {
[17:26:22.651]                 is_error <- inherits(cond, "error")
[17:26:22.651]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:22.651]                   NULL)
[17:26:22.651]                 if (is_error) {
[17:26:22.651]                   sessionInformation <- function() {
[17:26:22.651]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:22.651]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:22.651]                       search = base::search(), system = base::Sys.info())
[17:26:22.651]                   }
[17:26:22.651]                   ...future.conditions[[length(...future.conditions) + 
[17:26:22.651]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:22.651]                     cond$call), session = sessionInformation(), 
[17:26:22.651]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:22.651]                   signalCondition(cond)
[17:26:22.651]                 }
[17:26:22.651]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:22.651]                 "immediateCondition"))) {
[17:26:22.651]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:22.651]                   ...future.conditions[[length(...future.conditions) + 
[17:26:22.651]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:22.651]                   if (TRUE && !signal) {
[17:26:22.651]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:22.651]                     {
[17:26:22.651]                       inherits <- base::inherits
[17:26:22.651]                       invokeRestart <- base::invokeRestart
[17:26:22.651]                       is.null <- base::is.null
[17:26:22.651]                       muffled <- FALSE
[17:26:22.651]                       if (inherits(cond, "message")) {
[17:26:22.651]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:22.651]                         if (muffled) 
[17:26:22.651]                           invokeRestart("muffleMessage")
[17:26:22.651]                       }
[17:26:22.651]                       else if (inherits(cond, "warning")) {
[17:26:22.651]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:22.651]                         if (muffled) 
[17:26:22.651]                           invokeRestart("muffleWarning")
[17:26:22.651]                       }
[17:26:22.651]                       else if (inherits(cond, "condition")) {
[17:26:22.651]                         if (!is.null(pattern)) {
[17:26:22.651]                           computeRestarts <- base::computeRestarts
[17:26:22.651]                           grepl <- base::grepl
[17:26:22.651]                           restarts <- computeRestarts(cond)
[17:26:22.651]                           for (restart in restarts) {
[17:26:22.651]                             name <- restart$name
[17:26:22.651]                             if (is.null(name)) 
[17:26:22.651]                               next
[17:26:22.651]                             if (!grepl(pattern, name)) 
[17:26:22.651]                               next
[17:26:22.651]                             invokeRestart(restart)
[17:26:22.651]                             muffled <- TRUE
[17:26:22.651]                             break
[17:26:22.651]                           }
[17:26:22.651]                         }
[17:26:22.651]                       }
[17:26:22.651]                       invisible(muffled)
[17:26:22.651]                     }
[17:26:22.651]                     muffleCondition(cond, pattern = "^muffle")
[17:26:22.651]                   }
[17:26:22.651]                 }
[17:26:22.651]                 else {
[17:26:22.651]                   if (TRUE) {
[17:26:22.651]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:22.651]                     {
[17:26:22.651]                       inherits <- base::inherits
[17:26:22.651]                       invokeRestart <- base::invokeRestart
[17:26:22.651]                       is.null <- base::is.null
[17:26:22.651]                       muffled <- FALSE
[17:26:22.651]                       if (inherits(cond, "message")) {
[17:26:22.651]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:22.651]                         if (muffled) 
[17:26:22.651]                           invokeRestart("muffleMessage")
[17:26:22.651]                       }
[17:26:22.651]                       else if (inherits(cond, "warning")) {
[17:26:22.651]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:22.651]                         if (muffled) 
[17:26:22.651]                           invokeRestart("muffleWarning")
[17:26:22.651]                       }
[17:26:22.651]                       else if (inherits(cond, "condition")) {
[17:26:22.651]                         if (!is.null(pattern)) {
[17:26:22.651]                           computeRestarts <- base::computeRestarts
[17:26:22.651]                           grepl <- base::grepl
[17:26:22.651]                           restarts <- computeRestarts(cond)
[17:26:22.651]                           for (restart in restarts) {
[17:26:22.651]                             name <- restart$name
[17:26:22.651]                             if (is.null(name)) 
[17:26:22.651]                               next
[17:26:22.651]                             if (!grepl(pattern, name)) 
[17:26:22.651]                               next
[17:26:22.651]                             invokeRestart(restart)
[17:26:22.651]                             muffled <- TRUE
[17:26:22.651]                             break
[17:26:22.651]                           }
[17:26:22.651]                         }
[17:26:22.651]                       }
[17:26:22.651]                       invisible(muffled)
[17:26:22.651]                     }
[17:26:22.651]                     muffleCondition(cond, pattern = "^muffle")
[17:26:22.651]                   }
[17:26:22.651]                 }
[17:26:22.651]             }
[17:26:22.651]         }))
[17:26:22.651]     }, error = function(ex) {
[17:26:22.651]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:22.651]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:22.651]                 ...future.rng), started = ...future.startTime, 
[17:26:22.651]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:22.651]             version = "1.8"), class = "FutureResult")
[17:26:22.651]     }, finally = {
[17:26:22.651]         if (!identical(...future.workdir, getwd())) 
[17:26:22.651]             setwd(...future.workdir)
[17:26:22.651]         {
[17:26:22.651]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:22.651]                 ...future.oldOptions$nwarnings <- NULL
[17:26:22.651]             }
[17:26:22.651]             base::options(...future.oldOptions)
[17:26:22.651]             if (.Platform$OS.type == "windows") {
[17:26:22.651]                 old_names <- names(...future.oldEnvVars)
[17:26:22.651]                 envs <- base::Sys.getenv()
[17:26:22.651]                 names <- names(envs)
[17:26:22.651]                 common <- intersect(names, old_names)
[17:26:22.651]                 added <- setdiff(names, old_names)
[17:26:22.651]                 removed <- setdiff(old_names, names)
[17:26:22.651]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:22.651]                   envs[common]]
[17:26:22.651]                 NAMES <- toupper(changed)
[17:26:22.651]                 args <- list()
[17:26:22.651]                 for (kk in seq_along(NAMES)) {
[17:26:22.651]                   name <- changed[[kk]]
[17:26:22.651]                   NAME <- NAMES[[kk]]
[17:26:22.651]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:22.651]                     next
[17:26:22.651]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:22.651]                 }
[17:26:22.651]                 NAMES <- toupper(added)
[17:26:22.651]                 for (kk in seq_along(NAMES)) {
[17:26:22.651]                   name <- added[[kk]]
[17:26:22.651]                   NAME <- NAMES[[kk]]
[17:26:22.651]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:22.651]                     next
[17:26:22.651]                   args[[name]] <- ""
[17:26:22.651]                 }
[17:26:22.651]                 NAMES <- toupper(removed)
[17:26:22.651]                 for (kk in seq_along(NAMES)) {
[17:26:22.651]                   name <- removed[[kk]]
[17:26:22.651]                   NAME <- NAMES[[kk]]
[17:26:22.651]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:22.651]                     next
[17:26:22.651]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:22.651]                 }
[17:26:22.651]                 if (length(args) > 0) 
[17:26:22.651]                   base::do.call(base::Sys.setenv, args = args)
[17:26:22.651]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:22.651]             }
[17:26:22.651]             else {
[17:26:22.651]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:22.651]             }
[17:26:22.651]             {
[17:26:22.651]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:22.651]                   0L) {
[17:26:22.651]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:22.651]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:22.651]                   base::options(opts)
[17:26:22.651]                 }
[17:26:22.651]                 {
[17:26:22.651]                   {
[17:26:22.651]                     NULL
[17:26:22.651]                     RNGkind("Mersenne-Twister")
[17:26:22.651]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:22.651]                       inherits = FALSE)
[17:26:22.651]                   }
[17:26:22.651]                   options(future.plan = NULL)
[17:26:22.651]                   if (is.na(NA_character_)) 
[17:26:22.651]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:22.651]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:22.651]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:22.651]                     .init = FALSE)
[17:26:22.651]                 }
[17:26:22.651]             }
[17:26:22.651]         }
[17:26:22.651]     })
[17:26:22.651]     if (TRUE) {
[17:26:22.651]         base::sink(type = "output", split = FALSE)
[17:26:22.651]         if (TRUE) {
[17:26:22.651]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:22.651]         }
[17:26:22.651]         else {
[17:26:22.651]             ...future.result["stdout"] <- base::list(NULL)
[17:26:22.651]         }
[17:26:22.651]         base::close(...future.stdout)
[17:26:22.651]         ...future.stdout <- NULL
[17:26:22.651]     }
[17:26:22.651]     ...future.result$conditions <- ...future.conditions
[17:26:22.651]     ...future.result$finished <- base::Sys.time()
[17:26:22.651]     ...future.result
[17:26:22.651] }
[17:26:22.655] assign_globals() ...
[17:26:22.655] List of 4
[17:26:22.655]  $ ii   : int 1
[17:26:22.655]  $ n    : int 4
[17:26:22.655]  $ C    : cplx [1:25, 1:25] -2.25-1.5i -2.25-1.44i -2.25-1.38i ...
[17:26:22.655]   ..- attr(*, "region")=List of 2
[17:26:22.655]   .. ..$ xrange: num [1:2] -2.25 -0.781
[17:26:22.655]   .. ..$ yrange: num [1:2] -1.5 -0.0306
[17:26:22.655]   ..- attr(*, "tile")= int [1:2] 1 1
[17:26:22.655]  $ delay:function (counts)  
[17:26:22.655]   ..- attr(*, "srcref")= 'srcref' int [1:8] 41 12 41 30 12 30 41 41
[17:26:22.655]   .. ..- attr(*, "srcfile")=Classes 'srcfilecopy', 'srcfile' <environment: 0x0000018354c2d900> 
[17:26:22.655]  - attr(*, "where")=List of 4
[17:26:22.655]   ..$ ii   :<environment: R_EmptyEnv> 
[17:26:22.655]   ..$ n    :<environment: R_EmptyEnv> 
[17:26:22.655]   ..$ C    :<environment: R_EmptyEnv> 
[17:26:22.655]   ..$ delay:<environment: R_EmptyEnv> 
[17:26:22.655]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:26:22.655]  - attr(*, "resolved")= logi FALSE
[17:26:22.655]  - attr(*, "total_size")= num 14584
[17:26:22.655]  - attr(*, "already-done")= logi TRUE
[17:26:22.661] - copied 'ii' to environment
[17:26:22.661] - copied 'n' to environment
[17:26:22.661] - copied 'C' to environment
[17:26:22.661] - reassign environment for 'delay'
[17:26:22.661] - copied 'delay' to environment
[17:26:22.662] assign_globals() ... done
[17:26:22.662] plan(): Setting new future strategy stack:
[17:26:22.662] List of future strategies:
[17:26:22.662] 1. sequential:
[17:26:22.662]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:22.662]    - tweaked: FALSE
[17:26:22.662]    - call: NULL
[17:26:22.663] plan(): nbrOfWorkers() = 1
[17:26:22.677] plan(): Setting new future strategy stack:
[17:26:22.677] List of future strategies:
[17:26:22.677] 1. sequential:
[17:26:22.677]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:22.677]    - tweaked: FALSE
[17:26:22.677]    - call: plan(strategy)
[17:26:22.678] plan(): nbrOfWorkers() = 1
[17:26:22.678] SequentialFuture started (and completed)
[17:26:22.678] signalConditions() ...
[17:26:22.678]  - include = 'immediateCondition'
[17:26:22.678]  - exclude = 
[17:26:22.678]  - resignal = FALSE
[17:26:22.679]  - Number of conditions: 2
[17:26:22.679] signalConditions() ... done
[17:26:22.679] - Launch lazy future ... done
[17:26:22.679] run() for 'SequentialFuture' ... done
[17:26:22.679] - run() ... done
[17:26:22.679] - resolved() ...
[17:26:22.679] resolved() for 'SequentialFuture' ...
[17:26:22.680] - state: 'finished'
[17:26:22.680] - run: TRUE
[17:26:22.680] - result: 'FutureResult'
[17:26:22.680] resolved() for 'SequentialFuture' ... done
[17:26:22.680] - resolved: TRUE
[17:26:22.680] - resolved() ... done
[17:26:22.681] resolved() for 'SequentialFuture' ... done
Plotting tile #1 of 4 ...
[17:26:22.681] signalConditions() ...
[17:26:22.681]  - include = 'immediateCondition'
[17:26:22.681]  - exclude = 
[17:26:22.681]  - resignal = FALSE
[17:26:22.681]  - Number of conditions: 2
[17:26:22.682] signalConditions() ... done
[17:26:22.682] Future state: 'finished'
[17:26:22.682] signalConditions() ...
[17:26:22.682]  - include = 'condition'
[17:26:22.682]  - exclude = 'immediateCondition'
[17:26:22.682]  - resignal = TRUE
[17:26:22.682]  - Number of conditions: 2
[17:26:22.682]  - Condition #1: 'simpleMessage', 'message', 'condition'
Calculating tile #1 of 4 ...[17:26:22.683]  - Condition #2: 'simpleMessage', 'message', 'condition'
 done
[17:26:22.683] signalConditions() ... done
[17:26:22.684] resolved() for 'Future' ...
[17:26:22.684] - state: 'created'
[17:26:22.685] - run: TRUE
[17:26:22.685] - run() ...
[17:26:22.685] run() for 'Future' ...
[17:26:22.685] - state: 'created'
[17:26:22.685] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:22.685] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:22.686] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:22.686]   - Field: 'label'
[17:26:22.686]   - Field: 'local'
[17:26:22.686]   - Field: 'owner'
[17:26:22.686]   - Field: 'envir'
[17:26:22.686]   - Field: 'packages'
[17:26:22.686]   - Field: 'gc'
[17:26:22.687]   - Field: 'conditions'
[17:26:22.687]   - Field: 'expr'
[17:26:22.687]   - Field: 'uuid'
[17:26:22.687]   - Field: 'seed'
[17:26:22.687]   - Field: 'version'
[17:26:22.687]   - Field: 'result'
[17:26:22.687]   - Field: 'asynchronous'
[17:26:22.688]   - Field: 'calls'
[17:26:22.688]   - Field: 'globals'
[17:26:22.688]   - Field: 'stdout'
[17:26:22.688]   - Field: 'earlySignal'
[17:26:22.688]   - Field: 'lazy'
[17:26:22.688]   - Field: 'state'
[17:26:22.688] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:22.689] - Launch lazy future ...
[17:26:22.689] Packages needed by the future expression (n = 1): 'future'
[17:26:22.689] Packages needed by future strategies (n = 0): <none>
[17:26:22.696] {
[17:26:22.696]     {
[17:26:22.696]         {
[17:26:22.696]             ...future.startTime <- base::Sys.time()
[17:26:22.696]             {
[17:26:22.696]                 {
[17:26:22.696]                   {
[17:26:22.696]                     {
[17:26:22.696]                       base::local({
[17:26:22.696]                         has_future <- base::requireNamespace("future", 
[17:26:22.696]                           quietly = TRUE)
[17:26:22.696]                         if (has_future) {
[17:26:22.696]                           ns <- base::getNamespace("future")
[17:26:22.696]                           version <- ns[[".package"]][["version"]]
[17:26:22.696]                           if (is.null(version)) 
[17:26:22.696]                             version <- utils::packageVersion("future")
[17:26:22.696]                         }
[17:26:22.696]                         else {
[17:26:22.696]                           version <- NULL
[17:26:22.696]                         }
[17:26:22.696]                         if (!has_future || version < "1.8.0") {
[17:26:22.696]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:22.696]                             "", base::R.version$version.string), 
[17:26:22.696]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:22.696]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:22.696]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:22.696]                               "release", "version")], collapse = " "), 
[17:26:22.696]                             hostname = base::Sys.info()[["nodename"]])
[17:26:22.696]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:22.696]                             info)
[17:26:22.696]                           info <- base::paste(info, collapse = "; ")
[17:26:22.696]                           if (!has_future) {
[17:26:22.696]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:22.696]                               info)
[17:26:22.696]                           }
[17:26:22.696]                           else {
[17:26:22.696]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:22.696]                               info, version)
[17:26:22.696]                           }
[17:26:22.696]                           base::stop(msg)
[17:26:22.696]                         }
[17:26:22.696]                       })
[17:26:22.696]                     }
[17:26:22.696]                     base::local({
[17:26:22.696]                       for (pkg in "future") {
[17:26:22.696]                         base::loadNamespace(pkg)
[17:26:22.696]                         base::library(pkg, character.only = TRUE)
[17:26:22.696]                       }
[17:26:22.696]                     })
[17:26:22.696]                   }
[17:26:22.696]                   ...future.strategy.old <- future::plan("list")
[17:26:22.696]                   options(future.plan = NULL)
[17:26:22.696]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:22.696]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:22.696]                 }
[17:26:22.696]                 ...future.workdir <- getwd()
[17:26:22.696]             }
[17:26:22.696]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:22.696]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:22.696]         }
[17:26:22.696]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:22.696]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:22.696]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:22.696]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:22.696]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:22.696]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:22.696]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:22.696]             base::names(...future.oldOptions))
[17:26:22.696]     }
[17:26:22.696]     if (FALSE) {
[17:26:22.696]     }
[17:26:22.696]     else {
[17:26:22.696]         if (TRUE) {
[17:26:22.696]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:22.696]                 open = "w")
[17:26:22.696]         }
[17:26:22.696]         else {
[17:26:22.696]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:22.696]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:22.696]         }
[17:26:22.696]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:22.696]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:22.696]             base::sink(type = "output", split = FALSE)
[17:26:22.696]             base::close(...future.stdout)
[17:26:22.696]         }, add = TRUE)
[17:26:22.696]     }
[17:26:22.696]     ...future.frame <- base::sys.nframe()
[17:26:22.696]     ...future.conditions <- base::list()
[17:26:22.696]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:22.696]     if (FALSE) {
[17:26:22.696]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:22.696]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:22.696]     }
[17:26:22.696]     ...future.result <- base::tryCatch({
[17:26:22.696]         base::withCallingHandlers({
[17:26:22.696]             ...future.value <- base::withVisible(base::local({
[17:26:22.696]                 message(sprintf("Calculating tile #%d of %d ...", 
[17:26:22.696]                   ii, n), appendLF = FALSE)
[17:26:22.696]                 fit <- mandelbrot(C)
[17:26:22.696]                 delay(fit)
[17:26:22.696]                 message(" done")
[17:26:22.696]                 fit
[17:26:22.696]             }))
[17:26:22.696]             future::FutureResult(value = ...future.value$value, 
[17:26:22.696]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:22.696]                   ...future.rng), globalenv = if (FALSE) 
[17:26:22.696]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:22.696]                     ...future.globalenv.names))
[17:26:22.696]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:22.696]         }, condition = base::local({
[17:26:22.696]             c <- base::c
[17:26:22.696]             inherits <- base::inherits
[17:26:22.696]             invokeRestart <- base::invokeRestart
[17:26:22.696]             length <- base::length
[17:26:22.696]             list <- base::list
[17:26:22.696]             seq.int <- base::seq.int
[17:26:22.696]             signalCondition <- base::signalCondition
[17:26:22.696]             sys.calls <- base::sys.calls
[17:26:22.696]             `[[` <- base::`[[`
[17:26:22.696]             `+` <- base::`+`
[17:26:22.696]             `<<-` <- base::`<<-`
[17:26:22.696]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:22.696]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:22.696]                   3L)]
[17:26:22.696]             }
[17:26:22.696]             function(cond) {
[17:26:22.696]                 is_error <- inherits(cond, "error")
[17:26:22.696]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:22.696]                   NULL)
[17:26:22.696]                 if (is_error) {
[17:26:22.696]                   sessionInformation <- function() {
[17:26:22.696]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:22.696]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:22.696]                       search = base::search(), system = base::Sys.info())
[17:26:22.696]                   }
[17:26:22.696]                   ...future.conditions[[length(...future.conditions) + 
[17:26:22.696]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:22.696]                     cond$call), session = sessionInformation(), 
[17:26:22.696]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:22.696]                   signalCondition(cond)
[17:26:22.696]                 }
[17:26:22.696]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:22.696]                 "immediateCondition"))) {
[17:26:22.696]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:22.696]                   ...future.conditions[[length(...future.conditions) + 
[17:26:22.696]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:22.696]                   if (TRUE && !signal) {
[17:26:22.696]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:22.696]                     {
[17:26:22.696]                       inherits <- base::inherits
[17:26:22.696]                       invokeRestart <- base::invokeRestart
[17:26:22.696]                       is.null <- base::is.null
[17:26:22.696]                       muffled <- FALSE
[17:26:22.696]                       if (inherits(cond, "message")) {
[17:26:22.696]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:22.696]                         if (muffled) 
[17:26:22.696]                           invokeRestart("muffleMessage")
[17:26:22.696]                       }
[17:26:22.696]                       else if (inherits(cond, "warning")) {
[17:26:22.696]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:22.696]                         if (muffled) 
[17:26:22.696]                           invokeRestart("muffleWarning")
[17:26:22.696]                       }
[17:26:22.696]                       else if (inherits(cond, "condition")) {
[17:26:22.696]                         if (!is.null(pattern)) {
[17:26:22.696]                           computeRestarts <- base::computeRestarts
[17:26:22.696]                           grepl <- base::grepl
[17:26:22.696]                           restarts <- computeRestarts(cond)
[17:26:22.696]                           for (restart in restarts) {
[17:26:22.696]                             name <- restart$name
[17:26:22.696]                             if (is.null(name)) 
[17:26:22.696]                               next
[17:26:22.696]                             if (!grepl(pattern, name)) 
[17:26:22.696]                               next
[17:26:22.696]                             invokeRestart(restart)
[17:26:22.696]                             muffled <- TRUE
[17:26:22.696]                             break
[17:26:22.696]                           }
[17:26:22.696]                         }
[17:26:22.696]                       }
[17:26:22.696]                       invisible(muffled)
[17:26:22.696]                     }
[17:26:22.696]                     muffleCondition(cond, pattern = "^muffle")
[17:26:22.696]                   }
[17:26:22.696]                 }
[17:26:22.696]                 else {
[17:26:22.696]                   if (TRUE) {
[17:26:22.696]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:22.696]                     {
[17:26:22.696]                       inherits <- base::inherits
[17:26:22.696]                       invokeRestart <- base::invokeRestart
[17:26:22.696]                       is.null <- base::is.null
[17:26:22.696]                       muffled <- FALSE
[17:26:22.696]                       if (inherits(cond, "message")) {
[17:26:22.696]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:22.696]                         if (muffled) 
[17:26:22.696]                           invokeRestart("muffleMessage")
[17:26:22.696]                       }
[17:26:22.696]                       else if (inherits(cond, "warning")) {
[17:26:22.696]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:22.696]                         if (muffled) 
[17:26:22.696]                           invokeRestart("muffleWarning")
[17:26:22.696]                       }
[17:26:22.696]                       else if (inherits(cond, "condition")) {
[17:26:22.696]                         if (!is.null(pattern)) {
[17:26:22.696]                           computeRestarts <- base::computeRestarts
[17:26:22.696]                           grepl <- base::grepl
[17:26:22.696]                           restarts <- computeRestarts(cond)
[17:26:22.696]                           for (restart in restarts) {
[17:26:22.696]                             name <- restart$name
[17:26:22.696]                             if (is.null(name)) 
[17:26:22.696]                               next
[17:26:22.696]                             if (!grepl(pattern, name)) 
[17:26:22.696]                               next
[17:26:22.696]                             invokeRestart(restart)
[17:26:22.696]                             muffled <- TRUE
[17:26:22.696]                             break
[17:26:22.696]                           }
[17:26:22.696]                         }
[17:26:22.696]                       }
[17:26:22.696]                       invisible(muffled)
[17:26:22.696]                     }
[17:26:22.696]                     muffleCondition(cond, pattern = "^muffle")
[17:26:22.696]                   }
[17:26:22.696]                 }
[17:26:22.696]             }
[17:26:22.696]         }))
[17:26:22.696]     }, error = function(ex) {
[17:26:22.696]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:22.696]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:22.696]                 ...future.rng), started = ...future.startTime, 
[17:26:22.696]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:22.696]             version = "1.8"), class = "FutureResult")
[17:26:22.696]     }, finally = {
[17:26:22.696]         if (!identical(...future.workdir, getwd())) 
[17:26:22.696]             setwd(...future.workdir)
[17:26:22.696]         {
[17:26:22.696]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:22.696]                 ...future.oldOptions$nwarnings <- NULL
[17:26:22.696]             }
[17:26:22.696]             base::options(...future.oldOptions)
[17:26:22.696]             if (.Platform$OS.type == "windows") {
[17:26:22.696]                 old_names <- names(...future.oldEnvVars)
[17:26:22.696]                 envs <- base::Sys.getenv()
[17:26:22.696]                 names <- names(envs)
[17:26:22.696]                 common <- intersect(names, old_names)
[17:26:22.696]                 added <- setdiff(names, old_names)
[17:26:22.696]                 removed <- setdiff(old_names, names)
[17:26:22.696]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:22.696]                   envs[common]]
[17:26:22.696]                 NAMES <- toupper(changed)
[17:26:22.696]                 args <- list()
[17:26:22.696]                 for (kk in seq_along(NAMES)) {
[17:26:22.696]                   name <- changed[[kk]]
[17:26:22.696]                   NAME <- NAMES[[kk]]
[17:26:22.696]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:22.696]                     next
[17:26:22.696]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:22.696]                 }
[17:26:22.696]                 NAMES <- toupper(added)
[17:26:22.696]                 for (kk in seq_along(NAMES)) {
[17:26:22.696]                   name <- added[[kk]]
[17:26:22.696]                   NAME <- NAMES[[kk]]
[17:26:22.696]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:22.696]                     next
[17:26:22.696]                   args[[name]] <- ""
[17:26:22.696]                 }
[17:26:22.696]                 NAMES <- toupper(removed)
[17:26:22.696]                 for (kk in seq_along(NAMES)) {
[17:26:22.696]                   name <- removed[[kk]]
[17:26:22.696]                   NAME <- NAMES[[kk]]
[17:26:22.696]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:22.696]                     next
[17:26:22.696]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:22.696]                 }
[17:26:22.696]                 if (length(args) > 0) 
[17:26:22.696]                   base::do.call(base::Sys.setenv, args = args)
[17:26:22.696]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:22.696]             }
[17:26:22.696]             else {
[17:26:22.696]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:22.696]             }
[17:26:22.696]             {
[17:26:22.696]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:22.696]                   0L) {
[17:26:22.696]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:22.696]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:22.696]                   base::options(opts)
[17:26:22.696]                 }
[17:26:22.696]                 {
[17:26:22.696]                   {
[17:26:22.696]                     NULL
[17:26:22.696]                     RNGkind("Mersenne-Twister")
[17:26:22.696]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:22.696]                       inherits = FALSE)
[17:26:22.696]                   }
[17:26:22.696]                   options(future.plan = NULL)
[17:26:22.696]                   if (is.na(NA_character_)) 
[17:26:22.696]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:22.696]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:22.696]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:22.696]                     .init = FALSE)
[17:26:22.696]                 }
[17:26:22.696]             }
[17:26:22.696]         }
[17:26:22.696]     })
[17:26:22.696]     if (TRUE) {
[17:26:22.696]         base::sink(type = "output", split = FALSE)
[17:26:22.696]         if (TRUE) {
[17:26:22.696]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:22.696]         }
[17:26:22.696]         else {
[17:26:22.696]             ...future.result["stdout"] <- base::list(NULL)
[17:26:22.696]         }
[17:26:22.696]         base::close(...future.stdout)
[17:26:22.696]         ...future.stdout <- NULL
[17:26:22.696]     }
[17:26:22.696]     ...future.result$conditions <- ...future.conditions
[17:26:22.696]     ...future.result$finished <- base::Sys.time()
[17:26:22.696]     ...future.result
[17:26:22.696] }
[17:26:22.699] assign_globals() ...
[17:26:22.699] List of 4
[17:26:22.699]  $ ii   : int 2
[17:26:22.699]  $ n    : int 4
[17:26:22.699]  $ C    : cplx [1:25, 1:25] -0.719-1.5i -0.719-1.44i -0.719-1.38i ...
[17:26:22.699]   ..- attr(*, "region")=List of 2
[17:26:22.699]   .. ..$ xrange: num [1:2] -0.719 0.75
[17:26:22.699]   .. ..$ yrange: num [1:2] -1.5 -0.0306
[17:26:22.699]   ..- attr(*, "tile")= int [1:2] 1 2
[17:26:22.699]  $ delay:function (counts)  
[17:26:22.699]   ..- attr(*, "srcref")= 'srcref' int [1:8] 41 12 41 30 12 30 41 41
[17:26:22.699]   .. ..- attr(*, "srcfile")=Classes 'srcfilecopy', 'srcfile' <environment: 0x0000018354c2d900> 
[17:26:22.699]  - attr(*, "where")=List of 4
[17:26:22.699]   ..$ ii   :<environment: R_EmptyEnv> 
[17:26:22.699]   ..$ n    :<environment: R_EmptyEnv> 
[17:26:22.699]   ..$ C    :<environment: R_EmptyEnv> 
[17:26:22.699]   ..$ delay:<environment: R_EmptyEnv> 
[17:26:22.699]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:26:22.699]  - attr(*, "resolved")= logi FALSE
[17:26:22.699]  - attr(*, "total_size")= num 14584
[17:26:22.699]  - attr(*, "already-done")= logi TRUE
[17:26:22.705] - copied 'ii' to environment
[17:26:22.705] - copied 'n' to environment
[17:26:22.705] - copied 'C' to environment
[17:26:22.705] - reassign environment for 'delay'
[17:26:22.705] - copied 'delay' to environment
[17:26:22.706] assign_globals() ... done
[17:26:22.706] plan(): Setting new future strategy stack:
[17:26:22.706] List of future strategies:
[17:26:22.706] 1. sequential:
[17:26:22.706]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:22.706]    - tweaked: FALSE
[17:26:22.706]    - call: NULL
[17:26:22.707] plan(): nbrOfWorkers() = 1
[17:26:22.721] plan(): Setting new future strategy stack:
[17:26:22.721] List of future strategies:
[17:26:22.721] 1. sequential:
[17:26:22.721]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:22.721]    - tweaked: FALSE
[17:26:22.721]    - call: plan(strategy)
[17:26:22.721] plan(): nbrOfWorkers() = 1
[17:26:22.722] SequentialFuture started (and completed)
[17:26:22.722] signalConditions() ...
[17:26:22.722]  - include = 'immediateCondition'
[17:26:22.722]  - exclude = 
[17:26:22.722]  - resignal = FALSE
[17:26:22.722]  - Number of conditions: 2
[17:26:22.722] signalConditions() ... done
[17:26:22.723] - Launch lazy future ... done
[17:26:22.723] run() for 'SequentialFuture' ... done
[17:26:22.723] - run() ... done
[17:26:22.723] - resolved() ...
[17:26:22.723] resolved() for 'SequentialFuture' ...
[17:26:22.723] - state: 'finished'
[17:26:22.723] - run: TRUE
[17:26:22.724] - result: 'FutureResult'
[17:26:22.724] resolved() for 'SequentialFuture' ... done
[17:26:22.724] - resolved: TRUE
[17:26:22.724] - resolved() ... done
[17:26:22.724] resolved() for 'SequentialFuture' ... done
Plotting tile #2 of 4 ...
[17:26:22.724] signalConditions() ...
[17:26:22.724]  - include = 'immediateCondition'
[17:26:22.725]  - exclude = 
[17:26:22.725]  - resignal = FALSE
[17:26:22.725]  - Number of conditions: 2
[17:26:22.725] signalConditions() ... done
[17:26:22.725] Future state: 'finished'
[17:26:22.725] signalConditions() ...
[17:26:22.725]  - include = 'condition'
[17:26:22.726]  - exclude = 'immediateCondition'
[17:26:22.726]  - resignal = TRUE
[17:26:22.726]  - Number of conditions: 2
[17:26:22.726]  - Condition #1: 'simpleMessage', 'message', 'condition'
Calculating tile #2 of 4 ...[17:26:22.726]  - Condition #2: 'simpleMessage', 'message', 'condition'
 done
[17:26:22.726] signalConditions() ... done
[17:26:22.727] resolved() for 'Future' ...
[17:26:22.727] - state: 'created'
[17:26:22.727] - run: TRUE
[17:26:22.727] - run() ...
[17:26:22.727] run() for 'Future' ...
[17:26:22.728] - state: 'created'
[17:26:22.728] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:22.728] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:22.728] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:22.728]   - Field: 'label'
[17:26:22.729]   - Field: 'local'
[17:26:22.729]   - Field: 'owner'
[17:26:22.729]   - Field: 'envir'
[17:26:22.729]   - Field: 'packages'
[17:26:22.729]   - Field: 'gc'
[17:26:22.729]   - Field: 'conditions'
[17:26:22.729]   - Field: 'expr'
[17:26:22.730]   - Field: 'uuid'
[17:26:22.730]   - Field: 'seed'
[17:26:22.730]   - Field: 'version'
[17:26:22.730]   - Field: 'result'
[17:26:22.730]   - Field: 'asynchronous'
[17:26:22.730]   - Field: 'calls'
[17:26:22.730]   - Field: 'globals'
[17:26:22.730]   - Field: 'stdout'
[17:26:22.731]   - Field: 'earlySignal'
[17:26:22.731]   - Field: 'lazy'
[17:26:22.731]   - Field: 'state'
[17:26:22.731] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:22.731] - Launch lazy future ...
[17:26:22.731] Packages needed by the future expression (n = 1): 'future'
[17:26:22.731] Packages needed by future strategies (n = 0): <none>
[17:26:22.732] {
[17:26:22.732]     {
[17:26:22.732]         {
[17:26:22.732]             ...future.startTime <- base::Sys.time()
[17:26:22.732]             {
[17:26:22.732]                 {
[17:26:22.732]                   {
[17:26:22.732]                     {
[17:26:22.732]                       base::local({
[17:26:22.732]                         has_future <- base::requireNamespace("future", 
[17:26:22.732]                           quietly = TRUE)
[17:26:22.732]                         if (has_future) {
[17:26:22.732]                           ns <- base::getNamespace("future")
[17:26:22.732]                           version <- ns[[".package"]][["version"]]
[17:26:22.732]                           if (is.null(version)) 
[17:26:22.732]                             version <- utils::packageVersion("future")
[17:26:22.732]                         }
[17:26:22.732]                         else {
[17:26:22.732]                           version <- NULL
[17:26:22.732]                         }
[17:26:22.732]                         if (!has_future || version < "1.8.0") {
[17:26:22.732]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:22.732]                             "", base::R.version$version.string), 
[17:26:22.732]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:22.732]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:22.732]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:22.732]                               "release", "version")], collapse = " "), 
[17:26:22.732]                             hostname = base::Sys.info()[["nodename"]])
[17:26:22.732]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:22.732]                             info)
[17:26:22.732]                           info <- base::paste(info, collapse = "; ")
[17:26:22.732]                           if (!has_future) {
[17:26:22.732]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:22.732]                               info)
[17:26:22.732]                           }
[17:26:22.732]                           else {
[17:26:22.732]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:22.732]                               info, version)
[17:26:22.732]                           }
[17:26:22.732]                           base::stop(msg)
[17:26:22.732]                         }
[17:26:22.732]                       })
[17:26:22.732]                     }
[17:26:22.732]                     base::local({
[17:26:22.732]                       for (pkg in "future") {
[17:26:22.732]                         base::loadNamespace(pkg)
[17:26:22.732]                         base::library(pkg, character.only = TRUE)
[17:26:22.732]                       }
[17:26:22.732]                     })
[17:26:22.732]                   }
[17:26:22.732]                   ...future.strategy.old <- future::plan("list")
[17:26:22.732]                   options(future.plan = NULL)
[17:26:22.732]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:22.732]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:22.732]                 }
[17:26:22.732]                 ...future.workdir <- getwd()
[17:26:22.732]             }
[17:26:22.732]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:22.732]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:22.732]         }
[17:26:22.732]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:22.732]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:22.732]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:22.732]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:22.732]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:22.732]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:22.732]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:22.732]             base::names(...future.oldOptions))
[17:26:22.732]     }
[17:26:22.732]     if (FALSE) {
[17:26:22.732]     }
[17:26:22.732]     else {
[17:26:22.732]         if (TRUE) {
[17:26:22.732]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:22.732]                 open = "w")
[17:26:22.732]         }
[17:26:22.732]         else {
[17:26:22.732]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:22.732]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:22.732]         }
[17:26:22.732]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:22.732]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:22.732]             base::sink(type = "output", split = FALSE)
[17:26:22.732]             base::close(...future.stdout)
[17:26:22.732]         }, add = TRUE)
[17:26:22.732]     }
[17:26:22.732]     ...future.frame <- base::sys.nframe()
[17:26:22.732]     ...future.conditions <- base::list()
[17:26:22.732]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:22.732]     if (FALSE) {
[17:26:22.732]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:22.732]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:22.732]     }
[17:26:22.732]     ...future.result <- base::tryCatch({
[17:26:22.732]         base::withCallingHandlers({
[17:26:22.732]             ...future.value <- base::withVisible(base::local({
[17:26:22.732]                 message(sprintf("Calculating tile #%d of %d ...", 
[17:26:22.732]                   ii, n), appendLF = FALSE)
[17:26:22.732]                 fit <- mandelbrot(C)
[17:26:22.732]                 delay(fit)
[17:26:22.732]                 message(" done")
[17:26:22.732]                 fit
[17:26:22.732]             }))
[17:26:22.732]             future::FutureResult(value = ...future.value$value, 
[17:26:22.732]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:22.732]                   ...future.rng), globalenv = if (FALSE) 
[17:26:22.732]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:22.732]                     ...future.globalenv.names))
[17:26:22.732]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:22.732]         }, condition = base::local({
[17:26:22.732]             c <- base::c
[17:26:22.732]             inherits <- base::inherits
[17:26:22.732]             invokeRestart <- base::invokeRestart
[17:26:22.732]             length <- base::length
[17:26:22.732]             list <- base::list
[17:26:22.732]             seq.int <- base::seq.int
[17:26:22.732]             signalCondition <- base::signalCondition
[17:26:22.732]             sys.calls <- base::sys.calls
[17:26:22.732]             `[[` <- base::`[[`
[17:26:22.732]             `+` <- base::`+`
[17:26:22.732]             `<<-` <- base::`<<-`
[17:26:22.732]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:22.732]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:22.732]                   3L)]
[17:26:22.732]             }
[17:26:22.732]             function(cond) {
[17:26:22.732]                 is_error <- inherits(cond, "error")
[17:26:22.732]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:22.732]                   NULL)
[17:26:22.732]                 if (is_error) {
[17:26:22.732]                   sessionInformation <- function() {
[17:26:22.732]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:22.732]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:22.732]                       search = base::search(), system = base::Sys.info())
[17:26:22.732]                   }
[17:26:22.732]                   ...future.conditions[[length(...future.conditions) + 
[17:26:22.732]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:22.732]                     cond$call), session = sessionInformation(), 
[17:26:22.732]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:22.732]                   signalCondition(cond)
[17:26:22.732]                 }
[17:26:22.732]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:22.732]                 "immediateCondition"))) {
[17:26:22.732]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:22.732]                   ...future.conditions[[length(...future.conditions) + 
[17:26:22.732]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:22.732]                   if (TRUE && !signal) {
[17:26:22.732]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:22.732]                     {
[17:26:22.732]                       inherits <- base::inherits
[17:26:22.732]                       invokeRestart <- base::invokeRestart
[17:26:22.732]                       is.null <- base::is.null
[17:26:22.732]                       muffled <- FALSE
[17:26:22.732]                       if (inherits(cond, "message")) {
[17:26:22.732]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:22.732]                         if (muffled) 
[17:26:22.732]                           invokeRestart("muffleMessage")
[17:26:22.732]                       }
[17:26:22.732]                       else if (inherits(cond, "warning")) {
[17:26:22.732]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:22.732]                         if (muffled) 
[17:26:22.732]                           invokeRestart("muffleWarning")
[17:26:22.732]                       }
[17:26:22.732]                       else if (inherits(cond, "condition")) {
[17:26:22.732]                         if (!is.null(pattern)) {
[17:26:22.732]                           computeRestarts <- base::computeRestarts
[17:26:22.732]                           grepl <- base::grepl
[17:26:22.732]                           restarts <- computeRestarts(cond)
[17:26:22.732]                           for (restart in restarts) {
[17:26:22.732]                             name <- restart$name
[17:26:22.732]                             if (is.null(name)) 
[17:26:22.732]                               next
[17:26:22.732]                             if (!grepl(pattern, name)) 
[17:26:22.732]                               next
[17:26:22.732]                             invokeRestart(restart)
[17:26:22.732]                             muffled <- TRUE
[17:26:22.732]                             break
[17:26:22.732]                           }
[17:26:22.732]                         }
[17:26:22.732]                       }
[17:26:22.732]                       invisible(muffled)
[17:26:22.732]                     }
[17:26:22.732]                     muffleCondition(cond, pattern = "^muffle")
[17:26:22.732]                   }
[17:26:22.732]                 }
[17:26:22.732]                 else {
[17:26:22.732]                   if (TRUE) {
[17:26:22.732]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:22.732]                     {
[17:26:22.732]                       inherits <- base::inherits
[17:26:22.732]                       invokeRestart <- base::invokeRestart
[17:26:22.732]                       is.null <- base::is.null
[17:26:22.732]                       muffled <- FALSE
[17:26:22.732]                       if (inherits(cond, "message")) {
[17:26:22.732]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:22.732]                         if (muffled) 
[17:26:22.732]                           invokeRestart("muffleMessage")
[17:26:22.732]                       }
[17:26:22.732]                       else if (inherits(cond, "warning")) {
[17:26:22.732]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:22.732]                         if (muffled) 
[17:26:22.732]                           invokeRestart("muffleWarning")
[17:26:22.732]                       }
[17:26:22.732]                       else if (inherits(cond, "condition")) {
[17:26:22.732]                         if (!is.null(pattern)) {
[17:26:22.732]                           computeRestarts <- base::computeRestarts
[17:26:22.732]                           grepl <- base::grepl
[17:26:22.732]                           restarts <- computeRestarts(cond)
[17:26:22.732]                           for (restart in restarts) {
[17:26:22.732]                             name <- restart$name
[17:26:22.732]                             if (is.null(name)) 
[17:26:22.732]                               next
[17:26:22.732]                             if (!grepl(pattern, name)) 
[17:26:22.732]                               next
[17:26:22.732]                             invokeRestart(restart)
[17:26:22.732]                             muffled <- TRUE
[17:26:22.732]                             break
[17:26:22.732]                           }
[17:26:22.732]                         }
[17:26:22.732]                       }
[17:26:22.732]                       invisible(muffled)
[17:26:22.732]                     }
[17:26:22.732]                     muffleCondition(cond, pattern = "^muffle")
[17:26:22.732]                   }
[17:26:22.732]                 }
[17:26:22.732]             }
[17:26:22.732]         }))
[17:26:22.732]     }, error = function(ex) {
[17:26:22.732]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:22.732]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:22.732]                 ...future.rng), started = ...future.startTime, 
[17:26:22.732]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:22.732]             version = "1.8"), class = "FutureResult")
[17:26:22.732]     }, finally = {
[17:26:22.732]         if (!identical(...future.workdir, getwd())) 
[17:26:22.732]             setwd(...future.workdir)
[17:26:22.732]         {
[17:26:22.732]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:22.732]                 ...future.oldOptions$nwarnings <- NULL
[17:26:22.732]             }
[17:26:22.732]             base::options(...future.oldOptions)
[17:26:22.732]             if (.Platform$OS.type == "windows") {
[17:26:22.732]                 old_names <- names(...future.oldEnvVars)
[17:26:22.732]                 envs <- base::Sys.getenv()
[17:26:22.732]                 names <- names(envs)
[17:26:22.732]                 common <- intersect(names, old_names)
[17:26:22.732]                 added <- setdiff(names, old_names)
[17:26:22.732]                 removed <- setdiff(old_names, names)
[17:26:22.732]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:22.732]                   envs[common]]
[17:26:22.732]                 NAMES <- toupper(changed)
[17:26:22.732]                 args <- list()
[17:26:22.732]                 for (kk in seq_along(NAMES)) {
[17:26:22.732]                   name <- changed[[kk]]
[17:26:22.732]                   NAME <- NAMES[[kk]]
[17:26:22.732]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:22.732]                     next
[17:26:22.732]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:22.732]                 }
[17:26:22.732]                 NAMES <- toupper(added)
[17:26:22.732]                 for (kk in seq_along(NAMES)) {
[17:26:22.732]                   name <- added[[kk]]
[17:26:22.732]                   NAME <- NAMES[[kk]]
[17:26:22.732]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:22.732]                     next
[17:26:22.732]                   args[[name]] <- ""
[17:26:22.732]                 }
[17:26:22.732]                 NAMES <- toupper(removed)
[17:26:22.732]                 for (kk in seq_along(NAMES)) {
[17:26:22.732]                   name <- removed[[kk]]
[17:26:22.732]                   NAME <- NAMES[[kk]]
[17:26:22.732]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:22.732]                     next
[17:26:22.732]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:22.732]                 }
[17:26:22.732]                 if (length(args) > 0) 
[17:26:22.732]                   base::do.call(base::Sys.setenv, args = args)
[17:26:22.732]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:22.732]             }
[17:26:22.732]             else {
[17:26:22.732]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:22.732]             }
[17:26:22.732]             {
[17:26:22.732]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:22.732]                   0L) {
[17:26:22.732]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:22.732]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:22.732]                   base::options(opts)
[17:26:22.732]                 }
[17:26:22.732]                 {
[17:26:22.732]                   {
[17:26:22.732]                     NULL
[17:26:22.732]                     RNGkind("Mersenne-Twister")
[17:26:22.732]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:22.732]                       inherits = FALSE)
[17:26:22.732]                   }
[17:26:22.732]                   options(future.plan = NULL)
[17:26:22.732]                   if (is.na(NA_character_)) 
[17:26:22.732]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:22.732]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:22.732]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:22.732]                     .init = FALSE)
[17:26:22.732]                 }
[17:26:22.732]             }
[17:26:22.732]         }
[17:26:22.732]     })
[17:26:22.732]     if (TRUE) {
[17:26:22.732]         base::sink(type = "output", split = FALSE)
[17:26:22.732]         if (TRUE) {
[17:26:22.732]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:22.732]         }
[17:26:22.732]         else {
[17:26:22.732]             ...future.result["stdout"] <- base::list(NULL)
[17:26:22.732]         }
[17:26:22.732]         base::close(...future.stdout)
[17:26:22.732]         ...future.stdout <- NULL
[17:26:22.732]     }
[17:26:22.732]     ...future.result$conditions <- ...future.conditions
[17:26:22.732]     ...future.result$finished <- base::Sys.time()
[17:26:22.732]     ...future.result
[17:26:22.732] }
[17:26:22.735] assign_globals() ...
[17:26:22.735] List of 4
[17:26:22.735]  $ ii   : int 3
[17:26:22.735]  $ n    : int 4
[17:26:22.735]  $ C    : cplx [1:25, 1:25] -2.25+0.0306i -2.25+0.0918i -2.25+0.1531i ...
[17:26:22.735]   ..- attr(*, "region")=List of 2
[17:26:22.735]   .. ..$ xrange: num [1:2] -2.25 -0.781
[17:26:22.735]   .. ..$ yrange: num [1:2] 0.0306 1.5
[17:26:22.735]   ..- attr(*, "tile")= int [1:2] 2 1
[17:26:22.735]  $ delay:function (counts)  
[17:26:22.735]   ..- attr(*, "srcref")= 'srcref' int [1:8] 41 12 41 30 12 30 41 41
[17:26:22.735]   .. ..- attr(*, "srcfile")=Classes 'srcfilecopy', 'srcfile' <environment: 0x0000018354c2d900> 
[17:26:22.735]  - attr(*, "where")=List of 4
[17:26:22.735]   ..$ ii   :<environment: R_EmptyEnv> 
[17:26:22.735]   ..$ n    :<environment: R_EmptyEnv> 
[17:26:22.735]   ..$ C    :<environment: R_EmptyEnv> 
[17:26:22.735]   ..$ delay:<environment: R_EmptyEnv> 
[17:26:22.735]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:26:22.735]  - attr(*, "resolved")= logi FALSE
[17:26:22.735]  - attr(*, "total_size")= num 14584
[17:26:22.735]  - attr(*, "already-done")= logi TRUE
[17:26:22.740] - copied 'ii' to environment
[17:26:22.741] - copied 'n' to environment
[17:26:22.741] - copied 'C' to environment
[17:26:22.741] - reassign environment for 'delay'
[17:26:22.741] - copied 'delay' to environment
[17:26:22.741] assign_globals() ... done
[17:26:22.742] plan(): Setting new future strategy stack:
[17:26:22.742] List of future strategies:
[17:26:22.742] 1. sequential:
[17:26:22.742]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:22.742]    - tweaked: FALSE
[17:26:22.742]    - call: NULL
[17:26:22.742] plan(): nbrOfWorkers() = 1
[17:26:22.757] plan(): Setting new future strategy stack:
[17:26:22.757] List of future strategies:
[17:26:22.757] 1. sequential:
[17:26:22.757]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:22.757]    - tweaked: FALSE
[17:26:22.757]    - call: plan(strategy)
[17:26:22.758] plan(): nbrOfWorkers() = 1
[17:26:22.758] SequentialFuture started (and completed)
[17:26:22.758] signalConditions() ...
[17:26:22.758]  - include = 'immediateCondition'
[17:26:22.758]  - exclude = 
[17:26:22.759]  - resignal = FALSE
[17:26:22.759]  - Number of conditions: 2
[17:26:22.759] signalConditions() ... done
[17:26:22.759] - Launch lazy future ... done
[17:26:22.759] run() for 'SequentialFuture' ... done
[17:26:22.759] - run() ... done
[17:26:22.759] - resolved() ...
[17:26:22.759] resolved() for 'SequentialFuture' ...
[17:26:22.760] - state: 'finished'
[17:26:22.760] - run: TRUE
[17:26:22.760] - result: 'FutureResult'
[17:26:22.760] resolved() for 'SequentialFuture' ... done
[17:26:22.760] - resolved: TRUE
[17:26:22.760] - resolved() ... done
[17:26:22.760] resolved() for 'SequentialFuture' ... done
Plotting tile #3 of 4 ...
[17:26:22.761] signalConditions() ...
[17:26:22.761]  - include = 'immediateCondition'
[17:26:22.761]  - exclude = 
[17:26:22.761]  - resignal = FALSE
[17:26:22.761]  - Number of conditions: 2
[17:26:22.761] signalConditions() ... done
[17:26:22.761] Future state: 'finished'
[17:26:22.762] signalConditions() ...
[17:26:22.762]  - include = 'condition'
[17:26:22.762]  - exclude = 'immediateCondition'
[17:26:22.762]  - resignal = TRUE
[17:26:22.762]  - Number of conditions: 2
[17:26:22.762]  - Condition #1: 'simpleMessage', 'message', 'condition'
Calculating tile #3 of 4 ...[17:26:22.762]  - Condition #2: 'simpleMessage', 'message', 'condition'
 done
[17:26:22.763] signalConditions() ... done
[17:26:22.763] resolved() for 'Future' ...
[17:26:22.763] - state: 'created'
[17:26:22.763] - run: TRUE
[17:26:22.763] - run() ...
[17:26:22.764] run() for 'Future' ...
[17:26:22.764] - state: 'created'
[17:26:22.764] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:26:22.764] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:26:22.764] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:26:22.764]   - Field: 'label'
[17:26:22.765]   - Field: 'local'
[17:26:22.765]   - Field: 'owner'
[17:26:22.765]   - Field: 'envir'
[17:26:22.765]   - Field: 'packages'
[17:26:22.765]   - Field: 'gc'
[17:26:22.765]   - Field: 'conditions'
[17:26:22.765]   - Field: 'expr'
[17:26:22.766]   - Field: 'uuid'
[17:26:22.766]   - Field: 'seed'
[17:26:22.766]   - Field: 'version'
[17:26:22.766]   - Field: 'result'
[17:26:22.766]   - Field: 'asynchronous'
[17:26:22.766]   - Field: 'calls'
[17:26:22.766]   - Field: 'globals'
[17:26:22.766]   - Field: 'stdout'
[17:26:22.767]   - Field: 'earlySignal'
[17:26:22.767]   - Field: 'lazy'
[17:26:22.767]   - Field: 'state'
[17:26:22.767] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:26:22.767] - Launch lazy future ...
[17:26:22.767] Packages needed by the future expression (n = 1): 'future'
[17:26:22.767] Packages needed by future strategies (n = 0): <none>
[17:26:22.768] {
[17:26:22.768]     {
[17:26:22.768]         {
[17:26:22.768]             ...future.startTime <- base::Sys.time()
[17:26:22.768]             {
[17:26:22.768]                 {
[17:26:22.768]                   {
[17:26:22.768]                     {
[17:26:22.768]                       base::local({
[17:26:22.768]                         has_future <- base::requireNamespace("future", 
[17:26:22.768]                           quietly = TRUE)
[17:26:22.768]                         if (has_future) {
[17:26:22.768]                           ns <- base::getNamespace("future")
[17:26:22.768]                           version <- ns[[".package"]][["version"]]
[17:26:22.768]                           if (is.null(version)) 
[17:26:22.768]                             version <- utils::packageVersion("future")
[17:26:22.768]                         }
[17:26:22.768]                         else {
[17:26:22.768]                           version <- NULL
[17:26:22.768]                         }
[17:26:22.768]                         if (!has_future || version < "1.8.0") {
[17:26:22.768]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:22.768]                             "", base::R.version$version.string), 
[17:26:22.768]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:22.768]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:22.768]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:22.768]                               "release", "version")], collapse = " "), 
[17:26:22.768]                             hostname = base::Sys.info()[["nodename"]])
[17:26:22.768]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:22.768]                             info)
[17:26:22.768]                           info <- base::paste(info, collapse = "; ")
[17:26:22.768]                           if (!has_future) {
[17:26:22.768]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:22.768]                               info)
[17:26:22.768]                           }
[17:26:22.768]                           else {
[17:26:22.768]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:22.768]                               info, version)
[17:26:22.768]                           }
[17:26:22.768]                           base::stop(msg)
[17:26:22.768]                         }
[17:26:22.768]                       })
[17:26:22.768]                     }
[17:26:22.768]                     base::local({
[17:26:22.768]                       for (pkg in "future") {
[17:26:22.768]                         base::loadNamespace(pkg)
[17:26:22.768]                         base::library(pkg, character.only = TRUE)
[17:26:22.768]                       }
[17:26:22.768]                     })
[17:26:22.768]                   }
[17:26:22.768]                   ...future.strategy.old <- future::plan("list")
[17:26:22.768]                   options(future.plan = NULL)
[17:26:22.768]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:22.768]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:22.768]                 }
[17:26:22.768]                 ...future.workdir <- getwd()
[17:26:22.768]             }
[17:26:22.768]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:22.768]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:22.768]         }
[17:26:22.768]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:22.768]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:22.768]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:22.768]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:22.768]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:22.768]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:22.768]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:22.768]             base::names(...future.oldOptions))
[17:26:22.768]     }
[17:26:22.768]     if (FALSE) {
[17:26:22.768]     }
[17:26:22.768]     else {
[17:26:22.768]         if (TRUE) {
[17:26:22.768]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:22.768]                 open = "w")
[17:26:22.768]         }
[17:26:22.768]         else {
[17:26:22.768]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:22.768]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:22.768]         }
[17:26:22.768]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:22.768]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:22.768]             base::sink(type = "output", split = FALSE)
[17:26:22.768]             base::close(...future.stdout)
[17:26:22.768]         }, add = TRUE)
[17:26:22.768]     }
[17:26:22.768]     ...future.frame <- base::sys.nframe()
[17:26:22.768]     ...future.conditions <- base::list()
[17:26:22.768]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:22.768]     if (FALSE) {
[17:26:22.768]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:22.768]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:22.768]     }
[17:26:22.768]     ...future.result <- base::tryCatch({
[17:26:22.768]         base::withCallingHandlers({
[17:26:22.768]             ...future.value <- base::withVisible(base::local({
[17:26:22.768]                 message(sprintf("Calculating tile #%d of %d ...", 
[17:26:22.768]                   ii, n), appendLF = FALSE)
[17:26:22.768]                 fit <- mandelbrot(C)
[17:26:22.768]                 delay(fit)
[17:26:22.768]                 message(" done")
[17:26:22.768]                 fit
[17:26:22.768]             }))
[17:26:22.768]             future::FutureResult(value = ...future.value$value, 
[17:26:22.768]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:22.768]                   ...future.rng), globalenv = if (FALSE) 
[17:26:22.768]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:22.768]                     ...future.globalenv.names))
[17:26:22.768]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:22.768]         }, condition = base::local({
[17:26:22.768]             c <- base::c
[17:26:22.768]             inherits <- base::inherits
[17:26:22.768]             invokeRestart <- base::invokeRestart
[17:26:22.768]             length <- base::length
[17:26:22.768]             list <- base::list
[17:26:22.768]             seq.int <- base::seq.int
[17:26:22.768]             signalCondition <- base::signalCondition
[17:26:22.768]             sys.calls <- base::sys.calls
[17:26:22.768]             `[[` <- base::`[[`
[17:26:22.768]             `+` <- base::`+`
[17:26:22.768]             `<<-` <- base::`<<-`
[17:26:22.768]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:22.768]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:22.768]                   3L)]
[17:26:22.768]             }
[17:26:22.768]             function(cond) {
[17:26:22.768]                 is_error <- inherits(cond, "error")
[17:26:22.768]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:22.768]                   NULL)
[17:26:22.768]                 if (is_error) {
[17:26:22.768]                   sessionInformation <- function() {
[17:26:22.768]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:22.768]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:22.768]                       search = base::search(), system = base::Sys.info())
[17:26:22.768]                   }
[17:26:22.768]                   ...future.conditions[[length(...future.conditions) + 
[17:26:22.768]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:22.768]                     cond$call), session = sessionInformation(), 
[17:26:22.768]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:22.768]                   signalCondition(cond)
[17:26:22.768]                 }
[17:26:22.768]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:22.768]                 "immediateCondition"))) {
[17:26:22.768]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:22.768]                   ...future.conditions[[length(...future.conditions) + 
[17:26:22.768]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:22.768]                   if (TRUE && !signal) {
[17:26:22.768]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:22.768]                     {
[17:26:22.768]                       inherits <- base::inherits
[17:26:22.768]                       invokeRestart <- base::invokeRestart
[17:26:22.768]                       is.null <- base::is.null
[17:26:22.768]                       muffled <- FALSE
[17:26:22.768]                       if (inherits(cond, "message")) {
[17:26:22.768]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:22.768]                         if (muffled) 
[17:26:22.768]                           invokeRestart("muffleMessage")
[17:26:22.768]                       }
[17:26:22.768]                       else if (inherits(cond, "warning")) {
[17:26:22.768]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:22.768]                         if (muffled) 
[17:26:22.768]                           invokeRestart("muffleWarning")
[17:26:22.768]                       }
[17:26:22.768]                       else if (inherits(cond, "condition")) {
[17:26:22.768]                         if (!is.null(pattern)) {
[17:26:22.768]                           computeRestarts <- base::computeRestarts
[17:26:22.768]                           grepl <- base::grepl
[17:26:22.768]                           restarts <- computeRestarts(cond)
[17:26:22.768]                           for (restart in restarts) {
[17:26:22.768]                             name <- restart$name
[17:26:22.768]                             if (is.null(name)) 
[17:26:22.768]                               next
[17:26:22.768]                             if (!grepl(pattern, name)) 
[17:26:22.768]                               next
[17:26:22.768]                             invokeRestart(restart)
[17:26:22.768]                             muffled <- TRUE
[17:26:22.768]                             break
[17:26:22.768]                           }
[17:26:22.768]                         }
[17:26:22.768]                       }
[17:26:22.768]                       invisible(muffled)
[17:26:22.768]                     }
[17:26:22.768]                     muffleCondition(cond, pattern = "^muffle")
[17:26:22.768]                   }
[17:26:22.768]                 }
[17:26:22.768]                 else {
[17:26:22.768]                   if (TRUE) {
[17:26:22.768]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:22.768]                     {
[17:26:22.768]                       inherits <- base::inherits
[17:26:22.768]                       invokeRestart <- base::invokeRestart
[17:26:22.768]                       is.null <- base::is.null
[17:26:22.768]                       muffled <- FALSE
[17:26:22.768]                       if (inherits(cond, "message")) {
[17:26:22.768]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:22.768]                         if (muffled) 
[17:26:22.768]                           invokeRestart("muffleMessage")
[17:26:22.768]                       }
[17:26:22.768]                       else if (inherits(cond, "warning")) {
[17:26:22.768]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:22.768]                         if (muffled) 
[17:26:22.768]                           invokeRestart("muffleWarning")
[17:26:22.768]                       }
[17:26:22.768]                       else if (inherits(cond, "condition")) {
[17:26:22.768]                         if (!is.null(pattern)) {
[17:26:22.768]                           computeRestarts <- base::computeRestarts
[17:26:22.768]                           grepl <- base::grepl
[17:26:22.768]                           restarts <- computeRestarts(cond)
[17:26:22.768]                           for (restart in restarts) {
[17:26:22.768]                             name <- restart$name
[17:26:22.768]                             if (is.null(name)) 
[17:26:22.768]                               next
[17:26:22.768]                             if (!grepl(pattern, name)) 
[17:26:22.768]                               next
[17:26:22.768]                             invokeRestart(restart)
[17:26:22.768]                             muffled <- TRUE
[17:26:22.768]                             break
[17:26:22.768]                           }
[17:26:22.768]                         }
[17:26:22.768]                       }
[17:26:22.768]                       invisible(muffled)
[17:26:22.768]                     }
[17:26:22.768]                     muffleCondition(cond, pattern = "^muffle")
[17:26:22.768]                   }
[17:26:22.768]                 }
[17:26:22.768]             }
[17:26:22.768]         }))
[17:26:22.768]     }, error = function(ex) {
[17:26:22.768]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:22.768]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:22.768]                 ...future.rng), started = ...future.startTime, 
[17:26:22.768]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:22.768]             version = "1.8"), class = "FutureResult")
[17:26:22.768]     }, finally = {
[17:26:22.768]         if (!identical(...future.workdir, getwd())) 
[17:26:22.768]             setwd(...future.workdir)
[17:26:22.768]         {
[17:26:22.768]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:22.768]                 ...future.oldOptions$nwarnings <- NULL
[17:26:22.768]             }
[17:26:22.768]             base::options(...future.oldOptions)
[17:26:22.768]             if (.Platform$OS.type == "windows") {
[17:26:22.768]                 old_names <- names(...future.oldEnvVars)
[17:26:22.768]                 envs <- base::Sys.getenv()
[17:26:22.768]                 names <- names(envs)
[17:26:22.768]                 common <- intersect(names, old_names)
[17:26:22.768]                 added <- setdiff(names, old_names)
[17:26:22.768]                 removed <- setdiff(old_names, names)
[17:26:22.768]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:22.768]                   envs[common]]
[17:26:22.768]                 NAMES <- toupper(changed)
[17:26:22.768]                 args <- list()
[17:26:22.768]                 for (kk in seq_along(NAMES)) {
[17:26:22.768]                   name <- changed[[kk]]
[17:26:22.768]                   NAME <- NAMES[[kk]]
[17:26:22.768]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:22.768]                     next
[17:26:22.768]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:22.768]                 }
[17:26:22.768]                 NAMES <- toupper(added)
[17:26:22.768]                 for (kk in seq_along(NAMES)) {
[17:26:22.768]                   name <- added[[kk]]
[17:26:22.768]                   NAME <- NAMES[[kk]]
[17:26:22.768]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:22.768]                     next
[17:26:22.768]                   args[[name]] <- ""
[17:26:22.768]                 }
[17:26:22.768]                 NAMES <- toupper(removed)
[17:26:22.768]                 for (kk in seq_along(NAMES)) {
[17:26:22.768]                   name <- removed[[kk]]
[17:26:22.768]                   NAME <- NAMES[[kk]]
[17:26:22.768]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:22.768]                     next
[17:26:22.768]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:22.768]                 }
[17:26:22.768]                 if (length(args) > 0) 
[17:26:22.768]                   base::do.call(base::Sys.setenv, args = args)
[17:26:22.768]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:22.768]             }
[17:26:22.768]             else {
[17:26:22.768]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:22.768]             }
[17:26:22.768]             {
[17:26:22.768]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:22.768]                   0L) {
[17:26:22.768]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:22.768]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:22.768]                   base::options(opts)
[17:26:22.768]                 }
[17:26:22.768]                 {
[17:26:22.768]                   {
[17:26:22.768]                     NULL
[17:26:22.768]                     RNGkind("Mersenne-Twister")
[17:26:22.768]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:26:22.768]                       inherits = FALSE)
[17:26:22.768]                   }
[17:26:22.768]                   options(future.plan = NULL)
[17:26:22.768]                   if (is.na(NA_character_)) 
[17:26:22.768]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:22.768]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:22.768]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:22.768]                     .init = FALSE)
[17:26:22.768]                 }
[17:26:22.768]             }
[17:26:22.768]         }
[17:26:22.768]     })
[17:26:22.768]     if (TRUE) {
[17:26:22.768]         base::sink(type = "output", split = FALSE)
[17:26:22.768]         if (TRUE) {
[17:26:22.768]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:22.768]         }
[17:26:22.768]         else {
[17:26:22.768]             ...future.result["stdout"] <- base::list(NULL)
[17:26:22.768]         }
[17:26:22.768]         base::close(...future.stdout)
[17:26:22.768]         ...future.stdout <- NULL
[17:26:22.768]     }
[17:26:22.768]     ...future.result$conditions <- ...future.conditions
[17:26:22.768]     ...future.result$finished <- base::Sys.time()
[17:26:22.768]     ...future.result
[17:26:22.768] }
[17:26:22.771] assign_globals() ...
[17:26:22.771] List of 4
[17:26:22.771]  $ ii   : int 4
[17:26:22.771]  $ n    : int 4
[17:26:22.771]  $ C    : cplx [1:25, 1:25] -0.719+0.0306i -0.719+0.0918i -0.719+0.1531i ...
[17:26:22.771]   ..- attr(*, "region")=List of 2
[17:26:22.771]   .. ..$ xrange: num [1:2] -0.719 0.75
[17:26:22.771]   .. ..$ yrange: num [1:2] 0.0306 1.5
[17:26:22.771]   ..- attr(*, "tile")= int [1:2] 2 2
[17:26:22.771]  $ delay:function (counts)  
[17:26:22.771]   ..- attr(*, "srcref")= 'srcref' int [1:8] 41 12 41 30 12 30 41 41
[17:26:22.771]   .. ..- attr(*, "srcfile")=Classes 'srcfilecopy', 'srcfile' <environment: 0x0000018354c2d900> 
[17:26:22.771]  - attr(*, "where")=List of 4
[17:26:22.771]   ..$ ii   :<environment: R_EmptyEnv> 
[17:26:22.771]   ..$ n    :<environment: R_EmptyEnv> 
[17:26:22.771]   ..$ C    :<environment: R_EmptyEnv> 
[17:26:22.771]   ..$ delay:<environment: R_EmptyEnv> 
[17:26:22.771]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:26:22.771]  - attr(*, "resolved")= logi FALSE
[17:26:22.771]  - attr(*, "total_size")= num 14584
[17:26:22.771]  - attr(*, "already-done")= logi TRUE
[17:26:22.776] - copied 'ii' to environment
[17:26:22.776] - copied 'n' to environment
[17:26:22.777] - copied 'C' to environment
[17:26:22.777] - reassign environment for 'delay'
[17:26:22.777] - copied 'delay' to environment
[17:26:22.777] assign_globals() ... done
[17:26:22.777] plan(): Setting new future strategy stack:
[17:26:22.778] List of future strategies:
[17:26:22.778] 1. sequential:
[17:26:22.778]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:22.778]    - tweaked: FALSE
[17:26:22.778]    - call: NULL
[17:26:22.778] plan(): nbrOfWorkers() = 1
[17:26:22.792] plan(): Setting new future strategy stack:
[17:26:22.792] List of future strategies:
[17:26:22.792] 1. sequential:
[17:26:22.792]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:22.792]    - tweaked: FALSE
[17:26:22.792]    - call: plan(strategy)
[17:26:22.793] plan(): nbrOfWorkers() = 1
[17:26:22.793] SequentialFuture started (and completed)
[17:26:22.793] signalConditions() ...
[17:26:22.793]  - include = 'immediateCondition'
[17:26:22.793]  - exclude = 
[17:26:22.793]  - resignal = FALSE
[17:26:22.793]  - Number of conditions: 2
[17:26:22.794] signalConditions() ... done
[17:26:22.794] - Launch lazy future ... done
[17:26:22.794] run() for 'SequentialFuture' ... done
[17:26:22.794] - run() ... done
[17:26:22.794] - resolved() ...
[17:26:22.794] resolved() for 'SequentialFuture' ...
[17:26:22.794] - state: 'finished'
[17:26:22.794] - run: TRUE
[17:26:22.795] - result: 'FutureResult'
[17:26:22.795] resolved() for 'SequentialFuture' ... done
[17:26:22.795] - resolved: TRUE
[17:26:22.795] - resolved() ... done
[17:26:22.795] resolved() for 'SequentialFuture' ... done
Plotting tile #4 of 4 ...
[17:26:22.795] signalConditions() ...
[17:26:22.795]  - include = 'immediateCondition'
[17:26:22.796]  - exclude = 
[17:26:22.796]  - resignal = FALSE
[17:26:22.796]  - Number of conditions: 2
[17:26:22.796] signalConditions() ... done
[17:26:22.796] Future state: 'finished'
[17:26:22.796] signalConditions() ...
[17:26:22.796]  - include = 'condition'
[17:26:22.796]  - exclude = 'immediateCondition'
[17:26:22.797]  - resignal = TRUE
[17:26:22.797]  - Number of conditions: 2
[17:26:22.797]  - Condition #1: 'simpleMessage', 'message', 'condition'
Calculating tile #4 of 4 ...[17:26:22.797]  - Condition #2: 'simpleMessage', 'message', 'condition'
 done
[17:26:22.797] signalConditions() ... done

> close.screen()
[1] 1 2 3 4

> message("SUGGESTION: Try to rerun this demo after changing strategy for how futures are resolved, e.g. plan(multisession).\n")
SUGGESTION: Try to rerun this demo after changing strategy for how futures are resolved, e.g. plan(multisession).

- plan('sequential') ... DONE
Testing with 1 cores ... DONE
Testing with 2 cores ...
- plan('multisession') ...
[17:26:22.803] plan(): Setting new future strategy stack:
[17:26:22.803] List of future strategies:
[17:26:22.803] 1. multisession:
[17:26:22.803]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:26:22.803]    - tweaked: FALSE
[17:26:22.803]    - call: plan(strategy)
[17:26:22.803] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:26:22.803] multisession:
[17:26:22.803] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:26:22.803] - tweaked: FALSE
[17:26:22.803] - call: plan(strategy)
[17:26:22.806] getGlobalsAndPackages() ...
[17:26:22.807] Not searching for globals
[17:26:22.807] - globals: [0] <none>
[17:26:22.807] getGlobalsAndPackages() ... DONE
[17:26:22.807] [local output] makeClusterPSOCK() ...
[17:26:22.844] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:26:22.849] [local output] Base port: 25552
[17:26:22.850] [local output] Getting setup options for 2 cluster nodes ...
[17:26:22.850] [local output]  - Node 1 of 2 ...
[17:26:22.850] [local output] localMachine=TRUE => revtunnel=FALSE

[17:26:22.851] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpUFBBZS/worker.rank=1.parallelly.parent=67828.108f4322b7e32.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpUFBBZS/worker.rank=1.parallelly.parent=67828.108f4322b7e32.pid\")"'
[17:26:23.290] - Possible to infer worker's PID: TRUE
[17:26:23.291] [local output] Rscript port: 25552

[17:26:23.291] [local output]  - Node 2 of 2 ...
[17:26:23.292] [local output] localMachine=TRUE => revtunnel=FALSE

[17:26:23.293] [local output] Rscript port: 25552

[17:26:23.294] [local output] Getting setup options for 2 cluster nodes ... done
[17:26:23.294] [local output]  - Parallel setup requested for some PSOCK nodes
[17:26:23.294] [local output] Setting up PSOCK nodes in parallel
[17:26:23.295] List of 36
[17:26:23.295]  $ worker          : chr "localhost"
[17:26:23.295]   ..- attr(*, "localhost")= logi TRUE
[17:26:23.295]  $ master          : chr "localhost"
[17:26:23.295]  $ port            : int 25552
[17:26:23.295]  $ connectTimeout  : num 120
[17:26:23.295]  $ timeout         : num 120
[17:26:23.295]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:26:23.295]  $ homogeneous     : logi TRUE
[17:26:23.295]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=demo.R:67828:CRANWIN3:CRAN\" -e "| __truncated__
[17:26:23.295]  $ rscript_envs    : NULL
[17:26:23.295]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7" "D:/RCompile/recent/R/library"
[17:26:23.295]  $ rscript_startup : NULL
[17:26:23.295]  $ rscript_sh      : chr "cmd"
[17:26:23.295]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:26:23.295]  $ methods         : logi TRUE
[17:26:23.295]  $ socketOptions   : chr "no-delay"
[17:26:23.295]  $ useXDR          : logi FALSE
[17:26:23.295]  $ outfile         : chr "/dev/null"
[17:26:23.295]  $ renice          : int NA
[17:26:23.295]  $ rshcmd          : NULL
[17:26:23.295]  $ user            : chr(0) 
[17:26:23.295]  $ revtunnel       : logi FALSE
[17:26:23.295]  $ rshlogfile      : NULL
[17:26:23.295]  $ rshopts         : chr(0) 
[17:26:23.295]  $ rank            : int 1
[17:26:23.295]  $ manual          : logi FALSE
[17:26:23.295]  $ dryrun          : logi FALSE
[17:26:23.295]  $ quiet           : logi FALSE
[17:26:23.295]  $ setup_strategy  : chr "parallel"
[17:26:23.295]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:26:23.295]  $ pidfile         : chr "D:/temp/RtmpUFBBZS/worker.rank=1.parallelly.parent=67828.108f4322b7e32.pid"
[17:26:23.295]  $ rshcmd_label    : NULL
[17:26:23.295]  $ rsh_call        : NULL
[17:26:23.295]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:26:23.295]  $ localMachine    : logi TRUE
[17:26:23.295]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:26:23.295]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:26:23.295]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:26:23.295]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:26:23.295]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:26:23.295]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[17:26:23.295]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:26:23.295]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:26:23.295]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:26:23.295]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:26:23.295]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:26:23.295]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:26:23.295]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:26:23.295]  $ arguments       :List of 28
[17:26:23.295]   ..$ worker          : chr "localhost"
[17:26:23.295]   ..$ master          : NULL
[17:26:23.295]   ..$ port            : int 25552
[17:26:23.295]   ..$ connectTimeout  : num 120
[17:26:23.295]   ..$ timeout         : num 120
[17:26:23.295]   ..$ rscript         : NULL
[17:26:23.295]   ..$ homogeneous     : NULL
[17:26:23.295]   ..$ rscript_args    : NULL
[17:26:23.295]   ..$ rscript_envs    : NULL
[17:26:23.295]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7" "D:/RCompile/recent/R/library"
[17:26:23.295]   ..$ rscript_startup : NULL
[17:26:23.295]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[17:26:23.295]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:26:23.295]   ..$ methods         : logi TRUE
[17:26:23.295]   ..$ socketOptions   : chr "no-delay"
[17:26:23.295]   ..$ useXDR          : logi FALSE
[17:26:23.295]   ..$ outfile         : chr "/dev/null"
[17:26:23.295]   ..$ renice          : int NA
[17:26:23.295]   ..$ rshcmd          : NULL
[17:26:23.295]   ..$ user            : NULL
[17:26:23.295]   ..$ revtunnel       : logi NA
[17:26:23.295]   ..$ rshlogfile      : NULL
[17:26:23.295]   ..$ rshopts         : NULL
[17:26:23.295]   ..$ rank            : int 1
[17:26:23.295]   ..$ manual          : logi FALSE
[17:26:23.295]   ..$ dryrun          : logi FALSE
[17:26:23.295]   ..$ quiet           : logi FALSE
[17:26:23.295]   ..$ setup_strategy  : chr "parallel"
[17:26:23.295]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:26:23.315] [local output] System call to launch all workers:
[17:26:23.315] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=demo.R:67828:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpUFBBZS/worker.rank=1.parallelly.parent=67828.108f4322b7e32.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpAVtqMV/RLIBS_30708245f64e7\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=25552 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:26:23.315] [local output] Starting PSOCK main server
[17:26:23.321] [local output] Workers launched
[17:26:23.321] [local output] Waiting for workers to connect back
[17:26:23.322]  - [local output] 0 workers out of 2 ready
[17:26:23.488]  - [local output] 0 workers out of 2 ready
[17:26:23.489]  - [local output] 1 workers out of 2 ready
[17:26:23.489]  - [local output] 2 workers out of 2 ready
[17:26:23.489] [local output] Launching of workers completed
[17:26:23.490] [local output] Collecting session information from workers
[17:26:23.490] [local output]  - Worker #1 of 2
[17:26:23.491] [local output]  - Worker #2 of 2
[17:26:23.491] [local output] makeClusterPSOCK() ... done
[17:26:23.504] Packages needed by the future expression (n = 0): <none>
[17:26:23.505] Packages needed by future strategies (n = 0): <none>
[17:26:23.505] {
[17:26:23.505]     {
[17:26:23.505]         {
[17:26:23.505]             ...future.startTime <- base::Sys.time()
[17:26:23.505]             {
[17:26:23.505]                 {
[17:26:23.505]                   {
[17:26:23.505]                     {
[17:26:23.505]                       base::local({
[17:26:23.505]                         has_future <- base::requireNamespace("future", 
[17:26:23.505]                           quietly = TRUE)
[17:26:23.505]                         if (has_future) {
[17:26:23.505]                           ns <- base::getNamespace("future")
[17:26:23.505]                           version <- ns[[".package"]][["version"]]
[17:26:23.505]                           if (is.null(version)) 
[17:26:23.505]                             version <- utils::packageVersion("future")
[17:26:23.505]                         }
[17:26:23.505]                         else {
[17:26:23.505]                           version <- NULL
[17:26:23.505]                         }
[17:26:23.505]                         if (!has_future || version < "1.8.0") {
[17:26:23.505]                           info <- base::c(r_version = base::gsub("R version ", 
[17:26:23.505]                             "", base::R.version$version.string), 
[17:26:23.505]                             platform = base::sprintf("%s (%s-bit)", 
[17:26:23.505]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:26:23.505]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:23.505]                               "release", "version")], collapse = " "), 
[17:26:23.505]                             hostname = base::Sys.info()[["nodename"]])
[17:26:23.505]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:26:23.505]                             info)
[17:26:23.505]                           info <- base::paste(info, collapse = "; ")
[17:26:23.505]                           if (!has_future) {
[17:26:23.505]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:23.505]                               info)
[17:26:23.505]                           }
[17:26:23.505]                           else {
[17:26:23.505]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:23.505]                               info, version)
[17:26:23.505]                           }
[17:26:23.505]                           base::stop(msg)
[17:26:23.505]                         }
[17:26:23.505]                       })
[17:26:23.505]                     }
[17:26:23.505]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:23.505]                     base::options(mc.cores = 1L)
[17:26:23.505]                   }
[17:26:23.505]                   ...future.strategy.old <- future::plan("list")
[17:26:23.505]                   options(future.plan = NULL)
[17:26:23.505]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:23.505]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:23.505]                 }
[17:26:23.505]                 ...future.workdir <- getwd()
[17:26:23.505]             }
[17:26:23.505]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:23.505]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:23.505]         }
[17:26:23.505]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:23.505]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:23.505]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:23.505]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:23.505]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:23.505]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:23.505]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:23.505]             base::names(...future.oldOptions))
[17:26:23.505]     }
[17:26:23.505]     if (FALSE) {
[17:26:23.505]     }
[17:26:23.505]     else {
[17:26:23.505]         if (TRUE) {
[17:26:23.505]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:23.505]                 open = "w")
[17:26:23.505]         }
[17:26:23.505]         else {
[17:26:23.505]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:23.505]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:23.505]         }
[17:26:23.505]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:23.505]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:23.505]             base::sink(type = "output", split = FALSE)
[17:26:23.505]             base::close(...future.stdout)
[17:26:23.505]         }, add = TRUE)
[17:26:23.505]     }
[17:26:23.505]     ...future.frame <- base::sys.nframe()
[17:26:23.505]     ...future.conditions <- base::list()
[17:26:23.505]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:23.505]     if (FALSE) {
[17:26:23.505]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:23.505]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:23.505]     }
[17:26:23.505]     ...future.result <- base::tryCatch({
[17:26:23.505]         base::withCallingHandlers({
[17:26:23.505]             ...future.value <- base::withVisible(base::local({
[17:26:23.505]                 ...future.makeSendCondition <- base::local({
[17:26:23.505]                   sendCondition <- NULL
[17:26:23.505]                   function(frame = 1L) {
[17:26:23.505]                     if (is.function(sendCondition)) 
[17:26:23.505]                       return(sendCondition)
[17:26:23.505]                     ns <- getNamespace("parallel")
[17:26:23.505]                     if (exists("sendData", mode = "function", 
[17:26:23.505]                       envir = ns)) {
[17:26:23.505]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:23.505]                         envir = ns)
[17:26:23.505]                       envir <- sys.frame(frame)
[17:26:23.505]                       master <- NULL
[17:26:23.505]                       while (!identical(envir, .GlobalEnv) && 
[17:26:23.505]                         !identical(envir, emptyenv())) {
[17:26:23.505]                         if (exists("master", mode = "list", envir = envir, 
[17:26:23.505]                           inherits = FALSE)) {
[17:26:23.505]                           master <- get("master", mode = "list", 
[17:26:23.505]                             envir = envir, inherits = FALSE)
[17:26:23.505]                           if (inherits(master, c("SOCKnode", 
[17:26:23.505]                             "SOCK0node"))) {
[17:26:23.505]                             sendCondition <<- function(cond) {
[17:26:23.505]                               data <- list(type = "VALUE", value = cond, 
[17:26:23.505]                                 success = TRUE)
[17:26:23.505]                               parallel_sendData(master, data)
[17:26:23.505]                             }
[17:26:23.505]                             return(sendCondition)
[17:26:23.505]                           }
[17:26:23.505]                         }
[17:26:23.505]                         frame <- frame + 1L
[17:26:23.505]                         envir <- sys.frame(frame)
[17:26:23.505]                       }
[17:26:23.505]                     }
[17:26:23.505]                     sendCondition <<- function(cond) NULL
[17:26:23.505]                   }
[17:26:23.505]                 })
[17:26:23.505]                 withCallingHandlers({
[17:26:23.505]                   NA
[17:26:23.505]                 }, immediateCondition = function(cond) {
[17:26:23.505]                   sendCondition <- ...future.makeSendCondition()
[17:26:23.505]                   sendCondition(cond)
[17:26:23.505]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:23.505]                   {
[17:26:23.505]                     inherits <- base::inherits
[17:26:23.505]                     invokeRestart <- base::invokeRestart
[17:26:23.505]                     is.null <- base::is.null
[17:26:23.505]                     muffled <- FALSE
[17:26:23.505]                     if (inherits(cond, "message")) {
[17:26:23.505]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:23.505]                       if (muffled) 
[17:26:23.505]                         invokeRestart("muffleMessage")
[17:26:23.505]                     }
[17:26:23.505]                     else if (inherits(cond, "warning")) {
[17:26:23.505]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:23.505]                       if (muffled) 
[17:26:23.505]                         invokeRestart("muffleWarning")
[17:26:23.505]                     }
[17:26:23.505]                     else if (inherits(cond, "condition")) {
[17:26:23.505]                       if (!is.null(pattern)) {
[17:26:23.505]                         computeRestarts <- base::computeRestarts
[17:26:23.505]                         grepl <- base::grepl
[17:26:23.505]                         restarts <- computeRestarts(cond)
[17:26:23.505]                         for (restart in restarts) {
[17:26:23.505]                           name <- restart$name
[17:26:23.505]                           if (is.null(name)) 
[17:26:23.505]                             next
[17:26:23.505]                           if (!grepl(pattern, name)) 
[17:26:23.505]                             next
[17:26:23.505]                           invokeRestart(restart)
[17:26:23.505]                           muffled <- TRUE
[17:26:23.505]                           break
[17:26:23.505]                         }
[17:26:23.505]                       }
[17:26:23.505]                     }
[17:26:23.505]                     invisible(muffled)
[17:26:23.505]                   }
[17:26:23.505]                   muffleCondition(cond)
[17:26:23.505]                 })
[17:26:23.505]             }))
[17:26:23.505]             future::FutureResult(value = ...future.value$value, 
[17:26:23.505]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:23.505]                   ...future.rng), globalenv = if (FALSE) 
[17:26:23.505]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:23.505]                     ...future.globalenv.names))
[17:26:23.505]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:23.505]         }, condition = base::local({
[17:26:23.505]             c <- base::c
[17:26:23.505]             inherits <- base::inherits
[17:26:23.505]             invokeRestart <- base::invokeRestart
[17:26:23.505]             length <- base::length
[17:26:23.505]             list <- base::list
[17:26:23.505]             seq.int <- base::seq.int
[17:26:23.505]             signalCondition <- base::signalCondition
[17:26:23.505]             sys.calls <- base::sys.calls
[17:26:23.505]             `[[` <- base::`[[`
[17:26:23.505]             `+` <- base::`+`
[17:26:23.505]             `<<-` <- base::`<<-`
[17:26:23.505]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:23.505]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:23.505]                   3L)]
[17:26:23.505]             }
[17:26:23.505]             function(cond) {
[17:26:23.505]                 is_error <- inherits(cond, "error")
[17:26:23.505]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:23.505]                   NULL)
[17:26:23.505]                 if (is_error) {
[17:26:23.505]                   sessionInformation <- function() {
[17:26:23.505]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:23.505]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:23.505]                       search = base::search(), system = base::Sys.info())
[17:26:23.505]                   }
[17:26:23.505]                   ...future.conditions[[length(...future.conditions) + 
[17:26:23.505]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:23.505]                     cond$call), session = sessionInformation(), 
[17:26:23.505]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:23.505]                   signalCondition(cond)
[17:26:23.505]                 }
[17:26:23.505]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:23.505]                 "immediateCondition"))) {
[17:26:23.505]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:23.505]                   ...future.conditions[[length(...future.conditions) + 
[17:26:23.505]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:23.505]                   if (TRUE && !signal) {
[17:26:23.505]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:23.505]                     {
[17:26:23.505]                       inherits <- base::inherits
[17:26:23.505]                       invokeRestart <- base::invokeRestart
[17:26:23.505]                       is.null <- base::is.null
[17:26:23.505]                       muffled <- FALSE
[17:26:23.505]                       if (inherits(cond, "message")) {
[17:26:23.505]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:23.505]                         if (muffled) 
[17:26:23.505]                           invokeRestart("muffleMessage")
[17:26:23.505]                       }
[17:26:23.505]                       else if (inherits(cond, "warning")) {
[17:26:23.505]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:23.505]                         if (muffled) 
[17:26:23.505]                           invokeRestart("muffleWarning")
[17:26:23.505]                       }
[17:26:23.505]                       else if (inherits(cond, "condition")) {
[17:26:23.505]                         if (!is.null(pattern)) {
[17:26:23.505]                           computeRestarts <- base::computeRestarts
[17:26:23.505]                           grepl <- base::grepl
[17:26:23.505]                           restarts <- computeRestarts(cond)
[17:26:23.505]                           for (restart in restarts) {
[17:26:23.505]                             name <- restart$name
[17:26:23.505]                             if (is.null(name)) 
[17:26:23.505]                               next
[17:26:23.505]                             if (!grepl(pattern, name)) 
[17:26:23.505]                               next
[17:26:23.505]                             invokeRestart(restart)
[17:26:23.505]                             muffled <- TRUE
[17:26:23.505]                             break
[17:26:23.505]                           }
[17:26:23.505]                         }
[17:26:23.505]                       }
[17:26:23.505]                       invisible(muffled)
[17:26:23.505]                     }
[17:26:23.505]                     muffleCondition(cond, pattern = "^muffle")
[17:26:23.505]                   }
[17:26:23.505]                 }
[17:26:23.505]                 else {
[17:26:23.505]                   if (TRUE) {
[17:26:23.505]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:23.505]                     {
[17:26:23.505]                       inherits <- base::inherits
[17:26:23.505]                       invokeRestart <- base::invokeRestart
[17:26:23.505]                       is.null <- base::is.null
[17:26:23.505]                       muffled <- FALSE
[17:26:23.505]                       if (inherits(cond, "message")) {
[17:26:23.505]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:23.505]                         if (muffled) 
[17:26:23.505]                           invokeRestart("muffleMessage")
[17:26:23.505]                       }
[17:26:23.505]                       else if (inherits(cond, "warning")) {
[17:26:23.505]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:23.505]                         if (muffled) 
[17:26:23.505]                           invokeRestart("muffleWarning")
[17:26:23.505]                       }
[17:26:23.505]                       else if (inherits(cond, "condition")) {
[17:26:23.505]                         if (!is.null(pattern)) {
[17:26:23.505]                           computeRestarts <- base::computeRestarts
[17:26:23.505]                           grepl <- base::grepl
[17:26:23.505]                           restarts <- computeRestarts(cond)
[17:26:23.505]                           for (restart in restarts) {
[17:26:23.505]                             name <- restart$name
[17:26:23.505]                             if (is.null(name)) 
[17:26:23.505]                               next
[17:26:23.505]                             if (!grepl(pattern, name)) 
[17:26:23.505]                               next
[17:26:23.505]                             invokeRestart(restart)
[17:26:23.505]                             muffled <- TRUE
[17:26:23.505]                             break
[17:26:23.505]                           }
[17:26:23.505]                         }
[17:26:23.505]                       }
[17:26:23.505]                       invisible(muffled)
[17:26:23.505]                     }
[17:26:23.505]                     muffleCondition(cond, pattern = "^muffle")
[17:26:23.505]                   }
[17:26:23.505]                 }
[17:26:23.505]             }
[17:26:23.505]         }))
[17:26:23.505]     }, error = function(ex) {
[17:26:23.505]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:23.505]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:23.505]                 ...future.rng), started = ...future.startTime, 
[17:26:23.505]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:23.505]             version = "1.8"), class = "FutureResult")
[17:26:23.505]     }, finally = {
[17:26:23.505]         if (!identical(...future.workdir, getwd())) 
[17:26:23.505]             setwd(...future.workdir)
[17:26:23.505]         {
[17:26:23.505]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:23.505]                 ...future.oldOptions$nwarnings <- NULL
[17:26:23.505]             }
[17:26:23.505]             base::options(...future.oldOptions)
[17:26:23.505]             if (.Platform$OS.type == "windows") {
[17:26:23.505]                 old_names <- names(...future.oldEnvVars)
[17:26:23.505]                 envs <- base::Sys.getenv()
[17:26:23.505]                 names <- names(envs)
[17:26:23.505]                 common <- intersect(names, old_names)
[17:26:23.505]                 added <- setdiff(names, old_names)
[17:26:23.505]                 removed <- setdiff(old_names, names)
[17:26:23.505]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:23.505]                   envs[common]]
[17:26:23.505]                 NAMES <- toupper(changed)
[17:26:23.505]                 args <- list()
[17:26:23.505]                 for (kk in seq_along(NAMES)) {
[17:26:23.505]                   name <- changed[[kk]]
[17:26:23.505]                   NAME <- NAMES[[kk]]
[17:26:23.505]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:23.505]                     next
[17:26:23.505]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:23.505]                 }
[17:26:23.505]                 NAMES <- toupper(added)
[17:26:23.505]                 for (kk in seq_along(NAMES)) {
[17:26:23.505]                   name <- added[[kk]]
[17:26:23.505]                   NAME <- NAMES[[kk]]
[17:26:23.505]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:23.505]                     next
[17:26:23.505]                   args[[name]] <- ""
[17:26:23.505]                 }
[17:26:23.505]                 NAMES <- toupper(removed)
[17:26:23.505]                 for (kk in seq_along(NAMES)) {
[17:26:23.505]                   name <- removed[[kk]]
[17:26:23.505]                   NAME <- NAMES[[kk]]
[17:26:23.505]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:23.505]                     next
[17:26:23.505]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:23.505]                 }
[17:26:23.505]                 if (length(args) > 0) 
[17:26:23.505]                   base::do.call(base::Sys.setenv, args = args)
[17:26:23.505]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:23.505]             }
[17:26:23.505]             else {
[17:26:23.505]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:23.505]             }
[17:26:23.505]             {
[17:26:23.505]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:23.505]                   0L) {
[17:26:23.505]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:23.505]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:23.505]                   base::options(opts)
[17:26:23.505]                 }
[17:26:23.505]                 {
[17:26:23.505]                   {
[17:26:23.505]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:23.505]                     NULL
[17:26:23.505]                   }
[17:26:23.505]                   options(future.plan = NULL)
[17:26:23.505]                   if (is.na(NA_character_)) 
[17:26:23.505]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:23.505]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:23.505]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:23.505]                     .init = FALSE)
[17:26:23.505]                 }
[17:26:23.505]             }
[17:26:23.505]         }
[17:26:23.505]     })
[17:26:23.505]     if (TRUE) {
[17:26:23.505]         base::sink(type = "output", split = FALSE)
[17:26:23.505]         if (TRUE) {
[17:26:23.505]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:23.505]         }
[17:26:23.505]         else {
[17:26:23.505]             ...future.result["stdout"] <- base::list(NULL)
[17:26:23.505]         }
[17:26:23.505]         base::close(...future.stdout)
[17:26:23.505]         ...future.stdout <- NULL
[17:26:23.505]     }
[17:26:23.505]     ...future.result$conditions <- ...future.conditions
[17:26:23.505]     ...future.result$finished <- base::Sys.time()
[17:26:23.505]     ...future.result
[17:26:23.505] }
[17:26:23.589] MultisessionFuture started
[17:26:23.589] result() for ClusterFuture ...
[17:26:23.590] receiveMessageFromWorker() for ClusterFuture ...
[17:26:23.590] - Validating connection of MultisessionFuture
[17:26:23.641] - received message: FutureResult
[17:26:23.641] - Received FutureResult
[17:26:23.644] - Erased future from FutureRegistry
[17:26:23.644] result() for ClusterFuture ...
[17:26:23.644] - result already collected: FutureResult
[17:26:23.644] result() for ClusterFuture ... done
[17:26:23.645] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:23.645] result() for ClusterFuture ... done
[17:26:23.645] result() for ClusterFuture ...
[17:26:23.645] - result already collected: FutureResult
[17:26:23.645] result() for ClusterFuture ... done
[17:26:23.645] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:26:23.648] plan(): nbrOfWorkers() = 2


	demo(mandelbrot)
	---- ~~~~~~~~~~

> library("future")

> library("graphics")

> plot_what_is_done <- function(counts) {
+   for (kk in seq_along(counts)) {
+     f <- counts[[kk]]
+ 
+     ## Already plotted?
+     if (!inherits(f, "Future")) next
+ 
+     ## Not resolved?
+     if (!resolved(f)) next
+ 
+     message(sprintf("Plotting tile #%d of %d ...", kk, n))
+     counts[[kk]] <- value(f)
+     screen(kk)
+     plot(counts[[kk]])
+   }
+ 
+   counts
+ }

> ## Options
> region <- getOption("future.demo.mandelbrot.region", 1L)

> if (!is.list(region)) {
+   if (region == 1L) {
+     region <- list(xmid = -0.75, ymid = 0.0, side = 3.0)
+   } else if (region == 2L) {
+     region <- list(xmid = 0.283, ymid = -0.0095, side = 0.00026)
+   } else if (region == 3L) {
+     region <- list(xmid = 0.282989, ymid = -0.01, side = 3e-8)
+   }
+ }

> nrow <- getOption("future.demo.mandelbrot.nrow", 3L)

> resolution <- getOption("future.demo.mandelbrot.resolution", 400L)

> delay <- getOption("future.demo.mandelbrot.delay", interactive())

> if (isTRUE(delay)) {
+   delay <- function(counts) Sys.sleep(1.0)
+ } else if (!is.function(delay)) {
+   delay <- function(counts) {}
+ }

> ## Generate Mandelbrot tiles to be computed
> Cs <- mandelbrot_tiles(xmid = region$xmid, ymid = region$ymid,
+                        side = region$side, nrow = nrow,
+                        resolution = resolution)

> if (interactive()) {
+   dev.new()
+   plot.new()
+   split.screen(dim(Cs))
+   for (ii in seq_along(Cs)) {
+     screen(ii)
+     par(mar = c(0, 0, 0, 0))
+     text(x = 1 / 2, y = 1 / 2, sprintf("Future #%d\nunresolved", ii), cex = 2)
+   }
+ } else {
+   split.screen(dim(Cs))
+ }
[1] 5 6 7 8

> ## Create all Mandelbrot tiles via lazy futures
> n <- length(Cs)

> message(sprintf("Creating %d Mandelbrot tiles:", n), appendLF = FALSE)
Creating 4 Mandelbrot tiles:
> counts <- lapply(seq_along(Cs), FUN=function(ii) {
+   message(" ", ii, appendLF = FALSE)
+   C <- Cs[[ii]]
+   future({
+     message(sprintf("Calculating tile #%d of %d ...", ii, n), appendLF = FALSE)
+     fit <- mandelbrot(C)
+ 
+     ## Emulate slowness
+     delay(fit)
+ 
+     message(" done")
+     fit
+   }, lazy = TRUE)
+ })
 1[17:26:23.655] getGlobalsAndPackages() ...
[17:26:23.655] Searching for globals...
[17:26:23.659] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
[17:26:23.660] Searching for globals ... DONE
[17:26:23.660] Resolving globals: FALSE
[17:26:23.661] The total size of the 4 globals is 14.24 KiB (14584 bytes)
[17:26:23.661] The total size of the 4 globals exported for future expression ('{; message(sprintf("Calculating tile #%d of %d ...", ii, n),; appendLF = FALSE); fit <- mandelbrot(C); delay(fit); message(" done"); fit; }') is 14.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'C' (10.72 KiB of class 'complex'), 'delay' (3.41 KiB of class 'function') and 'ii' (56 bytes of class 'numeric')
[17:26:23.662] - globals: [4] 'ii', 'n', 'C', 'delay'
[17:26:23.662] - packages: [1] 'future'
[17:26:23.662] getGlobalsAndPackages() ... DONE
 2[17:26:23.667] getGlobalsAndPackages() ...
[17:26:23.667] Searching for globals...
[17:26:23.671] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
[17:26:23.672] Searching for globals ... DONE
[17:26:23.672] Resolving globals: FALSE
[17:26:23.673] The total size of the 4 globals is 14.24 KiB (14584 bytes)
[17:26:23.673] The total size of the 4 globals exported for future expression ('{; message(sprintf("Calculating tile #%d of %d ...", ii, n),; appendLF = FALSE); fit <- mandelbrot(C); delay(fit); message(" done"); fit; }') is 14.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'C' (10.72 KiB of class 'complex'), 'delay' (3.41 KiB of class 'function') and 'ii' (56 bytes of class 'numeric')
[17:26:23.673] - globals: [4] 'ii', 'n', 'C', 'delay'
[17:26:23.674] - packages: [1] 'future'
[17:26:23.674] getGlobalsAndPackages() ... DONE
 3[17:26:23.674] getGlobalsAndPackages() ...
[17:26:23.674] Searching for globals...
[17:26:23.679] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
[17:26:23.679] Searching for globals ... DONE
[17:26:23.679] Resolving globals: FALSE
[17:26:23.680] The total size of the 4 globals is 14.24 KiB (14584 bytes)
[17:26:23.681] The total size of the 4 globals exported for future expression ('{; message(sprintf("Calculating tile #%d of %d ...", ii, n),; appendLF = FALSE); fit <- mandelbrot(C); delay(fit); message(" done"); fit; }') is 14.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'C' (10.72 KiB of class 'complex'), 'delay' (3.41 KiB of class 'function') and 'ii' (56 bytes of class 'numeric')
[17:26:23.681] - globals: [4] 'ii', 'n', 'C', 'delay'
[17:26:23.681] - packages: [1] 'future'
[17:26:23.681] getGlobalsAndPackages() ... DONE
 4[17:26:23.682] getGlobalsAndPackages() ...
[17:26:23.682] Searching for globals...
[17:26:23.689] - globals found: [9] '{', 'message', 'sprintf', 'ii', 'n', '<-', 'mandelbrot', 'C', 'delay'
[17:26:23.689] Searching for globals ... DONE
[17:26:23.689] Resolving globals: FALSE
[17:26:23.690] The total size of the 4 globals is 14.24 KiB (14584 bytes)
[17:26:23.690] The total size of the 4 globals exported for future expression ('{; message(sprintf("Calculating tile #%d of %d ...", ii, n),; appendLF = FALSE); fit <- mandelbrot(C); delay(fit); message(" done"); fit; }') is 14.24 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). The three largest globals are 'C' (10.72 KiB of class 'complex'), 'delay' (3.41 KiB of class 'function') and 'ii' (56 bytes of class 'numeric')
[17:26:23.691] - globals: [4] 'ii', 'n', 'C', 'delay'
[17:26:23.691] - packages: [1] 'future'
[17:26:23.691] getGlobalsAndPackages() ... DONE

> message(".")
.

> ## Calculate and plot tiles
> repeat {
+   counts <- plot_what_is_done(counts)
+   if (!any(sapply(counts, FUN = inherits, "Future"))) break
+ }
[17:26:23.701] resolved() for 'Future' ...
[17:26:23.702] - state: 'created'
[17:26:23.702] - run: TRUE
[17:26:23.702] - run() ...
[17:26:23.702] run() for 'Future' ...
[17:26:23.702] - state: 'created'
[17:26:23.703] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:23.717] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:23.718] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:23.718]   - Field: 'node'
[17:26:23.718]   - Field: 'label'
[17:26:23.718]   - Field: 'local'
[17:26:23.718]   - Field: 'owner'
[17:26:23.718]   - Field: 'envir'
[17:26:23.719]   - Field: 'workers'
[17:26:23.719]   - Field: 'packages'
[17:26:23.719]   - Field: 'gc'
[17:26:23.719]   - Field: 'conditions'
[17:26:23.719]   - Field: 'persistent'
[17:26:23.720]   - Field: 'expr'
[17:26:23.720]   - Field: 'uuid'
[17:26:23.720]   - Field: 'seed'
[17:26:23.720]   - Field: 'version'
[17:26:23.720]   - Field: 'result'
[17:26:23.720]   - Field: 'asynchronous'
[17:26:23.721]   - Field: 'calls'
[17:26:23.721]   - Field: 'globals'
[17:26:23.721]   - Field: 'stdout'
[17:26:23.721]   - Field: 'earlySignal'
[17:26:23.721]   - Field: 'lazy'
[17:26:23.721]   - Field: 'state'
[17:26:23.722] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:23.722] - Launch lazy future ...
[17:26:23.722] Packages needed by the future expression (n = 1): 'future'
[17:26:23.722] Packages needed by future strategies (n = 0): <none>
[17:26:23.723] {
[17:26:23.723]     {
[17:26:23.723]         {
[17:26:23.723]             ...future.startTime <- base::Sys.time()
[17:26:23.723]             {
[17:26:23.723]                 {
[17:26:23.723]                   {
[17:26:23.723]                     {
[17:26:23.723]                       {
[17:26:23.723]                         base::local({
[17:26:23.723]                           has_future <- base::requireNamespace("future", 
[17:26:23.723]                             quietly = TRUE)
[17:26:23.723]                           if (has_future) {
[17:26:23.723]                             ns <- base::getNamespace("future")
[17:26:23.723]                             version <- ns[[".package"]][["version"]]
[17:26:23.723]                             if (is.null(version)) 
[17:26:23.723]                               version <- utils::packageVersion("future")
[17:26:23.723]                           }
[17:26:23.723]                           else {
[17:26:23.723]                             version <- NULL
[17:26:23.723]                           }
[17:26:23.723]                           if (!has_future || version < "1.8.0") {
[17:26:23.723]                             info <- base::c(r_version = base::gsub("R version ", 
[17:26:23.723]                               "", base::R.version$version.string), 
[17:26:23.723]                               platform = base::sprintf("%s (%s-bit)", 
[17:26:23.723]                                 base::R.version$platform, 8 * 
[17:26:23.723]                                   base::.Machine$sizeof.pointer), 
[17:26:23.723]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:23.723]                                 "release", "version")], collapse = " "), 
[17:26:23.723]                               hostname = base::Sys.info()[["nodename"]])
[17:26:23.723]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:26:23.723]                               info)
[17:26:23.723]                             info <- base::paste(info, collapse = "; ")
[17:26:23.723]                             if (!has_future) {
[17:26:23.723]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:23.723]                                 info)
[17:26:23.723]                             }
[17:26:23.723]                             else {
[17:26:23.723]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:23.723]                                 info, version)
[17:26:23.723]                             }
[17:26:23.723]                             base::stop(msg)
[17:26:23.723]                           }
[17:26:23.723]                         })
[17:26:23.723]                       }
[17:26:23.723]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:23.723]                       base::options(mc.cores = 1L)
[17:26:23.723]                     }
[17:26:23.723]                     base::local({
[17:26:23.723]                       for (pkg in "future") {
[17:26:23.723]                         base::loadNamespace(pkg)
[17:26:23.723]                         base::library(pkg, character.only = TRUE)
[17:26:23.723]                       }
[17:26:23.723]                     })
[17:26:23.723]                   }
[17:26:23.723]                   ...future.strategy.old <- future::plan("list")
[17:26:23.723]                   options(future.plan = NULL)
[17:26:23.723]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:23.723]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:23.723]                 }
[17:26:23.723]                 ...future.workdir <- getwd()
[17:26:23.723]             }
[17:26:23.723]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:23.723]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:23.723]         }
[17:26:23.723]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:23.723]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:23.723]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:23.723]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:23.723]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:23.723]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:23.723]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:23.723]             base::names(...future.oldOptions))
[17:26:23.723]     }
[17:26:23.723]     if (FALSE) {
[17:26:23.723]     }
[17:26:23.723]     else {
[17:26:23.723]         if (TRUE) {
[17:26:23.723]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:23.723]                 open = "w")
[17:26:23.723]         }
[17:26:23.723]         else {
[17:26:23.723]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:23.723]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:23.723]         }
[17:26:23.723]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:23.723]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:23.723]             base::sink(type = "output", split = FALSE)
[17:26:23.723]             base::close(...future.stdout)
[17:26:23.723]         }, add = TRUE)
[17:26:23.723]     }
[17:26:23.723]     ...future.frame <- base::sys.nframe()
[17:26:23.723]     ...future.conditions <- base::list()
[17:26:23.723]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:23.723]     if (FALSE) {
[17:26:23.723]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:23.723]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:23.723]     }
[17:26:23.723]     ...future.result <- base::tryCatch({
[17:26:23.723]         base::withCallingHandlers({
[17:26:23.723]             ...future.value <- base::withVisible(base::local({
[17:26:23.723]                 ...future.makeSendCondition <- base::local({
[17:26:23.723]                   sendCondition <- NULL
[17:26:23.723]                   function(frame = 1L) {
[17:26:23.723]                     if (is.function(sendCondition)) 
[17:26:23.723]                       return(sendCondition)
[17:26:23.723]                     ns <- getNamespace("parallel")
[17:26:23.723]                     if (exists("sendData", mode = "function", 
[17:26:23.723]                       envir = ns)) {
[17:26:23.723]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:23.723]                         envir = ns)
[17:26:23.723]                       envir <- sys.frame(frame)
[17:26:23.723]                       master <- NULL
[17:26:23.723]                       while (!identical(envir, .GlobalEnv) && 
[17:26:23.723]                         !identical(envir, emptyenv())) {
[17:26:23.723]                         if (exists("master", mode = "list", envir = envir, 
[17:26:23.723]                           inherits = FALSE)) {
[17:26:23.723]                           master <- get("master", mode = "list", 
[17:26:23.723]                             envir = envir, inherits = FALSE)
[17:26:23.723]                           if (inherits(master, c("SOCKnode", 
[17:26:23.723]                             "SOCK0node"))) {
[17:26:23.723]                             sendCondition <<- function(cond) {
[17:26:23.723]                               data <- list(type = "VALUE", value = cond, 
[17:26:23.723]                                 success = TRUE)
[17:26:23.723]                               parallel_sendData(master, data)
[17:26:23.723]                             }
[17:26:23.723]                             return(sendCondition)
[17:26:23.723]                           }
[17:26:23.723]                         }
[17:26:23.723]                         frame <- frame + 1L
[17:26:23.723]                         envir <- sys.frame(frame)
[17:26:23.723]                       }
[17:26:23.723]                     }
[17:26:23.723]                     sendCondition <<- function(cond) NULL
[17:26:23.723]                   }
[17:26:23.723]                 })
[17:26:23.723]                 withCallingHandlers({
[17:26:23.723]                   {
[17:26:23.723]                     message(sprintf("Calculating tile #%d of %d ...", 
[17:26:23.723]                       ii, n), appendLF = FALSE)
[17:26:23.723]                     fit <- mandelbrot(C)
[17:26:23.723]                     delay(fit)
[17:26:23.723]                     message(" done")
[17:26:23.723]                     fit
[17:26:23.723]                   }
[17:26:23.723]                 }, immediateCondition = function(cond) {
[17:26:23.723]                   sendCondition <- ...future.makeSendCondition()
[17:26:23.723]                   sendCondition(cond)
[17:26:23.723]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:23.723]                   {
[17:26:23.723]                     inherits <- base::inherits
[17:26:23.723]                     invokeRestart <- base::invokeRestart
[17:26:23.723]                     is.null <- base::is.null
[17:26:23.723]                     muffled <- FALSE
[17:26:23.723]                     if (inherits(cond, "message")) {
[17:26:23.723]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:23.723]                       if (muffled) 
[17:26:23.723]                         invokeRestart("muffleMessage")
[17:26:23.723]                     }
[17:26:23.723]                     else if (inherits(cond, "warning")) {
[17:26:23.723]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:23.723]                       if (muffled) 
[17:26:23.723]                         invokeRestart("muffleWarning")
[17:26:23.723]                     }
[17:26:23.723]                     else if (inherits(cond, "condition")) {
[17:26:23.723]                       if (!is.null(pattern)) {
[17:26:23.723]                         computeRestarts <- base::computeRestarts
[17:26:23.723]                         grepl <- base::grepl
[17:26:23.723]                         restarts <- computeRestarts(cond)
[17:26:23.723]                         for (restart in restarts) {
[17:26:23.723]                           name <- restart$name
[17:26:23.723]                           if (is.null(name)) 
[17:26:23.723]                             next
[17:26:23.723]                           if (!grepl(pattern, name)) 
[17:26:23.723]                             next
[17:26:23.723]                           invokeRestart(restart)
[17:26:23.723]                           muffled <- TRUE
[17:26:23.723]                           break
[17:26:23.723]                         }
[17:26:23.723]                       }
[17:26:23.723]                     }
[17:26:23.723]                     invisible(muffled)
[17:26:23.723]                   }
[17:26:23.723]                   muffleCondition(cond)
[17:26:23.723]                 })
[17:26:23.723]             }))
[17:26:23.723]             future::FutureResult(value = ...future.value$value, 
[17:26:23.723]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:23.723]                   ...future.rng), globalenv = if (FALSE) 
[17:26:23.723]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:23.723]                     ...future.globalenv.names))
[17:26:23.723]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:23.723]         }, condition = base::local({
[17:26:23.723]             c <- base::c
[17:26:23.723]             inherits <- base::inherits
[17:26:23.723]             invokeRestart <- base::invokeRestart
[17:26:23.723]             length <- base::length
[17:26:23.723]             list <- base::list
[17:26:23.723]             seq.int <- base::seq.int
[17:26:23.723]             signalCondition <- base::signalCondition
[17:26:23.723]             sys.calls <- base::sys.calls
[17:26:23.723]             `[[` <- base::`[[`
[17:26:23.723]             `+` <- base::`+`
[17:26:23.723]             `<<-` <- base::`<<-`
[17:26:23.723]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:23.723]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:23.723]                   3L)]
[17:26:23.723]             }
[17:26:23.723]             function(cond) {
[17:26:23.723]                 is_error <- inherits(cond, "error")
[17:26:23.723]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:23.723]                   NULL)
[17:26:23.723]                 if (is_error) {
[17:26:23.723]                   sessionInformation <- function() {
[17:26:23.723]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:23.723]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:23.723]                       search = base::search(), system = base::Sys.info())
[17:26:23.723]                   }
[17:26:23.723]                   ...future.conditions[[length(...future.conditions) + 
[17:26:23.723]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:23.723]                     cond$call), session = sessionInformation(), 
[17:26:23.723]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:23.723]                   signalCondition(cond)
[17:26:23.723]                 }
[17:26:23.723]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:23.723]                 "immediateCondition"))) {
[17:26:23.723]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:23.723]                   ...future.conditions[[length(...future.conditions) + 
[17:26:23.723]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:23.723]                   if (TRUE && !signal) {
[17:26:23.723]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:23.723]                     {
[17:26:23.723]                       inherits <- base::inherits
[17:26:23.723]                       invokeRestart <- base::invokeRestart
[17:26:23.723]                       is.null <- base::is.null
[17:26:23.723]                       muffled <- FALSE
[17:26:23.723]                       if (inherits(cond, "message")) {
[17:26:23.723]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:23.723]                         if (muffled) 
[17:26:23.723]                           invokeRestart("muffleMessage")
[17:26:23.723]                       }
[17:26:23.723]                       else if (inherits(cond, "warning")) {
[17:26:23.723]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:23.723]                         if (muffled) 
[17:26:23.723]                           invokeRestart("muffleWarning")
[17:26:23.723]                       }
[17:26:23.723]                       else if (inherits(cond, "condition")) {
[17:26:23.723]                         if (!is.null(pattern)) {
[17:26:23.723]                           computeRestarts <- base::computeRestarts
[17:26:23.723]                           grepl <- base::grepl
[17:26:23.723]                           restarts <- computeRestarts(cond)
[17:26:23.723]                           for (restart in restarts) {
[17:26:23.723]                             name <- restart$name
[17:26:23.723]                             if (is.null(name)) 
[17:26:23.723]                               next
[17:26:23.723]                             if (!grepl(pattern, name)) 
[17:26:23.723]                               next
[17:26:23.723]                             invokeRestart(restart)
[17:26:23.723]                             muffled <- TRUE
[17:26:23.723]                             break
[17:26:23.723]                           }
[17:26:23.723]                         }
[17:26:23.723]                       }
[17:26:23.723]                       invisible(muffled)
[17:26:23.723]                     }
[17:26:23.723]                     muffleCondition(cond, pattern = "^muffle")
[17:26:23.723]                   }
[17:26:23.723]                 }
[17:26:23.723]                 else {
[17:26:23.723]                   if (TRUE) {
[17:26:23.723]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:23.723]                     {
[17:26:23.723]                       inherits <- base::inherits
[17:26:23.723]                       invokeRestart <- base::invokeRestart
[17:26:23.723]                       is.null <- base::is.null
[17:26:23.723]                       muffled <- FALSE
[17:26:23.723]                       if (inherits(cond, "message")) {
[17:26:23.723]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:23.723]                         if (muffled) 
[17:26:23.723]                           invokeRestart("muffleMessage")
[17:26:23.723]                       }
[17:26:23.723]                       else if (inherits(cond, "warning")) {
[17:26:23.723]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:23.723]                         if (muffled) 
[17:26:23.723]                           invokeRestart("muffleWarning")
[17:26:23.723]                       }
[17:26:23.723]                       else if (inherits(cond, "condition")) {
[17:26:23.723]                         if (!is.null(pattern)) {
[17:26:23.723]                           computeRestarts <- base::computeRestarts
[17:26:23.723]                           grepl <- base::grepl
[17:26:23.723]                           restarts <- computeRestarts(cond)
[17:26:23.723]                           for (restart in restarts) {
[17:26:23.723]                             name <- restart$name
[17:26:23.723]                             if (is.null(name)) 
[17:26:23.723]                               next
[17:26:23.723]                             if (!grepl(pattern, name)) 
[17:26:23.723]                               next
[17:26:23.723]                             invokeRestart(restart)
[17:26:23.723]                             muffled <- TRUE
[17:26:23.723]                             break
[17:26:23.723]                           }
[17:26:23.723]                         }
[17:26:23.723]                       }
[17:26:23.723]                       invisible(muffled)
[17:26:23.723]                     }
[17:26:23.723]                     muffleCondition(cond, pattern = "^muffle")
[17:26:23.723]                   }
[17:26:23.723]                 }
[17:26:23.723]             }
[17:26:23.723]         }))
[17:26:23.723]     }, error = function(ex) {
[17:26:23.723]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:23.723]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:23.723]                 ...future.rng), started = ...future.startTime, 
[17:26:23.723]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:23.723]             version = "1.8"), class = "FutureResult")
[17:26:23.723]     }, finally = {
[17:26:23.723]         if (!identical(...future.workdir, getwd())) 
[17:26:23.723]             setwd(...future.workdir)
[17:26:23.723]         {
[17:26:23.723]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:23.723]                 ...future.oldOptions$nwarnings <- NULL
[17:26:23.723]             }
[17:26:23.723]             base::options(...future.oldOptions)
[17:26:23.723]             if (.Platform$OS.type == "windows") {
[17:26:23.723]                 old_names <- names(...future.oldEnvVars)
[17:26:23.723]                 envs <- base::Sys.getenv()
[17:26:23.723]                 names <- names(envs)
[17:26:23.723]                 common <- intersect(names, old_names)
[17:26:23.723]                 added <- setdiff(names, old_names)
[17:26:23.723]                 removed <- setdiff(old_names, names)
[17:26:23.723]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:23.723]                   envs[common]]
[17:26:23.723]                 NAMES <- toupper(changed)
[17:26:23.723]                 args <- list()
[17:26:23.723]                 for (kk in seq_along(NAMES)) {
[17:26:23.723]                   name <- changed[[kk]]
[17:26:23.723]                   NAME <- NAMES[[kk]]
[17:26:23.723]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:23.723]                     next
[17:26:23.723]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:23.723]                 }
[17:26:23.723]                 NAMES <- toupper(added)
[17:26:23.723]                 for (kk in seq_along(NAMES)) {
[17:26:23.723]                   name <- added[[kk]]
[17:26:23.723]                   NAME <- NAMES[[kk]]
[17:26:23.723]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:23.723]                     next
[17:26:23.723]                   args[[name]] <- ""
[17:26:23.723]                 }
[17:26:23.723]                 NAMES <- toupper(removed)
[17:26:23.723]                 for (kk in seq_along(NAMES)) {
[17:26:23.723]                   name <- removed[[kk]]
[17:26:23.723]                   NAME <- NAMES[[kk]]
[17:26:23.723]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:23.723]                     next
[17:26:23.723]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:23.723]                 }
[17:26:23.723]                 if (length(args) > 0) 
[17:26:23.723]                   base::do.call(base::Sys.setenv, args = args)
[17:26:23.723]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:23.723]             }
[17:26:23.723]             else {
[17:26:23.723]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:23.723]             }
[17:26:23.723]             {
[17:26:23.723]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:23.723]                   0L) {
[17:26:23.723]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:23.723]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:23.723]                   base::options(opts)
[17:26:23.723]                 }
[17:26:23.723]                 {
[17:26:23.723]                   {
[17:26:23.723]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:23.723]                     NULL
[17:26:23.723]                   }
[17:26:23.723]                   options(future.plan = NULL)
[17:26:23.723]                   if (is.na(NA_character_)) 
[17:26:23.723]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:23.723]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:23.723]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:23.723]                     .init = FALSE)
[17:26:23.723]                 }
[17:26:23.723]             }
[17:26:23.723]         }
[17:26:23.723]     })
[17:26:23.723]     if (TRUE) {
[17:26:23.723]         base::sink(type = "output", split = FALSE)
[17:26:23.723]         if (TRUE) {
[17:26:23.723]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:23.723]         }
[17:26:23.723]         else {
[17:26:23.723]             ...future.result["stdout"] <- base::list(NULL)
[17:26:23.723]         }
[17:26:23.723]         base::close(...future.stdout)
[17:26:23.723]         ...future.stdout <- NULL
[17:26:23.723]     }
[17:26:23.723]     ...future.result$conditions <- ...future.conditions
[17:26:23.723]     ...future.result$finished <- base::Sys.time()
[17:26:23.723]     ...future.result
[17:26:23.723] }
[17:26:23.728] Exporting 4 global objects (14.24 KiB) to cluster node #1 ...
[17:26:23.729] Exporting 'ii' (56 bytes) to cluster node #1 ...
[17:26:23.729] Exporting 'ii' (56 bytes) to cluster node #1 ... DONE
[17:26:23.729] Exporting 'n' (56 bytes) to cluster node #1 ...
[17:26:23.730] Exporting 'n' (56 bytes) to cluster node #1 ... DONE
[17:26:23.730] Exporting 'C' (10.72 KiB) to cluster node #1 ...
[17:26:23.730] Exporting 'C' (10.72 KiB) to cluster node #1 ... DONE
[17:26:23.731] Exporting 'delay' (3.41 KiB) to cluster node #1 ...
[17:26:23.731] Exporting 'delay' (3.41 KiB) to cluster node #1 ... DONE
[17:26:23.732] Exporting 4 global objects (14.24 KiB) to cluster node #1 ... DONE
[17:26:23.732] MultisessionFuture started
[17:26:23.732] - Launch lazy future ... done
[17:26:23.733] run() for 'MultisessionFuture' ... done
[17:26:23.733] - run() ... done
[17:26:23.733] - resolved() ...
[17:26:23.771] receiveMessageFromWorker() for ClusterFuture ...
[17:26:23.771] - Validating connection of MultisessionFuture
[17:26:23.772] - received message: FutureResult
[17:26:23.772] - Received FutureResult
[17:26:23.772] - Erased future from FutureRegistry
[17:26:23.772] result() for ClusterFuture ...
[17:26:23.772] - result already collected: FutureResult
[17:26:23.773] result() for ClusterFuture ... done
[17:26:23.773] signalConditions() ...
[17:26:23.773]  - include = 'immediateCondition'
[17:26:23.773]  - exclude = 
[17:26:23.773]  - resignal = FALSE
[17:26:23.773]  - Number of conditions: 2
[17:26:23.773] signalConditions() ... done
[17:26:23.774] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:23.774] - resolved: TRUE
[17:26:23.774] - resolved() ... done
[17:26:23.774] resolved() for 'MultisessionFuture' ... done
Plotting tile #1 of 4 ...
[17:26:23.774] result() for ClusterFuture ...
[17:26:23.775] - result already collected: FutureResult
[17:26:23.775] result() for ClusterFuture ... done
[17:26:23.775] result() for ClusterFuture ...
[17:26:23.775] - result already collected: FutureResult
[17:26:23.775] result() for ClusterFuture ... done
[17:26:23.775] signalConditions() ...
[17:26:23.776]  - include = 'immediateCondition'
[17:26:23.776]  - exclude = 
[17:26:23.776]  - resignal = FALSE
[17:26:23.776]  - Number of conditions: 2
[17:26:23.776] signalConditions() ... done
[17:26:23.776] Future state: 'finished'
[17:26:23.777] result() for ClusterFuture ...
[17:26:23.777] - result already collected: FutureResult
[17:26:23.777] result() for ClusterFuture ... done
[17:26:23.777] signalConditions() ...
[17:26:23.777]  - include = 'condition'
[17:26:23.777]  - exclude = 'immediateCondition'
[17:26:23.778]  - resignal = TRUE
[17:26:23.778]  - Number of conditions: 2
[17:26:23.778]  - Condition #1: 'simpleMessage', 'message', 'condition'
Calculating tile #1 of 4 ...[17:26:23.778]  - Condition #2: 'simpleMessage', 'message', 'condition'
 done
[17:26:23.778] signalConditions() ... done
[17:26:23.779] resolved() for 'Future' ...
[17:26:23.779] - state: 'created'
[17:26:23.780] - run: TRUE
[17:26:23.780] - run() ...
[17:26:23.780] run() for 'Future' ...
[17:26:23.780] - state: 'created'
[17:26:23.780] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:23.795] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:23.795] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:23.795]   - Field: 'node'
[17:26:23.796]   - Field: 'label'
[17:26:23.796]   - Field: 'local'
[17:26:23.796]   - Field: 'owner'
[17:26:23.796]   - Field: 'envir'
[17:26:23.796]   - Field: 'workers'
[17:26:23.796]   - Field: 'packages'
[17:26:23.797]   - Field: 'gc'
[17:26:23.797]   - Field: 'conditions'
[17:26:23.797]   - Field: 'persistent'
[17:26:23.797]   - Field: 'expr'
[17:26:23.797]   - Field: 'uuid'
[17:26:23.798]   - Field: 'seed'
[17:26:23.798]   - Field: 'version'
[17:26:23.798]   - Field: 'result'
[17:26:23.798]   - Field: 'asynchronous'
[17:26:23.798]   - Field: 'calls'
[17:26:23.798]   - Field: 'globals'
[17:26:23.799]   - Field: 'stdout'
[17:26:23.799]   - Field: 'earlySignal'
[17:26:23.799]   - Field: 'lazy'
[17:26:23.799]   - Field: 'state'
[17:26:23.799] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:23.799] - Launch lazy future ...
[17:26:23.800] Packages needed by the future expression (n = 1): 'future'
[17:26:23.800] Packages needed by future strategies (n = 0): <none>
[17:26:23.801] {
[17:26:23.801]     {
[17:26:23.801]         {
[17:26:23.801]             ...future.startTime <- base::Sys.time()
[17:26:23.801]             {
[17:26:23.801]                 {
[17:26:23.801]                   {
[17:26:23.801]                     {
[17:26:23.801]                       {
[17:26:23.801]                         base::local({
[17:26:23.801]                           has_future <- base::requireNamespace("future", 
[17:26:23.801]                             quietly = TRUE)
[17:26:23.801]                           if (has_future) {
[17:26:23.801]                             ns <- base::getNamespace("future")
[17:26:23.801]                             version <- ns[[".package"]][["version"]]
[17:26:23.801]                             if (is.null(version)) 
[17:26:23.801]                               version <- utils::packageVersion("future")
[17:26:23.801]                           }
[17:26:23.801]                           else {
[17:26:23.801]                             version <- NULL
[17:26:23.801]                           }
[17:26:23.801]                           if (!has_future || version < "1.8.0") {
[17:26:23.801]                             info <- base::c(r_version = base::gsub("R version ", 
[17:26:23.801]                               "", base::R.version$version.string), 
[17:26:23.801]                               platform = base::sprintf("%s (%s-bit)", 
[17:26:23.801]                                 base::R.version$platform, 8 * 
[17:26:23.801]                                   base::.Machine$sizeof.pointer), 
[17:26:23.801]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:23.801]                                 "release", "version")], collapse = " "), 
[17:26:23.801]                               hostname = base::Sys.info()[["nodename"]])
[17:26:23.801]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:26:23.801]                               info)
[17:26:23.801]                             info <- base::paste(info, collapse = "; ")
[17:26:23.801]                             if (!has_future) {
[17:26:23.801]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:23.801]                                 info)
[17:26:23.801]                             }
[17:26:23.801]                             else {
[17:26:23.801]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:23.801]                                 info, version)
[17:26:23.801]                             }
[17:26:23.801]                             base::stop(msg)
[17:26:23.801]                           }
[17:26:23.801]                         })
[17:26:23.801]                       }
[17:26:23.801]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:23.801]                       base::options(mc.cores = 1L)
[17:26:23.801]                     }
[17:26:23.801]                     base::local({
[17:26:23.801]                       for (pkg in "future") {
[17:26:23.801]                         base::loadNamespace(pkg)
[17:26:23.801]                         base::library(pkg, character.only = TRUE)
[17:26:23.801]                       }
[17:26:23.801]                     })
[17:26:23.801]                   }
[17:26:23.801]                   ...future.strategy.old <- future::plan("list")
[17:26:23.801]                   options(future.plan = NULL)
[17:26:23.801]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:23.801]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:23.801]                 }
[17:26:23.801]                 ...future.workdir <- getwd()
[17:26:23.801]             }
[17:26:23.801]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:23.801]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:23.801]         }
[17:26:23.801]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:23.801]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:23.801]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:23.801]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:23.801]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:23.801]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:23.801]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:23.801]             base::names(...future.oldOptions))
[17:26:23.801]     }
[17:26:23.801]     if (FALSE) {
[17:26:23.801]     }
[17:26:23.801]     else {
[17:26:23.801]         if (TRUE) {
[17:26:23.801]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:23.801]                 open = "w")
[17:26:23.801]         }
[17:26:23.801]         else {
[17:26:23.801]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:23.801]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:23.801]         }
[17:26:23.801]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:23.801]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:23.801]             base::sink(type = "output", split = FALSE)
[17:26:23.801]             base::close(...future.stdout)
[17:26:23.801]         }, add = TRUE)
[17:26:23.801]     }
[17:26:23.801]     ...future.frame <- base::sys.nframe()
[17:26:23.801]     ...future.conditions <- base::list()
[17:26:23.801]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:23.801]     if (FALSE) {
[17:26:23.801]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:23.801]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:23.801]     }
[17:26:23.801]     ...future.result <- base::tryCatch({
[17:26:23.801]         base::withCallingHandlers({
[17:26:23.801]             ...future.value <- base::withVisible(base::local({
[17:26:23.801]                 ...future.makeSendCondition <- base::local({
[17:26:23.801]                   sendCondition <- NULL
[17:26:23.801]                   function(frame = 1L) {
[17:26:23.801]                     if (is.function(sendCondition)) 
[17:26:23.801]                       return(sendCondition)
[17:26:23.801]                     ns <- getNamespace("parallel")
[17:26:23.801]                     if (exists("sendData", mode = "function", 
[17:26:23.801]                       envir = ns)) {
[17:26:23.801]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:23.801]                         envir = ns)
[17:26:23.801]                       envir <- sys.frame(frame)
[17:26:23.801]                       master <- NULL
[17:26:23.801]                       while (!identical(envir, .GlobalEnv) && 
[17:26:23.801]                         !identical(envir, emptyenv())) {
[17:26:23.801]                         if (exists("master", mode = "list", envir = envir, 
[17:26:23.801]                           inherits = FALSE)) {
[17:26:23.801]                           master <- get("master", mode = "list", 
[17:26:23.801]                             envir = envir, inherits = FALSE)
[17:26:23.801]                           if (inherits(master, c("SOCKnode", 
[17:26:23.801]                             "SOCK0node"))) {
[17:26:23.801]                             sendCondition <<- function(cond) {
[17:26:23.801]                               data <- list(type = "VALUE", value = cond, 
[17:26:23.801]                                 success = TRUE)
[17:26:23.801]                               parallel_sendData(master, data)
[17:26:23.801]                             }
[17:26:23.801]                             return(sendCondition)
[17:26:23.801]                           }
[17:26:23.801]                         }
[17:26:23.801]                         frame <- frame + 1L
[17:26:23.801]                         envir <- sys.frame(frame)
[17:26:23.801]                       }
[17:26:23.801]                     }
[17:26:23.801]                     sendCondition <<- function(cond) NULL
[17:26:23.801]                   }
[17:26:23.801]                 })
[17:26:23.801]                 withCallingHandlers({
[17:26:23.801]                   {
[17:26:23.801]                     message(sprintf("Calculating tile #%d of %d ...", 
[17:26:23.801]                       ii, n), appendLF = FALSE)
[17:26:23.801]                     fit <- mandelbrot(C)
[17:26:23.801]                     delay(fit)
[17:26:23.801]                     message(" done")
[17:26:23.801]                     fit
[17:26:23.801]                   }
[17:26:23.801]                 }, immediateCondition = function(cond) {
[17:26:23.801]                   sendCondition <- ...future.makeSendCondition()
[17:26:23.801]                   sendCondition(cond)
[17:26:23.801]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:23.801]                   {
[17:26:23.801]                     inherits <- base::inherits
[17:26:23.801]                     invokeRestart <- base::invokeRestart
[17:26:23.801]                     is.null <- base::is.null
[17:26:23.801]                     muffled <- FALSE
[17:26:23.801]                     if (inherits(cond, "message")) {
[17:26:23.801]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:23.801]                       if (muffled) 
[17:26:23.801]                         invokeRestart("muffleMessage")
[17:26:23.801]                     }
[17:26:23.801]                     else if (inherits(cond, "warning")) {
[17:26:23.801]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:23.801]                       if (muffled) 
[17:26:23.801]                         invokeRestart("muffleWarning")
[17:26:23.801]                     }
[17:26:23.801]                     else if (inherits(cond, "condition")) {
[17:26:23.801]                       if (!is.null(pattern)) {
[17:26:23.801]                         computeRestarts <- base::computeRestarts
[17:26:23.801]                         grepl <- base::grepl
[17:26:23.801]                         restarts <- computeRestarts(cond)
[17:26:23.801]                         for (restart in restarts) {
[17:26:23.801]                           name <- restart$name
[17:26:23.801]                           if (is.null(name)) 
[17:26:23.801]                             next
[17:26:23.801]                           if (!grepl(pattern, name)) 
[17:26:23.801]                             next
[17:26:23.801]                           invokeRestart(restart)
[17:26:23.801]                           muffled <- TRUE
[17:26:23.801]                           break
[17:26:23.801]                         }
[17:26:23.801]                       }
[17:26:23.801]                     }
[17:26:23.801]                     invisible(muffled)
[17:26:23.801]                   }
[17:26:23.801]                   muffleCondition(cond)
[17:26:23.801]                 })
[17:26:23.801]             }))
[17:26:23.801]             future::FutureResult(value = ...future.value$value, 
[17:26:23.801]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:23.801]                   ...future.rng), globalenv = if (FALSE) 
[17:26:23.801]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:23.801]                     ...future.globalenv.names))
[17:26:23.801]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:23.801]         }, condition = base::local({
[17:26:23.801]             c <- base::c
[17:26:23.801]             inherits <- base::inherits
[17:26:23.801]             invokeRestart <- base::invokeRestart
[17:26:23.801]             length <- base::length
[17:26:23.801]             list <- base::list
[17:26:23.801]             seq.int <- base::seq.int
[17:26:23.801]             signalCondition <- base::signalCondition
[17:26:23.801]             sys.calls <- base::sys.calls
[17:26:23.801]             `[[` <- base::`[[`
[17:26:23.801]             `+` <- base::`+`
[17:26:23.801]             `<<-` <- base::`<<-`
[17:26:23.801]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:23.801]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:23.801]                   3L)]
[17:26:23.801]             }
[17:26:23.801]             function(cond) {
[17:26:23.801]                 is_error <- inherits(cond, "error")
[17:26:23.801]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:23.801]                   NULL)
[17:26:23.801]                 if (is_error) {
[17:26:23.801]                   sessionInformation <- function() {
[17:26:23.801]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:23.801]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:23.801]                       search = base::search(), system = base::Sys.info())
[17:26:23.801]                   }
[17:26:23.801]                   ...future.conditions[[length(...future.conditions) + 
[17:26:23.801]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:23.801]                     cond$call), session = sessionInformation(), 
[17:26:23.801]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:23.801]                   signalCondition(cond)
[17:26:23.801]                 }
[17:26:23.801]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:23.801]                 "immediateCondition"))) {
[17:26:23.801]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:23.801]                   ...future.conditions[[length(...future.conditions) + 
[17:26:23.801]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:23.801]                   if (TRUE && !signal) {
[17:26:23.801]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:23.801]                     {
[17:26:23.801]                       inherits <- base::inherits
[17:26:23.801]                       invokeRestart <- base::invokeRestart
[17:26:23.801]                       is.null <- base::is.null
[17:26:23.801]                       muffled <- FALSE
[17:26:23.801]                       if (inherits(cond, "message")) {
[17:26:23.801]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:23.801]                         if (muffled) 
[17:26:23.801]                           invokeRestart("muffleMessage")
[17:26:23.801]                       }
[17:26:23.801]                       else if (inherits(cond, "warning")) {
[17:26:23.801]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:23.801]                         if (muffled) 
[17:26:23.801]                           invokeRestart("muffleWarning")
[17:26:23.801]                       }
[17:26:23.801]                       else if (inherits(cond, "condition")) {
[17:26:23.801]                         if (!is.null(pattern)) {
[17:26:23.801]                           computeRestarts <- base::computeRestarts
[17:26:23.801]                           grepl <- base::grepl
[17:26:23.801]                           restarts <- computeRestarts(cond)
[17:26:23.801]                           for (restart in restarts) {
[17:26:23.801]                             name <- restart$name
[17:26:23.801]                             if (is.null(name)) 
[17:26:23.801]                               next
[17:26:23.801]                             if (!grepl(pattern, name)) 
[17:26:23.801]                               next
[17:26:23.801]                             invokeRestart(restart)
[17:26:23.801]                             muffled <- TRUE
[17:26:23.801]                             break
[17:26:23.801]                           }
[17:26:23.801]                         }
[17:26:23.801]                       }
[17:26:23.801]                       invisible(muffled)
[17:26:23.801]                     }
[17:26:23.801]                     muffleCondition(cond, pattern = "^muffle")
[17:26:23.801]                   }
[17:26:23.801]                 }
[17:26:23.801]                 else {
[17:26:23.801]                   if (TRUE) {
[17:26:23.801]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:23.801]                     {
[17:26:23.801]                       inherits <- base::inherits
[17:26:23.801]                       invokeRestart <- base::invokeRestart
[17:26:23.801]                       is.null <- base::is.null
[17:26:23.801]                       muffled <- FALSE
[17:26:23.801]                       if (inherits(cond, "message")) {
[17:26:23.801]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:23.801]                         if (muffled) 
[17:26:23.801]                           invokeRestart("muffleMessage")
[17:26:23.801]                       }
[17:26:23.801]                       else if (inherits(cond, "warning")) {
[17:26:23.801]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:23.801]                         if (muffled) 
[17:26:23.801]                           invokeRestart("muffleWarning")
[17:26:23.801]                       }
[17:26:23.801]                       else if (inherits(cond, "condition")) {
[17:26:23.801]                         if (!is.null(pattern)) {
[17:26:23.801]                           computeRestarts <- base::computeRestarts
[17:26:23.801]                           grepl <- base::grepl
[17:26:23.801]                           restarts <- computeRestarts(cond)
[17:26:23.801]                           for (restart in restarts) {
[17:26:23.801]                             name <- restart$name
[17:26:23.801]                             if (is.null(name)) 
[17:26:23.801]                               next
[17:26:23.801]                             if (!grepl(pattern, name)) 
[17:26:23.801]                               next
[17:26:23.801]                             invokeRestart(restart)
[17:26:23.801]                             muffled <- TRUE
[17:26:23.801]                             break
[17:26:23.801]                           }
[17:26:23.801]                         }
[17:26:23.801]                       }
[17:26:23.801]                       invisible(muffled)
[17:26:23.801]                     }
[17:26:23.801]                     muffleCondition(cond, pattern = "^muffle")
[17:26:23.801]                   }
[17:26:23.801]                 }
[17:26:23.801]             }
[17:26:23.801]         }))
[17:26:23.801]     }, error = function(ex) {
[17:26:23.801]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:23.801]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:23.801]                 ...future.rng), started = ...future.startTime, 
[17:26:23.801]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:23.801]             version = "1.8"), class = "FutureResult")
[17:26:23.801]     }, finally = {
[17:26:23.801]         if (!identical(...future.workdir, getwd())) 
[17:26:23.801]             setwd(...future.workdir)
[17:26:23.801]         {
[17:26:23.801]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:23.801]                 ...future.oldOptions$nwarnings <- NULL
[17:26:23.801]             }
[17:26:23.801]             base::options(...future.oldOptions)
[17:26:23.801]             if (.Platform$OS.type == "windows") {
[17:26:23.801]                 old_names <- names(...future.oldEnvVars)
[17:26:23.801]                 envs <- base::Sys.getenv()
[17:26:23.801]                 names <- names(envs)
[17:26:23.801]                 common <- intersect(names, old_names)
[17:26:23.801]                 added <- setdiff(names, old_names)
[17:26:23.801]                 removed <- setdiff(old_names, names)
[17:26:23.801]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:23.801]                   envs[common]]
[17:26:23.801]                 NAMES <- toupper(changed)
[17:26:23.801]                 args <- list()
[17:26:23.801]                 for (kk in seq_along(NAMES)) {
[17:26:23.801]                   name <- changed[[kk]]
[17:26:23.801]                   NAME <- NAMES[[kk]]
[17:26:23.801]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:23.801]                     next
[17:26:23.801]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:23.801]                 }
[17:26:23.801]                 NAMES <- toupper(added)
[17:26:23.801]                 for (kk in seq_along(NAMES)) {
[17:26:23.801]                   name <- added[[kk]]
[17:26:23.801]                   NAME <- NAMES[[kk]]
[17:26:23.801]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:23.801]                     next
[17:26:23.801]                   args[[name]] <- ""
[17:26:23.801]                 }
[17:26:23.801]                 NAMES <- toupper(removed)
[17:26:23.801]                 for (kk in seq_along(NAMES)) {
[17:26:23.801]                   name <- removed[[kk]]
[17:26:23.801]                   NAME <- NAMES[[kk]]
[17:26:23.801]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:23.801]                     next
[17:26:23.801]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:23.801]                 }
[17:26:23.801]                 if (length(args) > 0) 
[17:26:23.801]                   base::do.call(base::Sys.setenv, args = args)
[17:26:23.801]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:23.801]             }
[17:26:23.801]             else {
[17:26:23.801]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:23.801]             }
[17:26:23.801]             {
[17:26:23.801]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:23.801]                   0L) {
[17:26:23.801]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:23.801]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:23.801]                   base::options(opts)
[17:26:23.801]                 }
[17:26:23.801]                 {
[17:26:23.801]                   {
[17:26:23.801]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:23.801]                     NULL
[17:26:23.801]                   }
[17:26:23.801]                   options(future.plan = NULL)
[17:26:23.801]                   if (is.na(NA_character_)) 
[17:26:23.801]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:23.801]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:23.801]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:23.801]                     .init = FALSE)
[17:26:23.801]                 }
[17:26:23.801]             }
[17:26:23.801]         }
[17:26:23.801]     })
[17:26:23.801]     if (TRUE) {
[17:26:23.801]         base::sink(type = "output", split = FALSE)
[17:26:23.801]         if (TRUE) {
[17:26:23.801]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:23.801]         }
[17:26:23.801]         else {
[17:26:23.801]             ...future.result["stdout"] <- base::list(NULL)
[17:26:23.801]         }
[17:26:23.801]         base::close(...future.stdout)
[17:26:23.801]         ...future.stdout <- NULL
[17:26:23.801]     }
[17:26:23.801]     ...future.result$conditions <- ...future.conditions
[17:26:23.801]     ...future.result$finished <- base::Sys.time()
[17:26:23.801]     ...future.result
[17:26:23.801] }
[17:26:23.806] Exporting 4 global objects (14.24 KiB) to cluster node #1 ...
[17:26:23.806] Exporting 'ii' (56 bytes) to cluster node #1 ...
[17:26:23.807] Exporting 'ii' (56 bytes) to cluster node #1 ... DONE
[17:26:23.807] Exporting 'n' (56 bytes) to cluster node #1 ...
[17:26:23.807] Exporting 'n' (56 bytes) to cluster node #1 ... DONE
[17:26:23.807] Exporting 'C' (10.72 KiB) to cluster node #1 ...
[17:26:23.808] Exporting 'C' (10.72 KiB) to cluster node #1 ... DONE
[17:26:23.808] Exporting 'delay' (3.41 KiB) to cluster node #1 ...
[17:26:23.809] Exporting 'delay' (3.41 KiB) to cluster node #1 ... DONE
[17:26:23.809] Exporting 4 global objects (14.24 KiB) to cluster node #1 ... DONE
[17:26:23.809] MultisessionFuture started
[17:26:23.810] - Launch lazy future ... done
[17:26:23.810] run() for 'MultisessionFuture' ... done
[17:26:23.810] - run() ... done
[17:26:23.810] - resolved() ...
[17:26:23.842] receiveMessageFromWorker() for ClusterFuture ...
[17:26:23.842] - Validating connection of MultisessionFuture
[17:26:23.842] - received message: FutureResult
[17:26:23.843] - Received FutureResult
[17:26:23.843] - Erased future from FutureRegistry
[17:26:23.843] result() for ClusterFuture ...
[17:26:23.843] - result already collected: FutureResult
[17:26:23.843] result() for ClusterFuture ... done
[17:26:23.843] signalConditions() ...
[17:26:23.844]  - include = 'immediateCondition'
[17:26:23.844]  - exclude = 
[17:26:23.844]  - resignal = FALSE
[17:26:23.844]  - Number of conditions: 2
[17:26:23.844] signalConditions() ... done
[17:26:23.844] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:23.845] - resolved: TRUE
[17:26:23.845] - resolved() ... done
[17:26:23.845] resolved() for 'MultisessionFuture' ... done
Plotting tile #2 of 4 ...
[17:26:23.845] result() for ClusterFuture ...
[17:26:23.845] - result already collected: FutureResult
[17:26:23.845] result() for ClusterFuture ... done
[17:26:23.846] result() for ClusterFuture ...
[17:26:23.846] - result already collected: FutureResult
[17:26:23.846] result() for ClusterFuture ... done
[17:26:23.846] signalConditions() ...
[17:26:23.846]  - include = 'immediateCondition'
[17:26:23.846]  - exclude = 
[17:26:23.847]  - resignal = FALSE
[17:26:23.847]  - Number of conditions: 2
[17:26:23.847] signalConditions() ... done
[17:26:23.847] Future state: 'finished'
[17:26:23.847] result() for ClusterFuture ...
[17:26:23.847] - result already collected: FutureResult
[17:26:23.848] result() for ClusterFuture ... done
[17:26:23.848] signalConditions() ...
[17:26:23.848]  - include = 'condition'
[17:26:23.848]  - exclude = 'immediateCondition'
[17:26:23.848]  - resignal = TRUE
[17:26:23.848]  - Number of conditions: 2
[17:26:23.849]  - Condition #1: 'simpleMessage', 'message', 'condition'
Calculating tile #2 of 4 ...[17:26:23.849]  - Condition #2: 'simpleMessage', 'message', 'condition'
 done
[17:26:23.849] signalConditions() ... done
[17:26:23.850] resolved() for 'Future' ...
[17:26:23.850] - state: 'created'
[17:26:23.850] - run: TRUE
[17:26:23.850] - run() ...
[17:26:23.851] run() for 'Future' ...
[17:26:23.851] - state: 'created'
[17:26:23.851] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:23.865] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:23.865] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:23.865]   - Field: 'node'
[17:26:23.865]   - Field: 'label'
[17:26:23.865]   - Field: 'local'
[17:26:23.866]   - Field: 'owner'
[17:26:23.866]   - Field: 'envir'
[17:26:23.866]   - Field: 'workers'
[17:26:23.866]   - Field: 'packages'
[17:26:23.866]   - Field: 'gc'
[17:26:23.867]   - Field: 'conditions'
[17:26:23.867]   - Field: 'persistent'
[17:26:23.867]   - Field: 'expr'
[17:26:23.867]   - Field: 'uuid'
[17:26:23.867]   - Field: 'seed'
[17:26:23.867]   - Field: 'version'
[17:26:23.868]   - Field: 'result'
[17:26:23.868]   - Field: 'asynchronous'
[17:26:23.868]   - Field: 'calls'
[17:26:23.868]   - Field: 'globals'
[17:26:23.868]   - Field: 'stdout'
[17:26:23.868]   - Field: 'earlySignal'
[17:26:23.869]   - Field: 'lazy'
[17:26:23.869]   - Field: 'state'
[17:26:23.869] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:23.869] - Launch lazy future ...
[17:26:23.870] Packages needed by the future expression (n = 1): 'future'
[17:26:23.870] Packages needed by future strategies (n = 0): <none>
[17:26:23.870] {
[17:26:23.870]     {
[17:26:23.870]         {
[17:26:23.870]             ...future.startTime <- base::Sys.time()
[17:26:23.870]             {
[17:26:23.870]                 {
[17:26:23.870]                   {
[17:26:23.870]                     {
[17:26:23.870]                       {
[17:26:23.870]                         base::local({
[17:26:23.870]                           has_future <- base::requireNamespace("future", 
[17:26:23.870]                             quietly = TRUE)
[17:26:23.870]                           if (has_future) {
[17:26:23.870]                             ns <- base::getNamespace("future")
[17:26:23.870]                             version <- ns[[".package"]][["version"]]
[17:26:23.870]                             if (is.null(version)) 
[17:26:23.870]                               version <- utils::packageVersion("future")
[17:26:23.870]                           }
[17:26:23.870]                           else {
[17:26:23.870]                             version <- NULL
[17:26:23.870]                           }
[17:26:23.870]                           if (!has_future || version < "1.8.0") {
[17:26:23.870]                             info <- base::c(r_version = base::gsub("R version ", 
[17:26:23.870]                               "", base::R.version$version.string), 
[17:26:23.870]                               platform = base::sprintf("%s (%s-bit)", 
[17:26:23.870]                                 base::R.version$platform, 8 * 
[17:26:23.870]                                   base::.Machine$sizeof.pointer), 
[17:26:23.870]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:23.870]                                 "release", "version")], collapse = " "), 
[17:26:23.870]                               hostname = base::Sys.info()[["nodename"]])
[17:26:23.870]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:26:23.870]                               info)
[17:26:23.870]                             info <- base::paste(info, collapse = "; ")
[17:26:23.870]                             if (!has_future) {
[17:26:23.870]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:23.870]                                 info)
[17:26:23.870]                             }
[17:26:23.870]                             else {
[17:26:23.870]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:23.870]                                 info, version)
[17:26:23.870]                             }
[17:26:23.870]                             base::stop(msg)
[17:26:23.870]                           }
[17:26:23.870]                         })
[17:26:23.870]                       }
[17:26:23.870]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:23.870]                       base::options(mc.cores = 1L)
[17:26:23.870]                     }
[17:26:23.870]                     base::local({
[17:26:23.870]                       for (pkg in "future") {
[17:26:23.870]                         base::loadNamespace(pkg)
[17:26:23.870]                         base::library(pkg, character.only = TRUE)
[17:26:23.870]                       }
[17:26:23.870]                     })
[17:26:23.870]                   }
[17:26:23.870]                   ...future.strategy.old <- future::plan("list")
[17:26:23.870]                   options(future.plan = NULL)
[17:26:23.870]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:23.870]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:23.870]                 }
[17:26:23.870]                 ...future.workdir <- getwd()
[17:26:23.870]             }
[17:26:23.870]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:23.870]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:23.870]         }
[17:26:23.870]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:23.870]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:23.870]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:23.870]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:23.870]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:23.870]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:23.870]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:23.870]             base::names(...future.oldOptions))
[17:26:23.870]     }
[17:26:23.870]     if (FALSE) {
[17:26:23.870]     }
[17:26:23.870]     else {
[17:26:23.870]         if (TRUE) {
[17:26:23.870]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:23.870]                 open = "w")
[17:26:23.870]         }
[17:26:23.870]         else {
[17:26:23.870]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:23.870]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:23.870]         }
[17:26:23.870]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:23.870]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:23.870]             base::sink(type = "output", split = FALSE)
[17:26:23.870]             base::close(...future.stdout)
[17:26:23.870]         }, add = TRUE)
[17:26:23.870]     }
[17:26:23.870]     ...future.frame <- base::sys.nframe()
[17:26:23.870]     ...future.conditions <- base::list()
[17:26:23.870]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:23.870]     if (FALSE) {
[17:26:23.870]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:23.870]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:23.870]     }
[17:26:23.870]     ...future.result <- base::tryCatch({
[17:26:23.870]         base::withCallingHandlers({
[17:26:23.870]             ...future.value <- base::withVisible(base::local({
[17:26:23.870]                 ...future.makeSendCondition <- base::local({
[17:26:23.870]                   sendCondition <- NULL
[17:26:23.870]                   function(frame = 1L) {
[17:26:23.870]                     if (is.function(sendCondition)) 
[17:26:23.870]                       return(sendCondition)
[17:26:23.870]                     ns <- getNamespace("parallel")
[17:26:23.870]                     if (exists("sendData", mode = "function", 
[17:26:23.870]                       envir = ns)) {
[17:26:23.870]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:23.870]                         envir = ns)
[17:26:23.870]                       envir <- sys.frame(frame)
[17:26:23.870]                       master <- NULL
[17:26:23.870]                       while (!identical(envir, .GlobalEnv) && 
[17:26:23.870]                         !identical(envir, emptyenv())) {
[17:26:23.870]                         if (exists("master", mode = "list", envir = envir, 
[17:26:23.870]                           inherits = FALSE)) {
[17:26:23.870]                           master <- get("master", mode = "list", 
[17:26:23.870]                             envir = envir, inherits = FALSE)
[17:26:23.870]                           if (inherits(master, c("SOCKnode", 
[17:26:23.870]                             "SOCK0node"))) {
[17:26:23.870]                             sendCondition <<- function(cond) {
[17:26:23.870]                               data <- list(type = "VALUE", value = cond, 
[17:26:23.870]                                 success = TRUE)
[17:26:23.870]                               parallel_sendData(master, data)
[17:26:23.870]                             }
[17:26:23.870]                             return(sendCondition)
[17:26:23.870]                           }
[17:26:23.870]                         }
[17:26:23.870]                         frame <- frame + 1L
[17:26:23.870]                         envir <- sys.frame(frame)
[17:26:23.870]                       }
[17:26:23.870]                     }
[17:26:23.870]                     sendCondition <<- function(cond) NULL
[17:26:23.870]                   }
[17:26:23.870]                 })
[17:26:23.870]                 withCallingHandlers({
[17:26:23.870]                   {
[17:26:23.870]                     message(sprintf("Calculating tile #%d of %d ...", 
[17:26:23.870]                       ii, n), appendLF = FALSE)
[17:26:23.870]                     fit <- mandelbrot(C)
[17:26:23.870]                     delay(fit)
[17:26:23.870]                     message(" done")
[17:26:23.870]                     fit
[17:26:23.870]                   }
[17:26:23.870]                 }, immediateCondition = function(cond) {
[17:26:23.870]                   sendCondition <- ...future.makeSendCondition()
[17:26:23.870]                   sendCondition(cond)
[17:26:23.870]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:23.870]                   {
[17:26:23.870]                     inherits <- base::inherits
[17:26:23.870]                     invokeRestart <- base::invokeRestart
[17:26:23.870]                     is.null <- base::is.null
[17:26:23.870]                     muffled <- FALSE
[17:26:23.870]                     if (inherits(cond, "message")) {
[17:26:23.870]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:23.870]                       if (muffled) 
[17:26:23.870]                         invokeRestart("muffleMessage")
[17:26:23.870]                     }
[17:26:23.870]                     else if (inherits(cond, "warning")) {
[17:26:23.870]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:23.870]                       if (muffled) 
[17:26:23.870]                         invokeRestart("muffleWarning")
[17:26:23.870]                     }
[17:26:23.870]                     else if (inherits(cond, "condition")) {
[17:26:23.870]                       if (!is.null(pattern)) {
[17:26:23.870]                         computeRestarts <- base::computeRestarts
[17:26:23.870]                         grepl <- base::grepl
[17:26:23.870]                         restarts <- computeRestarts(cond)
[17:26:23.870]                         for (restart in restarts) {
[17:26:23.870]                           name <- restart$name
[17:26:23.870]                           if (is.null(name)) 
[17:26:23.870]                             next
[17:26:23.870]                           if (!grepl(pattern, name)) 
[17:26:23.870]                             next
[17:26:23.870]                           invokeRestart(restart)
[17:26:23.870]                           muffled <- TRUE
[17:26:23.870]                           break
[17:26:23.870]                         }
[17:26:23.870]                       }
[17:26:23.870]                     }
[17:26:23.870]                     invisible(muffled)
[17:26:23.870]                   }
[17:26:23.870]                   muffleCondition(cond)
[17:26:23.870]                 })
[17:26:23.870]             }))
[17:26:23.870]             future::FutureResult(value = ...future.value$value, 
[17:26:23.870]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:23.870]                   ...future.rng), globalenv = if (FALSE) 
[17:26:23.870]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:23.870]                     ...future.globalenv.names))
[17:26:23.870]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:23.870]         }, condition = base::local({
[17:26:23.870]             c <- base::c
[17:26:23.870]             inherits <- base::inherits
[17:26:23.870]             invokeRestart <- base::invokeRestart
[17:26:23.870]             length <- base::length
[17:26:23.870]             list <- base::list
[17:26:23.870]             seq.int <- base::seq.int
[17:26:23.870]             signalCondition <- base::signalCondition
[17:26:23.870]             sys.calls <- base::sys.calls
[17:26:23.870]             `[[` <- base::`[[`
[17:26:23.870]             `+` <- base::`+`
[17:26:23.870]             `<<-` <- base::`<<-`
[17:26:23.870]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:23.870]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:23.870]                   3L)]
[17:26:23.870]             }
[17:26:23.870]             function(cond) {
[17:26:23.870]                 is_error <- inherits(cond, "error")
[17:26:23.870]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:23.870]                   NULL)
[17:26:23.870]                 if (is_error) {
[17:26:23.870]                   sessionInformation <- function() {
[17:26:23.870]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:23.870]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:23.870]                       search = base::search(), system = base::Sys.info())
[17:26:23.870]                   }
[17:26:23.870]                   ...future.conditions[[length(...future.conditions) + 
[17:26:23.870]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:23.870]                     cond$call), session = sessionInformation(), 
[17:26:23.870]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:23.870]                   signalCondition(cond)
[17:26:23.870]                 }
[17:26:23.870]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:23.870]                 "immediateCondition"))) {
[17:26:23.870]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:23.870]                   ...future.conditions[[length(...future.conditions) + 
[17:26:23.870]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:23.870]                   if (TRUE && !signal) {
[17:26:23.870]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:23.870]                     {
[17:26:23.870]                       inherits <- base::inherits
[17:26:23.870]                       invokeRestart <- base::invokeRestart
[17:26:23.870]                       is.null <- base::is.null
[17:26:23.870]                       muffled <- FALSE
[17:26:23.870]                       if (inherits(cond, "message")) {
[17:26:23.870]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:23.870]                         if (muffled) 
[17:26:23.870]                           invokeRestart("muffleMessage")
[17:26:23.870]                       }
[17:26:23.870]                       else if (inherits(cond, "warning")) {
[17:26:23.870]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:23.870]                         if (muffled) 
[17:26:23.870]                           invokeRestart("muffleWarning")
[17:26:23.870]                       }
[17:26:23.870]                       else if (inherits(cond, "condition")) {
[17:26:23.870]                         if (!is.null(pattern)) {
[17:26:23.870]                           computeRestarts <- base::computeRestarts
[17:26:23.870]                           grepl <- base::grepl
[17:26:23.870]                           restarts <- computeRestarts(cond)
[17:26:23.870]                           for (restart in restarts) {
[17:26:23.870]                             name <- restart$name
[17:26:23.870]                             if (is.null(name)) 
[17:26:23.870]                               next
[17:26:23.870]                             if (!grepl(pattern, name)) 
[17:26:23.870]                               next
[17:26:23.870]                             invokeRestart(restart)
[17:26:23.870]                             muffled <- TRUE
[17:26:23.870]                             break
[17:26:23.870]                           }
[17:26:23.870]                         }
[17:26:23.870]                       }
[17:26:23.870]                       invisible(muffled)
[17:26:23.870]                     }
[17:26:23.870]                     muffleCondition(cond, pattern = "^muffle")
[17:26:23.870]                   }
[17:26:23.870]                 }
[17:26:23.870]                 else {
[17:26:23.870]                   if (TRUE) {
[17:26:23.870]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:23.870]                     {
[17:26:23.870]                       inherits <- base::inherits
[17:26:23.870]                       invokeRestart <- base::invokeRestart
[17:26:23.870]                       is.null <- base::is.null
[17:26:23.870]                       muffled <- FALSE
[17:26:23.870]                       if (inherits(cond, "message")) {
[17:26:23.870]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:23.870]                         if (muffled) 
[17:26:23.870]                           invokeRestart("muffleMessage")
[17:26:23.870]                       }
[17:26:23.870]                       else if (inherits(cond, "warning")) {
[17:26:23.870]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:23.870]                         if (muffled) 
[17:26:23.870]                           invokeRestart("muffleWarning")
[17:26:23.870]                       }
[17:26:23.870]                       else if (inherits(cond, "condition")) {
[17:26:23.870]                         if (!is.null(pattern)) {
[17:26:23.870]                           computeRestarts <- base::computeRestarts
[17:26:23.870]                           grepl <- base::grepl
[17:26:23.870]                           restarts <- computeRestarts(cond)
[17:26:23.870]                           for (restart in restarts) {
[17:26:23.870]                             name <- restart$name
[17:26:23.870]                             if (is.null(name)) 
[17:26:23.870]                               next
[17:26:23.870]                             if (!grepl(pattern, name)) 
[17:26:23.870]                               next
[17:26:23.870]                             invokeRestart(restart)
[17:26:23.870]                             muffled <- TRUE
[17:26:23.870]                             break
[17:26:23.870]                           }
[17:26:23.870]                         }
[17:26:23.870]                       }
[17:26:23.870]                       invisible(muffled)
[17:26:23.870]                     }
[17:26:23.870]                     muffleCondition(cond, pattern = "^muffle")
[17:26:23.870]                   }
[17:26:23.870]                 }
[17:26:23.870]             }
[17:26:23.870]         }))
[17:26:23.870]     }, error = function(ex) {
[17:26:23.870]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:23.870]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:23.870]                 ...future.rng), started = ...future.startTime, 
[17:26:23.870]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:23.870]             version = "1.8"), class = "FutureResult")
[17:26:23.870]     }, finally = {
[17:26:23.870]         if (!identical(...future.workdir, getwd())) 
[17:26:23.870]             setwd(...future.workdir)
[17:26:23.870]         {
[17:26:23.870]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:23.870]                 ...future.oldOptions$nwarnings <- NULL
[17:26:23.870]             }
[17:26:23.870]             base::options(...future.oldOptions)
[17:26:23.870]             if (.Platform$OS.type == "windows") {
[17:26:23.870]                 old_names <- names(...future.oldEnvVars)
[17:26:23.870]                 envs <- base::Sys.getenv()
[17:26:23.870]                 names <- names(envs)
[17:26:23.870]                 common <- intersect(names, old_names)
[17:26:23.870]                 added <- setdiff(names, old_names)
[17:26:23.870]                 removed <- setdiff(old_names, names)
[17:26:23.870]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:23.870]                   envs[common]]
[17:26:23.870]                 NAMES <- toupper(changed)
[17:26:23.870]                 args <- list()
[17:26:23.870]                 for (kk in seq_along(NAMES)) {
[17:26:23.870]                   name <- changed[[kk]]
[17:26:23.870]                   NAME <- NAMES[[kk]]
[17:26:23.870]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:23.870]                     next
[17:26:23.870]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:23.870]                 }
[17:26:23.870]                 NAMES <- toupper(added)
[17:26:23.870]                 for (kk in seq_along(NAMES)) {
[17:26:23.870]                   name <- added[[kk]]
[17:26:23.870]                   NAME <- NAMES[[kk]]
[17:26:23.870]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:23.870]                     next
[17:26:23.870]                   args[[name]] <- ""
[17:26:23.870]                 }
[17:26:23.870]                 NAMES <- toupper(removed)
[17:26:23.870]                 for (kk in seq_along(NAMES)) {
[17:26:23.870]                   name <- removed[[kk]]
[17:26:23.870]                   NAME <- NAMES[[kk]]
[17:26:23.870]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:23.870]                     next
[17:26:23.870]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:23.870]                 }
[17:26:23.870]                 if (length(args) > 0) 
[17:26:23.870]                   base::do.call(base::Sys.setenv, args = args)
[17:26:23.870]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:23.870]             }
[17:26:23.870]             else {
[17:26:23.870]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:23.870]             }
[17:26:23.870]             {
[17:26:23.870]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:23.870]                   0L) {
[17:26:23.870]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:23.870]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:23.870]                   base::options(opts)
[17:26:23.870]                 }
[17:26:23.870]                 {
[17:26:23.870]                   {
[17:26:23.870]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:23.870]                     NULL
[17:26:23.870]                   }
[17:26:23.870]                   options(future.plan = NULL)
[17:26:23.870]                   if (is.na(NA_character_)) 
[17:26:23.870]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:23.870]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:23.870]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:23.870]                     .init = FALSE)
[17:26:23.870]                 }
[17:26:23.870]             }
[17:26:23.870]         }
[17:26:23.870]     })
[17:26:23.870]     if (TRUE) {
[17:26:23.870]         base::sink(type = "output", split = FALSE)
[17:26:23.870]         if (TRUE) {
[17:26:23.870]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:23.870]         }
[17:26:23.870]         else {
[17:26:23.870]             ...future.result["stdout"] <- base::list(NULL)
[17:26:23.870]         }
[17:26:23.870]         base::close(...future.stdout)
[17:26:23.870]         ...future.stdout <- NULL
[17:26:23.870]     }
[17:26:23.870]     ...future.result$conditions <- ...future.conditions
[17:26:23.870]     ...future.result$finished <- base::Sys.time()
[17:26:23.870]     ...future.result
[17:26:23.870] }
[17:26:23.876] Exporting 4 global objects (14.24 KiB) to cluster node #1 ...
[17:26:23.876] Exporting 'ii' (56 bytes) to cluster node #1 ...
[17:26:23.876] Exporting 'ii' (56 bytes) to cluster node #1 ... DONE
[17:26:23.877] Exporting 'n' (56 bytes) to cluster node #1 ...
[17:26:23.877] Exporting 'n' (56 bytes) to cluster node #1 ... DONE
[17:26:23.877] Exporting 'C' (10.72 KiB) to cluster node #1 ...
[17:26:23.878] Exporting 'C' (10.72 KiB) to cluster node #1 ... DONE
[17:26:23.878] Exporting 'delay' (3.41 KiB) to cluster node #1 ...
[17:26:23.878] Exporting 'delay' (3.41 KiB) to cluster node #1 ... DONE
[17:26:23.879] Exporting 4 global objects (14.24 KiB) to cluster node #1 ... DONE
[17:26:23.879] MultisessionFuture started
[17:26:23.880] - Launch lazy future ... done
[17:26:23.880] run() for 'MultisessionFuture' ... done
[17:26:23.880] - run() ... done
[17:26:23.880] - resolved() ...
[17:26:23.910] receiveMessageFromWorker() for ClusterFuture ...
[17:26:23.910] - Validating connection of MultisessionFuture
[17:26:23.911] - received message: FutureResult
[17:26:23.911] - Received FutureResult
[17:26:23.911] - Erased future from FutureRegistry
[17:26:23.911] result() for ClusterFuture ...
[17:26:23.912] - result already collected: FutureResult
[17:26:23.912] result() for ClusterFuture ... done
[17:26:23.912] signalConditions() ...
[17:26:23.912]  - include = 'immediateCondition'
[17:26:23.912]  - exclude = 
[17:26:23.912]  - resignal = FALSE
[17:26:23.913]  - Number of conditions: 2
[17:26:23.913] signalConditions() ... done
[17:26:23.913] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:23.913] - resolved: TRUE
[17:26:23.913] - resolved() ... done
[17:26:23.913] resolved() for 'MultisessionFuture' ... done
Plotting tile #3 of 4 ...
[17:26:23.914] result() for ClusterFuture ...
[17:26:23.914] - result already collected: FutureResult
[17:26:23.914] result() for ClusterFuture ... done
[17:26:23.914] result() for ClusterFuture ...
[17:26:23.914] - result already collected: FutureResult
[17:26:23.914] result() for ClusterFuture ... done
[17:26:23.915] signalConditions() ...
[17:26:23.915]  - include = 'immediateCondition'
[17:26:23.915]  - exclude = 
[17:26:23.915]  - resignal = FALSE
[17:26:23.915]  - Number of conditions: 2
[17:26:23.915] signalConditions() ... done
[17:26:23.916] Future state: 'finished'
[17:26:23.916] result() for ClusterFuture ...
[17:26:23.916] - result already collected: FutureResult
[17:26:23.916] result() for ClusterFuture ... done
[17:26:23.916] signalConditions() ...
[17:26:23.916]  - include = 'condition'
[17:26:23.917]  - exclude = 'immediateCondition'
[17:26:23.917]  - resignal = TRUE
[17:26:23.917]  - Number of conditions: 2
[17:26:23.917]  - Condition #1: 'simpleMessage', 'message', 'condition'
Calculating tile #3 of 4 ...[17:26:23.917]  - Condition #2: 'simpleMessage', 'message', 'condition'
 done
[17:26:23.918] signalConditions() ... done
[17:26:23.918] resolved() for 'Future' ...
[17:26:23.918] - state: 'created'
[17:26:23.919] - run: TRUE
[17:26:23.919] - run() ...
[17:26:23.919] run() for 'Future' ...
[17:26:23.919] - state: 'created'
[17:26:23.919] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:26:23.936] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:26:23.936] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:26:23.936]   - Field: 'node'
[17:26:23.936]   - Field: 'label'
[17:26:23.936]   - Field: 'local'
[17:26:23.937]   - Field: 'owner'
[17:26:23.937]   - Field: 'envir'
[17:26:23.937]   - Field: 'workers'
[17:26:23.937]   - Field: 'packages'
[17:26:23.937]   - Field: 'gc'
[17:26:23.937]   - Field: 'conditions'
[17:26:23.938]   - Field: 'persistent'
[17:26:23.938]   - Field: 'expr'
[17:26:23.938]   - Field: 'uuid'
[17:26:23.938]   - Field: 'seed'
[17:26:23.938]   - Field: 'version'
[17:26:23.938]   - Field: 'result'
[17:26:23.939]   - Field: 'asynchronous'
[17:26:23.939]   - Field: 'calls'
[17:26:23.939]   - Field: 'globals'
[17:26:23.939]   - Field: 'stdout'
[17:26:23.939]   - Field: 'earlySignal'
[17:26:23.939]   - Field: 'lazy'
[17:26:23.940]   - Field: 'state'
[17:26:23.940] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:26:23.940] - Launch lazy future ...
[17:26:23.940] Packages needed by the future expression (n = 1): 'future'
[17:26:23.941] Packages needed by future strategies (n = 0): <none>
[17:26:23.941] {
[17:26:23.941]     {
[17:26:23.941]         {
[17:26:23.941]             ...future.startTime <- base::Sys.time()
[17:26:23.941]             {
[17:26:23.941]                 {
[17:26:23.941]                   {
[17:26:23.941]                     {
[17:26:23.941]                       {
[17:26:23.941]                         base::local({
[17:26:23.941]                           has_future <- base::requireNamespace("future", 
[17:26:23.941]                             quietly = TRUE)
[17:26:23.941]                           if (has_future) {
[17:26:23.941]                             ns <- base::getNamespace("future")
[17:26:23.941]                             version <- ns[[".package"]][["version"]]
[17:26:23.941]                             if (is.null(version)) 
[17:26:23.941]                               version <- utils::packageVersion("future")
[17:26:23.941]                           }
[17:26:23.941]                           else {
[17:26:23.941]                             version <- NULL
[17:26:23.941]                           }
[17:26:23.941]                           if (!has_future || version < "1.8.0") {
[17:26:23.941]                             info <- base::c(r_version = base::gsub("R version ", 
[17:26:23.941]                               "", base::R.version$version.string), 
[17:26:23.941]                               platform = base::sprintf("%s (%s-bit)", 
[17:26:23.941]                                 base::R.version$platform, 8 * 
[17:26:23.941]                                   base::.Machine$sizeof.pointer), 
[17:26:23.941]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:26:23.941]                                 "release", "version")], collapse = " "), 
[17:26:23.941]                               hostname = base::Sys.info()[["nodename"]])
[17:26:23.941]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:26:23.941]                               info)
[17:26:23.941]                             info <- base::paste(info, collapse = "; ")
[17:26:23.941]                             if (!has_future) {
[17:26:23.941]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:26:23.941]                                 info)
[17:26:23.941]                             }
[17:26:23.941]                             else {
[17:26:23.941]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:26:23.941]                                 info, version)
[17:26:23.941]                             }
[17:26:23.941]                             base::stop(msg)
[17:26:23.941]                           }
[17:26:23.941]                         })
[17:26:23.941]                       }
[17:26:23.941]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:26:23.941]                       base::options(mc.cores = 1L)
[17:26:23.941]                     }
[17:26:23.941]                     base::local({
[17:26:23.941]                       for (pkg in "future") {
[17:26:23.941]                         base::loadNamespace(pkg)
[17:26:23.941]                         base::library(pkg, character.only = TRUE)
[17:26:23.941]                       }
[17:26:23.941]                     })
[17:26:23.941]                   }
[17:26:23.941]                   ...future.strategy.old <- future::plan("list")
[17:26:23.941]                   options(future.plan = NULL)
[17:26:23.941]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:26:23.941]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:26:23.941]                 }
[17:26:23.941]                 ...future.workdir <- getwd()
[17:26:23.941]             }
[17:26:23.941]             ...future.oldOptions <- base::as.list(base::.Options)
[17:26:23.941]             ...future.oldEnvVars <- base::Sys.getenv()
[17:26:23.941]         }
[17:26:23.941]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:26:23.941]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:26:23.941]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:26:23.941]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:26:23.941]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:26:23.941]             future.stdout.windows.reencode = NULL, width = 80L)
[17:26:23.941]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:26:23.941]             base::names(...future.oldOptions))
[17:26:23.941]     }
[17:26:23.941]     if (FALSE) {
[17:26:23.941]     }
[17:26:23.941]     else {
[17:26:23.941]         if (TRUE) {
[17:26:23.941]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:26:23.941]                 open = "w")
[17:26:23.941]         }
[17:26:23.941]         else {
[17:26:23.941]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:26:23.941]                 windows = "NUL", "/dev/null"), open = "w")
[17:26:23.941]         }
[17:26:23.941]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:26:23.941]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:26:23.941]             base::sink(type = "output", split = FALSE)
[17:26:23.941]             base::close(...future.stdout)
[17:26:23.941]         }, add = TRUE)
[17:26:23.941]     }
[17:26:23.941]     ...future.frame <- base::sys.nframe()
[17:26:23.941]     ...future.conditions <- base::list()
[17:26:23.941]     ...future.rng <- base::globalenv()$.Random.seed
[17:26:23.941]     if (FALSE) {
[17:26:23.941]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:26:23.941]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:26:23.941]     }
[17:26:23.941]     ...future.result <- base::tryCatch({
[17:26:23.941]         base::withCallingHandlers({
[17:26:23.941]             ...future.value <- base::withVisible(base::local({
[17:26:23.941]                 ...future.makeSendCondition <- base::local({
[17:26:23.941]                   sendCondition <- NULL
[17:26:23.941]                   function(frame = 1L) {
[17:26:23.941]                     if (is.function(sendCondition)) 
[17:26:23.941]                       return(sendCondition)
[17:26:23.941]                     ns <- getNamespace("parallel")
[17:26:23.941]                     if (exists("sendData", mode = "function", 
[17:26:23.941]                       envir = ns)) {
[17:26:23.941]                       parallel_sendData <- get("sendData", mode = "function", 
[17:26:23.941]                         envir = ns)
[17:26:23.941]                       envir <- sys.frame(frame)
[17:26:23.941]                       master <- NULL
[17:26:23.941]                       while (!identical(envir, .GlobalEnv) && 
[17:26:23.941]                         !identical(envir, emptyenv())) {
[17:26:23.941]                         if (exists("master", mode = "list", envir = envir, 
[17:26:23.941]                           inherits = FALSE)) {
[17:26:23.941]                           master <- get("master", mode = "list", 
[17:26:23.941]                             envir = envir, inherits = FALSE)
[17:26:23.941]                           if (inherits(master, c("SOCKnode", 
[17:26:23.941]                             "SOCK0node"))) {
[17:26:23.941]                             sendCondition <<- function(cond) {
[17:26:23.941]                               data <- list(type = "VALUE", value = cond, 
[17:26:23.941]                                 success = TRUE)
[17:26:23.941]                               parallel_sendData(master, data)
[17:26:23.941]                             }
[17:26:23.941]                             return(sendCondition)
[17:26:23.941]                           }
[17:26:23.941]                         }
[17:26:23.941]                         frame <- frame + 1L
[17:26:23.941]                         envir <- sys.frame(frame)
[17:26:23.941]                       }
[17:26:23.941]                     }
[17:26:23.941]                     sendCondition <<- function(cond) NULL
[17:26:23.941]                   }
[17:26:23.941]                 })
[17:26:23.941]                 withCallingHandlers({
[17:26:23.941]                   {
[17:26:23.941]                     message(sprintf("Calculating tile #%d of %d ...", 
[17:26:23.941]                       ii, n), appendLF = FALSE)
[17:26:23.941]                     fit <- mandelbrot(C)
[17:26:23.941]                     delay(fit)
[17:26:23.941]                     message(" done")
[17:26:23.941]                     fit
[17:26:23.941]                   }
[17:26:23.941]                 }, immediateCondition = function(cond) {
[17:26:23.941]                   sendCondition <- ...future.makeSendCondition()
[17:26:23.941]                   sendCondition(cond)
[17:26:23.941]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:23.941]                   {
[17:26:23.941]                     inherits <- base::inherits
[17:26:23.941]                     invokeRestart <- base::invokeRestart
[17:26:23.941]                     is.null <- base::is.null
[17:26:23.941]                     muffled <- FALSE
[17:26:23.941]                     if (inherits(cond, "message")) {
[17:26:23.941]                       muffled <- grepl(pattern, "muffleMessage")
[17:26:23.941]                       if (muffled) 
[17:26:23.941]                         invokeRestart("muffleMessage")
[17:26:23.941]                     }
[17:26:23.941]                     else if (inherits(cond, "warning")) {
[17:26:23.941]                       muffled <- grepl(pattern, "muffleWarning")
[17:26:23.941]                       if (muffled) 
[17:26:23.941]                         invokeRestart("muffleWarning")
[17:26:23.941]                     }
[17:26:23.941]                     else if (inherits(cond, "condition")) {
[17:26:23.941]                       if (!is.null(pattern)) {
[17:26:23.941]                         computeRestarts <- base::computeRestarts
[17:26:23.941]                         grepl <- base::grepl
[17:26:23.941]                         restarts <- computeRestarts(cond)
[17:26:23.941]                         for (restart in restarts) {
[17:26:23.941]                           name <- restart$name
[17:26:23.941]                           if (is.null(name)) 
[17:26:23.941]                             next
[17:26:23.941]                           if (!grepl(pattern, name)) 
[17:26:23.941]                             next
[17:26:23.941]                           invokeRestart(restart)
[17:26:23.941]                           muffled <- TRUE
[17:26:23.941]                           break
[17:26:23.941]                         }
[17:26:23.941]                       }
[17:26:23.941]                     }
[17:26:23.941]                     invisible(muffled)
[17:26:23.941]                   }
[17:26:23.941]                   muffleCondition(cond)
[17:26:23.941]                 })
[17:26:23.941]             }))
[17:26:23.941]             future::FutureResult(value = ...future.value$value, 
[17:26:23.941]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:23.941]                   ...future.rng), globalenv = if (FALSE) 
[17:26:23.941]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:26:23.941]                     ...future.globalenv.names))
[17:26:23.941]                 else NULL, started = ...future.startTime, version = "1.8")
[17:26:23.941]         }, condition = base::local({
[17:26:23.941]             c <- base::c
[17:26:23.941]             inherits <- base::inherits
[17:26:23.941]             invokeRestart <- base::invokeRestart
[17:26:23.941]             length <- base::length
[17:26:23.941]             list <- base::list
[17:26:23.941]             seq.int <- base::seq.int
[17:26:23.941]             signalCondition <- base::signalCondition
[17:26:23.941]             sys.calls <- base::sys.calls
[17:26:23.941]             `[[` <- base::`[[`
[17:26:23.941]             `+` <- base::`+`
[17:26:23.941]             `<<-` <- base::`<<-`
[17:26:23.941]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:26:23.941]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:26:23.941]                   3L)]
[17:26:23.941]             }
[17:26:23.941]             function(cond) {
[17:26:23.941]                 is_error <- inherits(cond, "error")
[17:26:23.941]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:26:23.941]                   NULL)
[17:26:23.941]                 if (is_error) {
[17:26:23.941]                   sessionInformation <- function() {
[17:26:23.941]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:26:23.941]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:26:23.941]                       search = base::search(), system = base::Sys.info())
[17:26:23.941]                   }
[17:26:23.941]                   ...future.conditions[[length(...future.conditions) + 
[17:26:23.941]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:26:23.941]                     cond$call), session = sessionInformation(), 
[17:26:23.941]                     timestamp = base::Sys.time(), signaled = 0L)
[17:26:23.941]                   signalCondition(cond)
[17:26:23.941]                 }
[17:26:23.941]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:26:23.941]                 "immediateCondition"))) {
[17:26:23.941]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:26:23.941]                   ...future.conditions[[length(...future.conditions) + 
[17:26:23.941]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:26:23.941]                   if (TRUE && !signal) {
[17:26:23.941]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:23.941]                     {
[17:26:23.941]                       inherits <- base::inherits
[17:26:23.941]                       invokeRestart <- base::invokeRestart
[17:26:23.941]                       is.null <- base::is.null
[17:26:23.941]                       muffled <- FALSE
[17:26:23.941]                       if (inherits(cond, "message")) {
[17:26:23.941]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:23.941]                         if (muffled) 
[17:26:23.941]                           invokeRestart("muffleMessage")
[17:26:23.941]                       }
[17:26:23.941]                       else if (inherits(cond, "warning")) {
[17:26:23.941]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:23.941]                         if (muffled) 
[17:26:23.941]                           invokeRestart("muffleWarning")
[17:26:23.941]                       }
[17:26:23.941]                       else if (inherits(cond, "condition")) {
[17:26:23.941]                         if (!is.null(pattern)) {
[17:26:23.941]                           computeRestarts <- base::computeRestarts
[17:26:23.941]                           grepl <- base::grepl
[17:26:23.941]                           restarts <- computeRestarts(cond)
[17:26:23.941]                           for (restart in restarts) {
[17:26:23.941]                             name <- restart$name
[17:26:23.941]                             if (is.null(name)) 
[17:26:23.941]                               next
[17:26:23.941]                             if (!grepl(pattern, name)) 
[17:26:23.941]                               next
[17:26:23.941]                             invokeRestart(restart)
[17:26:23.941]                             muffled <- TRUE
[17:26:23.941]                             break
[17:26:23.941]                           }
[17:26:23.941]                         }
[17:26:23.941]                       }
[17:26:23.941]                       invisible(muffled)
[17:26:23.941]                     }
[17:26:23.941]                     muffleCondition(cond, pattern = "^muffle")
[17:26:23.941]                   }
[17:26:23.941]                 }
[17:26:23.941]                 else {
[17:26:23.941]                   if (TRUE) {
[17:26:23.941]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:26:23.941]                     {
[17:26:23.941]                       inherits <- base::inherits
[17:26:23.941]                       invokeRestart <- base::invokeRestart
[17:26:23.941]                       is.null <- base::is.null
[17:26:23.941]                       muffled <- FALSE
[17:26:23.941]                       if (inherits(cond, "message")) {
[17:26:23.941]                         muffled <- grepl(pattern, "muffleMessage")
[17:26:23.941]                         if (muffled) 
[17:26:23.941]                           invokeRestart("muffleMessage")
[17:26:23.941]                       }
[17:26:23.941]                       else if (inherits(cond, "warning")) {
[17:26:23.941]                         muffled <- grepl(pattern, "muffleWarning")
[17:26:23.941]                         if (muffled) 
[17:26:23.941]                           invokeRestart("muffleWarning")
[17:26:23.941]                       }
[17:26:23.941]                       else if (inherits(cond, "condition")) {
[17:26:23.941]                         if (!is.null(pattern)) {
[17:26:23.941]                           computeRestarts <- base::computeRestarts
[17:26:23.941]                           grepl <- base::grepl
[17:26:23.941]                           restarts <- computeRestarts(cond)
[17:26:23.941]                           for (restart in restarts) {
[17:26:23.941]                             name <- restart$name
[17:26:23.941]                             if (is.null(name)) 
[17:26:23.941]                               next
[17:26:23.941]                             if (!grepl(pattern, name)) 
[17:26:23.941]                               next
[17:26:23.941]                             invokeRestart(restart)
[17:26:23.941]                             muffled <- TRUE
[17:26:23.941]                             break
[17:26:23.941]                           }
[17:26:23.941]                         }
[17:26:23.941]                       }
[17:26:23.941]                       invisible(muffled)
[17:26:23.941]                     }
[17:26:23.941]                     muffleCondition(cond, pattern = "^muffle")
[17:26:23.941]                   }
[17:26:23.941]                 }
[17:26:23.941]             }
[17:26:23.941]         }))
[17:26:23.941]     }, error = function(ex) {
[17:26:23.941]         base::structure(base::list(value = NULL, visible = NULL, 
[17:26:23.941]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:26:23.941]                 ...future.rng), started = ...future.startTime, 
[17:26:23.941]             finished = Sys.time(), session_uuid = NA_character_, 
[17:26:23.941]             version = "1.8"), class = "FutureResult")
[17:26:23.941]     }, finally = {
[17:26:23.941]         if (!identical(...future.workdir, getwd())) 
[17:26:23.941]             setwd(...future.workdir)
[17:26:23.941]         {
[17:26:23.941]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:26:23.941]                 ...future.oldOptions$nwarnings <- NULL
[17:26:23.941]             }
[17:26:23.941]             base::options(...future.oldOptions)
[17:26:23.941]             if (.Platform$OS.type == "windows") {
[17:26:23.941]                 old_names <- names(...future.oldEnvVars)
[17:26:23.941]                 envs <- base::Sys.getenv()
[17:26:23.941]                 names <- names(envs)
[17:26:23.941]                 common <- intersect(names, old_names)
[17:26:23.941]                 added <- setdiff(names, old_names)
[17:26:23.941]                 removed <- setdiff(old_names, names)
[17:26:23.941]                 changed <- common[...future.oldEnvVars[common] != 
[17:26:23.941]                   envs[common]]
[17:26:23.941]                 NAMES <- toupper(changed)
[17:26:23.941]                 args <- list()
[17:26:23.941]                 for (kk in seq_along(NAMES)) {
[17:26:23.941]                   name <- changed[[kk]]
[17:26:23.941]                   NAME <- NAMES[[kk]]
[17:26:23.941]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:23.941]                     next
[17:26:23.941]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:23.941]                 }
[17:26:23.941]                 NAMES <- toupper(added)
[17:26:23.941]                 for (kk in seq_along(NAMES)) {
[17:26:23.941]                   name <- added[[kk]]
[17:26:23.941]                   NAME <- NAMES[[kk]]
[17:26:23.941]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:23.941]                     next
[17:26:23.941]                   args[[name]] <- ""
[17:26:23.941]                 }
[17:26:23.941]                 NAMES <- toupper(removed)
[17:26:23.941]                 for (kk in seq_along(NAMES)) {
[17:26:23.941]                   name <- removed[[kk]]
[17:26:23.941]                   NAME <- NAMES[[kk]]
[17:26:23.941]                   if (name != NAME && is.element(NAME, old_names)) 
[17:26:23.941]                     next
[17:26:23.941]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:26:23.941]                 }
[17:26:23.941]                 if (length(args) > 0) 
[17:26:23.941]                   base::do.call(base::Sys.setenv, args = args)
[17:26:23.941]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:26:23.941]             }
[17:26:23.941]             else {
[17:26:23.941]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:26:23.941]             }
[17:26:23.941]             {
[17:26:23.941]                 if (base::length(...future.futureOptionsAdded) > 
[17:26:23.941]                   0L) {
[17:26:23.941]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:26:23.941]                   base::names(opts) <- ...future.futureOptionsAdded
[17:26:23.941]                   base::options(opts)
[17:26:23.941]                 }
[17:26:23.941]                 {
[17:26:23.941]                   {
[17:26:23.941]                     base::options(mc.cores = ...future.mc.cores.old)
[17:26:23.941]                     NULL
[17:26:23.941]                   }
[17:26:23.941]                   options(future.plan = NULL)
[17:26:23.941]                   if (is.na(NA_character_)) 
[17:26:23.941]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:26:23.941]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:26:23.941]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:26:23.941]                     .init = FALSE)
[17:26:23.941]                 }
[17:26:23.941]             }
[17:26:23.941]         }
[17:26:23.941]     })
[17:26:23.941]     if (TRUE) {
[17:26:23.941]         base::sink(type = "output", split = FALSE)
[17:26:23.941]         if (TRUE) {
[17:26:23.941]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:26:23.941]         }
[17:26:23.941]         else {
[17:26:23.941]             ...future.result["stdout"] <- base::list(NULL)
[17:26:23.941]         }
[17:26:23.941]         base::close(...future.stdout)
[17:26:23.941]         ...future.stdout <- NULL
[17:26:23.941]     }
[17:26:23.941]     ...future.result$conditions <- ...future.conditions
[17:26:23.941]     ...future.result$finished <- base::Sys.time()
[17:26:23.941]     ...future.result
[17:26:23.941] }
[17:26:23.946] Exporting 4 global objects (14.24 KiB) to cluster node #1 ...
[17:26:23.947] Exporting 'ii' (56 bytes) to cluster node #1 ...
[17:26:23.947] Exporting 'ii' (56 bytes) to cluster node #1 ... DONE
[17:26:23.947] Exporting 'n' (56 bytes) to cluster node #1 ...
[17:26:23.948] Exporting 'n' (56 bytes) to cluster node #1 ... DONE
[17:26:23.948] Exporting 'C' (10.72 KiB) to cluster node #1 ...
[17:26:23.948] Exporting 'C' (10.72 KiB) to cluster node #1 ... DONE
[17:26:23.948] Exporting 'delay' (3.41 KiB) to cluster node #1 ...
[17:26:23.949] Exporting 'delay' (3.41 KiB) to cluster node #1 ... DONE
[17:26:23.949] Exporting 4 global objects (14.24 KiB) to cluster node #1 ... DONE
[17:26:23.950] MultisessionFuture started
[17:26:23.950] - Launch lazy future ... done
[17:26:23.950] run() for 'MultisessionFuture' ... done
[17:26:23.950] - run() ... done
[17:26:23.950] - resolved() ...
[17:26:23.982] receiveMessageFromWorker() for ClusterFuture ...
[17:26:23.983] - Validating connection of MultisessionFuture
[17:26:23.983] - received message: FutureResult
[17:26:23.983] - Received FutureResult
[17:26:23.984] - Erased future from FutureRegistry
[17:26:23.984] result() for ClusterFuture ...
[17:26:23.984] - result already collected: FutureResult
[17:26:23.984] result() for ClusterFuture ... done
[17:26:23.984] signalConditions() ...
[17:26:23.984]  - include = 'immediateCondition'
[17:26:23.985]  - exclude = 
[17:26:23.985]  - resignal = FALSE
[17:26:23.985]  - Number of conditions: 2
[17:26:23.985] signalConditions() ... done
[17:26:23.985] receiveMessageFromWorker() for ClusterFuture ... done
[17:26:23.985] - resolved: TRUE
[17:26:23.986] - resolved() ... done
[17:26:23.986] resolved() for 'MultisessionFuture' ... done
Plotting tile #4 of 4 ...
[17:26:23.986] result() for ClusterFuture ...
[17:26:23.986] - result already collected: FutureResult
[17:26:23.986] result() for ClusterFuture ... done
[17:26:23.986] result() for ClusterFuture ...
[17:26:23.987] - result already collected: FutureResult
[17:26:23.987] result() for ClusterFuture ... done
[17:26:23.987] signalConditions() ...
[17:26:23.987]  - include = 'immediateCondition'
[17:26:23.987]  - exclude = 
[17:26:23.987]  - resignal = FALSE
[17:26:23.987]  - Number of conditions: 2
[17:26:23.988] signalConditions() ... done
[17:26:23.988] Future state: 'finished'
[17:26:23.988] result() for ClusterFuture ...
[17:26:23.988] - result already collected: FutureResult
[17:26:23.988] result() for ClusterFuture ... done
[17:26:23.988] signalConditions() ...
[17:26:23.989]  - include = 'condition'
[17:26:23.989]  - exclude = 'immediateCondition'
[17:26:23.989]  - resignal = TRUE
[17:26:23.989]  - Number of conditions: 2
[17:26:23.989]  - Condition #1: 'simpleMessage', 'message', 'condition'
Calculating tile #4 of 4 ...[17:26:23.990]  - Condition #2: 'simpleMessage', 'message', 'condition'
 done
[17:26:23.990] signalConditions() ... done

> close.screen()
[1] 1 2 3 4 5 6 7 8

> message("SUGGESTION: Try to rerun this demo after changing strategy for how futures are resolved, e.g. plan(multisession).\n")
SUGGESTION: Try to rerun this demo after changing strategy for how futures are resolved, e.g. plan(multisession).

- plan('multisession') ... DONE
Testing with 2 cores ... DONE
> message("*** Mandelbrot demo of the 'future' package ... DONE")
*** Mandelbrot demo of the 'future' package ... DONE
> 
> message("*** Demos ... DONE")
*** Demos ... DONE
> 
> source("incl/end.R")
[17:26:23.992] plan(): Setting new future strategy stack:
[17:26:23.992] List of future strategies:
[17:26:23.992] 1. sequential:
[17:26:23.992]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:26:23.992]    - tweaked: FALSE
[17:26:23.992]    - call: future::plan("sequential")
[17:26:23.993] plan(): nbrOfWorkers() = 1
Failed to undo environment variables:
 - Expected environment variables: [n=204] '!ExitCode', 'ALLUSERSPROFILE', 'APPDATA', 'BIBINPUTS', 'BINDIR', 'BSTINPUTS', 'COMMONPROGRAMFILES', 'COMPUTERNAME', 'COMSPEC', 'CURL_CA_BUNDLE', 'CYGWIN', 'CommonProgramFiles(x86)', 'CommonProgramW6432', 'DriverData', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'JAGS_ROOT', 'JAVA_HOME', 'LANGUAGE', 'LC_COLLATE', 'LC_MONETARY', 'LC_TIME', 'LOCALAPPDATA', 'LOGONSERVER', 'LS_HOME', 'LS_LICENSE_PATH', 'MAKE', 'MAKEFLAGS', 'MAKELEVEL', 'MFLAGS', 'MSMPI_BENCHMARKS', 'MSMPI_BIN', 'MSYS2_ENV_CONV_EXCL', 'NUMBER_OF_PROCESSORS', 'OCL', 'OMP_THREAD_LIMIT', 'OS', 'PATH', 'PATHEXT', 'PROCESSOR_ARCHITECTURE', 'PROCESSOR_IDENTIFIER', 'PROCESSOR_LEVEL', 'PROCESSOR_REVISION', 'PROGRAMFILES', 'PROMPT', 'PSModulePath', 'PUBLIC', 'PWD', 'ProgramData', 'ProgramFiles(x86)', 'ProgramW6432', 'RTOOLS43_HOME', 'RTOOLS44_HOME', 'R_ARCH', 'R_BROWSER', 'R_BZIPCMD', 'R_CMD', 'R_COMPILED_BY', 'R_CRAN_WEB', 'R_CUSTOM_TOOLS_PATH', 'R_CUSTOM_TOOLS_SOFT', 'R_DOC_DIR', 'R_ENVIRON_USER', 'R_GSCMD', 'R_GZIPCMD', 'R_HOME', 'R_INCLUDE_DIR', 'R_INSTALL_TAR', 'R_LIBS', 'R_LIBS_SITE', 'R_LIBS_USER', 'R_MAX_NUM_DLLS', 'R_OSTYPE', 'R_PAPERSIZE', 'R_PAPERSIZE_USER', 'R_PARALLELLY_MAKENODEPSOCK_AUTOKILL', 'R_PARALLELLY_MAKENODEPSOCK_CONNECTTIMEOUT', 'R_PARALLELLY_MAKENODEPSOCK_RSCRIPT_LABEL', 'R_PARALLELLY_MAKENODEPSOCK_SESSIONINFO_PKGS', 'R_PARALLELLY_MAKENODEPSOCK_TIMEOUT', 'R_PARALLELLY_RANDOM_PORTS', 'R_PARALLEL_PORT', 'R_RD4PDF', 'R_RTOOLS44_PATH', 'R_SCRIPT_LEGACY', 'R_SHARE_DIR', 'R_TESTS', 'R_UNZIPCMD', 'R_USER', 'R_VERSION', 'R_ZIPCMD', 'SED', 'SHLVL', 'SYSTEMDRIVE', 'SYSTEMROOT', 'TAR', 'TAR_OPTIONS', 'TEMP', 'TERM', 'TEXINPUTS', 'TMP', 'TMPDIR', 'USERDOMAIN', 'USERDOMAIN_ROAMINGPROFILE', 'USERNAME', 'USERPROFILE', 'WINDIR', '_', '_R_CHECK_AUTOCONF_', '_R_CHECK_BOGUS_RETURN_', '_R_CHECK_BROWSER_NONINTERACTIVE_', '_R_CHECK_BUILD_VIGNETTES_SEPARATELY_', '_R_CHECK_CODETOOLS_PROFILE_', '_R_CHECK_CODE_ASSIGN_TO_GLOBALENV_', '_R_CHECK_CODE_ATTACH_', '_R_CHECK_CODE_CLASS_IS_STRING_', '_R_CHECK_CODE_DATA_INTO_GLOBALENV_', '_R_CHECK_CODE_USAGE_VIA_NAMESPACES_', '_R_CHECK_CODE_USAGE_WITHOUT_LOADING_', '_R_CHECK_CODE_USAGE_WITH_ONLY_BASE_ATTACHED_', '_R_CHECK_CODOC_VARIABLES_IN_USAGES_', '_R_CHECK_COMPACT_DATA2_', '_R_CHECK_COMPILATION_FLAGS_', '_R_CHECK_CONNECTIONS_LEFT_OPEN_', '_R_CHECK_CRAN_INCOMING_', '_R_CHECK_CRAN_INCOMING_CHECK_FILE_URIS_', '_R_CHECK_CRAN_INCOMING_CHECK_URLS_IN_PARALLEL_', '_R_CHECK_CRAN_INCOMING_NOTE_GNU_MAKE_', '_R_CHECK_CRAN_INCOMING_REMOTE_', '_R_CHECK_CRAN_INCOMING_USE_ASPELL_', '_R_CHECK_DATALIST_', '_R_CHECK_DEPRECATED_DEFUNCT_', '_R_CHECK_DOC_SIZES2_', '_R_CHECK_DOT_FIRSTLIB_', '_R_CHECK_DOT_INTERNAL_', '_R_CHECK_EXAMPLE_TIMING_THRESHOLD_', '_R_CHECK_EXECUTABLES_', '_R_CHECK_EXECUTABLES_EXCLUSIONS_', '_R_CHECK_FF_CALLS_', '_R_CHECK_FF_DUP_', '_R_CHECK_FORCE_SUGGESTS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_LEEWAY_', '_R_CHECK_HAVE_MYSQL_', '_R_CHECK_HAVE_ODBC_', '_R_CHECK_HAVE_PERL_', '_R_CHECK_HAVE_POSTGRES_', '_R_CHECK_INSTALL_DEPENDS_', '_R_CHECK_INTERNALS2_', '_R_CHECK_LENGTH_1_CONDITION_', '_R_CHECK_LICENSE_', '_R_CHECK_LIMIT_CORES_', '_R_CHECK_MATRIX_DATA_', '_R_CHECK_MBCS_CONVERSION_FAILURE_', '_R_CHECK_NATIVE_ROUTINE_REGISTRATION_', '_R_CHECK_NEWS_IN_PLAIN_TEXT_', '_R_CHECK_NO_RECOMMENDED_', '_R_CHECK_NO_STOP_ON_TEST_ERROR_', '_R_CHECK_ORPHANED_', '_R_CHECK_OVERWRITE_REGISTERED_S3_METHODS_', '_R_CHECK_PACKAGES_USED_IGNORE_UNUSED_IMPORTS_', '_R_CHECK_PACKAGES_USED_IN_TESTS_USE_SUBDIRS_', '_R_CHECK_PACKAGE_DATASETS_SUPPRESS_NOTES_', '_R_CHECK_PACKAGE_NAME_', '_R_CHECK_PKG_SIZES_', '_R_CHECK_PKG_SIZES_THRESHOLD_', '_R_CHECK_PRAGMAS_', '_R_CHECK_RD_EXAMPLES_T_AND_F_', '_R_CHECK_RD_LINE_WIDTHS_', '_R_CHECK_RD_MATH_RENDERING_', '_R_CHECK_RD_NOTE_LOST_BRACES_', '_R_CHECK_RD_VALIDATE_RD2HTML_', '_R_CHECK_REPLACING_IMPORTS_', '_R_CHECK_R_DEPENDS_', '_R_CHECK_S3_METHODS_SHOW_POSSIBLE_ISSUES_', '_R_CHECK_SCREEN_DEVICE_', '_R_CHECK_SERIALIZATION_', '_R_CHECK_SHLIB_OPENMP_FLAGS_', '_R_CHECK_SRC_MINUS_W_IMPLICIT_', '_R_CHECK_SUBDIRS_NOCASE_', '_R_CHECK_SUGGESTS_ONLY_', '_R_CHECK_SYSTEM_CLOCK_', '_R_CHECK_TESTS_NLINES_', '_R_CHECK_TEST_TIMING_', '_R_CHECK_TIMINGS_', '_R_CHECK_TOPLEVEL_FILES_', '_R_CHECK_UNDOC_USE_ALL_NAMES_', '_R_CHECK_UNSAFE_CALLS_', '_R_CHECK_URLS_SHOW_301_STATUS_', '_R_CHECK_VC_DIRS_', '_R_CHECK_VIGNETTES_NLINES_', '_R_CHECK_VIGNETTES_SKIP_RUN_MAYBE_', '_R_CHECK_VIGNETTE_TIMING_', '_R_CHECK_VIGNETTE_TITLES_', '_R_CHECK_WINDOWS_DEVICE_', '_R_CHECK_XREFS_USE_ALIASES_FROM_CRAN_', '_R_CLASS_MATRIX_ARRAY_', '_R_DEPRECATED_IS_R_', '_R_S3_METHOD_LOOKUP_BASEENV_AFTER_GLOBALENV_', '_R_SHLIB_BUILD_OBJECTS_SYMBOL_TABLES_', '__R_CHECK_DOC_FILES_NOTE_IF_ALL_SPECIAL__', 'maj.version', 'nextArg--timingsnextArg--install'
 - Environment variables still there: [n=0] 
 - Environment variables missing: [n=1] 'MAKEFLAGS'
Differences environment variable by environment variable:
List of 3
 $ name    : chr "MAKEFLAGS"
 $ expected: 'Dlist' chr ""
 $ actual  : 'Dlist' chr NA
> 
> proc.time()
   user  system elapsed 
   4.29    0.20    5.32