java - 具有恒定长度的 System.arraycopy-6ren

java - 具有恒定长度的 System.arraycopy

转载作者：搜寻专家更新时间：2023-10-30 19:45:01

我在玩 JMH (http://openjdk.java.net/projects/code-tools/jmh/)，我偶然发现了一个奇怪的结果。

我正在对制作数组浅拷贝的方法进行基准测试，我可以观察到预期结果(遍历数组是一个坏主意，并且 #clone() 、 System#arraycopy() 和 Arrays#copyOf() 之间没有显着差异，性能方面).

除了 System#arraycopy() 在数组长度被硬编码时慢了四分之一...等等，什么？这怎么可能更慢？

有没有人知道可能是什么原因？

结果(吞吐量):

# JMH 1.11 (released 17 days ago)
# VM version: JDK 1.8.0_05, VM 25.5-b02
# VM invoker: /Library/Java/JavaVirtualMachines/jdk1.8.0_05.jdk/Contents/Home/jre/bin/java
# VM options: -Dfile.encoding=UTF-8 -Duser.country=FR -Duser.language=fr -Duser.variant
# Warmup: 20 iterations, 1 s each
# Measurement: 20 iterations, 1 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Throughput, ops/time

Benchmark                                            Mode  Cnt         Score         Error  Units
ArrayCopyBenchmark.ArraysCopyOf                     thrpt   20  67100500,319 ±  455252,537  ops/s
ArrayCopyBenchmark.ArraysCopyOf_Class               thrpt   20  65246374,290 ±  976481,330  ops/s
ArrayCopyBenchmark.ArraysCopyOf_Class_ConstantSize  thrpt   20  65068143,162 ± 1597390,531  ops/s
ArrayCopyBenchmark.ArraysCopyOf_ConstantSize        thrpt   20  64463603,462 ±  953946,811  ops/s
ArrayCopyBenchmark.Clone                            thrpt   20  64837239,393 ±  834353,404  ops/s
ArrayCopyBenchmark.Loop                             thrpt   20  21070422,097 ±  112595,764  ops/s
ArrayCopyBenchmark.Loop_ConstantSize                thrpt   20  24458867,274 ±  181486,291  ops/s
ArrayCopyBenchmark.SystemArrayCopy                  thrpt   20  66688368,490 ±  582416,954  ops/s
ArrayCopyBenchmark.SystemArrayCopy_ConstantSize     thrpt   20  48992312,357 ±  298807,039  ops/s

和基准类:

import java.util.Arrays;
import java.util.concurrent.TimeUnit;

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;

@State(Scope.Benchmark)
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.SECONDS)
public class ArrayCopyBenchmark {

    private static final int LENGTH = 32;

    private Object[] array;

    @Setup
    public void before() {
        array = new Object[LENGTH];
        for (int i = 0; i < LENGTH; i++) {
            array[i] = new Object();
        }
    }

    @Benchmark
    public Object[] Clone() {
        Object[] src = this.array;
        return src.clone();
    }

    @Benchmark
    public Object[] ArraysCopyOf() {
        Object[] src = this.array;
        return Arrays.copyOf(src, src.length);
    }

    @Benchmark
    public Object[] ArraysCopyOf_ConstantSize() {
        Object[] src = this.array;
        return Arrays.copyOf(src, LENGTH);
    }

    @Benchmark
    public Object[] ArraysCopyOf_Class() {
        Object[] src = this.array;
        return Arrays.copyOf(src, src.length, Object[].class);
    }

    @Benchmark
    public Object[] ArraysCopyOf_Class_ConstantSize() {
        Object[] src = this.array;
        return Arrays.copyOf(src, LENGTH, Object[].class);
    }

    @Benchmark
    public Object[] SystemArrayCopy() {
        Object[] src = this.array;
        int length = src.length;
        Object[] array = new Object[length];
        System.arraycopy(src, 0, array, 0, length);
        return array;
    }

    @Benchmark
    public Object[] SystemArrayCopy_ConstantSize() {
        Object[] src = this.array;
        Object[] array = new Object[LENGTH];
        System.arraycopy(src, 0, array, 0, LENGTH);
        return array;
    }

    @Benchmark
    public Object[] Loop() {
        Object[] src = this.array;
        int length = src.length;
        Object[] array = new Object[length];
        for (int i = 0; i < length; i++) {
            array[i] = src[i];
        }
        return array;
    }

    @Benchmark
    public Object[] Loop_ConstantSize() {
        Object[] src = this.array;
        Object[] array = new Object[LENGTH];
        for (int i = 0; i < LENGTH; i++) {
            array[i] = src[i];
        }
        return array;
    }
}

最佳答案

像往常一样，通过研究生成的代码可以快速回答此类问题。 JMH 在 Linux 上为您提供 -prof perfasm，在 Windows 上为您提供 -prof xperfasm。如果您在 JDK 8u40 上运行基准测试，那么您将看到(注意我使用 -bm avgt -tu ns 使分数更容易理解):

Benchmark                         Mode  Cnt   Score   Error  Units
ACB.SystemArrayCopy               avgt   25  13.294 ± 0.052  ns/op
ACB.SystemArrayCopy_ConstantSize  avgt   25  16.413 ± 0.080  ns/op

为什么这些基准测试的表现不同？让我们先做-prof perfnorm来剖析(我去掉了无关紧要的行):

Benchmark                                     Mode  Cnt    Score    Error  Units
ACB.SAC                                       avgt   25   13.466 ±  0.070  ns/op
ACB.SAC:·CPI                                  avgt    5    0.602 ±  0.025   #/op
ACB.SAC:·L1-dcache-load-misses                avgt    5    2.346 ±  0.239   #/op
ACB.SAC:·L1-dcache-loads                      avgt    5   24.756 ±  1.438   #/op
ACB.SAC:·L1-dcache-store-misses               avgt    5    2.404 ±  0.129   #/op
ACB.SAC:·L1-dcache-stores                     avgt    5   14.929 ±  0.230   #/op
ACB.SAC:·LLC-loads                            avgt    5    2.151 ±  0.217   #/op
ACB.SAC:·branches                             avgt    5   17.795 ±  1.003   #/op
ACB.SAC:·cycles                               avgt    5   56.677 ±  3.187   #/op
ACB.SAC:·instructions                         avgt    5   94.145 ±  6.442   #/op

ACB.SAC_ConstantSize                          avgt   25   16.447 ±  0.084  ns/op
ACB.SAC_ConstantSize:·CPI                     avgt    5    0.637 ±  0.016   #/op
ACB.SAC_ConstantSize:·L1-dcache-load-misses   avgt    5    2.357 ±  0.206   #/op
ACB.SAC_ConstantSize:·L1-dcache-loads         avgt    5   25.611 ±  1.482   #/op
ACB.SAC_ConstantSize:·L1-dcache-store-misses  avgt    5    2.368 ±  0.123   #/op
ACB.SAC_ConstantSize:·L1-dcache-stores        avgt    5   25.593 ±  1.610   #/op
ACB.SAC_ConstantSize:·LLC-loads               avgt    5    1.050 ±  0.038   #/op
ACB.SAC_ConstantSize:·branches                avgt    5   17.853 ±  0.697   #/op
ACB.SAC_ConstantSize:·cycles                  avgt    5   66.680 ±  2.049   #/op
ACB.SAC_ConstantSize:·instructions            avgt    5  104.759 ±  4.831   #/op

所以，ConstantSize 以某种方式做了更多的 L1-dcache-stores，但少了一个 LLC-load。嗯，这就是我们正在寻找的，在常量情况下有更多的商店。 -prof perfasm 方便地突出显示装配中的热部件:

默认:

  4.32%    6.36%   0x00007f7714bda2dc: movq   $0x1,(%rax)            ; alloc
  0.09%    0.04%   0x00007f7714bda2e3: prefetchnta 0x100(%r9)
  2.95%    1.48%   0x00007f7714bda2eb: movl   $0xf80022a9,0x8(%rax)
  0.38%    0.18%   0x00007f7714bda2f2: mov    %r11d,0xc(%rax)
  1.56%    3.02%   0x00007f7714bda2f6: prefetchnta 0x140(%r9)
  4.73%    2.71%   0x00007f7714bda2fe: prefetchnta 0x180(%r9)

ConstantSize:

  0.58%    1.22%   0x00007facf921132b: movq   $0x1,(%r14)            ; alloc
  0.84%    0.72%   0x00007facf9211332: prefetchnta 0xc0(%r10)
  0.11%    0.13%   0x00007facf921133a: movl   $0xf80022a9,0x8(%r14)
  0.21%    0.68%   0x00007facf9211342: prefetchnta 0x100(%r10)
  0.50%    0.87%   0x00007facf921134a: movl   $0x20,0xc(%r14)
  0.53%    0.82%   0x00007facf9211352: mov    $0x10,%ecx
  0.04%    0.14%   0x00007facf9211357: xor    %rax,%rax
  0.34%    0.76%   0x00007facf921135a: shl    $0x3,%rcx
  0.50%    1.17%   0x00007facf921135e: rex.W rep stos %al,%es:(%rdi) ; zeroing
 29.49%   52.09%   0x00007facf9211361: prefetchnta 0x140(%r10)
  1.03%    0.53%   0x00007facf9211369: prefetchnta 0x180(%r10)

所以那个讨厌的 rex.W rep stos %al,%es:(%rdi) 消耗了大量时间。这会将新分配的数组归零。在 ConstantSize 测试中，JVM 无法关联您正在覆盖整个目标数组，因此它必须在进入实际数组副本之前将其预置零。

如果您查看 JDK 9b82(最新可用)上生成的代码，那么您会看到它在非零副本中折叠了两种模式，正如您在 -prof perfasm 中看到的那样，并且也可以用-prof perfnorm确认:

Benchmark                                     Mode  Cnt    Score    Error  Units
ACB.SAC                                       avgt   50   14.156 ±  0.492  ns/op
ACB.SAC:·CPI                                  avgt    5    0.612 ±  0.144   #/op
ACB.SAC:·L1-dcache-load-misses                avgt    5    2.363 ±  0.341   #/op
ACB.SAC:·L1-dcache-loads                      avgt    5   28.350 ±  2.181   #/op
ACB.SAC:·L1-dcache-store-misses               avgt    5    2.287 ±  0.607   #/op
ACB.SAC:·L1-dcache-stores                     avgt    5   16.922 ±  3.402   #/op
ACB.SAC:·branches                             avgt    5   21.242 ±  5.914   #/op
ACB.SAC:·cycles                               avgt    5   67.168 ± 20.950   #/op
ACB.SAC:·instructions                         avgt    5  109.931 ± 35.905   #/op

ACB.SAC_ConstantSize                          avgt   50   13.763 ±  0.067  ns/op
ACB.SAC_ConstantSize:·CPI                     avgt    5    0.625 ±  0.024   #/op
ACB.SAC_ConstantSize:·L1-dcache-load-misses   avgt    5    2.376 ±  0.214   #/op
ACB.SAC_ConstantSize:·L1-dcache-loads         avgt    5   28.285 ±  2.127   #/op
ACB.SAC_ConstantSize:·L1-dcache-store-misses  avgt    5    2.335 ±  0.223   #/op
ACB.SAC_ConstantSize:·L1-dcache-stores        avgt    5   16.926 ±  1.467   #/op
ACB.SAC_ConstantSize:·branches                avgt    5   19.469 ±  0.869   #/op
ACB.SAC_ConstantSize:·cycles                  avgt    5   62.395 ±  3.898   #/op
ACB.SAC_ConstantSize:·instructions            avgt    5   99.891 ±  5.435   #/op

当然，所有这些用于数组复制的纳米基准都容易受到向量化复制 stub 中奇怪的对齐引起的性能差异的影响，但这是另一个(恐怖的)故事，我没有勇气讲。

关于java - 具有恒定长度的 System.arraycopy，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/32834869/

文章推荐： Python Pony ORM 一次插入多个值

文章推荐： c# - 如何使用 EF Core 添加新表

python - 将键-长度-值 (KLV) 字符串拆分为键、长度、值的小列表
将 KLV 字符串拆分为键、长度、值作为元素的列表/元组的更有效方法是什么？为了添加一点背景，前 3 位数字作为键，接下来的 2 位表示值的长度。我已经能够使用以下代码解决该问题。但我不认为我的代
javascript - 上传前如何获取视频的元数据(长度)？
首先，我试图从文件中提取视频持续时间，然后在无需实际上传文件的情况下显示它。当用户选择视频时 - 信息将显示在其下方，包括文件名、文件大小、文件类型。不管我的技能多么糟糕 - 我无法显示持续时间。我
scala - 获取数组列的大小/长度
我是 Scala 编程新手，这是我的问题:如何计算每行的字符串数量？我的数据框由一列 Array[String] 类型组成。 friendsDF: org.apache.spark.sql.DataF
javascript - 查找上传到React应用程序的音频文件的持续时间/长度
我有一个React Web应用程序(create-react-app)，该应用程序使用react-hook-forms上传歌曲并使用axios将其发送到我的Node / express服务器。我想确
Java - 如何将网络掩码转换为位/长度
如果给你一个网络掩码(例如 255.255.255.0)，你如何在 Java 中获得它的长度/位(例如 8)？最佳答案如果您想找出整数低端有多少个零位，请尝试 Integer.numberOfTr
追加和删除点击时的 Jquery 长度
我需要使用 jQuery 获取 div 数量的长度。我可以得到它，但在两个单击事件中声明变量，但这似乎是错误的，然后我还需要使用它来根据数字显示隐藏按钮。我觉得我不必将代码加倍。在这里摆弄 htt
python散点图面积大小比例 Axis 长度
我对此感到非常绝望，到目前为止我在 www 上找不到任何东西。情况如下: 我正在使用 Python。我有 3 个数组:x 坐标、y 坐标和半径。我想使用给定的 x 和 y 坐标创建散点图。到目
jQuery:动态加载元素的大小/长度
我有一个表单，我通过 jQuery 的加载函数动态添加新的输入和选择元素。有时加载的元素故意为空，在这种情况下我想隐藏容器 div，这样它就不会破坏样式。问题是，我似乎无法计算加载的元素，因此不知道
jQuery 长度 > 0
我决定通过替换来使我的代码更清晰 if (wrappedSet.length > 0) 类似 if (wrappedSet.exists()) 是否有任何 native jq 函数可以实现此目的？或者
MySQL更改 key 长度
简单的问题。如果我有一个如下表: CREATE TABLE `exampletable` ( `id` int(11) NOT NULL AUTO_INCREMENT, `textfield`
mysql - 参数化查询中的数据类型/长度
我正在使用经典 ASP/MySQL 将长用户输入插入到我的数据库中，该输入是从富文本编辑器生成的。该列设置为 LONG-TEXT。作为参数化查询(准备语句)的新手，我不确定用于此特定查询的数据长度。
javascript - 如何在文本输入字段上设置自动宽度/长度？
我正在获取 Stripe 交易费用的值(value)并通过禁用的文本字段显示它。由于输入文本域，句子出现较大空隙 This is the amount $3.50____________that n
css - 背景大小包含 AND 长度
我有一个 div，其背景图像的大小设置为包含。但是，图像是视网膜计算机(Macbook Pro 等)的双分辨率图像，所以我希望能够以某种方式让页面知道即使我说的是背景大小:包含 200x200 图像，
javascript - 从dom中删除元素时如何更改计数器/长度
我正在开发一个具有“已保存”和“已完成”模块的小部件。当我删除元素时，它会从 dom 中删除/淡化它，但是当我将其标记为完成时，它会将其克隆到已完成的选项卡。这工作很棒，但顶部括号内的数字不适合我。这
android JSONArray 长度
我有一个来自 json 提要的数组，我知道在 jArray 中有一个联盟，但我需要计算出该数组的计数，以防稍后将第二个添加到提要中。目前 log cat 没有注销“teamFeedStructure”
嵌套列表的 Javascript 长度
目标:给定一个混合类型的数组，确定每个级别的元素数量。如果同一层有两个子数组，则它们的每个元素都计入该层元素的总数。方法: Array.prototype.elementsAtLevels = fu
java - 测量Java中单链表的大小/长度？
我需要帮助为 Java 中的单链表制作 int size(); 方法。这是我目前所拥有的，但它没有返回正确的列表大小。 public int size() { int size = 0;
Java DataInputStream 长度
我正在为学校作业创建一个文件服务器应用程序。我目前拥有的是一个简单的 Client 类，它通过 TCP 发送图像，还有一个 Server 类接收图像并将其写入文件。这是我的客户端代码 import
haskell - 理解(,)<$>长度<*>头部的类型
我有这对功能 (,) length :: Foldable t => t a -> b -> (Int, b) 和， head :: [a] -> a 我想了解的类型 (,) length he
github - 如何在Jekyll's Liquid模板中比较字符串大小/长度？
我正在GitHub Pages上使用Jekyll来构建博客，并希望获得传递给YAML前题中Liquid模板的page.title字符串的长度，该字符串在每个帖子的YAML主题中。我还没有找到一种简单的

搜寻专家

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

java - 具有恒定长度的 System.arraycopy