Merge pull request graphhopper#275 from duongnt/master

incCapacity takes # of bytes required, not the delta

Author: Peter

core/src/main/java/com/graphhopper/coll/OSMIDMap.java

@@ -75,10 +75,10 @@ public int put( long key, int value )
             return oldValue;
         }
 
-        values.incCapacity(size + 4);
+        values.ensureCapacity(size + 4);
         values.setInt(size, value);
         long doubleSize = size * 2;
-        keys.incCapacity(doubleSize + 8);
+        keys.ensureCapacity(doubleSize + 8);
 
         // store long => double of the orig size
         byte[] longBytes = bitUtil.fromLong(key);

core/src/main/java/com/graphhopper/reader/PillarInfo.java

@@ -76,7 +76,7 @@ public void setNode( int id, double lat, double lon, double ele )
     private void _setNode( int id, double lat, double lon, double ele )
     {
         long tmp = (long) id * rowSizeInBytes;
-        da.incCapacity(tmp + rowSizeInBytes);
+        da.ensureCapacity(tmp + rowSizeInBytes);
         da.setInt(tmp + LAT, Helper.degreeToInt(lat));
         da.setInt(tmp + LON, Helper.degreeToInt(lon));
 

core/src/main/java/com/graphhopper/routing/ch/PrepareContractionHierarchies.java

@@ -766,15 +766,15 @@ public final boolean accept( EdgeIteratorState iter )
     private void setOrigEdgeCount( int index, int value )
     {
         long tmp = (long) index * 4;
-        originalEdges.incCapacity(tmp + 4);
+        originalEdges.ensureCapacity(tmp + 4);
         originalEdges.setInt(tmp, value);
     }
 
     private int getOrigEdgeCount( int index )
     {
         // TODO possible memory usage improvement: avoid storing the value 1 for normal edges (does not change)!
         long tmp = (long) index * 4;
-        originalEdges.incCapacity(tmp + 4);
+        originalEdges.ensureCapacity(tmp + 4);
         return originalEdges.getInt(tmp);
     }
 

core/src/main/java/com/graphhopper/search/NameIndex.java

@@ -77,7 +77,7 @@ public int put( String name )
         }
         byte[] bytes = getBytes(name);
         int oldPointer = bytePointer;
