ctx0 performance improvements

Signed-off-by: Andrew Stein <steinlink@gmail.com>

Author: texodus

rust/perspective-server/cpp/perspective/src/cpp/context_grouped_pkey.cpp

@@ -676,7 +676,9 @@ t_ctx_grouped_pkey::pprint() const {
 }
 
 void
-t_ctx_grouped_pkey::notify(const t_data_table& flattened) {
+t_ctx_grouped_pkey::notify(
+    const t_data_table& flattened, bool /* is_registration */
+) {
     PSP_TRACE_SENTINEL();
     PSP_VERBOSE_ASSERT(m_init, "touching uninited object");
 

rust/perspective-server/cpp/perspective/src/cpp/context_one.cpp

@@ -276,7 +276,7 @@ t_ctx1::get_data(const std::vector<t_uindex>& rows) const {
 }
 
 void
-t_ctx1::notify(const t_data_table& flattened) {
+t_ctx1::notify(const t_data_table& flattened, bool /* is_registration */) {
     PSP_TRACE_SENTINEL();
     PSP_VERBOSE_ASSERT(m_init, "touching uninited object");
 

rust/perspective-server/cpp/perspective/src/cpp/context_two.cpp

@@ -509,7 +509,7 @@ t_ctx2::reset_sortby() {
 }
 
 void
-t_ctx2::notify(const t_data_table& flattened) {
+t_ctx2::notify(const t_data_table& flattened, bool /* is_registration */) {
     for (t_uindex tree_idx = 0, loop_end = m_trees.size(); tree_idx < loop_end;
          ++tree_idx) {
         if (is_rtree_idx(tree_idx) != 0U) {

rust/perspective-server/cpp/perspective/src/cpp/context_unit.cpp

@@ -111,14 +111,21 @@ t_ctxunit::notify(
  * @param flattened
  */
 void
-t_ctxunit::notify(const t_data_table& flattened) {
+t_ctxunit::notify(const t_data_table& flattened, bool is_registration) {
     t_uindex nrecs = flattened.size();
     std::shared_ptr<const t_column> pkey_sptr =
         flattened.get_const_column("psp_pkey");
     const t_column* pkey_col = pkey_sptr.get();
 
     m_has_delta = true;
 
+    // During `_register_context`, no subscriber exists yet — skip the
+    // hopscotch_set insertions no observer can see. A unit context has no
+    // traversal/sort state to build either, so this is effectively O(1).
+    if (is_registration) {
+        return;
+    }
+
     // TODO: pkey and idx are equal, except idx is not a t_tscalar. I don't
     // think there is a difference between accessing the pkey column and
     // creating a brand new scalar, as get_scalar always returns a copy. We

rust/perspective-server/cpp/perspective/src/cpp/context_zero.cpp

@@ -184,7 +184,7 @@ t_ctx0::notify(
  * @param flattened
  */
 void
-t_ctx0::notify(const t_data_table& flattened) {
+t_ctx0::notify(const t_data_table& flattened, bool is_registration) {
     t_uindex nrecs = flattened.size();
     std::shared_ptr<const t_column> pkey_sptr =
         flattened.get_const_column("psp_pkey");
@@ -195,6 +195,40 @@ t_ctx0::notify(const t_data_table& flattened) {
 
     m_has_delta = true;
 
+    // During `_register_context`, no subscriber exists yet to observe the
+    // delta set produced here — skip populating `m_delta_pkeys` so we don't
+    // allocate one hopscotch_set entry per row. The first real update goes
+    // through the 6-arg `notify` which tracks deltas normally.
+    const bool track_deltas = !is_registration;
+
+    // Fast path: unsorted, unfiltered, empty traversal (i.e. initial
+    // registration of a pass-through ctx0). Skip the `m_new_elems`
+    // hopscotch_map round-trip and the subsequent `step_end` rebuild of
+    // `m_index`; append pkeys directly into `m_index`, then finalize
+    // (pkey-sort + `m_pkeyidx` population). This matches the row order
+    // the existing `add_row`/`step_end` path produces for an empty sort.
+    const bool can_bulk_load = !m_config.has_filters()
+        && m_traversal->empty_sort_by() && m_traversal->size() == 0;
+    if (can_bulk_load) {
+        m_traversal->bulk_load_reserve(nrecs);
+        if (track_deltas) {
+            m_delta_pkeys.reserve(nrecs);
+        }
+        for (t_uindex idx = 0; idx < nrecs; ++idx) {
+            t_tscalar pkey =
+                m_symtable.get_interned_tscalar(pkey_col->get_scalar(idx));
+            std::uint8_t op_ = *(op_col->get_nth<std::uint8_t>(idx));
+            if (static_cast<t_op>(op_) == OP_INSERT) {
+                m_traversal->bulk_load_append(pkey);
+            }
+            if (track_deltas) {
+                add_delta_pkey(pkey);
+            }
+        }
+        m_traversal->bulk_load_finalize();
+        return;
+    }
+
     if (m_config.has_filters()) {
         t_mask msk = filter_table_for_config(flattened, m_config);
 
@@ -219,8 +253,9 @@ t_ctx0::notify(const t_data_table& flattened) {
                     break;
             }
 
-            // Add primary key to track row delta
-            add_delta_pkey(pkey);
+            if (track_deltas) {
+                add_delta_pkey(pkey);
+            }
         }
 
         return;
@@ -242,8 +277,9 @@ t_ctx0::notify(const t_data_table& flattened) {
                 break;
         }
 
-        // Add primary key to track row delta
-        add_delta_pkey(pkey);
+        if (track_deltas) {
+            add_delta_pkey(pkey);
+        }
     }
 }
 

rust/perspective-server/cpp/perspective/src/cpp/flat_traversal.cpp

@@ -17,6 +17,8 @@
 #include <perspective/scalar.h>
 #include <perspective/schema.h>
 
+#include <algorithm>
+
 namespace perspective {
 
 t_ftrav::t_ftrav() : m_step_deletes(0), m_step_inserts(0) {
@@ -279,6 +281,14 @@ t_ftrav::step_begin() {
 
 void
 t_ftrav::step_end() {
+    // Fast path: if no incremental work happened this step, `m_index` and
+    // `m_pkeyidx` are already in their final shape (either unchanged, or
+    // populated directly via `bulk_load_append`). Skip the O(N) rebuild.
+    if (m_step_inserts == 0 && m_step_deletes == 0) {
+        m_new_elems.clear();
+        return;
+    }
+
     // The new number of rows in this traversal
     t_index new_size = m_index->size() + m_step_inserts - m_step_deletes;
 
@@ -447,4 +457,42 @@ t_ftrav::get_from_gstate(
     return gstate.get(*master_table, colname, pkey);
 }
 
+void
+t_ftrav::bulk_load_reserve(t_uindex n) {
+    m_index->reserve(n);
+    m_pkeyidx.reserve(n);
+}
+
+void
+t_ftrav::bulk_load_append(t_tscalar pkey) {
+    // Pre-condition: `empty_sort_by()` and the caller has ownership of
+    // step framing (i.e. we're inside a `step_begin`/`step_end` pair for
+    // an initial registration). `m_step_inserts` is intentionally NOT
+    // incremented so that `step_end` takes its short-circuit path.
+    // `m_pkeyidx` is populated in `bulk_load_finalize` after sorting,
+    // not here — the pkey-to-index mapping only has meaning once the
+    // final sort order is determined.
+    m_index->emplace_back();
+    m_index->back().m_pkey = pkey;
+}
+
+void
+t_ftrav::bulk_load_finalize() {
+    // Match the order the existing `add_row`/`step_end` path would
+    // produce for an empty sort spec: `cmp_mselem` with zero sort
+    // columns falls through to `a.m_pkey < b.m_pkey`, so sort
+    // `m_index` by pkey and then rebuild `m_pkeyidx` against the final
+    // row positions.
+    std::sort(
+        m_index->begin(),
+        m_index->end(),
+        [](const t_mselem& a, const t_mselem& b) {
+            return a.m_pkey < b.m_pkey;
+        }
+    );
+    for (t_uindex i = 0, loop_end = m_index->size(); i < loop_end; ++i) {
+        m_pkeyidx[(*m_index)[i].m_pkey] = i;
+    }
+}
+
 } // end namespace perspective