encode with cache + dyntab find

Author: kelbon

include/hpack/dynamic_table.hpp

@@ -16,15 +16,18 @@ struct dynamic_table_t {
 
  private:
   struct key_of_entry {
-    using type = table_entry;
-    table_entry operator()(const entry_t& v) const noexcept;
+    using type = std::string_view;
+    std::string_view operator()(const entry_t&) const noexcept;
   };
-  // for forward declaring entry_t
-  using hook_type_option = bi::base_hook<bi::set_base_hook<bi::link_mode<bi::normal_link>>>;
 
   // invariant: do not contain nullptrs
   std::vector<entry_t*> entries;
-  bi::multiset<entry_t, bi::constant_time_size<false>, hook_type_option, bi::key_of_value<key_of_entry>> set;
+  using entry_set_hook = bi::set_base_hook<bi::link_mode<bi::normal_link>>;
+  // sorted by name
+  using entry_set_t = bi::multiset<entry_t, bi::constant_time_size<false>, bi::base_hook<entry_set_hook>,
+                                   bi::key_of_value<key_of_entry>>;
+
+  entry_set_t set;
   // in bytes
   // invariant: <= _max_size
   size_type _current_size = 0;
@@ -49,7 +52,9 @@ struct dynamic_table_t {
                          Insertion Point      Dropping Point
   */
  public:
-  dynamic_table_t() = default;
+  // 4096 - default size by protocol
+  dynamic_table_t() : dynamic_table_t(4096) {
+  }
   // `user_protocol_max_size` and `max_size()` both initialized to `max_size`
   explicit dynamic_table_t(size_type max_size,
                            std::pmr::memory_resource* m = std::pmr::get_default_resource()) noexcept;
@@ -71,6 +76,12 @@ struct dynamic_table_t {
 
   dynamic_table_t& operator=(dynamic_table_t&& other) noexcept;
 
+  void swap(dynamic_table_t&) noexcept;
+
+  friend void swap(dynamic_table_t& a, dynamic_table_t& b) noexcept {
+    return a.swap(b);
+  }
+
   ~dynamic_table_t();
 
   // returns index of added pair, 0 if cannot add
@@ -97,11 +108,15 @@ struct dynamic_table_t {
     return entries.size() + static_table_t::first_unused_index - 1;
   }
 
-  find_result_t find(std::string_view name, std::string_view value) noexcept;
-  find_result_t find(index_type name, std::string_view value) noexcept;
+  // searches both static and dynamic table
+  find_result_t find(std::string_view name, std::string_view value) const noexcept;
+  // searches both static and dynamic table
+  // precondition: name <= current_max_index()
+  find_result_t find(index_type name, std::string_view value) const noexcept;
 
-  // precondition: first_unused_index <= index <= current_max_index()
+  // precondition: 0 < index <= current_max_index()
   // Note: returned value may be invalidated on next .add_entry()
+  // searches both in static and dynamic tables
   table_entry get_entry(index_type index) const noexcept;
 
   void reset() noexcept;

include/hpack/encoder.hpp

@@ -4,6 +4,8 @@
 #include "hpack/strings.hpp"
 #include "hpack/integers.hpp"
 
+#include <charconv>
+
 namespace hpack {
 
 struct encoder {
@@ -37,6 +39,11 @@ struct encoder {
 
   // only name indexed
   // precondition: header_index present in static or dynamic table
+  //
+  // Note: will encode to the cached header, but calling this function again will not result in more efficient
+  // encoding.
+  // Instead, it will send requests to cache the header and this will result in evicting from dynamic table.
+  // Its likely you want to use encode_with_cache instead
   template <bool Huffman = false, Out O>
   O encode_header_and_cache(index_type header_index, std::string_view value, O _out) {
     assert(header_index <= dyntab.current_max_index() && header_index != 0);
@@ -51,6 +58,11 @@ struct encoder {
 
   // indexes value for future use
   // 'out_index' contains index of 'name' + 'value' pair after encode
+  //
+  // Note: will encode to the cached header, but calling this function again will not result in more efficient
+  // encoding.
+  // Instead, it will send requests to cache the header and this will result in evicting from dynamic table.
+  // Its likely you want to use encode_with_cache instead
   template <bool Huffman = false, Out O>
   O encode_header_and_cache(std::string_view name, std::string_view value, O _out) {
     /*
@@ -76,6 +88,34 @@ struct encoder {
     return noexport::unadapt<O>(encode_string<Huffman>(value, out));
   }
 
+  // encodes header like 'encode_header_and_cache', but uses created cache, so next calls much more efficient
+  // than first call
+  //
+  // Note: does not use static_table. In this case its better to use `encode_header_fully_indexed`
+  template <bool Huffman = false, Out O>
+  O encode_with_cache(std::string_view name, std::string_view value, O out) {
+    find_result_t r = dyntab.find(name, value);
+    if (r.value_indexed) [[likely]] {
+      // its likely, because only first call will be not cached
+      return encode_header_fully_indexed(r.header_name_index, out);
+    }
+    return encode_header_and_cache<Huffman>(name, value, out);
+  }
+
+  // encodes header like 'encode_header_and_cache', but uses created cache, so next calls much more efficient
+  // than first call
+  //
+  // Note: does not use static_table. In this case its better to use `encode_header_fully_indexed`
+  template <bool Huffman = false, Out O>
+  O encode_with_cache(index_type name, std::string_view value, O out) {
+    find_result_t r = dyntab.find(name, value);
+    if (r.value_indexed) [[likely]] {
+      // its likely, because only first call will be not cached
+      return encode_header_fully_indexed(r.header_name_index, out);
+    }
+    return encode_header_and_cache<Huffman>(name, value, out);
+  }
+
   template <bool Huffman = false, Out O>
   O encode_header_without_indexing(index_type name, std::string_view value, O _out) {
     /*
@@ -251,6 +291,35 @@ struct encoder {
     dyntab.update_size(new_size);
     return it;
   }
+
+  // encodes :status pseudoheader for server
+  // precondition:
+  template <Out O>
+  O encode_status(int status, O out) {
+    using enum static_table_t::values;
+    switch (status) {
+      case 200:
+        return encode_header_fully_indexed(status_200, out);
+      case 204:
+        return encode_header_fully_indexed(status_204, out);
+      case 206:
+        return encode_header_fully_indexed(status_206, out);
+      case 304:
+        return encode_header_fully_indexed(status_304, out);
+      case 400:
+        return encode_header_fully_indexed(status_400, out);
+      case 404:
+        return encode_header_fully_indexed(status_404, out);
+      case 500:
+        return encode_header_fully_indexed(status_500, out);
+      default:
+        char data[32];
+        auto [ptr, ec] = std::to_chars(data, data + 32, status);
+        assert(ec == std::errc{});
+        // its likely, that server will send this status again, so cache it
+        return encode_with_cache(status_200, std::string_view(+data, ptr), out);
+    }
+  }
 };
 
 }  // namespace hpack

src/dynamic_table.cpp

@@ -4,11 +4,9 @@
 #include <utility>
 #include <cstring>  // memcpy
 
-namespace bi = boost::intrusive;
-
 namespace hpack {
 
-struct dynamic_table_t::entry_t : bi::set_base_hook<bi::link_mode<bi::normal_link>> {
+struct dynamic_table_t::entry_t : entry_set_hook {
   const size_type name_end;
   const size_type value_end;
   const size_t _insert_c;
@@ -46,6 +44,10 @@ struct dynamic_table_t::entry_t : bi::set_base_hook<bi::link_mode<bi::normal_lin
   }
 };
 
+std::string_view dynamic_table_t::key_of_entry::operator()(const dynamic_table_t::entry_t& v) const noexcept {
+  return v.name();
+}
+
 // precondition: 'e' now in entries
 index_type dynamic_table_t::indexof(const dynamic_table_t::entry_t& e) const noexcept {
   return static_table_t::first_unused_index + (_insert_count - e._insert_c);
@@ -61,10 +63,6 @@ static size_type entry_size(const dynamic_table_t::entry_t& entry) noexcept {
   return entry.value_end + 32;
 }
 
-table_entry dynamic_table_t::key_of_entry::operator()(const dynamic_table_t::entry_t& v) const noexcept {
-  return {v.name(), v.value()};
-}
-
 dynamic_table_t::dynamic_table_t(size_type max_size, std::pmr::memory_resource* m) noexcept
     : _current_size(0),
       _max_size(max_size),
@@ -73,25 +71,23 @@ dynamic_table_t::dynamic_table_t(size_type max_size, std::pmr::memory_resource*
       _resource(m ? m : std::pmr::get_default_resource()) {
 }
 
-dynamic_table_t::dynamic_table_t(dynamic_table_t&& other) noexcept
-    : entries(std::move(other.entries)),
-      set(std::move(other.set)),
-      _current_size(std::exchange(other._current_size, 0)),
-      _max_size(std::exchange(other._max_size, 0)),
-      _insert_count(std::exchange(other._insert_count, 0)),
-      _resource(std::exchange(other._resource, std::pmr::get_default_resource())) {
+void dynamic_table_t::swap(dynamic_table_t& other) noexcept {
+  using std::swap;
+  swap(entries, other.entries);
+  swap(set, other.set);
+  swap(_current_size, other._current_size);
+  swap(_max_size, other._max_size);
+  swap(_user_protocol_max_size, other._user_protocol_max_size);
+  swap(_insert_count, other._insert_count);
+  swap(_resource, other._resource);
+}
+
+dynamic_table_t::dynamic_table_t(dynamic_table_t&& other) noexcept {
+  swap(other);
 }
 
 dynamic_table_t& dynamic_table_t::operator=(dynamic_table_t&& other) noexcept {
-  if (this == &other) [[unlikely]]
-    return *this;
-  reset();
-  entries = std::move(other.entries);
-  set = std::move(other.set);
-  _current_size = std::exchange(other._current_size, 0);
-  _max_size = std::exchange(other._max_size, 0);
-  _insert_count = std::exchange(other._insert_count, 0);
-  _resource = std::exchange(other._resource, std::pmr::get_default_resource());
+  swap(other);
   return *this;
 }
 
@@ -129,38 +125,26 @@ void dynamic_table_t::update_size(size_type new_max_size) {
   _max_size = new_max_size;
 }
 
-find_result_t dynamic_table_t::find(std::string_view name, std::string_view value) noexcept {
+find_result_t dynamic_table_t::find(std::string_view name, std::string_view value) const noexcept {
   find_result_t r;
-  auto it = set.find(table_entry{name, value});
-  if (it == set.end())
-    return r;
-  if (name == it->name()) {
-    r.header_name_index = indexof(*it);
-    if (value == it->value())
-      r.value_indexed = true;
+  auto [b, e] = set.equal_range(name);
+  for (; b != e; ++b) {
+    if (b->name() == name) {
+      r.header_name_index = indexof(*b);
+      if (b->value() == value) {
+        r.value_indexed = true;
+        return r;
+      }
+    }
   }
   return r;
 }
 
-find_result_t dynamic_table_t::find(index_type name, std::string_view value) noexcept {
+find_result_t dynamic_table_t::find(index_type name, std::string_view value) const noexcept {
   assert(name <= current_max_index());
-  find_result_t r;
-  if (name < static_table_t::first_unused_index || name > current_max_index() || name == 0)
-    return r;
-  table_entry e = get_entry(name);
-  if (e.value == value) {
-    r.header_name_index = name;
-    r.value_indexed = true;
-    return r;
-  }
-  auto it = set.find(table_entry{e.name, value});
-  assert(it != set.end());
-  if (e.name == it->name()) {
-    r.header_name_index = indexof(*it);
-    if (value == it->value())
-      r.value_indexed = true;
-  }
-  return r;
+  if (name == 0) [[unlikely]]
+    return {};
+  return find(get_entry(name).name, value);
 }
 
 void dynamic_table_t::reset() noexcept {
@@ -175,15 +159,17 @@ void dynamic_table_t::evict_until_fits_into(size_type bytes) noexcept {
   size_type i = 0;
   for (; _current_size > bytes; ++i) {
     _current_size -= entry_size(*entries[i]);
-    set.erase(set.s_iterator_to(*entries[i]));
+    set.erase(set.iterator_to(*entries[i]));
     entry_t::destroy(entries[i], _resource);
   }
   // evicts should be rare operation
   entries.erase(entries.begin(), entries.begin() + i);
 }
 
 table_entry dynamic_table_t::get_entry(index_type index) const noexcept {
-  assert(index >= static_table_t::first_unused_index && index <= current_max_index());
+  assert(index != 0 && index <= current_max_index());
+  if (index < static_table_t::first_unused_index)
+    return static_table_t::get_entry(index);
   auto& e = *(&entries.back() - (index - static_table_t::first_unused_index));
   return table_entry{e->name(), e->value()};
 }