Index: lucene/CHANGES.txt =================================================================== --- lucene/CHANGES.txt (revision 1493822) +++ lucene/CHANGES.txt (working copy) @@ -225,6 +225,9 @@ * LUCENE-5025: FST's Builder can now handle more than 2.1 billion "tail nodes" while building a minimal FST. (Aaron Binns, Adrien Grand, Mike McCandless) + +* LUCENE-5063: FieldCache.DEFAULT.get(Ints|Longs) now uses bit-packing to save + memory. (Adrien Grand) Build Index: lucene/core/src/test/org/apache/lucene/search/TestFieldCache.java =================================================================== --- lucene/core/src/test/org/apache/lucene/search/TestFieldCache.java (revision 1493822) +++ lucene/core/src/test/org/apache/lucene/search/TestFieldCache.java (working copy) @@ -23,23 +23,33 @@ import java.util.Arrays; import java.util.LinkedHashSet; import java.util.List; -import java.util.Locale; import java.util.concurrent.CyclicBarrier; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; import org.apache.lucene.analysis.MockAnalyzer; -import org.apache.lucene.codecs.DocValuesFormat; import org.apache.lucene.document.BinaryDocValuesField; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; +import org.apache.lucene.document.Field.Store; import org.apache.lucene.document.IntField; +import org.apache.lucene.document.LongField; import org.apache.lucene.document.NumericDocValuesField; import org.apache.lucene.document.SortedDocValuesField; import org.apache.lucene.document.SortedSetDocValuesField; import org.apache.lucene.document.StoredField; -import org.apache.lucene.document.StringField; -import org.apache.lucene.index.*; +import org.apache.lucene.index.AtomicReader; +import org.apache.lucene.index.BinaryDocValues; +import org.apache.lucene.index.DirectoryReader; +import org.apache.lucene.index.DocTermOrds; +import org.apache.lucene.index.IndexReader; +import org.apache.lucene.index.IndexWriter; +import org.apache.lucene.index.IndexWriterConfig; +import org.apache.lucene.index.RandomIndexWriter; +import org.apache.lucene.index.SlowCompositeReaderWrapper; +import org.apache.lucene.index.SortedDocValues; +import org.apache.lucene.index.SortedSetDocValues; +import org.apache.lucene.index.TermsEnum; import org.apache.lucene.search.FieldCache.Bytes; import org.apache.lucene.search.FieldCache.Doubles; import org.apache.lucene.search.FieldCache.Floats; @@ -692,4 +702,97 @@ ir.close(); dir.close(); } + + // Make sure that the use of GrowableWriter doesn't prevent from using the full long range + public void testLongFieldCache() throws IOException { + Directory dir = newDirectory(); + IndexWriterConfig cfg = newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random())); + cfg.setMergePolicy(newLogMergePolicy()); + RandomIndexWriter iw = new RandomIndexWriter(random(), dir); + Document doc = new Document(); + LongField field = new LongField("f", 0L, Store.YES); + doc.add(field); + final long[] values = new long[_TestUtil.nextInt(random(), 1, 10)]; + for (int i = 0; i < values.length; ++i) { + final long v; + switch (random().nextInt(10)) { + case 0: + v = Long.MIN_VALUE; + break; + case 1: + v = 0; + break; + case 2: + v = Long.MAX_VALUE; + break; + default: + v = _TestUtil.nextLong(random(), -10, 10); + break; + } + values[i] = v; + if (v == 0 && random().nextBoolean()) { + // missing + iw.addDocument(new Document()); + } else { + field.setLongValue(v); + iw.addDocument(doc); + } + } + iw.forceMerge(1); + final DirectoryReader reader = iw.getReader(); + final FieldCache.Longs longs = FieldCache.DEFAULT.getLongs(getOnlySegmentReader(reader), "f", false); + for (int i = 0; i < values.length; ++i) { + assertEquals(values[i], longs.get(i)); + } + reader.close(); + iw.close(); + dir.close(); + } + + // Make sure that the use of GrowableWriter doesn't prevent from using the full int range + public void testIntFieldCache() throws IOException { + Directory dir = newDirectory(); + IndexWriterConfig cfg = newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random())); + cfg.setMergePolicy(newLogMergePolicy()); + RandomIndexWriter iw = new RandomIndexWriter(random(), dir); + Document doc = new Document(); + IntField field = new IntField("f", 0, Store.YES); + doc.add(field); + final int[] values = new int[_TestUtil.nextInt(random(), 1, 10)]; + for (int i = 0; i < values.length; ++i) { + final int v; + switch (random().nextInt(10)) { + case 0: + v = Integer.MIN_VALUE; + break; + case 1: + v = 0; + break; + case 2: + v = Integer.MAX_VALUE; + break; + default: + v = _TestUtil.nextInt(random(), -10, 10); + break; + } + values[i] = v; + if (v == 0 && random().nextBoolean()) { + // missing + iw.addDocument(new Document()); + } else { + field.setIntValue(v); + iw.addDocument(doc); + } + } + iw.forceMerge(1); + final DirectoryReader reader = iw.getReader(); + final FieldCache.Ints ints = FieldCache.DEFAULT.getInts(getOnlySegmentReader(reader), "f", false); + for (int i = 0; i < values.length; ++i) { + assertEquals(values[i], ints.get(i)); + } + reader.close(); + iw.close(); + dir.close(); + } + } Index: lucene/core/src/test/org/apache/lucene/util/packed/TestPackedInts.java =================================================================== --- lucene/core/src/test/org/apache/lucene/util/packed/TestPackedInts.java (revision 1493822) +++ lucene/core/src/test/org/apache/lucene/util/packed/TestPackedInts.java (working copy) @@ -650,8 +650,11 @@ wrt.set(99, (1 << 23) - 1); assertEquals(1 << 10, wrt.get(valueCount - 1)); wrt.set(1, Long.MAX_VALUE); + wrt.set(2, -3); + assertEquals(64, wrt.getBitsPerValue()); assertEquals(1 << 10, wrt.get(valueCount - 1)); assertEquals(Long.MAX_VALUE, wrt.get(1)); + assertEquals(-3L, wrt.get(2)); assertEquals(2, wrt.get(4)); assertEquals((1 << 23) - 1, wrt.get(99)); assertEquals(10, wrt.get(7)); Index: lucene/core/src/java/org/apache/lucene/search/FieldCacheImpl.java =================================================================== --- lucene/core/src/java/org/apache/lucene/search/FieldCacheImpl.java (revision 1493822) +++ lucene/core/src/java/org/apache/lucene/search/FieldCacheImpl.java (working copy) @@ -38,7 +38,6 @@ import org.apache.lucene.index.SortedSetDocValues; import org.apache.lucene.index.Terms; import org.apache.lucene.index.TermsEnum; -import org.apache.lucene.util.ArrayUtil; import org.apache.lucene.util.Bits; import org.apache.lucene.util.BytesRef; import org.apache.lucene.util.FieldCacheSanityChecker; @@ -574,15 +573,19 @@ } static class IntsFromArray extends Ints { - private final int[] values; + private final PackedInts.Reader values; + private final int minValue; - public IntsFromArray(int[] values) { + public IntsFromArray(PackedInts.Reader values, int minValue) { + assert values.getBitsPerValue() <= 32; this.values = values; + this.minValue = minValue; } @Override public int get(int docID) { - return values[docID]; + final long delta = values.get(docID); + return minValue + (int) delta; } } @@ -598,6 +601,15 @@ } } + private static class GrowableWriterAndMinValue { + GrowableWriterAndMinValue(GrowableWriter array, long minValue) { + this.writer = array; + this.minValue = minValue; + } + public GrowableWriter writer; + public long minValue; + } + static final class IntCache extends Cache { IntCache(FieldCacheImpl wrapper) { super(wrapper); @@ -621,11 +633,12 @@ } } - final HoldsOneThing valuesRef = new HoldsOneThing(); + final HoldsOneThing valuesRef = new HoldsOneThing(); Uninvert u = new Uninvert() { + private int minValue; private int currentValue; - private int[] values; + private GrowableWriter values; @Override public void visitTerm(BytesRef term) { @@ -635,16 +648,29 @@ // (which will hit a NumberFormatException // when we first try the DEFAULT_INT_PARSER), // we don't double-alloc: - values = new int[reader.maxDoc()]; - valuesRef.set(values); + int startBitsPerValue; + // Make sure than missing values (0) can be stored without resizing + if (currentValue < 0) { + minValue = currentValue; + startBitsPerValue = PackedInts.bitsRequired((-minValue) & 0xFFFFFFFFL); + } else { + minValue = 0; + startBitsPerValue = PackedInts.bitsRequired(currentValue); + } + startBitsPerValue = Math.max(startBitsPerValue, 4); + values = new GrowableWriter(startBitsPerValue, reader.maxDoc(), PackedInts.FAST); + if (minValue != 0) { + values.fill(0, values.size(), (-minValue) & 0xFFFFFFFFL); // default value must be 0 + } + valuesRef.set(new GrowableWriterAndMinValue(values, minValue)); } } @Override public void visitDoc(int docID) { - values[docID] = currentValue; + values.set(docID, (currentValue - minValue) & 0xFFFFFFFFL); } - + @Override protected TermsEnum termsEnum(Terms terms) throws IOException { return parser.termsEnum(terms); @@ -656,11 +682,11 @@ if (setDocsWithField) { wrapper.setDocsWithField(reader, key.field, u.docsWithField); } - int[] values = valuesRef.get(); + GrowableWriterAndMinValue values = valuesRef.get(); if (values == null) { - values = new int[reader.maxDoc()]; + return new IntsFromArray(new PackedInts.NullReader(reader.maxDoc()), 0); } - return new IntsFromArray(values); + return new IntsFromArray(values.writer.getMutable(), (int) values.minValue); } } @@ -879,15 +905,17 @@ } static class LongsFromArray extends Longs { - private final long[] values; + private final PackedInts.Reader values; + private final long minValue; - public LongsFromArray(long[] values) { + public LongsFromArray(PackedInts.Reader values, long minValue) { this.values = values; + this.minValue = minValue; } @Override public long get(int docID) { - return values[docID]; + return minValue + values.get(docID); } } @@ -914,11 +942,12 @@ } } - final HoldsOneThing valuesRef = new HoldsOneThing(); + final HoldsOneThing valuesRef = new HoldsOneThing(); Uninvert u = new Uninvert() { + private long minValue; private long currentValue; - private long[] values; + private GrowableWriter values; @Override public void visitTerm(BytesRef term) { @@ -928,14 +957,27 @@ // (which will hit a NumberFormatException // when we first try the DEFAULT_INT_PARSER), // we don't double-alloc: - values = new long[reader.maxDoc()]; - valuesRef.set(values); + int startBitsPerValue; + // Make sure than missing values (0) can be stored without resizing + if (currentValue < 0) { + minValue = currentValue; + startBitsPerValue = minValue == Long.MIN_VALUE ? 64 : PackedInts.bitsRequired(-minValue); + } else { + minValue = 0; + startBitsPerValue = PackedInts.bitsRequired(currentValue); + } + startBitsPerValue = Math.max(startBitsPerValue, 4); + values = new GrowableWriter(startBitsPerValue, reader.maxDoc(), PackedInts.FAST); + if (minValue != 0) { + values.fill(0, values.size(), -minValue); // default value must be 0 + } + valuesRef.set(new GrowableWriterAndMinValue(values, minValue)); } } @Override public void visitDoc(int docID) { - values[docID] = currentValue; + values.set(docID, currentValue - minValue); } @Override @@ -949,11 +991,11 @@ if (setDocsWithField) { wrapper.setDocsWithField(reader, key.field, u.docsWithField); } - long[] values = valuesRef.get(); + GrowableWriterAndMinValue values = valuesRef.get(); if (values == null) { - values = new long[reader.maxDoc()]; + return new LongsFromArray(new PackedInts.NullReader(reader.maxDoc()), 0L); } - return new LongsFromArray(values); + return new LongsFromArray(values.writer.getMutable(), values.minValue); } } @@ -1146,7 +1188,6 @@ final PagedBytes bytes = new PagedBytes(15); int startTermsBPV; - int startNumUniqueTerms; final int termCountHardLimit; if (maxDoc == Integer.MAX_VALUE) { @@ -1170,15 +1211,11 @@ } startTermsBPV = PackedInts.bitsRequired(numUniqueTerms); - - startNumUniqueTerms = (int) numUniqueTerms; } else { startTermsBPV = 1; - startNumUniqueTerms = 1; } } else { startTermsBPV = 1; - startNumUniqueTerms = 1; } MonotonicAppendingLongBuffer termOrdToBytesOffset = new MonotonicAppendingLongBuffer(); Index: lucene/core/src/java/org/apache/lucene/util/packed/GrowableWriter.java =================================================================== --- lucene/core/src/java/org/apache/lucene/util/packed/GrowableWriter.java (revision 1493822) +++ lucene/core/src/java/org/apache/lucene/util/packed/GrowableWriter.java (working copy) @@ -25,22 +25,32 @@ /** * Implements {@link PackedInts.Mutable}, but grows the * bit count of the underlying packed ints on-demand. + *

Beware that this class will accept to set negative values but in order + * to do this, it will grow the number of bits per value to 64. * *

@lucene.internal

*/ - public class GrowableWriter implements PackedInts.Mutable { - private long currentMaxValue; + private long currentMask; private PackedInts.Mutable current; private final float acceptableOverheadRatio; + /** + * @param startBitsPerValue the initial number of bits per value, may grow depending on the data + * @param valueCount the number of values + * @param acceptableOverheadRatio an acceptable overhead ratio + */ public GrowableWriter(int startBitsPerValue, int valueCount, float acceptableOverheadRatio) { this.acceptableOverheadRatio = acceptableOverheadRatio; current = PackedInts.getMutable(valueCount, startBitsPerValue, this.acceptableOverheadRatio); - currentMaxValue = PackedInts.maxValue(current.getBitsPerValue()); + currentMask = mask(current.getBitsPerValue()); } + private static long mask(int bitsPerValue) { + return bitsPerValue == 64 ? ~0L : PackedInts.maxValue(bitsPerValue); + } + @Override public long get(int index) { return current.get(index); @@ -71,16 +81,16 @@ } private void ensureCapacity(long value) { - assert value >= 0; - if (value <= currentMaxValue) { + if ((value & currentMask) == value) { return; } - final int bitsRequired = PackedInts.bitsRequired(value); + final int bitsRequired = value < 0 ? 64 : PackedInts.bitsRequired(value); + assert bitsRequired > current.getBitsPerValue(); final int valueCount = size(); PackedInts.Mutable next = PackedInts.getMutable(valueCount, bitsRequired, acceptableOverheadRatio); PackedInts.copy(current, 0, next, 0, valueCount, PackedInts.DEFAULT_BUFFER_SIZE); current = next; - currentMaxValue = PackedInts.maxValue(current.getBitsPerValue()); + currentMask = mask(current.getBitsPerValue()); } @Override @@ -110,6 +120,10 @@ public int set(int index, long[] arr, int off, int len) { long max = 0; for (int i = off, end = off + len; i < end; ++i) { + // bitwise or is nice because either all values are positive and the + // or-ed result will require as many bits per value as the max of the + // values, or one of them is negative and the result will be negative, + // forcing GrowableWriter to use 64 bits per value max |= arr[i]; } ensureCapacity(max);