Apache
/
lucene
mirror of https://github.com/apache/lucene.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

LUCENE-2504: small optimization to sort missing last comparators - use static inner classes 

git-svn-id: https://svn.apache.org/repos/asf/lucene/dev/trunk@997449 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Yonik Seeley 2010-09-15 18:41:40 +00:00
parent 76a9dc048c
commit ff5a2942d3
1 changed files with 326 additions and 312 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

636
solr/src/java/org/apache/solr/search/MissingStringLastComparatorSource.java
View File

@ -30,8 +30,6 @@ import java.io.IOException;
public class MissingStringLastComparatorSource extends FieldComparatorSource {
private final BytesRef missingValueProxy;
public MissingStringLastComparatorSource() {
@ -56,30 +54,96 @@ public class MissingStringLastComparatorSource extends FieldComparatorSource {
// Copied from Lucene's TermOrdValComparator and modified since the Lucene version couldn't
// be extended.
class TermOrdValComparator_SML extends FieldComparator {
private static final int NULL_ORD = Integer.MAX_VALUE;
class TermOrdValComparator_SML extends FieldComparator {
private static final int NULL_ORD = Integer.MAX_VALUE;
private final int[] ords;
private final BytesRef[] values;
private final int[] readerGen;
private final int[] ords;
private final BytesRef[] values;
private final int[] readerGen;
private int currentReaderGen = -1;
private FieldCache.DocTermsIndex termsIndex;
private final String field;
private FieldCache.DocTermsIndex termsIndex;
private final String field;
private int bottomSlot = -1;
private int bottomOrd;
private boolean bottomSameReader;
private BytesRef bottomValue;
private final BytesRef tempBR = new BytesRef();
private final BytesRef NULL_VAL;
private final BytesRef NULL_VAL;
private PerSegmentComparator current;
public TermOrdValComparator_SML(int numHits, String field, int sortPos, boolean reversed, BytesRef nullVal) {
ords = new int[numHits];
values = new BytesRef[numHits];
readerGen = new int[numHits];
this.field = field;
this.NULL_VAL = nullVal;
public TermOrdValComparator_SML(int numHits, String field, int sortPos, boolean reversed, BytesRef nullVal) {
ords = new int[numHits];
values = new BytesRef[numHits];
readerGen = new int[numHits];
this.field = field;
this.NULL_VAL = nullVal;
}
@Override
public int compare(int slot1, int slot2) {
throw new UnsupportedOperationException();
}
@Override
public void setBottom(int slot) {
throw new UnsupportedOperationException();
}
@Override
public int compareBottom(int doc) {
throw new UnsupportedOperationException();
}
@Override
public void copy(int slot, int doc) {
throw new UnsupportedOperationException();
}
@Override
public Comparable<?> value(int slot) {
throw new UnsupportedOperationException();
}
@Override
public FieldComparator setNextReader(IndexReader reader, int docBase) throws IOException {
return TermOrdValComparator_SML.createComparator(reader, this);
}
// Base class for specialized (per bit width of the
// ords) per-segment comparator. NOTE: this is messy;
// we do this only because hotspot can't reliably inline
// the underlying array access when looking up doc->ord
private static abstract class PerSegmentComparator extends FieldComparator {
protected TermOrdValComparator_SML parent;
protected final int[] ords;
protected final BytesRef[] values;
protected final int[] readerGen;
protected int currentReaderGen = -1;
protected FieldCache.DocTermsIndex termsIndex;
protected int bottomSlot = -1;
protected int bottomOrd;
protected boolean bottomSameReader = false;
protected BytesRef bottomValue;
protected final BytesRef tempBR = new BytesRef();
public PerSegmentComparator(TermOrdValComparator_SML parent) {
this.parent = parent;
PerSegmentComparator previous = parent.current;
if (previous != null) {
currentReaderGen = previous.currentReaderGen;
bottomSlot = previous.bottomSlot;
bottomOrd = previous.bottomOrd;
bottomValue = previous.bottomValue;
}
ords = parent.ords;
values = parent.values;
readerGen = parent.readerGen;
termsIndex = parent.termsIndex;
currentReaderGen++;
}
@Override
public FieldComparator setNextReader(IndexReader reader, int docBase) throws IOException {
return TermOrdValComparator_SML.createComparator(reader, parent);
}
@Override
@ -101,294 +165,6 @@ public class MissingStringLastComparatorSource extends FieldComparatorSource {
return val1.compareTo(val2);
}
@Override
public int compareBottom(int doc) {
throw new UnsupportedOperationException();
}
@Override
public void copy(int slot, int doc) {
throw new UnsupportedOperationException();
}
// Base class for specialized (per bit width of the
// ords) per-segment comparator. NOTE: this is messy;
// we do this only because hotspot can't reliably inline
// the underlying array access when looking up doc->ord
private abstract class PerSegmentComparator extends FieldComparator {
@Override
public FieldComparator setNextReader(IndexReader reader, int docBase) throws IOException {
return TermOrdValComparator_SML.this.setNextReader(reader, docBase);
}
@Override
public int compare(int slot1, int slot2) {
return TermOrdValComparator_SML.this.compare(slot1, slot2);
}
@Override
public void setBottom(final int bottom) {
TermOrdValComparator_SML.this.setBottom(bottom);
}
@Override
public Comparable<?> value(int slot) {
return TermOrdValComparator_SML.this.value(slot);
}
}
// Used per-segment when bit width of doc->ord is 8:
private final class ByteOrdComparator extends PerSegmentComparator {
private final byte[] readerOrds;
private final FieldCache.DocTermsIndex termsIndex;
private final int docBase;
public ByteOrdComparator(byte[] readerOrds, FieldCache.DocTermsIndex termsIndex, int docBase) {
this.readerOrds = readerOrds;
this.termsIndex = termsIndex;
this.docBase = docBase;
}
@Override
public int compareBottom(int doc) {
assert bottomSlot != -1;
int order = readerOrds[doc]&0xFF;
if (order == 0) order = NULL_ORD;
if (bottomSameReader) {
// ord is precisely comparable, even in the equal case
return bottomOrd - order;
} else {
// ord is only approx comparable: if they are not
// equal, we can use that; if they are equal, we
// must fallback to compare by value
final int cmp = bottomOrd - order;
if (cmp != 0) {
return cmp;
}
// take care of the case where both vals are null
if (order == NULL_ORD) return 0;
// and at this point we know that neither value is null, so safe to compare
termsIndex.lookup(order, tempBR);
return bottomValue.compareTo(tempBR);
}
}
@Override
public void copy(int slot, int doc) {
int ord = readerOrds[doc]&0xFF;
if (ord == 0) {
ords[slot] = NULL_ORD;
values[slot] = null;
} else {
ords[slot] = ord;
assert ord > 0;
if (values[slot] == null) {
values[slot] = new BytesRef();
}
termsIndex.lookup(ord, values[slot]);
}
readerGen[slot] = currentReaderGen;
}
}
// Used per-segment when bit width of doc->ord is 16:
private final class ShortOrdComparator extends PerSegmentComparator {
private final short[] readerOrds;
private final FieldCache.DocTermsIndex termsIndex;
private final int docBase;
public ShortOrdComparator(short[] readerOrds, FieldCache.DocTermsIndex termsIndex, int docBase) {
this.readerOrds = readerOrds;
this.termsIndex = termsIndex;
this.docBase = docBase;
}
@Override
public int compareBottom(int doc) {
assert bottomSlot != -1;
int order = readerOrds[doc]&0xFFFF;
if (order == 0) order = NULL_ORD;
if (bottomSameReader) {
// ord is precisely comparable, even in the equal case
return bottomOrd - order;
} else {
// ord is only approx comparable: if they are not
// equal, we can use that; if they are equal, we
// must fallback to compare by value
final int cmp = bottomOrd - order;
if (cmp != 0) {
return cmp;
}
// take care of the case where both vals are null
if (order == NULL_ORD) return 0;
// and at this point we know that neither value is null, so safe to compare
termsIndex.lookup(order, tempBR);
return bottomValue.compareTo(tempBR);
}
}
@Override
public void copy(int slot, int doc) {
int ord = readerOrds[doc]&0xFFFF;
if (ord == 0) {
ords[slot] = NULL_ORD;
values[slot] = null;
} else {
ords[slot] = ord;
assert ord > 0;
if (values[slot] == null) {
values[slot] = new BytesRef();
}
termsIndex.lookup(ord, values[slot]);
}
readerGen[slot] = currentReaderGen;
}
}
// Used per-segment when bit width of doc->ord is 32:
private final class IntOrdComparator extends PerSegmentComparator {
private final int[] readerOrds;
private final FieldCache.DocTermsIndex termsIndex;
private final int docBase;
public IntOrdComparator(int[] readerOrds, FieldCache.DocTermsIndex termsIndex, int docBase) {
this.readerOrds = readerOrds;
this.termsIndex = termsIndex;
this.docBase = docBase;
}
@Override
public int compareBottom(int doc) {
assert bottomSlot != -1;
int order = readerOrds[doc];
if (order == 0) order = NULL_ORD;
if (bottomSameReader) {
// ord is precisely comparable, even in the equal case
return bottomOrd - order;
} else {
// ord is only approx comparable: if they are not
// equal, we can use that; if they are equal, we
// must fallback to compare by value
final int cmp = bottomOrd - order;
if (cmp != 0) {
return cmp;
}
// take care of the case where both vals are null
if (order == NULL_ORD) return 0;
// and at this point we know that neither value is null, so safe to compare
termsIndex.lookup(order, tempBR);
return bottomValue.compareTo(tempBR);
}
}
@Override
public void copy(int slot, int doc) {
int ord = readerOrds[doc];
if (ord == 0) {
ords[slot] = NULL_ORD;
values[slot] = null;
} else {
ords[slot] = ord;
assert ord > 0;
if (values[slot] == null) {
values[slot] = new BytesRef();
}
termsIndex.lookup(ord, values[slot]);
}
readerGen[slot] = currentReaderGen;
}
}
// Used per-segment when bit width is not a native array
// size (8, 16, 32):
private final class AnyOrdComparator extends PerSegmentComparator {
private final PackedInts.Reader readerOrds;
private final FieldCache.DocTermsIndex termsIndex;
private final int docBase;
public AnyOrdComparator(PackedInts.Reader readerOrds, FieldCache.DocTermsIndex termsIndex, int docBase) {
this.readerOrds = readerOrds;
this.termsIndex = termsIndex;
this.docBase = docBase;
}
@Override
public int compareBottom(int doc) {
assert bottomSlot != -1;
int order = (int) readerOrds.get(doc);
if (order == 0) order = NULL_ORD;
if (bottomSameReader) {
// ord is precisely comparable, even in the equal case
return bottomOrd - order;
} else {
// ord is only approx comparable: if they are not
// equal, we can use that; if they are equal, we
// must fallback to compare by value
final int cmp = bottomOrd - order;
if (cmp != 0) {
return cmp;
}
// take care of the case where both vals are null
if (order == NULL_ORD) return 0;
// and at this point we know that neither value is null, so safe to compare
termsIndex.lookup(order, tempBR);
return bottomValue.compareTo(tempBR);
}
}
@Override
public void copy(int slot, int doc) {
int ord = (int) readerOrds.get(doc);
if (ord == 0) {
ords[slot] = NULL_ORD;
values[slot] = null;
} else {
ords[slot] = ord;
assert ord > 0;
if (values[slot] == null) {
values[slot] = new BytesRef();
}
termsIndex.lookup(ord, values[slot]);
}
readerGen[slot] = currentReaderGen;
}
}
@Override
public FieldComparator setNextReader(IndexReader reader, int docBase) throws IOException {
termsIndex = FieldCache.DEFAULT.getTermsIndex(reader, field);
final PackedInts.Reader docToOrd = termsIndex.getDocToOrd();
FieldComparator perSegComp;
if (docToOrd instanceof Direct8) {
perSegComp = new ByteOrdComparator(((Direct8) docToOrd).getArray(), termsIndex, docBase);
} else if (docToOrd instanceof Direct16) {
perSegComp = new ShortOrdComparator(((Direct16) docToOrd).getArray(), termsIndex, docBase);
} else if (docToOrd instanceof Direct32) {
perSegComp = new IntOrdComparator(((Direct32) docToOrd).getArray(), termsIndex, docBase);
} else {
perSegComp = new AnyOrdComparator(docToOrd, termsIndex, docBase);
}
currentReaderGen++;
if (bottomSlot != -1) {
perSegComp.setBottom(bottomSlot);
}
return perSegComp;
}
@Override
public void setBottom(final int bottom) {
bottomSlot = bottom;
@ -423,6 +199,244 @@ public class MissingStringLastComparatorSource extends FieldComparatorSource {
@Override
public Comparable<?> value(int slot) {
return values==null ? NULL_VAL : values[slot];
return values==null ? parent.NULL_VAL : values[slot];
}
}
// Used per-segment when bit width of doc->ord is 8:
private static final class ByteOrdComparator extends PerSegmentComparator {
private final byte[] readerOrds;
public ByteOrdComparator(byte[] readerOrds, TermOrdValComparator_SML parent) {
super(parent);
this.readerOrds = readerOrds;
}
@Override
public int compareBottom(int doc) {
assert bottomSlot != -1;
int order = readerOrds[doc]&0xFF;
if (order == 0) order = NULL_ORD;
if (bottomSameReader) {
// ord is precisely comparable, even in the equal case
return bottomOrd - order;
} else {
// ord is only approx comparable: if they are not
// equal, we can use that; if they are equal, we
// must fallback to compare by value
final int cmp = bottomOrd - order;
if (cmp != 0) {
return cmp;
}
// take care of the case where both vals are null
if (order == NULL_ORD) return 0;
// and at this point we know that neither value is null, so safe to compare
termsIndex.lookup(order, tempBR);
return bottomValue.compareTo(tempBR);
}
}
@Override
public void copy(int slot, int doc) {
int ord = readerOrds[doc]&0xFF;
if (ord == 0) {
ords[slot] = NULL_ORD;
values[slot] = null;
} else {
ords[slot] = ord;
assert ord > 0;
if (values[slot] == null) {
values[slot] = new BytesRef();
}
termsIndex.lookup(ord, values[slot]);
}
readerGen[slot] = currentReaderGen;
}
}
// Used per-segment when bit width of doc->ord is 16:
private static final class ShortOrdComparator extends PerSegmentComparator {
private final short[] readerOrds;
public ShortOrdComparator(short[] readerOrds, TermOrdValComparator_SML parent) {
super(parent);
this.readerOrds = readerOrds;
}
@Override
public int compareBottom(int doc) {
assert bottomSlot != -1;
int order = readerOrds[doc]&0xFFFF;
if (order == 0) order = NULL_ORD;
if (bottomSameReader) {
// ord is precisely comparable, even in the equal case
return bottomOrd - order;
} else {
// ord is only approx comparable: if they are not
// equal, we can use that; if they are equal, we
// must fallback to compare by value
final int cmp = bottomOrd - order;
if (cmp != 0) {
return cmp;
}
// take care of the case where both vals are null
if (order == NULL_ORD) return 0;
// and at this point we know that neither value is null, so safe to compare
termsIndex.lookup(order, tempBR);
return bottomValue.compareTo(tempBR);
}
}
@Override
public void copy(int slot, int doc) {
int ord = readerOrds[doc]&0xFFFF;
if (ord == 0) {
ords[slot] = NULL_ORD;
values[slot] = null;
} else {
ords[slot] = ord;
assert ord > 0;
if (values[slot] == null) {
values[slot] = new BytesRef();
}
termsIndex.lookup(ord, values[slot]);
}
readerGen[slot] = currentReaderGen;
}
}
// Used per-segment when bit width of doc->ord is 32:
private static final class IntOrdComparator extends PerSegmentComparator {
private final int[] readerOrds;
public IntOrdComparator(int[] readerOrds, TermOrdValComparator_SML parent) {
super(parent);
this.readerOrds = readerOrds;
}
@Override
public int compareBottom(int doc) {
assert bottomSlot != -1;
int order = readerOrds[doc];
if (order == 0) order = NULL_ORD;
if (bottomSameReader) {
// ord is precisely comparable, even in the equal case
return bottomOrd - order;
} else {
// ord is only approx comparable: if they are not
// equal, we can use that; if they are equal, we
// must fallback to compare by value
final int cmp = bottomOrd - order;
if (cmp != 0) {
return cmp;
}
// take care of the case where both vals are null
if (order == NULL_ORD) return 0;
// and at this point we know that neither value is null, so safe to compare
termsIndex.lookup(order, tempBR);
return bottomValue.compareTo(tempBR);
}
}
@Override
public void copy(int slot, int doc) {
int ord = readerOrds[doc];
if (ord == 0) {
ords[slot] = NULL_ORD;
values[slot] = null;
} else {
ords[slot] = ord;
assert ord > 0;
if (values[slot] == null) {
values[slot] = new BytesRef();
}
termsIndex.lookup(ord, values[slot]);
}
readerGen[slot] = currentReaderGen;
}
}
// Used per-segment when bit width is not a native array
// size (8, 16, 32):
private static final class AnyOrdComparator extends PerSegmentComparator {
private final PackedInts.Reader readerOrds;
public AnyOrdComparator(PackedInts.Reader readerOrds, TermOrdValComparator_SML parent) {
super(parent);
this.readerOrds = readerOrds;
}
@Override
public int compareBottom(int doc) {
assert bottomSlot != -1;
int order = (int) readerOrds.get(doc);
if (order == 0) order = NULL_ORD;
if (bottomSameReader) {
// ord is precisely comparable, even in the equal case
return bottomOrd - order;
} else {
// ord is only approx comparable: if they are not
// equal, we can use that; if they are equal, we
// must fallback to compare by value
final int cmp = bottomOrd - order;
if (cmp != 0) {
return cmp;
}
// take care of the case where both vals are null
if (order == NULL_ORD) return 0;
// and at this point we know that neither value is null, so safe to compare
termsIndex.lookup(order, tempBR);
return bottomValue.compareTo(tempBR);
}
}
@Override
public void copy(int slot, int doc) {
int ord = (int) readerOrds.get(doc);
if (ord == 0) {
ords[slot] = NULL_ORD;
values[slot] = null;
} else {
ords[slot] = ord;
assert ord > 0;
if (values[slot] == null) {
values[slot] = new BytesRef();
}
termsIndex.lookup(ord, values[slot]);
}
readerGen[slot] = currentReaderGen;
}
}
public static FieldComparator createComparator(IndexReader reader, TermOrdValComparator_SML parent) throws IOException {
parent.termsIndex = FieldCache.DEFAULT.getTermsIndex(reader, parent.field);
final PackedInts.Reader docToOrd = parent.termsIndex.getDocToOrd();
PerSegmentComparator perSegComp;
if (docToOrd instanceof Direct8) {
perSegComp = new ByteOrdComparator(((Direct8) docToOrd).getArray(), parent);
} else if (docToOrd instanceof Direct16) {
perSegComp = new ShortOrdComparator(((Direct16) docToOrd).getArray(), parent);
} else if (docToOrd instanceof Direct32) {
perSegComp = new IntOrdComparator(((Direct32) docToOrd).getArray(), parent);
} else {
perSegComp = new AnyOrdComparator(docToOrd, parent);
}
if (perSegComp.bottomSlot != -1) {
perSegComp.setBottom(perSegComp.bottomSlot);
}
parent.current = perSegComp;
return perSegComp;
}
}