diff --git a/base/CMakeLists.txt b/base/CMakeLists.txt
index 855619eebb..6bf99996f5 100644
--- a/base/CMakeLists.txt
+++ b/base/CMakeLists.txt
@@ -63,6 +63,7 @@ set(SRC
   set_operations.hpp
   shared_buffer_manager.cpp
   shared_buffer_manager.hpp
+  small_map.hpp
   small_set.hpp
   src_point.cpp
   src_point.hpp
diff --git a/base/base_tests/small_set_test.cpp b/base/base_tests/small_set_test.cpp
index 41d08935d1..9a633ed9eb 100644
--- a/base/base_tests/small_set_test.cpp
+++ b/base/base_tests/small_set_test.cpp
@@ -1,15 +1,19 @@
 #include "testing/testing.hpp"
 
+#include "base/small_map.hpp"
 #include "base/small_set.hpp"
+#include "base/timer.hpp"
 
 #include <algorithm>
 #include <iterator>
+#include <random>
 #include <vector>
+#include <unordered_map>
 
+namespace small_set_test
+{
 using namespace base;
 
-namespace
-{
 UNIT_TEST(SmallSet_Empty)
 {
   SmallSet<0> set;
@@ -73,4 +77,191 @@ UNIT_TEST(SmallSet_Smoke)
 
   TEST_EQUAL(set.Size(), std::distance(set.begin(), set.end()), ());
 }
-}  // namespace
+
+#ifndef DEBUG
+std::vector<uint32_t> GenerateIndices(uint32_t min, uint32_t max)
+{
+  std::vector<uint32_t> res;
+
+  std::uniform_int_distribution<uint64_t> randDist(min, max);
+  std::random_device randDevice;
+  std::mt19937 randEngine(randDevice());
+
+  for (size_t i = 0; i < 10000000; ++i)
+    res.push_back(randDist(randEngine));
+
+  return res;
+}
+
+UNIT_TEST(SmallMap_Benchmark1)
+{
+  // 1. Init maps.
+  // Dataset is similar to routing::VehicleModel.
+  std::unordered_map<uint32_t, bool> uMap = {
+    {1, true}, {2, false}, {4, false}, {6, true}, {7, true},
+    {8, true}, {12, false}, {15, false}, {26, true}, {30, false},
+    {36, false}, {43, false}, {54, false}, {57, true}, {58, true},
+    {65, true}, {69, true}, {90, true}, {95, false}, {119, false},
+    {167, true}, {176, false}, {259, true}, {272, false}, {994, true},
+    {1054, false}
+  };
+
+  base::SmallMap<uint32_t, bool> sMap(uMap.begin(), uMap.end());
+
+  // 2. Generate indices.
+  std::vector<uint32_t> indices = GenerateIndices(1, 1054);
+
+  uint64_t t1, t2;
+  uint32_t sum1 = 0, sum2 = 0;
+
+  // 3. Run unordered_map.
+  {
+    base::Timer timer;
+    for (auto i : indices)
+      sum1 += (uMap.find(i) != uMap.end() ? 1 : 0);
+    t1 = timer.ElapsedMilliseconds();
+  }
+
+  // 4. Run SmallMap.
+  {
+    base::Timer timer;
+    for (auto i : indices)
+      sum2 += (sMap.Find(i) ? 1 : 0);
+    t2 = timer.ElapsedMilliseconds();
+  }
+
+  TEST_EQUAL(sum1, sum2, ());
+  TEST_LESS(t2, t1, ());
+  LOG(LINFO, ("unordered_map time =", t1, "SmallMap time =", t2));
+}
+
+UNIT_TEST(SmallMap_Benchmark2)
+{
+  uint32_t i = 0;
+  // Dataset is similar to routing::VehicleModelFactory.
+  std::unordered_map<std::string, std::shared_ptr<int>> uMap = {
+    {"", make_shared<int>(i++)},
+    {"Australia", make_shared<int>(i++)},
+    {"Austria", make_shared<int>(i++)},
+    {"Belarus", make_shared<int>(i++)},
+    {"Belgium", make_shared<int>(i++)},
+    {"Brazil", make_shared<int>(i++)},
+    {"Denmark", make_shared<int>(i++)},
+    {"France", make_shared<int>(i++)},
+    {"Finland", make_shared<int>(i++)},
+    {"Germany", make_shared<int>(i++)},
+    {"Hungary", make_shared<int>(i++)},
+    {"Iceland", make_shared<int>(i++)},
+    {"Netherlands", make_shared<int>(i++)},
+    {"Norway", make_shared<int>(i++)},
+    {"Oman", make_shared<int>(i++)},
+    {"Poland", make_shared<int>(i++)},
+    {"Romania", make_shared<int>(i++)},
+    {"Russian Federation", make_shared<int>(i++)},
+    {"Slovakia", make_shared<int>(i++)},
+    {"Spain", make_shared<int>(i++)},
+    {"Switzerland", make_shared<int>(i++)},
+    {"Turkey", make_shared<int>(i++)},
+    {"Ukraine", make_shared<int>(i++)},
+    {"United Kingdom", make_shared<int>(i++)},
+    {"United States of America", make_shared<int>(i++)},
+  };
+
+  base::SmallMap<std::string, std::shared_ptr<int>> sMap(uMap.begin(), uMap.end());
+
+  // 2. Generate indices.
+  std::vector<std::string> keys;
+  for (auto const & e : uMap)
+  {
+    keys.push_back(e.first);
+    keys.push_back(e.first + "_Foo");
+    keys.push_back(e.first + "_Bar");
+    keys.push_back(e.first + "_Bazz");
+  }
+  std::vector<uint32_t> indices = GenerateIndices(0, keys.size() - 1);
+
+  uint64_t t1, t2;
+  uint32_t sum1 = 0, sum2 = 0;
+
+  // 3. Run unordered_map.
+  {
+    base::Timer timer;
+    for (auto i : indices)
+    {
+      auto const it = uMap.find(keys[i]);
+      if (it != uMap.end())
+        sum1 += *it->second;
+    }
+    t1 = timer.ElapsedMilliseconds();
+  }
+
+  // 4. Run SmallMap.
+  {
+    base::Timer timer;
+    for (auto i : indices)
+    {
+      auto const * p = sMap.Find(keys[i]);
+      if (p)
+        sum2 += **p;
+    }
+    t2 = timer.ElapsedMilliseconds();
+  }
+
+  TEST_EQUAL(sum1, sum2, ());
+  // std::hash(std::string) is better than std::less(std::string)
+  TEST_LESS(t1, t2, ());
+  LOG(LINFO, ("unordered_map time =", t1, "SmallMap time =", t2));
+}
+
+UNIT_TEST(SmallMap_Benchmark3)
+{
+  // Dataset is similar to routing::VehicleModel.m_surfaceFactors.
+  std::unordered_map<int, int> uMap = {
+    {1, 0}, {10, 1}, {100, 2}, {1000, 3},
+  };
+
+  base::SmallMap<int, int> sMap(uMap.begin(), uMap.end());
+  base::SmallMapBase<int, int> sbMap(uMap.begin(), uMap.end());
+
+  std::vector<uint32_t> indices = GenerateIndices(0, 3);
+  // Missing key queries are even worse for the std map.
+  std::vector<int> keys;
+  for (auto const & e : uMap)
+    keys.push_back(e.first);
+
+  uint64_t t1, t2, t3;
+  uint32_t sum1 = 0, sum2 = 0, sum3 = 0;
+
+  // 3. Run unordered_map.
+  {
+    base::Timer timer;
+    for (auto i : indices)
+      sum1 += uMap.find(keys[i])->second;
+    t1 = timer.ElapsedMilliseconds();
+  }
+
+  // 4. Run SmallMap.
+  {
+    base::Timer timer;
+    for (auto i : indices)
+      sum2 += *sMap.Find(keys[i]);
+    t2 = timer.ElapsedMilliseconds();
+  }
+
+  // 5. Run SmallMapBase.
+  {
+    base::Timer timer;
+    for (auto i : indices)
+      sum3 += *sbMap.Find(keys[i]);
+    t3 = timer.ElapsedMilliseconds();
+  }
+
+  TEST_EQUAL(sum1, sum2, ());
+  TEST_EQUAL(sum1, sum3, ());
+  TEST_LESS(t2, t1, ());
+  TEST_LESS(t3, t2, ());
+  LOG(LINFO, ("unordered_map time =", t1, "SmallMap time =", t2, "SmallMapBase time =", t3));
+}
+#endif
+
+}  // namespace small_set_test
diff --git a/base/buffer_vector.hpp b/base/buffer_vector.hpp
index 185873431b..dce28142be 100644
--- a/base/buffer_vector.hpp
+++ b/base/buffer_vector.hpp
@@ -4,6 +4,7 @@
 
 #include <algorithm>
 #include <cstring>       // for memcpy
+#include <iterator>
 #include <type_traits>
 #include <utility>
 #include <vector>
@@ -47,9 +48,9 @@ public:
     resize(n, c);
   }
 
