some microtuning
This commit is contained in:
Arndt Brenschede
parent
d963814d78
commit
2213d4f7fc
9 changed files with 278 additions and 149 deletions
|
|
@ -6,15 +6,19 @@ public class BitCoderContext
|
|||
private byte[] ab;
|
||||
private int idxMax;
|
||||
private int idx = -1;
|
||||
private int bm = 0x100; // byte mask (write mode)
|
||||
private int bits; // bits left in buffer (read mode)
|
||||
private int b;
|
||||
private int bits; // bits left in buffer
|
||||
private int b; // buffer word
|
||||
|
||||
private static final int[] vl_values = new int[4096];
|
||||
private static final int[] vl_length = new int[4096];
|
||||
|
||||
private static final int[] vc_values = new int[4096];
|
||||
private static final int[] vc_length = new int[4096];
|
||||
|
||||
private static final int[] reverse_byte = new int[256];
|
||||
|
||||
private static final int[] bm2bits = new int[256];
|
||||
|
||||
static
|
||||
{
|
||||
// fill varbits lookup table
|
||||
|
|
@ -30,6 +34,24 @@ public class BitCoderContext
|
|||
vl_values[i] = bc.decodeVarBits2();
|
||||
vl_length[i] = bc.getReadingBitPosition() - b0;
|
||||
}
|
||||
for( int i=0; i<4096; i++ )
|
||||
{
|
||||
bc.reset();
|
||||
int b0 = bc.getWritingBitPosition();
|
||||
bc.encodeVarBits2( i );
|
||||
vc_values[i] = bc.b;
|
||||
vc_length[i] = bc.getWritingBitPosition() - b0;
|
||||
}
|
||||
for( int i=0; i<1024; i++ )
|
||||
{
|
||||
bc.reset();
|
||||
bc.bits = 14;
|
||||
bc.b = 0x1000 + i;
|
||||
|
||||
int b0 = bc.getReadingBitPosition();
|
||||
vl_values[i] = bc.decodeVarBits2();
|
||||
vl_length[i] = bc.getReadingBitPosition() - b0;
|
||||
}
|
||||
for( int b=0; b<256; b++ )
|
||||
{
|
||||
int r = 0;
|
||||
|
|
@ -39,6 +61,10 @@ public class BitCoderContext
|
|||
}
|
||||
reverse_byte[b] = r;
|
||||
}
|
||||
for( int b=0; b<8; b++ )
|
||||
{
|
||||
bm2bits[1<<b] = b;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -58,7 +84,6 @@ public class BitCoderContext
|
|||
public final void reset()
|
||||
{
|
||||
idx = -1;
|
||||
bm = 0x100;
|
||||
bits = 0;
|
||||
b = 0;
|
||||
}
|
||||
|
|
@ -73,7 +98,7 @@ public class BitCoderContext
|
|||
*
|
||||
* @see #decodeVarBits
|
||||
*/
|
||||
public final void encodeVarBits( int value )
|
||||
public final void encodeVarBits2( int value )
|
||||
{
|
||||
int range = 0;
|
||||
while (value > range)
|
||||
|
|
@ -86,6 +111,20 @@ public class BitCoderContext
|
|||
encodeBounded( range, value );
|
||||
}
|
||||
|
||||
public final void encodeVarBits( int value )
|
||||
{
|
||||
if ( (value & 0xfff) == value )
|
||||
{
|
||||
flushBuffer();
|
||||
b |= vc_values[value] << bits;
|
||||
bits += vc_length[value];
|
||||
}
|
||||
else
|
||||
{
|
||||
encodeVarBits2( value ); // slow fallback for large values
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @see #encodeVarBits
|
||||
*/
|
||||
|
|
@ -120,20 +159,39 @@ public class BitCoderContext
|
|||
bits -= len;
|
||||
return mask;
|
||||
}
|
||||
return decodeVarBits2();
|
||||
if ( (b & 0xffffff) != 0 )
|
||||
{
|
||||
// here we just know len in [25..47]
|
||||
// ( fillBuffer guarantees only 24 bits! )
|
||||
b >>>= 12;
|
||||
int len3 = 1 + (vl_length[b & 0xfff]>>1);
|
||||
b >>>= len3;
|
||||
int len2 = 11 + len3;
|
||||
bits -= len2+1;
|
||||
fillBuffer();
|
||||
int mask = 0xffffffff >>> ( 32 - len2 );
|
||||
mask += b & mask;
|
||||
b >>>= len2;
|
||||
bits -= len2;
|
||||
return mask;
|
||||
}
|
||||
return decodeVarBits2(); // no chance, use the slow one
|
||||
}
|
||||
|
||||
|
||||
public final void encodeBit( boolean value )
|
||||
{
|
||||
if ( bm == 0x100 )
|
||||
if (bits > 31)
|
||||
{
|
||||
bm = 1;
|
||||
ab[++idx] = 0;
|
||||
ab[++idx] = (byte)(b & 0xff);
|
||||
b >>>= 8;
|
||||
bits -=8;
|
||||
}
|
||||
if ( value )
|
||||
ab[idx] |= bm;
|
||||
bm <<= 1;
|
||||
{
|
||||
b |= 1 << bits;
|
||||
}
|
||||
bits++;
|
||||
}
|
||||
|
||||
public final boolean decodeBit()
|
||||
|
|
@ -160,17 +218,15 @@ public class BitCoderContext
|
|||
int im = 1; // integer mask
|
||||
while (im <= max)
|
||||
{
|
||||
if ( bm == 0x100 )
|
||||
{
|
||||
bm = 1;
|
||||
ab[++idx] = 0;
|
||||
}
|
||||
if ( ( value & im ) != 0 )
|
||||
{
|
||||
ab[idx] |= bm;
|
||||
encodeBit( true );
|
||||
max -= im;
|
||||
}
|
||||
bm <<= 1;
|
||||
else
|
||||
{
|
||||
encodeBit( false );
|
||||
}
|
||||
im <<= 1;
|
||||
}
|
||||
}
|
||||
|
|
@ -239,27 +295,37 @@ public class BitCoderContext
|
|||
}
|
||||
}
|
||||
|
||||
private void flushBuffer()
|
||||
{
|
||||
while (bits > 7)
|
||||
{
|
||||
ab[++idx] = (byte)(b & 0xff);
|
||||
b >>>= 8;
|
||||
bits -=8;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* flushes and closes the (write-mode) context
|
||||
*
|
||||
* @return the encoded length in bytes
|
||||
*/
|
||||
public final int getEncodedLength()
|
||||
public final int closeAndGetEncodedLength()
|
||||
{
|
||||
flushBuffer();
|
||||
if ( bits > 0 )
|
||||
{
|
||||
ab[++idx] = (byte)(b & 0xff);
|
||||
}
|
||||
return idx + 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return the encoded length in bits
|
||||
*/
|
||||
public final long getWritingBitPosition()
|
||||
public final int getWritingBitPosition()
|
||||
{
|
||||
long bitpos = idx << 3;
|
||||
int m = bm;
|
||||
while (m > 1)
|
||||
{
|
||||
bitpos++;
|
||||
m >>= 1;
|
||||
}
|
||||
return bitpos;
|
||||
return (idx << 3) + 8 + bits;
|
||||
}
|
||||
|
||||
public final int getReadingBitPosition()
|
||||
|
|
@ -275,40 +341,33 @@ public class BitCoderContext
|
|||
b >>>= (8-bits);
|
||||
}
|
||||
|
||||
public final void copyBitsTo( byte[] dst, int bitcount )
|
||||
public static void main( String[] args )
|
||||
{
|
||||
int dstIdx = 0;
|
||||
for(;;)
|
||||
byte[] ab = new byte[581969];
|
||||
BitCoderContext ctx = new BitCoderContext( ab );
|
||||
for ( int i = 0; i < 31; i++ )
|
||||
{
|
||||
if ( bitcount > 8 )
|
||||
{
|
||||
if ( bits < 8 )
|
||||
{
|
||||
b |= (ab[++idx] & 0xff) << bits;
|
||||
}
|
||||
else
|
||||
{
|
||||
bits -= 8;
|
||||
}
|
||||
dst[dstIdx++] = (byte)b;
|
||||
b >>>= 8;
|
||||
bitcount -= 8;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( bits < bitcount )
|
||||
{
|
||||
b |= (ab[++idx] & 0xff) << bits;
|
||||
bits += 8;
|
||||
}
|
||||
ctx.encodeVarBits( (1<<i)+3 );
|
||||
}
|
||||
for ( int i = 0; i < 100000; i+=13 )
|
||||
{
|
||||
ctx.encodeVarBits( i );
|
||||
}
|
||||
ctx.closeAndGetEncodedLength();
|
||||
ctx = new BitCoderContext( ab );
|
||||
|
||||
int mask = 0xff >>> ( 8 - bitcount );
|
||||
dst[dstIdx] = (byte)(b & mask);
|
||||
bits -= bitcount;
|
||||
b >>>= bitcount;
|
||||
break;
|
||||
}
|
||||
for ( int i = 0; i < 31; i++ )
|
||||
{
|
||||
int value = ctx.decodeVarBits();
|
||||
int v0 = (1<<i)+3;
|
||||
if ( !(v0 == value ) )
|
||||
throw new RuntimeException( "value mismatch value=" + value + "v0=" + v0 );
|
||||
}
|
||||
for ( int i = 0; i < 100000; i+=13 )
|
||||
{
|
||||
int value = ctx.decodeVarBits();
|
||||
if ( !(value == i ) )
|
||||
throw new RuntimeException( "value mismatch i=" + i + "v=" + value );
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -26,21 +26,12 @@ public final class SortedHeap<V>
|
|||
public V popLowestKeyValue()
|
||||
{
|
||||
SortedBin bin = firstNonEmpty;
|
||||
if ( bin == null )
|
||||
if ( firstNonEmpty == null )
|
||||
{
|
||||
return null;
|
||||
}
|
||||
size--;
|
||||
int minId = bin.lv;
|
||||
SortedBin minBin = bin;
|
||||
while( ( bin = bin.nextNonEmpty ) != null )
|
||||
{
|
||||
if ( bin.lv < minId )
|
||||
{
|
||||
minId = bin.lv;
|
||||
minBin = bin;
|
||||
}
|
||||
}
|
||||
SortedBin minBin = firstNonEmpty.getMinBin();
|
||||
return (V) minBin.dropLowest();
|
||||
}
|
||||
|
||||
|
|
@ -127,7 +118,112 @@ public final class SortedHeap<V>
|
|||
}
|
||||
}
|
||||
|
||||
// unrolled version of above for binsize = 4
|
||||
void add4( int key, Object value )
|
||||
{
|
||||
int p = lp--;
|
||||
if ( p == 4 || key < al[p] )
|
||||
{
|
||||
lv = al[p - 1] = key;
|
||||
vla[p - 1] = value;
|
||||
return;
|
||||
}
|
||||
lv = al[p - 1] = al[p];
|
||||
vla[p - 1] = vla[p];
|
||||
p++;
|
||||
|
||||
if ( p == 4 || key < al[p] )
|
||||
{
|
||||
al[p - 1] = key;
|
||||
vla[p - 1] = value;
|
||||
return;
|
||||
}
|
||||
al[p - 1] = al[p];
|
||||
vla[p - 1] = vla[p];
|
||||
p++;
|
||||
|
||||
if ( p == 4 || key < al[p] )
|
||||
{
|
||||
al[p - 1] = key;
|
||||
vla[p - 1] = value;
|
||||
return;
|
||||
}
|
||||
al[p - 1] = al[p];
|
||||
vla[p - 1] = vla[p];
|
||||
|
||||
al[p] = key;
|
||||
vla[p] = value;
|
||||
}
|
||||
|
||||
// unrolled loop for performance sake
|
||||
SortedBin getMinBin()
|
||||
{
|
||||
SortedBin minBin = this;
|
||||
SortedBin bin = this;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
if ( (bin = bin.nextNonEmpty) == null ) return minBin;
|
||||
if ( bin.lv < minBin.lv ) minBin = bin;
|
||||
return minBin;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -146,7 +242,7 @@ public final class SortedHeap<V>
|
|||
}
|
||||
if ( first.lp > 0 )
|
||||
{
|
||||
first.add( key, value );
|
||||
first.add4( key, value );
|
||||
if ( firstNonEmpty != first )
|
||||
{
|
||||
first.nextNonEmpty = firstNonEmpty;
|
||||
|
|
@ -155,7 +251,7 @@ public final class SortedHeap<V>
|
|||
}
|
||||
else // second bin not full
|
||||
{
|
||||
second.add( key, value );
|
||||
second.add4( key, value );
|
||||
if ( first.nextNonEmpty != second )
|
||||
{
|
||||
second.nextNonEmpty = first.nextNonEmpty;
|
||||
|
|
@ -199,21 +295,9 @@ public final class SortedHeap<V>
|
|||
// now merge the content of these non-empty bins into the target bin
|
||||
while( firstNonEmpty != null )
|
||||
{
|
||||
SortedBin ne = firstNonEmpty;
|
||||
SortedBin minBin = ne;
|
||||
int minId = minBin.lv;
|
||||
|
||||
while ( ( ne = ne.nextNonEmpty ) != null )
|
||||
{
|
||||
if ( ne.lv < minId )
|
||||
{
|
||||
minBin = ne;
|
||||
minId = minBin.lv;
|
||||
}
|
||||
}
|
||||
|
||||
// current minimum found, copy to target array
|
||||
al_t[tp] = minId;
|
||||
// copy current minimum to target array
|
||||
SortedBin minBin = firstNonEmpty.getMinBin();
|
||||
al_t[tp] = minBin.lv;
|
||||
vla_t[tp++] = minBin.dropLowest();
|
||||
}
|
||||
|
||||
|
|
@ -265,35 +349,4 @@ public final class SortedHeap<V>
|
|||
}
|
||||
return tp;
|
||||
}
|
||||
|
||||
public static void main(String[] args)
|
||||
{
|
||||
SortedHeap<String> sh = new SortedHeap<String>();
|
||||
Random rnd = new Random();
|
||||
for( int i = 0; i< 1000; i++ )
|
||||
{
|
||||
int val = rnd.nextInt( 1000000 );
|
||||
sh.add( val, "" + val );
|
||||
val = rnd.nextInt( 1000000 );
|
||||
sh.add( val, "" + val );
|
||||
sh.popLowestKeyValue();
|
||||
}
|
||||
|
||||
int cnt = 0;
|
||||
int lastval = 0;
|
||||
for(;;)
|
||||
{
|
||||
String s = sh.popLowestKeyValue();
|
||||
if ( s == null ) break;
|
||||
cnt ++;
|
||||
int val = Integer.parseInt( s );
|
||||
System.out.println( "popLowestKeyValue: " + val);
|
||||
// Assert.assertTrue( "sorting test", val >= lastval );
|
||||
lastval = val;
|
||||
}
|
||||
// Assert.assertTrue( "total count test", cnt == 100000 );
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,18 +8,29 @@ public class BitCoderContextTest
|
|||
@Test
|
||||
public void varBitsEncodeDecodeTest()
|
||||
{
|
||||
byte[] ab = new byte[4000];
|
||||
byte[] ab = new byte[581969];
|
||||
BitCoderContext ctx = new BitCoderContext( ab );
|
||||
for ( int i = 0; i < 1000; i++ )
|
||||
for ( int i = 0; i < 31; i++ )
|
||||
{
|
||||
ctx.encodeVarBits( (1<<i)+3 );
|
||||
}
|
||||
for ( int i = 0; i < 100000; i+=13 )
|
||||
{
|
||||
ctx.encodeVarBits( i );
|
||||
}
|
||||
ctx.closeAndGetEncodedLength();
|
||||
ctx = new BitCoderContext( ab );
|
||||
|
||||
for ( int i = 0; i < 1000; i++ )
|
||||
for ( int i = 0; i < 31; i++ )
|
||||
{
|
||||
int value = ctx.decodeVarBits();
|
||||
Assert.assertTrue( "distance value mismatch i=" + i + "v=" + value, value == i );
|
||||
int v0 = (1<<i)+3;
|
||||
Assert.assertTrue( "value mismatch value=" + value + "v0=" + v0, v0 == value );
|
||||
}
|
||||
for ( int i = 0; i < 100000; i+=13 )
|
||||
{
|
||||
int value = ctx.decodeVarBits();
|
||||
Assert.assertTrue( "value mismatch i=" + i + "v=" + value, value == i );
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -35,6 +46,7 @@ public class BitCoderContextTest
|
|||
ctx.encodeBounded( max, val );
|
||||
}
|
||||
}
|
||||
ctx.closeAndGetEncodedLength();
|
||||
|
||||
ctx = new BitCoderContext( ab );
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue