Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

POC of one-to-many bidirectional routing in map-matching

Browse Source
This commit is contained in:
Siarhei Fedartsou 2024-07-29 19:53:44 +02:00
parent 4a34c86544
commit 2e2ce1d421
5 changed files with 121 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
include/engine/routing_algorithms/routing_base_ch.hpp
View File

@ -460,14 +460,14 @@ void search(SearchEngineData<Algorithm> &engine_working_data,
duration_upper_bound); duration_upper_bound);
} }
inline std::vector<double> inline std::vector<double> getNetworkDistances(
getNetworkDistances(SearchEngineData<Algorithm> &, SearchEngineData<Algorithm> &,
const DataFacade<ch::Algorithm> &, const DataFacade<ch::Algorithm> &,
SearchEngineData<Algorithm>::QueryHeap &, SearchEngineData<Algorithm>::QueryHeap &,
const std::vector<std::unique_ptr<typename SearchEngineData<Algorithm>::QueryHeap>> &, const std::vector<std::unique_ptr<typename SearchEngineData<Algorithm>::QueryHeap>> &,
const PhantomNode &, const PhantomNode &,
const std::vector<PhantomNode> &, const std::vector<PhantomNode> &,
EdgeWeight /*duration_upper_bound*/ = INVALID_EDGE_WEIGHT) EdgeWeight /*duration_upper_bound*/ = INVALID_EDGE_WEIGHT)
{ {
std::vector<double> distances; std::vector<double> distances;
return distances; return distances;

99
include/engine/routing_algorithms/routing_base_mld.hpp
View File

@ -39,11 +39,11 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
}; };
auto res = std::min(std::min(level(source.forward_segment_id, target.forward_segment_id), auto res = std::min(std::min(level(source.forward_segment_id, target.forward_segment_id),
level(source.forward_segment_id, target.reverse_segment_id)), level(source.forward_segment_id, target.reverse_segment_id)),
std::min(level(source.reverse_segment_id, target.forward_segment_id), std::min(level(source.reverse_segment_id, target.forward_segment_id),
level(source.reverse_segment_id, target.reverse_segment_id))); level(source.reverse_segment_id, target.reverse_segment_id)));
// std::cerr << "OLD!!! " << (int)res << std::endl; // std::cerr << "OLD!!! " << (int)res << std::endl;
return res; return res;
} }
@ -95,7 +95,7 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
getNodeQueryLevel(partition, node, source, target)); getNodeQueryLevel(partition, node, source, target));
})); }));
}); });
// std::cerr << "NEW " << (int)min_level << std::endl; // std::cerr << "NEW " << (int)min_level << std::endl;
return min_level; return min_level;
} }
@ -144,10 +144,9 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
highest_different_level(phantom_node.reverse_segment_id)); highest_different_level(phantom_node.reverse_segment_id));
return std::min(current_level, highest_level); return std::min(current_level, highest_level);
}); });
// std::cerr << "NEW!!! " << (int)node_level << std::endl;
return node_level;
// std::cerr << "NEW!!! " << (int)node_level << std::endl;
return node_level;
} }
// Unrestricted search with a single phantom node and a vector of phantom nodes: // Unrestricted search with a single phantom node and a vector of phantom nodes:
@ -463,10 +462,13 @@ void routingStep(const DataFacade<Algorithm> &facade,
BOOST_ASSERT(!facade.ExcludeNode(heapNode.node)); BOOST_ASSERT(!facade.ExcludeNode(heapNode.node));
if (DIRECTION == FORWARD_DIRECTION) { if (DIRECTION == FORWARD_DIRECTION)
// std::cerr << "FORWARDO " << heapNode.node << std::endl; {
} else { // std::cerr << "FORWARDO " << heapNode.node << std::endl;
//std::cerr << "REVERSEO " << heapNode.node << std::endl; }
else
{
// std::cerr << "REVERSEO " << heapNode.node << std::endl;
} }
// Upper bound for the path source -> target with // Upper bound for the path source -> target with
@ -656,7 +658,7 @@ searchDistance(SearchEngineData<Algorithm> &,
auto [middle, _] = *searchResult; auto [middle, _] = *searchResult;
// std::cerr << "old " << middle << std::endl; // std::cerr << "old " << middle << std::endl;
auto distance = forward_heap.GetData(middle).distance + reverse_heap.GetData(middle).distance; auto distance = forward_heap.GetData(middle).distance + reverse_heap.GetData(middle).distance;
return distance; return distance;
@ -817,7 +819,7 @@ runSearch2(const DataFacade<Algorithm> &facade,
size_t candidatesCount, size_t candidatesCount,
const std::vector<NodeID> &force_step_nodes, const std::vector<NodeID> &force_step_nodes,
EdgeWeight weight_upper_bound, EdgeWeight weight_upper_bound,
const PhantomEndpointCandidates& candidates) const PhantomEndpointCandidates &candidates)
{ {
// if (forward_heap.Empty() || reverse_heap.Empty()) // if (forward_heap.Empty() || reverse_heap.Empty())
// { // {
@ -846,7 +848,8 @@ runSearch2(const DataFacade<Algorithm> &facade,
bool cont = false; bool cont = false;
for (size_t i = 0; i < candidatesCount; ++i) for (size_t i = 0; i < candidatesCount; ++i)
{ {
if ((forward_heap_min + reverse_heap_mins[i]) < weights[i]) if ((forward_heap.Size() + reverse_heap[i]->Size() > 0) &&
(forward_heap_min + reverse_heap_mins[i]) < weights[i])
{ {
cont = true; cont = true;
break; break;
@ -855,19 +858,13 @@ runSearch2(const DataFacade<Algorithm> &facade,
return cont; return cont;
}; };
while ((forward_heap.Size() + std::accumulate(reverse_heap.begin(), while (shouldContinue())
reverse_heap.end(),
0,
[](auto sum, const auto &heap)
{ return sum + heap->Size(); }) >
0) &&
shouldContinue())
{ {
if (!forward_heap.Empty()) if (!forward_heap.Empty())
{ {
const auto heapNode = forward_heap.DeleteMinGetHeapNode(); const auto heapNode = forward_heap.DeleteMinGetHeapNode();
// std::cerr << "FORWARDN " << heapNode.node << std::endl; // std::cerr << "FORWARDN " << heapNode.node << std::endl;
//auto heapNode = routingStep2<FORWARD_DIRECTION>(facade, forward_heap, args...); // auto heapNode = routingStep2<FORWARD_DIRECTION>(facade, forward_heap, args...);
for (size_t i = 0; i < candidatesCount; ++i) for (size_t i = 0; i < candidatesCount; ++i)
{ {
@ -884,10 +881,10 @@ runSearch2(const DataFacade<Algorithm> &facade,
middles[i] = heapNode.node; middles[i] = heapNode.node;
weights[i] = path_weight; weights[i] = path_weight;
// auto distance = // auto distance =
// forward_heap.GetData(middles[i]).distance + reverse_heap[i]->GetData(middles[i]).distance; // forward_heap.GetData(middles[i]).distance +
// std::cerr << "RFOUNDN " << i <<" " << distance << std::endl; // reverse_heap[i]->GetData(middles[i]).distance;
// std::cerr << "RFOUNDN " << i <<" " << distance << std::endl;
} }
} }
} }
@ -902,8 +899,8 @@ runSearch2(const DataFacade<Algorithm> &facade,
if (!reverse_heap[i]->Empty() && (forward_heap_min + reverse_heap_mins[i]) < weights[i]) if (!reverse_heap[i]->Empty() && (forward_heap_min + reverse_heap_mins[i]) < weights[i])
{ {
const auto heapNode = reverse_heap[i]->DeleteMinGetHeapNode(); const auto heapNode = reverse_heap[i]->DeleteMinGetHeapNode();
//std::cerr << "REVERSEN " << i << " " << heapNode.node << std::endl; // std::cerr << "REVERSEN " << i << " " << heapNode.node << std::endl;
const auto reverseHeapNode = forward_heap.GetHeapNodeIfWasInserted(heapNode.node); const auto reverseHeapNode = forward_heap.GetHeapNodeIfWasInserted(heapNode.node);
if (reverseHeapNode) if (reverseHeapNode)
{ {
@ -917,13 +914,14 @@ runSearch2(const DataFacade<Algorithm> &facade,
middles[i] = heapNode.node; middles[i] = heapNode.node;
weights[i] = path_weight; weights[i] = path_weight;
// auto distance = // auto distance =
// forward_heap.GetData(middles[i]).distance + reverse_heap[i]->GetData(middles[i]).distance; // forward_heap.GetData(middles[i]).distance +
// std::cerr << "FFOUNDN " << i << " " << distance << std::endl; // reverse_heap[i]->GetData(middles[i]).distance;
// std::cerr << "FFOUNDN " << i << " " << distance << std::endl;
} }
} }
relaxOutgoingEdges<REVERSE_DIRECTION>(facade, *reverse_heap[i], heapNode, candidates); relaxOutgoingEdges<REVERSE_DIRECTION>(
facade, *reverse_heap[i], heapNode, candidates);
if (!reverse_heap[i]->Empty()) if (!reverse_heap[i]->Empty())
reverse_heap_mins[i] = reverse_heap[i]->MinKey(); reverse_heap_mins[i] = reverse_heap[i]->MinKey();
@ -988,10 +986,15 @@ std::vector<EdgeDistance> searchDistance2(
size_t candidatesCount, size_t candidatesCount,
const std::vector<NodeID> &force_step_nodes, const std::vector<NodeID> &force_step_nodes,
EdgeWeight weight_upper_bound, EdgeWeight weight_upper_bound,
const PhantomEndpointCandidates& candidates) const PhantomEndpointCandidates &candidates)
{ {
auto searchResults = runSearch2( auto searchResults = runSearch2(facade,
facade, forward_heap, reverse_heaps, candidatesCount, force_step_nodes, weight_upper_bound, candidates); forward_heap,
reverse_heaps,
candidatesCount,
force_step_nodes,
weight_upper_bound,
candidates);
std::vector<EdgeDistance> res; std::vector<EdgeDistance> res;
for (size_t i = 0; i < searchResults.size(); ++i) for (size_t i = 0; i < searchResults.size(); ++i)
{ {
@ -1003,7 +1006,7 @@ std::vector<EdgeDistance> searchDistance2(
{ {
auto [middle, _] = *searchResults[i]; auto [middle, _] = *searchResults[i];
//std::cerr << "new " << i << " " << middle << std::endl; // std::cerr << "new " << i << " " << middle << std::endl;
auto distance = auto distance =
forward_heap.GetData(middle).distance + reverse_heaps[i]->GetData(middle).distance; forward_heap.GetData(middle).distance + reverse_heaps[i]->GetData(middle).distance;
@ -1013,14 +1016,15 @@ std::vector<EdgeDistance> searchDistance2(
return res; return res;
} }
template <typename Algorithm> template <typename Algorithm>
std::vector<double> std::vector<double> getNetworkDistances(
getNetworkDistances(SearchEngineData<Algorithm> &engine_working_data, SearchEngineData<Algorithm> &engine_working_data,
const DataFacade<Algorithm> &facade, const DataFacade<Algorithm> &facade,
typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &forward_heap, typename SearchEngineData<Algorithm>::MapMatchingQueryHeap &forward_heap,
const std::vector<std::unique_ptr<typename SearchEngineData<Algorithm>::MapMatchingQueryHeap>> &reverse_heaps, const std::vector<std::unique_ptr<typename SearchEngineData<Algorithm>::MapMatchingQueryHeap>>
const PhantomNode &source_phantom, &reverse_heaps,
const std::vector<PhantomNode> &target_phantoms, const PhantomNode &source_phantom,
EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT) const std::vector<PhantomNode> &target_phantoms,
EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
{ {
forward_heap.Clear(); forward_heap.Clear();
for (const auto &heap : reverse_heaps) for (const auto &heap : reverse_heaps)
@ -1085,7 +1089,6 @@ getNetworkDistances(SearchEngineData<Algorithm> &engine_working_data,
source_phantomes.push_back(source_phantom); source_phantomes.push_back(source_phantom);
PhantomEndpointCandidates phantom_candidates{source_phantomes, target_phantoms}; PhantomEndpointCandidates phantom_candidates{source_phantomes, target_phantoms};
auto distances2 = searchDistance2(engine_working_data, auto distances2 = searchDistance2(engine_working_data,
facade, facade,
forward_heap, forward_heap,

6
src/benchmarks/bench.cpp
View File

@ -395,9 +395,9 @@ void runMatchBenchmark(const OSRM &osrm, const GPSTraces &gpsTraces, int iterati
std::optional<size_t> radius = std::nullopt; std::optional<size_t> radius = std::nullopt;
}; };
std::vector<Benchmark> benchmarks = {{"500 matches, default radius", 10}, std::vector<Benchmark> benchmarks = {{"500 matches, default radius"},
/*{"500 matches, radius=10", 10}, {"500 matches, radius=10", 10},
{"500 matches, radius=20", 20}*/}; {"500 matches, radius=20", 20}};
runBenchmarks(benchmarks, runBenchmarks(benchmarks,
iterations, iterations,

95
src/engine/routing_algorithms/map_matching.cpp
View File

@ -61,74 +61,80 @@ inline void initializeHeap<mld::Algorithm>(SearchEngineData<mld::Algorithm> &eng
const auto nodes_number = facade.GetNumberOfNodes(); const auto nodes_number = facade.GetNumberOfNodes();
const auto border_nodes_number = facade.GetMaxBorderNodeID() + 1; const auto border_nodes_number = facade.GetMaxBorderNodeID() + 1;
engine_working_data.InitializeOrClearMapMatchingThreadLocalStorage(nodes_number, engine_working_data.InitializeOrClearMapMatchingThreadLocalStorage(
border_nodes_number, nodes_number, border_nodes_number, max_candidates);
max_candidates);
} }
#include <iostream>
#include <fstream> #include <fstream>
#include <iostream>
template <typename T> template <typename T> void saveVectorToFile(const std::vector<T> &data, const std::string &filename)
void saveVectorToFile(const std::vector<T>& data, const std::string& filename) { {
std::ofstream outFile(filename, std::ios::binary); std::ofstream outFile(filename, std::ios::binary);
if (!outFile) { if (!outFile)
{
std::cerr << "Error opening file for writing: " << filename << std::endl; std::cerr << "Error opening file for writing: " << filename << std::endl;
return; return;
} }
size_t size = data.size(); size_t size = data.size();
outFile.write(reinterpret_cast<const char*>(&size), sizeof(size)); outFile.write(reinterpret_cast<const char *>(&size), sizeof(size));
outFile.write(reinterpret_cast<const char*>(data.data()), size * sizeof(T)); outFile.write(reinterpret_cast<const char *>(data.data()), size * sizeof(T));
outFile.close(); outFile.close();
if (!outFile.good()) { if (!outFile.good())
{
std::cerr << "Error occurred at writing time!" << std::endl; std::cerr << "Error occurred at writing time!" << std::endl;
} }
} }
template <typename T> template <typename T> bool loadVectorFromFile(std::vector<T> &data, const std::string &filename)
bool loadVectorFromFile(std::vector<T>& data, const std::string& filename) { {
std::ifstream inFile(filename, std::ios::binary); std::ifstream inFile(filename, std::ios::binary);
if (!inFile) { if (!inFile)
{
std::cerr << "Error opening file for reading: " << filename << std::endl; std::cerr << "Error opening file for reading: " << filename << std::endl;
return false; return false;
} }
size_t size; size_t size;
inFile.read(reinterpret_cast<char*>(&size), sizeof(size)); inFile.read(reinterpret_cast<char *>(&size), sizeof(size));
data.resize(size); data.resize(size);
inFile.read(reinterpret_cast<char*>(data.data()), size * sizeof(T)); inFile.read(reinterpret_cast<char *>(data.data()), size * sizeof(T));
inFile.close(); inFile.close();
if (!inFile.good()) { if (!inFile.good())
{
std::cerr << "Error occurred at reading time!" << std::endl; std::cerr << "Error occurred at reading time!" << std::endl;
return false; return false;
} }
return true; return true;
} }
template <typename T> template <typename T> void saveStructToFile(const T &data, const std::string &filename)
void saveStructToFile(const T& data, const std::string& filename) { {
std::ofstream outFile(filename, std::ios::binary); std::ofstream outFile(filename, std::ios::binary);
if (!outFile) { if (!outFile)
{
std::cerr << "Error opening file for writing: " << filename << std::endl; std::cerr << "Error opening file for writing: " << filename << std::endl;
return; return;
} }
outFile.write(reinterpret_cast<const char*>(&data), sizeof(T)); outFile.write(reinterpret_cast<const char *>(&data), sizeof(T));
outFile.close(); outFile.close();
if (!outFile.good()) { if (!outFile.good())
{
std::cerr << "Error occurred at writing time!" << std::endl; std::cerr << "Error occurred at writing time!" << std::endl;
} }
} }
template <typename T> bool loadStructFromFile(T &data, const std::string &filename)
template <typename T> {
bool loadStructFromFile(T& data, const std::string& filename) {
std::ifstream inFile(filename, std::ios::binary); std::ifstream inFile(filename, std::ios::binary);
if (!inFile) { if (!inFile)
{
std::cerr << "Error opening file for reading: " << filename << std::endl; std::cerr << "Error opening file for reading: " << filename << std::endl;
return false; return false;
} }
inFile.read(reinterpret_cast<char*>(&data), sizeof(T)); inFile.read(reinterpret_cast<char *>(&data), sizeof(T));
inFile.close(); inFile.close();
if (!inFile.good()) { if (!inFile.good())
{
std::cerr << "Error occurred at reading time!" << std::endl; std::cerr << "Error occurred at reading time!" << std::endl;
return false; return false;
} }
@ -304,20 +310,20 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
{ {
continue; continue;
} }
// PhantomNode source; // PhantomNode source;
// loadStructFromFile<PhantomNode>(source, "source.bin"); // loadStructFromFile<PhantomNode>(source, "source.bin");
std::vector<PhantomNode> target_phantom_nodes; std::vector<PhantomNode> target_phantom_nodes;
// loadVectorFromFile(target_phantom_nodes, "target.bin"); // loadVectorFromFile(target_phantom_nodes, "target.bin");
// target_phantom_nodes.erase(target_phantom_nodes.begin()); // target_phantom_nodes.erase(target_phantom_nodes.begin());
// target_phantom_nodes.erase(target_phantom_nodes.begin()); // target_phantom_nodes.erase(target_phantom_nodes.begin());
// target_phantom_nodes.erase(target_phantom_nodes.begin()); // target_phantom_nodes.erase(target_phantom_nodes.begin());
// target_phantom_nodes.erase(target_phantom_nodes.begin()); // target_phantom_nodes.erase(target_phantom_nodes.begin());
// target_phantom_nodes.pop_back(); // target_phantom_nodes.pop_back();
// target_phantom_nodes.pop_back(); // target_phantom_nodes.pop_back();
// target_phantom_nodes.erase(target_phantom_nodes.begin() + 1); // target_phantom_nodes.erase(target_phantom_nodes.begin() + 1);
// target_phantom_nodes.push_back(target); // target_phantom_nodes.push_back(target);
for (const auto s_prime : util::irange<std::size_t>(0UL, current_viterbi.size())) for (const auto s_prime : util::irange<std::size_t>(0UL, current_viterbi.size()))
{ {
const double emission_pr = emission_log_probabilities[t][s_prime]; const double emission_pr = emission_log_probabilities[t][s_prime];
@ -329,8 +335,8 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
target_phantom_nodes.push_back(current_timestamps_list[s_prime].phantom_node); target_phantom_nodes.push_back(current_timestamps_list[s_prime].phantom_node);
} }
// TIMER_START(NEW_DIST); // TIMER_START(NEW_DIST);
#if 1 #if 1
(void)reverse_heap; (void)reverse_heap;
auto distances = auto distances =
getNetworkDistances(engine_working_data, getNetworkDistances(engine_working_data,
@ -368,7 +374,8 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
// { // {
// if (std::abs(old_distances[i] - new_distances[i]) > 0.01) // if (std::abs(old_distances[i] - new_distances[i]) > 0.01)
// { // {
// // saveStructToFile(prev_unbroken_timestamps_list[s].phantom_node, "source.bin"); // // saveStructToFile(prev_unbroken_timestamps_list[s].phantom_node,
// "source.bin");
// // saveVectorToFile(target_phantom_nodes, "target.bin"); // // saveVectorToFile(target_phantom_nodes, "target.bin");
// // std::cerr << "OOPS " << old_distances[i] << " " << new_distances[i] // // std::cerr << "OOPS " << old_distances[i] << " " << new_distances[i]
// // << std::endl; // // << std::endl;

13
src/engine/search_engine_data.cpp
View File

@ -15,7 +15,8 @@ thread_local SearchEngineData<CH>::SearchEngineHeapPtr
SearchEngineData<CH>::map_matching_forward_heap_1; SearchEngineData<CH>::map_matching_forward_heap_1;
thread_local SearchEngineData<CH>::SearchEngineHeapPtr thread_local SearchEngineData<CH>::SearchEngineHeapPtr
SearchEngineData<CH>::map_matching_reverse_heap_1; SearchEngineData<CH>::map_matching_reverse_heap_1;
thread_local std::vector<typename SearchEngineData<CH>::SearchEngineHeapPtr> SearchEngineData<CH>::map_matching_reverse_heaps; thread_local std::vector<typename SearchEngineData<CH>::SearchEngineHeapPtr>
SearchEngineData<CH>::map_matching_reverse_heaps;
thread_local SearchEngineData<CH>::ManyToManyHeapPtr SearchEngineData<CH>::many_to_many_heap; thread_local SearchEngineData<CH>::ManyToManyHeapPtr SearchEngineData<CH>::many_to_many_heap;
@ -124,7 +125,8 @@ thread_local SearchEngineData<MLD>::MapMatchingHeapPtr
thread_local SearchEngineData<MLD>::MapMatchingHeapPtr thread_local SearchEngineData<MLD>::MapMatchingHeapPtr
SearchEngineData<MLD>::map_matching_reverse_heap_1; SearchEngineData<MLD>::map_matching_reverse_heap_1;
thread_local SearchEngineData<MLD>::ManyToManyHeapPtr SearchEngineData<MLD>::many_to_many_heap; thread_local SearchEngineData<MLD>::ManyToManyHeapPtr SearchEngineData<MLD>::many_to_many_heap;
thread_local std::vector<typename SearchEngineData<MLD>::MapMatchingHeapPtr> SearchEngineData<MLD>::map_matching_reverse_heaps; thread_local std::vector<typename SearchEngineData<MLD>::MapMatchingHeapPtr>
SearchEngineData<MLD>::map_matching_reverse_heaps;
void SearchEngineData<MLD>::InitializeOrClearMapMatchingThreadLocalStorage( void SearchEngineData<MLD>::InitializeOrClearMapMatchingThreadLocalStorage(
unsigned number_of_nodes, unsigned number_of_boundary_nodes, size_t max_candidates) unsigned number_of_nodes, unsigned number_of_boundary_nodes, size_t max_candidates)
@ -149,14 +151,15 @@ void SearchEngineData<MLD>::InitializeOrClearMapMatchingThreadLocalStorage(
new MapMatchingQueryHeap(number_of_nodes, number_of_boundary_nodes)); new MapMatchingQueryHeap(number_of_nodes, number_of_boundary_nodes));
} }
if (max_candidates > map_matching_reverse_heaps.size()) { if (max_candidates > map_matching_reverse_heaps.size())
{
size_t to_add = max_candidates - map_matching_reverse_heaps.size(); size_t to_add = max_candidates - map_matching_reverse_heaps.size();
for (unsigned i = 0; i < to_add; ++i) for (unsigned i = 0; i < to_add; ++i)
{ {
map_matching_reverse_heaps.emplace_back(new MapMatchingQueryHeap(number_of_nodes, number_of_boundary_nodes)); map_matching_reverse_heaps.emplace_back(
new MapMatchingQueryHeap(number_of_nodes, number_of_boundary_nodes));
} }
} }
} }
void SearchEngineData<MLD>::InitializeOrClearFirstThreadLocalStorage( void SearchEngineData<MLD>::InitializeOrClearFirstThreadLocalStorage(