feat(tree): copy input points before all batch operations

Author: RomaLzhih

docs/MANUAL.md

@@ -188,22 +188,19 @@ Then we can use the tree as follows:
 - Build the tree:
 ```c++
 Points points;
-auto points_copy = points;
-tree.Build(points_copy);
+tree.Build(points);
 ```
 - Batch Insert:
 ```c++
 Points insert_points;
-auto insert_copy = insert_points;
-tree.BatchInsert(insert_copy);
+tree.BatchInsert(insert_points);
 ```
 
 - Batch Delete (assumes all points to be deleted are in the tree, use `BatchDiff` if you are not sure):
 ```c++
 Points delete_points;
-auto delete_copy = delete_points;
-tree.BatchDelete(delete_copy);
-// tree.BatchDiff(delete_copy);
+tree.BatchDelete(delete_points);
+// tree.BatchDiff(delete_points);
 ```
 
 - KNN query

example/kd_tree.h

@@ -150,9 +150,7 @@ void run_example() {
 
   // 2. Build the KdTree
   Tree tree;
-  auto points_copy =
-      points;  // WARN: Important! The input array will be changed during build.
-  tree.Build(parlay::make_slice(points_copy));
+  tree.Build(parlay::make_slice(points));
   std::cout << "Built KdTree with " << n << " points" << std::endl;
 
   // 3. K-Nearest Neighbors query
@@ -203,16 +201,14 @@ void run_example() {
     new_points[i].aug.id = n + i;
   });
 
-  Points insert_copy(new_points);  // same as build
-  tree.BatchInsert(parlay::make_slice(insert_copy));
+  tree.BatchInsert(parlay::make_slice(new_points));
   std::cout << "Inserted " << insert_count << " new points" << std::endl;
 
   // 6. Batch delete some points
   size_t delete_count = 50;
   Points points_to_delete = points.subseq(0, delete_count);
 
-  Points delete_copy(points_to_delete);  // same as build
-  tree.BatchDelete(parlay::make_slice(delete_copy));
+  tree.BatchDelete(parlay::make_slice(points_to_delete));
   std::cout << "Deleted " << delete_count << " points" << std::endl;
 
   // 7. Clean up

example/orth_tree.h

@@ -199,8 +199,6 @@ void run_example() {
   // 2. Build the OrthTree
   // OrthTree requires a bounding box to be specified
   Tree tree;
-  auto points_copy =
-      points;  // WARN: Important! The input array will be changed during build.
 
   // Calculate bounding box for the points
   // NOTE: This is not necessary, unless you want to specify a certain bounding
@@ -211,7 +209,7 @@ void run_example() {
             << bounding_box.first[1] << "), (" << bounding_box.second[0] << ", "
             << bounding_box.second[1] << ")]" << std::endl;
 
-  tree.Build(parlay::make_slice(points_copy), bounding_box);
+  tree.Build(parlay::make_slice(points), bounding_box);
   std::cout << "Built OrthTree (quadtree) with " << n << " points" << std::endl;
 
   // 3. K-Nearest Neighbors query
@@ -262,16 +260,14 @@ void run_example() {
     new_points[i].aug.id = n + i;
   });
 
-  Points insert_copy(new_points);  // same as build
-  tree.BatchInsert(parlay::make_slice(insert_copy));
+  tree.BatchInsert(parlay::make_slice(new_points));
   std::cout << "Inserted " << insert_count << " new points" << std::endl;
 
   // 6. Batch delete some points
   size_t delete_count = 50;
   Points points_to_delete = points.subseq(0, delete_count);
 
-  Points delete_copy(points_to_delete);  // same as build
-  tree.BatchDelete(parlay::make_slice(delete_copy));
+  tree.BatchDelete(parlay::make_slice(points_to_delete));
   std::cout << "Deleted " << delete_count << " points" << std::endl;
 
   // 7. Clean up

example/p_tree.h

@@ -78,9 +78,7 @@ void run_example() {
 
   // 2. Build the PTree
   Tree tree;
-  auto points_copy =
-      points;  // WARN: Important! The input array will be changed during build.
-  tree.Build(parlay::make_slice(points_copy));
+  tree.Build(parlay::make_slice(points));
   std::cout << "Built PTree with " << n << " points using Morton curve"
             << std::endl;
 
@@ -132,16 +130,14 @@ void run_example() {
     new_points[i].aug.id = n + i;
   });
 
-  Points insert_copy(new_points);  // same as build
-  tree.BatchInsert(parlay::make_slice(insert_copy));
+  tree.BatchInsert(parlay::make_slice(new_points));
   std::cout << "Inserted " << insert_count << " new points" << std::endl;
 
   // 6. Batch delete some points
   size_t delete_count = 50;
   Points points_to_delete = points.subseq(0, delete_count);
 
-  Points delete_copy(points_to_delete);  // same as build
-  tree.BatchDelete(parlay::make_slice(delete_copy));
+  tree.BatchDelete(parlay::make_slice(points_to_delete));
   std::cout << "Deleted " << delete_count << " points" << std::endl;
 
   // 7. Clean up

include/psi/kd_tree.h

@@ -84,7 +84,10 @@ class KdTree : public BaseTree<Point,
 
   constexpr void DeleteTree() override;
 
-  void BatchInsert(Slice In);
+  template <typename Range>
+  void BatchInsert(Range&& In);
+
+  void BatchInsert_(Slice In);
 
   Node* BatchInsertRecursive(Node* T, Slice In, Slice Out, DimsType d);
 

include/psi/kd_tree_impl/kd_batch_delete.hpp

@@ -18,7 +18,9 @@ void KdTree<Point, SplitRule, LeafAugType, InteriorAugType, kSkHeight,
   static_assert(std::is_constructible_v<parlay::range_value_type_t<Range>,
                                         parlay::range_reference_type_t<Range>>);
 
-  Slice A = parlay::make_slice(In);
+  auto aux = Points::uninitialized(parlay::size(In));
+  parlay::copy(In, parlay::make_slice(aux));
+  Slice A = parlay::make_slice(aux);
   BatchDelete_(A);
   return;
 }

