ARROW-9140: [R] Zero-copy Arrow to R where possible #10445

romainfrancois · 2021-06-03T15:10:11Z

This makes altrep R vectors of type INTSXP or REALSXP from arrow::Array of type Int32Type / DoubleType that don't have any nulls:

the altrep vector holds an external pointer so that the Array stays around, and its payload is shared. The R vector is marked as not mutable.

library(arrow, warn.conflicts = FALSE)
#> See arrow_info() for available features

create a “big” arrow Array with no nulls (just for testing purposes)

a <- arrow:::Test_array_nonull_dbl_vector(1e7)

turn into R vector, using altrep, sharing the payload

v <- a$as_vector()

verify it’s an altrep with the inspect method

.Internal(inspect(v))
#> @7f9abf8ba470 14 REALSXP g0c0 [REF(65535)] std::shared_ptr<arrow::Array, double, NONULL> (len=10000000, ptr=0x7f9ab5c8cd18)

it’s marked as not mutable so check that modify -> duplicate

v[1] <- 0
#> Duplicate
.Internal(inspect(v))
#> @7f9ac0000000 14 REALSXP g1c7 [MARK,REF(1)] (len=10000000, tl=0) 0,42,42,42,42,...

timings for double vector

bench::workout({
  a <- arrow:::Test_array_nonull_dbl_vector(1e7)
  v <- a$as_vector()
  .Internal(inspect(v))
  v[1] <- 0
  .Internal(inspect(v))
})
#> @7f9abc122190 14 REALSXP g0c0 [REF(65535)] std::shared_ptr<arrow::Array, double, NONULL> (len=10000000, ptr=0x7f9aba2109c8)
#> Duplicate
#> @7f9aa5c00000 14 REALSXP g1c7 [MARK,REF(1)] (len=10000000, tl=0) 0,42,42,42,42,...
#> # A tibble: 5 x 3
#>   exprs                                             process     real
#>   <bch:expr>                                       <bch:tm> <bch:tm>
#> 1 a <- arrow:::Test_array_nonull_dbl_vector(1e+07)   70.3ms   70.6ms
#> 2 v <- a$as_vector()                                   13µs   14.3µs
#> 3 .Internal(inspect(v))                                12µs   11.9µs

when a copy is needed, the data is copied entirely:

#> 4 v[1] <- 0                                          53.1ms   53.2ms
#> 5 .Internal(inspect(v))                                20µs   22.6µs

timings for integer vector

bench::workout({
  a <- arrow:::Test_array_nonull_int_vector(1e7)
  v <- a$as_vector()
  .Internal(inspect(v))
  v[1] <- 0
  .Internal(inspect(v))
})
#> @7f9abc5bd780 13 INTSXP g0c0 [REF(65535)] std::shared_ptr<arrow::Array, int32, NONULL> (len=10000000, ptr=0x7f9ab8997378)
#> @7f9ac0000000 14 REALSXP g1c7 [MARK,REF(1)] (len=10000000, tl=0) 0,42,42,42,42,...
#> # A tibble: 5 x 3
#>   exprs                                             process     real
#>   <bch:expr>                                       <bch:tm> <bch:tm>
#> 1 a <- arrow:::Test_array_nonull_int_vector(1e+07)   54.5ms   54.7ms
#> 2 v <- a$as_vector()                                   12µs   13.2µs
#> 3 .Internal(inspect(v))                                11µs   11.3µs
#> 4 v[1] <- 0                                         851.4ms  854.6ms
#> 5 .Internal(inspect(v))                                17µs   18.8µs

^{Created on 2021-06-08 by the reprex package (v2.0.0)}

github-actions · 2021-06-08T08:08:41Z

https://issues.apache.org/jira/browse/ARROW-9140

romainfrancois · 2021-06-08T10:39:14Z

An interesting side benefit from this is that we don't get altrep R vectors from slices:

library(arrow, warn.conflicts = FALSE)
#> See arrow_info() for available features

x <- 1:1e3+ 1L
v <- Array$create(x)
x1 <- v$as_vector()  
.Internal(inspect(x1))
#> @7face1b4ba18 13 INTSXP g0c0 [REF(65535)] std::shared_ptr<arrow::Array, int32, NONULL> (len=1000, ptr=0x7facdc27e998)

x2 <- v$Slice(500)$as_vector()
.Internal(inspect(x2))
#> @7facde2bfd80 13 INTSXP g0c0 [REF(65535)] std::shared_ptr<arrow::Array, int32, NONULL> (len=500, ptr=0x7facdb0a2198)

