Various scheme-related optimizations. (#300)

* Various scheme-related optimizations.

* Various fixes

Author: lemire

include/ada/common_defs.h

@@ -275,4 +275,12 @@ namespace ada {
 #define ADA_ASSERT_EQUAL(LHS, RHS, MESSAGE)
 #define ADA_ASSERT_TRUE(COND)
 #endif
+
+
+
+#ifdef ADA_VISUAL_STUDIO
+#define ADA_ASSUME(COND) __assume(COND)
+#else
+#define ADA_ASSUME(COND) do { if (!(COND)) __builtin_unreachable(); } while (0)
+#endif
 #endif // ADA_COMMON_DEFS_H

include/ada/url-inl.h

@@ -154,6 +154,8 @@ inline bool url::base_fragment_has_value() const { return fragment.has_value();
 
 inline bool url::base_search_has_value() const { return query.has_value(); }
 
+inline void url::set_protocol_as_file() { type =  ada::scheme::type::FILE; }
+
 inline void url::set_scheme(std::string &&new_scheme) noexcept {
   type = ada::scheme::get_scheme_type(new_scheme);
   // We only move the 'scheme' if it is non-special.

include/ada/url.h

@@ -120,6 +120,8 @@ struct url : url_base {
   inline bool base_fragment_has_value() const override;
   /** @private */
   inline bool base_search_has_value() const override;
+  /** @private set this URL's type to file */
+  inline void set_protocol_as_file();
   /** @return true if the URL has host */
   [[nodiscard]] inline bool has_hostname() const noexcept;
   /** @return true if it has an host but it is the empty string */

include/ada/url_aggregator-inl.h

@@ -97,6 +97,7 @@ inline void url_aggregator::update_base_hostname(const std::string_view input) {
 
   bool has_credential = components.protocol_end + 2 < components.host_start;
   uint32_t current_length = components.host_end - components.host_start;
+  // next line could overflow but unsigned arithmetic has well-defined overflows.
   uint32_t new_difference = uint32_t(input.size()) - current_length;
   // The common case is current_length == 0.
   buffer.erase(components.host_start, current_length);
@@ -676,6 +677,32 @@ ada_really_inline size_t url_aggregator::parse_port(std::string_view view, bool
   return consumed;
 }
 
+inline void url_aggregator::set_protocol_as_file() {
+  ada_log("url_aggregator::set_protocol_as_file ");
+  ADA_ASSERT_TRUE(validate());
+  type =  ada::scheme::type::FILE;
+  // next line could overflow but unsigned arithmetic has well-defined overflows.
+  uint32_t new_difference = 5 - components.protocol_end;
+
+  if(buffer.empty()) {
+    buffer.append("file:");
+  } else {
+    buffer.erase(0, components.protocol_end);
+    buffer.insert(0, "file:");
+  }
+  components.protocol_end = 5;
+
+  // Update the rest of the components.
+  components.username_end += new_difference;
+  components.host_start += new_difference;
+  components.host_end += new_difference;
+  components.pathname_start += new_difference;
+  if (components.search_start != url_components::omitted) { components.search_start += new_difference; }
+  if (components.hash_start != url_components::omitted) { components.hash_start += new_difference; }
+  ADA_ASSERT_TRUE(validate());
+}
+
+
 }
 
 #endif // ADA_URL_AGGREGATOR_INL_H

include/ada/url_aggregator.h

@@ -42,10 +42,17 @@ namespace ada {
     void set_search(const std::string_view input);
     void set_hash(const std::string_view input);
     inline void set_scheme(std::string_view new_scheme) noexcept;
+    /** @private fast function to set the scheme from a view with a colon in the buffer, does not change type */
+    inline void set_scheme_from_view_with_colon(std::string_view new_scheme_with_colon) noexcept;
+
     inline void copy_scheme(const url_aggregator& u) noexcept;
 
     [[nodiscard]] bool has_valid_domain() const noexcept override;
 
+    /** @private */
+    inline bool has_authority() const noexcept;
+    /** @private set this URL's type to file */
+    inline void set_protocol_as_file();
     /**
      * The origin getter steps are to return the serialization of this’s URL’s
      * origin. [HTML]
@@ -233,9 +240,7 @@ namespace ada {
     inline void consume_prepared_path(std::string_view input);
     /** @private */
     template <bool has_state_override = false>
-    [[nodiscard]] ada_really_inline bool parse_scheme(const std::string_view input);
-    /** @private */
-    inline bool has_authority() const noexcept;
+    [[nodiscard]] ada_really_inline bool parse_scheme_with_colon(const std::string_view input);
 
     /**
      * Useful for implementing efficient serialization for the URL.

src/parser.cpp

@@ -37,6 +37,22 @@ namespace ada::parser {
     // we must return.
     if(base_url != nullptr) { url.is_valid &= base_url->is_valid; }
     if(!url.is_valid) { return url; }
+    if constexpr (result_type_is_ada_url_aggregator) {
+      // Most of the time, we just need user_input.size().
+      // In some instances, we may need a bit more.
+      ///////////////////////////
+      // This is *very* important. This line should be removed
+      // hastily. There are principled reasons why reserve is important
+      // for performance. If you have a benchmark with small inputs,
+      // it may not matter, but in other instances, it could.
+      ////
+      // This rounds up to the next power of two.
+      uint32_t reserve_capacity = (0xFFFFFFFF >> helpers::leading_zeroes(uint32_t(user_input.size()))) + 1;
+      url.reserve(reserve_capacity);
+      //
+      //
+      //
+    }
     std::string tmp_buffer;
     std::string_view internal_input;
     if(unicode::has_tabs_or_newline(user_input)) {
@@ -93,7 +109,12 @@ namespace ada::parser {
           // Otherwise, if c is U+003A (:), then:
           if ((input_position != input_size) && (url_data[input_position] == ':')) {
             ada_log("SCHEME the scheme should be ", url_data.substr(0,input_position));
-            if(!url.parse_scheme(url_data.substr(0,input_position))) { return url; }
+            if constexpr (result_type_is_ada_url) {
+              if(!url.parse_scheme(url_data.substr(0,input_position))) { return url; }
+            } else {
+              // we pass the colon along instead of painfully adding it back.
+              if(!url.parse_scheme_with_colon(url_data.substr(0,input_position+1))) { return url; }
+            }
             ada_log("SCHEME the scheme is ", url.get_protocol());
 
             // If url’s scheme is "file", then:
@@ -653,8 +674,7 @@ namespace ada::parser {
           ada_log("FILE ", helpers::substring(url_data, input_position));
           std::string_view file_view = helpers::substring(url_data, input_position);
 
-          // Set url’s scheme to "file".
-          url.set_scheme("file");
+          url.set_protocol_as_file();
           if constexpr (result_type_is_ada_url) {
             // Set url’s host to the empty string.
             url.host = "";

src/url_aggregator.cpp

@@ -14,10 +14,12 @@
 
 namespace ada {
 template <bool has_state_override>
-[[nodiscard]] ada_really_inline bool url_aggregator::parse_scheme(const std::string_view input) {
-  ada_log("url_aggregator::parse_scheme ", input);
+[[nodiscard]] ada_really_inline bool url_aggregator::parse_scheme_with_colon(const std::string_view input_with_colon) {
+  ada_log("url_aggregator::parse_scheme_with_colon ", input_with_colon);
   ADA_ASSERT_TRUE(validate());
-  ADA_ASSERT_TRUE(!helpers::overlaps(input, buffer));
+  ADA_ASSERT_TRUE(!helpers::overlaps(input_with_colon, buffer));
+  std::string_view input{input_with_colon};
+  input.remove_suffix(1);
   auto parsed_type = ada::scheme::get_scheme_type(input);
   bool is_input_special = (parsed_type != ada::scheme::NOT_SPECIAL);
   /**
@@ -36,16 +38,15 @@ template <bool has_state_override>
       if (type == ada::scheme::type::FILE && components.host_start == components.host_end) { return true; }
     }
 
-    set_scheme(input);
+    type = parsed_type;
+    set_scheme_from_view_with_colon(input_with_colon);
 
     if (has_state_override) {
       // This is uncommon.
       uint16_t urls_scheme_port = get_special_port();
 
-      if (urls_scheme_port) {
-        // If url’s port is url’s scheme’s default port, then set url’s port to null.
-        if (components.port == urls_scheme_port) { components.port = url_components::omitted; }
-      }
+      // If url’s port is url’s scheme’s default port, then set url’s port to null.
+      if (components.port == urls_scheme_port) { components.port = url_components::omitted; }
     }
   } else { // slow path
     std::string _buffer = std::string(input);
@@ -69,16 +70,14 @@ template <bool has_state_override>
       if (type == ada::scheme::type::FILE && components.host_start == components.host_end) { return true; }
     }
 
-    set_scheme(std::move(_buffer));
+    set_scheme(_buffer);
 
     if (has_state_override) {
       // This is uncommon.
       uint16_t urls_scheme_port = get_special_port();
 
-      if (urls_scheme_port) {
-        // If url’s port is url’s scheme’s default port, then set url’s port to null.
-        if (components.port == urls_scheme_port) { components.port = url_components::omitted; }
-      }
+      // If url’s port is url’s scheme’s default port, then set url’s port to null.
+      if (components.port == urls_scheme_port) { components.port = url_components::omitted; }
     }
   }
   ADA_ASSERT_TRUE(validate());
@@ -88,6 +87,7 @@ template <bool has_state_override>
 inline void url_aggregator::copy_scheme(const url_aggregator& u) noexcept {
   ada_log("url_aggregator::copy_scheme ", u.buffer);
   ADA_ASSERT_TRUE(validate());
+  // next line could overflow but unsigned arithmetic has well-defined overflows.
   uint32_t new_difference = u.components.protocol_end - components.protocol_end;
   type = u.type;
   buffer.erase(0, components.protocol_end);
@@ -107,22 +107,48 @@ inline void url_aggregator::copy_scheme(const url_aggregator& u) noexcept {
   ADA_ASSERT_TRUE(validate());
 }
 
+inline void url_aggregator::set_scheme_from_view_with_colon(std::string_view new_scheme_with_colon) noexcept {
+  ada_log("url_aggregator::set_scheme_from_view_with_colon ", new_scheme_with_colon);
+  ADA_ASSERT_TRUE(validate());
+  ADA_ASSERT_TRUE(!new_scheme_with_colon.empty() && new_scheme_with_colon.back() == ':');
+  // next line could overflow but unsigned arithmetic has well-defined overflows.
+  uint32_t new_difference = uint32_t(new_scheme_with_colon.size()) - components.protocol_end;
+
+  if(buffer.empty()) {
+    buffer.append(new_scheme_with_colon);
+  } else {
+    buffer.erase(0, components.protocol_end);
+    buffer.insert(0, new_scheme_with_colon);
+  }
+  components.protocol_end += new_difference;
+
+  // Update the rest of the components.
+  components.username_end += new_difference;
+  components.host_start += new_difference;
+  components.host_end += new_difference;
+  components.pathname_start += new_difference;
+  if (components.search_start != url_components::omitted) { components.search_start += new_difference; }
+  if (components.hash_start != url_components::omitted) { components.hash_start += new_difference; }
+  ADA_ASSERT_TRUE(validate());
+}
+
+
 inline void url_aggregator::set_scheme(std::string_view new_scheme) noexcept {
   ada_log("url_aggregator::set_scheme ", new_scheme);
   ADA_ASSERT_TRUE(validate());
-  uint32_t new_difference = uint32_t(new_scheme.size()) - components.protocol_end;
-
-  // Optimization opportunity: Get rid of this branch
-  if (new_scheme.back() != ':') { new_difference += 1; }
+  ADA_ASSERT_TRUE(new_scheme.empty() || new_scheme.back() != ':');
+  // next line could overflow but unsigned arithmetic has well-defined overflows.
+  uint32_t new_difference = uint32_t(new_scheme.size()) - components.protocol_end + 1;
 
   type = ada::scheme::get_scheme_type(new_scheme);
-  buffer.erase(0, components.protocol_end);
-  buffer.insert(0, helpers::concat(new_scheme, ":"));
+  if(buffer.empty()) {
+    buffer.append(helpers::concat(new_scheme, ":"));
+  } else {
+    buffer.erase(0, components.protocol_end);
+    buffer.insert(0, helpers::concat(new_scheme, ":"));
+  }
   components.protocol_end = uint32_t(new_scheme.size() + 1);
 
-  // No need to update the components
-  if (new_difference == 0) { return; }
-
   // Update the rest of the components.
   components.username_end += new_difference;
   components.host_start += new_difference;
@@ -149,7 +175,7 @@ bool url_aggregator::set_protocol(const std::string_view input) {
   std::string::iterator pointer = std::find_if_not(view.begin(), view.end(), unicode::is_alnum_plus);
 
   if (pointer != view.end() && *pointer == ':') {
-    return parse_scheme<true>(std::string_view(view.data(), pointer - view.begin()));
+    return parse_scheme_with_colon<true>(std::string_view(view.data(), pointer - view.begin() + 1));
   }
   return false;
 }
@@ -1001,9 +1027,10 @@ std::string url_aggregator::to_diagram() const {
       line2[i] = '-';
     }
     line2.append(" hash_start");
+    answer.append(line2);
+    answer.append("\n");
   }
-  answer.append(line2);
-  answer.append("\n");
+
 
   std::string line3 = line1;
   if(components.search_start != url_components::omitted) {
@@ -1015,9 +1042,10 @@ std::string url_aggregator::to_diagram() const {
     }
     line3.append(" search_start ");
     line3.append(std::to_string(components.search_start));
+    answer.append(line3);
+    answer.append("\n");
   }
-  answer.append(line3);
-  answer.append("\n");
+
 
   std::string line4 = line1;
   if(components.pathname_start != buffer.size()) {
@@ -1028,9 +1056,10 @@ std::string url_aggregator::to_diagram() const {
     }
     line4.append(" pathname_start ");
     line4.append(std::to_string(components.pathname_start));
+    answer.append(line4);
+    answer.append("\n");
   }
-  answer.append(line4);
-  answer.append("\n");
+
 
   std::string line5 = line1;
   if(components.host_end != buffer.size()) {
@@ -1042,9 +1071,10 @@ std::string url_aggregator::to_diagram() const {
     }
     line5.append(" host_end ");
     line5.append(std::to_string(components.host_end));
+    answer.append(line5);
+    answer.append("\n");
   }
-  answer.append(line5);
-  answer.append("\n");
+
 
   std::string line6 = line1;
   if(components.host_start != buffer.size()) {
@@ -1056,9 +1086,10 @@ std::string url_aggregator::to_diagram() const {
     }
     line6.append(" host_start ");
     line6.append(std::to_string(components.host_start));
+    answer.append(line6);
+    answer.append("\n");
   }
-  answer.append(line6);
-  answer.append("\n");
+
 
   std::string line7 = line1;
   if(components.username_end != buffer.size()) {
@@ -1070,9 +1101,10 @@ std::string url_aggregator::to_diagram() const {
     }
     line7.append(" username_end ");
     line7.append(std::to_string(components.username_end));
+    answer.append(line7);
+    answer.append("\n");
   }
-  answer.append(line7);
-  answer.append("\n");
+
 
   std::string line8 = line1;
   if(components.protocol_end != buffer.size()) {
@@ -1084,9 +1116,10 @@ std::string url_aggregator::to_diagram() const {
     }
     line8.append(" protocol_end ");
     line8.append(std::to_string(components.protocol_end));
+    answer.append(line8);
+    answer.append("\n");
   }
-  answer.append(line8);
-  answer.append("\n");
+
 
   if(components.hash_start == url_components::omitted) {
     answer.append("note: hash omitted\n");