RedAuburn/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

[search] Separated the ResultTracer.

Browse source
This commit is contained in:
Maxim Pimenov 2019-02-08 15:06:19 +03:00 • committed by Tatiana Yan
parent ce161beb47
commit 6e830e8ac5
17 changed files with 109 additions and 86 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
map/search_api.cpp
View file

@ -8,6 +8,7 @@
#include "search/bookmarks/processor.hpp"
#include "search/geometry_utils.hpp"
#include "search/hotels_filter.hpp"
#include "search/tracer.hpp"
#include "storage/downloader_search_params.hpp"

32
search/geocoder.cpp
View file

@ -313,21 +313,9 @@ size_t OrderCountries(boost::optional<m2::PointD> const & position, m2::RectD co
return distance(infos.begin(), sep);
}
void TraceEntrance(shared_ptr<Tracer> tracer, Tracer::Branch branch)
{
if (tracer != nullptr)
tracer->CallMethod(branch);
}
void TraceExit(shared_ptr<Tracer> tracer, Tracer::Branch branch)
{
if (tracer != nullptr)
tracer->LeaveMethod(branch);
}
#define TRACE(branch) \
TraceEntrance(m_params.m_tracer, Tracer::Branch::branch); \
SCOPE_GUARD(tracerGuard, [&] { TraceExit(m_params.m_tracer, Tracer::Branch::branch); });
#define TRACE(branch) \
m_resultTracer.CallMethod(ResultTracer::Branch::branch); \
SCOPE_GUARD(tracerGuard, [&] { m_resultTracer.LeaveMethod(ResultTracer::Branch::branch); });
} // namespace
// Geocoder::Geocoder ------------------------------------------------------------------------------
@ -396,6 +384,8 @@ void Geocoder::SetParams(Params const & params)
}
}
m_resultTracer.Clear();
LOG(LDEBUG, (static_cast<QueryParams const &>(m_params)));
}
@ -1043,13 +1033,14 @@ void Geocoder::CreateStreetsLayerAndMatchLowerLayers(BaseContext & ctx,
ScopedMarkTokens mark(ctx.m_tokens, BaseContext::TOKEN_TYPE_STREET, prediction.m_tokenRange);
size_t const numEmitted = ctx.m_numEmitted;
LOG(LINFO, ("num emitted1", ctx.m_numEmitted));
MatchPOIsAndBuildings(ctx, 0 /* curToken */);
LOG(LINFO, ("num emitted2", ctx.m_numEmitted));
// A relaxed best effort parse: at least show the street if we can find one.
if (numEmitted == ctx.m_numEmitted)
if (numEmitted == ctx.m_numEmitted && ctx.SkipUsedTokens(0) != ctx.m_numTokens)
{
TRACE(Relaxed);
FindPaths(ctx);
}
}
void Geocoder::MatchPOIsAndBuildings(BaseContext & ctx, size_t curToken)
@ -1377,10 +1368,7 @@ void Geocoder::EmitResult(BaseContext & ctx, MwmSet::MwmId const & mwmId, uint32
info.m_allTokensUsed = allTokensUsed;
if (m_params.m_tracer == nullptr)
m_preRanker.Emplace(id, info, Tracer::Provenance{});
else
m_preRanker.Emplace(id, info, m_params.m_tracer->GetProvenance());
m_preRanker.Emplace(id, info, m_resultTracer.GetProvenance());
++ctx.m_numEmitted;
}

4
search/geocoder.hpp
View file

@ -21,6 +21,7 @@
#include "search/ranking_utils.hpp"
#include "search/streets_matcher.hpp"
#include "search/token_range.hpp"
#include "search/tracer.hpp"
#include "indexer/mwm_set.hpp"
@ -62,7 +63,6 @@ class FeaturesFilter;
class FeaturesLayerMatcher;
class PreRanker;
class TokenSlice;
class Tracer;
// This class is used to retrieve all features corresponding to a
// search query. Search query is represented as a sequence of tokens
@ -304,6 +304,8 @@ private:
std::vector<SearchTrieRequest<strings::LevenshteinDFA>> m_tokenRequests;
SearchTrieRequest<strings::PrefixDFAModifier<strings::LevenshteinDFA>> m_prefixTokenRequest;
ResultTracer m_resultTracer;
PreRanker & m_preRanker;
};
} // namespace search

