1 /*

     2  * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 /**

    25  * @test

    26  * @bug 8132081

    27  * @summary C2 support for Adler32 on SPARC

    28  *

    29  * @run main/othervm/timeout=600 -Xbatch TestAdler32 -m

    30  */

    31 

    32 import java.nio.ByteBuffer;

    33 import java.util.zip.Checksum;

    34 import java.util.zip.Adler32;

    35 

    36 public class TestAdler32 {

    37     public static void main(String[] args) {

    38         int offset = Integer.getInteger("offset", 0);

    39         int msgSize = Integer.getInteger("msgSize", 512);

    40         boolean multi = false;

    41         int iters = 20000;

    42         int warmupIters = 20000;

    43 

    44         if (args.length > 0) {

    45             if (args[0].equals("-m")) {

    46                 multi = true;

    47             } else {

    48                 iters = Integer.valueOf(args[0]);

    49             }

    50             if (args.length > 1) {

    51                 warmupIters = Integer.valueOf(args[1]);

    52             }

    53         }

    54 

    55         if (multi) {

    56             test_multi(warmupIters);

    57             return;

    58         }

    59 

    60         System.out.println(" offset = " + offset);

    61         System.out.println("msgSize = " + msgSize + " bytes");

    62         System.out.println("  iters = " + iters);

    63 

    64         byte[] b = initializedBytes(msgSize, offset);

    65 

    66         Adler32 adler0 = new Adler32();

    67         Adler32 adler1 = new Adler32();

    68         Adler32 adler2 = new Adler32();

    69 

    70         adler0.update(b, offset, msgSize);

    71 

    72         System.out.println("-------------------------------------------------------");

    73 

    74         /* warm up */

    75         for (int i = 0; i < warmupIters; i++) {

    76             adler1.reset();

    77             adler1.update(b, offset, msgSize);

    78         }

    79 

    80         /* measure performance */

    81         long start = System.nanoTime();

    82         for (int i = 0; i < iters; i++) {

    83             adler1.reset();

    84             adler1.update(b, offset, msgSize);

    85         }

    86         long end = System.nanoTime();

    87         double total = (double)(end - start)/1e9;         // in seconds

    88         double thruput = (double)msgSize*iters/1e6/total; // in MB/s

    89         System.out.println("Adler32.update(byte[]) runtime = " + total + " seconds");

    90         System.out.println("Adler32.update(byte[]) throughput = " + thruput + " MB/s");

    91 

    92         /* check correctness */

    93         for (int i = 0; i < iters; i++) {

    94             adler1.reset();

    95             adler1.update(b, offset, msgSize);

    96             if (!check(adler0, adler1)) break;

    97         }

    98         report("Adlers", adler0, adler1);

    99 

   100         System.out.println("-------------------------------------------------------");

   101 

   102         ByteBuffer buf = ByteBuffer.allocateDirect(msgSize);

   103         buf.put(b, offset, msgSize);

   104         buf.flip();

   105 

   106         /* warm up */

   107         for (int i = 0; i < warmupIters; i++) {

   108             adler2.reset();

   109             adler2.update(buf);

   110             buf.rewind();

   111         }

   112 

   113         /* measure performance */

   114         start = System.nanoTime();

   115         for (int i = 0; i < iters; i++) {

   116             adler2.reset();

   117             adler2.update(buf);

   118             buf.rewind();

   119         }

   120         end = System.nanoTime();

   121         total = (double)(end - start)/1e9;         // in seconds

   122         thruput = (double)msgSize*iters/1e6/total; // in MB/s

   123         System.out.println("Adler32.update(ByteBuffer) runtime = " + total + " seconds");

   124         System.out.println("Adler32.update(ByteBuffer) throughput = " + thruput + " MB/s");

   125 

   126         /* check correctness */

   127         for (int i = 0; i < iters; i++) {

   128             adler2.reset();

   129             adler2.update(buf);

   130             buf.rewind();

   131             if (!check(adler0, adler2)) break;

   132         }

   133         report("Adlers", adler0, adler1);

   134 

   135         System.out.println("-------------------------------------------------------");

   136     }

   137 

   138     private static void report(String s, Checksum adler0, Checksum adler1) {

   139         System.out.printf("%s: adler0 = %08x, adler1 = %08x\n",

   140                           s, adler0.getValue(), adler1.getValue());

   141     }

   142 

   143     private static boolean check(Checksum adler0, Checksum adler1) {

   144         if (adler0.getValue() != adler1.getValue()) {

   145             System.err.printf("ERROR: adler0 = %08x, adler1 = %08x\n",

   146                               adler0.getValue(), adler1.getValue());

   147             return false;

   148         }

   149         return true;

   150     }

   151 

   152     private static byte[] initializedBytes(int M, int offset) {

   153         byte[] bytes = new byte[M + offset];

   154         for (int i = 0; i < offset; i++) {

   155             bytes[i] = (byte) i;

   156         }

   157         for (int i = offset; i < bytes.length; i++) {

   158             bytes[i] = (byte) (i - offset);

   159         }

   160         return bytes;

   161     }

   162 

   163     private static void test_multi(int iters) {

   164         int len1 = 8;    // the  8B/iteration loop

   165         int len2 = 32;   // the 32B/iteration loop

   166         int len3 = 4096; // the 4KB/iteration loop

   167 

   168         byte[] b = initializedBytes(len3*16, 0);

   169         int[] offsets = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 16, 32, 64, 128, 256, 512 };

   170         int[] sizes = { 0, 1, 2, 3, 4, 5, 6, 7,

   171                         len1, len1+1, len1+2, len1+3, len1+4, len1+5, len1+6, len1+7,

   172                         len1*2, len1*2+1, len1*2+3, len1*2+5, len1*2+7,

   173                         len2, len2+1, len2+3, len2+5, len2+7,

   174                         len2*2, len2*4, len2*8, len2*16, len2*32, len2*64,

   175                         len3, len3+1, len3+3, len3+5, len3+7,

   176                         len3*2, len3*4, len3*8,

   177                         len1+len2, len1+len2+1, len1+len2+3, len1+len2+5, len1+len2+7,

   178                         len1+len3, len1+len3+1, len1+len3+3, len1+len3+5, len1+len3+7,

   179                         len2+len3, len2+len3+1, len2+len3+3, len2+len3+5, len2+len3+7,

   180                         len1+len2+len3, len1+len2+len3+1, len1+len2+len3+3,

   181                         len1+len2+len3+5, len1+len2+len3+7,

   182                         (len1+len2+len3)*2, (len1+len2+len3)*2+1, (len1+len2+len3)*2+3,

   183                         (len1+len2+len3)*2+5, (len1+len2+len3)*2+7,

   184                         (len1+len2+len3)*3, (len1+len2+len3)*3-1, (len1+len2+len3)*3-3,

   185                         (len1+len2+len3)*3-5, (len1+len2+len3)*3-7 };

   186         Adler32[] adler0 = new Adler32[offsets.length*sizes.length];

   187         Adler32[] adler1 = new Adler32[offsets.length*sizes.length];

   188         int i, j, k;

   189 

   190         System.out.printf("testing %d cases ...\n", offsets.length*sizes.length);

   191 

   192         /* set the result from interpreter as reference */

   193         for (i = 0; i < offsets.length; i++) {

   194             for (j = 0; j < sizes.length; j++) {

   195                 adler0[i*sizes.length + j] = new Adler32();

   196                 adler1[i*sizes.length + j] = new Adler32();

   197                 adler0[i*sizes.length + j].update(b, offsets[i], sizes[j]);

   198             }

   199         }

   200 

   201         /* warm up the JIT compiler and get result */

   202         for (k = 0; k < iters; k++) {

   203             for (i = 0; i < offsets.length; i++) {

   204                 for (j = 0; j < sizes.length; j++) {

   205                     adler1[i*sizes.length + j].reset();

   206                     adler1[i*sizes.length + j].update(b, offsets[i], sizes[j]);

   207                 }

   208             }

   209         }

   210 

   211         /* check correctness */

   212         for (i = 0; i < offsets.length; i++) {

   213             for (j = 0; j < sizes.length; j++) {

   214                 if (!check(adler0[i*sizes.length + j], adler1[i*sizes.length + j])) {

   215                     System.out.printf("offsets[%d] = %d", i, offsets[i]);

   216                     System.out.printf("\tsizes[%d] = %d\n", j, sizes[j]);

   217                 }

   218             }

   219         }

   220     }

   221 }