performance improvements suggested by a1k0n

Author: julsal

src/main/java/com/spotify/annoy/ANNIndex.java

@@ -15,7 +15,7 @@ public class ANNIndex implements AnnoyIndex {
 
 
  private final ArrayList<Long> roots;
- private Map<Integer, MappedByteBuffer> buffers = new HashMap<>();
+ private MappedByteBuffer[] buffers;
 
  private final int DIMENSION, MIN_LEAF_SIZE;
  private final IndexType INDEX_TYPE;
@@ -72,20 +72,25 @@ public ANNIndex(final int dimension,
  private void load(final String filename) throws IOException {
  memoryMappedFile = new RandomAccessFile(filename, "r");
  long fileSize = memoryMappedFile.length();
- int buffIndex = (int) Math.ceil(((double) fileSize) / BLOCK_SIZE) - 1;
+ if (fileSize == 0L) {
+ throw new IOException("Index is a 0-byte file?");
+    }
+
+ int buffIndex =  (int) (fileSize - 1) / BLOCK_SIZE;
  int rest = (int) (fileSize % BLOCK_SIZE);
  int blockSize = (rest > 0 ? rest : BLOCK_SIZE);
  long position = Math.max(0, fileSize - blockSize);
 
+ buffers = new MappedByteBuffer[buffIndex + 1];
  boolean process = true;
  int m = -1;
  long index = fileSize;
- while(blockSize > 0) {
+ while(position >= 0) {
  MappedByteBuffer annBuf = memoryMappedFile.getChannel().map(
  FileChannel.MapMode.READ_ONLY, position, blockSize);
  annBuf.order(ByteOrder.LITTLE_ENDIAN);
 
- buffers.put(buffIndex--, annBuf);
+ buffers[buffIndex--] = annBuf;
 
  for (int i = blockSize - NODE_SIZE; process && i >= 0; i -= NODE_SIZE) {
  index -= NODE_SIZE;
@@ -95,31 +100,31 @@ private void load(final String filename) throws IOException {
  m = k;
         } else {
  process = false;
- break;
         }
       }
- blockSize = (int) Math.min(BLOCK_SIZE, position);
+ blockSize = BLOCK_SIZE;
  position = position - blockSize;
     }
   }
 
  private float getFloatInAnnBuf(long pos) {
- int b = (int) Math.floor(((double) pos) / BLOCK_SIZE);
- int f = (int) (pos - (b * BLOCK_SIZE));
- return buffers.get(b).getFloat(f);
+ int b = (int) pos / BLOCK_SIZE;
+ int f = (int) pos % BLOCK_SIZE;
+ return buffers[b].getFloat(f);
   }
 
  private int getIntInAnnBuf(long pos) {
- int b = (int) Math.floor(((double) pos) / BLOCK_SIZE);
- int f = (int) (pos - (b * BLOCK_SIZE));
- return buffers.get(b).getInt(f);
+ int b = (int) pos / BLOCK_SIZE;
+ int i = (int) pos % BLOCK_SIZE;
+ return buffers[b].getInt(i);
   }
 
  @Override
  public void getNodeVector(final long nodeOffset, float[] v) {
+ MappedByteBuffer nodeBuf = buffers[(int) nodeOffset / BLOCK_SIZE];
+ int offset = (int) (nodeOffset % BLOCK_SIZE) + K_NODE_HEADER_STYLE;
  for (int i = 0; i < DIMENSION; i++) {
- long offSet = nodeOffset + K_NODE_HEADER_STYLE + i * FLOAT_SIZE;
- v[i] = getFloatInAnnBuf(offSet);
+ v[i] = nodeBuf.getFloat(offset + i * FLOAT_SIZE);
     }
   }