Clarify ALTREP array boundary semantics

Author: sounkou-bioinfo

NEWS.md

@@ -1,6 +1,7 @@
 # Rtinycc 0.1.11
 
 - Add `tcc_list_symbols()` to inspect global symbol names and resolved hexadecimal addresses known to a libtcc state.
+- Improve ALTREP-aware copy-in paths by using `RAW_GET_REGION()` when copying raw vectors into native memory and scalar accessors for callback/struct scalar conversions. Clarify that mutable array FFI inputs can materialize ALTREP vectors when R exposes writable C storage.
 - Fix `PROTECT` and memory-balance hygiene bugs in internal C state initialization (`RC_libtcc_state_new`, `RC_libtcc_get_symbol`, and callback registration paths). Previously, class string attributes could be inadvertently allocated without proper protection.
 - Fix a stack-depth and protection imbalance bug in `RC_invoke_callback_internal` where callback execution could unexpectedly unprotect the `call` object prior to evaluation.
 

R/aaa_ffi_codegen_matrix.R

@@ -580,7 +580,13 @@ RTINYCC_FFI_SEMANTICS <- list(
       ownership = "R",
       r_storage = "raw",
       checks = character(),
-      notes = "Zero-copy borrow of RAW(x); sound only while no fresh R allocations are inserted before the C call."
+      notes = paste(
+        "Mutable pointer input through RAW(x); for ordinary materialized vectors",
+        "no extra buffer is allocated. ALTREP vectors follow R's writable pointer",
+        "materialization path. ALTREP-specific read-only or temp-buffer behavior",
+        "needs a separate access-mode contract because this type permits mutation",
+        "and pointer aliasing."
+      )
     ),
     return = list(
       mode = "copy_array",
@@ -601,7 +607,13 @@ RTINYCC_FFI_SEMANTICS <- list(
       ownership = "R",
       r_storage = "integer",
       checks = character(),
-      notes = "Zero-copy borrow of INTEGER(x); sound only while no fresh R allocations are inserted before the C call."
+      notes = paste(
+        "Mutable pointer input through INTEGER(x); for ordinary materialized",
+        "vectors no extra buffer is allocated. ALTREP vectors follow R's writable",
+        "pointer materialization path. ALTREP-specific read-only or temp-buffer",
+        "behavior needs a separate access-mode contract because this type permits",
+        "mutation and pointer aliasing."
+      )
     ),
     return = list(
       mode = "copy_array",
@@ -622,7 +634,13 @@ RTINYCC_FFI_SEMANTICS <- list(
       ownership = "R",
       r_storage = "numeric",
       checks = character(),
-      notes = "Zero-copy borrow of REAL(x); sound only while no fresh R allocations are inserted before the C call."
+      notes = paste(
+        "Mutable pointer input through REAL(x); for ordinary materialized vectors",
+        "no extra buffer is allocated. ALTREP vectors follow R's writable pointer",
+        "materialization path. ALTREP-specific read-only or temp-buffer behavior",
+        "needs a separate access-mode contract because this type permits mutation",
+        "and pointer aliasing."
+      )
     ),
     return = list(
       mode = "copy_array",
@@ -643,7 +661,13 @@ RTINYCC_FFI_SEMANTICS <- list(
       ownership = "R",
       r_storage = "logical",
       checks = character(),
-      notes = "Zero-copy borrow of LOGICAL(x); sound only while no fresh R allocations are inserted before the C call."
+      notes = paste(
+        "Mutable pointer input through LOGICAL(x); for ordinary materialized",
+        "vectors no extra buffer is allocated. ALTREP vectors follow R's writable",
+        "pointer materialization path. ALTREP-specific read-only or temp-buffer",
+        "behavior needs a separate access-mode contract because this type permits",
+        "mutation and pointer aliasing."
+      )
     ),
     return = list(
       mode = "copy_array",
@@ -1083,8 +1107,9 @@ RTINYCC_COMPOSITE_SEMANTICS <- list(
     write_copy = TRUE,
     ownership = "struct-owned-storage",
     notes = paste(
-      "Raw struct helpers copy bytes out to a fresh RAWSXP or copy bytes from",
-      "a RAWSXP back into the struct buffer with memcpy()."
+      "Raw struct helpers copy bytes out to a fresh RAWSXP with memcpy() and",
+      "copy bytes from a RAWSXP back into the struct buffer with RAW_GET_REGION(),",
+      "which avoids asking R for a writable raw-vector data pointer on copy-in."
     )
   ),
   struct_array_field = list(
@@ -1253,7 +1278,7 @@ RTINYCC_COMPOSITE_CODEGEN_SPECS <- list(
   ),
   list(
     name = "struct_raw_access_copy",
-    info = "struct raw access helpers use memcpy copy paths",
+    info = "struct raw access helpers use explicit copy paths",
     generate_args = list(
       symbols = list(),
       c_code = "struct packet { unsigned char data[8]; };",
@@ -1276,7 +1301,7 @@ RTINYCC_COMPOSITE_CODEGEN_SPECS <- list(
         fixed = TRUE
       ),
       list(
-        pattern = "memcpy(p, RAW(raw),",
+        pattern = "RAW_GET_REGION(raw, 0, n_copy, (Rbyte*)p)",
         fixed = TRUE
       )
     )

R/aaa_ffi_codegen_rules.R

@@ -537,7 +537,7 @@ struct_array_field_setter_rule("i32", field_name) %as%
 
 struct_array_field_setter_rule("i64", field_name) %as%
   {
-    sprintf("p->%s[idx] = (int64_t)REAL(val)[0];", field_name)
+    sprintf("p->%s[idx] = (int64_t)asReal(val);", field_name)
   }
 
 struct_array_field_setter_rule("u8", field_name) %as%
@@ -552,22 +552,22 @@ struct_array_field_setter_rule("u16", field_name) %as%
 
 struct_array_field_setter_rule("u32", field_name) %as%
   {
-    sprintf("p->%s[idx] = (uint32_t)REAL(val)[0];", field_name)
+    sprintf("p->%s[idx] = (uint32_t)asReal(val);", field_name)
   }
 
 struct_array_field_setter_rule("u64", field_name) %as%
   {
-    sprintf("p->%s[idx] = (uint64_t)REAL(val)[0];", field_name)
+    sprintf("p->%s[idx] = (uint64_t)asReal(val);", field_name)
   }
 
 struct_array_field_setter_rule("f32", field_name) %as%
   {
-    sprintf("p->%s[idx] = (float)REAL(val)[0];", field_name)
+    sprintf("p->%s[idx] = (float)asReal(val);", field_name)
   }
 
 struct_array_field_setter_rule("f64", field_name) %as%
   {
-    sprintf("p->%s[idx] = REAL(val)[0];", field_name)
+    sprintf("p->%s[idx] = asReal(val);", field_name)
   }
 
 struct_array_field_setter_rule("bool", field_name) %as%
@@ -604,7 +604,7 @@ struct_field_setter_rule("i32", field_name, size) %as%
 
 struct_field_setter_rule("i64", field_name, size) %as%
   {
-    sprintf("p->%s = (int64_t)REAL(val)[0];", field_name)
+    sprintf("p->%s = (int64_t)asReal(val);", field_name)
   }
 
 struct_field_setter_rule("u8", field_name, size) %as%
@@ -619,12 +619,12 @@ struct_field_setter_rule("u16", field_name, size) %as%
 
 struct_field_setter_rule("u32", field_name, size) %as%
   {
-    sprintf("p->%s = (uint32_t)REAL(val)[0];", field_name)
+    sprintf("p->%s = (uint32_t)asReal(val);", field_name)
   }
 
 struct_field_setter_rule("u64", field_name, size) %as%
   {
-    sprintf("p->%s = (uint64_t)REAL(val)[0];", field_name)
+    sprintf("p->%s = (uint64_t)asReal(val);", field_name)
   }
 
 struct_field_setter_rule("f32", field_name, size) %as%

R/ffi_codegen.R

@@ -921,12 +921,14 @@ generate_struct_raw_access <- function(struct_name) {
     sprintf("SEXP R_wrap_struct_%s_set_raw(SEXP ext, SEXP raw) {", struct_name),
     sprintf("  struct %s *p = R_ExternalPtrAddr(ext);", struct_name),
     sprintf("  if (!p) Rf_error(\"Null pointer\");"),
-    "  int n = LENGTH(raw);",
+    "  if (TYPEOF(raw) != RAWSXP) Rf_error(\"expected raw vector\");",
+    "  R_xlen_t n = XLENGTH(raw);",
     sprintf(
-      "  memcpy(p, RAW(raw), (n < sizeof(struct %s)) ? n : sizeof(struct %s));",
+      "  R_xlen_t n_copy = (n < (R_xlen_t)sizeof(struct %s)) ? n : (R_xlen_t)sizeof(struct %s);",
       struct_name,
       struct_name
     ),
+    "  if (n_copy > 0 && RAW_GET_REGION(raw, 0, n_copy, (Rbyte*)p) != n_copy) Rf_error(\"failed to read raw vector\");",
     "  return R_NilValue;",
     "}",
     ""

R/ffi_types.R

@@ -11,7 +11,9 @@
 # - numeric() → double* (via REAL())
 # - logical() → int* (via LOGICAL())
 #
-# We support both scalar types (with coercion) and array types (zero-copy)
+# We support both scalar types (with coercion) and array types. Array inputs
+# borrow writable R vector storage for materialized vectors; ALTREP vectors may
+# be materialized by R when the wrapper asks for a C data pointer.
 
 new_rtinycc_ffi_type <- function(name, ..., family = name) {
   fields <- list(name = name, family = family, ...)
@@ -101,7 +103,8 @@ FFI_TYPES <- list(
     kind = "scalar"
   ),
 
-  # Array types - R native vector types (zero-copy)
+  # Array types - R native vector types. These are writable pointer borrows;
+  # ALTREP inputs may materialize when R exposes the C data pointer.
   # R raw vector → uint8_t* (byte buffer)
   raw = list(
     c_type = "uint8_t*",
@@ -112,7 +115,7 @@ FFI_TYPES <- list(
     c_element = "uint8_t"
   ),
 
-  # R integer vector → int32_t* (zero-copy via INTEGER())
+  # R integer vector → int32_t* (writable borrow via INTEGER())
   integer_array = list(
     c_type = "int32_t*",
     r_type = "integer",
@@ -122,7 +125,7 @@ FFI_TYPES <- list(
     c_element = "int32_t"
   ),
 
-  # R numeric vector → double* (zero-copy via REAL())
+  # R numeric vector → double* (writable borrow via REAL())
   numeric_array = list(
     c_type = "double*",
     r_type = "numeric",
@@ -132,7 +135,7 @@ FFI_TYPES <- list(
     c_element = "double"
   ),
 
-  # R logical vector → int* (zero-copy via LOGICAL())
+  # R logical vector → int* (writable borrow via LOGICAL())
   logical_array = list(
     c_type = "int*",
     r_type = "logical",

README.Rmd

@@ -1104,8 +1104,8 @@ In practice, the usual pattern is:
 
 - `Rtinycc` compiles tiny modules very quickly
 - a regular `.Call()` module can have lower minimal per-call overhead
-- array-oriented zero-copy inputs are a much better fit than many tiny scalar
-  crossings
+- array-oriented inputs can be zero-copy for already-materialized R vectors,
+  but ALTREP inputs may materialize when C pointer access is requested
 - return paths that copy native buffers back into fresh R vectors make that
   copy cost visible
 

README.md

@@ -1979,8 +1979,9 @@ In practice, the usual pattern is:
 
 - `Rtinycc` compiles tiny modules very quickly
 - a regular `.Call()` module can have lower minimal per-call overhead
-- array-oriented zero-copy inputs are a much better fit than many tiny
-  scalar crossings
+- array-oriented inputs can be zero-copy for already-materialized R
+  vectors, but ALTREP inputs may materialize when C pointer access is
+  requested
 - return paths that copy native buffers back into fresh R vectors make
   that copy cost visible
 

TODO

@@ -1,3 +1,4 @@
+- design explicit ALTREP-aware FFI array semantics before changing mutable array inputs; decide whether to add read-only array types, inout copy-back modes, aliasing rules, and when to use *_GET_REGION(), DATAPTR_RO(), or writable materialization
 - add simple input types for tcc_call_symbol
 - add simple more types
 - setjump support for tcc_call_symbol

src/RC_libtcc.c

@@ -1138,7 +1138,10 @@ SEXP RC_write_bytes(SEXP ptr, SEXP raw) {
     }
     R_xlen_t n = XLENGTH(raw);
     if (n > 0) {
-        memcpy(data, RAW(raw), (size_t)n);
+        R_xlen_t copied = RAW_GET_REGION(raw, 0, n, (Rbyte*)data);
+        if (copied != n) {
+            Rf_error("failed to read raw vector");
+        }
     }
     return R_NilValue;
 }

src/platform_async.c

@@ -16,13 +16,13 @@ static cb_result_t cb_result_from_sexp(SEXP s) {
     if (s == R_NilValue) return r;
     if (Rf_isInteger(s) && XLENGTH(s) >= 1) {
         r.kind = CB_RESULT_INT;
-        r.v.i  = INTEGER(s)[0];
+        r.v.i  = Rf_asInteger(s);
     } else if (Rf_isReal(s) && XLENGTH(s) >= 1) {
         r.kind = CB_RESULT_REAL;
-        r.v.d  = REAL(s)[0];
+        r.v.d  = Rf_asReal(s);
     } else if (Rf_isLogical(s) && XLENGTH(s) >= 1) {
         r.kind = CB_RESULT_LOGICAL;
-        r.v.i  = LOGICAL(s)[0];
+        r.v.i  = Rf_asLogical(s);
     } else if (TYPEOF(s) == EXTPTRSXP) {
         r.kind = CB_RESULT_PTR;
         r.v.p  = R_ExternalPtrAddr(s);