2
search/intermediate_result.cpp
View file

@ -73,7 +73,7 @@ PreRankerResult::PreRankerResult(FeatureID const & id, PreRankingInfo const & in
}
PreRankerResult::PreRankerResult(FeatureID const & id, PreRankingInfo const & info,
vector<Tracer::Branch> const & provenance)
vector<ResultTracer::Branch> const & provenance)
: m_id(id), m_info(info), m_provenance(provenance)
{
ASSERT(m_id.IsValid(), ());

10
search/intermediate_result.hpp
View file

@ -35,7 +35,7 @@ public:
PreRankerResult(FeatureID const & id, PreRankingInfo const & info);
PreRankerResult(FeatureID const & id, PreRankingInfo const & info,
std::vector<Tracer::Branch> const & provenance);
std::vector<ResultTracer::Branch> const & provenance);
static bool LessRankAndPopularity(PreRankerResult const & r1, PreRankerResult const & r2);
static bool LessDistance(PreRankerResult const & r1, PreRankerResult const & r2);
@ -55,7 +55,7 @@ public:
uint8_t GetPopularity() const { return m_info.m_popularity; }
PreRankingInfo & GetInfo() { return m_info; }
PreRankingInfo const & GetInfo() const { return m_info; }
std::vector<Tracer::Branch> const & GetProvenance() const { return m_provenance; }
std::vector<ResultTracer::Branch> const & GetProvenance() const { return m_provenance; }
private:
friend class RankerResult;
@ -64,7 +64,7 @@ private:
PreRankingInfo m_info;
// The call path in the Geocoder that leads to this result.
std::vector<Tracer::Branch> m_provenance;
std::vector<ResultTracer::Branch> m_provenance;
};
// Second result class. Objects are created during reading of features.
@ -115,7 +115,7 @@ public:
uint32_t GetBestType(std::vector<uint32_t> const & preferredTypes = {}) const;
std::vector<Tracer::Branch> const & GetProvenance() const { return m_provenance; }
std::vector<ResultTracer::Branch> const & GetProvenance() const { return m_provenance; }
private:
friend class RankerResultMaker;
@ -146,7 +146,7 @@ private:
Result::Metadata m_metadata;
// The call path in the Geocoder that leads to this result.
std::vector<Tracer::Branch> m_provenance;
std::vector<ResultTracer::Branch> m_provenance;
};
void ProcessMetadata(FeatureType & ft, Result::Metadata & meta);

24
search/pre_ranker.cpp
View file

@ -3,6 +3,7 @@
#include "search/dummy_rank_table.hpp"
#include "search/lazy_centers_table.hpp"
#include "search/pre_ranking_info.hpp"
#include "search/tracer.hpp"
#include "indexer/data_source.hpp"
#include "indexer/mwm_set.hpp"
@ -15,6 +16,7 @@
#include "base/random.hpp"
#include "base/stl_helpers.hpp"
#include <algorithm>
#include <iterator>
#include <set>
@ -56,6 +58,7 @@ void PreRanker::Init(Params const & params)
{
m_numSentResults = 0;
m_results.clear();
m_relaxedResults.clear();
m_params = params;
m_currEmit.clear();
}
@ -222,8 +225,10 @@ void PreRanker::Filter(bool viewportSearch)
void PreRanker::UpdateResults(bool lastUpdate)
{
FilterRelaxedResults(lastUpdate);
FillMissingFieldsInPreResults();
Filter(m_params.m_viewportSearch);
LOG(LINFO, ("sending", m_results.size(), "results to ranker"));
m_numSentResults += m_results.size();
m_ranker.SetPreRankerResults(move(m_results));
m_results.clear();
@ -313,4 +318,23 @@ void PreRanker::FilterForViewportSearch()
m_results.push_back(results[i]);
}
}
void PreRanker::FilterRelaxedResults(bool lastUpdate)
{
if (lastUpdate)
{
m_results.insert(m_results.end(), m_relaxedResults.begin(), m_relaxedResults.end());
m_relaxedResults.clear();
}
else
{
auto const isNotRelaxed = [](PreRankerResult const & res) {
auto const & prov = res.GetProvenance();
return find(prov.begin(), prov.end(), ResultTracer::Branch::Relaxed) == prov.end();
};
auto const it = partition(m_results.begin(), m_results.end(), isNotRelaxed);
m_relaxedResults.insert(m_relaxedResults.end(), it, m_results.end());
m_results.erase(it, m_results.end());
}
}
} // namespace search