^{Created on 2021-06-08 by the reprex package (v2.0.0)}

romainfrancois · 2021-06-08T11:14:29Z

@nealrichardson I've turned off making INT64 arrays with no nulls into altrep bit64::integer64 vectors (i.e. reusing the payload of the array as the data of the underlying double array in R ...) because of the auto downcasting to int vectors when it fits:

library(arrow, warn.conflicts = FALSE)

i64 <- Array$create(bit64::as.integer64(1:10))
.Internal(inspect(as.vector(i64)))
#> @7ff0b2099c38 13 INTSXP g0c4 [REF(2)] (len=10, tl=0) 1,2,3,4,5,...

^{Created on 2021-06-08 by the reprex package (v2.0.0)}

I can altogether remove the int64 altrep code if needed ... ?

nealrichardson · 2021-06-08T15:07:54Z

This is super cool. We should get some benchmarking on this.

Tangentially related, should we have an options(arrow.altrep) or something to govern whether to use ALTREP? I know vroom has a function argument to enable or disable it (though I don't know why exactly). Might be useful to have in case there are unforeseen issues, or if nothing else it would make it easy for people to test side-by-side the performance.

romainfrancois · 2021-06-08T15:56:15Z

Interesting, we could make that opt-in. For now it's all happening here so would be easy enough to make conditional:

// [[arrow::export]]
SEXP Array__as_vector(const std::shared_ptr<arrow::Array>& array) {
  auto type = array->type();

#if defined(HAS_ALTREP)
  if (array->null_count() == 0) {
    switch (type->id()) {
      case arrow::Type::DOUBLE:
        return arrow::r::Make_array_nonull_dbl_vector(array);
      case arrow::Type::INT32:
        return arrow::r::Make_array_nonull_int_vector(array);
        // case arrow::Type::INT64:
        //   return arrow::r::Make_array_nonull_int64_vector(array);

      default:
        break;
    }
  }
#endif

  return arrow::r::ArrayVector__as_vector(array->length(), type, {array});
}

nealrichardson · 2021-06-08T16:55:32Z

Cool, so that would just be if(GetBoolOption("arrow.altrep", true) && array->null_count() == 0)

romainfrancois · 2021-06-09T11:07:15Z

I've used arrow.use_altrep but I can use arrow.altrep all the same.

I've put GetBoolOption("arrow.altrep", true) after the array->null_count() == 0 because it's cheaper to call null_count().

GetBoolOption("arrow.altrep", true) means that this is opt-out, I'm fine with this but it might be risky.

nealrichardson · 2021-06-09T21:18:37Z

I've used arrow.use_altrep but I can use arrow.altrep all the same.

SGTM

I've put GetBoolOption("arrow.altrep", true) after the array->null_count() == 0 because it's cheaper to call null_count().

That surprises me, I'd expect that checking an R boolean would be faster than counting nulls in a (potentially long) array.

GetBoolOption("arrow.altrep", true) means that this is opt-out, I'm fine with this but it might be risky.

I think defaulting to ALTREP on is good (particularly if/when we quantify its benefits) but leaving an escape hatch in case of error is nice.

pitrou

Not an R user, but here are some comments.

r/src/altrep.cpp

r/src/array_to_vector.cpp

r/tests/testthat/test-altrep.R

jonkeane · 2021-06-10T19:48:09Z

Ok, I've run some benchmarks on this branch and I'm seeing a huge speed up for floats + integers with as.vector(array). 🎉

It might be out of scope for this PR, but chunked arrays don't see a similar speed up (which makes sense given they call ArrayVector__as_vector directly rather than routing through Array__as_vector, so they aren't being using alt rep). I can't quite tell from the cpp if Table__to_dataframe would just work with alt rep as well if it worked with ChunkedArrays or if we would need to more to facilitate that.

library(arrow, warn.conflicts = FALSE)

x <- 1:1e3+ 1L
v <- Array$create(x)
x1 <- v$as_vector()  
.Internal(inspect(x1))
#> @7f9077f5a1a8 13 INTSXP g0c0 [REF(65535)] std::shared_ptr<arrow::Array, int32, NONULL> (len=1000, ptr=0x7f90975a9a08)


v_chunked <- ChunkedArray$create(x)
x2 <- v_chunked$as_vector()  
.Internal(inspect(x2))
#> @7f908312c000 13 INTSXP g0c7 [REF(2)] (len=1000, tl=0) 2,3,4,5,6,...

