1 /*
   2  * Copyright (c) 2012, 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 /**
  26  * @test
  27  * @bug 6340864
  28  * @summary Implement vectorization optimizations in hotspot-server
  29  *
  30  * @run main/othervm/timeout=400 -Xbatch -Xmx64m TestLongVect
  31  */
  32 
  33 public class TestLongVect {
  34   private static final int ARRLEN = 997;
  35   private static final int ITERS  = 11000;
  36   private static final long ADD_INIT = Long.MAX_VALUE-500;
  37   private static final long BIT_MASK = 0xEC80F731EC80F731L;
  38   private static final int VALUE = 31;
  39   private static final int SHIFT = 64;
  40 
  41   public static void main(String args[]) {
  42     System.out.println("Testing Long vectors");
  43     int errn = test();
  44     if (errn > 0) {
  45       System.err.println("FAILED: " + errn + " errors");
  46       System.exit(97);
  47     }
  48     System.out.println("PASSED");
  49   }
  50 
  51   static int test() {
  52     long[] a0 = new long[ARRLEN];
  53     long[] a1 = new long[ARRLEN];
  54     long[] a2 = new long[ARRLEN];
  55     long[] a3 = new long[ARRLEN];
  56     long[] a4 = new long[ARRLEN];
  57     // Initialize
  58     long gold_sum = 0;
  59     for (int i=0; i<ARRLEN; i++) {
  60       long val = (long)(ADD_INIT+i);
  61       gold_sum += val;
  62       a1[i] = val;
  63       a2[i] = (long)VALUE;
  64       a3[i] = (long)-VALUE;
  65       a4[i] = (long)BIT_MASK;
  66     }
  67     System.out.println("Warmup");
  68     for (int i=0; i<ITERS; i++) {
  69       test_sum(a1);
  70       test_addc(a0, a1);
  71       test_addv(a0, a1, (long)VALUE);
  72       test_adda(a0, a1, a2);
  73       test_subc(a0, a1);
  74       test_subv(a0, a1, (long)VALUE);
  75       test_suba(a0, a1, a2);
  76 
  77       test_mulc(a0, a1);
  78       test_mulv(a0, a1, (long)VALUE);
  79       test_mula(a0, a1, a2);
  80       test_divc(a0, a1);
  81       test_divv(a0, a1, (long)VALUE);
  82       test_diva(a0, a1, a2);
  83       test_mulc_n(a0, a1);
  84       test_mulv(a0, a1, (long)-VALUE);
  85       test_mula(a0, a1, a3);
  86       test_divc_n(a0, a1);
  87       test_divv(a0, a1, (long)-VALUE);
  88       test_diva(a0, a1, a3);
  89 
  90       test_andc(a0, a1);
  91       test_andv(a0, a1, (long)BIT_MASK);
  92       test_anda(a0, a1, a4);
  93       test_orc(a0, a1);
  94       test_orv(a0, a1, (long)BIT_MASK);
  95       test_ora(a0, a1, a4);
  96       test_xorc(a0, a1);
  97       test_xorv(a0, a1, (long)BIT_MASK);
  98       test_xora(a0, a1, a4);
  99 
 100       test_sllc(a0, a1);
 101       test_sllv(a0, a1, VALUE);
 102       test_srlc(a0, a1);
 103       test_srlv(a0, a1, VALUE);
 104       test_srac(a0, a1);
 105       test_srav(a0, a1, VALUE);
 106 
 107       test_sllc_n(a0, a1);
 108       test_sllv(a0, a1, -VALUE);
 109       test_srlc_n(a0, a1);
 110       test_srlv(a0, a1, -VALUE);
 111       test_srac_n(a0, a1);
 112       test_srav(a0, a1, -VALUE);
 113 
 114       test_sllc_o(a0, a1);
 115       test_sllv(a0, a1, SHIFT);
 116       test_srlc_o(a0, a1);
 117       test_srlv(a0, a1, SHIFT);
 118       test_srac_o(a0, a1);
 119       test_srav(a0, a1, SHIFT);
 120 
 121       test_sllc_on(a0, a1);
 122       test_sllv(a0, a1, -SHIFT);
 123       test_srlc_on(a0, a1);
 124       test_srlv(a0, a1, -SHIFT);
 125       test_srac_on(a0, a1);
 126       test_srav(a0, a1, -SHIFT);
 127 
 128       test_sllc_add(a0, a1);
 129       test_sllv_add(a0, a1, ADD_INIT);
 130       test_srlc_add(a0, a1);
 131       test_srlv_add(a0, a1, ADD_INIT);
 132       test_srac_add(a0, a1);
 133       test_srav_add(a0, a1, ADD_INIT);
 134 
 135       test_sllc_and(a0, a1);
 136       test_sllv_and(a0, a1, BIT_MASK);
 137       test_srlc_and(a0, a1);
 138       test_srlv_and(a0, a1, BIT_MASK);
 139       test_srac_and(a0, a1);
 140       test_srav_and(a0, a1, BIT_MASK);
 141     }
 142     // Test and verify results
 143     System.out.println("Verification");
 144     int errn = 0;
 145     {
 146       long sum = test_sum(a1);
 147       if (sum != gold_sum) {
 148         System.err.println("test_sum:  " + sum + " != " + gold_sum);
 149         errn++;
 150       }
 151 
 152       test_addc(a0, a1);
 153       for (int i=0; i<ARRLEN; i++) {
 154         errn += verify("test_addc: ", i, a0[i], (long)((long)(ADD_INIT+i)+VALUE));
 155       }
 156       test_addv(a0, a1, (long)VALUE);
 157       for (int i=0; i<ARRLEN; i++) {
 158         errn += verify("test_addv: ", i, a0[i], (long)((long)(ADD_INIT+i)+VALUE));
 159       }
 160       test_adda(a0, a1, a2);
 161       for (int i=0; i<ARRLEN; i++) {
 162         errn += verify("test_adda: ", i, a0[i], (long)((long)(ADD_INIT+i)+VALUE));
 163       }
 164 
 165       test_subc(a0, a1);
 166       for (int i=0; i<ARRLEN; i++) {
 167         errn += verify("test_subc: ", i, a0[i], (long)((long)(ADD_INIT+i)-VALUE));
 168       }
 169       test_subv(a0, a1, (long)VALUE);
 170       for (int i=0; i<ARRLEN; i++) {
 171         errn += verify("test_subv: ", i, a0[i], (long)((long)(ADD_INIT+i)-VALUE));
 172       }
 173       test_suba(a0, a1, a2);
 174       for (int i=0; i<ARRLEN; i++) {
 175         errn += verify("test_suba: ", i, a0[i], (long)((long)(ADD_INIT+i)-VALUE));
 176       }
 177 
 178       test_mulc(a0, a1);
 179       for (int i=0; i<ARRLEN; i++) {
 180         errn += verify("test_mulc: ", i, a0[i], (long)((long)(ADD_INIT+i)*VALUE));
 181       }
 182       test_mulv(a0, a1, (long)VALUE);
 183       for (int i=0; i<ARRLEN; i++) {
 184         errn += verify("test_mulv: ", i, a0[i], (long)((long)(ADD_INIT+i)*VALUE));
 185       }
 186       test_mula(a0, a1, a2);
 187       for (int i=0; i<ARRLEN; i++) {
 188         errn += verify("test_mula: ", i, a0[i], (long)((long)(ADD_INIT+i)*VALUE));
 189       }
 190 
 191       test_divc(a0, a1);
 192       for (int i=0; i<ARRLEN; i++) {
 193         errn += verify("test_divc: ", i, a0[i], (long)((long)(ADD_INIT+i)/VALUE));
 194       }
 195       test_divv(a0, a1, (long)VALUE);
 196       for (int i=0; i<ARRLEN; i++) {
 197         errn += verify("test_divv: ", i, a0[i], (long)((long)(ADD_INIT+i)/VALUE));
 198       }
 199       test_diva(a0, a1, a2);
 200       for (int i=0; i<ARRLEN; i++) {
 201         errn += verify("test_diva: ", i, a0[i], (long)((long)(ADD_INIT+i)/VALUE));
 202       }
 203 
 204       test_mulc_n(a0, a1);
 205       for (int i=0; i<ARRLEN; i++) {
 206         errn += verify("test_mulc_n: ", i, a0[i], (long)((long)(ADD_INIT+i)*(-VALUE)));
 207       }
 208       test_mulv(a0, a1, (long)-VALUE);
 209       for (int i=0; i<ARRLEN; i++) {
 210         errn += verify("test_mulv_n: ", i, a0[i], (long)((long)(ADD_INIT+i)*(-VALUE)));
 211       }
 212       test_mula(a0, a1, a3);
 213       for (int i=0; i<ARRLEN; i++) {
 214         errn += verify("test_mula_n: ", i, a0[i], (long)((long)(ADD_INIT+i)*(-VALUE)));
 215       }
 216 
 217       test_divc_n(a0, a1);
 218       for (int i=0; i<ARRLEN; i++) {
 219         errn += verify("test_divc_n: ", i, a0[i], (long)((long)(ADD_INIT+i)/(-VALUE)));
 220       }
 221       test_divv(a0, a1, (long)-VALUE);
 222       for (int i=0; i<ARRLEN; i++) {
 223         errn += verify("test_divv_n: ", i, a0[i], (long)((long)(ADD_INIT+i)/(-VALUE)));
 224       }
 225       test_diva(a0, a1, a3);
 226       for (int i=0; i<ARRLEN; i++) {
 227         errn += verify("test_diva_n: ", i, a0[i], (long)((long)(ADD_INIT+i)/(-VALUE)));
 228       }
 229 
 230       test_andc(a0, a1);
 231       for (int i=0; i<ARRLEN; i++) {
 232         errn += verify("test_andc: ", i, a0[i], (long)((long)(ADD_INIT+i)&BIT_MASK));
 233       }
 234       test_andv(a0, a1, (long)BIT_MASK);
 235       for (int i=0; i<ARRLEN; i++) {
 236         errn += verify("test_andv: ", i, a0[i], (long)((long)(ADD_INIT+i)&BIT_MASK));
 237       }
 238       test_anda(a0, a1, a4);
 239       for (int i=0; i<ARRLEN; i++) {
 240         errn += verify("test_anda: ", i, a0[i], (long)((long)(ADD_INIT+i)&BIT_MASK));
 241       }
 242 
 243       test_orc(a0, a1);
 244       for (int i=0; i<ARRLEN; i++) {
 245         errn += verify("test_orc: ", i, a0[i], (long)((long)(ADD_INIT+i)|BIT_MASK));
 246       }
 247       test_orv(a0, a1, (long)BIT_MASK);
 248       for (int i=0; i<ARRLEN; i++) {
 249         errn += verify("test_orv: ", i, a0[i], (long)((long)(ADD_INIT+i)|BIT_MASK));
 250       }
 251       test_ora(a0, a1, a4);
 252       for (int i=0; i<ARRLEN; i++) {
 253         errn += verify("test_ora: ", i, a0[i], (long)((long)(ADD_INIT+i)|BIT_MASK));
 254       }
 255 
 256       test_xorc(a0, a1);
 257       for (int i=0; i<ARRLEN; i++) {
 258         errn += verify("test_xorc: ", i, a0[i], (long)((long)(ADD_INIT+i)^BIT_MASK));
 259       }
 260       test_xorv(a0, a1, (long)BIT_MASK);
 261       for (int i=0; i<ARRLEN; i++) {
 262         errn += verify("test_xorv: ", i, a0[i], (long)((long)(ADD_INIT+i)^BIT_MASK));
 263       }
 264       test_xora(a0, a1, a4);
 265       for (int i=0; i<ARRLEN; i++) {
 266         errn += verify("test_xora: ", i, a0[i], (long)((long)(ADD_INIT+i)^BIT_MASK));
 267       }
 268 
 269       test_sllc(a0, a1);
 270       for (int i=0; i<ARRLEN; i++) {
 271         errn += verify("test_sllc: ", i, a0[i], (long)((long)(ADD_INIT+i)<<VALUE));
 272       }
 273       test_sllv(a0, a1, VALUE);
 274       for (int i=0; i<ARRLEN; i++) {
 275         errn += verify("test_sllv: ", i, a0[i], (long)((long)(ADD_INIT+i)<<VALUE));
 276       }
 277 
 278       test_srlc(a0, a1);
 279       for (int i=0; i<ARRLEN; i++) {
 280         errn += verify("test_srlc: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>VALUE));
 281       }
 282       test_srlv(a0, a1, VALUE);
 283       for (int i=0; i<ARRLEN; i++) {
 284         errn += verify("test_srlv: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>VALUE));
 285       }
 286 
 287       test_srac(a0, a1);
 288       for (int i=0; i<ARRLEN; i++) {
 289         errn += verify("test_srac: ", i, a0[i], (long)((long)(ADD_INIT+i)>>VALUE));
 290       }
 291       test_srav(a0, a1, VALUE);
 292       for (int i=0; i<ARRLEN; i++) {
 293         errn += verify("test_srav: ", i, a0[i], (long)((long)(ADD_INIT+i)>>VALUE));
 294       }
 295 
 296       test_sllc_n(a0, a1);
 297       for (int i=0; i<ARRLEN; i++) {
 298         errn += verify("test_sllc_n: ", i, a0[i], (long)((long)(ADD_INIT+i)<<(-VALUE)));
 299       }
 300       test_sllv(a0, a1, -VALUE);
 301       for (int i=0; i<ARRLEN; i++) {
 302         errn += verify("test_sllv_n: ", i, a0[i], (long)((long)(ADD_INIT+i)<<(-VALUE)));
 303       }
 304 
 305       test_srlc_n(a0, a1);
 306       for (int i=0; i<ARRLEN; i++) {
 307         errn += verify("test_srlc_n: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>(-VALUE)));
 308       }
 309       test_srlv(a0, a1, -VALUE);
 310       for (int i=0; i<ARRLEN; i++) {
 311         errn += verify("test_srlv_n: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>(-VALUE)));
 312       }
 313 
 314       test_srac_n(a0, a1);
 315       for (int i=0; i<ARRLEN; i++) {
 316         errn += verify("test_srac_n: ", i, a0[i], (long)((long)(ADD_INIT+i)>>(-VALUE)));
 317       }
 318       test_srav(a0, a1, -VALUE);
 319       for (int i=0; i<ARRLEN; i++) {
 320         errn += verify("test_srav_n: ", i, a0[i], (long)((long)(ADD_INIT+i)>>(-VALUE)));
 321       }
 322 
 323       test_sllc_o(a0, a1);
 324       for (int i=0; i<ARRLEN; i++) {
 325         errn += verify("test_sllc_o: ", i, a0[i], (long)((long)(ADD_INIT+i)<<SHIFT));
 326       }
 327       test_sllv(a0, a1, SHIFT);
 328       for (int i=0; i<ARRLEN; i++) {
 329         errn += verify("test_sllv_o: ", i, a0[i], (long)((long)(ADD_INIT+i)<<SHIFT));
 330       }
 331 
 332       test_srlc_o(a0, a1);
 333       for (int i=0; i<ARRLEN; i++) {
 334         errn += verify("test_srlc_o: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>SHIFT));
 335       }
 336       test_srlv(a0, a1, SHIFT);
 337       for (int i=0; i<ARRLEN; i++) {
 338         errn += verify("test_srlv_o: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>SHIFT));
 339       }
 340 
 341       test_srac_o(a0, a1);
 342       for (int i=0; i<ARRLEN; i++) {
 343         errn += verify("test_srac_o: ", i, a0[i], (long)((long)(ADD_INIT+i)>>SHIFT));
 344       }
 345       test_srav(a0, a1, SHIFT);
 346       for (int i=0; i<ARRLEN; i++) {
 347         errn += verify("test_srav_o: ", i, a0[i], (long)((long)(ADD_INIT+i)>>SHIFT));
 348       }
 349 
 350       test_sllc_on(a0, a1);
 351       for (int i=0; i<ARRLEN; i++) {
 352         errn += verify("test_sllc_on: ", i, a0[i], (long)((long)(ADD_INIT+i)<<(-SHIFT)));
 353       }
 354       test_sllv(a0, a1, -SHIFT);
 355       for (int i=0; i<ARRLEN; i++) {
 356         errn += verify("test_sllv_on: ", i, a0[i], (long)((long)(ADD_INIT+i)<<(-SHIFT)));
 357       }
 358 
 359       test_srlc_on(a0, a1);
 360       for (int i=0; i<ARRLEN; i++) {
 361         errn += verify("test_srlc_on: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>(-SHIFT)));
 362       }
 363       test_srlv(a0, a1, -SHIFT);
 364       for (int i=0; i<ARRLEN; i++) {
 365         errn += verify("test_srlv_on: ", i, a0[i], (long)((long)(ADD_INIT+i)>>>(-SHIFT)));
 366       }
 367 
 368       test_srac_on(a0, a1);
 369       for (int i=0; i<ARRLEN; i++) {
 370         errn += verify("test_srac_on: ", i, a0[i], (long)((long)(ADD_INIT+i)>>(-SHIFT)));
 371       }
 372       test_srav(a0, a1, -SHIFT);
 373       for (int i=0; i<ARRLEN; i++) {
 374         errn += verify("test_srav_on: ", i, a0[i], (long)((long)(ADD_INIT+i)>>(-SHIFT)));
 375       }
 376 
 377       test_sllc_add(a0, a1);
 378       for (int i=0; i<ARRLEN; i++) {
 379         errn += verify("test_sllc_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)<<VALUE));
 380       }
 381       test_sllv_add(a0, a1, ADD_INIT);
 382       for (int i=0; i<ARRLEN; i++) {
 383         errn += verify("test_sllv_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)<<VALUE));
 384       }
 385 
 386       test_srlc_add(a0, a1);
 387       for (int i=0; i<ARRLEN; i++) {
 388         errn += verify("test_srlc_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)>>>VALUE));
 389       }
 390       test_srlv_add(a0, a1, ADD_INIT);
 391       for (int i=0; i<ARRLEN; i++) {
 392         errn += verify("test_srlv_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)>>>VALUE));
 393       }
 394 
 395       test_srac_add(a0, a1);
 396       for (int i=0; i<ARRLEN; i++) {
 397         errn += verify("test_srac_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)>>VALUE));
 398       }
 399       test_srav_add(a0, a1, ADD_INIT);
 400       for (int i=0; i<ARRLEN; i++) {
 401         errn += verify("test_srav_add: ", i, a0[i], (long)(((long)(ADD_INIT+i) + ADD_INIT)>>VALUE));
 402       }
 403 
 404       test_sllc_and(a0, a1);
 405       for (int i=0; i<ARRLEN; i++) {
 406         errn += verify("test_sllc_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)<<VALUE));
 407       }
 408       test_sllv_and(a0, a1, BIT_MASK);
 409       for (int i=0; i<ARRLEN; i++) {
 410         errn += verify("test_sllv_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)<<VALUE));
 411       }
 412 
 413       test_srlc_and(a0, a1);
 414       for (int i=0; i<ARRLEN; i++) {
 415         errn += verify("test_srlc_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)>>>VALUE));
 416       }
 417       test_srlv_and(a0, a1, BIT_MASK);
 418       for (int i=0; i<ARRLEN; i++) {
 419         errn += verify("test_srlv_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)>>>VALUE));
 420       }
 421 
 422       test_srac_and(a0, a1);
 423       for (int i=0; i<ARRLEN; i++) {
 424         errn += verify("test_srac_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)>>VALUE));
 425       }
 426       test_srav_and(a0, a1, BIT_MASK);
 427       for (int i=0; i<ARRLEN; i++) {
 428         errn += verify("test_srav_and: ", i, a0[i], (long)(((long)(ADD_INIT+i) & BIT_MASK)>>VALUE));
 429       }
 430 
 431     }
 432 
 433     if (errn > 0)
 434       return errn;
 435 
 436     System.out.println("Time");
 437     long start, end;
 438 
 439     start = System.currentTimeMillis();
 440     for (int i=0; i<ITERS; i++) {
 441       test_sum(a1);
 442     }
 443     end = System.currentTimeMillis();
 444     System.out.println("test_sum: " + (end - start));
 445 
 446     start = System.currentTimeMillis();
 447     for (int i=0; i<ITERS; i++) {
 448       test_addc(a0, a1);
 449     }
 450     end = System.currentTimeMillis();
 451     System.out.println("test_addc: " + (end - start));
 452     start = System.currentTimeMillis();
 453     for (int i=0; i<ITERS; i++) {
 454       test_addv(a0, a1, (long)VALUE);
 455     }
 456     end = System.currentTimeMillis();
 457     System.out.println("test_addv: " + (end - start));
 458     start = System.currentTimeMillis();
 459     for (int i=0; i<ITERS; i++) {
 460       test_adda(a0, a1, a2);
 461     }
 462     end = System.currentTimeMillis();
 463     System.out.println("test_adda: " + (end - start));
 464 
 465     start = System.currentTimeMillis();
 466     for (int i=0; i<ITERS; i++) {
 467       test_subc(a0, a1);
 468     }
 469     end = System.currentTimeMillis();
 470     System.out.println("test_subc: " + (end - start));
 471     start = System.currentTimeMillis();
 472     for (int i=0; i<ITERS; i++) {
 473       test_subv(a0, a1, (long)VALUE);
 474     }
 475     end = System.currentTimeMillis();
 476     System.out.println("test_subv: " + (end - start));
 477     start = System.currentTimeMillis();
 478     for (int i=0; i<ITERS; i++) {
 479       test_suba(a0, a1, a2);
 480     }
 481     end = System.currentTimeMillis();
 482     System.out.println("test_suba: " + (end - start));
 483 
 484     start = System.currentTimeMillis();
 485     for (int i=0; i<ITERS; i++) {
 486       test_mulc(a0, a1);
 487     }
 488     end = System.currentTimeMillis();
 489     System.out.println("test_mulc: " + (end - start));
 490     start = System.currentTimeMillis();
 491     for (int i=0; i<ITERS; i++) {
 492       test_mulv(a0, a1, (long)VALUE);
 493     }
 494     end = System.currentTimeMillis();
 495     System.out.println("test_mulv: " + (end - start));
 496     start = System.currentTimeMillis();
 497     for (int i=0; i<ITERS; i++) {
 498       test_mula(a0, a1, a2);
 499     }
 500     end = System.currentTimeMillis();
 501     System.out.println("test_mula: " + (end - start));
 502 
 503     start = System.currentTimeMillis();
 504     for (int i=0; i<ITERS; i++) {
 505       test_divc(a0, a1);
 506     }
 507     end = System.currentTimeMillis();
 508     System.out.println("test_divc: " + (end - start));
 509     start = System.currentTimeMillis();
 510     for (int i=0; i<ITERS; i++) {
 511       test_divv(a0, a1, (long)VALUE);
 512     }
 513     end = System.currentTimeMillis();
 514     System.out.println("test_divv: " + (end - start));
 515     start = System.currentTimeMillis();
 516     for (int i=0; i<ITERS; i++) {
 517       test_diva(a0, a1, a2);
 518     }
 519     end = System.currentTimeMillis();
 520     System.out.println("test_diva: " + (end - start));
 521 
 522     start = System.currentTimeMillis();
 523     for (int i=0; i<ITERS; i++) {
 524       test_mulc_n(a0, a1);
 525     }
 526     end = System.currentTimeMillis();
 527     System.out.println("test_mulc_n: " + (end - start));
 528     start = System.currentTimeMillis();
 529     for (int i=0; i<ITERS; i++) {
 530       test_mulv(a0, a1, (long)-VALUE);
 531     }
 532     end = System.currentTimeMillis();
 533     System.out.println("test_mulv_n: " + (end - start));
 534     start = System.currentTimeMillis();
 535     for (int i=0; i<ITERS; i++) {
 536       test_mula(a0, a1, a3);
 537     }
 538     end = System.currentTimeMillis();
 539     System.out.println("test_mula_n: " + (end - start));
 540 
 541     start = System.currentTimeMillis();
 542     for (int i=0; i<ITERS; i++) {
 543       test_divc_n(a0, a1);
 544     }
 545     end = System.currentTimeMillis();
 546     System.out.println("test_divc_n: " + (end - start));
 547     start = System.currentTimeMillis();
 548     for (int i=0; i<ITERS; i++) {
 549       test_divv(a0, a1, (long)-VALUE);
 550     }
 551     end = System.currentTimeMillis();
 552     System.out.println("test_divv_n: " + (end - start));
 553     start = System.currentTimeMillis();
 554     for (int i=0; i<ITERS; i++) {
 555       test_diva(a0, a1, a3);
 556     }
 557     end = System.currentTimeMillis();
 558     System.out.println("test_diva_n: " + (end - start));
 559 
 560     start = System.currentTimeMillis();
 561     for (int i=0; i<ITERS; i++) {
 562       test_andc(a0, a1);
 563     }
 564     end = System.currentTimeMillis();
 565     System.out.println("test_andc: " + (end - start));
 566     start = System.currentTimeMillis();
 567     for (int i=0; i<ITERS; i++) {
 568       test_andv(a0, a1, (long)BIT_MASK);
 569     }
 570     end = System.currentTimeMillis();
 571     System.out.println("test_andv: " + (end - start));
 572     start = System.currentTimeMillis();
 573     for (int i=0; i<ITERS; i++) {
 574       test_anda(a0, a1, a4);
 575     }
 576     end = System.currentTimeMillis();
 577     System.out.println("test_anda: " + (end - start));
 578 
 579     start = System.currentTimeMillis();
 580     for (int i=0; i<ITERS; i++) {
 581       test_orc(a0, a1);
 582     }
 583     end = System.currentTimeMillis();
 584     System.out.println("test_orc: " + (end - start));
 585     start = System.currentTimeMillis();
 586     for (int i=0; i<ITERS; i++) {
 587       test_orv(a0, a1, (long)BIT_MASK);
 588     }
 589     end = System.currentTimeMillis();
 590     System.out.println("test_orv: " + (end - start));
 591     start = System.currentTimeMillis();
 592     for (int i=0; i<ITERS; i++) {
 593       test_ora(a0, a1, a4);
 594     }
 595     end = System.currentTimeMillis();
 596     System.out.println("test_ora: " + (end - start));
 597 
 598     start = System.currentTimeMillis();
 599     for (int i=0; i<ITERS; i++) {
 600       test_xorc(a0, a1);
 601     }
 602     end = System.currentTimeMillis();
 603     System.out.println("test_xorc: " + (end - start));
 604     start = System.currentTimeMillis();
 605     for (int i=0; i<ITERS; i++) {
 606       test_xorv(a0, a1, (long)BIT_MASK);
 607     }
 608     end = System.currentTimeMillis();
 609     System.out.println("test_xorv: " + (end - start));
 610     start = System.currentTimeMillis();
 611     for (int i=0; i<ITERS; i++) {
 612       test_xora(a0, a1, a4);
 613     }
 614     end = System.currentTimeMillis();
 615     System.out.println("test_xora: " + (end - start));
 616 
 617     start = System.currentTimeMillis();
 618     for (int i=0; i<ITERS; i++) {
 619       test_sllc(a0, a1);
 620     }
 621     end = System.currentTimeMillis();
 622     System.out.println("test_sllc: " + (end - start));
 623     start = System.currentTimeMillis();
 624     for (int i=0; i<ITERS; i++) {
 625       test_sllv(a0, a1, VALUE);
 626     }
 627     end = System.currentTimeMillis();
 628     System.out.println("test_sllv: " + (end - start));
 629 
 630     start = System.currentTimeMillis();
 631     for (int i=0; i<ITERS; i++) {
 632       test_srlc(a0, a1);
 633     }
 634     end = System.currentTimeMillis();
 635     System.out.println("test_srlc: " + (end - start));
 636     start = System.currentTimeMillis();
 637     for (int i=0; i<ITERS; i++) {
 638       test_srlv(a0, a1, VALUE);
 639     }
 640     end = System.currentTimeMillis();
 641     System.out.println("test_srlv: " + (end - start));
 642 
 643     start = System.currentTimeMillis();
 644     for (int i=0; i<ITERS; i++) {
 645       test_srac(a0, a1);
 646     }
 647     end = System.currentTimeMillis();
 648     System.out.println("test_srac: " + (end - start));
 649     start = System.currentTimeMillis();
 650     for (int i=0; i<ITERS; i++) {
 651       test_srav(a0, a1, VALUE);
 652     }
 653     end = System.currentTimeMillis();
 654     System.out.println("test_srav: " + (end - start));
 655 
 656     start = System.currentTimeMillis();
 657     for (int i=0; i<ITERS; i++) {
 658       test_sllc_n(a0, a1);
 659     }
 660     end = System.currentTimeMillis();
 661     System.out.println("test_sllc_n: " + (end - start));
 662     start = System.currentTimeMillis();
 663     for (int i=0; i<ITERS; i++) {
 664       test_sllv(a0, a1, -VALUE);
 665     }
 666     end = System.currentTimeMillis();
 667     System.out.println("test_sllv_n: " + (end - start));
 668 
 669     start = System.currentTimeMillis();
 670     for (int i=0; i<ITERS; i++) {
 671       test_srlc_n(a0, a1);
 672     }
 673     end = System.currentTimeMillis();
 674     System.out.println("test_srlc_n: " + (end - start));
 675     start = System.currentTimeMillis();
 676     for (int i=0; i<ITERS; i++) {
 677       test_srlv(a0, a1, -VALUE);
 678     }
 679     end = System.currentTimeMillis();
 680     System.out.println("test_srlv_n: " + (end - start));
 681 
 682     start = System.currentTimeMillis();
 683     for (int i=0; i<ITERS; i++) {
 684       test_srac_n(a0, a1);
 685     }
 686     end = System.currentTimeMillis();
 687     System.out.println("test_srac_n: " + (end - start));
 688     start = System.currentTimeMillis();
 689     for (int i=0; i<ITERS; i++) {
 690       test_srav(a0, a1, -VALUE);
 691     }
 692     end = System.currentTimeMillis();
 693     System.out.println("test_srav_n: " + (end - start));
 694 
 695     start = System.currentTimeMillis();
 696     for (int i=0; i<ITERS; i++) {
 697       test_sllc_o(a0, a1);
 698     }
 699     end = System.currentTimeMillis();
 700     System.out.println("test_sllc_o: " + (end - start));
 701     start = System.currentTimeMillis();
 702     for (int i=0; i<ITERS; i++) {
 703       test_sllv(a0, a1, SHIFT);
 704     }
 705     end = System.currentTimeMillis();
 706     System.out.println("test_sllv_o: " + (end - start));
 707 
 708     start = System.currentTimeMillis();
 709     for (int i=0; i<ITERS; i++) {
 710       test_srlc_o(a0, a1);
 711     }
 712     end = System.currentTimeMillis();
 713     System.out.println("test_srlc_o: " + (end - start));
 714     start = System.currentTimeMillis();
 715     for (int i=0; i<ITERS; i++) {
 716       test_srlv(a0, a1, SHIFT);
 717     }
 718     end = System.currentTimeMillis();
 719     System.out.println("test_srlv_o: " + (end - start));
 720 
 721     start = System.currentTimeMillis();
 722     for (int i=0; i<ITERS; i++) {
 723       test_srac_o(a0, a1);
 724     }
 725     end = System.currentTimeMillis();
 726     System.out.println("test_srac_o: " + (end - start));
 727     start = System.currentTimeMillis();
 728     for (int i=0; i<ITERS; i++) {
 729       test_srav(a0, a1, SHIFT);
 730     }
 731     end = System.currentTimeMillis();
 732     System.out.println("test_srav_o: " + (end - start));
 733 
 734     start = System.currentTimeMillis();
 735     for (int i=0; i<ITERS; i++) {
 736       test_sllc_on(a0, a1);
 737     }
 738     end = System.currentTimeMillis();
 739     System.out.println("test_sllc_on: " + (end - start));
 740     start = System.currentTimeMillis();
 741     for (int i=0; i<ITERS; i++) {
 742       test_sllv(a0, a1, -SHIFT);
 743     }
 744     end = System.currentTimeMillis();
 745     System.out.println("test_sllv_on: " + (end - start));
 746 
 747     start = System.currentTimeMillis();
 748     for (int i=0; i<ITERS; i++) {
 749       test_srlc_on(a0, a1);
 750     }
 751     end = System.currentTimeMillis();
 752     System.out.println("test_srlc_on: " + (end - start));
 753     start = System.currentTimeMillis();
 754     for (int i=0; i<ITERS; i++) {
 755       test_srlv(a0, a1, -SHIFT);
 756     }
 757     end = System.currentTimeMillis();
 758     System.out.println("test_srlv_on: " + (end - start));
 759 
 760     start = System.currentTimeMillis();
 761     for (int i=0; i<ITERS; i++) {
 762       test_srac_on(a0, a1);
 763     }
 764     end = System.currentTimeMillis();
 765     System.out.println("test_srac_on: " + (end - start));
 766     start = System.currentTimeMillis();
 767     for (int i=0; i<ITERS; i++) {
 768       test_srav(a0, a1, -SHIFT);
 769     }
 770     end = System.currentTimeMillis();
 771     System.out.println("test_srav_on: " + (end - start));
 772 
 773     start = System.currentTimeMillis();
 774     for (int i=0; i<ITERS; i++) {
 775       test_sllc_add(a0, a1);
 776     }
 777     end = System.currentTimeMillis();
 778     System.out.println("test_sllc_add: " + (end - start));
 779     start = System.currentTimeMillis();
 780     for (int i=0; i<ITERS; i++) {
 781       test_sllv_add(a0, a1, ADD_INIT);
 782     }
 783     end = System.currentTimeMillis();
 784     System.out.println("test_sllv_add: " + (end - start));
 785 
 786     start = System.currentTimeMillis();
 787     for (int i=0; i<ITERS; i++) {
 788       test_srlc_add(a0, a1);
 789     }
 790     end = System.currentTimeMillis();
 791     System.out.println("test_srlc_add: " + (end - start));
 792     start = System.currentTimeMillis();
 793     for (int i=0; i<ITERS; i++) {
 794       test_srlv_add(a0, a1, ADD_INIT);
 795     }
 796     end = System.currentTimeMillis();
 797     System.out.println("test_srlv_add: " + (end - start));
 798 
 799     start = System.currentTimeMillis();
 800     for (int i=0; i<ITERS; i++) {
 801       test_srac_add(a0, a1);
 802     }
 803     end = System.currentTimeMillis();
 804     System.out.println("test_srac_add: " + (end - start));
 805     start = System.currentTimeMillis();
 806     for (int i=0; i<ITERS; i++) {
 807       test_srav_add(a0, a1, ADD_INIT);
 808     }
 809     end = System.currentTimeMillis();
 810     System.out.println("test_srav_add: " + (end - start));
 811 
 812     start = System.currentTimeMillis();
 813     for (int i=0; i<ITERS; i++) {
 814       test_sllc_and(a0, a1);
 815     }
 816     end = System.currentTimeMillis();
 817     System.out.println("test_sllc_and: " + (end - start));
 818     start = System.currentTimeMillis();
 819     for (int i=0; i<ITERS; i++) {
 820       test_sllv_and(a0, a1, BIT_MASK);
 821     }
 822     end = System.currentTimeMillis();
 823     System.out.println("test_sllv_and: " + (end - start));
 824 
 825     start = System.currentTimeMillis();
 826     for (int i=0; i<ITERS; i++) {
 827       test_srlc_and(a0, a1);
 828     }
 829     end = System.currentTimeMillis();
 830     System.out.println("test_srlc_and: " + (end - start));
 831     start = System.currentTimeMillis();
 832     for (int i=0; i<ITERS; i++) {
 833       test_srlv_and(a0, a1, BIT_MASK);
 834     }
 835     end = System.currentTimeMillis();
 836     System.out.println("test_srlv_and: " + (end - start));
 837 
 838     start = System.currentTimeMillis();
 839     for (int i=0; i<ITERS; i++) {
 840       test_srac_and(a0, a1);
 841     }
 842     end = System.currentTimeMillis();
 843     System.out.println("test_srac_and: " + (end - start));
 844     start = System.currentTimeMillis();
 845     for (int i=0; i<ITERS; i++) {
 846       test_srav_and(a0, a1, BIT_MASK);
 847     }
 848     end = System.currentTimeMillis();
 849     System.out.println("test_srav_and: " + (end - start));
 850 
 851     return errn;
 852   }
 853 
 854   static long test_sum(long[] a1) {
 855     long sum = 0;
 856     for (int i = 0; i < a1.length; i+=1) {
 857       sum += a1[i];
 858     }
 859     return sum;
 860   }
 861 
 862   static void test_addc(long[] a0, long[] a1) {
 863     for (int i = 0; i < a0.length; i+=1) {
 864       a0[i] = (long)(a1[i]+VALUE);
 865     }
 866   }
 867   static void test_addv(long[] a0, long[] a1, long b) {
 868     for (int i = 0; i < a0.length; i+=1) {
 869       a0[i] = (long)(a1[i]+b);
 870     }
 871   }
 872   static void test_adda(long[] a0, long[] a1, long[] a2) {
 873     for (int i = 0; i < a0.length; i+=1) {
 874       a0[i] = (long)(a1[i]+a2[i]);
 875     }
 876   }
 877 
 878   static void test_subc(long[] a0, long[] a1) {
 879     for (int i = 0; i < a0.length; i+=1) {
 880       a0[i] = (long)(a1[i]-VALUE);
 881     }
 882   }
 883   static void test_subv(long[] a0, long[] a1, long b) {
 884     for (int i = 0; i < a0.length; i+=1) {
 885       a0[i] = (long)(a1[i]-b);
 886     }
 887   }
 888   static void test_suba(long[] a0, long[] a1, long[] a2) {
 889     for (int i = 0; i < a0.length; i+=1) {
 890       a0[i] = (long)(a1[i]-a2[i]);
 891     }
 892   }
 893 
 894   static void test_mulc(long[] a0, long[] a1) {
 895     for (int i = 0; i < a0.length; i+=1) {
 896       a0[i] = (long)(a1[i]*VALUE);
 897     }
 898   }
 899   static void test_mulc_n(long[] a0, long[] a1) {
 900     for (int i = 0; i < a0.length; i+=1) {
 901       a0[i] = (long)(a1[i]*(-VALUE));
 902     }
 903   }
 904   static void test_mulv(long[] a0, long[] a1, long b) {
 905     for (int i = 0; i < a0.length; i+=1) {
 906       a0[i] = (long)(a1[i]*b);
 907     }
 908   }
 909   static void test_mula(long[] a0, long[] a1, long[] a2) {
 910     for (int i = 0; i < a0.length; i+=1) {
 911       a0[i] = (long)(a1[i]*a2[i]);
 912     }
 913   }
 914 
 915   static void test_divc(long[] a0, long[] a1) {
 916     for (int i = 0; i < a0.length; i+=1) {
 917       a0[i] = (long)(a1[i]/VALUE);
 918     }
 919   }
 920   static void test_divc_n(long[] a0, long[] a1) {
 921     for (int i = 0; i < a0.length; i+=1) {
 922       a0[i] = (long)(a1[i]/(-VALUE));
 923     }
 924   }
 925   static void test_divv(long[] a0, long[] a1, long b) {
 926     for (int i = 0; i < a0.length; i+=1) {
 927       a0[i] = (long)(a1[i]/b);
 928     }
 929   }
 930   static void test_diva(long[] a0, long[] a1, long[] a2) {
 931     for (int i = 0; i < a0.length; i+=1) {
 932       a0[i] = (long)(a1[i]/a2[i]);
 933     }
 934   }
 935 
 936   static void test_andc(long[] a0, long[] a1) {
 937     for (int i = 0; i < a0.length; i+=1) {
 938       a0[i] = (long)(a1[i]&BIT_MASK);
 939     }
 940   }
 941   static void test_andv(long[] a0, long[] a1, long b) {
 942     for (int i = 0; i < a0.length; i+=1) {
 943       a0[i] = (long)(a1[i]&b);
 944     }
 945   }
 946   static void test_anda(long[] a0, long[] a1, long[] a2) {
 947     for (int i = 0; i < a0.length; i+=1) {
 948       a0[i] = (long)(a1[i]&a2[i]);
 949     }
 950   }
 951 
 952   static void test_orc(long[] a0, long[] a1) {
 953     for (int i = 0; i < a0.length; i+=1) {
 954       a0[i] = (long)(a1[i]|BIT_MASK);
 955     }
 956   }
 957   static void test_orv(long[] a0, long[] a1, long b) {
 958     for (int i = 0; i < a0.length; i+=1) {
 959       a0[i] = (long)(a1[i]|b);
 960     }
 961   }
 962   static void test_ora(long[] a0, long[] a1, long[] a2) {
 963     for (int i = 0; i < a0.length; i+=1) {
 964       a0[i] = (long)(a1[i]|a2[i]);
 965     }
 966   }
 967 
 968   static void test_xorc(long[] a0, long[] a1) {
 969     for (int i = 0; i < a0.length; i+=1) {
 970       a0[i] = (long)(a1[i]^BIT_MASK);
 971     }
 972   }
 973   static void test_xorv(long[] a0, long[] a1, long b) {
 974     for (int i = 0; i < a0.length; i+=1) {
 975       a0[i] = (long)(a1[i]^b);
 976     }
 977   }
 978   static void test_xora(long[] a0, long[] a1, long[] a2) {
 979     for (int i = 0; i < a0.length; i+=1) {
 980       a0[i] = (long)(a1[i]^a2[i]);
 981     }
 982   }
 983 
 984   static void test_sllc(long[] a0, long[] a1) {
 985     for (int i = 0; i < a0.length; i+=1) {
 986       a0[i] = (long)(a1[i]<<VALUE);
 987     }
 988   }
 989   static void test_sllc_n(long[] a0, long[] a1) {
 990     for (int i = 0; i < a0.length; i+=1) {
 991       a0[i] = (long)(a1[i]<<(-VALUE));
 992     }
 993   }
 994   static void test_sllc_o(long[] a0, long[] a1) {
 995     for (int i = 0; i < a0.length; i+=1) {
 996       a0[i] = (long)(a1[i]<<SHIFT);
 997     }
 998   }
 999   static void test_sllc_on(long[] a0, long[] a1) {
1000     for (int i = 0; i < a0.length; i+=1) {
1001       a0[i] = (long)(a1[i]<<(-SHIFT));
1002     }
1003   }
1004   static void test_sllv(long[] a0, long[] a1, int b) {
1005     for (int i = 0; i < a0.length; i+=1) {
1006       a0[i] = (long)(a1[i]<<b);
1007     }
1008   }
1009   static void test_sllc_add(long[] a0, long[] a1) {
1010     for (int i = 0; i < a0.length; i+=1) {
1011       a0[i] = (long)((a1[i] + ADD_INIT)<<VALUE);
1012     }
1013   }
1014   static void test_sllv_add(long[] a0, long[] a1, long b) {
1015     for (int i = 0; i < a0.length; i+=1) {
1016       a0[i] = (long)((a1[i] + b)<<VALUE);
1017     }
1018   }
1019   static void test_sllc_and(long[] a0, long[] a1) {
1020     for (int i = 0; i < a0.length; i+=1) {
1021       a0[i] = (long)((a1[i] & BIT_MASK)<<VALUE);
1022     }
1023   }
1024   static void test_sllv_and(long[] a0, long[] a1, long b) {
1025     for (int i = 0; i < a0.length; i+=1) {
1026       a0[i] = (long)((a1[i] & b)<<VALUE);
1027     }
1028   }
1029 
1030   static void test_srlc(long[] a0, long[] a1) {
1031     for (int i = 0; i < a0.length; i+=1) {
1032       a0[i] = (long)(a1[i]>>>VALUE);
1033     }
1034   }
1035   static void test_srlc_n(long[] a0, long[] a1) {
1036     for (int i = 0; i < a0.length; i+=1) {
1037       a0[i] = (long)(a1[i]>>>(-VALUE));
1038     }
1039   }
1040   static void test_srlc_o(long[] a0, long[] a1) {
1041     for (int i = 0; i < a0.length; i+=1) {
1042       a0[i] = (long)(a1[i]>>>SHIFT);
1043     }
1044   }
1045   static void test_srlc_on(long[] a0, long[] a1) {
1046     for (int i = 0; i < a0.length; i+=1) {
1047       a0[i] = (long)(a1[i]>>>(-SHIFT));
1048     }
1049   }
1050   static void test_srlv(long[] a0, long[] a1, int b) {
1051     for (int i = 0; i < a0.length; i+=1) {
1052       a0[i] = (long)(a1[i]>>>b);
1053     }
1054   }
1055   static void test_srlc_add(long[] a0, long[] a1) {
1056     for (int i = 0; i < a0.length; i+=1) {
1057       a0[i] = (long)((a1[i] + ADD_INIT)>>>VALUE);
1058     }
1059   }
1060   static void test_srlv_add(long[] a0, long[] a1, long b) {
1061     for (int i = 0; i < a0.length; i+=1) {
1062       a0[i] = (long)((a1[i] + b)>>>VALUE);
1063     }
1064   }
1065   static void test_srlc_and(long[] a0, long[] a1) {
1066     for (int i = 0; i < a0.length; i+=1) {
1067       a0[i] = (long)((a1[i] & BIT_MASK)>>>VALUE);
1068     }
1069   }
1070   static void test_srlv_and(long[] a0, long[] a1, long b) {
1071     for (int i = 0; i < a0.length; i+=1) {
1072       a0[i] = (long)((a1[i] & b)>>>VALUE);
1073     }
1074   }
1075 
1076   static void test_srac(long[] a0, long[] a1) {
1077     for (int i = 0; i < a0.length; i+=1) {
1078       a0[i] = (long)(a1[i]>>VALUE);
1079     }
1080   }
1081   static void test_srac_n(long[] a0, long[] a1) {
1082     for (int i = 0; i < a0.length; i+=1) {
1083       a0[i] = (long)(a1[i]>>(-VALUE));
1084     }
1085   }
1086   static void test_srac_o(long[] a0, long[] a1) {
1087     for (int i = 0; i < a0.length; i+=1) {
1088       a0[i] = (long)(a1[i]>>SHIFT);
1089     }
1090   }
1091   static void test_srac_on(long[] a0, long[] a1) {
1092     for (int i = 0; i < a0.length; i+=1) {
1093       a0[i] = (long)(a1[i]>>(-SHIFT));
1094     }
1095   }
1096   static void test_srav(long[] a0, long[] a1, int b) {
1097     for (int i = 0; i < a0.length; i+=1) {
1098       a0[i] = (long)(a1[i]>>b);
1099     }
1100   }
1101   static void test_srac_add(long[] a0, long[] a1) {
1102     for (int i = 0; i < a0.length; i+=1) {
1103       a0[i] = (long)((a1[i] + ADD_INIT)>>VALUE);
1104     }
1105   }
1106   static void test_srav_add(long[] a0, long[] a1, long b) {
1107     for (int i = 0; i < a0.length; i+=1) {
1108       a0[i] = (long)((a1[i] + b)>>VALUE);
1109     }
1110   }
1111   static void test_srac_and(long[] a0, long[] a1) {
1112     for (int i = 0; i < a0.length; i+=1) {
1113       a0[i] = (long)((a1[i] & BIT_MASK)>>VALUE);
1114     }
1115   }
1116   static void test_srav_and(long[] a0, long[] a1, long b) {
1117     for (int i = 0; i < a0.length; i+=1) {
1118       a0[i] = (long)((a1[i] & b)>>VALUE);
1119     }
1120   }
1121 
1122   static int verify(String text, int i, long elem, long val) {
1123     if (elem != val) {
1124       System.err.println(text + "[" + i + "] = " + elem + " != " + val);
1125       return 1;
1126     }
1127     return 0;
1128   }
1129 }