boxtec
/
yacy_search_server
mirror of https://github.com/yacy/yacy_search_server
4
1
Fork 0
Code Issues Projects Releases Wiki Activity

performance hacks

Browse Source 
git-svn-id: https://svn.berlios.de/svnroot/repos/yacy/trunk@7988 6c8d7289-2bf4-0310-a012-ef5d649a1542
pull/1/head
orbiter 14 years ago
parent a7df70221e
commit 7df0643f0e
4 changed files with 161 additions and 83 deletions
Show Stats Download Patch File Download Diff File

2
source/net/yacy/kelondro/index/Row.java
Unescape View File

@ -346,7 +346,7 @@ public final class Row {
// compares only the content of the primary key
if (Row.this.objectOrder == null) throw new kelondroException("objects cannot be compared, no order given");
assert Row.this.primaryKeyLength == o.getPrimaryKeyLength();
return Row.this.objectOrder.compare(bytes(), 0, o.bytes(), 0, Row.this.primaryKeyLength);
return Row.this.objectOrder.compare(bytes(), o.bytes(), Row.this.primaryKeyLength);
}
public int compare(final Entry o1, final Entry o2) {

109
source/net/yacy/kelondro/order/Base64Order.java
Unescape View File

@ -406,9 +406,9 @@ public class Base64Order extends AbstractOrder<byte[]> implements ByteOrder, Com
public final int compare(final byte[] a, final byte[] b) {
try {
return (this.asc) ?
((this.zero == null) ? compares(a, b) : compare0(a, 0, b, 0, a.length))
((this.zero == null) ? compares(a, b) : compare0(a, b, a.length))
:
((this.zero == null) ? compares(b, a) : compare0(b, 0, a, 0, a.length));
((this.zero == null) ? compares(b, a) : compare0(b, a, a.length));
} catch (final Throwable e) {
// if a or b is not well-formed, an ArrayIndexOutOfBoundsException may occur
// in that case we don't want that the exception makes databse functions
@ -429,6 +429,27 @@ public class Base64Order extends AbstractOrder<byte[]> implements ByteOrder, Com
}
}
public final int compare(final byte[] a, final byte[] b, final int length) {
try {
return (this.asc) ?
compare0(a, b, length)
:
compare0(b, a, length);
} catch (final Throwable e) {
// same handling as in simple compare method above
final boolean wfa = wellformed(a, 0, length);
final boolean wfb = wellformed(b, 0, length);
if (wfa && wfb) {
// uh strange. throw the exception
if (e instanceof ArrayIndexOutOfBoundsException) throw (ArrayIndexOutOfBoundsException) e;
throw new RuntimeException(e.getMessage());
}
if (wfa) return (this.asc) ? -1 : 1;
if (wfb) return (this.asc) ? 1 : -1;
return ((this.asc) ? 1 : -1) * NaturalOrder.naturalOrder.compare(a, b, length);
}
}
public final int compare(final byte[] a, final int aoffset, final byte[] b, final int boffset, final int length) {
try {
return (this.asc) ?
@ -450,33 +471,44 @@ public class Base64Order extends AbstractOrder<byte[]> implements ByteOrder, Com
}
}
private final int compare0(final byte[] a, final int aoffset, final byte[] b, final int boffset, final int length) {
private final int compare0(final byte[] a, final byte[] b, int length) {
if (this.zero == null) return compares(a, b, length);
// we have an artificial start point. check all combinations
if (this.zero.length < length) length = this.zero.length;
final int az = compares(a, this.zero, length); // -1 if a < z; 0 if a == z; 1 if a > z
final int bz = compares(b, this.zero, length); // -1 if b < z; 0 if b == z; 1 if b > z
if (az == bz) return compares(a, b, length);
return sig(az - bz);
}
private final int compare0(final byte[] a, final int aoffset, final byte[] b, final int boffset, int length) {
if (this.zero == null) return compares(a, aoffset, b, boffset, length);
// we have an artificial start point. check all combinations
final int az = compares(a, aoffset, this.zero, 0, Math.min(length, this.zero.length)); // -1 if a < z; 0 if a == z; 1 if a > z
final int bz = compares(b, boffset, this.zero, 0, Math.min(length, this.zero.length)); // -1 if b < z; 0 if b == z; 1 if b > z
if (this.zero.length < length) length = this.zero.length;
final int az = compares(a, aoffset, this.zero, 0, length); // -1 if a < z; 0 if a == z; 1 if a > z
final int bz = compares(b, boffset, this.zero, 0, length); // -1 if b < z; 0 if b == z; 1 if b > z
if (az == bz) return compares(a, aoffset, b, boffset, length);
return sig(az - bz);
}
private final int compares(final byte[] a, final byte[] b) {
assert (this.ahpla.length == 128);
//assert (this.ahpla.length == 128);
short i = 0;
final int al = a.length;
final int bl = b.length;
final short ml = (short) Math.min(al, bl);
byte ac, bc;
while (i < ml) { // trace point
assert (i < a.length) : "i = " + i + ", aoffset = " + 0 + ", a.length = " + a.length + ", a = " + NaturalOrder.arrayList(a, 0, al);
assert (i < b.length) : "i = " + i + ", boffset = " + 0 + ", b.length = " + b.length + ", b = " + NaturalOrder.arrayList(b, 0, al);
//assert (i < a.length) : "i = " + i + ", aoffset = " + 0 + ", a.length = " + a.length + ", a = " + NaturalOrder.arrayList(a, 0, al);
//assert (i < b.length) : "i = " + i + ", boffset = " + 0 + ", b.length = " + b.length + ", b = " + NaturalOrder.arrayList(b, 0, al);
ac = a[i];
assert (ac >= 0) && (ac < 128) : "ac = " + ac + ", a = " + NaturalOrder.arrayList(a, 0, al);
//assert (ac >= 0) && (ac < 128) : "ac = " + ac + ", a = " + NaturalOrder.arrayList(a, 0, al);
bc = b[i];
assert (bc >= 0) && (bc < 128) : "bc = " + bc + ", b = " + NaturalOrder.arrayList(b, 0, al);
assert ac != 0;
assert bc != 0;
//if ((ac == 0) && (bc == 0)) return 0; // zero-terminated length
//assert (bc >= 0) && (bc < 128) : "bc = " + bc + ", b = " + NaturalOrder.arrayList(b, 0, al);
//assert ac != 0;
//assert bc != 0;
if (ac != bc) return this.ab[(ac << 7) | bc];
i++;
}
@ -487,30 +519,45 @@ public class Base64Order extends AbstractOrder<byte[]> implements ByteOrder, Com
return 0;
}
private final int compares(final byte[] a, final int aoffset, final byte[] b, final int boffset, final int length) {
assert (aoffset + length <= a.length) : "a.length = " + a.length + ", aoffset = " + aoffset + ", alength = " + length;
assert (boffset + length <= b.length) : "b.length = " + b.length + ", boffset = " + boffset + ", blength = " + length;
private final int compares(final byte[] a, final byte[] b, final int length) {
assert (length <= a.length) : "a.length = " + a.length + ", alength = " + length;
assert (length <= b.length) : "b.length = " + b.length + ", blength = " + length;
assert (this.ahpla.length == 128);
short i = 0;
byte ac, bc;
//byte acc, bcc;
//int c = 0;
while (i < length) {
assert (i + aoffset < a.length) : "i = " + i + ", aoffset = " + aoffset + ", a.length = " + a.length + ", a = " + NaturalOrder.arrayList(a, aoffset, length);
assert (i + boffset < b.length) : "i = " + i + ", boffset = " + boffset + ", b.length = " + b.length + ", b = " + NaturalOrder.arrayList(b, boffset, length);
ac = a[aoffset + i];
assert (ac >= 0) && (ac < 128) : "ac = " + ac + ", a = " + NaturalOrder.arrayList(a, aoffset, length);
bc = b[boffset + i];
assert (bc >= 0) && (bc < 128) : "bc = " + bc + ", b = " + NaturalOrder.arrayList(b, boffset, length);
assert (i < a.length) : "i = " + i + ", a.length = " + a.length + ", a = " + NaturalOrder.arrayList(a, 0, length);
assert (i < b.length) : "i = " + i + ", b.length = " + b.length + ", b = " + NaturalOrder.arrayList(b, 0, length);
ac = a[i];
assert (ac >= 0) && (ac < 128) : "ac = " + ac + ", a = " + NaturalOrder.arrayList(a, 0, length);
bc = b[i];
assert (bc >= 0) && (bc < 128) : "bc = " + bc + ", b = " + NaturalOrder.arrayList(b, 0, length);
assert ac != 0;
assert bc != 0;
//if ((ac == 0) && (bc == 0)) return 0; // zero-terminated length
if (ac == bc) {
// shortcut in case of equality: we don't need to lookup the ahpla value
i++;
continue;
}
return this.ab[(ac << 7) | bc];
if (ac != bc) return this.ab[(ac << 7) | bc];
i++;
}
// they are equal
return 0;
}
private final int compares(final byte[] a, final int aoffset, final byte[] b, final int boffset, final int length) {
//assert (aoffset + length <= a.length) : "a.length = " + a.length + ", aoffset = " + aoffset + ", alength = " + length;
//assert (boffset + length <= b.length) : "b.length = " + b.length + ", boffset = " + boffset + ", blength = " + length;
//assert (this.ahpla.length == 128);
short i = 0;
byte ac, bc;
while (i < length) {
//assert (i + aoffset < a.length) : "i = " + i + ", aoffset = " + aoffset + ", a.length = " + a.length + ", a = " + NaturalOrder.arrayList(a, aoffset, length);
//assert (i + boffset < b.length) : "i = " + i + ", boffset = " + boffset + ", b.length = " + b.length + ", b = " + NaturalOrder.arrayList(b, boffset, length);
ac = a[aoffset + i];
//assert (ac >= 0) && (ac < 128) : "ac = " + ac + ", a = " + NaturalOrder.arrayList(a, aoffset, length);
bc = b[boffset + i];
//assert (bc >= 0) && (bc < 128) : "bc = " + bc + ", b = " + NaturalOrder.arrayList(b, boffset, length);
//assert ac != 0;
//assert bc != 0;
if (ac != bc) return this.ab[(ac << 7) | bc];
i++;
}
// they are equal
return 0;

2
source/net/yacy/kelondro/order/ByteOrder.java
Unescape View File

@ -40,6 +40,8 @@ public interface ByteOrder extends Order<byte[]> {
public int compare(byte[] a, byte[] b);
public int compare(byte[] a, byte[] b, int len);
public int compare(byte[] a, int astart, byte[] b, int bstart, int len);
public boolean equal(final byte[] a, final byte[] b);

71
source/net/yacy/kelondro/order/NaturalOrder.java
Unescape View File

@ -76,16 +76,16 @@ public final class NaturalOrder extends AbstractOrder<byte[]> implements ByteOrd
}
public final String signature() {
if (!asc) return "nd";
if ( asc) return "nu";
if (!this.asc) return "nd";
if ( this.asc) return "nu";
return null;
}
private final static long cardinalI(final byte[] key, int off, int len) {
private final static long cardinalI(final byte[] key, int off, final int len) {
// returns a cardinal number in the range of 0 .. Long.MAX_VALUE
long c = 0;
int lim = off + Math.min(8, len);
int lim8 = off + 8;
final int lim = off + Math.min(8, len);
final int lim8 = off + 8;
while (off < lim) c = (c << 8) | ((long) key[off++] & 0xFF);
while (off++ < lim8) c = (c << 8);
c = c >>> 1;
@ -100,7 +100,7 @@ public final class NaturalOrder extends AbstractOrder<byte[]> implements ByteOrd
return Long.MAX_VALUE - keyCardinal + zeroCardinal;
}
public long cardinal(final byte[] key, int off, int len) {
public long cardinal(final byte[] key, final int off, final int len) {
if (this.zero == null) return cardinalI(key, off, len);
final long zeroCardinal = cardinalI(this.zero, 0, this.zero.length);
final long keyCardinal = cardinalI(key, off, len);
@ -152,29 +152,43 @@ public final class NaturalOrder extends AbstractOrder<byte[]> implements ByteOrd
// with filled-up char(0)-values
public final int compare(final byte[] a, final byte[] b) {
if (a.length == b.length) {
return (asc) ? compare0(a, 0, b, 0, a.length) : compare0(b, 0, a, 0, a.length);
return (this.asc) ? compare0(a, 0, b, 0, a.length) : compare0(b, 0, a, 0, a.length);
}
int length = Math.min(a.length, b.length);
if (asc) {
int c = compare0(a, 0, b, 0, length);
final int length = Math.min(a.length, b.length);
if (this.asc) {
final int c = compare0(a, 0, b, 0, length);
if (c != 0) return c;
return (a.length > b.length) ? 1 : -1;
}
int c = compare0(b, 0, a, 0, length);
final int c = compare0(b, 0, a, 0, length);
if (c != 0) return c;
return (a.length > b.length) ? -1 : 1;
}
public final int compare(final byte[] a, final byte[] b, final int length) {
return (this.asc) ? compare0(a, b, length) : compare0(b, a, length);
}
public final int compare(final byte[] a, final int aoffset, final byte[] b, final int boffset, final int length) {
return (asc) ? compare0(a, aoffset, b, boffset, length) : compare0(b, boffset, a, aoffset, length);
return (this.asc) ? compare0(a, aoffset, b, boffset, length) : compare0(b, boffset, a, aoffset, length);
}
public final int compare0(final byte[] a, final int aoffset, final byte[] b, final int boffset, final int length) {
if (zero == null) return compares(a, aoffset, b, boffset, length);
private final int compare0(final byte[] a, final byte[] b, final int length) {
if (this.zero == null) return compares(a, b, length);
// we have an artificial start point. check all combinations
assert length == zero.length;
final int az = compares(a, aoffset, zero, 0, length); // -1 if a < z; 0 if a == z; 1 if a > z
final int bz = compares(b, boffset, zero, 0, length); // -1 if b < z; 0 if b == z; 1 if b > z
assert length == this.zero.length;
final int az = compares(a, this.zero, length); // -1 if a < z; 0 if a == z; 1 if a > z
final int bz = compares(b, this.zero, length); // -1 if b < z; 0 if b == z; 1 if b > z
if (az == bz) return compares(a, b, length);
return sig(az - bz);
}
private final int compare0(final byte[] a, final int aoffset, final byte[] b, final int boffset, final int length) {
if (this.zero == null) return compares(a, aoffset, b, boffset, length);
// we have an artificial start point. check all combinations
assert length == this.zero.length;
final int az = compares(a, aoffset, this.zero, 0, length); // -1 if a < z; 0 if a == z; 1 if a > z
final int bz = compares(b, boffset, this.zero, 0, length); // -1 if b < z; 0 if b == z; 1 if b > z
if (az == bz) return compares(a, aoffset, b, boffset, length);
return sig(az - bz);
}
@ -201,7 +215,22 @@ public final class NaturalOrder extends AbstractOrder<byte[]> implements ByteOrd
return true;
}
public static final int compares(final byte[] a, final int aoffset, final byte[] b, final int boffset, final int length) {
private static final int compares(final byte[] a, final byte[] b, final int length) {
int i = 0;
int aa, bb;
while (i < length) {
aa = 0xff & a[i];
bb = 0xff & b[i];
if (aa > bb) return 1;
if (aa < bb) return -1;
// else the bytes are equal and it may go on yet undecided
i++;
}
// they are equal
return 0;
}
private static final int compares(final byte[] a, final int aoffset, final byte[] b, final int boffset, final int length) {
int i = 0;
int aa, bb;
while (i < length) {
@ -243,7 +272,7 @@ public final class NaturalOrder extends AbstractOrder<byte[]> implements ByteOrd
return sb.toString();
}
public static Iterator<Long> LongIterator(Iterator<byte[]> b256Iterator) {
public static Iterator<Long> LongIterator(final Iterator<byte[]> b256Iterator) {
return new LongIter(b256Iterator);
}
@ -251,7 +280,7 @@ public final class NaturalOrder extends AbstractOrder<byte[]> implements ByteOrd
private final Iterator<byte[]> b256Iterator;
public LongIter(Iterator<byte[]> b256Iterator) {
public LongIter(final Iterator<byte[]> b256Iterator) {
this.b256Iterator = b256Iterator;
}
@ -260,7 +289,7 @@ public final class NaturalOrder extends AbstractOrder<byte[]> implements ByteOrd
}
public Long next() {
byte[] b = this.b256Iterator.next();
final byte[] b = this.b256Iterator.next();
assert (b != null);
if (b == null) return null;
return Long.valueOf(decodeLong(b));

Write Preview
Loading…
Cancel
Save