-  buffer_vector(std::initializer_list<T> const & initList) : m_size(0)
+  buffer_vector(std::initializer_list<T> init) : m_size(0)
   {
-    assign(initList.begin(), initList.end());
+    assign(std::make_move_iterator(init.begin()), std::make_move_iterator(init.end()));
   }
 
   template <typename TIt>
diff --git a/base/small_map.hpp b/base/small_map.hpp
new file mode 100644
index 0000000000..12f8068cfe
--- /dev/null
+++ b/base/small_map.hpp
@@ -0,0 +1,94 @@
+#pragma once
+
+#include "assert.hpp"
+
+#include <vector>
+
+namespace base
+{
+
+/// Consider using as a replacement of unordered_map (map) when:
+/// - very small amount of elements (<8)
+template <class Key, class Value> class SmallMapBase
+{
+public:
+  using ValueType = std::pair<Key, Value>;
+
+  SmallMapBase() = default;
+  SmallMapBase(std::initializer_list<ValueType> init) : m_map(std::move(init)) {}
+  template <class Iter> SmallMapBase(Iter beg, Iter end) : m_map(beg, end) {}
+
+  bool operator==(SmallMapBase const & rhs) const { return m_map == rhs.m_map; }
+
+  void Reserve(size_t count) { m_map.reserve(count); }
+  void Insert(Key k, Value v) { m_map.emplace_back(std::move(k), std::move(v)); }
+
+  Value const * Find(Key const & k) const
+  {
+    for (auto const & e : m_map)
+    {
+      if (e.first == k)
+        return &e.second;
+    }
+    return nullptr;
+  }
+
+protected:
+  /// @todo buffer_vector is not suitable now, because Key/Value is not default constructible.
+  std::vector<ValueType> m_map;
+};
+
+/// Consider using as a replacement of unordered_map (map) when:
+/// - initialize and don't modify
+/// - relatively small amount of elements (8-128)
+template <class Key, class Value> class SmallMap : public SmallMapBase<Key, Value>
+{
+  using BaseT = SmallMapBase<Key, Value>;
+
+public:
+  using ValueType = typename BaseT::ValueType;
+
+  SmallMap() = default;
+  SmallMap(std::initializer_list<ValueType> init)
+    : BaseT(std::move(init))
+  {
+    FinishBuilding();
+  }
+  template <class Iter> SmallMap(Iter beg, Iter end)
+    : BaseT(beg, end)
+  {
+    FinishBuilding();
+  }
+
+  void FinishBuilding()
+  {
+    auto & theMap = this->m_map;
+    std::sort(theMap.begin(), theMap.end(), [](ValueType const & l, ValueType const & r)
+    {
+      return l.first < r.first;
+    });
+  }
+
+  Value const * Find(Key const & k) const
+  {
+    auto const & theMap = this->m_map;
+    auto const it = std::lower_bound(theMap.cbegin(), theMap.cend(), k,
+                                     [](ValueType const & l, Key const & r)
+    {
+      return l.first < r;
+    });
+
+    if (it != theMap.cend() && it->first == k)
+      return &(it->second);
+    return nullptr;
+  }
+
+  Value const & Get(Key const & k) const
+  {
+    Value const * v = Find(k);
+    ASSERT(v, ());
+    return *v;
+  }
+};
+
+} // namespace base