drifty/comaps
1
0
Fork 0
mirror of https://codeberg.org/comaps/comaps synced 2025-12-23 06:33:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

[core] Replace SmallMap

Browse Source 
Signed-off-by: x7z4w <x7z4w@noreply.codeberg.org>
This commit is contained in:
x7z4w
2025-11-24 17:34:56 +00:00
committed by Konstantin Pastbin
parent 969e1ef2da
commit 882dccb87d
25 changed files with 162 additions and 742 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
generator/maxspeeds_builder.cpp
View File

@@ -421,9 +421,7 @@ public:
auto const s = m_avgSpeeds[ind][type].m_speed;
if (s > 0)
return s;
auto const * p = kHighwayBasedSpeeds.Find(type);
CHECK(p, ());
return p->GetSpeed(inCity).m_weight;
return kHighwayBasedSpeeds.at(type).GetSpeed(inCity).m_weight;
};
// These speeds: Primary, Secondary, Tertiary, Residential have the biggest routing quality impact.

2
libs/base/CMakeLists.txt
View File

@@ -65,8 +65,6 @@ 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
stats.hpp

1
libs/base/base_tests/CMakeLists.txt
View File

@@ -33,7 +33,6 @@ set(SRC
regexp_test.cpp
rolling_hash_test.cpp
scope_guard_test.cpp
small_set_test.cpp
stl_helpers_tests.cpp
string_utils_test.cpp
suffix_array_tests.cpp

270
libs/base/base_tests/small_set_test.cpp
View File

@@ -1,270 +0,0 @@
#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 "3party/ankerl/unordered_dense.h"
namespace small_set_test
{
using namespace base;
UNIT_TEST(SmallSet_Smoke)
{
SmallSet<300> set;
TEST_EQUAL(set.Size(), 0, ());
for (uint64_t i = 0; i < 300; ++i)
TEST(!set.Contains(i), ());
set.Insert(0);
TEST_EQUAL(set.Size(), 1, ());
TEST(set.Contains(0), ());
set.Insert(0);
TEST_EQUAL(set.Size(), 1, ());
TEST(set.Contains(0), ());
set.Insert(5);
TEST_EQUAL(set.Size(), 2, ());
TEST(set.Contains(0), ());
TEST(set.Contains(5), ());
set.Insert(64);
TEST_EQUAL(set.Size(), 3, ());
TEST(set.Contains(0), ());
TEST(set.Contains(5), ());
TEST(set.Contains(64), ());
{
auto cur = set.begin();
auto end = set.end();
for (uint64_t i : {0, 5, 64})
{
TEST(cur != end, ());
TEST_EQUAL(*cur, i, ());
++cur;
}
TEST(cur == end, ());
}
set.Remove(5);
TEST_EQUAL(set.Size(), 2, ());
TEST(set.Contains(0), ());
TEST(!set.Contains(5), ());
TEST(set.Contains(64), ());
set.Insert(297);
set.Insert(298);
set.Insert(299);
TEST_EQUAL(set.Size(), 5, ());
{
std::vector<uint64_t> const actual(set.begin(), set.end());
std::vector<uint64_t> const expected = {0, 64, 297, 298, 299};
TEST_EQUAL(actual, expected, ());
}
TEST_EQUAL(set.Size(), std::distance(set.begin(), set.end()), ());
}
bool BenchmarkTimeLessOrNear(uint64_t l, uint64_t r, double relativeTolerance)
{
return (l < r) || ((l - r) / static_cast<double>(l) < relativeTolerance);
}
#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.
ankerl::unordered_dense::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::HighResTimer timer;
for (auto i : indices)
sum1 += (uMap.find(i) != uMap.end() ? 1 : 0);
t1 = timer.ElapsedMilliseconds();
}
// 4. Run SmallMap.
{
base::HighResTimer timer;
for (auto i : indices)
sum2 += (sMap.Find(i) ? 1 : 0);
t2 = timer.ElapsedMilliseconds();
}
TEST_EQUAL(sum1, sum2, ());
// At this moment, we have rare t2 > t1 on Linux CI.
TEST(BenchmarkTimeLessOrNear(t2, t1, 0.3), (t2, t1));
LOG(LINFO, ("unordered_map time =", t1, "SmallMap time =", t2));
}
UNIT_TEST(SmallMap_Benchmark2)
{
using namespace std;
uint32_t i = 0;
// Dataset is similar to routing::VehicleModelFactory.
ankerl::unordered_dense::map<string, 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::HighResTimer 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::HighResTimer 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));
}
// Small 4 elements sample doesn't work for new (gcc11+, clang14+) toolchain.
/*
UNIT_TEST(SmallMap_Benchmark3)
{
// Dataset is similar to routing::VehicleModel.m_surfaceFactors.
ankerl::unordered_dense::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::HighResTimer timer;
for (auto i : indices)
sum1 += uMap.find(keys[i])->second;
t1 = timer.ElapsedMilliseconds();
}
// 4. Run SmallMap.
{
base::HighResTimer timer;
for (auto i : indices)
sum2 += *sMap.Find(keys[i]);
t2 = timer.ElapsedMilliseconds();
}
// 5. Run SmallMapBase.
{
base::HighResTimer 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(BenchmarkTimeLessOrNear(t3, t2, 0.05), (t3, t2));
LOG(LINFO, ("unordered_map time =", t1, "SmallMap time =", t2, "SmallMapBase time =", t3));
}
*/
#endif
} // namespace small_set_test

100
libs/base/small_map.hpp
View File

@@ -1,100 +0,0 @@
#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;
}
size_t size() const { return m_map.size(); }
auto begin() const { return m_map.begin(); }
auto end() const { return m_map.end(); }
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;
}
void Replace(Key const & k, Value v)
{
auto & theMap = this->m_map;
auto it = std::lower_bound(theMap.begin(), theMap.end(), k,
[](ValueType const & l, Key const & r) { return l.first < r; });
ASSERT(it != theMap.end() && it->first == k, ());
it->second = std::move(v);
}
Value const & Get(Key const & k) const
{
Value const * v = Find(k);
ASSERT(v, ());
return *v;
}
};
} // namespace base

220
libs/base/small_set.hpp
View File

