Hi
Craig regarding to your question about which events I have to consider in
my scenario...I can have events that tell me a road is blocked...so I need
to present to the customer a different shortestpath in order to arrive to
destination....so in this case it's like if costs relationships between
nodes change and this mean that potentially the minimum path can
change.....as far as I know if there are changes on the minimum path, the
contracted graph should be re-generated
Anyway....from what I saw in the theory, Dijkstra and A* should have these
low performances when there are around 1 Million of nodes and several
million of relationships; in our case we have around 570000 nodes and
660000 relationships....I really can't figure why this behaviour....
Angelo
Il giorno lunedì 19 maggio 2014 19:41:05 UTC+2, Angelo Immediata ha scritto:
>
> Hi there
>
> We are using Neo4j 2.0.3 in order to build a routing system. We are using
> the classical A Start implementation, tough we saw that there is a
> TraversalAstar implementation but it seems to be in experimental status yet.
>
> By the way, we read an OSM file and create our graph; actually we have
> around 1 million of points. around 2 million of relationships and around 5
> million of properites on relationships; by reading neo4j documentation it
> seems to me that this DB dimension is really small and it's really well
> handled by neo4j but in my case this doesn't seem to be real (maybe I'm
> missing something)
>
> Actually our node creation code is the following one:
>
> private long createGraphNode(OsmNodeWrapper osmNodeWrapper)
> {
> try
> {
> Map<String, Object> nodeProps = new HashMap<String, Object>();
> double x = osmNodeWrapper.getLongitude();
> double y = osmNodeWrapper.getLatitude();
> nodeProps.put(OSMAttribute.LATITUDE_PROPERTY, y);
> nodeProps.put(OSMAttribute.LONGITUDE_PROPERTY, x);
> nodeProps.put(OSMAttribute.OSM_NODE_ID_PROPERTY, osmNodeWrapper.
> getOsmNodeId());
> if (osmNodeWrapper.isTrafficSignal())
> nodeProps.put(OSMAttribute.TRAFFIC_SIGNAL, true);
> // Creo il nodo
> long graphNodeId = inserter.createNode(nodeProps, mainNodeLabel);
> // aggiungo l'identificativo del nodo sul grafo
> osmNodeWrapper.setGraphNodeId(graphNodeId);
> return graphNodeId;
> }
>
> In our graph, we have only 2 types of relationships:
>
> - *CAR_ONE_WAY_RELATION* for one way road with Direction OUTCOMING
> - *CAR_BIDIRECTIONAL_WAY_RELATION* for bidirectional road with
> Direction BOTH
>
> This is the relationship creation code:
> //Create RelationShip
> Map<String, Object> relationProps = new HashMap<String, Object>();
> relationProps.put(OSMAttribute.EDGE_LENGTH_PROPERTY, lunghezzaArco);
> ....//other properties
> long relId = inserter.createRelationship(startNode, endNode,
> "CAR_ONE_WAY_RELATION", relationProps);
>
> osmWayIdPropertyIndex.add(relId, relationProps)
>
> We configured the neo4j embedded by using the following parameters:
>
> neostore.nodestore.db.mapped_memory=100M
> neostore.relationshipstore.db.mapped_memory=3G
> neostore.propertystore.db.mapped_memory=100M
> neostore.propertystore.db.strings.mapped_memory=200M
> neostore.propertystore.db.arrays.mapped_memory=50M
> cache_type=strong
>
> As you can see we use a strong cache type; this means we cache all data in
> memory. Moreover when out application starts we load all nodes and
> properties in memory; n order to do this we use this code:
>
>
> private void loadWholeGraphInMemory() throws PinfGraphServiceException{
> StopWatch sw = new StopWatch();
> sw.start();
> Node start;
> for ( Node n : ggo.getAllNodes() ) {
> n.getPropertyKeys();
> for ( Relationship relationship : n.getRelationships() ) {
> start = relationship.getStartNode();
> }
> }
> for ( Relationship r : ggo.getAllRelationships() ) {
> start = r.getStartNode();
> r.getPropertyKeys();
> }
> sw.stop();
> logger.info("Grafo caricato in "+sw.getLastTaskTimeMillis()+" millis");
>
>
> }
>
> We tried to execute the AStar algorithm between 2 points. The distance
> between points is around 130 kilometers. In order to execute the algorithm
> Neo4j takes around 4 seconds for returning a path and it seems to me really
> too much; if i compare it to other software on the same OSM I have really
> really really really different performance.
> Is there any way to improve the Algorithm performance? Where can we act to
> have better performance? would be better to use the Traversal AStar?
> Moreover is there any plan to implement bi-directional AStar and/or
> Dijkstra?
>
> I guess that with this kind of perfomance, Neo4j is not suitable for my
> scenario
>
> Thank you
> Angelo
>
>
>
>
>
--
You received this message because you are subscribed to the Google Groups
"Neo4j" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.
