< prev index next >
test/compiler/intrinsics/zip/TestCRC32.java
Print this page
rev 12684 : [mq]: 8176580.patch
*** 34,44 ****
import java.nio.ByteBuffer;
import java.util.zip.CRC32;
import java.util.zip.Checksum;
public class TestCRC32 {
! public static void main(String[] args) {
int offset = Integer.getInteger("offset", 0);
int msgSize = Integer.getInteger("msgSize", 512);
boolean multi = false;
int iters = 20000;
int warmupIters = 20000;
--- 34,59 ----
import java.nio.ByteBuffer;
import java.util.zip.CRC32;
import java.util.zip.Checksum;
public class TestCRC32 {
! // standard CRC32 polynomial
! // coefficients in different forms
! // normal: polyBits = 0x04c11db7 = 0b0000 0100 1100 0001 0001 1101 1011 0111
! // reversed: polybits = 0xedb88320 = 0b1110 1101 1011 1000 1000 0011 0010 0000
! // reversed reciprocal polybits = 0x82608edb = 0b1000 0010 0110 0000 1000 1110 1101 1011
! //
! // 0 5 9 13 17 21 25 29
! // | | | | | | | |
! // reversed shiftL 1 polyBits = 0x1db710641L = 0b1 1101 1011 0111 0001 0000 0110 0100 0001
! final static long polyBits = (1L<<(32-32)) + (1L<<(32-26)) + (1L<<(32-23)) + (1L<<(32-22))
! + (1L<<(32-16)) + (1L<<(32-12)) + (1L<<(32-11)) + (1L<<(32-10))
! + (1L<<(32-8)) + (1L<<(32-7)) + (1L<<(32-5)) + (1L<<(32-4))
! + (1L<<(32-2)) + (1L<<(32-1)) + (1L<<(32-0));
! final static long polyBitsShifted = polyBits>>1;
!
! public static void main(String[] args) throws Exception {
int offset = Integer.getInteger("offset", 0);
int msgSize = Integer.getInteger("msgSize", 512);
boolean multi = false;
int iters = 20000;
int warmupIters = 20000;
*** 63,105 ****
System.out.println("msgSize = " + msgSize + " bytes");
System.out.println(" iters = " + iters);
byte[] b = initializedBytes(msgSize, offset);
CRC32 crc0 = new CRC32();
CRC32 crc1 = new CRC32();
CRC32 crc2 = new CRC32();
crc0.update(b, offset, msgSize);
System.out.println("-------------------------------------------------------");
/* warm up */
for (int i = 0; i < warmupIters; i++) {
crc1.reset();
crc1.update(b, offset, msgSize);
}
! /* measure performance */
long start = System.nanoTime();
for (int i = 0; i < iters; i++) {
crc1.reset();
crc1.update(b, offset, msgSize);
}
long end = System.nanoTime();
double total = (double)(end - start)/1e9; // in seconds
double thruput = (double)msgSize*iters/1e6/total; // in MB/s
System.out.println("CRC32.update(byte[]) runtime = " + total + " seconds");
System.out.println("CRC32.update(byte[]) throughput = " + thruput + " MB/s");
!
! /* check correctness */
! for (int i = 0; i < iters; i++) {
! crc1.reset();
! crc1.update(b, offset, msgSize);
! if (!check(crc0, crc1)) break;
! }
! report("CRCs", crc0, crc1);
System.out.println("-------------------------------------------------------");
ByteBuffer buf = ByteBuffer.allocateDirect(msgSize);
buf.put(b, offset, msgSize);
--- 78,140 ----
System.out.println("msgSize = " + msgSize + " bytes");
System.out.println(" iters = " + iters);
byte[] b = initializedBytes(msgSize, offset);
+ final long crcReference = update_byteLoop(0, b, offset);
+
CRC32 crc0 = new CRC32();
CRC32 crc1 = new CRC32();
CRC32 crc2 = new CRC32();
crc0.update(b, offset, msgSize);
+ if (!check(crc0, crcReference)) {
+ System.out.println("CRC32: crc mismatch during initialization.");
+ throw new Exception("TestCRC32 Error");
+ }
System.out.println("-------------------------------------------------------");
/* warm up */
for (int i = 0; i < warmupIters; i++) {
crc1.reset();
crc1.update(b, offset, msgSize);
+ if (!check(crc1, crcReference)) {
+ System.out.println("CRC32: crc mismatch during warmup iteration " + i);
+ throw new Exception("TestCRC32 Error");
+ }
+ }
+
+ /* check correctness
+ * Do that before measuring performance
+ * to even better heat up involved methods.
+ */
+ for (int i = 0; i < iters; i++) {
+ crc1.reset();
+ crc1.update(b, offset, msgSize);
+ if (!check(crc1, crcReference)) {
+ System.out.println("CRC32: crc mismatch during check iteration " + i);
+ throw new Exception("TestCRC32 Error");
}
+ }
+ report("CRCs", crc1, crcReference);
! /* measure performance
! * Don't spoil times with error checking.
! */
long start = System.nanoTime();
for (int i = 0; i < iters; i++) {
crc1.reset();
crc1.update(b, offset, msgSize);
}
long end = System.nanoTime();
+
double total = (double)(end - start)/1e9; // in seconds
double thruput = (double)msgSize*iters/1e6/total; // in MB/s
System.out.println("CRC32.update(byte[]) runtime = " + total + " seconds");
System.out.println("CRC32.update(byte[]) throughput = " + thruput + " MB/s");
! report("CRCs", crc1, crcReference);
System.out.println("-------------------------------------------------------");
ByteBuffer buf = ByteBuffer.allocateDirect(msgSize);
buf.put(b, offset, msgSize);
*** 108,120 ****
/* warm up */
for (int i = 0; i < warmupIters; i++) {
crc2.reset();
crc2.update(buf);
buf.rewind();
}
! /* measure performance */
start = System.nanoTime();
for (int i = 0; i < iters; i++) {
crc2.reset();
crc2.update(buf);
buf.rewind();
--- 143,176 ----
/* warm up */
for (int i = 0; i < warmupIters; i++) {
crc2.reset();
crc2.update(buf);
buf.rewind();
+ if (!check(crc2, crcReference)) {
+ System.out.println("CRC32: crc2 mismatch during warmup iteration " + i);
+ throw new Exception("TestCRC32 Error");
+ }
}
! /* check correctness
! * Do that before measuring performance
! * to even better heat up involved methods.
! */
! for (int i = 0; i < iters; i++) {
! crc2.reset();
! crc2.update(buf);
! buf.rewind();
! if (!check(crc2, crcReference)) {
! System.out.println("CRC32: crc2 mismatch during check iteration " + i);
! throw new Exception("TestCRC32 Error");
! }
! }
! report("CRCs", crc2, crcReference);
!
! /* measure performance
! * Don't spoil times with error checking.
! */
start = System.nanoTime();
for (int i = 0; i < iters; i++) {
crc2.reset();
crc2.update(buf);
buf.rewind();
*** 122,153 ****
end = System.nanoTime();
total = (double)(end - start)/1e9; // in seconds
thruput = (double)msgSize*iters/1e6/total; // in MB/s
System.out.println("CRC32.update(ByteBuffer) runtime = " + total + " seconds");
System.out.println("CRC32.update(ByteBuffer) throughput = " + thruput + " MB/s");
! /* check correctness */
! for (int i = 0; i < iters; i++) {
! crc2.reset();
! crc2.update(buf);
! buf.rewind();
! if (!check(crc0, crc2)) break;
}
- report("CRCs", crc0, crc2);
! System.out.println("-------------------------------------------------------");
}
! private static void report(String s, Checksum crc0, Checksum crc1) {
! System.out.printf("%s: crc0 = %08x, crc1 = %08x\n",
! s, crc0.getValue(), crc1.getValue());
}
! private static boolean check(Checksum crc0, Checksum crc1) {
! if (crc0.getValue() != crc1.getValue()) {
! System.err.printf("ERROR: crc0 = %08x, crc1 = %08x\n",
! crc0.getValue(), crc1.getValue());
return false;
}
return true;
}
--- 178,236 ----
end = System.nanoTime();
total = (double)(end - start)/1e9; // in seconds
thruput = (double)msgSize*iters/1e6/total; // in MB/s
System.out.println("CRC32.update(ByteBuffer) runtime = " + total + " seconds");
System.out.println("CRC32.update(ByteBuffer) throughput = " + thruput + " MB/s");
+ report("CRCs", crc2, crcReference);
! System.out.println("-------------------------------------------------------");
}
! // Just a loop over a byte array, updating the CRC byte by byte.
! public static long update_byteLoop(long crc, byte[] buf, int offset) {
! return update_byteLoop(crc, buf, offset, buf.length-offset);
! }
!
! // Just a loop over a byte array, with given length, updating the CRC byte by byte.
! public static long update_byteLoop(long crc, byte[] buf, int offset, int length) {
! int end = length+offset;
! for (int i = offset; i < end; i++) {
! crc = update_singlebyte(crc, polyBitsShifted, buf[i]);
! }
! return crc;
! }
!
! // Straight-forward implementation of CRC update by one byte.
! // We use this very basic implementation to calculate reference
! // results. It is necessary to have full control over how the
! // reference results are calculated. It is not sufficient to rely
! // on the interpreter (or c1, or c2) to do the right thing.
! public static long update_singlebyte(long crc, long polynomial, int val) {
! crc = (crc ^ -1L) & 0x00000000ffffffffL; // use 1's complement of crc
! crc = crc ^ (val&0xff); // XOR in next byte from stream
! for (int i = 0; i < 8; i++) {
! boolean bitset = (crc & 0x01L) != 0;
!
! crc = crc>>1;
! if (bitset) {
! crc = crc ^ polynomial;
! crc = crc & 0x00000000ffffffffL;
! }
! }
! crc = (crc ^ -1L) & 0x00000000ffffffffL; // revert taking 1's complement
! return crc;
}
! private static void report(String s, Checksum crc, long crcReference) {
! System.out.printf("%s: crc = %08x, crcReference = %08x\n",
! s, crc.getValue(), crcReference);
}
! private static boolean check(Checksum crc, long crcReference) {
! if (crc.getValue() != crcReference) {
! System.err.printf("ERROR: crc = %08x, crcReference = %08x\n",
! crc.getValue(), crcReference);
return false;
}
return true;
}
*** 160,170 ****
bytes[i] = (byte) (i - offset);
}
return bytes;
}
! private static void test_multi(int iters) {
int len1 = 8; // the 8B/iteration loop
int len2 = 32; // the 32B/iteration loop
int len3 = 4096; // the 4KB/iteration loop
byte[] b = initializedBytes(len3*16, 0);
--- 243,253 ----
bytes[i] = (byte) (i - offset);
}
return bytes;
}
! private static void test_multi(int iters) throws Exception {
int len1 = 8; // the 8B/iteration loop
int len2 = 32; // the 32B/iteration loop
int len3 = 4096; // the 4KB/iteration loop
byte[] b = initializedBytes(len3*16, 0);
*** 183,223 ****
len1+len2+len3+5, len1+len2+len3+7,
(len1+len2+len3)*2, (len1+len2+len3)*2+1, (len1+len2+len3)*2+3,
(len1+len2+len3)*2+5, (len1+len2+len3)*2+7,
(len1+len2+len3)*3, (len1+len2+len3)*3-1, (len1+len2+len3)*3-3,
(len1+len2+len3)*3-5, (len1+len2+len3)*3-7 };
- CRC32[] crc0 = new CRC32[offsets.length*sizes.length];
CRC32[] crc1 = new CRC32[offsets.length*sizes.length];
int i, j, k;
System.out.printf("testing %d cases ...\n", offsets.length*sizes.length);
! /* set the result from interpreter as reference */
for (i = 0; i < offsets.length; i++) {
for (j = 0; j < sizes.length; j++) {
- crc0[i*sizes.length + j] = new CRC32();
crc1[i*sizes.length + j] = new CRC32();
! crc0[i*sizes.length + j].update(b, offsets[i], sizes[j]);
}
}
! /* warm up the JIT compiler and get result */
for (k = 0; k < iters; k++) {
for (i = 0; i < offsets.length; i++) {
for (j = 0; j < sizes.length; j++) {
crc1[i*sizes.length + j].reset();
crc1[i*sizes.length + j].update(b, offsets[i], sizes[j]);
- }
- }
- }
! /* check correctness */
! for (i = 0; i < offsets.length; i++) {
! for (j = 0; j < sizes.length; j++) {
! if (!check(crc0[i*sizes.length + j], crc1[i*sizes.length + j])) {
! System.out.printf("offsets[%d] = %d", i, offsets[i]);
System.out.printf("\tsizes[%d] = %d\n", j, sizes[j]);
}
}
}
}
}
--- 266,312 ----
len1+len2+len3+5, len1+len2+len3+7,
(len1+len2+len3)*2, (len1+len2+len3)*2+1, (len1+len2+len3)*2+3,
(len1+len2+len3)*2+5, (len1+len2+len3)*2+7,
(len1+len2+len3)*3, (len1+len2+len3)*3-1, (len1+len2+len3)*3-3,
(len1+len2+len3)*3-5, (len1+len2+len3)*3-7 };
CRC32[] crc1 = new CRC32[offsets.length*sizes.length];
+ long[] crcReference = new long[offsets.length*sizes.length];
int i, j, k;
System.out.printf("testing %d cases ...\n", offsets.length*sizes.length);
! try {
! // Initialize CRC32 result arrays, CRC32 reference array.
! // Reference is calculated using a very basic Java implementation.
for (i = 0; i < offsets.length; i++) {
for (j = 0; j < sizes.length; j++) {
crc1[i*sizes.length + j] = new CRC32();
! crcReference[i*sizes.length + j] = update_byteLoop(0, b, offsets[i], sizes[j]);
}
}
! // Warm up the JIT compiler. Over time, all methods involved will
! // be executed by the interpreter, then get compiled by c1 and
! // finally by c2. Each calculated CRC value must, in each iteration,
! // be equal to the precalculated reference value for the test to pass.
for (k = 0; k < iters; k++) {
for (i = 0; i < offsets.length; i++) {
for (j = 0; j < sizes.length; j++) {
crc1[i*sizes.length + j].reset();
crc1[i*sizes.length + j].update(b, offsets[i], sizes[j]);
! if (!check(crc1[i*sizes.length + j], crcReference[i*sizes.length + j])) {
! System.out.printf("iteration %d:", k);
! System.out.printf("\toffsets[%d] = %d", i, offsets[i]);
System.out.printf("\tsizes[%d] = %d\n", j, sizes[j]);
+ throw new Exception("TestCRC32 Error");
+ }
+ }
}
}
+ } catch (Exception e) {
+ System.out.println("Exception: " + e);
+ //System.exit(1);
+ throw new Exception(e);
}
}
}
< prev index next >