@@ -1,220 +0,0 @@
#pragma once
#include "base/assert.hpp"
#include "base/bits.hpp"
#include <cstdint>
#include <iterator>
#include <sstream>
#include <string>
namespace base
{
// A set of nonnegative integers less than |UpperBound|.
//
// Requires UpperBound + O(1) bits of memory. All operations except
// Clear() and iteration are O(1). Clear() and iteration require
// O(UpperBound) steps.
//
// *NOTE* This class *IS NOT* thread safe.
template <uint64_t UpperBound>
class SmallSet
{
public:
static uint64_t constexpr kNumBlocks = (UpperBound + 63) / 64;
static_assert(kNumBlocks > 0);
class Iterator
{
public:
using difference_type = uint64_t;
using value_type = uint64_t;
using pointer = void;
using reference = uint64_t;
using iterator_category = std::forward_iterator_tag;
Iterator(uint64_t const * blocks, uint64_t current_block_index)
: m_blocks(blocks)
, m_current_block_index(current_block_index)
, m_current_block(0)
{
ASSERT_LESS_OR_EQUAL(current_block_index, kNumBlocks, ());
if (current_block_index < kNumBlocks)
m_current_block = m_blocks[current_block_index];
SkipZeroes();
}
bool operator==(Iterator const & rhs) const
{
return m_blocks == rhs.m_blocks && m_current_block_index == rhs.m_current_block_index &&
m_current_block == rhs.m_current_block;
}
bool operator!=(Iterator const & rhs) const { return !(*this == rhs); }
uint64_t operator*() const
{
ASSERT_NOT_EQUAL(m_current_block, 0, ());
auto const bit = m_current_block & -m_current_block;
return bits::FloorLog(bit) + m_current_block_index * 64;
}
Iterator const & operator++()
{
ASSERT(m_current_block_index < kNumBlocks, ());
ASSERT_NOT_EQUAL(m_current_block, 0, ());
m_current_block = m_current_block & (m_current_block - 1);
SkipZeroes();
return *this;
}
private:
void SkipZeroes()
{
ASSERT_LESS_OR_EQUAL(m_current_block_index, kNumBlocks, ());
if (m_current_block != 0 || m_current_block_index == kNumBlocks)
return;
do
++m_current_block_index;
while (m_current_block_index < kNumBlocks && m_blocks[m_current_block_index] == 0);
if (m_current_block_index < kNumBlocks)
m_current_block = m_blocks[m_current_block_index];
else
m_current_block = 0;
}
uint64_t const * m_blocks;
uint64_t m_current_block_index;
uint64_t m_current_block;
};
#define DEFINE_BLOCK_OFFSET(value) \
uint64_t const block = value / 64; \
uint64_t const offset = value % 64
// This invalidates all iterators except end().
void Insert(uint64_t value)
{
ASSERT_LESS(value, UpperBound, ());
DEFINE_BLOCK_OFFSET(value);
auto const bit = kOne << offset;
m_size += (m_blocks[block] & bit) == 0;
m_blocks[block] |= bit;
}
// This invalidates all iterators except end().
void Remove(uint64_t value)
{
ASSERT_LESS(value, UpperBound, ());
DEFINE_BLOCK_OFFSET(value);
auto const bit = kOne << offset;
m_size -= (m_blocks[block] & bit) != 0;
m_blocks[block] &= ~bit;
}
bool Contains(uint64_t value) const
{
ASSERT_LESS(value, UpperBound, ());
DEFINE_BLOCK_OFFSET(value);
return m_blocks[block] & (kOne << offset);
}
#undef DEFINE_BLOCK_OFFSET
uint64_t Size() const { return m_size; }
// This invalidates all iterators except end().
void Clear()
{
std::fill(std::begin(m_blocks), std::end(m_blocks), static_cast<uint64_t>(0));
m_size = 0;
}
Iterator begin() const { return Iterator(m_blocks, 0); }
Iterator cbegin() const { return Iterator(m_blocks, 0); }
Iterator end() const { return Iterator(m_blocks, kNumBlocks); }
Iterator cend() const { return Iterator(m_blocks, kNumBlocks); }
private:
static uint64_t constexpr kOne = 1;
uint64_t m_blocks[kNumBlocks] = {};
uint64_t m_size = 0;
};
// static
template <uint64_t UpperBound>
uint64_t constexpr SmallSet<UpperBound>::kNumBlocks;
// static
template <uint64_t UpperBound>
uint64_t constexpr SmallSet<UpperBound>::kOne;
template <uint64_t UpperBound>
std::string DebugPrint(SmallSet<UpperBound> const & set)
{
std::ostringstream os;
os << "SmallSet<" << UpperBound << "> [" << set.Size() << ": ";
for (auto const & v : set)
os << v << " ";
os << "]";
return os.str();
}
// This is a delegate for SmallSet<>, that checks the validity of
// argument in Insert(), Remove() and Contains() methods and does
// nothing when the argument is not valid.
template <uint64_t UpperBound>
class SafeSmallSet
{
public:
using Set = SmallSet<UpperBound>;
using Iterator = typename Set::Iterator;
void Insert(uint64_t value)
{
if (IsValid(value))
m_set.Insert(value);
}
void Remove(uint64_t value)
{
if (IsValid(value))
m_set.Remove(value);
}
bool Contains(uint64_t value) const { return IsValid(value) && m_set.Contains(value); }
uint64_t Size() const { return m_set.Size(); }
void Clear() { m_set.Clear(); }
Iterator begin() const { return m_set.begin(); }
Iterator cbegin() const { return m_set.cbegin(); }
Iterator end() const { return m_set.end(); }
Iterator cend() const { return m_set.cend(); }
private:
bool IsValid(uint64_t value) const { return value < UpperBound; }
Set m_set;
};
template <uint64_t UpperBound>
std::string DebugPrint(SafeSmallSet<UpperBound> const & set)
{
std::ostringstream os;
os << "SafeSmallSet<" << UpperBound << "> [" << set.Size() << ": ";
for (auto const v : set)
os << v << " ";
os << "]";
return os.str();
}
} // namespace base

17
libs/drape_frontend/apply_feature_functors.cpp
View File

