[pcre2pp] try to optimize matches... but doesn't do much...

Author: tstack

src/base/time_util.cc

@@ -380,7 +380,7 @@ exttm::from_tv(const timeval& tv)
 {
     auto retval = exttm{};
 
-    retval.et_tm = *gmtime(&tv.tv_sec);
+    gmtime_r(&tv.tv_sec, &retval.et_tm);
     retval.et_nsec = tv.tv_usec * 1000;
 
     return retval;

src/log_format.cc

@@ -1401,11 +1401,9 @@ external_log_format::scan(logfile& lf,
             continue;
         }
 
-        auto match_res = pat->capture_from(line_sf)
-                             .into(md)
-                             .matches(PCRE2_NO_UTF_CHECK)
-                             .ignore_error();
-        if (!match_res) {
+        auto found_match
+            = pat->capture_from(line_sf).into(md).found_p(PCRE2_NO_UTF_CHECK);
+        if (!found_match) {
             if (!this->lf_pattern_locks.empty() && pat_index != -1) {
                 curr_fmt = -1;
                 pat_index = -1;

src/log_format_fwd.hh

@@ -32,12 +32,18 @@
 #ifndef lnav_log_format_fwd_hh
 #define lnav_log_format_fwd_hh
 
+#include <chrono>
+#include <cstdint>
+#include <optional>
 #include <utility>
 
 #include <sys/types.h>
+#include <time.h>
 
 #include "ArenaAlloc/arenaalloc.h"
 #include "base/file_range.hh"
+#include "base/intern_string.hh"
+#include "base/log_level_enum.hh"
 #include "base/map_util.hh"
 #include "base/string_attr_type.hh"
 #include "byte_array.hh"
@@ -153,11 +159,12 @@ public:
           ll_sub_offset(0), ll_valid_utf(1), ll_level(lev), ll_module_id(mod),
           ll_meta_mark(0), ll_expr_mark(0)
     {
-        memset(this->ll_schema, 0, sizeof(this->ll_schema));
+        this->ll_schema[0] = 0;
+        this->ll_schema[1] = 0;
     }
 
     logline(file_off_t off,
-            const struct timeval& tv,
+            const timeval& tv,
             log_level_t lev,
             uint8_t mod = 0,
             uint8_t opid = 0)
@@ -166,7 +173,8 @@ public:
           ll_expr_mark(0)
     {
         this->set_time(tv);
-        memset(this->ll_schema, 0, sizeof(this->ll_schema));
+        this->ll_schema[0] = 0;
+        this->ll_schema[1] = 0;
     }
 
     /** @return The offset of the line in the file. */
@@ -192,10 +200,10 @@ public:
 
     void to_exttm(struct exttm& tm_out) const
     {
-        auto secs = static_cast<time_t>(
+        const auto secs = static_cast<time_t>(
             this->get_time<std::chrono::seconds>().count());
 
-        tm_out.et_tm = *gmtime(&secs);
+        gmtime_r(&secs, &tm_out.et_tm);
         tm_out.et_nsec
             = this->get_subsecond_time<std::chrono::nanoseconds>().count();
     }
@@ -216,10 +224,7 @@ public:
         };
     }
 
-    void set_time(const timeval& tv)
-    {
-        this->ll_time = to_us(tv);
-    }
+    void set_time(const timeval& tv) { this->ll_time = to_us(tv); }
 
     template<typename T>
     void set_subsecond_time(T sub)
@@ -340,8 +345,6 @@ public:
         memcpy(this->ll_schema, ba.in(), sizeof(this->ll_schema));
     }
 
-    char get_schema() const { return this->ll_schema[0]; }
-
     /**
      * Perform a partial match of the given schema against this log line.
      * Storing the full schema is not practical, so we just keep the first four

src/pcrepp/pcre2pp.cc

@@ -34,8 +34,7 @@
 #include "config.h"
 #include "ww898/cp_utf8.hpp"
 
-namespace lnav {
-namespace pcre2pp {
+namespace lnav::pcre2pp {
 
 std::string
 match_data::to_string() const
@@ -395,6 +394,53 @@ code::named_captures::end() const
     };
 }
 
+bool
+matcher::found_p(uint32_t options)
+{
+    this->mb_input.i_offset = this->mb_input.i_next_offset;
+
+    if (this->mb_input.i_offset == -1) {
+        return false;
+    }
+
+    auto rc = pcre2_match(this->mb_code.p_code.in(),
+                          this->mb_input.i_string.udata(),
+                          this->mb_input.i_string.length(),
+                          this->mb_input.i_offset,
+                          options,
+                          this->mb_match_data.md_data.in(),
+                          nullptr);
+
+    if (rc > 0) {
+        this->mb_match_data.md_input = this->mb_input;
+        this->mb_match_data.md_code = &this->mb_code;
+        this->mb_match_data.md_capture_end = rc;
+        if (this->mb_match_data[0]->empty()
+            && this->mb_match_data[0]->sf_end >= this->mb_input.i_string.sf_end)
+        {
+            this->mb_input.i_next_offset = -1;
+        } else if (this->mb_match_data[0]->empty()) {
+            this->mb_input.i_next_offset
+                = this->mb_match_data.md_ovector[1] + 1;
+        } else {
+            this->mb_input.i_next_offset = this->mb_match_data.md_ovector[1];
+        }
+        this->mb_match_data.md_input.i_next_offset
+            = this->mb_input.i_next_offset;
+        return true;
+    }
+
+    this->mb_match_data.md_input = this->mb_input;
+    this->mb_match_data.md_ovector[0] = this->mb_input.i_offset;
+    this->mb_match_data.md_ovector[1] = this->mb_input.i_offset;
+    this->mb_match_data.md_capture_end = 1;
+    if (rc == PCRE2_ERROR_NOMATCH) {
+        return false;
+    }
+
+    return false;
+}
+
 matcher::matches_result
 matcher::matches(uint32_t options)
 {
@@ -474,5 +520,4 @@ matcher::error::get_message()
     return {(const char*) buffer};
 }
 
-}  // namespace pcre2pp
-}  // namespace lnav
+}  // namespace lnav::pcre2pp

src/pcrepp/pcre2pp.hh

@@ -44,8 +44,7 @@
 #include "base/result.h"
 #include "mapbox/variant.hpp"
 
-namespace lnav {
-namespace pcre2pp {
+namespace lnav::pcre2pp {
 
 class code;
 struct capture_builder;
@@ -171,6 +170,8 @@ public:
         return *this;
     }
 
+    bool found_p(uint32_t options = 0);
+
     matches_result matches(uint32_t options = 0);
 
     int get_next_offset() const { return this->mb_input.i_next_offset; }
@@ -380,7 +381,6 @@ capture_builder::for_each(F func) &&
     return Err(eret);
 }
 
-}  // namespace pcre2pp
-}  // namespace lnav
+}  // namespace lnav::pcre2pp
 
 #endif

src/relative_time.cc

@@ -1002,10 +1002,7 @@ relative_time::window_start(const struct exttm& tm) const
         tv.tv_sec = us / 1000000ULL;
         tv.tv_usec = us % 1000000ULL;
 
-        retval.et_tm = *gmtime(&tv.tv_sec);
-        retval.et_nsec = tv.tv_usec * 1000ULL;
-
-        return retval;
+        return exttm::from_tv(tv);
     }
 
     bool clear = false;

src/relative_time.hh

@@ -30,7 +30,7 @@
 #ifndef LNAV_RELATIVE_TIME_HH
 #define LNAV_RELATIVE_TIME_HH
 
-#include <sys/time.h>
+#include <time.h>
 
 #define __STDC_FORMAT_MACROS
 #include <array>
@@ -187,43 +187,39 @@ public:
         return true;
     }
 
-    struct exttm adjust_now() const
+    exttm adjust_now() const
     {
-        struct exttm tm;
+        exttm tm;
         time_t now;
 
         time(&now);
-        tm.et_tm = *gmtime(&now);
+        gmtime_r(&now, &tm.et_tm);
         return this->adjust(tm);
     }
 
-    struct exttm adjust(const struct timeval& tv) const
+    exttm adjust(const struct timeval& tv) const
     {
-        struct exttm tm;
-
-        tm.et_tm = *gmtime(&tv.tv_sec);
-        tm.et_nsec = tv.tv_usec * 1000;
-        return this->adjust(tm);
+        return this->adjust(exttm::from_tv(tv));
     }
 
-    struct exttm adjust(const struct exttm& tm) const;
+    exttm adjust(const struct exttm& tm) const;
 
-    std::optional<exttm> window_start(const struct exttm& tm) const;
+    std::optional<exttm> window_start(const exttm& tm) const;
 
     int64_t to_microseconds() const;
 
-    void to_timeval(struct timeval& tv_out) const
+    void to_timeval(timeval& tv_out) const
     {
-        int64_t us = this->to_microseconds();
+        const auto us = this->to_microseconds();
 
         tv_out.tv_sec = us / (1000 * 1000);
         tv_out.tv_usec = us % (1000 * 1000);
     }
 
-    struct timeval to_timeval() const
+    timeval to_timeval() const
     {
-        int64_t us = this->to_microseconds();
-        struct timeval retval;
+        const auto us = this->to_microseconds();
+        timeval retval;
 
         retval.tv_sec = us / (1000 * 1000);
         retval.tv_usec = us % (1000 * 1000);

src/time-extension-functions.cc

@@ -111,7 +111,7 @@ timeslice(sqlite3_value* time_in, std::optional<const char*> slice_in_opt)
 
             tv.tv_sec = std::chrono::duration_cast<std::chrono::seconds>(msecs)
                             .count();
-            tm.et_tm = *gmtime(&tv.tv_sec);
+            gmtime_r(&tv.tv_sec, &tm.et_tm);
             tm.et_nsec = std::chrono::duration_cast<std::chrono::nanoseconds>(
                              msecs % 1000)
                              .count();
@@ -123,7 +123,7 @@ timeslice(sqlite3_value* time_in, std::optional<const char*> slice_in_opt)
             auto fract = modf(secs, &integ);
 
             tv.tv_sec = integ;
-            tm.et_tm = *gmtime(&tv.tv_sec);
+            gmtime_r(&tv.tv_sec, &tm.et_tm);
             tm.et_nsec = floor(fract * 1000000000.0);
             break;
         }