[perf] minor optimization for filtering

Author: tstack

src/filter_observer.cc

@@ -27,18 +27,23 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <algorithm>
+#include <iterator>
+
 #include "filter_observer.hh"
 
+#include "base/lnav_log.hh"
 #include "config.h"
 #include "log_format.hh"
+#include "shared_buffer.hh"
 
 void
 line_filter_observer::logline_new_lines(const logfile& lf,
                                         logfile::const_iterator ll_begin,
                                         logfile::const_iterator ll_end,
                                         const shared_buffer_ref& sbr)
 {
-    size_t offset = std::distance(lf.begin(), ll_begin);
+    const auto offset = std::distance(lf.begin(), ll_begin);
 
     require(&lf == this->lfo_filter_state.tfs_logfile.get());
 
@@ -53,7 +58,7 @@ line_filter_observer::logline_new_lines(const logfile& lf,
             lf.get_format()->get_subline(*ll_begin, sbr_copy);
         }
         sbr_copy.erase_ansi();
-        for (auto& filter : this->lfo_filter_stack) {
+        for (const auto& filter : this->lfo_filter_stack) {
             if (filter->lf_deleted) {
                 continue;
             }
@@ -69,7 +74,8 @@ line_filter_observer::logline_new_lines(const logfile& lf,
 void
 line_filter_observer::logline_eof(const logfile& lf)
 {
-    for (auto& iter : this->lfo_filter_stack) {
+    this->lfo_filter_state.reserve(lf.size() + lf.estimated_remaining_lines());
+    for (const auto& iter : this->lfo_filter_stack) {
         if (iter->lf_deleted) {
             continue;
         }
@@ -82,7 +88,7 @@ line_filter_observer::get_min_count(size_t max) const
 {
     size_t retval = max;
 
-    for (auto& filter : this->lfo_filter_stack) {
+    for (const auto& filter : this->lfo_filter_stack) {
         if (filter->lf_deleted) {
             continue;
         }

src/filter_observer.hh

@@ -30,21 +30,24 @@
 #ifndef filter_observer_hh
 #define filter_observer_hh
 
-#include <sys/types.h>
+#include <cstdint>
+#include <memory>
 
+#include "base/file_range.hh"
 #include "logfile.hh"
+#include "shared_buffer.hh"
 #include "textview_curses.hh"
 
 class line_filter_observer : public logline_observer {
 public:
-    line_filter_observer(filter_stack& fs, std::shared_ptr<logfile> lf)
+    line_filter_observer(filter_stack& fs, const std::shared_ptr<logfile>& lf)
         : lfo_filter_stack(fs), lfo_filter_state(lf)
     {
     }
 
     void logline_restart(const logfile& lf, file_size_t rollback_size) override
     {
-        for (auto& filter : this->lfo_filter_stack) {
+        for (const auto& filter : this->lfo_filter_stack) {
             filter->revert_to_last(this->lfo_filter_state, rollback_size);
         }
     }

src/lnav.indexing.cc

@@ -46,7 +46,7 @@ class loading_observer : public logfile_observer {
 public:
     loading_observer() : lo_last_offset(0) {}
 
-    indexing_result logfile_indexing(const std::shared_ptr<logfile>& lf,
+    indexing_result logfile_indexing(const logfile* lf,
                                      file_off_t off,
                                      file_size_t total) override
     {
@@ -87,16 +87,19 @@ class loading_observer : public logfile_observer {
 };
 
 void
-do_observer_update(const std::shared_ptr<logfile>& lf)
+do_observer_update(const logfile* lf)
 {
-    if (lf && lnav_data.ld_mode == ln_mode_t::FILES
+    if (lf != nullptr && lnav_data.ld_mode == ln_mode_t::FILES
         && lnav_data.ld_exec_phase < lnav_exec_phase::INTERACTIVE)
     {
         auto& fc = lnav_data.ld_active_files;
-        const auto iter = std::find(fc.fc_files.begin(), fc.fc_files.end(), lf);
+        size_t index = 0;
 
-        if (iter != fc.fc_files.end()) {
-            auto index = std::distance(fc.fc_files.begin(), iter);
+        for (const auto& curr_file : fc.fc_files) {
+            if (curr_file.get() != lf) {
+                index++;
+                continue;
+            }
             lnav_data.ld_files_view.set_selection(
                 vis_line_t(fc.fc_other_files.size() + index));
             lnav_data.ld_files_view.reload_data();

src/lnav.indexing.hh

@@ -45,6 +45,6 @@ rebuild_indexes_result_t rebuild_indexes(
 void rebuild_indexes_repeatedly();
 bool rescan_files(bool required = false);
 bool update_active_files(file_collection& new_files);
-void do_observer_update(const std::shared_ptr<logfile>& lf);
+void do_observer_update(const logfile* lf);
 
 #endif

src/logfile.cc

@@ -623,7 +623,9 @@ logfile::process_prefix(shared_buffer_ref& sbr,
                                    || li.li_utf8_scan_result.usr_has_ansi);
         }
         if (prescan_size > 0 && this->lf_index.size() >= prescan_size
-            && prescan_time != this->lf_index[prescan_size - 1].get_time<std::chrono::microseconds>())
+            && prescan_time
+                != this->lf_index[prescan_size - 1]
+                       .get_time<std::chrono::microseconds>())
         {
             retval = true;
         }
@@ -931,8 +933,7 @@ logfile::rebuild_index(std::optional<ui_clock::time_point> deadline)
                 this->lf_notes.writeAccess()->emplace(note_type::not_utf,
                                                       note_um);
                 if (this->lf_logfile_observer != nullptr) {
-                    this->lf_logfile_observer->logfile_indexing(
-                        this->shared_from_this(), 0, 0);
+                    this->lf_logfile_observer->logfile_indexing(this, 0, 0);
                 }
                 break;
             }
@@ -1030,7 +1031,7 @@ logfile::rebuild_index(std::optional<ui_clock::time_point> deadline)
 
             if (this->lf_logfile_observer != nullptr) {
                 auto indexing_res = this->lf_logfile_observer->logfile_indexing(
-                    this->shared_from_this(),
+                    this,
                     this->lf_line_buffer.get_read_offset(
                         li.li_file_range.next_offset()),
                     st.st_size);
@@ -1086,7 +1087,7 @@ logfile::rebuild_index(std::optional<ui_clock::time_point> deadline)
                 }
 
                 for (const auto& pd : this->lf_applicable_partitioners) {
-                    static thread_local auto part_md
+                    thread_local auto part_md
                         = lnav::pcre2pp::match_data::unitialized();
 
                     auto curr_ll = this->end() - 1;
@@ -1146,8 +1147,7 @@ logfile::rebuild_index(std::optional<ui_clock::time_point> deadline)
             this->lf_notes.writeAccess()->emplace(note_type::indexing_disabled,
                                                   note_um);
             if (this->lf_logfile_observer != nullptr) {
-                this->lf_logfile_observer->logfile_indexing(
-                    this->shared_from_this(), 0, 0);
+                this->lf_logfile_observer->logfile_indexing(this, 0, 0);
             }
         }
 
@@ -1219,7 +1219,8 @@ logfile::rebuild_index(std::optional<ui_clock::time_point> deadline)
         this->lf_sort_needed = false;
     }
 
-    this->lf_index_time = std::chrono::seconds{this->lf_line_buffer.get_file_time()};
+    this->lf_index_time
+        = std::chrono::seconds{this->lf_line_buffer.get_file_time()};
     if (this->lf_index_time.count() == 0) {
         this->lf_index_time = std::chrono::seconds{st.st_mtime};
     }
@@ -1355,7 +1356,7 @@ logfile::reobserve_from(iterator iter)
 
         if (this->lf_logfile_observer != nullptr) {
             auto indexing_res = this->lf_logfile_observer->logfile_indexing(
-                this->shared_from_this(), offset, this->size());
+                this, offset, this->size());
             if (indexing_res == logfile_observer::indexing_result::BREAK) {
                 break;
             }
@@ -1373,7 +1374,7 @@ logfile::reobserve_from(iterator iter)
     }
     if (this->lf_logfile_observer != nullptr) {
         this->lf_logfile_observer->logfile_indexing(
-            this->shared_from_this(), this->size(), this->size());
+            this, this->size(), this->size());
         this->lf_logline_observer->logline_eof(*this);
     }
 }
@@ -1685,4 +1686,3 @@ logfile::estimated_remaining_lines() const
 
     return remaining_bytes / bytes_per_line;
 }
-

src/logfile.hh

@@ -78,7 +78,7 @@ public:
      * @param total The total size of the file.
      * @return false
      */
-    virtual indexing_result logfile_indexing(const std::shared_ptr<logfile>& lf,
+    virtual indexing_result logfile_indexing(const logfile* lf,
                                              file_off_t off,
                                              file_size_t total)
         = 0;
@@ -87,7 +87,7 @@ public:
 struct logfile_activity {
     int64_t la_polls{0};
     int64_t la_reads{0};
-    struct rusage la_initial_index_rusage {};
+    struct rusage la_initial_index_rusage{};
 };
 
 /**
@@ -180,7 +180,10 @@ public:
      * @return The last modified time of the file when the file was last
      * indexed.
      */
-    std::chrono::microseconds get_modified_time() const { return this->lf_index_time; }
+    std::chrono::microseconds get_modified_time() const
+    {
+        return this->lf_index_time;
+    }
 
     int get_time_offset_line() const { return this->lf_time_offset_line; }
 
@@ -464,7 +467,7 @@ private:
     std::optional<std::filesystem::path> lf_actual_path;
     std::string lf_basename;
     std::string lf_content_id;
-    struct stat lf_stat {};
+    struct stat lf_stat{};
     std::shared_ptr<log_format> lf_format;
     uint32_t lf_format_quality{0};
     std::vector<logline> lf_index;
@@ -473,9 +476,7 @@ private:
     bool lf_sort_needed{false};
     line_buffer lf_line_buffer;
     int lf_time_offset_line{0};
-    struct timeval lf_time_offset {
-        0, 0
-    };
+    struct timeval lf_time_offset{0, 0};
     bool lf_is_closed{false};
     bool lf_indexing{true};
     bool lf_partial_line{false};

src/textview_curses.cc

@@ -1083,7 +1083,8 @@ textview_curses::grep_value_for_line(vis_line_t line, std::string& value_out)
         if (retval.li_utf8_scan_result.is_valid()
             && retval.li_utf8_scan_result.usr_has_ansi)
         {
-            // log_debug("has ansi %d", retval.li_utf8_scan_result.usr_has_ansi);
+            // log_debug("has ansi %d",
+            // retval.li_utf8_scan_result.usr_has_ansi);
             auto new_size = erase_ansi_escapes(value_out);
             value_out.resize(new_size);
         }
@@ -1384,6 +1385,12 @@ logfile_filter_state::resize(size_t newsize)
     }
 }
 
+void
+logfile_filter_state::reserve(size_t expected)
+{
+    this->tfs_mask.reserve(expected);
+}
+
 std::optional<size_t>
 logfile_filter_state::content_line_to_vis_line(uint32_t line)
 {

src/textview_curses.hh

@@ -48,6 +48,7 @@
 #include "ring_span.hh"
 #include "text_format.hh"
 #include "textview_curses_fwd.hh"
+#include "vis_line.hh"
 
 class textview_curses;
 
@@ -65,6 +66,8 @@ public:
 
     void resize(size_t newsize);
 
+    void reserve(size_t expected);
+
     std::optional<size_t> content_line_to_vis_line(uint32_t line);
 
     const static int MAX_FILTERS = 32;