@@ -28,7 +28,6 @@
#include "drape/utils/projection.hpp"
#include "base/logging.hpp"
#include "base/small_map.hpp"
#include "base/stl_helpers.hpp"
#include <algorithm>
@@ -37,6 +36,8 @@
#include <map>
#include <mutex>
#include "3party/skarupke/flat_hash_map.hpp"
namespace df
{
dp::Color ToDrapeColor(uint32_t src)
@@ -271,7 +272,7 @@ dp::Color GetRoadShieldColor(dp::Color const & baseColor, ftypes::RoadShield con
{
using ftypes::RoadShieldType;
static base::SmallMapBase<ftypes::RoadShieldType, df::ColorConstant> kColors = {
static ska::flat_hash_map<RoadShieldType, df::ColorConstant> const kColors = {
{RoadShieldType::Generic_White, kRoadShieldWhiteBackgroundColor},
{RoadShieldType::Generic_Green, kRoadShieldGreenBackgroundColor},
{RoadShieldType::Generic_Blue, kRoadShieldBlueBackgroundColor},
@@ -294,8 +295,9 @@ dp::Color GetRoadShieldColor(dp::Color const & baseColor, ftypes::RoadShield con
{RoadShieldType::Generic_Pill_Orange_Bordered, kRoadShieldOrangeBackgroundColor},
{RoadShieldType::UK_Highway, kRoadShieldGreenBackgroundColor}};
if (auto const * cl = kColors.Find(shield.m_type); cl)
return df::GetColorConstant(*cl);
auto const it = kColors.find(shield.m_type);
if (it != kColors.cend())
return df::GetColorConstant(it->second);
return baseColor;
}
@@ -304,7 +306,7 @@ dp::Color GetRoadShieldTextColor(dp::Color const & baseColor, ftypes::RoadShield
{
using ftypes::RoadShieldType;
static base::SmallMapBase<ftypes::RoadShieldType, df::ColorConstant> kColors = {
static ska::flat_hash_map<RoadShieldType, df::ColorConstant> const kColors = {
{RoadShieldType::Generic_White, kRoadShieldBlackTextColor},
{RoadShieldType::Generic_Green, kRoadShieldWhiteTextColor},
{RoadShieldType::Generic_Blue, kRoadShieldWhiteTextColor},
@@ -336,8 +338,9 @@ dp::Color GetRoadShieldTextColor(dp::Color const & baseColor, ftypes::RoadShield
{RoadShieldType::Hungary_Green, kRoadShieldWhiteTextColor},
{RoadShieldType::Hungary_Blue, kRoadShieldWhiteTextColor}};
if (auto const * cl = kColors.Find(shield.m_type); cl)
return df::GetColorConstant(*cl);
auto const it = kColors.find(shield.m_type);
if (it != kColors.cend())
return df::GetColorConstant(it->second);
return baseColor;
}

5
libs/editor/new_feature_categories.cpp
View File

@@ -20,6 +20,7 @@ NewFeatureCategories::NewFeatureCategories(editor::EditorConfig const & config)
}
m_types.emplace_back(clType);
}
m_addedLangs.reserve(CategoriesHolder::kLocaleMapping.size() + 1);
}
NewFeatureCategories::NewFeatureCategories(NewFeatureCategories && other) noexcept
@@ -37,14 +38,14 @@ void NewFeatureCategories::AddLanguage(std::string lang)
lang = "en";
langCode = CategoriesHolder::kEnglishCode;
}
if (m_addedLangs.Contains(langCode))
if (m_addedLangs.contains(langCode))
return;
auto const & c = classif();
for (auto const & type : m_types)
m_index.AddCategoryByTypeAndLang(c.GetTypeByReadableObjectName(type), langCode);
m_addedLangs.Insert(langCode);
m_addedLangs.insert(langCode);
}
NewFeatureCategories::TypeNames NewFeatureCategories::Search(std::string const & query) const

5
libs/editor/new_feature_categories.hpp
View File

@@ -6,11 +6,12 @@
#include "indexer/categories_index.hpp"
#include "base/macros.hpp"
#include "base/small_set.hpp"
#include <string>
#include <vector>
#include "3party/ankerl/unordered_dense.h"
namespace osm
{
// This class holds an index of categories that can be set for a newly added feature.
@@ -43,7 +44,7 @@ public:
TypeNames const & GetAllCreatableTypeNames() const { return m_types; }
private:
using Langs = base::SmallSet<CategoriesHolder::kLocaleMapping.size() + 1>;
using Langs = ankerl::unordered_dense::set<int8_t>;
indexer::CategoriesIndex m_index;
Langs m_addedLangs;

9
libs/indexer/ftypes_matcher.cpp
View File

@@ -339,20 +339,21 @@ IsWayChecker::IsWayChecker()
{"unclassified", Minors},
};
m_ranks.Reserve(std::size(types));
m_ranks.reserve(std::size(types));
for (auto const & e : types)
{
uint32_t const type = c.GetTypeByPath({"highway", e.first});
m_types.push_back(type);
m_ranks.Insert(type, e.second);
m_ranks.insert({type, e.second});
}
}
IsWayChecker::SearchRank IsWayChecker::GetSearchRank(uint32_t type) const
{
ftype::TruncValue(type, 2);
if (auto const * res = m_ranks.Find(type))
return *res;
auto const it = m_ranks.find(type);
if (it != m_ranks.cend())
return it->second;
return Default;
}

7
libs/indexer/ftypes_matcher.hpp
View File

@@ -3,13 +3,16 @@
#include "indexer/feature_data.hpp"
#include "indexer/feature_utils.hpp"
#include "base/small_map.hpp"
#include "base/stl_helpers.hpp"
#include <boost/container_hash/hash.hpp>
#include <functional>
#include <string>
#include <vector>
#include "3party/skarupke/flat_hash_map.hpp"
#define DECLARE_CHECKER_INSTANCE(CheckerType) \
static CheckerType const & Instance() \
{ \
@@ -193,7 +196,7 @@ public:
SearchRank GetSearchRank(uint32_t type) const;
private:
base::SmallMap<uint32_t, SearchRank> m_ranks;
ska::flat_hash_map<uint32_t, SearchRank, boost::hash<uint32_t>> m_ranks;
};
class IsStreetOrSquareChecker : public BaseChecker

11
libs/routing/routing_options.cpp
View File

@@ -75,19 +75,18 @@ RoutingOptionsClassifier::RoutingOptionsClassifier()
{{"psurface", "paved_good"}, RoutingOptions::Road::Paved},
{{"psurface", "paved_bad"}, RoutingOptions::Road::Paved}};
m_data.Reserve(std::size(types));
m_data.reserve(std::size(types));
for (auto const & data : types)
m_data.Insert(c.GetTypeByPath(data.first), data.second);
m_data.FinishBuilding();
m_data.insert({c.GetTypeByPath(data.first), data.second});
}
optional<RoutingOptions::Road> RoutingOptionsClassifier::Get(uint32_t type) const
{
ftype::TruncValue(type, 2); // in case of highway-motorway-bridge
auto const * res = m_data.Find(type);
if (res)
return *res;
auto const it = m_data.find(type);
if (it != m_data.cend())
return it->second;
return {};
}

6
libs/routing/routing_options.hpp
View File

@@ -1,11 +1,13 @@
#pragma once
#include "base/small_map.hpp"
#include <boost/container_hash/hash.hpp>
#include <optional>
#include <string>
#include <type_traits>
#include "3party/skarupke/flat_hash_map.hpp"
namespace routing
{
class RoutingOptions
@@ -51,7 +53,7 @@ public:
static RoutingOptionsClassifier const & Instance();
private:
base::SmallMap<uint32_t, RoutingOptions::Road> m_data;
ska::flat_hash_map<uint32_t, RoutingOptions::Road, boost::hash<uint32_t>> m_data;
};
RoutingOptions::Road ChooseMainRoutingOptionRoad(RoutingOptions options, bool isCarRouter);

