performance loss in as_list_of() due to list2()

[mgirlich]

Both as_list_of.list() and as_list_of.vctrs_list_of() call list_of(!!!x, .ptype = .ptype) which directly collects the input again via list2(). As profvis shows this roundtrip doubles to triples the time required

vctrs:::as_list_of.list <- function (x, ..., .ptype = NULL) {
    list_of(!!!x, .ptype = .ptype)
}

vctrs:::list_of <- function (..., .ptype = NULL) {
    args <- list2(...)
    ptype <- vec_ptype_common(!!!args, .ptype = .ptype)
    if (is.null(ptype)) {
        abort("Could not find common type for elements of `x`.")
    }
    x <- map(args, vec_cast, to = ptype)
    new_list_of(x, ptype)
}

I don't know if r-lib/rlang#937 would help to speed this up but it would be great if one could avoid this performance loss which feels quite unnecessary.

[lionel-]

I don't think there is an alternative here. We need both args and ptype. I'll look into optimising list2() for simple cases, but this is not high priority right now.

[lionel-]

@DavisVaughan pointed out I misinterpreted your comment, which was about the duplicate collection between as-list-of and list-of, not the one in list-of.

[DavisVaughan]

Could you please provide a reprex that generated the profvis output that you are showing?

[mgirlich]

Ah, sorry, it's not completely correct what I've written above. It is only taking so much time when the input is a list_of object, not for a normal list.

library(vctrs)

x_list <- as.list(1:1e6)
x_list_of <- as_list_of(as.list(1:1e6))

bench::mark(
  list = as_list_of(x_list, .ptype = integer()),
  list_of = as_list_of(x_list_of, .ptype = integer())
)
#> Warning: Some expressions had a GC in every iteration; so filtering is disabled.
#> # A tibble: 2 x 6
#>   expression      min   median `itr/sec` mem_alloc `gc/sec`
#>   <bch:expr> <bch:tm> <bch:tm>     <dbl> <bch:byt>    <dbl>
#> 1 list          1.55s    1.55s     0.645    30.5MB     4.51
#> 2 list_of       3.55s    3.55s     0.281    38.2MB     5.07

According to profvis the list2() call only needs 20 ms for the normal list input. When I checked this with bench::mark() something weird seems to be going on as the performance is slow for both list and list_of. Checking the speed of rlang::list2(!!!x_list) outside of bench::mark() was always fast (also after restarting R). Am I overseeing something here?

library(vctrs)

x_list <- as.list(1:1e6)
x_list_of <- as_list_of(as.list(1:1e6))


bench::mark(
  list = rlang::list2(!!!x_list),
  list_of = rlang::list2(!!!x_list_of)
)
#> Warning: Some expressions had a GC in every iteration; so filtering is disabled.
#> # A tibble: 2 x 6
#>   expression      min   median `itr/sec` mem_alloc `gc/sec`
#>   <bch:expr> <bch:tm> <bch:tm>     <dbl> <bch:byt>    <dbl>
#> 1 list          1.11s    1.11s     0.898    7.63MB    2.69 
#> 2 list_of    455.89ms 503.59ms     1.99     7.63MB    0.993

t_start <- Sys.time()
tmp <- rlang::list2(!!!x_list)
Sys.time() - t_start
#> Time difference of 0.01694703 secs

t_start <- Sys.time()
tmp <- rlang::list2(!!!x_list_of)
Sys.time() - t_start
#> Time difference of 2.113888 secs

^{Created on 2020-06-30 by the reprex package (v0.3.0)}

[DavisVaughan]

You are seeing an interaction of !!! and bench::mark() that has been fixed in the devel version of bench. r-lib/bench@7018fb3

If you don't want the devel version you can hack around it with this

library(vctrs)

x_list <- as.list(1:1e6)
x_list_of <- as_list_of(as.list(1:1e6))

list2_splice <- function(x) {
  rlang::list2(!!!x)
}

bench::mark(
  list = list2_splice(x_list),
  list_of = list2_splice(x_list_of)
)
#> Warning: Some expressions had a GC in every iteration; so filtering is disabled.
#> # A tibble: 2 x 6
#>   expression      min   median `itr/sec` mem_alloc `gc/sec`
#>   <bch:expr> <bch:tm> <bch:tm>     <dbl> <bch:byt>    <dbl>
#> 1 list        11.17ms  13.45ms    70.9      7.63MB    11.5 
#> 2 list_of       1.15s    1.15s     0.868   19.12MB     8.68

[DavisVaughan]

@lionel- the difference seen in list2() between list2(!!! <list>) and list2(!!! <list_of>) is driven by rlang:::rlang_as_list(), which is that fallback for S3 objects.

It may be worth rewriting the rlang_as_list_from_list() branch of that in C since that is what takes all the time (but we'd have to consider the fact that we'd lose the generic-ness of [[ if we did that)

(using x_list_of from above as x here)

Browse[2]> bench::mark(rlang_as_list_from_list_impl(x))
# A tibble: 1 x 13
  expression                        min median `itr/sec` mem_alloc `gc/sec` n_itr  n_gc total_time
  <bch:expr>                      <bch> <bch:>     <dbl> <bch:byt>    <dbl> <int> <dbl>   <bch:tm>
1 rlang_as_list_from_list_impl(x) 1.07s  1.07s     0.936    7.63MB     4.68     1     5      1.07s
# … with 4 more variables: result <list>, memory <list>, time <list>, gc <list>

Most of the time is in the [[ dispatch and calling of [[.vctrs_list_of in rlang_as_list_from_list()

[lionel-]

The purpose of this function is to call the generic [[ though

[lionel-]

As we have learned in #1226, transforming a classed list that inherits from "list" to a bare list can be very fast. I have opened r-lib/rlang#1140 to track this. Thanks for the report!