< 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 >