Add SYCL support for t/geometry/t/pipelines kernels, Transform ops, and NNS CPU fallback

cpp/open3d/core/CMakeLists.txt

@@ -102,6 +102,7 @@ open3d_sycl_target_sources(core_impl PRIVATE
     linalg/LeastSquaresSYCL.cpp
     linalg/LUSYCL.cpp
     linalg/MatmulSYCL.cpp
+    nns/KnnSearchOpsSYCL.cpp
     linalg/SolveSYCL.cpp
     linalg/SVDSYCL.cpp
     linalg/TriSYCL.cpp

cpp/open3d/core/nns/FixedRadiusIndex.cpp

@@ -104,8 +104,16 @@ bool FixedRadiusIndex::SetTensorData(const Tensor &dataset_points,
         CALL_BUILD(double, BuildSpatialHashTableCUDA)
 #else
         utility::LogError(
-                "-DBUILD_CUDA_MODULE=OFF. Please compile Open3d with "
+                "-DBUILD_CUDA_MODULE=OFF. Please compile Open3D with "
                 "-DBUILD_CUDA_MODULE=ON.");
+#endif
+    } else if (device.IsSYCL()) {
+#ifdef BUILD_SYCL_MODULE
+        return true;
+#else
+        utility::LogError(
+                "-DBUILD_SYCL_MODULE=OFF. Please compile Open3D with "
+                "-DBUILD_SYCL_MODULE=ON.");
 #endif
     } else {
         CALL_BUILD(float, BuildSpatialHashTableCPU)
@@ -171,8 +179,18 @@ std::tuple<Tensor, Tensor, Tensor> FixedRadiusIndex::SearchRadius(
         });
 #else
         utility::LogError(
-                "-DBUILD_CUDA_MODULE=OFF. Please compile Open3d with "
+                "-DBUILD_CUDA_MODULE=OFF. Please compile Open3D with "
                 "-DBUILD_CUDA_MODULE=ON.");
+#endif
+    } else if (device.IsSYCL()) {
+#ifdef BUILD_SYCL_MODULE
+        DISPATCH_FLOAT_INT_DTYPE_TO_TEMPLATE(dtype, index_dtype, [&]() {
+            FixedRadiusSearchSYCL<scalar_t, int_t>(RADIUS_PARAMETERS);
+        });
+#else
+        utility::LogError(
+                "-DBUILD_SYCL_MODULE=OFF. Please compile Open3D with "
+                "-DBUILD_SYCL_MODULE=ON.");
 #endif
     } else {
         DISPATCH_FLOAT_INT_DTYPE_TO_TEMPLATE(dtype, index_dtype, [&]() {
@@ -240,8 +258,18 @@ std::tuple<Tensor, Tensor, Tensor> FixedRadiusIndex::SearchHybrid(
         });
 #else
         utility::LogError(
-                "-DBUILD_CUDA_MODULE=OFF. Please compile Open3d with "
+                "-DBUILD_CUDA_MODULE=OFF. Please compile Open3D with "
                 "-DBUILD_CUDA_MODULE=ON.");
+#endif
+    } else if (device.IsSYCL()) {
+#ifdef BUILD_SYCL_MODULE
+        DISPATCH_FLOAT_INT_DTYPE_TO_TEMPLATE(dtype, index_dtype, [&]() {
+            HybridSearchSYCL<scalar_t, int_t>(HYBRID_PARAMETERS);
+        });
+#else
+        utility::LogError(
+                "-DBUILD_SYCL_MODULE=OFF. Please compile Open3D with "
+                "-DBUILD_SYCL_MODULE=ON.");
 #endif
     } else {
         DISPATCH_FLOAT_INT_DTYPE_TO_TEMPLATE(dtype, index_dtype, [&]() {

cpp/open3d/core/nns/FixedRadiusIndex.h

@@ -376,6 +376,40 @@ void HybridSearchCUDA(const Tensor& points,
                       Tensor& neighbors_distance);
 #endif
 
+#ifdef BUILD_SYCL_MODULE
+template <class T, class TIndex>
+void FixedRadiusSearchSYCL(const Tensor& points,
+                           const Tensor& queries,
+                           double radius,
+                           const Tensor& points_row_splits,
+                           const Tensor& queries_row_splits,
+                           const Tensor& hash_table_splits,
+                           const Tensor& hash_table_index,
+                           const Tensor& hash_table_cell_splits,
+                           const Metric metric,
+                           const bool ignore_query_point,
+                           const bool return_distances,
+                           const bool sort,
+                           Tensor& neighbors_index,
+                           Tensor& neighbors_row_splits,
+                           Tensor& neighbors_distance);
+
+template <class T, class TIndex>
+void HybridSearchSYCL(const Tensor& points,
+                      const Tensor& queries,
+                      double radius,
+                      int max_knn,
+                      const Tensor& points_row_splits,
+                      const Tensor& queries_row_splits,
+                      const Tensor& hash_table_splits,
+                      const Tensor& hash_table_index,
+                      const Tensor& hash_table_cell_splits,
+                      const Metric metric,
+                      Tensor& neighbors_index,
+                      Tensor& neighbors_count,
+                      Tensor& neighbors_distance);
+#endif
+
 /// \class FixedRadiusIndex
 ///
 /// \brief FixedRadiusIndex for nearest neighbor range search.

cpp/open3d/core/nns/KnnIndex.cpp

@@ -67,6 +67,17 @@ bool KnnIndex::SetTensorData(const Tensor& dataset_points,
         utility::LogError(
                 "GPU Tensor is not supported when -DBUILD_CUDA_MODULE=OFF. "
                 "Please recompile Open3d With -DBUILD_CUDA_MODULE=ON.");
+#endif
+    } else if (dataset_points.IsSYCL()) {
+#ifdef BUILD_SYCL_MODULE
+        dataset_points_ = dataset_points.Contiguous();
+        points_row_splits_ = points_row_splits.Contiguous();
+        index_dtype_ = index_dtype;
+        return true;
+#else
+        utility::LogError(
+                "SYCL Tensor is not supported when -DBUILD_SYCL_MODULE=OFF. "
+                "Please recompile Open3D with -DBUILD_SYCL_MODULE=ON.");
 #endif
     } else {
         utility::LogError(
@@ -124,13 +135,24 @@ std::pair<Tensor, Tensor> KnnIndex::SearchKnn(const Tensor& query_points,
         });
 #else
         utility::LogError(
-                "-DBUILD_CUDA_MODULE=OFF. Please compile Open3d with "
+                "-DBUILD_CUDA_MODULE=OFF. Please compile Open3D with "
                 "-DBUILD_CUDA_MODULE=ON.");
+#endif
+    } else if (device.IsSYCL()) {
+#ifdef BUILD_SYCL_MODULE
+        const Dtype index_dtype = GetIndexDtype();
+        DISPATCH_FLOAT_INT_DTYPE_TO_TEMPLATE(dtype, index_dtype, [&]() {
+            KnnSearchSYCL<scalar_t, int_t>(KNN_PARAMETERS);
+        });
+#else
+        utility::LogError(
+                "-DBUILD_SYCL_MODULE=OFF. Please compile Open3D with "
+                "-DBUILD_SYCL_MODULE=ON.");
 #endif
     } else {
         utility::LogError(
-                "-DBUILD_CUDA_MODULE=OFF. Please compile Open3d with "
-                "-DBUILD_CUDA_MODULE=ON.");
+                "KnnIndex only supports CUDA and SYCL tensors. Please use "
+                "NanoFlannIndex instead for CPU tensors.");
     }
     return std::make_pair(neighbors_index, neighbors_distance);
 }

cpp/open3d/core/nns/KnnIndex.h

@@ -29,14 +29,28 @@ void KnnSearchCUDA(const Tensor& points,
                    Tensor& neighbors_distance);
 #endif
 
+#ifdef BUILD_SYCL_MODULE
+template <class T, class TIndex>
+void KnnSearchSYCL(const Tensor& points,
+                   const Tensor& points_row_splits,
+                   const Tensor& queries,
+                   const Tensor& queries_row_splits,
+                   int knn,
+                   Tensor& neighbors_index,
+                   Tensor& neighbors_row_splits,
+                   Tensor& neighbors_distance);
+#endif
+
 class KnnIndex : public NNSIndex {
 public:
     KnnIndex();
 
     /// \brief Parameterized Constructor.
     ///
-    /// \param dataset_points Provides a set of data points as Tensor for KDTree
-    /// construction.
+    /// \param dataset_points Provides a set of data points as Tensor for
+    /// nearest neighbor search. CPU tensors use NanoFlann through
+    /// open3d::core::nns::NearestNeighborSearch, while CUDA and SYCL tensors
+    /// are handled by this class.
     KnnIndex(const Tensor& dataset_points);
     KnnIndex(const Tensor& dataset_points, const Dtype& index_dtype);
     ~KnnIndex();