3
search/pre_ranker.hpp
View file

@ -94,9 +94,12 @@ public:
private:
void FilterForViewportSearch();
void FilterRelaxedResults(bool lastUpdate);
DataSource const & m_dataSource;
Ranker & m_ranker;
std::vector<PreRankerResult> m_results;
std::vector<PreRankerResult> m_relaxedResults;
Params m_params;
// Amount of results sent up the pipeline.

1
search/pre_ranking_info.hpp
View file

@ -3,7 +3,6 @@
#include "search/intersection_result.hpp"
#include "search/model.hpp"
#include "search/token_range.hpp"
#include "search/tracer.hpp"
#include "indexer/feature_decl.hpp"

2
search/processor.cpp
View file

@ -549,8 +549,6 @@ void Processor::InitGeocoder(Geocoder::Params & geocoderParams, SearchParams con
geocoderParams.m_cuisineTypes = m_cuisineTypes;
geocoderParams.m_preferredTypes = m_preferredTypes;
geocoderParams.m_tracer = searchParams.m_tracer;
if (geocoderParams.m_tracer == nullptr)
geocoderParams.m_tracer = make_shared<Tracer>();
m_geocoder.SetParams(geocoderParams);
}

2
search/ranker.cpp
View file

@ -516,7 +516,9 @@ void Ranker::UpdateResults(bool lastUpdate)
BailIfCancelled();
MakeRankerResults(m_geocoderParams, m_tentativeResults);
LOG(LINFO, ("made res, size =", m_tentativeResults.size()));
RemoveDuplicatingLinear(m_tentativeResults);
LOG(LINFO, ("removed duplicates, size =", m_tentativeResults.size()));
if (m_tentativeResults.empty())
return;

4
search/ranking_info.cpp
View file

@ -80,8 +80,8 @@ string DebugPrint(RankingInfo const & info)
os << "m_type:" << DebugPrint(info.m_type) << ",";
os << "m_pureCats:" << info.m_pureCats << ",";
os << "m_falseCats:" << info.m_falseCats << ",";
os << "m_allTokensUsed:" << info.m_allTokensUsed;
os << "m_categorialRequest:" << info.m_categorialRequest;
os << "m_allTokensUsed:" << info.m_allTokensUsed << ",";
os << "m_categorialRequest:" << info.m_categorialRequest << ",";
os << "m_hasName:" << info.m_hasName;
os << "]";
return os.str();

4
search/result.cpp
View file

@ -166,9 +166,9 @@ string DebugPrint(Result const & result)
os << "Result [";
os << "name: " << result.GetString() << ", ";
os << "type: " << readableType << ", ";
os << "info: " << DebugPrint(result.GetRankingInfo()) << ", ";
os << "info: " << DebugPrint(result.GetRankingInfo());
if (!result.GetProvenance().empty())
os << "provenance: " << ::DebugPrint(result.GetProvenance());
os << ", provenance: " << ::DebugPrint(result.GetProvenance());
os << "]";
return os.str();
}

4
search/result.hpp
View file

@ -131,7 +131,7 @@ public:
RankingInfo const & GetRankingInfo() const { return m_info; }
std::vector<Tracer::Branch> const & GetProvenance() const { return m_provenance; }
std::vector<ResultTracer::Branch> const & GetProvenance() const { return m_provenance; }
template <typename Info>
void SetRankingInfo(Info && info)
@ -167,7 +167,7 @@ private:
// a search query. -1 if undefined.
int32_t m_positionInResults = -1;
std::vector<Tracer::Branch> m_provenance;
std::vector<ResultTracer::Branch> m_provenance;
public:
// Careful when moving: the order of destructors is important.

