If you have a dumb benchmark like this:

    @Param({"1024"})
    int size;

    byte[] pad;
    long[] source, destination;

    @Setup(Level.Iteration)
    public void setUp() {
        Random r = new Random(42);

        pad = new byte[r.nextInt(1024)];
        source = new long[size];
        destination = new long[size];

        for (int i = 0; i < size; ++i) {
            source[i] = r.nextInt();
        }

        // Promote all the arrays
        System.gc();
    }

    @Benchmark
    public void arraycopy() {
        System.arraycopy(source, 0, destination, 0, size);
    }

And run it with JDK 9b107 on i7-4790K @ 4.0 GHz, Linux x86_64, then you will see that performance fluctuates a lot:

# Warmup Iteration   1: 351.178 ns/op
# Warmup Iteration   2: 385.568 ns/op
# Warmup Iteration   3: 366.771 ns/op
# Warmup Iteration   4: 341.570 ns/op
# Warmup Iteration   5: 420.488 ns/op
Iteration   1: 309.817 ns/op
Iteration   2: 346.652 ns/op
Iteration   3: 408.156 ns/op
Iteration   4: 343.857 ns/op
Iteration   5: 137.810 ns/op
Iteration   6: 283.327 ns/op
Iteration   7: 356.355 ns/op
Iteration   8: 319.256 ns/op
Iteration   9: 136.157 ns/op
Iteration  10: 302.372 ns/op
Iteration  11: 299.792 ns/op
Iteration  12: 389.018 ns/op
Iteration  13: 329.284 ns/op
Iteration  14: 142.508 ns/op
Iteration  15: 297.566 ns/op

Since this run with the same generated code that ends up calling jlong_disjoint_arraycopy, and the hottest piece of code is AVX-assisted copy:

  1.90%    0.69%  │ ↗ │││  0x00007feb44f11a70: vmovdqu -0x38(%rdi,%rdx,8),%ymm0
 36.10%   36.21%  │ │ │││  0x00007feb44f11a76: vmovdqu %ymm0,-0x38(%rcx,%rdx,8)
 10.28%   11.38%  │ │ │││  0x00007feb44f11a7c: vmovdqu -0x18(%rdi,%rdx,8),%ymm1
 29.87%   26.29%  │ │ │││  0x00007feb44f11a82: vmovdqu %ymm1,-0x18(%rcx,%rdx,8)
 15.40%   18.50%  ↘ │ │││  0x00007feb44f11a88: add    $0x8,%rdx
                    ╰ │││  0x00007feb44f11a8c: jle    Stub::jlong_disjoint_arraycopy+48 0x00007feb44f11a70

...the suspicion obviously falls to data alignment.

This work targets to substantially improve the arraycopy performance and variance on x86_64. 

The key things the new code does:
  *) Aligns destination address to perform aligned stores: the cost on misaligned stores, especially on wide AVX stores is horrible;
  *) Uses the widest copy, basically all vector registers that we have to perform the bulk copy: this minimizes some ill effects from dependencies and forwarding;
  *) Does the tail copies with the widest operations possible, this optimizes the copy lengths that are not exactly the power of 2;