include/psi/kd_tree_impl/kd_batch_diff.hpp

@@ -4,25 +4,31 @@
 #include "../kd_tree.h"
 
 namespace psi {
-template <typename Point, typename SplitRule, typename LeafAugType, typename InteriorAugType,  uint_fast8_t kSkHeight,
+template <typename Point, typename SplitRule, typename LeafAugType,
+          typename InteriorAugType, uint_fast8_t kSkHeight,
           uint_fast8_t kImbaRatio>
 template <typename Range>
-void KdTree<Point, SplitRule, LeafAugType, InteriorAugType, kSkHeight , kImbaRatio>::BatchDiff(Range&& In) {
+void KdTree<Point, SplitRule, LeafAugType, InteriorAugType, kSkHeight,
+            kImbaRatio>::BatchDiff(Range&& In) {
   static_assert(parlay::is_random_access_range_v<Range>);
   static_assert(
       parlay::is_less_than_comparable_v<parlay::range_reference_type_t<Range>>);
   static_assert(std::is_constructible_v<parlay::range_value_type_t<Range>,
                                         parlay::range_reference_type_t<Range>>);
 
-  Slice A = parlay::make_slice(In);
+  auto aux = Points::uninitialized(parlay::size(In));
+  parlay::copy(In, parlay::make_slice(aux));
+  Slice A = parlay::make_slice(aux);
   BatchDiff_(A);
   return;
 }
 
 // NOTE: batch delete suitable for Points that are pratially covered in the tree
-template <typename Point, typename SplitRule, typename LeafAugType, typename InteriorAugType,  uint_fast8_t kSkHeight,
+template <typename Point, typename SplitRule, typename LeafAugType,
+          typename InteriorAugType, uint_fast8_t kSkHeight,
           uint_fast8_t kImbaRatio>
-void KdTree<Point, SplitRule, LeafAugType, InteriorAugType, kSkHeight , kImbaRatio>::BatchDiff_(Slice A) {
+void KdTree<Point, SplitRule, LeafAugType, InteriorAugType, kSkHeight,
+            kImbaRatio>::BatchDiff_(Slice A) {
   Points B = Points::uninitialized(A.size());
   Node* T = this->root_;
   Box box = this->tree_box_;
@@ -55,13 +61,17 @@ void KdTree<Point, SplitRule, LeafAugType, InteriorAugType, kSkHeight , kImbaRat
 
 // NOTE: only sieve the Points, without rebuilding the tree
 // NOTE: the kdtree needs box since the box will be changed in batch diff
-template <typename Point, typename SplitRule, typename LeafAugType, typename InteriorAugType,  uint_fast8_t kSkHeight,
+template <typename Point, typename SplitRule, typename LeafAugType,
+          typename InteriorAugType, uint_fast8_t kSkHeight,
           uint_fast8_t kImbaRatio>
-typename KdTree<Point, SplitRule, LeafAugType, InteriorAugType, kSkHeight , kImbaRatio>::NodeBox
-KdTree<Point, SplitRule, LeafAugType, InteriorAugType, kSkHeight , kImbaRatio>::BatchDiffRecursive(
-    Node* T,
-    typename KdTree<Point, SplitRule, LeafAugType, InteriorAugType, kSkHeight , kImbaRatio>::Box const& box,
-    Slice In, Slice Out, DimsType d) {
+typename KdTree<Point, SplitRule, LeafAugType, InteriorAugType, kSkHeight,
+                kImbaRatio>::NodeBox
+KdTree<Point, SplitRule, LeafAugType, InteriorAugType, kSkHeight, kImbaRatio>::
+    BatchDiffRecursive(
+        Node* T,
+        typename KdTree<Point, SplitRule, LeafAugType, InteriorAugType,
+                        kSkHeight, kImbaRatio>::Box const& box,
+        Slice In, Slice Out, DimsType d) {
   size_t n = In.size();
 
   if (n == 0) return NodeBox(T, box);

include/psi/kd_tree_impl/kd_batch_insert.hpp

@@ -5,9 +5,29 @@
 #include "parlay/slice.h"
 
 namespace psi {
-template <typename Point, typename SplitRule, typename LeafAugType, typename InteriorAugType,  uint_fast8_t kSkHeight,
+template <typename Point, typename SplitRule, typename LeafAugType,
+          typename InteriorAugType, uint_fast8_t kSkHeight,
           uint_fast8_t kImbaRatio>
-void KdTree<Point, SplitRule, LeafAugType, InteriorAugType, kSkHeight , kImbaRatio>::BatchInsert(Slice A) {
+template <typename Range>
+void KdTree<Point, SplitRule, LeafAugType, InteriorAugType, kSkHeight,
+            kImbaRatio>::BatchInsert(Range&& In) {
+  static_assert(parlay::is_random_access_range_v<Range>);
+  static_assert(
+      parlay::is_less_than_comparable_v<parlay::range_reference_type_t<Range>>);
+  static_assert(std::is_constructible_v<parlay::range_value_type_t<Range>,
+                                        parlay::range_reference_type_t<Range>>);
+
+  auto aux = Points::uninitialized(parlay::size(In));
+  parlay::copy(In, parlay::make_slice(aux));
+  Slice A = parlay::make_slice(aux);
+  BatchInsert_(A);
+}
+
+template <typename Point, typename SplitRule, typename LeafAugType,
+          typename InteriorAugType, uint_fast8_t kSkHeight,
+          uint_fast8_t kImbaRatio>
+void KdTree<Point, SplitRule, LeafAugType, InteriorAugType, kSkHeight,
+            kImbaRatio>::BatchInsert_(Slice A) {
   if (this->root_ == nullptr) {  // TODO: may check using explicity tag
     return Build_(A);
   }
@@ -26,10 +46,12 @@ void KdTree<Point, SplitRule, LeafAugType, InteriorAugType, kSkHeight , kImbaRat
 }
 
 // NOTE: return the updated Node
-template <typename Point, typename SplitRule, typename LeafAugType, typename InteriorAugType,  uint_fast8_t kSkHeight,
+template <typename Point, typename SplitRule, typename LeafAugType,
+          typename InteriorAugType, uint_fast8_t kSkHeight,
           uint_fast8_t kImbaRatio>
-Node* KdTree<Point, SplitRule, LeafAugType, InteriorAugType, kSkHeight , kImbaRatio>::BatchInsertRecursive(
-    Node* T, Slice In, Slice Out, DimsType d) {
+Node* KdTree<Point, SplitRule, LeafAugType, InteriorAugType, kSkHeight,
+             kImbaRatio>::BatchInsertRecursive(Node* T, Slice In, Slice Out,
+                                               DimsType d) {
   size_t n = In.size();
 
   if (n == 0) return T;

include/psi/kd_tree_impl/kd_build_tree.hpp

@@ -21,7 +21,9 @@ void KdTree<Point, SplitRule, LeafAugType, InteriorAugType, kSkHeight,
   static_assert(std::is_constructible_v<parlay::range_value_type_t<Range>,
                                         parlay::range_reference_type_t<Range>>);
 
-  Slice A = parlay::make_slice(In);
+  auto aux = Points::uninitialized(parlay::size(In));
+  parlay::copy(In, parlay::make_slice(aux));
+  Slice A = parlay::make_slice(aux);
   Build_(A);
 }
 

include/psi/orth_tree_impl/orth_batch_delete.hpp

@@ -18,7 +18,9 @@ void OrthTree<Point, SplitRule, LeafAugType, InteriorAugType, kMD, kSkHeight,
   static_assert(std::is_constructible_v<parlay::range_value_type_t<Range>,
                                         parlay::range_reference_type_t<Range>>);
 
-  Slice A = parlay::make_slice(In);
+  auto aux = Points::uninitialized(parlay::size(In));
+  parlay::copy(In, parlay::make_slice(aux));
+  Slice A = parlay::make_slice(aux);
   BatchDelete_(A);
   return;
 }