^{Created on 2021-06-10 by the reprex package (v2.0.0)}

arrowbench results (using the new benchmarks in voltrondata-labs/arrowbench#28):
zero-copy-data-conversion.html.zip

… no nulls into an altrep R numeric vector w/ no copy

…e `arrow.use_altrep` option (with default to TRUE: opt out)

- const std::shared_ptr<Array>& Get()

romainfrancois · 2021-06-17T13:44:44Z

@jonkeane we might be able to deal with a fake ChunkedArrray that has only one array, but otherwise we can't use the same trick with general (more than 1 array) case, because by construction the payload of these arrays is not contiguous, which is what we leverage here.

I believe this can be a follow up pull request with some altrep vectors to wrap chunked arrays, and arrays with nulls. Implementation will be different, e.g. the DATAPTR() will cause materialization (and so be expensive) but for things that are altrep aware and know how to iterate by region, we might be able to only materialize regions as needed.

jonkeane · 2021-06-17T13:56:32Z

That sounds good. The faked ChunkedArray with one chunk might be (surprisingly) beneficial, at least in (some? see below) parquet reading situations.

With csv reading, we frequently (with sufficiently large csvs) get multiple chunks, but I've tried reading parquet a few times to get a table with chunked arrays where there are more than one chunk and haven't so far seen it happen. I need to dig more into the parquet reading source code to see if it is ever possible to get more-than-1-chunks-ChunkedArrays from reading a parquet.

tab <- Table$create(x = 1:100)
tf <- tempfile(); on.exit(unlink(tf))
write_parquet(tab, tf, chunk_size = 10)
read_tab <- read_parquet(tf, as_data_frame = FALSE) 
read_tab[[1]]$num_chunks

romainfrancois · 2021-06-18T09:34:48Z

library(arrow, warn.conflicts = FALSE)
#> See arrow_info() for available features

c_int <- ChunkedArray$create(1:1000)
c_dbl <- ChunkedArray$create(as.numeric(1:1000))
c_int$num_chunks
#> [1] 1
c_dbl$num_chunks
#> [1] 1
.Internal(inspect(as.vector(c_int)))
#> @7fc1314ce2a8 13 INTSXP g0c0 [REF(65535)] std::shared_ptr<arrow::Array, int32, NONULL> (len=1000, ptr=0x7fc1274a0408)
.Internal(inspect(as.vector(c_dbl)))
#> @7fc131528a90 14 REALSXP g0c0 [REF(65535)] std::shared_ptr<arrow::Array, double, NONULL> (len=1000, ptr=0x7fc12b2b5178)

^{Created on 2021-06-18 by the reprex package (v2.0.0.9000)}

I think I'll deal with this https://issues.apache.org/jira/browse/ARROW-13114 here as well, and then do a follow up for using RTasks (i.e. https://issues.apache.org/jira/browse/ARROW-13113).

romainfrancois · 2021-06-18T12:48:30Z

Actually, I now think it is better to do the RTasks thing first https://issues.apache.org/jira/browse/ARROW-13113 and then rework RecordBatch__to_dataframe() and Table__to_dataframe()

romainfrancois · 2021-06-18T13:17:08Z

I'm not sure why we get this: https://github.com/apache/arrow/pull/10445/checks?check_run_id=2858594249#step:8:2641

bkietz · 2021-06-18T18:40:30Z

I'm not sure why we get this: https://github.com/apache/arrow/pull/10445/checks?check_run_id=2858594249#step:8:2641

Looks like linking the arrow binding failed. There's a cpp11 symbol missing
https://github.com/apache/arrow/pull/10445/checks?check_run_id=2858594151#step:9:5579

... which is odd because it's a template, so it ought to be inlined everywhere

bkietz

This is neat, thanks for doing it. Some minor comments:

r/src/array_to_vector.cpp

bkietz · 2021-06-18T18:16:57Z

r/src/altrep.cpp

+}
+
+SEXP MakeInt32ArrayNoNull(const std::shared_ptr<Array>& array) {
+  return Int32ArrayNoNull::Make(array);


Edge case worthy of mention in a comment somewhere: IIUC this doesn't check for instances of NA_integer_ in array and these will be considered null by R even though is_altrep_int_nonull(as.vector(array)) (and we report no_NA = 1)

I'll think about where to mention this, but this isn't limited to these altrep variants. any int32 array that happens to have a non null NA_integer_ will be mismanaged by R with this sentinel approach.

r/src/altrep.cpp

Co-authored-by: Benjamin Kietzman <bengilgit@gmail.com>

romainfrancois · 2021-06-21T07:58:22Z

@nealrichardson I believe this is ready to go

r/src/altrep.cpp

github-actions bot added the Component: R label Jun 8, 2021

romainfrancois force-pushed the ARROW_9140_zero_copy branch from f2db09c to 320b33f Compare June 8, 2021 11:08

romainfrancois marked this pull request as ready for review June 8, 2021 11:52

nealrichardson requested a review from bkietz June 9, 2021 02:51

pitrou reviewed Jun 10, 2021

View reviewed changes

romainfrancois added 9 commits June 17, 2021 14:12

skeleton for short-circuit to altrep vector with zero copy

6a2d388

initial implementation for converting an Array of DoubleType that has…

9f5067c

… no nulls into an altrep R numeric vector w/ no copy

+ altrep integer vector

445627b

handle offset in Dataptr()

57d6cf7

fix int64 support

4287818

turning off int64 altrep for now

f9c55d0

lint

3ffc90f

test for altrep-ness

935ebbb

remove int64 specific altrep code and condition altrepification on th…

8721259

…e `arrow.use_altrep` option (with default to TRUE: opt out)

romainfrancois force-pushed the ARROW_9140_zero_copy branch from 50a88df to 8721259 Compare June 17, 2021 12:13

romainfrancois added 4 commits June 17, 2021 14:50

- Make array_nonnull a template

0485ce1

- const std::shared_ptr<Array>& Get()

use GetValues<>(1)

5af3bdb

more tests

cb71467

swap again option and null_count, only altrep non empty

ac371d2

This comment has been minimized.

Sign in to view

chunked arrays with only one array get altrep'ed

26d4721

+ template keyword

1dc89eb

simplify and CamelCase

cee2e60

bkietz requested changes Jun 18, 2021

View reviewed changes

romainfrancois and others added 3 commits June 21, 2021 09:16

Update r/src/array_to_vector.cpp

9456dfa

Co-authored-by: Benjamin Kietzman <bengilgit@gmail.com>

show the external pointer in inspect

598f752

inspect the subtree

e756d7c

being explicit about the Deleter

adb0d4a

bkietz reviewed Jun 21, 2021

View reviewed changes

r/src/altrep.cpp Outdated Show resolved Hide resolved

bkietz and others added 2 commits June 21, 2021 14:32

try using non-default_deleter

bfb5de1

lint

a5f0253

nealrichardson closed this in 593a08d Jun 23, 2021

asfimport mentioned this pull request Jun 23, 2021

[R] Zero-copy Arrow to R where possible #25249

Closed

ARROW-9140: [R] Zero-copy Arrow to R where possible #10445

ARROW-9140: [R] Zero-copy Arrow to R where possible #10445

Uh oh!

Conversation

romainfrancois commented Jun 3, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

github-actions bot commented Jun 8, 2021

Uh oh!

romainfrancois commented Jun 8, 2021

Uh oh!

romainfrancois commented Jun 8, 2021

Uh oh!

nealrichardson commented Jun 8, 2021

Uh oh!

romainfrancois commented Jun 8, 2021

Uh oh!

nealrichardson commented Jun 8, 2021

Uh oh!

romainfrancois commented Jun 9, 2021

Uh oh!

nealrichardson commented Jun 9, 2021

Uh oh!

pitrou left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

jonkeane commented Jun 10, 2021

Uh oh!

romainfrancois commented Jun 17, 2021

Uh oh!

jonkeane commented Jun 17, 2021

Uh oh!

This comment has been minimized.

romainfrancois commented Jun 18, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

romainfrancois commented Jun 18, 2021

Uh oh!

romainfrancois commented Jun 18, 2021

Uh oh!

bkietz commented Jun 18, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

bkietz left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

bkietz Jun 18, 2021

Choose a reason for hiding this comment

Uh oh!

romainfrancois Jun 21, 2021

Choose a reason for hiding this comment

Uh oh!

Uh oh!

romainfrancois commented Jun 21, 2021

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

5 participants

romainfrancois commented Jun 3, 2021 •

edited

Loading

romainfrancois commented Jun 18, 2021 •

edited

Loading

bkietz commented Jun 18, 2021 •

edited

Loading