perf: optimize the vector performance in favor of small_vector

Signed-off-by: c8ef <c8ef@outlook.com>

Author: c8ef

include/Makefile.am

@@ -86,7 +86,6 @@ bm/bm_sim/queue.h \
 bm/bm_sim/queueing.h \
 bm/bm_sim/ras.h \
 bm/bm_sim/runtime_interface.h \
-bm/bm_sim/short_alloc.h \
 bm/bm_sim/stateful.h \
 bm/bm_sim/switch.h \
 bm/bm_sim/simple_pre.h \

include/bm/bm_sim/CPPLINT.cfg

@@ -3,4 +3,3 @@
 # SPDX-License-Identifier: Apache-2.0
 
 exclude_files=nn\.h
-exclude_files=short_alloc\.h

include/bm/bm_sim/bytecontainer.h

@@ -15,14 +15,13 @@
 #ifndef BM_BM_SIM_BYTECONTAINER_H_
 #define BM_BM_SIM_BYTECONTAINER_H_
 
-#include <vector>
 #include <iterator>
 #include <string>
+#include <vector>
 
+#include <boost/container/small_vector.hpp>
 #include <boost/functional/hash.hpp>
 
-#include "short_alloc.h"
-
 namespace bm {
 
 //! This class is used everytime a vector of bytes is needed in bmv2. It is most
@@ -32,7 +31,7 @@ class ByteContainer {
   static constexpr size_t S = 16u;
   static_assert(sizeof(char) == 1, "");
   static_assert(alignof(char) == 1, "");
-  using _vector = std::vector<char, detail::short_alloc<char, S, 1> >;
+  using _vector = boost::container::small_vector<char, S>;
 
  public:
   using iterator = _vector::iterator;
@@ -42,22 +41,19 @@ class ByteContainer {
   using size_type = size_t;
 
  public:
-  ByteContainer()
-      : bytes(_a) {
-    bytes.reserve(S);
-  }
+  ByteContainer() = default;
 
   //! Constructs the container with \p nbytes copies of elements with value \p c
   explicit ByteContainer(const size_t nbytes, const char c = '\x00')
-      : bytes(nbytes, c, _a) { }
+      : bytes(nbytes, c) {}
 
   //! Constructs the container by copying the bytes in vector \p bytes
-  explicit ByteContainer(const std::vector<char> &bytes)
-      : bytes(bytes.begin(), bytes.end(), _a) { }
+  explicit ByteContainer(const std::vector<char>& bytes)
+      : bytes(bytes.begin(), bytes.end()) {}
 
   //! Constructs the container by copying the bytes in this byte array
-  ByteContainer(const char *bytes, size_t nbytes)
-      : bytes(bytes, bytes + nbytes, _a) { }
+  ByteContainer(const char* bytes, size_t nbytes)
+      : bytes(bytes, bytes + nbytes) {}
 
   static char char2digit(char c) {
     if (c >= '0' && c <= '9')
@@ -72,14 +68,14 @@ class ByteContainer {
 
   //! Constructs the container from a hexadecimal string. Parameter \p hexstring
   //! can optionally include the `0x` prefix.
-  explicit ByteContainer(const std::string &hexstring)
-      : bytes(_a) {
-    bytes.reserve(S);
+  explicit ByteContainer(const std::string& hexstring) {
+    if (hexstring.empty()) return;
     size_t idx = 0;
 
     assert(hexstring[idx] != '-');
 
-    if (hexstring[idx] == '0' && hexstring[idx + 1] == 'x') {
+    if (hexstring.size() >= 2 && hexstring[idx] == '0' &&
+        hexstring[idx + 1] == 'x') {
       idx += 2;
     }
     size_t size = hexstring.size();
@@ -97,19 +93,11 @@ class ByteContainer {
     }
   }
 
-  ByteContainer(const ByteContainer &other)
-      : bytes(other.bytes, _a) { }
-
-  ByteContainer &operator=(const ByteContainer &other) {
-    bytes.assign(other.begin(), other.end());
-    return *this;
-  }
-
   //! Returns the number of bytes in the container
   size_type size() const noexcept { return bytes.size(); }
 
   //! Clears the contents of the container
-  void clear() { return bytes.clear(); }
+  void clear() { bytes.clear(); }
 
   // iterators
 
@@ -265,7 +253,6 @@ class ByteContainer {
   }
 
  private:
-  _vector::allocator_type::arena_type _a;
   _vector bytes;
 };
 

include/bm/bm_sim/short_alloc.h

@@ -30,16 +30,16 @@
 #include <functional>
 #include <mutex>
 #include <string>
-#include <unordered_set>
 #include <unordered_map>
+#include <unordered_set>
 #include <vector>
 
+#include <boost/container/small_vector.hpp>
 #include <boost/thread/locks.hpp>  // for boost::lock
 
 #include "bignum.h"
 #include "data.h"
 #include "named_p4object.h"
-#include "short_alloc.h"
 
 namespace bm {
 
@@ -175,19 +175,16 @@ class RegisterSync {
   using Lock = RegisterArray::UniqueLock;
 
   template <size_t NumLocks = 4>
-  using LockVector = std::vector<
-    Lock, ::detail::short_alloc<Lock, NumLocks * sizeof(Lock), alignof(Lock)> >;
+  using LockVector = boost::container::small_vector<Lock, NumLocks>;
 
   struct RegisterLocks {
-    LockVector<>::allocator_type::arena_type a;
-    LockVector<> v{a};
+    LockVector<> v{};
   };
 
   void add_register_array(const RegisterArray *register_array);
 
   void merge_from(const RegisterSync &other);
 
-  // tried NRVO, but RegisterLocks not movable
   void lock(RegisterLocks *RL) const {
     for (auto m : mutexes) RL->v.emplace_back(*m, std::defer_lock);
     boost::lock(RL->v.begin(), RL->v.end());