77
libs/routing_common/bicycle_model.cpp
View File

@@ -108,7 +108,7 @@ VehicleModel::LimitsInitList NoTrunk()
HighwayBasedSpeeds NormalPedestrianSpeed()
{
HighwayBasedSpeeds res = kDefaultSpeeds;
res.Replace(HighwayType::HighwayPedestrian, InOutCitySpeedKMpH(kSpeedOnFootwayKMpH));
res[HighwayType::HighwayPedestrian] = InOutCitySpeedKMpH(kSpeedOnFootwayKMpH);
return res;
}
@@ -125,15 +125,15 @@ HighwayBasedSpeeds NormalPedestrianAndFootwaySpeed()
{
HighwayBasedSpeeds res = kDefaultSpeeds;
InOutCitySpeedKMpH const footSpeed(kSpeedOnFootwayKMpH);
res.Replace(HighwayType::HighwayPedestrian, footSpeed);
res.Replace(HighwayType::HighwayFootway, footSpeed);
res[HighwayType::HighwayPedestrian] = footSpeed;
res[HighwayType::HighwayFootway] = footSpeed;
return res;
}
HighwayBasedSpeeds DismountPathSpeed()
{
HighwayBasedSpeeds res = kDefaultSpeeds;
res.Replace(HighwayType::HighwayPath, InOutCitySpeedKMpH(kSpeedDismountKMpH));
res[HighwayType::HighwayPath] = InOutCitySpeedKMpH(kSpeedDismountKMpH);
return res;
}
@@ -143,15 +143,15 @@ HighwayBasedSpeeds PreferFootwaysToRoads()
// Decrease secondary/tertiary weight speed (-20% from default).
InOutCitySpeedKMpH roadSpeed = InOutCitySpeedKMpH(SpeedKMpH(11.0, 17.0), SpeedKMpH(16.0, 19.0));
res.Replace(HighwayType::HighwaySecondary, roadSpeed);
res.Replace(HighwayType::HighwaySecondaryLink, roadSpeed);
res.Replace(HighwayType::HighwayTertiary, roadSpeed);
res.Replace(HighwayType::HighwayTertiaryLink, roadSpeed);
res[HighwayType::HighwaySecondary] = roadSpeed;
res[HighwayType::HighwaySecondaryLink] = roadSpeed;
res[HighwayType::HighwayTertiary] = roadSpeed;
res[HighwayType::HighwayTertiaryLink] = roadSpeed;
// Increase footway speed to make bigger than other roads (+20% from default roads).
InOutCitySpeedKMpH footSpeed = InOutCitySpeedKMpH(SpeedKMpH(17.0, 12.0), SpeedKMpH(20.0, 15.0));
res.Replace(HighwayType::HighwayPedestrian, footSpeed);
res.Replace(HighwayType::HighwayFootway, footSpeed);
res[HighwayType::HighwayPedestrian] = footSpeed;
res[HighwayType::HighwayFootway] = footSpeed;
return res;
}
@@ -205,7 +205,7 @@ BicycleModel::BicycleModel(VehicleModel::LimitsInitList const & limits, HighwayB
m_onedirBicycleType = cl.GetTypeByPath({"hwtag", "onedir_bicycle"});
// Assign 90% of max cycleway speed for bicycle=yes to keep choosing most preferred cycleway.
auto const yesSpeed = kDefaultSpeeds.Get(HighwayType::HighwayCycleway).m_inCity * 0.9;
auto const yesSpeed = kDefaultSpeeds.at(HighwayType::HighwayCycleway).m_inCity * 0.9;
AddAdditionalRoadTypes(cl, {{std::move(hwtagYesBicycle), InOutCitySpeedKMpH(yesSpeed)}});
// Update max speed with possible ferry transfer and bicycle speed downhill.
@@ -265,40 +265,39 @@ BicycleModelFactory::BicycleModelFactory(CountryParentNameGetterFn const & count
: VehicleModelFactory(countryParentNameGetterFn)
{
using namespace bicycle_model;
using std::make_shared;
// Names must be the same with country names from countries.txt
m_models[""] = make_shared<BicycleModel>(kDefaultOptions);
m_models[""] = std::make_shared<BicycleModel>(kDefaultOptions);
m_models["Australia"] = make_shared<BicycleModel>(AllAllowed(), NormalPedestrianAndFootwaySpeed());
m_models["Austria"] = make_shared<BicycleModel>(NoTrunk(), DismountPathSpeed());
m_models["Australia"] = std::make_shared<BicycleModel>(AllAllowed(), NormalPedestrianAndFootwaySpeed());
m_models["Austria"] = std::make_shared<BicycleModel>(NoTrunk(), DismountPathSpeed());
// Belarus law demands to use footways for bicycles where possible.
m_models["Belarus"] = make_shared<BicycleModel>(kDefaultOptions, PreferFootwaysToRoads());
m_models["Belgium"] = make_shared<BicycleModel>(NoTrunk(), NormalPedestrianSpeed());
m_models["Brazil"] = make_shared<BicycleModel>(AllAllowed());
m_models["Denmark"] = make_shared<BicycleModel>(NoTrunk());
m_models["France"] = make_shared<BicycleModel>(NoTrunk(), NormalPedestrianSpeed());
m_models["Finland"] = make_shared<BicycleModel>(kDefaultOptions, NormalPedestrianSpeed());
m_models["Hungary"] = make_shared<BicycleModel>(NoTrunk());
m_models["Iceland"] = make_shared<BicycleModel>(AllAllowed(), NormalPedestrianAndFootwaySpeed());
m_models["Ireland"] = make_shared<BicycleModel>(AllAllowed());
m_models["Italy"] = make_shared<BicycleModel>(kDefaultOptions, NormalPedestrianSpeed());
m_models["Netherlands"] = make_shared<BicycleModel>(NoTrunk());
m_models["Norway"] = make_shared<BicycleModel>(AllAllowed(), NormalPedestrianAndFootwaySpeed());
m_models["Oman"] = make_shared<BicycleModel>(AllAllowed());
m_models["Philippines"] = make_shared<BicycleModel>(AllAllowed(), NormalPedestrianSpeed());
m_models["Poland"] = make_shared<BicycleModel>(NoTrunk());
m_models["Romania"] = make_shared<BicycleModel>(AllAllowed());
m_models["Belarus"] = std::make_shared<BicycleModel>(kDefaultOptions, PreferFootwaysToRoads());
m_models["Belgium"] = std::make_shared<BicycleModel>(NoTrunk(), NormalPedestrianSpeed());
m_models["Brazil"] = std::make_shared<BicycleModel>(AllAllowed());
m_models["Denmark"] = std::make_shared<BicycleModel>(NoTrunk());
m_models["France"] = std::make_shared<BicycleModel>(NoTrunk(), NormalPedestrianSpeed());
m_models["Finland"] = std::make_shared<BicycleModel>(kDefaultOptions, NormalPedestrianSpeed());
m_models["Hungary"] = std::make_shared<BicycleModel>(NoTrunk());
m_models["Iceland"] = std::make_shared<BicycleModel>(AllAllowed(), NormalPedestrianAndFootwaySpeed());
m_models["Ireland"] = std::make_shared<BicycleModel>(AllAllowed());
m_models["Italy"] = std::make_shared<BicycleModel>(kDefaultOptions, NormalPedestrianSpeed());
m_models["Netherlands"] = std::make_shared<BicycleModel>(NoTrunk());
m_models["Norway"] = std::make_shared<BicycleModel>(AllAllowed(), NormalPedestrianAndFootwaySpeed());
m_models["Oman"] = std::make_shared<BicycleModel>(AllAllowed());
m_models["Philippines"] = std::make_shared<BicycleModel>(AllAllowed(), NormalPedestrianSpeed());
m_models["Poland"] = std::make_shared<BicycleModel>(NoTrunk());
m_models["Romania"] = std::make_shared<BicycleModel>(AllAllowed());
// Note. Despite the fact that according to
// https://wiki.openstreetmap.org/wiki/OSM_tags_for_routing/Access-Restrictions passing through service and
// living_street with a bicycle is prohibited it's allowed according to Russian traffic rules.
m_models["Russian Federation"] = make_shared<BicycleModel>(kDefaultOptions, NormalPedestrianAndFootwaySpeed());
m_models["Slovakia"] = make_shared<BicycleModel>(NoTrunk());
m_models["Spain"] = make_shared<BicycleModel>(NoTrunk(), NormalPedestrianSpeed());
m_models["Sweden"] = make_shared<BicycleModel>(kDefaultOptions, NormalPedestrianSpeed());
m_models["Switzerland"] = make_shared<BicycleModel>(NoTrunk(), NormalPedestrianAndFootwaySpeed());
m_models["Ukraine"] = make_shared<BicycleModel>(UkraineOptions());
m_models["United Kingdom"] = make_shared<BicycleModel>(AllAllowed());
m_models["United States of America"] = make_shared<BicycleModel>(AllAllowed(), NormalPedestrianSpeed());
m_models["Russian Federation"] = std::make_shared<BicycleModel>(kDefaultOptions, NormalPedestrianAndFootwaySpeed());
m_models["Slovakia"] = std::make_shared<BicycleModel>(NoTrunk());
m_models["Spain"] = std::make_shared<BicycleModel>(NoTrunk(), NormalPedestrianSpeed());
m_models["Sweden"] = std::make_shared<BicycleModel>(kDefaultOptions, NormalPedestrianSpeed());
m_models["Switzerland"] = std::make_shared<BicycleModel>(NoTrunk(), NormalPedestrianAndFootwaySpeed());
m_models["Ukraine"] = std::make_shared<BicycleModel>(UkraineOptions());
m_models["United Kingdom"] = std::make_shared<BicycleModel>(AllAllowed());
m_models["United States of America"] = std::make_shared<BicycleModel>(AllAllowed(), NormalPedestrianSpeed());
}
} // namespace routing

2
libs/routing_common/car_model.cpp
View File

@@ -97,7 +97,7 @@ CarModel::CarModel(VehicleModel::LimitsInitList const & roadLimits)
m_yesType = cl.GetTypeByPath(hwtagYesCar);
// Set small track speed if highway is not in kHighwayBasedSpeeds (path, pedestrian), but marked as yescar.
AddAdditionalRoadTypes(cl, {{std::move(hwtagYesCar), kHighwayBasedSpeeds.Get(HighwayType::HighwayTrack)}});
AddAdditionalRoadTypes(cl, {{std::move(hwtagYesCar), kHighwayBasedSpeeds.at(HighwayType::HighwayTrack)}});
// Set max possible (reasonable) car speed. See EdgeEstimator::CalcHeuristic.
SpeedKMpH constexpr kMaxCarSpeedKMpH(200.0);

65
libs/routing_common/pedestrian_model.cpp
View File

@@ -125,8 +125,8 @@ HighwayBasedSpeeds IncreasePrimary()
{
/// @todo Probably, should make Primary = Secondary = 4.
HighwayBasedSpeeds res = pedestrian_model::kDefaultSpeeds;
res.Replace(HighwayType::HighwayPrimary, InOutCitySpeedKMpH(SpeedKMpH(3.0, 5.0)));
res.Replace(HighwayType::HighwayPrimaryLink, InOutCitySpeedKMpH(SpeedKMpH(3.0, 5.0)));
res[HighwayType::HighwayPrimary] = InOutCitySpeedKMpH(SpeedKMpH(3.0, 5.0));
res[HighwayType::HighwayPrimaryLink] = InOutCitySpeedKMpH(SpeedKMpH(3.0, 5.0));
return res;
}
@@ -163,7 +163,7 @@ PedestrianModel::PedestrianModel(VehicleModel::LimitsInitList const & limits, Hi
m_noType = cl.GetTypeByPath({"hwtag", "nofoot"});
m_yesType = cl.GetTypeByPath(hwtagYesFoot);
AddAdditionalRoadTypes(cl, {{std::move(hwtagYesFoot), kDefaultSpeeds.Get(HighwayType::HighwayLivingStreet)}});
AddAdditionalRoadTypes(cl, {{std::move(hwtagYesFoot), kDefaultSpeeds.at(HighwayType::HighwayLivingStreet)}});
// Update max pedestrian speed with possible ferry transfer. See EdgeEstimator::CalcHeuristic.
SpeedKMpH constexpr kMaxPedestrianSpeedKMpH(60.0);
@@ -194,38 +194,37 @@ PedestrianModelFactory::PedestrianModelFactory(CountryParentNameGetterFn const &
: VehicleModelFactory(countryParentNameGetterFn)
{
using namespace pedestrian_model;
using std::make_shared;
// Names must be the same with country names from countries.txt
m_models[""] = make_shared<PedestrianModel>(kDefaultOptions);
m_models[""] = std::make_shared<PedestrianModel>(kDefaultOptions);
m_models["Australia"] = make_shared<PedestrianModel>(AllAllowed());
m_models["Austria"] = make_shared<PedestrianModel>(NoTrunk());
m_models["Belarus"] = make_shared<PedestrianModel>(YesCycleway());
m_models["Belgium"] = make_shared<PedestrianModel>(YesCycleway(YesBridleway(NoTrunk())));
m_models["Brazil"] = make_shared<PedestrianModel>(YesBridleway());
m_models["Denmark"] = make_shared<PedestrianModel>(YesCycleway(NoTrunk()));
m_models["France"] = make_shared<PedestrianModel>(NoTrunk());
m_models["Finland"] = make_shared<PedestrianModel>(YesCycleway());
m_models["Georgia"] = make_shared<PedestrianModel>(AllAllowed(), IncreasePrimary());
m_models["Greece"] = make_shared<PedestrianModel>(YesCycleway(YesBridleway(NoTrunk())));
m_models["Hungary"] = make_shared<PedestrianModel>(NoTrunk());
m_models["Iceland"] = make_shared<PedestrianModel>(AllAllowed());
m_models["Ireland"] = make_shared<PedestrianModel>(AllAllowed());
m_models["Netherlands"] = make_shared<PedestrianModel>(YesCycleway(NoTrunk()));
m_models["Norway"] = make_shared<PedestrianModel>(AllAllowed());
m_models["Oman"] = make_shared<PedestrianModel>(AllAllowed());
m_models["Philippines"] = make_shared<PedestrianModel>(AllAllowed());
m_models["Poland"] = make_shared<PedestrianModel>(YesBridleway(NoTrunk()));
m_models["Romania"] = make_shared<PedestrianModel>(YesBridleway());
m_models["Russian Federation"] = make_shared<PedestrianModel>(YesCycleway());
m_models["Slovakia"] = make_shared<PedestrianModel>(NoTrunk());
m_models["Spain"] = make_shared<PedestrianModel>(NoTrunk());
m_models["Sweden"] = make_shared<PedestrianModel>(AllAllowed());
m_models["Switzerland"] = make_shared<PedestrianModel>(NoTrunk());
m_models["Turkey"] = make_shared<PedestrianModel>(AllAllowed(), IncreasePrimary());
m_models["Ukraine"] = make_shared<PedestrianModel>(NoTrunk());
m_models["United Kingdom"] = make_shared<PedestrianModel>(AllAllowed());
m_models["United States of America"] = make_shared<PedestrianModel>(AllAllowed());
m_models["Australia"] = std::make_shared<PedestrianModel>(AllAllowed());
m_models["Austria"] = std::make_shared<PedestrianModel>(NoTrunk());
m_models["Belarus"] = std::make_shared<PedestrianModel>(YesCycleway());
m_models["Belgium"] = std::make_shared<PedestrianModel>(YesCycleway(YesBridleway(NoTrunk())));
m_models["Brazil"] = std::make_shared<PedestrianModel>(YesBridleway());
m_models["Denmark"] = std::make_shared<PedestrianModel>(YesCycleway(NoTrunk()));
m_models["France"] = std::make_shared<PedestrianModel>(NoTrunk());
m_models["Finland"] = std::make_shared<PedestrianModel>(YesCycleway());
m_models["Georgia"] = std::make_shared<PedestrianModel>(AllAllowed(), IncreasePrimary());
m_models["Greece"] = std::make_shared<PedestrianModel>(YesCycleway(YesBridleway(NoTrunk())));
m_models["Hungary"] = std::make_shared<PedestrianModel>(NoTrunk());
m_models["Iceland"] = std::make_shared<PedestrianModel>(AllAllowed());
m_models["Ireland"] = std::make_shared<PedestrianModel>(AllAllowed());
m_models["Netherlands"] = std::make_shared<PedestrianModel>(YesCycleway(NoTrunk()));
m_models["Norway"] = std::make_shared<PedestrianModel>(AllAllowed());
m_models["Oman"] = std::make_shared<PedestrianModel>(AllAllowed());
m_models["Philippines"] = std::make_shared<PedestrianModel>(AllAllowed());
m_models["Poland"] = std::make_shared<PedestrianModel>(YesBridleway(NoTrunk()));
m_models["Romania"] = std::make_shared<PedestrianModel>(YesBridleway());
m_models["Russian Federation"] = std::make_shared<PedestrianModel>(YesCycleway());
m_models["Slovakia"] = std::make_shared<PedestrianModel>(NoTrunk());
m_models["Spain"] = std::make_shared<PedestrianModel>(NoTrunk());
m_models["Sweden"] = std::make_shared<PedestrianModel>(AllAllowed());
m_models["Switzerland"] = std::make_shared<PedestrianModel>(NoTrunk());
m_models["Turkey"] = std::make_shared<PedestrianModel>(AllAllowed(), IncreasePrimary());
m_models["Ukraine"] = std::make_shared<PedestrianModel>(NoTrunk());
m_models["United Kingdom"] = std::make_shared<PedestrianModel>(AllAllowed());
m_models["United States of America"] = std::make_shared<PedestrianModel>(AllAllowed());
}
} // namespace routing

56
libs/routing_common/vehicle_model.cpp
View File

@@ -33,19 +33,18 @@ VehicleModel::VehicleModel(Classificator const & classif, LimitsInitList const &
: m_highwayBasedInfo(info)
, m_onewayType(ftypes::IsOneWayChecker::Instance().GetType())
{
m_roadTypes.Reserve(featureTypeLimits.size());
m_roadTypes.reserve(featureTypeLimits.size());
for (auto const & v : featureTypeLimits)
{
auto const * speed = info.m_speeds.Find(v.m_type);
ASSERT(speed, ("Can't found speed for", v.m_type));
auto const it = info.m_speeds.find(v.m_type);
ASSERT_EQUAL(it, info.m_speeds.cend(), ("Can't found speed for", v.m_type));
m_maxModelSpeed = Max(m_maxModelSpeed, *speed);
m_maxModelSpeed = Max(m_maxModelSpeed, it->second);
m_roadTypes.Insert(classif.GetTypeForIndex(static_cast<uint32_t>(v.m_type)), v.m_isPassThroughAllowed);
m_roadTypes.insert({classif.GetTypeForIndex(static_cast<uint32_t>(v.m_type)), v.m_isPassThroughAllowed});
}
m_roadTypes.FinishBuilding();
m_surfaceFactors.Reserve(featureTypeSurface.size());
m_surfaceFactors.reserve(featureTypeSurface.size());
for (auto const & v : featureTypeSurface)
{
auto const & speedFactor = v.m_factor;
@@ -53,7 +52,7 @@ VehicleModel::VehicleModel(Classificator const & classif, LimitsInitList const &
ASSERT_LESS_OR_EQUAL(speedFactor.m_eta, 1.0, ());
ASSERT_GREATER(speedFactor.m_weight, 0.0, ());
ASSERT_GREATER(speedFactor.m_eta, 0.0, ());
m_surfaceFactors.Insert(classif.GetTypeByPath(v.m_type), speedFactor);
m_surfaceFactors.insert({classif.GetTypeByPath(v.m_type), speedFactor});
if (v.m_type[1] == "paved_bad")
m_minSurfaceFactorForMaxspeed = speedFactor;
@@ -65,9 +64,9 @@ void VehicleModel::AddAdditionalRoadTypes(Classificator const & classif, Additio
for (auto const & r : roads)
{
uint32_t const type = classif.GetTypeByPath(r.m_type);
if (m_roadTypes.Find(type) == nullptr)
if (m_roadTypes.find(type) == m_roadTypes.cend())
{
m_addRoadTypes.Insert(type, r.m_speed);
m_addRoadTypes.insert({type, r.m_speed});
m_maxModelSpeed = Max(m_maxModelSpeed, r.m_speed);
}
}
@@ -95,17 +94,16 @@ double VehicleModel::GetMaxWeightSpeed() const
optional<HighwayType> VehicleModel::GetHighwayType(uint32_t type) const
{
auto const * value = m_roadTypes.Find(type);
if (value)
if (m_roadTypes.find(type) != m_roadTypes.cend())
return static_cast<HighwayType>(classif().GetIndexForType(type));
return {};
}
void VehicleModel::GetSurfaceFactor(uint32_t type, SpeedFactor & factor) const
{
auto const * surface = m_surfaceFactors.Find(type);
if (surface)
factor = Pick<min>(factor, *surface);
auto const it = m_surfaceFactors.find(type);
if (it != m_surfaceFactors.cend())
factor = Pick<min>(factor, it->second);
ASSERT_LESS_OR_EQUAL(factor.m_weight, 1.0, ());
ASSERT_LESS_OR_EQUAL(factor.m_eta, 1.0, ());
@@ -115,12 +113,12 @@ void VehicleModel::GetSurfaceFactor(uint32_t type, SpeedFactor & factor) const
void VehicleModel::GetAdditionalRoadSpeed(uint32_t type, bool isCityRoad, optional<SpeedKMpH> & speed) const
{
auto const * s = m_addRoadTypes.Find(type);
if (s)
auto const it = m_addRoadTypes.find(type);
if (it != m_addRoadTypes.cend())
{
// Now we have only 1 additional type "yes" for all models.
ASSERT(!speed, ());
speed = isCityRoad ? s->m_inCity : s->m_outCity;
speed = isCityRoad ? it->second.m_inCity : it->second.m_outCity;
}
}
@@ -157,9 +155,9 @@ SpeedKMpH VehicleModel::GetTypeSpeedImpl(FeatureTypes const & types, SpeedParams
}
else
{
auto const * s = m_highwayBasedInfo.m_speeds.Find(*hwType);
ASSERT(s, ("Key:", *hwType, "is not found."));
speed = s->GetSpeed(isCityRoad);
auto const it = m_highwayBasedInfo.m_speeds.find(*hwType);
ASSERT_EQUAL(it, m_highwayBasedInfo.m_speeds.cend(), ("Key:", *hwType, "is not found."));
speed = it->second.GetSpeed(isCityRoad);
if (isCar)
{
@@ -183,9 +181,9 @@ SpeedKMpH VehicleModel::GetTypeSpeedImpl(FeatureTypes const & types, SpeedParams
}
auto const typeKey = *hwType;
auto const * factor = m_highwayBasedInfo.m_factors.Find(typeKey);
ASSERT(factor, ("Key:", typeKey, "is not found."));
auto const & f = factor->GetFactor(isCityRoad);
auto const it = m_highwayBasedInfo.m_factors.find(typeKey);
ASSERT_EQUAL(it, m_highwayBasedInfo.m_factors.cend(), ("Key:", typeKey, "is not found."));
auto const & f = it->second.GetFactor(isCityRoad);
speed.m_weight *= f.m_weight;
speed.m_eta *= f.m_eta;
}
@@ -218,12 +216,12 @@ bool VehicleModel::IsPassThroughAllowed(FeatureTypes const & types) const
ftype::TruncValue(t, 2);
// Additional types (like ferry) are always pass-through now.
if (m_addRoadTypes.Find(t))
if (m_addRoadTypes.find(t) != m_addRoadTypes.cend())
return true;
bool const * allow = m_roadTypes.Find(t);
if (allow && *allow)
return true;
auto const it = m_roadTypes.find(t);
if (it != m_roadTypes.cend())
return it->second;
}
return false;
@@ -232,7 +230,7 @@ bool VehicleModel::IsPassThroughAllowed(FeatureTypes const & types) const
bool VehicleModel::IsRoadType(uint32_t type) const
{
ftype::TruncValue(type, 2);
return m_addRoadTypes.Find(type) || m_roadTypes.Find(type);
return m_addRoadTypes.find(type) != m_addRoadTypes.cend() || m_roadTypes.find(type) != m_roadTypes.cend();
}
bool VehicleModel::IsRoadImpl(FeatureTypes const & types) const

13
libs/routing_common/vehicle_model.hpp
View File

@@ -4,7 +4,7 @@
#include "indexer/feature_data.hpp"
#include "base/small_map.hpp"
#include <boost/container_hash/hash.hpp>
#include <functional>
#include <initializer_list>
@@ -15,6 +15,7 @@
#include <vector>
#include "3party/ankerl/unordered_dense.h"
#include "3party/skarupke/flat_hash_map.hpp"
class Classificator;
class FeatureType;
@@ -60,8 +61,8 @@ enum class HighwayType : uint16_t
RouteShuttleTrain = 1054,
};
using HighwayBasedFactors = base::SmallMap<HighwayType, InOutCityFactor>;
using HighwayBasedSpeeds = base::SmallMap<HighwayType, InOutCitySpeedKMpH>;
using HighwayBasedFactors = ska::flat_hash_map<HighwayType, InOutCityFactor, boost::hash<HighwayType>>;
using HighwayBasedSpeeds = ska::flat_hash_map<HighwayType, InOutCitySpeedKMpH, boost::hash<HighwayType>>;
/// \brief Params for calculation of an approximate speed on a feature.
struct SpeedParams
@@ -330,13 +331,13 @@ private:
uint32_t m_onewayType;
// HW type -> allow pass through.
base::SmallMap<uint32_t, bool> m_roadTypes;
ska::flat_hash_map<uint32_t, bool, boost::hash<uint32_t>> m_roadTypes;
// Mapping surface types psurface={paved_good/paved_bad/unpaved_good/unpaved_bad} to surface speed factors.
base::SmallMapBase<uint32_t, SpeedFactor> m_surfaceFactors;
ska::flat_hash_map<uint32_t, SpeedFactor, boost::hash<uint32_t>> m_surfaceFactors;
SpeedFactor m_minSurfaceFactorForMaxspeed;
/// @todo Do we really need a separate map here or can merge with the m_roadTypes map?
base::SmallMapBase<uint32_t, InOutCitySpeedKMpH> m_addRoadTypes;
ska::flat_hash_map<uint32_t, InOutCitySpeedKMpH, boost::hash<uint32_t>> m_addRoadTypes;
};
class VehicleModelFactory : public VehicleModelFactoryInterface

5
libs/search/common.hpp
View File

@@ -3,9 +3,10 @@
#include "indexer/categories_holder.hpp"
#include "base/buffer_vector.hpp"
#include "base/small_set.hpp"
#include "base/string_utils.hpp"
#include "3party/ankerl/unordered_dense.h"
namespace search
{
// The prefix is stored separately.
@@ -13,7 +14,7 @@ namespace search
// the prefix and non-prefix tokens.
using QueryTokens = buffer_vector<strings::UniString, 32>;
using Locales = base::SafeSmallSet<CategoriesHolder::kLocaleMapping.size() + 1>;
using Locales = ankerl::unordered_dense::set<uint64_t>;
/// Upper bound for max count of tokens for indexing and scoring.
size_t constexpr kMaxNumTokens = 32;

8
libs/search/processor.cpp
View File

@@ -495,11 +495,11 @@ Locales Processor::GetCategoryLocales() const
Locales result;
// Prepare array of processing locales. English locale is always present for category matching.
result.Insert(static_cast<uint64_t>(enLocaleCode));
result.insert(static_cast<uint64_t>(enLocaleCode));
if (m_currentLocaleCode != -1)
result.Insert(static_cast<uint64_t>(m_currentLocaleCode));
result.insert(static_cast<uint64_t>(m_currentLocaleCode));
if (m_inputLocaleCode != -1)
result.Insert(static_cast<uint64_t>(m_inputLocaleCode));
result.insert(static_cast<uint64_t>(m_inputLocaleCode));
return result;
}
@@ -829,7 +829,7 @@ void Processor::InitParams(QueryParams & params) const
for (size_t i = 0; i < params.GetNumTokens(); ++i)
base::SortUnique(params.GetTypeIndices(i));
m_keywordsScorer.ForEachLanguage([&params](int8_t lang) { params.GetLangs().Insert(static_cast<uint64_t>(lang)); });
m_keywordsScorer.ForEachLanguage([&params](int8_t lang) { params.GetLangs().insert(static_cast<uint64_t>(lang)); });
}
void Processor::InitGeocoder(Geocoder::Params & geocoderParams, SearchParams const & searchParams)

4
libs/search/query_params.cpp
View File

@@ -1542,7 +1542,7 @@ void QueryParams::Clear()
m_hasPrefix = false;
m_isCommonToken.clear();
m_typeIndices.clear();
m_langs.Clear();
m_langs.clear();
}
bool QueryParams::IsCategorySynonym(size_t i) const
@@ -1637,7 +1637,7 @@ string DebugPrint(QueryParams const & params)
ostringstream os;
os << boolalpha << "QueryParams "
<< "{ m_tokens: " << ::DebugPrint(params.m_tokens) << ", m_prefixToken: " << DebugPrint(params.m_prefixToken)
<< ", m_typeIndices: " << ::DebugPrint(params.m_typeIndices) << ", m_langs: " << DebugPrint(params.m_langs)
<< ", m_typeIndices: " << ::DebugPrint(params.m_typeIndices) << ", m_langs: " << ::DebugPrint(params.m_langs)
<< ", m_isCommonToken: " << ::DebugPrint(params.m_isCommonToken) << " }";
return os.str();
}

12
libs/search/query_params.hpp
View File

@@ -3,13 +3,14 @@
#include "coding/string_utf8_multilang.hpp"
#include "base/assert.hpp"
#include "base/small_set.hpp"
#include "base/string_utils.hpp"
#include <algorithm>
#include <string>
#include <vector>
#include "3party/ankerl/unordered_dense.h"
namespace search
{
class TokenRange;
@@ -19,7 +20,7 @@ class QueryParams
public:
using String = strings::UniString;
using TypeIndices = std::vector<uint32_t>;
using Langs = base::SafeSmallSet<StringUtf8Multilang::kMaxSupportedLanguages>;
using Langs = ankerl::unordered_dense::set<int8_t>;
class Token
{
@@ -127,7 +128,7 @@ public:
Langs & GetLangs() { return m_langs; }
Langs const & GetLangs() const { return m_langs; }
bool LangExists(int8_t lang) const { return m_langs.Contains(lang); }
bool LangExists(int8_t lang) const { return m_langs.contains(lang); }
void SetCategorialRequest(bool isCategorial) { m_isCategorialRequest = isCategorial; }
bool IsCategorialRequest() const { return m_isCategorialRequest; }
@@ -147,5 +148,10 @@ private:
std::vector<TypeIndices> m_typeIndices;
Langs m_langs;
inline std::string DebugPrint(Langs const & v)
{
return DebugPrintSequence(v.cbegin(), v.cend());
}
};
} // namespace search

1
libs/search/search_tests/locality_scorer_test.cpp
View File

@@ -22,6 +22,7 @@
#include <vector>
#include "3party/ankerl/unordered_dense.h"
#include "3party/skarupke/flat_hash_map.hpp"
namespace locality_scorer_test
{

2
libs/search/utils.cpp
View File

@@ -20,7 +20,7 @@ std::vector<uint32_t> GetCategoryTypes(std::string const & name, std::string con
int8_t const code = CategoriesHolder::MapLocaleToInteger(locale);
Locales locales;
locales.Insert(static_cast<uint64_t>(code));
locales.insert(static_cast<uint64_t>(code));
auto const tokens = NormalizeAndTokenizeString(name);

2
libs/search/utils.hpp
View File

@@ -85,7 +85,7 @@ bool FillCategories(QuerySliceOnRawStrings<T> const & slice, Locales const & loc
types.clear();
catHolder.ForEachNameAndType([&](CategoriesHolder::Category::Name const & categorySynonym, uint32_t type)
{
if (!locales.Contains(static_cast<uint64_t>(categorySynonym.m_locale)))
if (!locales.contains(static_cast<uint64_t>(categorySynonym.m_locale)))
return;
auto const categoryTokens = NormalizeAndTokenizeString(categorySynonym.m_name);