Paul spotted the following small inefficiencies:

        for (; wi < l; wi++) {
            long bi = ((long) Objects.checkIndex(wi, l, null)) << LOG2_ARRAY_LONG_INDEX_SCALE;
            long av = U.getLongUnaligned(a, aOffset + bi);
            long bv = U.getLongUnaligned(b, bOffset + bi);
            if (av != bv) {

is compiled as:

0b0 B9: # B28 B10 <- B8 B13 Loop: B9-B13 inner main of N130 Freq: 977.661
0b0 movl RDX, RDI # spill
0b2 # castII of RDX
0b2 movq RBX, [R9 + #16 + RDX << #3] # long
0b7 movq RAX, [RSI + #16 + RDX << #3] # long
0bc cmpq RBX, RAX
0bf jne B28 P=0.000000 C=7836.000000
0bf
0c5 B10: # B28 B11 <- B9 Freq: 977.66
0c5 movl RDX, RDI # spill
0c7 incl RDX # int
0c9 # castII of RDX
0c9 movq RBX, [R9 + #16 + RDX << #3] # long
0ce movq RAX, [RSI + #16 + RDX << #3] # long
0d3 cmpq RBX, RAX
0d6 jne B28 P=0.000000 C=7836.000000
0d6
0dc B11: # B28 B12 <- B10 Freq: 977.66
0dc movl RDX, RDI # spill
0de addl RDX, #2 # int
0e1 # castII of RDX
0e1 movq RBX, [R9 + #16 + RDX << #3] # long
0e6 movq RAX, [RSI + #16 + RDX << #3] # long
0eb cmpq RBX, RAX
0ee jne B28 P=0.000000 C=7836.000000
0ee
0f4 B12: # B28 B13 <- B11 Freq: 977.659
0f4 movl RDX, RDI # spill
0f6 addl RDX, #3 # int
0f9 # castII of RDX
0f9 movq RBX, [R9 + #16 + RDX << #3] # long
0fe movq RAX, [RSI + #16 + RDX << #3] # long
103 cmpq RBX, RAX
106 jne B28 P=0.000000 C=7836.000000
106
10c B13: # B9 B14 <- B12 Freq: 977.659
10c addl RDI, #4 # int
10f cmpl RDI, RBP
111 jl,s B9 # loop end P=0.998980 C=7836.000000

But the intermediate increment of the induction variable should be folded in the address computation of the memory accesses.
This loop:
        for (; wi < length >> valuesPerWidth; wi++) {
            long bi = ((long) wi) << LOG2_ARRAY_LONG_INDEX_SCALE;
            long av = U.getLongUnaligned(a, aOffset + bi);
            long bv = U.getLongUnaligned(b, bOffset + bi);
            if (av != bv) {

with length and array length is compiled as:

0b0 B7: # B32 B8 <- B6 B15 Loop: B7-B15 inner main of N123 Freq: 975.843
0b0 movslq R8, RSI # i2l
0b3 movq RAX, [RDX + #16 + R8 << #3] # long
0b8 movq RDI, [RBP + #16 + R8 << #3] # long
0bd cmpq RAX, RDI
0c0 jne B32 P=0.000000 C=7836.000000
0c0
0c6 B8: # B33 B9 <- B7 Freq: 975.842
0c6 movl R8, RSI # spill
0c9 incl R8 # int
0cc movslq RDI, R8 # i2l
0cf movq RAX, [RDX + #16 + RDI << #3] # long
0d4 movq RDI, [RBP + #16 + RDI << #3] # long
0d9 cmpq RAX, RDI
0dc jne B33 P=0.000000 C=7836.000000
0dc
0e2 B9: # B33 B10 <- B8 Freq: 975.842
0e2 movl R8, RSI # spill
0e5 addl R8, #2 # int
0e9 movslq RDI, R8 # i2l
0ec movq RAX, [RDX + #16 + RDI << #3] # long
0f1 movq RDI, [RBP + #16 + RDI << #3] # long
0f6 cmpq RAX, RDI
0f9 jne B33 P=0.000000 C=7836.000000
0f9
0ff B10: # B33 B11 <- B9 Freq: 975.842
0ff movl R8, RSI # spill
102 addl R8, #3 # int
106 movslq RDI, R8 # i2l
109 movq RAX, [RDX + #16 + RDI << #3] # long
10e movq RDI, [RBP + #16 + RDI << #3] # long
113 cmpq RAX, RDI
116 jne B33 P=0.000000 C=7836.000000
116
11c B11: # B33 B12 <- B10 Freq: 975.841
11c movl R8, RSI # spill
11f addl R8, #4 # int
123 movslq RDI, R8 # i2l
126 movq RAX, [RDX + #16 + RDI << #3] # long
12b movq RDI, [RBP + #16 + RDI << #3] # long
130 cmpq RAX, RDI
133 jne B33 P=0.000000 C=7836.000000
133
139 B12: # B33 B13 <- B11 Freq: 975.841
139 movl R8, RSI # spill
13c addl R8, #5 # int
140 movslq RDI, R8 # i2l
143 movq RAX, [RDX + #16 + RDI << #3] # long
148 movq RDI, [RBP + #16 + RDI << #3] # long
14d cmpq RAX, RDI
150 jne B33 P=0.000000 C=7836.000000
150
156 B13: # B33 B14 <- B12 Freq: 975.84
156 movl R8, RSI # spill
159 addl R8, #6 # int
15d movslq RDI, R8 # i2l
160 movq RAX, [RDX + #16 + RDI << #3] # long
165 movq RDI, [RBP + #16 + RDI << #3] # long
16a cmpq RAX, RDI
16d jne B33 P=0.000000 C=7836.000000
16d
173 B14: # B33 B15 <- B13 Freq: 975.84
173 movl R8, RSI # spill
176 addl R8, #7 # int
17a movslq RDI, R8 # i2l
17d movq RAX, [RDX + #16 + RDI << #3] # long
182 movq RDI, [RBP + #16 + RDI << #3] # long
187 cmpq RAX, RDI
18a jne B33 P=0.000000 C=7836.000000
18a
190 B15: # B7 B16 <- B14 Freq: 975.839
190 addl RSI, #8 # int
193 cmpl RSI, R11
196 jl B7 # loop end P=0.998980 C=7836.000000

The i2l conversions are not needed because the loop bounds guarantee the induction variable is always positive. As above intermediate increment of the induction variable should be folded in the address computations.