16
search/search_integration_tests/processor_test.cpp
View file

@ -285,15 +285,15 @@ UNIT_CLASS_TEST(ProcessorTest, Smoke)
{
Rules rules = {ExactMatch(wonderlandId, feynmanHouse), ExactMatch(wonderlandId, lantern1),
ExactMatch(wonderlandId, firstAprilStreet)};
// TEST(ResultsMatch("feynman street 1", rules), ());
TEST(ResultsMatch("feynman street 1", rules), ());
}
{
Rules rules = {ExactMatch(wonderlandId, bohrHouse), ExactMatch(wonderlandId, hilbertHouse),
ExactMatch(wonderlandId, lantern1), ExactMatch(wonderlandId, firstAprilStreet)};
// TEST(ResultsMatch("bohr street 1", rules), ());
TEST(ResultsMatch("bohr street 1", rules), ());
}
{
// TEST(ResultsMatch("bohr street 1 unit 3", {ExactMatch(wonderlandId, bohrStreet1)}), ());
TEST(ResultsMatch("bohr street 1 unit 3", {ExactMatch(wonderlandId, bohrStreet1)}), ());
}
{
Rules rules = {ExactMatch(wonderlandId, lantern1), ExactMatch(wonderlandId, lantern2)};
@ -301,7 +301,7 @@ UNIT_CLASS_TEST(ProcessorTest, Smoke)
}
{
Rules rules = {ExactMatch(wonderlandId, feynmanHouse), ExactMatch(wonderlandId, feynmanStreet)};
// TEST(ResultsMatch("wonderland los alamos feynman 1 unit 1 ", rules), ());
TEST(ResultsMatch("wonderland los alamos feynman 1 unit 1 ", rules), ());
}
{
// It's possible to find Descartes house by name.
@ -317,12 +317,12 @@ UNIT_CLASS_TEST(ProcessorTest, Smoke)
}
{
Rules rules = {ExactMatch(wonderlandId, bornHouse), ExactMatch(wonderlandId, firstAprilStreet)};
// TEST(ResultsMatch("long pond 1st april street 8 ", rules), ());
TEST(ResultsMatch("long pond 1st april street 8 ", rules), ());
}
{
Rules rules = {ExactMatch(wonderlandId, terranceHouse), ExactMatch(wonderlandId, stradaDrive)};
// TEST(ResultsMatch("Toronto strada drive 155", rules), ());
TEST(ResultsMatch("Toronto strada drive 155", rules), ());
}
}
@ -1761,8 +1761,10 @@ UNIT_CLASS_TEST(ProcessorTest, SynonymsTest)
}
{
Rules rules = {ExactMatch(wonderlandId, stPeterRu)};
Rules relaxedRules = {ExactMatch(wonderlandId, stPeterRu),
ExactMatch(wonderlandId, streetRu)};
TEST(ResultsMatch("собор святого петра ", rules), ());
TEST(ResultsMatch("собор св петра ", rules), ());
TEST(ResultsMatch("собор св петра ", relaxedRules), ());
}
}

5
search/search_tests_support/test_search_request.cpp
View file

@ -116,16 +116,13 @@ void TestSearchRequest::OnStarted()
void TestSearchRequest::OnResults(search::Results const & results)
{
lock_guard<mutex> lock(m_mu);
m_results.assign(results.begin(), results.end());
if (results.IsEndMarker())
{
m_done = true;
m_endTime = m_timer.TimeElapsed();
m_cv.notify_one();
}
else
{
m_results.assign(results.begin(), results.end());
}
}
void TestSearchRequest::SetCustomOnResults(SearchParams::OnResults const & onResults)

34
search/tracer.cpp
View file

