You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by jp...@apache.org on 2012/08/29 12:32:43 UTC
svn commit: r1378497 [3/3] - in /lucene/dev/branches/branch_4x/lucene: ./
core/src/java/org/apache/lucene/util/packed/
Modified: lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked9.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked9.java?rev=1378497&r1=1378496&r2=1378497&view=diff
==============================================================================
--- lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked9.java (original)
+++ lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked9.java Wed Aug 29 10:32:40 2012
@@ -22,15 +22,12 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPacked9 extends BulkOperation {
- @Override
- public int blockCount() {
- return 9;
- }
+final class BulkOperationPacked9 extends BulkOperationPacked {
- @Override
- public int valueCount() {
- return 64;
+ public BulkOperationPacked9() {
+ super(9);
+ assert blockCount() == 9;
+ assert valueCount() == 64;
}
@Override
@@ -483,38 +480,4 @@ final class BulkOperationPacked9 extends
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 55) | ((values[valuesOffset++] & 0xffffffffL) << 46) | ((values[valuesOffset++] & 0xffffffffL) << 37) | ((values[valuesOffset++] & 0xffffffffL) << 28) | ((values[valuesOffset++] & 0xffffffffL) << 19) | ((values[valuesOffset++] & 0xffffffffL) << 10) | ((values[valuesOffset++] & 0xffffffffL) << 1) | ((values[valuesOffset] & 0xffffffffL) >>> 8);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 56) | ((values[valuesOffset++] & 0xffffffffL) << 47) | ((values[valuesOffset++] & 0xffffffffL) << 38) | ((values[valuesOffset++] & 0xffffffffL) << 29) | ((values[valuesOffset++] & 0xffffffffL) << 20) | ((values[valuesOffset++] & 0xffffffffL) << 11) | ((values[valuesOffset++] & 0xffffffffL) << 2) | ((values[valuesOffset] & 0xffffffffL) >>> 7);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 57) | ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 39) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 21) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset++] & 0xffffffffL) << 3) | ((values[valuesOffset] & 0xffffffffL) >>> 6);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 58) | ((values[valuesOffset++] & 0xffffffffL) << 49) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 31) | ((values[valuesOffset++] & 0xffffffffL) << 22) | ((values[valuesOffset++] & 0xffffffffL) << 13) | ((values[valuesOffset++] & 0xffffffffL) << 4) | ((values[valuesOffset] & 0xffffffffL) >>> 5);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 59) | ((values[valuesOffset++] & 0xffffffffL) << 50) | ((values[valuesOffset++] & 0xffffffffL) << 41) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 23) | ((values[valuesOffset++] & 0xffffffffL) << 14) | ((values[valuesOffset++] & 0xffffffffL) << 5) | ((values[valuesOffset] & 0xffffffffL) >>> 4);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 60) | ((values[valuesOffset++] & 0xffffffffL) << 51) | ((values[valuesOffset++] & 0xffffffffL) << 42) | ((values[valuesOffset++] & 0xffffffffL) << 33) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 15) | ((values[valuesOffset++] & 0xffffffffL) << 6) | ((values[valuesOffset] & 0xffffffffL) >>> 3);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 61) | ((values[valuesOffset++] & 0xffffffffL) << 52) | ((values[valuesOffset++] & 0xffffffffL) << 43) | ((values[valuesOffset++] & 0xffffffffL) << 34) | ((values[valuesOffset++] & 0xffffffffL) << 25) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset++] & 0xffffffffL) << 7) | ((values[valuesOffset] & 0xffffffffL) >>> 2);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 62) | ((values[valuesOffset++] & 0xffffffffL) << 53) | ((values[valuesOffset++] & 0xffffffffL) << 44) | ((values[valuesOffset++] & 0xffffffffL) << 35) | ((values[valuesOffset++] & 0xffffffffL) << 26) | ((values[valuesOffset++] & 0xffffffffL) << 17) | ((values[valuesOffset++] & 0xffffffffL) << 8) | ((values[valuesOffset] & 0xffffffffL) >>> 1);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 63) | ((values[valuesOffset++] & 0xffffffffL) << 54) | ((values[valuesOffset++] & 0xffffffffL) << 45) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 27) | ((values[valuesOffset++] & 0xffffffffL) << 18) | ((values[valuesOffset++] & 0xffffffffL) << 9) | (values[valuesOffset++] & 0xffffffffL);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] << 55) | (values[valuesOffset++] << 46) | (values[valuesOffset++] << 37) | (values[valuesOffset++] << 28) | (values[valuesOffset++] << 19) | (values[valuesOffset++] << 10) | (values[valuesOffset++] << 1) | (values[valuesOffset] >>> 8);
- blocks[blocksOffset++] = (values[valuesOffset++] << 56) | (values[valuesOffset++] << 47) | (values[valuesOffset++] << 38) | (values[valuesOffset++] << 29) | (values[valuesOffset++] << 20) | (values[valuesOffset++] << 11) | (values[valuesOffset++] << 2) | (values[valuesOffset] >>> 7);
- blocks[blocksOffset++] = (values[valuesOffset++] << 57) | (values[valuesOffset++] << 48) | (values[valuesOffset++] << 39) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 21) | (values[valuesOffset++] << 12) | (values[valuesOffset++] << 3) | (values[valuesOffset] >>> 6);
- blocks[blocksOffset++] = (values[valuesOffset++] << 58) | (values[valuesOffset++] << 49) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 31) | (values[valuesOffset++] << 22) | (values[valuesOffset++] << 13) | (values[valuesOffset++] << 4) | (values[valuesOffset] >>> 5);
- blocks[blocksOffset++] = (values[valuesOffset++] << 59) | (values[valuesOffset++] << 50) | (values[valuesOffset++] << 41) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 23) | (values[valuesOffset++] << 14) | (values[valuesOffset++] << 5) | (values[valuesOffset] >>> 4);
- blocks[blocksOffset++] = (values[valuesOffset++] << 60) | (values[valuesOffset++] << 51) | (values[valuesOffset++] << 42) | (values[valuesOffset++] << 33) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 15) | (values[valuesOffset++] << 6) | (values[valuesOffset] >>> 3);
- blocks[blocksOffset++] = (values[valuesOffset++] << 61) | (values[valuesOffset++] << 52) | (values[valuesOffset++] << 43) | (values[valuesOffset++] << 34) | (values[valuesOffset++] << 25) | (values[valuesOffset++] << 16) | (values[valuesOffset++] << 7) | (values[valuesOffset] >>> 2);
- blocks[blocksOffset++] = (values[valuesOffset++] << 62) | (values[valuesOffset++] << 53) | (values[valuesOffset++] << 44) | (values[valuesOffset++] << 35) | (values[valuesOffset++] << 26) | (values[valuesOffset++] << 17) | (values[valuesOffset++] << 8) | (values[valuesOffset] >>> 1);
- blocks[blocksOffset++] = (values[valuesOffset++] << 63) | (values[valuesOffset++] << 54) | (values[valuesOffset++] << 45) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 27) | (values[valuesOffset++] << 18) | (values[valuesOffset++] << 9) | values[valuesOffset++];
- }
- }
-
}
Modified: lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock1.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock1.java?rev=1378497&r1=1378496&r2=1378497&view=diff
==============================================================================
--- lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock1.java (original)
+++ lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock1.java Wed Aug 29 10:32:40 2012
@@ -22,15 +22,10 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPackedSingleBlock1 extends BulkOperation {
- @Override
- public int blockCount() {
- return 1;
- }
+final class BulkOperationPackedSingleBlock1 extends BulkOperationPackedSingleBlock {
- @Override
- public int valueCount() {
- return 64;
+ public BulkOperationPackedSingleBlock1() {
+ super(1);
}
@Override
@@ -339,22 +334,4 @@ final class BulkOperationPackedSingleBlo
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 1) | ((values[valuesOffset++] & 0xffffffffL) << 2) | ((values[valuesOffset++] & 0xffffffffL) << 3) | ((values[valuesOffset++] & 0xffffffffL) << 4) | ((values[valuesOffset++] & 0xffffffffL) << 5) | ((values[valuesOffset++] & 0xffffffffL) << 6) | ((values[valuesOffset++] & 0xffffffffL) << 7) | ((values[valuesOffset++] & 0xffffffffL) << 8) | ((values[valuesOffset++] & 0xffffffffL) << 9) | ((values[valuesOffset++] & 0xffffffffL) << 10) | ((values[valuesOffset++] & 0xffffffffL) << 11) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset++] & 0xffffffffL) << 13) | ((values[valuesOffset++] & 0xffffffffL) << 14) | ((values[valuesOffset++] & 0xffffffffL) << 15) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset++] & 0xffffffffL) << 17) | ((values[valuesOffset++] & 0xffffffffL) << 18) | ((values[valuesOffset++] & 0xffffffffL) <<
19) | ((values[valuesOffset++] & 0xffffffffL) << 20) | ((values[valuesOffset++] & 0xffffffffL) << 21) | ((values[valuesOffset++] & 0xffffffffL) << 22) | ((values[valuesOffset++] & 0xffffffffL) << 23) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 25) | ((values[valuesOffset++] & 0xffffffffL) << 26) | ((values[valuesOffset++] & 0xffffffffL) << 27) | ((values[valuesOffset++] & 0xffffffffL) << 28) | ((values[valuesOffset++] & 0xffffffffL) << 29) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 31) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 33) | ((values[valuesOffset++] & 0xffffffffL) << 34) | ((values[valuesOffset++] & 0xffffffffL) << 35) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 37) | ((values[valuesOffset++] & 0xffffffffL) << 38) | ((values[valuesOffset++] & 0xffffffffL) << 39) | ((
values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 41) | ((values[valuesOffset++] & 0xffffffffL) << 42) | ((values[valuesOffset++] & 0xffffffffL) << 43) | ((values[valuesOffset++] & 0xffffffffL) << 44) | ((values[valuesOffset++] & 0xffffffffL) << 45) | ((values[valuesOffset++] & 0xffffffffL) << 46) | ((values[valuesOffset++] & 0xffffffffL) << 47) | ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 49) | ((values[valuesOffset++] & 0xffffffffL) << 50) | ((values[valuesOffset++] & 0xffffffffL) << 51) | ((values[valuesOffset++] & 0xffffffffL) << 52) | ((values[valuesOffset++] & 0xffffffffL) << 53) | ((values[valuesOffset++] & 0xffffffffL) << 54) | ((values[valuesOffset++] & 0xffffffffL) << 55) | ((values[valuesOffset++] & 0xffffffffL) << 56) | ((values[valuesOffset++] & 0xffffffffL) << 57) | ((values[valuesOffset++] & 0xffffffffL) << 58) | ((values[valuesOffset++] & 0xffffffffL) << 59) | ((values[va
luesOffset++] & 0xffffffffL) << 60) | ((values[valuesOffset++] & 0xffffffffL) << 61) | ((values[valuesOffset++] & 0xffffffffL) << 62) | ((values[valuesOffset++] & 0xffffffffL) << 63);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 1) | (values[valuesOffset++] << 2) | (values[valuesOffset++] << 3) | (values[valuesOffset++] << 4) | (values[valuesOffset++] << 5) | (values[valuesOffset++] << 6) | (values[valuesOffset++] << 7) | (values[valuesOffset++] << 8) | (values[valuesOffset++] << 9) | (values[valuesOffset++] << 10) | (values[valuesOffset++] << 11) | (values[valuesOffset++] << 12) | (values[valuesOffset++] << 13) | (values[valuesOffset++] << 14) | (values[valuesOffset++] << 15) | (values[valuesOffset++] << 16) | (values[valuesOffset++] << 17) | (values[valuesOffset++] << 18) | (values[valuesOffset++] << 19) | (values[valuesOffset++] << 20) | (values[valuesOffset++] << 21) | (values[valuesOffset++] << 22) | (values[valuesOffset++] << 23) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 25) | (values[valuesOffset++] << 26) | (values[valuesOffset++] << 27) | (values[valuesOffset++] << 28) | (values[valuesOf
fset++] << 29) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 31) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 33) | (values[valuesOffset++] << 34) | (values[valuesOffset++] << 35) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 37) | (values[valuesOffset++] << 38) | (values[valuesOffset++] << 39) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 41) | (values[valuesOffset++] << 42) | (values[valuesOffset++] << 43) | (values[valuesOffset++] << 44) | (values[valuesOffset++] << 45) | (values[valuesOffset++] << 46) | (values[valuesOffset++] << 47) | (values[valuesOffset++] << 48) | (values[valuesOffset++] << 49) | (values[valuesOffset++] << 50) | (values[valuesOffset++] << 51) | (values[valuesOffset++] << 52) | (values[valuesOffset++] << 53) | (values[valuesOffset++] << 54) | (values[valuesOffset++] << 55) | (values[valuesOffset++] << 56) | (values[valuesOffset++] << 57) | (values[valuesOffset++] << 58) | (values[valuesO
ffset++] << 59) | (values[valuesOffset++] << 60) | (values[valuesOffset++] << 61) | (values[valuesOffset++] << 62) | (values[valuesOffset++] << 63);
- }
- }
-
}
Modified: lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock10.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock10.java?rev=1378497&r1=1378496&r2=1378497&view=diff
==============================================================================
--- lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock10.java (original)
+++ lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock10.java Wed Aug 29 10:32:40 2012
@@ -22,15 +22,10 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPackedSingleBlock10 extends BulkOperation {
- @Override
- public int blockCount() {
- return 1;
- }
+final class BulkOperationPackedSingleBlock10 extends BulkOperationPackedSingleBlock {
- @Override
- public int valueCount() {
- return 6;
+ public BulkOperationPackedSingleBlock10() {
+ super(10);
}
@Override
@@ -107,22 +102,4 @@ final class BulkOperationPackedSingleBlo
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 10) | ((values[valuesOffset++] & 0xffffffffL) << 20) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 50);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 10) | (values[valuesOffset++] << 20) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 50);
- }
- }
-
}
Modified: lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock12.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock12.java?rev=1378497&r1=1378496&r2=1378497&view=diff
==============================================================================
--- lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock12.java (original)
+++ lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock12.java Wed Aug 29 10:32:40 2012
@@ -22,15 +22,10 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPackedSingleBlock12 extends BulkOperation {
- @Override
- public int blockCount() {
- return 1;
- }
+final class BulkOperationPackedSingleBlock12 extends BulkOperationPackedSingleBlock {
- @Override
- public int valueCount() {
- return 5;
+ public BulkOperationPackedSingleBlock12() {
+ super(12);
}
@Override
@@ -103,22 +98,4 @@ final class BulkOperationPackedSingleBlo
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 48);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 12) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 48);
- }
- }
-
}
Modified: lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock16.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock16.java?rev=1378497&r1=1378496&r2=1378497&view=diff
==============================================================================
--- lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock16.java (original)
+++ lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock16.java Wed Aug 29 10:32:40 2012
@@ -22,15 +22,10 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPackedSingleBlock16 extends BulkOperation {
- @Override
- public int blockCount() {
- return 1;
- }
+final class BulkOperationPackedSingleBlock16 extends BulkOperationPackedSingleBlock {
- @Override
- public int valueCount() {
- return 4;
+ public BulkOperationPackedSingleBlock16() {
+ super(16);
}
@Override
@@ -99,22 +94,4 @@ final class BulkOperationPackedSingleBlo
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 48);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 16) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 48);
- }
- }
-
}
Modified: lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock2.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock2.java?rev=1378497&r1=1378496&r2=1378497&view=diff
==============================================================================
--- lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock2.java (original)
+++ lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock2.java Wed Aug 29 10:32:40 2012
@@ -22,15 +22,10 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPackedSingleBlock2 extends BulkOperation {
- @Override
- public int blockCount() {
- return 1;
- }
+final class BulkOperationPackedSingleBlock2 extends BulkOperationPackedSingleBlock {
- @Override
- public int valueCount() {
- return 32;
+ public BulkOperationPackedSingleBlock2() {
+ super(2);
}
@Override
@@ -211,22 +206,4 @@ final class BulkOperationPackedSingleBlo
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 2) | ((values[valuesOffset++] & 0xffffffffL) << 4) | ((values[valuesOffset++] & 0xffffffffL) << 6) | ((values[valuesOffset++] & 0xffffffffL) << 8) | ((values[valuesOffset++] & 0xffffffffL) << 10) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset++] & 0xffffffffL) << 14) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset++] & 0xffffffffL) << 18) | ((values[valuesOffset++] & 0xffffffffL) << 20) | ((values[valuesOffset++] & 0xffffffffL) << 22) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 26) | ((values[valuesOffset++] & 0xffffffffL) << 28) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 34) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffff
L) << 38) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 42) | ((values[valuesOffset++] & 0xffffffffL) << 44) | ((values[valuesOffset++] & 0xffffffffL) << 46) | ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 50) | ((values[valuesOffset++] & 0xffffffffL) << 52) | ((values[valuesOffset++] & 0xffffffffL) << 54) | ((values[valuesOffset++] & 0xffffffffL) << 56) | ((values[valuesOffset++] & 0xffffffffL) << 58) | ((values[valuesOffset++] & 0xffffffffL) << 60) | ((values[valuesOffset++] & 0xffffffffL) << 62);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 2) | (values[valuesOffset++] << 4) | (values[valuesOffset++] << 6) | (values[valuesOffset++] << 8) | (values[valuesOffset++] << 10) | (values[valuesOffset++] << 12) | (values[valuesOffset++] << 14) | (values[valuesOffset++] << 16) | (values[valuesOffset++] << 18) | (values[valuesOffset++] << 20) | (values[valuesOffset++] << 22) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 26) | (values[valuesOffset++] << 28) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 34) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 38) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 42) | (values[valuesOffset++] << 44) | (values[valuesOffset++] << 46) | (values[valuesOffset++] << 48) | (values[valuesOffset++] << 50) | (values[valuesOffset++] << 52) | (values[valuesOffset++] << 54) | (values[valuesOffset++] << 56) | (values[val
uesOffset++] << 58) | (values[valuesOffset++] << 60) | (values[valuesOffset++] << 62);
- }
- }
-
}
Modified: lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock21.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock21.java?rev=1378497&r1=1378496&r2=1378497&view=diff
==============================================================================
--- lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock21.java (original)
+++ lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock21.java Wed Aug 29 10:32:40 2012
@@ -22,15 +22,10 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPackedSingleBlock21 extends BulkOperation {
- @Override
- public int blockCount() {
- return 1;
- }
+final class BulkOperationPackedSingleBlock21 extends BulkOperationPackedSingleBlock {
- @Override
- public int valueCount() {
- return 3;
+ public BulkOperationPackedSingleBlock21() {
+ super(21);
}
@Override
@@ -95,22 +90,4 @@ final class BulkOperationPackedSingleBlo
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 21) | ((values[valuesOffset++] & 0xffffffffL) << 42);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 21) | (values[valuesOffset++] << 42);
- }
- }
-
}
Modified: lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock3.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock3.java?rev=1378497&r1=1378496&r2=1378497&view=diff
==============================================================================
--- lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock3.java (original)
+++ lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock3.java Wed Aug 29 10:32:40 2012
@@ -22,15 +22,10 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPackedSingleBlock3 extends BulkOperation {
- @Override
- public int blockCount() {
- return 1;
- }
+final class BulkOperationPackedSingleBlock3 extends BulkOperationPackedSingleBlock {
- @Override
- public int valueCount() {
- return 21;
+ public BulkOperationPackedSingleBlock3() {
+ super(3);
}
@Override
@@ -167,22 +162,4 @@ final class BulkOperationPackedSingleBlo
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 3) | ((values[valuesOffset++] & 0xffffffffL) << 6) | ((values[valuesOffset++] & 0xffffffffL) << 9) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset++] & 0xffffffffL) << 15) | ((values[valuesOffset++] & 0xffffffffL) << 18) | ((values[valuesOffset++] & 0xffffffffL) << 21) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 27) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 33) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 39) | ((values[valuesOffset++] & 0xffffffffL) << 42) | ((values[valuesOffset++] & 0xffffffffL) << 45) | ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 51) | ((values[valuesOffset++] & 0xffffffffL) << 54) | ((values[valuesOffset++] & 0xfffffff
fL) << 57) | ((values[valuesOffset++] & 0xffffffffL) << 60);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 3) | (values[valuesOffset++] << 6) | (values[valuesOffset++] << 9) | (values[valuesOffset++] << 12) | (values[valuesOffset++] << 15) | (values[valuesOffset++] << 18) | (values[valuesOffset++] << 21) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 27) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 33) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 39) | (values[valuesOffset++] << 42) | (values[valuesOffset++] << 45) | (values[valuesOffset++] << 48) | (values[valuesOffset++] << 51) | (values[valuesOffset++] << 54) | (values[valuesOffset++] << 57) | (values[valuesOffset++] << 60);
- }
- }
-
}
Modified: lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock4.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock4.java?rev=1378497&r1=1378496&r2=1378497&view=diff
==============================================================================
--- lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock4.java (original)
+++ lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock4.java Wed Aug 29 10:32:40 2012
@@ -22,15 +22,10 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPackedSingleBlock4 extends BulkOperation {
- @Override
- public int blockCount() {
- return 1;
- }
+final class BulkOperationPackedSingleBlock4 extends BulkOperationPackedSingleBlock {
- @Override
- public int valueCount() {
- return 16;
+ public BulkOperationPackedSingleBlock4() {
+ super(4);
}
@Override
@@ -147,22 +142,4 @@ final class BulkOperationPackedSingleBlo
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 4) | ((values[valuesOffset++] & 0xffffffffL) << 8) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset++] & 0xffffffffL) << 20) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 28) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 44) | ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 52) | ((values[valuesOffset++] & 0xffffffffL) << 56) | ((values[valuesOffset++] & 0xffffffffL) << 60);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 4) | (values[valuesOffset++] << 8) | (values[valuesOffset++] << 12) | (values[valuesOffset++] << 16) | (values[valuesOffset++] << 20) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 28) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 44) | (values[valuesOffset++] << 48) | (values[valuesOffset++] << 52) | (values[valuesOffset++] << 56) | (values[valuesOffset++] << 60);
- }
- }
-
}
Modified: lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock5.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock5.java?rev=1378497&r1=1378496&r2=1378497&view=diff
==============================================================================
--- lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock5.java (original)
+++ lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock5.java Wed Aug 29 10:32:40 2012
@@ -22,15 +22,10 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPackedSingleBlock5 extends BulkOperation {
- @Override
- public int blockCount() {
- return 1;
- }
+final class BulkOperationPackedSingleBlock5 extends BulkOperationPackedSingleBlock {
- @Override
- public int valueCount() {
- return 12;
+ public BulkOperationPackedSingleBlock5() {
+ super(5);
}
@Override
@@ -131,22 +126,4 @@ final class BulkOperationPackedSingleBlo
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 5) | ((values[valuesOffset++] & 0xffffffffL) << 10) | ((values[valuesOffset++] & 0xffffffffL) << 15) | ((values[valuesOffset++] & 0xffffffffL) << 20) | ((values[valuesOffset++] & 0xffffffffL) << 25) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 35) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 45) | ((values[valuesOffset++] & 0xffffffffL) << 50) | ((values[valuesOffset++] & 0xffffffffL) << 55);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 5) | (values[valuesOffset++] << 10) | (values[valuesOffset++] << 15) | (values[valuesOffset++] << 20) | (values[valuesOffset++] << 25) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 35) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 45) | (values[valuesOffset++] << 50) | (values[valuesOffset++] << 55);
- }
- }
-
}
Modified: lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock6.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock6.java?rev=1378497&r1=1378496&r2=1378497&view=diff
==============================================================================
--- lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock6.java (original)
+++ lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock6.java Wed Aug 29 10:32:40 2012
@@ -22,15 +22,10 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPackedSingleBlock6 extends BulkOperation {
- @Override
- public int blockCount() {
- return 1;
- }
+final class BulkOperationPackedSingleBlock6 extends BulkOperationPackedSingleBlock {
- @Override
- public int valueCount() {
- return 10;
+ public BulkOperationPackedSingleBlock6() {
+ super(6);
}
@Override
@@ -123,22 +118,4 @@ final class BulkOperationPackedSingleBlo
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 6) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset++] & 0xffffffffL) << 18) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 42) | ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 54);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 6) | (values[valuesOffset++] << 12) | (values[valuesOffset++] << 18) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 42) | (values[valuesOffset++] << 48) | (values[valuesOffset++] << 54);
- }
- }
-
}
Modified: lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock7.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock7.java?rev=1378497&r1=1378496&r2=1378497&view=diff
==============================================================================
--- lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock7.java (original)
+++ lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock7.java Wed Aug 29 10:32:40 2012
@@ -22,15 +22,10 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPackedSingleBlock7 extends BulkOperation {
- @Override
- public int blockCount() {
- return 1;
- }
+final class BulkOperationPackedSingleBlock7 extends BulkOperationPackedSingleBlock {
- @Override
- public int valueCount() {
- return 9;
+ public BulkOperationPackedSingleBlock7() {
+ super(7);
}
@Override
@@ -119,22 +114,4 @@ final class BulkOperationPackedSingleBlo
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 7) | ((values[valuesOffset++] & 0xffffffffL) << 14) | ((values[valuesOffset++] & 0xffffffffL) << 21) | ((values[valuesOffset++] & 0xffffffffL) << 28) | ((values[valuesOffset++] & 0xffffffffL) << 35) | ((values[valuesOffset++] & 0xffffffffL) << 42) | ((values[valuesOffset++] & 0xffffffffL) << 49) | ((values[valuesOffset++] & 0xffffffffL) << 56);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 7) | (values[valuesOffset++] << 14) | (values[valuesOffset++] << 21) | (values[valuesOffset++] << 28) | (values[valuesOffset++] << 35) | (values[valuesOffset++] << 42) | (values[valuesOffset++] << 49) | (values[valuesOffset++] << 56);
- }
- }
-
}
Modified: lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock8.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock8.java?rev=1378497&r1=1378496&r2=1378497&view=diff
==============================================================================
--- lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock8.java (original)
+++ lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock8.java Wed Aug 29 10:32:40 2012
@@ -22,15 +22,10 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPackedSingleBlock8 extends BulkOperation {
- @Override
- public int blockCount() {
- return 1;
- }
+final class BulkOperationPackedSingleBlock8 extends BulkOperationPackedSingleBlock {
- @Override
- public int valueCount() {
- return 8;
+ public BulkOperationPackedSingleBlock8() {
+ super(8);
}
@Override
@@ -115,22 +110,4 @@ final class BulkOperationPackedSingleBlo
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 8) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 56);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 8) | (values[valuesOffset++] << 16) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 48) | (values[valuesOffset++] << 56);
- }
- }
-
}
Modified: lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock9.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock9.java?rev=1378497&r1=1378496&r2=1378497&view=diff
==============================================================================
--- lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock9.java (original)
+++ lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock9.java Wed Aug 29 10:32:40 2012
@@ -22,15 +22,10 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPackedSingleBlock9 extends BulkOperation {
- @Override
- public int blockCount() {
- return 1;
- }
+final class BulkOperationPackedSingleBlock9 extends BulkOperationPackedSingleBlock {
- @Override
- public int valueCount() {
- return 7;
+ public BulkOperationPackedSingleBlock9() {
+ super(9);
}
@Override
@@ -111,22 +106,4 @@ final class BulkOperationPackedSingleBlo
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 9) | ((values[valuesOffset++] & 0xffffffffL) << 18) | ((values[valuesOffset++] & 0xffffffffL) << 27) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 45) | ((values[valuesOffset++] & 0xffffffffL) << 54);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 9) | (values[valuesOffset++] << 18) | (values[valuesOffset++] << 27) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 45) | (values[valuesOffset++] << 54);
- }
- }
-
}
Modified: lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/gen_BulkOperation.py
URL: http://svn.apache.org/viewvc/lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/gen_BulkOperation.py?rev=1378497&r1=1378496&r2=1378497&view=diff
==============================================================================
--- lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/gen_BulkOperation.py (original)
+++ lucene/dev/branches/branch_4x/lucene/core/src/java/org/apache/lucene/util/packed/gen_BulkOperation.py Wed Aug 29 10:32:40 2012
@@ -19,6 +19,7 @@ from fractions import gcd
"""Code generation for bulk operations"""
+MAX_SPECIALIZED_BITS_PER_VALUE = 24;
PACKED_64_SINGLE_BLOCK_BPV = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 16, 21, 32]
OUTPUT_FILE = "BulkOperation.java"
HEADER = """// This file has been automatically generated, DO NOT EDIT
@@ -45,32 +46,11 @@ package org.apache.lucene.util.packed;
"""
FOOTER="""
-
- private static long[] toLongArray(int[] ints, int offset, int length) {
- long[] arr = new long[length];
- for (int i = 0; i < length; ++i) {
- arr[i] = ints[offset + i];
+ protected int writeLong(long block, byte[] blocks, int blocksOffset) {
+ for (int j = 1; j <= 8; ++j) {
+ blocks[blocksOffset++] = (byte) (block >>> (64 - (j << 3)));
}
- return arr;
- }
-
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- encode(toLongArray(values, valuesOffset, iterations * valueCount()), 0, blocks, blocksOffset, iterations);
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, byte[] blocks, int blocksOffset, int iterations) {
- final long[] longBLocks = new long[blockCount() * iterations];
- encode(values, valuesOffset, longBLocks, 0, iterations);
- ByteBuffer.wrap(blocks, blocksOffset, 8 * iterations * blockCount()).asLongBuffer().put(longBLocks);
- }
-
- @Override
- public void encode(int[] values, int valuesOffset, byte[] blocks, int blocksOffset, int iterations) {
- final long[] longBLocks = new long[blockCount() * iterations];
- encode(values, valuesOffset, longBLocks, 0, iterations);
- ByteBuffer.wrap(blocks, blocksOffset, 8 * iterations * blockCount()).asLongBuffer().put(longBLocks);
+ return blocksOffset;
}
/**
@@ -140,18 +120,12 @@ def get_type(bits):
def packed64singleblock(bpv, f):
values = 64 / bpv
- f.write(" @Override\n")
- f.write(" public int blockCount() {\n")
- f.write(" return 1;\n")
- f.write(" }\n\n")
- f.write(" @Override\n")
- f.write(" public int valueCount() {\n")
- f.write(" return %d;\n" %values)
+ f.write("\n")
+ f.write(" public BulkOperationPackedSingleBlock%d() {\n" %bpv)
+ f.write(" super(%d);\n" %bpv)
f.write(" }\n\n")
p64sb_decode(bpv, f, 32)
p64sb_decode(bpv, f, 64)
- p64sb_encode(bpv, f, 32)
- p64sb_encode(bpv, f, 64)
def p64sb_decode(bpv, f, bits):
values = 64 / bpv
@@ -227,31 +201,6 @@ def p64sb_decode(bpv, f, bits):
f.write(" }\n")
f.write(" }\n\n")
-def p64sb_encode(bpv, f, bits):
- values = 64 / bpv
- typ = get_type(bits)
- mask_start, mask_end = masks(bits)
- f.write(" @Override\n")
- f.write(" public void encode(%s[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {\n" %typ)
- if bits < bpv:
- f.write(" throw new UnsupportedOperationException();\n")
- f.write(" }\n\n")
- return
- f.write(" assert blocksOffset + iterations * blockCount() <= blocks.length;\n")
- f.write(" assert valuesOffset + iterations * valueCount() <= values.length;\n")
- f.write(" for (int i = 0; i < iterations; ++i) {\n")
- for i in xrange(values):
- block_offset = i / values
- offset_in_block = i % values
- if i == 0:
- f.write(" blocks[blocksOffset++] = %svalues[valuesOffset++]%s" %(mask_start, mask_end))
- else:
- f.write(" | (%svalues[valuesOffset++]%s << %d)" %(mask_start, mask_end, i * bpv))
- if i == values - 1:
- f.write(";\n")
- f.write(" }\n")
- f.write(" }\n\n")
-
def packed64(bpv, f):
blocks = bpv
values = blocks * 64 / bpv
@@ -260,13 +209,12 @@ def packed64(bpv, f):
values /= 2
assert values * bpv == 64 * blocks, "%d values, %d blocks, %d bits per value" %(values, blocks, bpv)
mask = (1 << bpv) - 1
- f.write(" @Override\n")
- f.write(" public int blockCount() {\n")
- f.write(" return %d;\n" %blocks)
- f.write(" }\n\n")
- f.write(" @Override\n")
- f.write(" public int valueCount() {\n")
- f.write(" return %d;\n" %values)
+
+ f.write("\n")
+ f.write(" public BulkOperationPacked%d() {\n" %bpv)
+ f.write(" super(%d);\n" %bpv)
+ f.write(" assert blockCount() == %d;\n" %blocks)
+ f.write(" assert valueCount() == %d;\n" %values)
f.write(" }\n\n")
if bpv == 64:
@@ -289,17 +237,10 @@ def packed64(bpv, f):
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
LongBuffer.wrap(values, valuesOffset, iterations * valueCount()).put(ByteBuffer.wrap(blocks, blocksOffset, 8 * iterations * blockCount()).asLongBuffer());
}
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- System.arraycopy(values, valuesOffset, blocks, blocksOffset, valueCount() * iterations);
- }
""")
else:
p64_decode(bpv, f, 32, values)
p64_decode(bpv, f, 64, values)
- p64_encode(bpv, f, 32, values)
- p64_encode(bpv, f, 64, values)
def p64_decode(bpv, f, bits, values):
typ = get_type(bits)
@@ -383,41 +324,11 @@ def p64_decode(bpv, f, bits, values):
f.write(" }\n")
f.write(" }\n\n")
-def p64_encode(bpv, f, bits, values):
- typ = get_type(bits)
- mask_start, mask_end = masks(bits)
- f.write(" @Override\n")
- f.write(" public void encode(%s[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {\n" %typ)
- f.write(" assert blocksOffset + iterations * blockCount() <= blocks.length;\n")
- f.write(" assert valuesOffset + iterations * valueCount() <= values.length;\n")
- f.write(" for (int i = 0; i < iterations; ++i) {\n")
- for i in xrange(0, values):
- block_offset = i * bpv / 64
- bit_offset = (i * bpv) % 64
- if bit_offset == 0:
- # start of block
- f.write(" blocks[blocksOffset++] = (%svalues[valuesOffset++]%s << %d)" %(mask_start, mask_end, 64 - bpv))
- elif bit_offset + bpv == 64:
- # end of block
- f.write(" | %svalues[valuesOffset++]%s;\n" %(mask_start, mask_end))
- elif bit_offset + bpv < 64:
- # inside a block
- f.write(" | (%svalues[valuesOffset++]%s << %d)" %(mask_start, mask_end, 64 - bit_offset - bpv))
- else:
- # value spans across 2 blocks
- right_bits = bit_offset + bpv - 64
- f.write(" | (%svalues[valuesOffset]%s >>> %d);\n" %(mask_start, mask_end, right_bits))
- f.write(" blocks[blocksOffset++] = (%svalues[valuesOffset++]%s << %d)" %(mask_start, mask_end, 64 - right_bits))
- f.write(" }\n")
- f.write(" }\n\n")
-
-
if __name__ == '__main__':
p64_bpv = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 16, 21, 32]
f = open(OUTPUT_FILE, 'w')
f.write(HEADER)
- f.write('import java.nio.ByteBuffer;\n')
f.write('\n')
f.write('''/**
* Efficient sequential read/write of packed integers.
@@ -427,6 +338,9 @@ if __name__ == '__main__':
f.write(' private static final BulkOperation[] packedBulkOps = new BulkOperation[] {\n')
for bpv in xrange(1, 65):
+ if bpv > MAX_SPECIALIZED_BITS_PER_VALUE:
+ f.write(' new BulkOperationPacked(%d),\n' % bpv)
+ continue
f2 = open('BulkOperationPacked%d.java' % bpv, 'w')
f2.write(HEADER)
if bpv == 64:
@@ -436,7 +350,7 @@ if __name__ == '__main__':
f2.write('''/**
* Efficient sequential read/write of packed integers.
*/\n''')
- f2.write('final class BulkOperationPacked%d extends BulkOperation {\n' % bpv)
+ f2.write('final class BulkOperationPacked%d extends BulkOperationPacked {\n' % bpv)
packed64(bpv, f2)
f2.write('}\n')
f2.close()
@@ -449,12 +363,15 @@ if __name__ == '__main__':
f.write(' private static final BulkOperation[] packedSingleBlockBulkOps = new BulkOperation[] {\n')
for bpv in xrange(1, max(PACKED_64_SINGLE_BLOCK_BPV)+1):
if bpv in PACKED_64_SINGLE_BLOCK_BPV:
+ if bpv > MAX_SPECIALIZED_BITS_PER_VALUE:
+ f.write(' new BulkOperationPackedSingleBlock(%d),\n' % bpv)
+ continue
f2 = open('BulkOperationPackedSingleBlock%d.java' % bpv, 'w')
f2.write(HEADER)
f2.write('''/**
* Efficient sequential read/write of packed integers.
*/\n''')
- f2.write('final class BulkOperationPackedSingleBlock%d extends BulkOperation {\n' % bpv)
+ f2.write('final class BulkOperationPackedSingleBlock%d extends BulkOperationPackedSingleBlock {\n' % bpv)
packed64singleblock(bpv,f2)
f2.write('}\n')
f2.close()