-        names.incCapacity(bytePointer + 1 + bytes.length);
+        names.ensureCapacity(bytePointer + 1 + bytes.length);
         byte[] sizeBytes = new byte[]
         {
             (byte) bytes.length

core/src/main/java/com/graphhopper/storage/AbstractDataAccess.java

@@ -138,7 +138,7 @@ protected void copyHeader( DataAccess da )
     public DataAccess copyTo( DataAccess da )
     {
         copyHeader(da);
-        da.incCapacity(getCapacity());
+        da.ensureCapacity(getCapacity());
         long cap = getCapacity();
         // currently get/setBytes does not support copying more bytes then segmentSize
         int segSize = Math.min(da.getSegmentSize(), getSegmentSize());

core/src/main/java/com/graphhopper/storage/DataAccess.java

@@ -23,7 +23,7 @@
  * Directory.create. Current implementations are RAM and memory mapped access.
  * <p/>
  * Life cycle: (1) object creation, (2) configuration (e.g. segment size), (3) create or
- * loadExisting, (4) usage and calling incCapacity if necessary, (5) close
+ * loadExisting, (4) usage and calling ensureCapacity if necessary, (5) close
  * <p/>
  * @author Peter Karich
  */
@@ -86,7 +86,7 @@ public interface DataAccess extends Storable<DataAccess>
 
     /**
      * The first time you use a DataAccess object after configuring it you need to call this. After
-     * that first call you have to use incCapacity to ensure that enough space is reserved.
+     * that first call you have to use ensureCapacity to ensure that enough space is reserved.
      */
     @Override
     DataAccess create( long bytes );
@@ -98,7 +98,7 @@ public interface DataAccess extends Storable<DataAccess>
      * @see #create(long)
      * @return true if size was increased
      */
-    boolean incCapacity( long bytes );
+    boolean ensureCapacity(long bytes);
 
     /**
      * Reduces the allocate space to the specified bytes. Warning: it'll free the space even if it

core/src/main/java/com/graphhopper/storage/GraphHopperStorage.java

@@ -24,10 +24,17 @@
 import com.graphhopper.routing.util.EdgeFilter;
 import com.graphhopper.routing.util.EncodingManager;
 import com.graphhopper.search.NameIndex;
-import com.graphhopper.util.*;
-import static com.graphhopper.util.Helper.nf;
+import com.graphhopper.util.BitUtil;
+import com.graphhopper.util.EdgeExplorer;
+import com.graphhopper.util.EdgeIterator;
+import com.graphhopper.util.EdgeIteratorState;
+import com.graphhopper.util.GHUtility;
+import com.graphhopper.util.Helper;
+import com.graphhopper.util.PointList;
 import com.graphhopper.util.shapes.BBox;
 
+import static com.graphhopper.util.Helper.nf;
+
 /**
  * The main implementation which handles nodes and edges file format. It can be used with different
  * Directory implementations like RAMDirectory for fast access or via MMapDirectory for
@@ -259,7 +266,7 @@ final void ensureNodeIndex( int nodeIndex )
 
         long oldNodes = nodeCount;
         nodeCount = nodeIndex + 1;
-        boolean capacityIncreased = nodes.incCapacity((long) nodeCount * nodeEntryBytes);
+        boolean capacityIncreased = nodes.ensureCapacity((long)nodeCount * nodeEntryBytes);
         if (capacityIncreased)
         {
             long newBytesCapacity = nodes.getCapacity();
@@ -290,12 +297,12 @@ private void initNodeRefs( long oldCapacity, long newCapacity )
 
     private void ensureEdgeIndex( int edgeIndex )
     {
-        edges.incCapacity(((long) edgeIndex + 1) * edgeEntryBytes);
+        edges.ensureCapacity(((long)edgeIndex + 1) * edgeEntryBytes);
     }
 
     private void ensureGeometry( long bytePos, int byteLength )
     {
-        wayGeometry.incCapacity(bytePos + byteLength);
+        wayGeometry.ensureCapacity(bytePos + byteLength);
     }
 
     @Override

core/src/main/java/com/graphhopper/storage/MMapDataAccess.java

@@ -81,7 +81,7 @@ public MMapDataAccess create( long bytes )
         initRandomAccessFile();
         bytes = Math.max(10 * 4, bytes);
         setSegmentSize(segmentSizeInBytes);
-        incCapacity(bytes);
+        ensureCapacity(bytes);
         return this;
     }
 
@@ -97,7 +97,7 @@ public DataAccess copyTo( DataAccess da )
     }
 
     @Override
-    public boolean incCapacity( long bytes )
+    public boolean ensureCapacity(long bytes)
     {
         return mapIt(HEADER_OFFSET, bytes, true);
     }

core/src/main/java/com/graphhopper/storage/RAMDataAccess.java

@@ -87,12 +87,12 @@ public RAMDataAccess create( long bytes )
 
         // initialize transient values
         setSegmentSize(segmentSizeInBytes);
-        incCapacity(Math.max(10 * 4, bytes));
+        ensureCapacity(Math.max(10 * 4, bytes));
         return this;
     }
 
     @Override
-    public boolean incCapacity( long bytes )
+    public boolean ensureCapacity(long bytes)
     {
         if (bytes < 0)
             throw new IllegalArgumentException("new capacity has to be strictly positive");

core/src/main/java/com/graphhopper/storage/RAMIntDataAccess.java

@@ -90,12 +90,12 @@ public RAMIntDataAccess create( long bytes )
 
         // initialize transient values
         setSegmentSize(segmentSizeInBytes);
-        incCapacity(Math.max(10 * 4, bytes));
+        ensureCapacity(Math.max(10 * 4, bytes));
         return this;
     }
 
     @Override
-    public boolean incCapacity( long bytes )
+    public boolean ensureCapacity(long bytes)
     {
         if (bytes < 0)
             throw new IllegalArgumentException("new capacity has to be strictly positive");

core/src/main/java/com/graphhopper/storage/Storable.java

@@ -30,7 +30,7 @@
  * interface</li>
  * <li>if(!storable.loadExisting()) storable.create()</li>
  * <li>usage storable and optional flush() calls in-between. Keep in mind that some data structure
- * could require a call to increase memory while usage. E.g. DataAccess.incCapacity()</li>
+ * could require a call to increase memory while usage. E.g. DataAccess.ensureCapacity()</li>
  * <li>Finally do close() which does no flush()</li>
  * </ol>
  * <p/>

core/src/main/java/com/graphhopper/storage/SynchedDAWrapper.java

@@ -100,9 +100,9 @@ public synchronized DataAccess create( long bytes )
     }
 
     @Override
-    public synchronized boolean incCapacity( long bytes )
+    public synchronized boolean ensureCapacity(long bytes)
     {
-        return inner.incCapacity(bytes);
+        return inner.ensureCapacity(bytes);
     }
 
     @Override

core/src/main/java/com/graphhopper/storage/TurnCostStorage.java

@@ -204,12 +204,7 @@ private long nextCostFlags( int node, int edgeFrom, int edgeTo )
 
     private void ensureTurnCostIndex( int nodeIndex )
     {
-        long deltaCap = ((long) nodeIndex + 4) * turnCostsEntryBytes - turnCosts.getCapacity();
-        if (deltaCap <= 0)
-        {
-            return;
-        }
-        turnCosts.incCapacity(deltaCap);
+        turnCosts.ensureCapacity(((long) nodeIndex + 4) * turnCostsEntryBytes);
     }
 
     @Override

core/src/main/java/com/graphhopper/storage/UnsafeDataAccess.java

@@ -17,7 +17,6 @@
  */
 package com.graphhopper.storage;
 
-import static com.graphhopper.storage.AbstractDataAccess.HEADER_OFFSET;
 import com.graphhopper.util.NotThreadSafe;
 import java.io.File;
 import java.io.IOException;
@@ -74,12 +73,12 @@ public UnsafeDataAccess create( long bytes )
         // TODO use unsafe.pageSize() instead segmentSizeInBytes?
         // e.g. on my system pageSize is only 4096
         setSegmentSize(segmentSizeInBytes);
-        incCapacity(bytes);
+        ensureCapacity(bytes);
         return this;
     }
 
     @Override
-    public final boolean incCapacity( long bytes )
+    public final boolean ensureCapacity(long bytes)
     {
         return ensureCapacity(bytes, true);
     }

core/src/main/java/com/graphhopper/storage/index/LocationIndexTree.java

@@ -525,7 +525,7 @@ int store( InMemEntry entry, int intIndex )
                 size += len;
                 intIndex++;
                 leafs++;
-                dataAccess.incCapacity((long) (intIndex + len + 1) * 4);
+                dataAccess.ensureCapacity((long)(intIndex + len + 1) * 4);
                 if (len == 1)
                 {
                     // less disc space for single entries
@@ -550,7 +550,7 @@ int store( InMemEntry entry, int intIndex )
                     {
                         continue;
                     }
-                    dataAccess.incCapacity((long) (intIndex + 1) * 4);
+                    dataAccess.ensureCapacity((long)(intIndex + 1) * 4);
                     int beforeIntIndex = intIndex;
                     intIndex = store(subEntry, beforeIntIndex);
                     if (intIndex == beforeIntIndex)

core/src/test/java/com/graphhopper/storage/DataAccessTest.java

@@ -95,7 +95,7 @@ public void testExceptionIfNoEnsureCapacityWasCalled()
     {
         DataAccess da = createDataAccess(name);
         assertFalse(da.loadExisting());
-        // throw some undefined exception if no incCapacity was called
+        // throw some undefined exception if no ensureCapacity was called
         try
         {
             da.setInt(2 * 4, 321);
@@ -149,7 +149,7 @@ public void testEnsureCapacity()
         da.setInt(31 * 4, 200);
 
         assertEquals(200, da.getInt(31 * 4));
-        da.incCapacity(2 * 128);
+        da.ensureCapacity(2 * 128);
         assertEquals(200, da.getInt(31 * 4));
         // now it shouldn't fail
         da.setInt(32 * 4, 220);
@@ -159,7 +159,7 @@ public void testEnsureCapacity()
         // ensure some bigger area
         da = createDataAccess(name);
         da.create(200 * 4);
-        da.incCapacity(600 * 4);
+        da.ensureCapacity(600 * 4);
         da.close();
     }
 
@@ -198,7 +198,7 @@ public void testSegments()
         da.setSegmentSize(128);
         da.create(10);
         assertEquals(1, da.getSegments());
-        da.incCapacity(500);
+        da.ensureCapacity(500);
         int olds = da.getSegments();
         assertTrue(olds > 3);
 

core/src/test/java/com/graphhopper/storage/GraphHopperStorageWithTurnCostsTest.java

@@ -17,15 +17,15 @@
  */
 package com.graphhopper.storage;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
 import java.io.IOException;
-
-import org.junit.Test;
+import java.util.Random;
 
 import com.graphhopper.util.EdgeIteratorState;
 import com.graphhopper.util.Helper;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 /**
  *
@@ -93,4 +93,45 @@ public void testSave_and_fileFormat_withTurnCostEntries() throws IOException
         graph.edge(3, 4, 123, true).setWayGeometry(Helper.createPointList(4.4, 5.5, 6.6, 7.7));
         checkGraph(graph);
     }
+
+    @Test
+    public void testEnsureCapacity() throws IOException {
+        graph = newGraph(new MMapDirectory(defaultGraphLoc), false);
+        graph.setSegmentSize(128);
+        graph.create(100); // 100 is the minimum size
+
+        // assert that turnCostStorage can hold 104 turn cost entries at the beginning
+        assertEquals(104, turnCostStorage.getCapacity() / 16);
+
+        Random r = new Random();
+
+        NodeAccess na = graph.getNodeAccess();
+        for (int i = 0; i < 100; i++) {
+            double randomLat = 90 * r.nextDouble();
+            double randomLon = 180 * r.nextDouble();
+
+            na.setNode(i, randomLat, randomLon);
+        }
+
+        // Make node 50 the 'center' node
+        for (int nodeId = 51; nodeId < 100; nodeId++) {
+            graph.edge(50, nodeId, r.nextDouble(), true);
+        }
+        for (int nodeId = 0; nodeId < 50; nodeId++) {
+            graph.edge(nodeId, 50, r.nextDouble(), true);
+        }
+
+        // add 100 turn cost entries around node 50
+        for (int edgeId = 0; edgeId < 50; edgeId++) {
+            turnCostStorage.addTurnInfo(50, edgeId, edgeId + 50, 1337);
+            turnCostStorage.addTurnInfo(50, edgeId + 50, edgeId, 1337);
+        }
+
+        turnCostStorage.addTurnInfo(50, 0, 1, 1337);
+        assertEquals(104, turnCostStorage.getCapacity() / 16); // we are still good here
+
+        turnCostStorage.addTurnInfo(50, 0, 2, 1337);
+        // A new segment should be added, which will support 128 / 16 = 8 more entries.
+        assertEquals(112, turnCostStorage.getCapacity() / 16);
+    }
 }