@ -6,7 +6,6 @@
#include <cstddef>
#include <iomanip>
#include <sstream>
#include <string>
using namespace std;
@ -42,12 +41,12 @@ vector<Tracer::Parse> Tracer::GetUniqueParses() const
return parses;
}
void Tracer::CallMethod(Branch branch)
{
m_provenance.emplace_back(branch);
}
// ResultTracer ------------------------------------------------------------------------------------
void ResultTracer::Clear() { m_provenance.clear(); }
void Tracer::LeaveMethod(Branch branch)
void ResultTracer::CallMethod(Branch branch) { m_provenance.emplace_back(branch); }
void ResultTracer::LeaveMethod(Branch branch)
{
CHECK(!m_provenance.empty(), ());
CHECK_EQUAL(m_provenance.back(), branch, ());
@ -82,20 +81,21 @@ string DebugPrint(Tracer::Parse const & parse)
return os.str();
}
string DebugPrint(Tracer::Branch branch)
string DebugPrint(ResultTracer::Branch branch)
{
switch (branch)
{
case Tracer::Branch::GoEverywhere: return "GoEverywhere";
case Tracer::Branch::GoInViewport: return "GoInViewport";
case Tracer::Branch::MatchCategories: return "MatchCategories";
case Tracer::Branch::MatchRegions: return "MatchRegions";
case Tracer::Branch::MatchCities: return "MatchCities";
case Tracer::Branch::MatchAroundPivot: return "MatchAroundPivot";
case Tracer::Branch::MatchPOIsAndBuildings: return "MatchPOIsAndBuildings";
case Tracer::Branch::GreedilyMatchStreets: return "GreedilyMatchStreets";
case Tracer::Branch::WithPostcodes: return "WithPostcodes";
case Tracer::Branch::MatchUnclassified: return "MatchUnclassified";
case ResultTracer::Branch::GoEverywhere: return "GoEverywhere";
case ResultTracer::Branch::GoInViewport: return "GoInViewport";
case ResultTracer::Branch::MatchCategories: return "MatchCategories";
case ResultTracer::Branch::MatchRegions: return "MatchRegions";
case ResultTracer::Branch::MatchCities: return "MatchCities";
case ResultTracer::Branch::MatchAroundPivot: return "MatchAroundPivot";
case ResultTracer::Branch::MatchPOIsAndBuildings: return "MatchPOIsAndBuildings";
case ResultTracer::Branch::GreedilyMatchStreets: return "GreedilyMatchStreets";
case ResultTracer::Branch::WithPostcodes: return "WithPostcodes";
case ResultTracer::Branch::MatchUnclassified: return "MatchUnclassified";
case ResultTracer::Branch::Relaxed: return "Relaxed";
}
UNREACHABLE();
}

47
search/tracer.hpp
View file

@ -13,23 +13,6 @@ namespace search
class Tracer
{
public:
// Mimics the Geocoder methods.
enum class Branch
{
GoEverywhere,
GoInViewport,
MatchCategories,
MatchRegions,
MatchCities,
MatchAroundPivot,
MatchPOIsAndBuildings,
GreedilyMatchStreets,
WithPostcodes,
MatchUnclassified,
};
using Provenance = std::vector<Branch>;
struct Parse
{
using TokenType = BaseContext::TokenType;
@ -62,17 +45,41 @@ public:
std::vector<Parse> GetUniqueParses() const;
private:
std::vector<Parse> m_parses;
};
class ResultTracer
{
public:
// Mimics the Geocoder methods.
enum class Branch
{
GoEverywhere,
GoInViewport,
MatchCategories,
MatchRegions,
MatchCities,
MatchAroundPivot,
MatchPOIsAndBuildings,
GreedilyMatchStreets,
WithPostcodes,
MatchUnclassified,
Relaxed,
};
using Provenance = std::vector<Branch>;
void Clear();
void CallMethod(Branch branch);
void LeaveMethod(Branch branch);
Provenance const & GetProvenance() const { return m_provenance; }
private:
std::vector<Parse> m_parses;
// Traces the Geocoder call tree that leads to emitting the current result.
Provenance m_provenance;
};
std::string DebugPrint(Tracer::Parse const & parse);
std::string DebugPrint(Tracer::Branch branch);
std::string DebugPrint(ResultTracer::Branch branch);
} // namespace search