clean up readme

Signed-off-by: Alexander Droste <alexander.droste@protonmail.com>

Author: 0ax1

vortex-cuda/README.md

@@ -10,35 +10,28 @@ Key files:
 - `vortex-cuda/src/arrow/canonical.rs`: canonical-array export to `ArrowDeviceArray`.
 - `vortex-test/e2e-cuda/src/lib.rs`: cuDF interop harness.
 
-Current export coverage includes primitive, bool, decimal/temporal, string/binary view, and struct arrays. Remaining work includes null masks, broader dtype coverage, `ArrowDeviceArrayStream`, and PyVortex integration.
+## Building cuDF
 
-## cuDF compatibility
+Note that the `cudf-test-harness` repository provides prebuilt cuDF libraries for x86_64 and aarch64.
 
-Vortex exports string and binary columns as Arrow `Utf8View` / `BinaryView` device arrays with producer-owned `ArrowArray.private_data`. cuDF string/binary interop requires a build containing `rapidsai/cudf#22620`; until a release version is identified, test with a cuDF commit that includes that change.
-
-## Building cuDF for interop testing
-
-Pass a single CUDA architecture, e.g. `-DCMAKE_CUDA_ARCHITECTURES=90a`; otherwise cuDF builds for many architectures and local builds are much slower.
+From the cuDF repository root, compile cuDF locally without exporting additional environment variables:
 
 ```sh
-export PATH=/usr/local/cuda-13.1/bin:$PATH
+cmake -E rm -rf cpp/build
 
 cmake -S cpp -B cpp/build \
-  -DCMAKE_INSTALL_PREFIX=${CONDA_PREFIX:-/usr/local} \
-  -DCMAKE_CUDA_ARCHITECTURES=90a \
+  -DCMAKE_INSTALL_PREFIX=/usr/local \
+  -DCMAKE_CUDA_ARCHITECTURES=NATIVE \
   -DBUILD_TESTS=ON \
   -DDISABLE_DEPRECATION_WARNINGS=ON \
   -DCMAKE_BUILD_TYPE=Debug \
   -DCUDF_BUILD_STREAMS_TEST_UTIL=OFF \
-  -DCUDAToolkit_ROOT=/usr/local/cuda-13.1 \
-  -DCMAKE_CUDA_COMPILER=/usr/local/cuda-13.1/bin/nvcc \
-  -DCMAKE_CXX_COMPILER=/usr/bin/g++-13 \
-  -DCMAKE_C_COMPILER=/usr/bin/gcc-13 \
-  -GNinja
-
-cmake --build cpp/build --target INTEROP_TEST -j$(nproc)
-
-LD_LIBRARY_PATH=/usr/local/cuda-13.1/compat:$LD_LIBRARY_PATH ./cpp/build/gtests/INTEROP_TEST
+  -DCUDAToolkit_ROOT=/usr/local/cuda \
+  -DCMAKE_CUDA_COMPILER=/usr/local/cuda/bin/nvcc \
+  -DCMAKE_C_COMPILER=gcc \
+  -DCMAKE_CXX_COMPILER=g++ \
+  -GNinja && cmake --build cpp/build --target INTEROP_TEST --parallel
 ```
 
-Adjust architecture, compiler paths, and CUDA paths for the machine under test.
+The clean build directory is important when changing compilers because CMake caches the selected C and C++
+compilers in `CMakeCache.txt`.

vortex-cuda/src/arrow/canonical.rs

@@ -448,11 +448,9 @@ where
 
 /// Export Vortex binary views as standard Arrow `Binary`.
 ///
-/// cuDF's Arrow Device import currently rejects both Arrow `Binary` and Arrow `BinaryView`
-/// (unlike `Utf8View`, which it accepts as strings), so standard `Binary` is exported as the
-/// layout other Arrow Device consumers accept most widely. This path keeps conversion on the
-/// CUDA stream by building `i32` offsets from view sizes and gathering inline/out-of-line view
-/// bytes into one contiguous values buffer.
+/// cuDF currently rejects Arrow Device `Binary`/`BinaryView`, but `Binary` is the widest
+/// compatible layout for other consumers. Conversion stays on the CUDA stream by building
+/// `i32` offsets and gathering inline/out-of-line bytes into one values buffer.
 async fn export_binary(
     varbinview: VarBinViewArray,
     ctx: &mut CudaExecutionCtx,
@@ -682,10 +680,9 @@ fn gather_binary_values(
 ///
 /// Returns `None` for the buffer when Arrow can omit validity because all rows are valid.
 ///
-/// Every returned buffer is backed by an allocation padded to a 4-byte multiple with zeroed
-/// padding so cuDF's word-sized mask reads stay in bounds: the fast path through the device
-/// copy's tail zeroing, the other paths through their own padded allocations. Bits at positions
-/// `>= len + arrow_offset` within the final data byte are unspecified, as Arrow permits.
+/// Returned buffers use zeroed 4-byte padding so cuDF's word-sized mask reads stay in bounds.
+/// Bits at positions `>= len + arrow_offset` within the final data byte are unspecified, as
+/// Arrow permits.
 pub(super) async fn export_arrow_validity_buffer(
     validity: Validity,
     len: usize,

vortex-cuda/src/dynamic_dispatch/plan_builder.rs

@@ -894,3 +894,29 @@ impl FusedPlan {
         len * final_elem_bytes.max(output_elem_bytes)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use vortex::array::IntoArray;
+    use vortex::array::arrays::PrimitiveArray;
+    use vortex::array::builtins::ArrayBuiltins;
+    use vortex::dtype::DType;
+    use vortex::dtype::Nullability;
+
+    use super::*;
+
+    #[test]
+    fn cast_to_non_primitive_target_is_not_dyn_dispatch_compatible() -> VortexResult<()> {
+        let cast = PrimitiveArray::from_iter([0u8, 1])
+            .into_array()
+            .cast(DType::Bool(Nullability::NonNullable))?;
+
+        assert!(!is_dyn_dispatch_cast_compatible(&cast));
+        assert!(matches!(
+            DispatchPlan::new(&cast, CudaDispatchMode::DynDispatchOnly)?,
+            DispatchPlan::Unfused
+        ));
+
+        Ok(())
+    }
+}