All good, but needs unpacking of start and end

Contractor/EdgeBasedGraphFactory.cpp

@@ -306,7 +306,7 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
                 m_node_info_list[v].lat/COORDINATE_PRECISION << "," << m_node_info_list[v].lon/COORDINATE_PRECISION;
     }
     BOOST_ASSERT( forward_data.edgeBasedNodeID != std::numeric_limits<unsigned>::max() );
-    SimpleLogger().Write() << "e1: " << e1 << "u: " << u << ", v: " << v;
+    // SimpleLogger().Write() << "e1: " << e1 << "u: " << u << ", v: " << v;
 
     if( forward_data.ignore_in_grid ) {
         // SimpleLogger().Write(logDEBUG) << "skipped edge at " << m_node_info_list[u].lat << "," <<
@@ -324,7 +324,7 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
     if ( e2 == m_node_based_graph->EndEdges(v) ) {
         SimpleLogger().Write(logDEBUG) << "Did not find edge (" << v << "," << u << ")";
     }
-#endif NDEBUG
+#endif
     BOOST_ASSERT( e2 != std::numeric_limits<unsigned>::max() );
     BOOST_ASSERT( e2 < m_node_based_graph->EndEdges(v) );
     const EdgeData & reverse_data = m_node_based_graph->GetEdgeData(e2);
@@ -470,6 +470,7 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
                     reverse_dist_prefix_sum[geometry_size-1-i]
                 )
             );
+            BOOST_ASSERT( m_edge_based_node_list.back().IsCompressed() );
             first_node_of_edge = last_coordinate_id;
         }
         //TODO: Manually reconstruct last edge.
@@ -518,6 +519,7 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
                 0
             )
         );
+        BOOST_ASSERT( !m_edge_based_node_list.back().IsCompressed() );
     }
 }
 
