[DNM][routing] Two threads bidirectional A*.

coding/file_reader.hpp

@@ -10,7 +10,7 @@
 #include <string>
 
 // FileReader, cheap to copy, not thread safe.
-// It is assumed that file is not modified during FireReader lifetime,
+// It is assumed that file is not modified during FileReader lifetime,
 // because of caching and assumption that Size() is constant.
 class FileReader : public ModelReader
 {

generator/generator_tests/altitude_test.cpp

@@ -134,13 +134,13 @@ void TestAltitudes(DataSource const & dataSource, MwmSet::MwmId const & mwmId,
                    std::string const & mwmPath, bool hasAltitudeExpected,
                    AltitudeGetter & expectedAltitudes)
 {
-  AltitudeLoader loader(dataSource, mwmId);
+  AltitudeLoader loader(dataSource, mwmId, false /* twoThreadsReady */);
   TEST_EQUAL(loader.HasAltitudes(), hasAltitudeExpected, ());
 
   auto processor = [&expectedAltitudes, &loader](FeatureType & f, uint32_t const & id) {
     f.ParseGeometry(FeatureType::BEST_GEOMETRY);
     size_t const pointsCount = f.GetPointsCount();
-    geometry::Altitudes const altitudes = loader.GetAltitudes(id, pointsCount);
+    geometry::Altitudes const altitudes = loader.GetAltitudes(id, pointsCount, true /* isOutgoing */);
 
     if (!routing::IsRoad(feature::TypesHolder(f)))
     {

generator/generator_tests_support/routing_helpers.cpp

@@ -46,8 +46,9 @@ void ReEncodeOsmIdsToFeatureIdsMapping(std::string const & mappingContent, std::
 
 namespace routing
 {
-void TestGeometryLoader::Load(uint32_t featureId, RoadGeometry & road)
+void TestGeometryLoader::Load(uint32_t featureId, RoadGeometry & road, bool isOutgoing)
 {
+  CHECK(isOutgoing, ("TestGeometryLoader() is not ready for two threads feature parsing."));
   auto const it = m_roads.find(featureId);
   if (it == m_roads.cend())
     return;
@@ -98,7 +99,7 @@ std::unique_ptr<IndexGraph> BuildIndexGraph(std::unique_ptr<TestGeometryLoader>
                                             std::vector<Joint> const & joints)
 {
   auto graph = std::make_unique<IndexGraph>(std::make_shared<Geometry>(std::move(geometryLoader)),
-                                       estimator);
+                                            estimator);
   graph->Import(joints);
   return graph;
 }

generator/generator_tests_support/routing_helpers.hpp

@@ -31,7 +31,7 @@ class TestGeometryLoader : public GeometryLoader
 {
 public:
   // GeometryLoader overrides:
-  void Load(uint32_t featureId, routing::RoadGeometry & road) override;
+  void Load(uint32_t featureId, routing::RoadGeometry & road, bool isOutgoing) override;
 
   void AddRoad(uint32_t featureId, bool oneWay, float speed,
                routing::RoadGeometry::Points const & points);

generator/restriction_collector.cpp

@@ -129,8 +129,10 @@ bool RestrictionCollector::ParseRestrictions(std::string const & path)
 Joint::Id RestrictionCollector::GetFirstCommonJoint(uint32_t firstFeatureId,
                                                     uint32_t secondFeatureId) const
 {
-  uint32_t const firstLen = m_indexGraph->GetGeometry().GetRoad(firstFeatureId).GetPointsCount();
-  uint32_t const secondLen = m_indexGraph->GetGeometry().GetRoad(secondFeatureId).GetPointsCount();
+  uint32_t const firstLen =
+      m_indexGraph->GetGeometry().GetRoad(firstFeatureId, true /* isOutgoing */).GetPointsCount();
+  uint32_t const secondLen =
+      m_indexGraph->GetGeometry().GetRoad(secondFeatureId, true /* isOutgoing */).GetPointsCount();
 
   auto const firstRoad = m_indexGraph->GetRoad(firstFeatureId);
   auto const secondRoad = m_indexGraph->GetRoad(secondFeatureId);
@@ -155,7 +157,7 @@ bool RestrictionCollector::FeatureHasPointWithCoords(uint32_t featureId,
                                                      m2::PointD const & coords) const
 {
   CHECK(m_indexGraph, ());
-  auto const & roadGeometry = m_indexGraph->GetGeometry().GetRoad(featureId);
+  auto const & roadGeometry = m_indexGraph->GetGeometry().GetRoad(featureId, true /* isOutgoing */);
   uint32_t const pointsCount = roadGeometry.GetPointsCount();
   for (uint32_t i = 0; i < pointsCount; ++i)
   {
@@ -245,7 +247,7 @@ bool RestrictionCollector::CheckAndProcessUTurn(Restriction::Type & restrictionT
 
     uint32_t & featureId = featureIds.back();
 
-    auto const & road = m_indexGraph->GetGeometry().GetRoad(featureId);
+    auto const & road = m_indexGraph->GetGeometry().GetRoad(featureId, true /* isOutgoing */);
     // Can not do UTurn from feature to the same feature if it is one way.
     if (road.IsOneWay())
       return false;

generator/routing_index_generator.cpp

@@ -173,7 +173,7 @@ class IndexGraphWrapper final
   routing::Segment GetFinishSegment() const { return {}; }
   bool ConvertToReal(routing::Segment const & /* segment */) const { return false; }
   routing::RouteWeight HeuristicCostEstimate(routing::Segment const & /* from */,
-                                             ms::LatLon const & /* to */)
+                                             ms::LatLon const & /* to */, bool /* isOutgoing */)
   {
     CHECK(false, ("This method exists only for compatibility with IndexGraphStarterJoints"));
     return routing::GetAStarWeightZero<routing::RouteWeight>();
@@ -200,11 +200,12 @@ class IndexGraphWrapper final
   }
 
   routing::RouteWeight GetAStarWeightEpsilon() { return routing::RouteWeight(0.0); }
+  bool IsTwoThreadsReady() const { return false; }
   // @}
 
-  ms::LatLon const & GetPoint(routing::Segment const & s, bool forward)
+  ms::LatLon const & GetPoint(routing::Segment const & s, bool forward, bool isOutgoing)
   {
-    return m_graph.GetPoint(s, forward);
+    return m_graph.GetPoint(s, forward, isOutgoing);
   }
 
   void GetEdgesList(routing::Segment const & child, bool isOutgoing,
@@ -223,14 +224,14 @@ class IndexGraphWrapper final
                                *m_AStarParents);
   }
 
-  bool IsJoint(routing::Segment const & segment, bool fromStart) const
+  bool IsJoint(routing::Segment const & segment, bool fromStart, bool isOutgoing) const
   {
-    return IsJointOrEnd(segment, fromStart);
+    return IsJointOrEnd(segment, fromStart, isOutgoing);
   }
 
-  bool IsJointOrEnd(routing::Segment const & segment, bool fromStart) const
+  bool IsJointOrEnd(routing::Segment const & segment, bool fromStart, bool isOutgoing) const
   {
-    return m_graph.IsJointOrEnd(segment, fromStart);
+    return m_graph.IsJointOrEnd(segment, fromStart, isOutgoing);
   }
 
   template <typename Vertex>
@@ -256,7 +257,8 @@ class DijkstraWrapperJoints : public routing::IndexGraphStarterJoints<IndexGraph
   {
   }
 
-  Weight HeuristicCostEstimate(Vertex const & /* from */, Vertex const & /* to */) override
+  Weight HeuristicCostEstimate(Vertex const & /* from */, Vertex const & /* to */,
+                               bool /* isOutgoing */) override
   {
     return routing::GetAStarWeightZero<Weight>();
   }

indexer/altitude_loader.cpp

@@ -33,10 +33,13 @@ void LoadAndMap(size_t dataSize, ReaderSource<FilesContainerR::TReader> & src, T
 
 namespace feature
 {
-AltitudeLoader::AltitudeLoader(DataSource const & dataSource, MwmSet::MwmId const & mwmId)
+AltitudeLoader::AltitudeLoader(DataSource const & dataSource, MwmSet::MwmId const & mwmId,
+                               bool twoThreadsReady)
   : m_handle(dataSource.GetMwmHandleById(mwmId))
+  , m_handleBwd(twoThreadsReady ? make_unique<MwmSet::MwmHandle>(dataSource.GetMwmHandleById(mwmId))
+                                : nullptr)
 {
-  if (!m_handle.IsAlive())
+  if (!m_handle.IsAlive() || (IsTwoThreadsReady() && !m_handleBwd->IsAlive()))
     return;
 
   auto const & mwmValue = *m_handle.GetValue();
@@ -58,6 +61,12 @@ AltitudeLoader::AltitudeLoader(DataSource const & dataSource, MwmSet::MwmId cons
     LoadAndMap(m_header.GetAltitudeAvailabilitySize(), src, m_altitudeAvailability,
                m_altitudeAvailabilityRegion);
     LoadAndMap(m_header.GetFeatureTableSize(), src, m_featureTable, m_featureTableRegion);
+
+    if (IsTwoThreadsReady())
+    {
+      m_readerBwd = make_unique<FilesContainerR::TReader>(
+          m_handleBwd->GetValue()->m_cont.GetReader(ALTITUDES_FILE_TAG));
+    }
   }
   catch (Reader::OpenException const & e)
   {
@@ -71,24 +80,36 @@ bool AltitudeLoader::HasAltitudes() const
   return m_reader != nullptr && m_header.m_minAltitude != geometry::kInvalidAltitude;
 }
 
-geometry::Altitudes const & AltitudeLoader::GetAltitudes(uint32_t featureId, size_t pointCount)
+geometry::Altitudes const & AltitudeLoader::GetAltitudes(uint32_t featureId, size_t pointCount,
+                                                         bool isOutgoing)
+{
+  // Note. The backward reader and cache should not be used in case of calling GetAltitudes()
+  // method from one thread.
+  auto isForward = IsTwoThreadsReady() ? isOutgoing : true;
+  return GetAltitudes(featureId, pointCount, isForward ? m_reader : m_readerBwd,
+                      isForward ? m_cache : m_cacheBwd);
+}
+
+geometry::Altitudes const & AltitudeLoader::AltitudeLoader::GetAltitudes(
+    uint32_t featureId, size_t pointCount, unique_ptr<FilesContainerR::TReader> & reader,
+    map<uint32_t, geometry::Altitudes> & cache) const
 {
   if (!HasAltitudes())
   {
     // There's no altitude section in mwm.
-    return m_cache
+    return cache
         .insert(
             make_pair(featureId, geometry::Altitudes(pointCount, geometry::kDefaultAltitudeMeters)))
         .first->second;
   }
 
-  auto const it = m_cache.find(featureId);
-  if (it != m_cache.end())
+  auto const it = cache.find(featureId);
+  if (it != cache.end())
     return it->second;
 
   if (!m_altitudeAvailability[featureId])
   {
-    return m_cache
+    return cache
         .insert(make_pair(featureId, geometry::Altitudes(pointCount, m_header.m_minAltitude)))
         .first->second;
   }
@@ -99,35 +120,35 @@ geometry::Altitudes const & AltitudeLoader::GetAltitudes(uint32_t featureId, siz
   CHECK_LESS_OR_EQUAL(offset, m_featureTable.size(), ("Feature Id", featureId, "of", m_countryFileName));
 
   uint64_t const altitudeInfoOffsetInSection = m_header.m_altitudesOffset + offset;
-  CHECK_LESS(altitudeInfoOffsetInSection, m_reader->Size(), ("Feature Id", featureId, "of", m_countryFileName));
+  CHECK_LESS(altitudeInfoOffsetInSection, reader->Size(), ("Feature Id", featureId, "of", m_countryFileName));
 
   try
   {
     Altitudes altitudes;
-    ReaderSource<FilesContainerR::TReader> src(*m_reader);
+    ReaderSource<FilesContainerR::TReader> src(*reader);
     src.Skip(altitudeInfoOffsetInSection);
     bool const isDeserialized = altitudes.Deserialize(m_header.m_minAltitude, pointCount,
                                                       m_countryFileName, featureId,  src);
 
     bool const allValid =
         isDeserialized &&
-        none_of(altitudes.m_altitudes.begin(), altitudes.m_altitudes.end(),
-                [](geometry::Altitude a) { return a == geometry::kInvalidAltitude; });
+            none_of(altitudes.m_altitudes.begin(), altitudes.m_altitudes.end(),
+                    [](geometry::Altitude a) { return a == geometry::kInvalidAltitude; });
     if (!allValid)
     {
-      LOG(LERROR, ("Only a part point of a feature has a valid altitdue. Altitudes: ", altitudes.m_altitudes,
-                   ". Feature Id", featureId, "of", m_countryFileName));
-      return m_cache
+      LOG(LERROR, ("Only a part point of a feature has a valid altitude. Altitudes: ", altitudes.m_altitudes,
+          ". Feature Id", featureId, "of", m_countryFileName));
+      return cache
           .insert(make_pair(featureId, geometry::Altitudes(pointCount, m_header.m_minAltitude)))
           .first->second;
     }
 
-    return m_cache.insert(make_pair(featureId, move(altitudes.m_altitudes))).first->second;
+    return cache.insert(make_pair(featureId, move(altitudes.m_altitudes))).first->second;
   }
   catch (Reader::OpenException const & e)
   {
     LOG(LERROR, ("Feature Id", featureId, "of", m_countryFileName, ". Error while getting altitude data:", e.Msg()));
-    return m_cache
+    return cache
         .insert(make_pair(featureId, geometry::Altitudes(pointCount, m_header.m_minAltitude)))
         .first->second;
   }

indexer/altitude_loader.hpp

@@ -25,27 +25,43 @@ namespace feature
 class AltitudeLoader
 {
 public:
-  AltitudeLoader(DataSource const & dataSource, MwmSet::MwmId const & mwmId);
+  AltitudeLoader(DataSource const & dataSource, MwmSet::MwmId const & mwmId,
+                 bool twoThreadsReady);
+
+  bool HasAltitudes() const;
 
   /// \returns altitude of feature with |featureId|. All items of the returned vector are valid
   /// or the returned vector is empty.
-  geometry::Altitudes const & GetAltitudes(uint32_t featureId, size_t pointCount);
+  geometry::Altitudes const & GetAltitudes(uint32_t featureId, size_t pointCount, bool isOutgoing);
 
-  bool HasAltitudes() const;
+  bool IsTwoThreadsReady() const { return m_handleBwd != nullptr; }
 
-  void ClearCache() { m_cache.clear(); }
+  void ClearCache(bool isOutgoing) { isOutgoing ? m_cache.clear() : m_cacheBwd.clear(); }
 
 private:
+  geometry::Altitudes const & GetAltitudes(
+      uint32_t featureId, size_t pointCount, std::unique_ptr<FilesContainerR::TReader> & reader,
+      std::map<uint32_t, geometry::Altitudes> & cache) const;
+
   std::unique_ptr<CopiedMemoryRegion> m_altitudeAvailabilityRegion;
   std::unique_ptr<CopiedMemoryRegion> m_featureTableRegion;
 
   succinct::rs_bit_vector m_altitudeAvailability;
   succinct::elias_fano m_featureTable;
 
+  // Note. If |twoThreadsReady| parameter of constructor is true method GetAltitudes() may be called
+  // from two different threads. In that case all calls of GetAltitudes() with |isOutgoing| == true
+  // should be done from one thread and from another one of |isOutgoing| == true.
+  // To call GetAltitudes() from two threads without locks it's necessary to have
+  // two caches for reading from disk (in m_handle/m_reader and m_handleBwd/m_readerBwd)
+  // and two caches for keeping read altitudes (m_cache and m_cacheBwd).
   std::unique_ptr<FilesContainerR::TReader> m_reader;
+  std::unique_ptr<FilesContainerR::TReader> m_readerBwd;
   std::map<uint32_t, geometry::Altitudes> m_cache;
+  std::map<uint32_t, geometry::Altitudes> m_cacheBwd;
   AltitudeHeader m_header;
   std::string m_countryFileName;
   MwmSet::MwmHandle m_handle;
+  std::unique_ptr<MwmSet::MwmHandle> m_handleBwd;
 };
 }  // namespace feature

routing/async_router.cpp

@@ -398,7 +398,7 @@ void AsyncRouter::CalculateRoute()
       absentFetcher->GenerateRequest(checkpoints);
 
     // Run basic request.
-    code = router->CalculateRoute(checkpoints, startDirection, adjustToPrevRoute,
+    code = router->CalculateRoute(checkpoints, startDirection, true /* useTwoThreads */, adjustToPrevRoute,
                                   delegateProxy->GetDelegate(), *route);
     router->SetGuides({});
     elapsedSec = timer.ElapsedSeconds(); // routing time