1 /*
   2  * Copyright (c) 2020, 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 package org.openjdk.bench.valhalla.arraytotal.copy;
  24 
  25 import org.openjdk.bench.valhalla.arraytotal.util.StatesR64long;
  26 import org.openjdk.bench.valhalla.types.A64long;
  27 import org.openjdk.bench.valhalla.types.Int64;
  28 import org.openjdk.bench.valhalla.types.R64long;
  29 import org.openjdk.jmh.annotations.Benchmark;
  30 import org.openjdk.jmh.annotations.CompilerControl;
  31 
  32 public class IdentityCopy0 extends StatesR64long {
  33 
  34     @Benchmark
  35     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
  36     public void Obj_to_Obj_as_Obj_to_Obj_copy(Obj_as_Obj s, Obj_as_Obj d) {
  37         Object[] src = s.arr;
  38         Object[] dst = d.arr;
  39         for (int i = 0; i < src.length; i++) {
  40             dst[i] = src[i];
  41         }
  42     }
  43 
  44     @Benchmark
  45     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
  46     public void Obj_to_Int_as_Obj_to_Obj_copy(Obj_as_Obj s, Int_as_Obj d) {
  47         Object[] src = s.arr;
  48         Object[] dst = d.arr;
  49         for (int i = 0; i < src.length; i++) {
  50             dst[i] = src[i];
  51         }
  52     }
  53 
  54     @Benchmark
  55     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
  56     public void Obj_to_Abs_as_Obj_to_Obj_copy(Obj_as_Obj s, Abs_as_Obj d) {
  57         Object[] src = s.arr;
  58         Object[] dst = d.arr;
  59         for (int i = 0; i < src.length; i++) {
  60             dst[i] = src[i];
  61         }
  62     }
  63 
  64     @Benchmark
  65     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
  66     public void Obj_to_Ref_as_Obj_to_Obj_copy(Obj_as_Obj s, Ref_as_Obj d) {
  67         Object[] src = s.arr;
  68         Object[] dst = d.arr;
  69         for (int i = 0; i < src.length; i++) {
  70             dst[i] = src[i];
  71         }
  72     }
  73 
  74     @Benchmark
  75     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
  76     public void Obj_to_Int_as_Obj_to_Int_copy(Obj_as_Obj s, Int_as_Int d) {
  77         Object[] src = s.arr;
  78         Int64[] dst = d.arr;
  79         for (int i = 0; i < src.length; i++) {
  80             dst[i] = (Int64)src[i];
  81         }
  82     }
  83 
  84     @Benchmark
  85     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
  86     public void Obj_to_Abs_as_Obj_to_Int_copy(Obj_as_Obj s, Abs_as_Int d) {
  87         Object[] src = s.arr;
  88         Int64[] dst = d.arr;
  89         for (int i = 0; i < src.length; i++) {
  90             dst[i] = (Int64)src[i];
  91         }
  92     }
  93 
  94     @Benchmark
  95     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
  96     public void Obj_to_Ref_as_Obj_to_Int_copy(Obj_as_Obj s, Ref_as_Int d) {
  97         Object[] src = s.arr;
  98         Int64[] dst = d.arr;
  99         for (int i = 0; i < src.length; i++) {
 100             dst[i] = (Int64)src[i];
 101         }
 102     }
 103 
 104     @Benchmark
 105     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 106     public void Obj_to_Abs_as_Obj_to_Abs_copy(Obj_as_Obj s, Abs_as_Abs d) {
 107         Object[] src = s.arr;
 108         A64long[] dst = d.arr;
 109         for (int i = 0; i < src.length; i++) {
 110             dst[i] = (A64long)src[i];
 111         }
 112     }
 113 
 114     @Benchmark
 115     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 116     public void Obj_to_Ref_as_Obj_to_Abs_copy(Obj_as_Obj s, Ref_as_Abs d) {
 117         Object[] src = s.arr;
 118         A64long[] dst = d.arr;
 119         for (int i = 0; i < src.length; i++) {
 120             dst[i] = (A64long)src[i];
 121         }
 122     }
 123 
 124     @Benchmark
 125     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 126     public void Obj_to_Ref_as_Obj_to_Ref_copy(Obj_as_Obj s, Ref_as_Ref d) {
 127         Object[] src = s.arr;
 128         R64long[] dst = d.arr;
 129         for (int i = 0; i < src.length; i++) {
 130             dst[i] = (R64long)src[i];
 131         }
 132     }
 133 
 134     @Benchmark
 135     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 136     public void Int_to_Obj_as_Obj_to_Obj_copy(Int_as_Obj s, Obj_as_Obj d) {
 137         Object[] src = s.arr;
 138         Object[] dst = d.arr;
 139         for (int i = 0; i < src.length; i++) {
 140             dst[i] = src[i];
 141         }
 142     }
 143 
 144     @Benchmark
 145     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 146     public void Int_to_Int_as_Obj_to_Obj_copy(Int_as_Obj s, Int_as_Obj d) {
 147         Object[] src = s.arr;
 148         Object[] dst = d.arr;
 149         for (int i = 0; i < src.length; i++) {
 150             dst[i] = src[i];
 151         }
 152     }
 153 
 154     @Benchmark
 155     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 156     public void Int_to_Abs_as_Obj_to_Obj_copy(Int_as_Obj s, Abs_as_Obj d) {
 157         Object[] src = s.arr;
 158         Object[] dst = d.arr;
 159         for (int i = 0; i < src.length; i++) {
 160             dst[i] = src[i];
 161         }
 162     }
 163 
 164     @Benchmark
 165     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 166     public void Int_to_Ref_as_Obj_to_Obj_copy(Int_as_Obj s, Ref_as_Obj d) {
 167         Object[] src = s.arr;
 168         Object[] dst = d.arr;
 169         for (int i = 0; i < src.length; i++) {
 170             dst[i] = src[i];
 171         }
 172     }
 173 
 174     @Benchmark
 175     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 176     public void Int_to_Int_as_Obj_to_Int_copy(Int_as_Obj s, Int_as_Int d) {
 177         Object[] src = s.arr;
 178         Int64[] dst = d.arr;
 179         for (int i = 0; i < src.length; i++) {
 180             dst[i] = (Int64)src[i];
 181         }
 182     }
 183 
 184     @Benchmark
 185     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 186     public void Int_to_Abs_as_Obj_to_Int_copy(Int_as_Obj s, Abs_as_Int d) {
 187         Object[] src = s.arr;
 188         Int64[] dst = d.arr;
 189         for (int i = 0; i < src.length; i++) {
 190             dst[i] = (Int64)src[i];
 191         }
 192     }
 193 
 194     @Benchmark
 195     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 196     public void Int_to_Ref_as_Obj_to_Int_copy(Int_as_Obj s, Ref_as_Int d) {
 197         Object[] src = s.arr;
 198         Int64[] dst = d.arr;
 199         for (int i = 0; i < src.length; i++) {
 200             dst[i] = (Int64)src[i];
 201         }
 202     }
 203 
 204     @Benchmark
 205     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 206     public void Int_to_Abs_as_Obj_to_Abs_copy(Int_as_Obj s, Abs_as_Abs d) {
 207         Object[] src = s.arr;
 208         A64long[] dst = d.arr;
 209         for (int i = 0; i < src.length; i++) {
 210             dst[i] = (A64long)src[i];
 211         }
 212     }
 213 
 214     @Benchmark
 215     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 216     public void Int_to_Ref_as_Obj_to_Abs_copy(Int_as_Obj s, Ref_as_Abs d) {
 217         Object[] src = s.arr;
 218         A64long[] dst = d.arr;
 219         for (int i = 0; i < src.length; i++) {
 220             dst[i] = (A64long)src[i];
 221         }
 222     }
 223 
 224     @Benchmark
 225     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 226     public void Int_to_Ref_as_Obj_to_Ref_copy(Int_as_Obj s, Ref_as_Ref d) {
 227         Object[] src = s.arr;
 228         R64long[] dst = d.arr;
 229         for (int i = 0; i < src.length; i++) {
 230             dst[i] = (R64long)src[i];
 231         }
 232     }
 233 
 234     @Benchmark
 235     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 236     public void Abs_to_Obj_as_Obj_to_Obj_copy(Abs_as_Obj s, Obj_as_Obj d) {
 237         Object[] src = s.arr;
 238         Object[] dst = d.arr;
 239         for (int i = 0; i < src.length; i++) {
 240             dst[i] = src[i];
 241         }
 242     }
 243 
 244     @Benchmark
 245     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 246     public void Abs_to_Int_as_Obj_to_Obj_copy(Abs_as_Obj s, Int_as_Obj d) {
 247         Object[] src = s.arr;
 248         Object[] dst = d.arr;
 249         for (int i = 0; i < src.length; i++) {
 250             dst[i] = src[i];
 251         }
 252     }
 253 
 254     @Benchmark
 255     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 256     public void Abs_to_Abs_as_Obj_to_Obj_copy(Abs_as_Obj s, Abs_as_Obj d) {
 257         Object[] src = s.arr;
 258         Object[] dst = d.arr;
 259         for (int i = 0; i < src.length; i++) {
 260             dst[i] = src[i];
 261         }
 262     }
 263 
 264     @Benchmark
 265     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 266     public void Abs_to_Ref_as_Obj_to_Obj_copy(Abs_as_Obj s, Ref_as_Obj d) {
 267         Object[] src = s.arr;
 268         Object[] dst = d.arr;
 269         for (int i = 0; i < src.length; i++) {
 270             dst[i] = src[i];
 271         }
 272     }
 273 
 274     @Benchmark
 275     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 276     public void Abs_to_Int_as_Obj_to_Int_copy(Abs_as_Obj s, Int_as_Int d) {
 277         Object[] src = s.arr;
 278         Int64[] dst = d.arr;
 279         for (int i = 0; i < src.length; i++) {
 280             dst[i] = (Int64)src[i];
 281         }
 282     }
 283 
 284     @Benchmark
 285     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 286     public void Abs_to_Abs_as_Obj_to_Int_copy(Abs_as_Obj s, Abs_as_Int d) {
 287         Object[] src = s.arr;
 288         Int64[] dst = d.arr;
 289         for (int i = 0; i < src.length; i++) {
 290             dst[i] = (Int64)src[i];
 291         }
 292     }
 293 
 294     @Benchmark
 295     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 296     public void Abs_to_Ref_as_Obj_to_Int_copy(Abs_as_Obj s, Ref_as_Int d) {
 297         Object[] src = s.arr;
 298         Int64[] dst = d.arr;
 299         for (int i = 0; i < src.length; i++) {
 300             dst[i] = (Int64)src[i];
 301         }
 302     }
 303 
 304     @Benchmark
 305     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 306     public void Abs_to_Abs_as_Obj_to_Abs_copy(Abs_as_Obj s, Abs_as_Abs d) {
 307         Object[] src = s.arr;
 308         A64long[] dst = d.arr;
 309         for (int i = 0; i < src.length; i++) {
 310             dst[i] = (A64long)src[i];
 311         }
 312     }
 313 
 314     @Benchmark
 315     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 316     public void Abs_to_Ref_as_Obj_to_Abs_copy(Abs_as_Obj s, Ref_as_Abs d) {
 317         Object[] src = s.arr;
 318         A64long[] dst = d.arr;
 319         for (int i = 0; i < src.length; i++) {
 320             dst[i] = (A64long)src[i];
 321         }
 322     }
 323 
 324     @Benchmark
 325     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 326     public void Abs_to_Ref_as_Obj_to_Ref_copy(Abs_as_Obj s, Ref_as_Ref d) {
 327         Object[] src = s.arr;
 328         R64long[] dst = d.arr;
 329         for (int i = 0; i < src.length; i++) {
 330             dst[i] = (R64long)src[i];
 331         }
 332     }
 333 
 334     @Benchmark
 335     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 336     public void Ref_to_Obj_as_Obj_to_Obj_copy(Ref_as_Obj s, Obj_as_Obj d) {
 337         Object[] src = s.arr;
 338         Object[] dst = d.arr;
 339         for (int i = 0; i < src.length; i++) {
 340             dst[i] = src[i];
 341         }
 342     }
 343 
 344     @Benchmark
 345     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 346     public void Ref_to_Int_as_Obj_to_Obj_copy(Ref_as_Obj s, Int_as_Obj d) {
 347         Object[] src = s.arr;
 348         Object[] dst = d.arr;
 349         for (int i = 0; i < src.length; i++) {
 350             dst[i] = src[i];
 351         }
 352     }
 353 
 354     @Benchmark
 355     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 356     public void Ref_to_Abs_as_Obj_to_Obj_copy(Ref_as_Obj s, Abs_as_Obj d) {
 357         Object[] src = s.arr;
 358         Object[] dst = d.arr;
 359         for (int i = 0; i < src.length; i++) {
 360             dst[i] = src[i];
 361         }
 362     }
 363 
 364     @Benchmark
 365     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 366     public void Ref_to_Ref_as_Obj_to_Obj_copy(Ref_as_Obj s, Ref_as_Obj d) {
 367         Object[] src = s.arr;
 368         Object[] dst = d.arr;
 369         for (int i = 0; i < src.length; i++) {
 370             dst[i] = src[i];
 371         }
 372     }
 373 
 374     @Benchmark
 375     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 376     public void Ref_to_Int_as_Obj_to_Int_copy(Ref_as_Obj s, Int_as_Int d) {
 377         Object[] src = s.arr;
 378         Int64[] dst = d.arr;
 379         for (int i = 0; i < src.length; i++) {
 380             dst[i] = (Int64)src[i];
 381         }
 382     }
 383 
 384     @Benchmark
 385     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 386     public void Ref_to_Abs_as_Obj_to_Int_copy(Ref_as_Obj s, Abs_as_Int d) {
 387         Object[] src = s.arr;
 388         Int64[] dst = d.arr;
 389         for (int i = 0; i < src.length; i++) {
 390             dst[i] = (Int64)src[i];
 391         }
 392     }
 393 
 394     @Benchmark
 395     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 396     public void Ref_to_Ref_as_Obj_to_Int_copy(Ref_as_Obj s, Ref_as_Int d) {
 397         Object[] src = s.arr;
 398         Int64[] dst = d.arr;
 399         for (int i = 0; i < src.length; i++) {
 400             dst[i] = (Int64)src[i];
 401         }
 402     }
 403 
 404     @Benchmark
 405     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 406     public void Ref_to_Abs_as_Obj_to_Abs_copy(Ref_as_Obj s, Abs_as_Abs d) {
 407         Object[] src = s.arr;
 408         A64long[] dst = d.arr;
 409         for (int i = 0; i < src.length; i++) {
 410             dst[i] = (A64long)src[i];
 411         }
 412     }
 413 
 414     @Benchmark
 415     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 416     public void Ref_to_Ref_as_Obj_to_Abs_copy(Ref_as_Obj s, Ref_as_Abs d) {
 417         Object[] src = s.arr;
 418         A64long[] dst = d.arr;
 419         for (int i = 0; i < src.length; i++) {
 420             dst[i] = (A64long)src[i];
 421         }
 422     }
 423 
 424     @Benchmark
 425     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 426     public void Ref_to_Ref_as_Obj_to_Ref_copy(Ref_as_Obj s, Ref_as_Ref d) {
 427         Object[] src = s.arr;
 428         R64long[] dst = d.arr;
 429         for (int i = 0; i < src.length; i++) {
 430             dst[i] = (R64long)src[i];
 431         }
 432     }
 433 
 434     @Benchmark
 435     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 436     public void Int_to_Obj_as_Int_to_Obj_copy(Int_as_Int s, Obj_as_Obj d) {
 437         Int64[] src = s.arr;
 438         Object[] dst = d.arr;
 439         for (int i = 0; i < src.length; i++) {
 440             dst[i] = src[i];
 441         }
 442     }
 443 
 444     @Benchmark
 445     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 446     public void Int_to_Int_as_Int_to_Obj_copy(Int_as_Int s, Int_as_Obj d) {
 447         Int64[] src = s.arr;
 448         Object[] dst = d.arr;
 449         for (int i = 0; i < src.length; i++) {
 450             dst[i] = src[i];
 451         }
 452     }
 453 
 454     @Benchmark
 455     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 456     public void Int_to_Abs_as_Int_to_Obj_copy(Int_as_Int s, Abs_as_Obj d) {
 457         Int64[] src = s.arr;
 458         Object[] dst = d.arr;
 459         for (int i = 0; i < src.length; i++) {
 460             dst[i] = src[i];
 461         }
 462     }
 463 
 464     @Benchmark
 465     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 466     public void Int_to_Ref_as_Int_to_Obj_copy(Int_as_Int s, Ref_as_Obj d) {
 467         Int64[] src = s.arr;
 468         Object[] dst = d.arr;
 469         for (int i = 0; i < src.length; i++) {
 470             dst[i] = src[i];
 471         }
 472     }
 473 
 474     @Benchmark
 475     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 476     public void Int_to_Int_as_Int_to_Int_copy(Int_as_Int s, Int_as_Int d) {
 477         Int64[] src = s.arr;
 478         Int64[] dst = d.arr;
 479         for (int i = 0; i < src.length; i++) {
 480             dst[i] = src[i];
 481         }
 482     }
 483 
 484     @Benchmark
 485     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 486     public void Int_to_Abs_as_Int_to_Int_copy(Int_as_Int s, Abs_as_Int d) {
 487         Int64[] src = s.arr;
 488         Int64[] dst = d.arr;
 489         for (int i = 0; i < src.length; i++) {
 490             dst[i] = src[i];
 491         }
 492     }
 493 
 494     @Benchmark
 495     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 496     public void Int_to_Ref_as_Int_to_Int_copy(Int_as_Int s, Ref_as_Int d) {
 497         Int64[] src = s.arr;
 498         Int64[] dst = d.arr;
 499         for (int i = 0; i < src.length; i++) {
 500             dst[i] = src[i];
 501         }
 502     }
 503 
 504     @Benchmark
 505     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 506     public void Int_to_Abs_as_Int_to_Abs_copy(Int_as_Int s, Abs_as_Abs d) {
 507         Int64[] src = s.arr;
 508         A64long[] dst = d.arr;
 509         for (int i = 0; i < src.length; i++) {
 510             dst[i] = (A64long)src[i];
 511         }
 512     }
 513 
 514     @Benchmark
 515     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 516     public void Int_to_Ref_as_Int_to_Abs_copy(Int_as_Int s, Ref_as_Abs d) {
 517         Int64[] src = s.arr;
 518         A64long[] dst = d.arr;
 519         for (int i = 0; i < src.length; i++) {
 520             dst[i] = (A64long)src[i];
 521         }
 522     }
 523 
 524     @Benchmark
 525     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 526     public void Int_to_Ref_as_Int_to_Ref_copy(Int_as_Int s, Ref_as_Ref d) {
 527         Int64[] src = s.arr;
 528         R64long[] dst = d.arr;
 529         for (int i = 0; i < src.length; i++) {
 530             dst[i] = (R64long)src[i];
 531         }
 532     }
 533 
 534     @Benchmark
 535     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 536     public void Abs_to_Obj_as_Int_to_Obj_copy(Abs_as_Int s, Obj_as_Obj d) {
 537         Int64[] src = s.arr;
 538         Object[] dst = d.arr;
 539         for (int i = 0; i < src.length; i++) {
 540             dst[i] = src[i];
 541         }
 542     }
 543 
 544     @Benchmark
 545     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 546     public void Abs_to_Int_as_Int_to_Obj_copy(Abs_as_Int s, Int_as_Obj d) {
 547         Int64[] src = s.arr;
 548         Object[] dst = d.arr;
 549         for (int i = 0; i < src.length; i++) {
 550             dst[i] = src[i];
 551         }
 552     }
 553 
 554     @Benchmark
 555     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 556     public void Abs_to_Abs_as_Int_to_Obj_copy(Abs_as_Int s, Abs_as_Obj d) {
 557         Int64[] src = s.arr;
 558         Object[] dst = d.arr;
 559         for (int i = 0; i < src.length; i++) {
 560             dst[i] = src[i];
 561         }
 562     }
 563 
 564     @Benchmark
 565     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 566     public void Abs_to_Ref_as_Int_to_Obj_copy(Abs_as_Int s, Ref_as_Obj d) {
 567         Int64[] src = s.arr;
 568         Object[] dst = d.arr;
 569         for (int i = 0; i < src.length; i++) {
 570             dst[i] = src[i];
 571         }
 572     }
 573 
 574     @Benchmark
 575     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 576     public void Abs_to_Int_as_Int_to_Int_copy(Abs_as_Int s, Int_as_Int d) {
 577         Int64[] src = s.arr;
 578         Int64[] dst = d.arr;
 579         for (int i = 0; i < src.length; i++) {
 580             dst[i] = src[i];
 581         }
 582     }
 583 
 584     @Benchmark
 585     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 586     public void Abs_to_Abs_as_Int_to_Int_copy(Abs_as_Int s, Abs_as_Int d) {
 587         Int64[] src = s.arr;
 588         Int64[] dst = d.arr;
 589         for (int i = 0; i < src.length; i++) {
 590             dst[i] = src[i];
 591         }
 592     }
 593 
 594     @Benchmark
 595     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 596     public void Abs_to_Ref_as_Int_to_Int_copy(Abs_as_Int s, Ref_as_Int d) {
 597         Int64[] src = s.arr;
 598         Int64[] dst = d.arr;
 599         for (int i = 0; i < src.length; i++) {
 600             dst[i] = src[i];
 601         }
 602     }
 603 
 604     @Benchmark
 605     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 606     public void Abs_to_Abs_as_Int_to_Abs_copy(Abs_as_Int s, Abs_as_Abs d) {
 607         Int64[] src = s.arr;
 608         A64long[] dst = d.arr;
 609         for (int i = 0; i < src.length; i++) {
 610             dst[i] = (A64long)src[i];
 611         }
 612     }
 613 
 614     @Benchmark
 615     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 616     public void Abs_to_Ref_as_Int_to_Abs_copy(Abs_as_Int s, Ref_as_Abs d) {
 617         Int64[] src = s.arr;
 618         A64long[] dst = d.arr;
 619         for (int i = 0; i < src.length; i++) {
 620             dst[i] = (A64long)src[i];
 621         }
 622     }
 623 
 624     @Benchmark
 625     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 626     public void Abs_to_Ref_as_Int_to_Ref_copy(Abs_as_Int s, Ref_as_Ref d) {
 627         Int64[] src = s.arr;
 628         R64long[] dst = d.arr;
 629         for (int i = 0; i < src.length; i++) {
 630             dst[i] = (R64long)src[i];
 631         }
 632     }
 633 
 634     @Benchmark
 635     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 636     public void Ref_to_Obj_as_Int_to_Obj_copy(Ref_as_Int s, Obj_as_Obj d) {
 637         Int64[] src = s.arr;
 638         Object[] dst = d.arr;
 639         for (int i = 0; i < src.length; i++) {
 640             dst[i] = src[i];
 641         }
 642     }
 643 
 644     @Benchmark
 645     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 646     public void Ref_to_Int_as_Int_to_Obj_copy(Ref_as_Int s, Int_as_Obj d) {
 647         Int64[] src = s.arr;
 648         Object[] dst = d.arr;
 649         for (int i = 0; i < src.length; i++) {
 650             dst[i] = src[i];
 651         }
 652     }
 653 
 654     @Benchmark
 655     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 656     public void Ref_to_Abs_as_Int_to_Obj_copy(Ref_as_Int s, Abs_as_Obj d) {
 657         Int64[] src = s.arr;
 658         Object[] dst = d.arr;
 659         for (int i = 0; i < src.length; i++) {
 660             dst[i] = src[i];
 661         }
 662     }
 663 
 664     @Benchmark
 665     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 666     public void Ref_to_Ref_as_Int_to_Obj_copy(Ref_as_Int s, Ref_as_Obj d) {
 667         Int64[] src = s.arr;
 668         Object[] dst = d.arr;
 669         for (int i = 0; i < src.length; i++) {
 670             dst[i] = src[i];
 671         }
 672     }
 673 
 674     @Benchmark
 675     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 676     public void Ref_to_Int_as_Int_to_Int_copy(Ref_as_Int s, Int_as_Int d) {
 677         Int64[] src = s.arr;
 678         Int64[] dst = d.arr;
 679         for (int i = 0; i < src.length; i++) {
 680             dst[i] = src[i];
 681         }
 682     }
 683 
 684     @Benchmark
 685     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 686     public void Ref_to_Abs_as_Int_to_Int_copy(Ref_as_Int s, Abs_as_Int d) {
 687         Int64[] src = s.arr;
 688         Int64[] dst = d.arr;
 689         for (int i = 0; i < src.length; i++) {
 690             dst[i] = src[i];
 691         }
 692     }
 693 
 694     @Benchmark
 695     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 696     public void Ref_to_Ref_as_Int_to_Int_copy(Ref_as_Int s, Ref_as_Int d) {
 697         Int64[] src = s.arr;
 698         Int64[] dst = d.arr;
 699         for (int i = 0; i < src.length; i++) {
 700             dst[i] = src[i];
 701         }
 702     }
 703 
 704     @Benchmark
 705     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 706     public void Ref_to_Abs_as_Int_to_Abs_copy(Ref_as_Int s, Abs_as_Abs d) {
 707         Int64[] src = s.arr;
 708         A64long[] dst = d.arr;
 709         for (int i = 0; i < src.length; i++) {
 710             dst[i] = (A64long)src[i];
 711         }
 712     }
 713 
 714     @Benchmark
 715     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 716     public void Ref_to_Ref_as_Int_to_Abs_copy(Ref_as_Int s, Ref_as_Abs d) {
 717         Int64[] src = s.arr;
 718         A64long[] dst = d.arr;
 719         for (int i = 0; i < src.length; i++) {
 720             dst[i] = (A64long)src[i];
 721         }
 722     }
 723 
 724     @Benchmark
 725     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 726     public void Ref_to_Ref_as_Int_to_Ref_copy(Ref_as_Int s, Ref_as_Ref d) {
 727         Int64[] src = s.arr;
 728         R64long[] dst = d.arr;
 729         for (int i = 0; i < src.length; i++) {
 730             dst[i] = (R64long)src[i];
 731         }
 732     }
 733 
 734     @Benchmark
 735     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 736     public void Abs_to_Obj_as_Abs_to_Obj_copy(Abs_as_Abs s, Obj_as_Obj d) {
 737         A64long[] src = s.arr;
 738         Object[] dst = d.arr;
 739         for (int i = 0; i < src.length; i++) {
 740             dst[i] = src[i];
 741         }
 742     }
 743 
 744     @Benchmark
 745     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 746     public void Abs_to_Int_as_Abs_to_Obj_copy(Abs_as_Abs s, Int_as_Obj d) {
 747         A64long[] src = s.arr;
 748         Object[] dst = d.arr;
 749         for (int i = 0; i < src.length; i++) {
 750             dst[i] = src[i];
 751         }
 752     }
 753 
 754     @Benchmark
 755     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 756     public void Abs_to_Abs_as_Abs_to_Obj_copy(Abs_as_Abs s, Abs_as_Obj d) {
 757         A64long[] src = s.arr;
 758         Object[] dst = d.arr;
 759         for (int i = 0; i < src.length; i++) {
 760             dst[i] = src[i];
 761         }
 762     }
 763 
 764     @Benchmark
 765     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 766     public void Abs_to_Ref_as_Abs_to_Obj_copy(Abs_as_Abs s, Ref_as_Obj d) {
 767         A64long[] src = s.arr;
 768         Object[] dst = d.arr;
 769         for (int i = 0; i < src.length; i++) {
 770             dst[i] = src[i];
 771         }
 772     }
 773 
 774     @Benchmark
 775     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 776     public void Abs_to_Int_as_Abs_to_Int_copy(Abs_as_Abs s, Int_as_Int d) {
 777         A64long[] src = s.arr;
 778         Int64[] dst = d.arr;
 779         for (int i = 0; i < src.length; i++) {
 780             dst[i] = src[i];
 781         }
 782     }
 783 
 784     @Benchmark
 785     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 786     public void Abs_to_Abs_as_Abs_to_Int_copy(Abs_as_Abs s, Abs_as_Int d) {
 787         A64long[] src = s.arr;
 788         Int64[] dst = d.arr;
 789         for (int i = 0; i < src.length; i++) {
 790             dst[i] = src[i];
 791         }
 792     }
 793 
 794     @Benchmark
 795     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 796     public void Abs_to_Ref_as_Abs_to_Int_copy(Abs_as_Abs s, Ref_as_Int d) {
 797         A64long[] src = s.arr;
 798         Int64[] dst = d.arr;
 799         for (int i = 0; i < src.length; i++) {
 800             dst[i] = src[i];
 801         }
 802     }
 803 
 804     @Benchmark
 805     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 806     public void Abs_to_Abs_as_Abs_to_Abs_copy(Abs_as_Abs s, Abs_as_Abs d) {
 807         A64long[] src = s.arr;
 808         A64long[] dst = d.arr;
 809         for (int i = 0; i < src.length; i++) {
 810             dst[i] = src[i];
 811         }
 812     }
 813 
 814     @Benchmark
 815     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 816     public void Abs_to_Ref_as_Abs_to_Abs_copy(Abs_as_Abs s, Ref_as_Abs d) {
 817         A64long[] src = s.arr;
 818         A64long[] dst = d.arr;
 819         for (int i = 0; i < src.length; i++) {
 820             dst[i] = src[i];
 821         }
 822     }
 823 
 824     @Benchmark
 825     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 826     public void Abs_to_Ref_as_Abs_to_Ref_copy(Abs_as_Abs s, Ref_as_Ref d) {
 827         A64long[] src = s.arr;
 828         R64long[] dst = d.arr;
 829         for (int i = 0; i < src.length; i++) {
 830             dst[i] = (R64long)src[i];
 831         }
 832     }
 833 
 834     @Benchmark
 835     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 836     public void Ref_to_Obj_as_Abs_to_Obj_copy(Ref_as_Abs s, Obj_as_Obj d) {
 837         A64long[] src = s.arr;
 838         Object[] dst = d.arr;
 839         for (int i = 0; i < src.length; i++) {
 840             dst[i] = src[i];
 841         }
 842     }
 843 
 844     @Benchmark
 845     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 846     public void Ref_to_Int_as_Abs_to_Obj_copy(Ref_as_Abs s, Int_as_Obj d) {
 847         A64long[] src = s.arr;
 848         Object[] dst = d.arr;
 849         for (int i = 0; i < src.length; i++) {
 850             dst[i] = src[i];
 851         }
 852     }
 853 
 854     @Benchmark
 855     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 856     public void Ref_to_Abs_as_Abs_to_Obj_copy(Ref_as_Abs s, Abs_as_Obj d) {
 857         A64long[] src = s.arr;
 858         Object[] dst = d.arr;
 859         for (int i = 0; i < src.length; i++) {
 860             dst[i] = src[i];
 861         }
 862     }
 863 
 864     @Benchmark
 865     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 866     public void Ref_to_Ref_as_Abs_to_Obj_copy(Ref_as_Abs s, Ref_as_Obj d) {
 867         A64long[] src = s.arr;
 868         Object[] dst = d.arr;
 869         for (int i = 0; i < src.length; i++) {
 870             dst[i] = src[i];
 871         }
 872     }
 873 
 874     @Benchmark
 875     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 876     public void Ref_to_Int_as_Abs_to_Int_copy(Ref_as_Abs s, Int_as_Int d) {
 877         A64long[] src = s.arr;
 878         Int64[] dst = d.arr;
 879         for (int i = 0; i < src.length; i++) {
 880             dst[i] = src[i];
 881         }
 882     }
 883 
 884     @Benchmark
 885     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 886     public void Ref_to_Abs_as_Abs_to_Int_copy(Ref_as_Abs s, Abs_as_Int d) {
 887         A64long[] src = s.arr;
 888         Int64[] dst = d.arr;
 889         for (int i = 0; i < src.length; i++) {
 890             dst[i] = src[i];
 891         }
 892     }
 893 
 894     @Benchmark
 895     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 896     public void Ref_to_Ref_as_Abs_to_Int_copy(Ref_as_Abs s, Ref_as_Int d) {
 897         A64long[] src = s.arr;
 898         Int64[] dst = d.arr;
 899         for (int i = 0; i < src.length; i++) {
 900             dst[i] = src[i];
 901         }
 902     }
 903 
 904     @Benchmark
 905     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 906     public void Ref_to_Abs_as_Abs_to_Abs_copy(Ref_as_Abs s, Abs_as_Abs d) {
 907         A64long[] src = s.arr;
 908         A64long[] dst = d.arr;
 909         for (int i = 0; i < src.length; i++) {
 910             dst[i] = src[i];
 911         }
 912     }
 913 
 914     @Benchmark
 915     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 916     public void Ref_to_Ref_as_Abs_to_Abs_copy(Ref_as_Abs s, Ref_as_Abs d) {
 917         A64long[] src = s.arr;
 918         A64long[] dst = d.arr;
 919         for (int i = 0; i < src.length; i++) {
 920             dst[i] = src[i];
 921         }
 922     }
 923 
 924     @Benchmark
 925     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 926     public void Ref_to_Ref_as_Abs_to_Ref_copy(Ref_as_Abs s, Ref_as_Ref d) {
 927         A64long[] src = s.arr;
 928         R64long[] dst = d.arr;
 929         for (int i = 0; i < src.length; i++) {
 930             dst[i] = (R64long)src[i];
 931         }
 932     }
 933 
 934     @Benchmark
 935     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 936     public void Ref_to_Obj_as_Ref_to_Obj_copy(Ref_as_Ref s, Obj_as_Obj d) {
 937         R64long[] src = s.arr;
 938         Object[] dst = d.arr;
 939         for (int i = 0; i < src.length; i++) {
 940             dst[i] = src[i];
 941         }
 942     }
 943 
 944     @Benchmark
 945     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 946     public void Ref_to_Int_as_Ref_to_Obj_copy(Ref_as_Ref s, Int_as_Obj d) {
 947         R64long[] src = s.arr;
 948         Object[] dst = d.arr;
 949         for (int i = 0; i < src.length; i++) {
 950             dst[i] = src[i];
 951         }
 952     }
 953 
 954     @Benchmark
 955     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 956     public void Ref_to_Abs_as_Ref_to_Obj_copy(Ref_as_Ref s, Abs_as_Obj d) {
 957         R64long[] src = s.arr;
 958         Object[] dst = d.arr;
 959         for (int i = 0; i < src.length; i++) {
 960             dst[i] = src[i];
 961         }
 962     }
 963 
 964     @Benchmark
 965     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 966     public void Ref_to_Ref_as_Ref_to_Obj_copy(Ref_as_Ref s, Ref_as_Obj d) {
 967         R64long[] src = s.arr;
 968         Object[] dst = d.arr;
 969         for (int i = 0; i < src.length; i++) {
 970             dst[i] = src[i];
 971         }
 972     }
 973 
 974     @Benchmark
 975     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 976     public void Ref_to_Int_as_Ref_to_Int_copy(Ref_as_Ref s, Int_as_Int d) {
 977         R64long[] src = s.arr;
 978         Int64[] dst = d.arr;
 979         for (int i = 0; i < src.length; i++) {
 980             dst[i] = src[i];
 981         }
 982     }
 983 
 984     @Benchmark
 985     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 986     public void Ref_to_Abs_as_Ref_to_Int_copy(Ref_as_Ref s, Abs_as_Int d) {
 987         R64long[] src = s.arr;
 988         Int64[] dst = d.arr;
 989         for (int i = 0; i < src.length; i++) {
 990             dst[i] = src[i];
 991         }
 992     }
 993 
 994     @Benchmark
 995     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
 996     public void Ref_to_Ref_as_Ref_to_Int_copy(Ref_as_Ref s, Ref_as_Int d) {
 997         R64long[] src = s.arr;
 998         Int64[] dst = d.arr;
 999         for (int i = 0; i < src.length; i++) {
1000             dst[i] = src[i];
1001         }
1002     }
1003 
1004     @Benchmark
1005     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
1006     public void Ref_to_Abs_as_Ref_to_Abs_copy(Ref_as_Ref s, Abs_as_Abs d) {
1007         R64long[] src = s.arr;
1008         A64long[] dst = d.arr;
1009         for (int i = 0; i < src.length; i++) {
1010             dst[i] = src[i];
1011         }
1012     }
1013 
1014     @Benchmark
1015     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
1016     public void Ref_to_Ref_as_Ref_to_Abs_copy(Ref_as_Ref s, Ref_as_Abs d) {
1017         R64long[] src = s.arr;
1018         A64long[] dst = d.arr;
1019         for (int i = 0; i < src.length; i++) {
1020             dst[i] = src[i];
1021         }
1022     }
1023 
1024     @Benchmark
1025     @CompilerControl(CompilerControl.Mode.DONT_INLINE)
1026     public void Ref_to_Ref_as_Ref_to_Ref_copy(Ref_as_Ref s, Ref_as_Ref d) {
1027         R64long[] src = s.arr;
1028         R64long[] dst = d.arr;
1029         for (int i = 0; i < src.length; i++) {
1030             dst[i] = src[i];
1031         }
1032     }
1033 
1034 }