@@ -742,7 +744,7 @@ void EdgeBasedGraphFactory::Run(
             if( u > v ) {
                 continue;
             }
-            BOOST_ASSERT( u < v );
+            // BOOST_ASSERT( u < v );
             BOOST_ASSERT( edge_data.type != SHRT_MAX );
 
             //Note: edges that end on barrier nodes or on a turn restriction

DataStructures/Coordinate.cpp

@@ -26,9 +26,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include <osrm/Coordinate.h>
+#include "../Util/SimpleLogger.h"
 #include "../Util/StringUtil.h"
 
 #include <boost/assert.hpp>
+
+#include <bitset>
+#include <iostream>
 #include <limits>
 
 FixedPointCoordinate::FixedPointCoordinate()
@@ -39,7 +43,16 @@ FixedPointCoordinate::FixedPointCoordinate()
 FixedPointCoordinate::FixedPointCoordinate(int lat, int lon)
  :  lat(lat),
     lon(lon)
-{ }
+{
+    if(0 != (lat >> 30)) {
+        std::bitset<32> y(lat);
+        SimpleLogger().Write(logDEBUG) << "broken lat: " << lat << ", bits: " << y;
+    }
+    if(0 != (lon >> 30)) {
+        std::bitset<32> x(lon);
+        SimpleLogger().Write(logDEBUG) << "broken lon: " << lon << ", bits: " << x;
+    }
+}
 
 void FixedPointCoordinate::Reset() {
     lat = std::numeric_limits<int>::min();
@@ -159,3 +172,7 @@ void FixedPointCoordinate::convertInternalReversedCoordinateToString(
     convertInternalLatLonToString(coord.lon, tmp);
     output += tmp;
 }
+
+void FixedPointCoordinate::Output(std::ostream & out) const {//, FixedPointCoordinate & c) {
+    out << "(" << lat << "," << lon << ")";
+}

DataStructures/EdgeBasedNode.h

@@ -23,8 +23,8 @@ struct EdgeBasedNode {
         name_id(std::numeric_limits<unsigned>::max()),
         forward_weight(std::numeric_limits<int>::max() >> 1),
         reverse_weight(std::numeric_limits<int>::max() >> 1),
-        forward_offset_to_edge_based_node(0),
+        forward_offset(0),
-        reverse_offset_to_edge_based_node(0)
+        reverse_offset(0)
     { }
 
     EdgeBasedNode(
@@ -38,8 +38,8 @@ struct EdgeBasedNode {
         NodeID name_id,
         int forward_weight,
         int reverse_weight,
-        int forward_offset_to_edge_based_node,
+        int forward_offset,
-        int reverse_offset_to_edge_based_node
+        int reverse_offset
     ) :
         forward_edge_based_node_id(forward_edge_based_node_id),
         reverse_edge_based_node_id(reverse_edge_based_node_id),
@@ -51,8 +51,8 @@ struct EdgeBasedNode {
         name_id(name_id),
         forward_weight(forward_weight),
         reverse_weight(reverse_weight),
-        forward_offset_to_edge_based_node(forward_offset_to_edge_based_node),
+        forward_offset(forward_offset),
-        reverse_offset_to_edge_based_node(reverse_offset_to_edge_based_node)
+        reverse_offset(reverse_offset)
     { }
 
     // Computes:

DataStructures/PhantomNodes.h

@@ -33,11 +33,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 struct PhantomNode {
     PhantomNode() :
-        forward_node_id(std::numeric_limits<unsigned>::max()),
+        forward_node_id( SPECIAL_NODEID ),
-        reverse_node_id(std::numeric_limits<unsigned>::max()),
+        reverse_node_id( SPECIAL_NODEID ),
-        name_id(std::numeric_limits<unsigned>::max()),
+        name_id( std::numeric_limits<unsigned>::max() ),
-        forward_weight(INT_MAX),
+        forward_weight(INVALID_EDGE_WEIGHT),
-        reverse_weight(INT_MAX),
+        reverse_weight(INVALID_EDGE_WEIGHT),
+        forward_offset(0),
+        reverse_offset(0),
         ratio(0.)
     { }
 
@@ -46,25 +48,44 @@ struct PhantomNode {
     unsigned name_id;
     int forward_weight;
     int reverse_weight;
+    int forward_offset;
+    int reverse_offset;
     double ratio;
     FixedPointCoordinate location;
 
+    int GetForwardWeightPlusOffset() const {
+        return forward_weight + forward_offset;
+    }
+
+    int GetReverseWeightPlusOffset() const {
+        return reverse_weight + reverse_offset;
+    }
+
     void Reset() {
-        forward_node_id = std::numeric_limits<unsigned>::max();
+        forward_node_id = SPECIAL_NODEID;
-        name_id = std::numeric_limits<unsigned>::max();
+        name_id = SPECIAL_NODEID;
-        forward_weight = INT_MAX;
+        forward_weight = INVALID_EDGE_WEIGHT;
-        reverse_weight = INT_MAX;
+        reverse_weight = INVALID_EDGE_WEIGHT;
+        forward_offset = 0;
+        reverse_offset = 0;
         ratio = 0.;
         location.Reset();
     }
+
     bool isBidirected() const {
-        return forward_node_id != UINT_MAX && reverse_node_id != UINT_MAX;
+        return ( forward_node_id != SPECIAL_NODEID ) &&
+               ( reverse_node_id != SPECIAL_NODEID );
     }
+
+    bool IsCompressed() const {
+        return (forward_offset != 0) || (reverse_offset != 0);
+    }
+
     bool isValid(const unsigned numberOfNodes) const {
         return
             location.isValid() &&
             ( (forward_node_id < numberOfNodes) || (reverse_node_id < numberOfNodes) ) &&
-            ( (forward_weight != INT_MAX) || (reverse_weight != INT_MAX) ) &&
+            ( (forward_weight != INVALID_EDGE_WEIGHT) || (reverse_weight != INVALID_EDGE_WEIGHT) ) &&
             (ratio >= 0.) &&
             (ratio <= 1.) &&
             (name_id != std::numeric_limits<unsigned>::max());
@@ -88,7 +109,7 @@ struct PhantomNodes {
     }
 
     bool AtLeastOnePhantomNodeIsUINTMAX() const {
-        return !(startPhantom.forward_node_id == std::numeric_limits<unsigned>::max() || targetPhantom.forward_node_id == std::numeric_limits<unsigned>::max());
+        return !(startPhantom.forward_node_id == SPECIAL_NODEID || targetPhantom.forward_node_id == SPECIAL_NODEID);
     }
 
     bool PhantomNodesHaveEqualLocation() const {

DataStructures/SharedMemoryVectorWrapper.h

@@ -115,6 +115,8 @@ public:
 
     std::size_t size() const { return m_size; }
 
+    bool empty() const { return 0 == size(); }
+
     DataT & operator[](const unsigned index) {
         BOOST_ASSERT_MSG(index < m_size, "invalid size");
         return m_ptr[index];

DataStructures/StaticGraph.h

@@ -115,6 +115,7 @@ public:
                                 u << "," << data.id << "," << v << ")";
 
                         data.shortcut = false;
+                        BOOST_ASSERT(false);
                     }
                     eid2 = FindEdgeInEitherDirection(data.id, v);
                     if(eid2 == UINT_MAX) {
@@ -122,6 +123,7 @@ public:
                             "cannot find second segment of edge (" <<
                                 u << "," << data.id << "," << v << ")";
                         data.shortcut = false;
+                        BOOST_ASSERT(false);
                     }
                 }
             }
@@ -165,7 +167,7 @@ public:
     //searches for a specific edge
     EdgeIterator FindEdge( const NodeIterator from, const NodeIterator to ) const {
         EdgeIterator smallestEdge = SPECIAL_EDGEID;
-        EdgeWeight smallestWeight = UINT_MAX;
+        EdgeWeight smallestWeight = INVALID_EDGE_WEIGHT;
         for ( EdgeIterator edge = BeginEdges( from ); edge < EndEdges(from); edge++ ) {
             const NodeID target = GetTarget(edge);
             const EdgeWeight weight = GetEdgeData(edge).distance;

DataStructures/StaticRTree.h

@@ -51,6 +51,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <boost/algorithm/minmax_element.hpp>
 #include <boost/range/algorithm_ext/erase.hpp>
 #include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
 #include <boost/thread.hpp>
 #include <boost/type_traits.hpp>
 
@@ -68,7 +69,7 @@ const static uint32_t RTREE_LEAF_NODE_SIZE = 1170;
 
 static boost::thread_specific_ptr<boost::filesystem::ifstream> thread_local_rtree_stream;
 
-template<class DataT, bool UseSharedMemory = false>
+template<class DataT, class CoordinateListT = std::vector<FixedPointCoordinate>, bool UseSharedMemory = false>
 class StaticRTree : boost::noncopyable {
 public:
     struct RectangleInt2D {
@@ -289,8 +290,9 @@ private:
 
     typename ShM<TreeNode, UseSharedMemory>::vector m_search_tree;
     uint64_t m_element_count;
-
     const std::string m_leaf_node_filename;
+    boost::shared_ptr<CoordinateListT> m_coordinate_list;
+
 public:
     //Construct a packed Hilbert-R-Tree with Kamel-Faloutsos algorithm [1]
     explicit StaticRTree(
@@ -426,9 +428,11 @@ public:
     //Read-only operation for queries
     explicit StaticRTree(
             const boost::filesystem::path & node_file,
-            const boost::filesystem::path & leaf_file
+            const boost::filesystem::path & leaf_file,
-    ) : m_leaf_node_filename(leaf_file.string()) {
+            const boost::shared_ptr<CoordinateListT> coordinate_list
+    ) : m_leaf_node_filename( leaf_file.string() ) {
         //open tree node file and load into RAM.
+        m_coordinate_list = coordinate_list;
 
         if ( !boost::filesystem::exists( node_file ) ) {
             throw OSRMException("ram index file does not exist");
@@ -463,9 +467,11 @@ public:
     explicit StaticRTree(
             TreeNode * tree_node_ptr,
             const uint32_t number_of_nodes,
-            const boost::filesystem::path & leaf_file
+            const boost::filesystem::path & leaf_file,
+            boost::shared_ptr<CoordinateListT> coordinate_list
     ) : m_search_tree(tree_node_ptr, number_of_nodes),
-        m_leaf_node_filename(leaf_file.string())
+        m_leaf_node_filename(leaf_file.string()),
+        m_coordinate_list(coordinate_list)
     {
         //open leaf node file and store thread specific pointer
         if ( !boost::filesystem::exists( leaf_file ) ) {
@@ -659,6 +665,8 @@ public:
                             result_phantom_node.name_id = current_edge.name_id;
                             result_phantom_node.forward_weight = current_edge.forward_weight;
                             result_phantom_node.reverse_weight = current_edge.reverse_weight;
+                            result_phantom_node.forward_offset = current_edge.forward_offset;
+                            result_phantom_node.reverse_offset = current_edge.reverse_offset;
                             result_phantom_node.location = nearest;
                             current_start_coordinate.lat = current_edge.lat1;
                             current_start_coordinate.lon = current_edge.lon1;

Descriptors/DescriptionFactory.cpp

@@ -139,5 +139,9 @@ void DescriptionFactory::BuildRouteSummary(
 ) {
     summary.startName = start_phantom.name_id;
     summary.destName = target_phantom.name_id;
+
+    SimpleLogger().Write(logDEBUG) << "phantom start name: " << start_phantom.name_id << ", path: " << pathDescription.front().name_id;
+    SimpleLogger().Write(logDEBUG) << "phantom target name: " << target_phantom.name_id << ", path: " << pathDescription.back().name_id;
+
     summary.BuildDurationAndLengthStrings(distance, time);
 }

Include/osrm/Coordinate.h

@@ -28,7 +28,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef FIXED_POINT_COORDINATE_H_
 #define FIXED_POINT_COORDINATE_H_
 
-#include <iostream>
+#include <iosfwd>   //for std::ostream
 
 static const double COORDINATE_PRECISION = 1000000.;
 
@@ -37,7 +37,7 @@ struct FixedPointCoordinate {
     int lon;
 
     FixedPointCoordinate();
-    explicit FixedPointCoordinate (int lat, int lon);
+    explicit FixedPointCoordinate( int lat, int lon);
     void Reset();
     bool isSet() const;
     bool isValid() const;
@@ -74,11 +74,13 @@ struct FixedPointCoordinate {
         const FixedPointCoordinate & coord,
         std::string & output
     );
+
+    void Output(std::ostream & out) const;
 };
 
-inline std::ostream & operator<<(std::ostream & out, const FixedPointCoordinate & c){
+inline std::ostream& operator<<(std::ostream& o, FixedPointCoordinate const & c){
-    out << "(" << c.lat << "," << c.lon << ")";
+    c.Output(o);
-    return out;
+    return o;
 }
 
 #endif /* FIXED_POINT_COORDINATE_H_ */

RoutingAlgorithms/AlternativePathRouting.h

@@ -113,26 +113,26 @@ public:
         NodeID middle_node = UINT_MAX;
         forward_heap1.Insert(
             phantom_node_pair.startPhantom.forward_node_id,
-            -phantom_node_pair.startPhantom.forward_weight,
+            -phantom_node_pair.startPhantom.GetForwardWeightPlusOffset(),
             phantom_node_pair.startPhantom.forward_node_id
         );
         if(phantom_node_pair.startPhantom.isBidirected() ) {
             forward_heap1.Insert(
                 phantom_node_pair.startPhantom.reverse_node_id,
-                -phantom_node_pair.startPhantom.reverse_weight,
+                -phantom_node_pair.startPhantom.GetReverseWeightPlusOffset(),
                 phantom_node_pair.startPhantom.reverse_node_id
             );
         }
 
         reverse_heap1.Insert(
             phantom_node_pair.targetPhantom.forward_node_id,
-            phantom_node_pair.targetPhantom.forward_weight,
+            phantom_node_pair.targetPhantom.GetForwardWeightPlusOffset(),
             phantom_node_pair.targetPhantom.forward_node_id
         );
         if(phantom_node_pair.targetPhantom.isBidirected() ) {
         	reverse_heap1.Insert(
                 phantom_node_pair.targetPhantom.reverse_node_id,
-                phantom_node_pair.targetPhantom.reverse_weight,
+                phantom_node_pair.targetPhantom.GetReverseWeightPlusOffset(),
                 phantom_node_pair.targetPhantom.reverse_node_id
             );
         }

RoutingAlgorithms/BasicRoutingInterface.h

@@ -202,7 +202,8 @@ public:
                 BOOST_ASSERT_MSG(!ed.shortcut, "original edge flagged as shortcut");
                 unsigned name_index = facade->GetNameIndexFromEdgeID(ed.id);
                 TurnInstruction turn_instruction = facade->GetTurnInstructionForEdgeID(ed.id);
-                //TODO: reorder to always iterate over a result vector
+
+                //TODO: refactor to iterate over a result vector in both cases
                 if ( !facade->EdgeIsCompressed(ed.id) ){
                     SimpleLogger().Write() << "Edge " << ed.id << " is not compressed, smaller_edge_id: " << smaller_edge_id;
                     BOOST_ASSERT( !facade->EdgeIsCompressed(ed.id) );
@@ -218,10 +219,17 @@ public:
                     SimpleLogger().Write() << "Edge " << ed.id << " is compressed";
                     std::vector<unsigned> id_vector;
                     facade->GetUncompressedGeometry(ed.id, id_vector);
-                    BOOST_FOREACH(const unsigned coordinate_id, id_vector){
+                    if( unpacked_path.empty() ) {
-                        //TODO: unpack entire geometry
+                        SimpleLogger().Write(logDEBUG) << "first segment(" << facade->GetEscapedNameForNameID(ed.id) << ") is packed";
-                        //TODO: set distance to 0, see if works
 
+                    }
+
+                    // if( recursion_stack.empty() ) {
+                    //     SimpleLogger().Write(logDEBUG) << "last segment is packed";
+                    // }
+
+                    BOOST_FOREACH(const unsigned coordinate_id, id_vector){
+                        //TODO: skip if first edge is compressed until start point is reached
                         unpacked_path.push_back(
                             PathData(
                                 coordinate_id,
@@ -238,6 +246,8 @@ public:
 
             }
         }
+
+
     }
 
     inline void UnpackEdge(

RoutingAlgorithms/ShortestPathRouting.h

@@ -109,12 +109,12 @@ public:
 
                 forward_heap1.Insert(
                     phantom_node_pair.startPhantom.forward_node_id,
-                    distance1-phantom_node_pair.startPhantom.forward_weight,
+                    distance1-phantom_node_pair.startPhantom.GetForwardWeightPlusOffset(),
                     phantom_node_pair.startPhantom.forward_node_id
                 );
                 forward_heap2.Insert(
                     phantom_node_pair.startPhantom.forward_node_id,
-                    distance1-phantom_node_pair.startPhantom.forward_weight,
+                    distance1-phantom_node_pair.startPhantom.GetForwardWeightPlusOffset(),
                     phantom_node_pair.startPhantom.forward_node_id
                 );
             }
@@ -122,12 +122,12 @@ public:
                 BOOST_ASSERT(phantom_node_pair.startPhantom.reverse_node_id != UINT_MAX);
                 forward_heap1.Insert(
                     phantom_node_pair.startPhantom.reverse_node_id,
-                    distance2-phantom_node_pair.startPhantom.reverse_weight,
+                    distance2-phantom_node_pair.startPhantom.GetReverseWeightPlusOffset(),
                     phantom_node_pair.startPhantom.reverse_node_id
                 );
                 forward_heap2.Insert(
                     phantom_node_pair.startPhantom.reverse_node_id,
-                    distance2-phantom_node_pair.startPhantom.reverse_weight,
+                    distance2-phantom_node_pair.startPhantom.GetReverseWeightPlusOffset(),
                     phantom_node_pair.startPhantom.reverse_node_id
                 );
             }
@@ -135,7 +135,7 @@ public:
             //insert new backward nodes into backward heap, unadjusted.
             reverse_heap1.Insert(
                 phantom_node_pair.targetPhantom.forward_node_id,
-                phantom_node_pair.targetPhantom.forward_weight,
+                phantom_node_pair.targetPhantom.GetForwardWeightPlusOffset(),
                 phantom_node_pair.targetPhantom.forward_node_id
             );
             BOOST_ASSERT(phantom_node_pair.targetPhantom.forward_node_id != UINT_MAX);
@@ -144,7 +144,7 @@ public:
                 BOOST_ASSERT(phantom_node_pair.startPhantom.forward_node_id != UINT_MAX);
                 reverse_heap2.Insert(
                     phantom_node_pair.targetPhantom.reverse_node_id,
-                    phantom_node_pair.targetPhantom.reverse_weight,
+                    phantom_node_pair.targetPhantom.GetReverseWeightPlusOffset(),
                     phantom_node_pair.targetPhantom.reverse_node_id
                 );
             }

Server/DataStructures/InternalDataFacade.h

@@ -45,6 +45,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <osrm/Coordinate.h>
 
+#include <boost/make_shared.hpp>
+#include <boost/shared_ptr.hpp>
+
 template<class EdgeDataT>
 class InternalDataFacade : public BaseDataFacade<EdgeDataT> {
 
@@ -61,7 +64,7 @@ private:
     QueryGraph                             * m_query_graph;
     std::string                              m_timestamp;
 
-    ShM<FixedPointCoordinate, false>::vector m_coordinate_list;
+    boost::shared_ptr<ShM<FixedPointCoordinate, false>::vector> m_coordinate_list;
     ShM<NodeID, false>::vector               m_via_node_list;
     ShM<unsigned, false>::vector             m_name_ID_list;
     ShM<TurnInstruction, false>::vector      m_turn_instruction_list;
@@ -71,7 +74,13 @@ private:
     ShM<unsigned, false>::vector             m_compressed_geometry_indices;
     ShM<unsigned, false>::vector             m_compressed_geometries;
 
-    StaticRTree<RTreeLeaf, false>          * m_static_rtree;
+    boost::shared_ptr<
+        StaticRTree<
+            RTreeLeaf,
+            ShM<FixedPointCoordinate, false>::vector,
+            false
+        >
+    > m_static_rtree;
 
 
     void LoadTimestamp(const boost::filesystem::path & timestamp_path) {
@@ -131,15 +140,16 @@ private:
             (char *)&number_of_coordinates,
             sizeof(unsigned)
         );
-        m_coordinate_list.resize(number_of_coordinates);
+        m_coordinate_list = boost::make_shared<std::vector<FixedPointCoordinate> >(number_of_coordinates);
         for(unsigned i = 0; i < number_of_coordinates; ++i) {
             nodes_input_stream.read((char *)&current_node, sizeof(NodeInfo));
-            m_coordinate_list[i] = FixedPointCoordinate(
+            m_coordinate_list->at(i) = FixedPointCoordinate(
                     current_node.lat,
                     current_node.lon
             );
+            BOOST_ASSERT( ( m_coordinate_list->at(i).lat >> 30) == 0 );
+            BOOST_ASSERT( ( m_coordinate_list->at(i).lon >> 30) == 0 );
         }
-        std::vector<FixedPointCoordinate>(m_coordinate_list).swap(m_coordinate_list);
         nodes_input_stream.close();
 
         SimpleLogger().Write(logDEBUG) << "Loading edge data";
@@ -221,9 +231,15 @@ private:
         const boost::filesystem::path & ram_index_path,
         const boost::filesystem::path & file_index_path
     ) {
-        m_static_rtree = new StaticRTree<RTreeLeaf>(
+        BOOST_ASSERT_MSG(
+            !m_coordinate_list->empty(),
+            "coordinates must be loaded before r-tree"
+        );
+
+        m_static_rtree = boost::make_shared<StaticRTree<RTreeLeaf> >(
             ram_index_path,
-            file_index_path
+            file_index_path,
+            m_coordinate_list
         );
     }
 
@@ -238,6 +254,8 @@ private:
         BOOST_ASSERT_MSG(0 != number_of_names, "name file broken");
         BOOST_ASSERT_MSG(0 != number_of_chars, "name file broken");
 
+        SimpleLogger().Write(logDEBUG) << "no. of names: " << number_of_names;
+
         m_name_begin_indices.resize(number_of_names);
         name_stream.read(
             (char*)&m_name_begin_indices[0],
@@ -258,7 +276,7 @@ private:
 public:
     ~InternalDataFacade() {
         delete m_query_graph;
-        delete m_static_rtree;
+        m_static_rtree.reset();
     }
 
     explicit InternalDataFacade( const ServerPaths & server_paths ) {
@@ -379,7 +397,7 @@ public:
         const unsigned id
     ) const {
         // const unsigned coordinate_index = m_via_node_list.at(id);
-        return m_coordinate_list.at(id);
+        return m_coordinate_list->at(id);
     };
 
     bool EdgeIsCompressed( const unsigned id ) const {
@@ -471,7 +489,7 @@ public:
             unsigned coordinate_id = m_compressed_geometries[geometry_index];
             // uncomment to use compressed geometry
             result_nodes.push_back( coordinate_id );
-            SimpleLogger().Write() << "coordinate " << coordinate_id << " at " << m_coordinate_list.at(coordinate_id);
+            SimpleLogger().Write() << "coordinate " << coordinate_id << " at " << m_coordinate_list->at(coordinate_id);
         }
     }
 

Server/DataStructures/SharedDataFacade.h

@@ -30,9 +30,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 //implements all data storage when shared memory _IS_ used
 
-#include <boost/make_shared.hpp>
-#include <boost/shared_ptr.hpp>
-
 #include "BaseDataFacade.h"
 #include "SharedDataType.h"
 
@@ -42,6 +39,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../../Util/ProgramOptions.h"
 #include "../../Util/SimpleLogger.h"
 
+#include <boost/make_shared.hpp>
+#include <boost/shared_ptr.hpp>
+
 #include <algorithm>
 
 template<class EdgeDataT>
@@ -55,7 +55,7 @@ private:
     typedef typename StaticGraph<EdgeData, true>::_StrEdge  GraphEdge;
     typedef typename QueryGraph::InputEdge                  InputEdge;
     typedef typename super::RTreeLeaf                       RTreeLeaf;
-    typedef typename StaticRTree<RTreeLeaf, true>::TreeNode RTreeNode;
+    typedef typename StaticRTree<RTreeLeaf, ShM<FixedPointCoordinate, true>::vector, true>::TreeNode RTreeNode;
 
     SharedDataLayout    * data_layout;
     char                * shared_memory;
@@ -72,13 +72,21 @@ private:
     boost::shared_ptr<SharedMemory>         m_large_memory;
     std::string                             m_timestamp;
 
-    ShM<FixedPointCoordinate, true>::vector m_coordinate_list;
+    boost::shared_ptr<
+        ShM<FixedPointCoordinate, true>::vector
+    > m_coordinate_list;
     ShM<NodeID, true>::vector               m_via_node_list;
     ShM<unsigned, true>::vector             m_name_ID_list;
     ShM<TurnInstruction, true>::vector      m_turn_instruction_list;
     ShM<char, true>::vector                 m_names_char_list;
     ShM<unsigned, true>::vector             m_name_begin_indices;
-    boost::shared_ptr<StaticRTree<RTreeLeaf, true> > m_static_rtree;
+    boost::shared_ptr<
+        StaticRTree<
+            RTreeLeaf,
+            ShM<FixedPointCoordinate, true>::vector,
+            true
+        >
+    > m_static_rtree;
 
     // SharedDataFacade() { }
 
@@ -95,13 +103,19 @@ private:
     void LoadRTree(
         const boost::filesystem::path & file_index_path
     ) {
+        BOOST_ASSERT_MSG(
+            !m_coordinate_list->empty(),
+            "coordinates must be loaded before r-tree"
+        );
+
         RTreeNode * tree_ptr = (RTreeNode *)(
             shared_memory + data_layout->GetRSearchTreeOffset()
         );
-        m_static_rtree = boost::make_shared<StaticRTree<RTreeLeaf, true> >(
+        m_static_rtree = boost::make_shared<StaticRTree<RTreeLeaf, ShM<FixedPointCoordinate, true>::vector, true> >(
             tree_ptr,
             data_layout->r_search_tree_size,
-            file_index_path
+            file_index_path,
+            m_coordinate_list
         );
     }
 
@@ -134,11 +148,10 @@ private:
         FixedPointCoordinate * coordinate_list_ptr = (FixedPointCoordinate *)(
             shared_memory + data_layout->GetCoordinateListOffset()
         );
-        typename ShM<FixedPointCoordinate, true>::vector coordinate_list(
+        m_coordinate_list = boost::make_shared<ShM<FixedPointCoordinate, true>::vector> (
                 coordinate_list_ptr,
                 data_layout->coordinate_list_size
         );
-        m_coordinate_list.swap( coordinate_list );
 
         TurnInstruction * turn_instruction_list_ptr = (TurnInstruction *)(
             shared_memory + data_layout->GetTurnInstructionListOffset()
@@ -309,7 +322,7 @@ public:
         const unsigned id
     ) const {
         // const NodeID node = m_via_node_list.at(id);
-        return m_coordinate_list.at(id);
+        return m_coordinate_list->at(id);
     };
 
     virtual bool EdgeIsCompressed( const unsigned id ) const {

Server/DataStructures/SharedDataType.h

@@ -43,7 +43,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <boost/integer.hpp>
 
 typedef BaseDataFacade<QueryEdge::EdgeData>::RTreeLeaf RTreeLeaf;
-typedef StaticRTree<RTreeLeaf, true>::TreeNode RTreeNode;
+typedef StaticRTree<RTreeLeaf, ShM<FixedPointCoordinate, true>::vector, true>::TreeNode RTreeNode;
 typedef StaticGraph<QueryEdge::EdgeData> QueryGraph;
 
 struct SharedDataLayout {