System.arrayCopy медленный

Ответ 1

Собственно, компилятор HotSpot достаточно умен, чтобы разворачивать и векторизовать ручной цикл копирования - почему код результата выглядит хорошо оптимизированным.

Почему System.arraycopy медленнее? Это изначально родной метод, и вы должны заплатить за собственный вызов, пока компилятор не оптимизирует его как JVM.

Однако в вашем тесте компилятор не имеет возможности для такой оптимизации, потому что метод enlarge не вызывается достаточно много раз (т.е. он не считается горячим).

Я покажу вам забавный трюк, чтобы заставить оптимизировать. Перепишите enlarge следующим образом:

private static int[] enlarge(int[] array, int size) {
    for (int i = 0; i < 10000; i++) { /* fool the JIT */ }

    int[] newArray = new int[array.length + size];
    System.arraycopy(array, 0, newArray, 0, array.length);
    return newArray;
}

Пустой цикл запускает переполнение счетчика backedge, что, в свою очередь, вызывает компиляцию метода enlarge. Пустой цикл затем исключается из скомпилированного кода, поэтому он безвреден. Теперь метод enlarge получает примерно в 1,5 раза быстрее, чем ручной цикл!

Важно, что System.arraycopy сразу следует за new int[]. В этом случае HotSpot может оптимизировать избыточное обнуление нового выделенного массива. Знаете, все объекты Java должны быть обнулены сразу после создания. Но поскольку компилятор обнаруживает, что массив заполняется сразу после создания, он может исключить обнуление, тем самым делая код результата еще быстрее.

P.S. Тест @assylias хорош, но он также страдает тем, что System.arraycopy не является встроенным для больших массивов. В случае небольших массивов arrayCopy критерий называется много раз в секунду, JIT считает его горячим и хорошо оптимизируется. Но для больших массивов каждая итерация длиннее, поэтому в секунду происходит намного меньше итераций, а JIT не обрабатывает arrayCopy как горячую.

Ответ 2

Используя jmh, я получаю результаты, показанные в таблице ниже (размер - это размер массива, оценка - время в микросекундах, ошибка показывает доверительный интервал на 99,9%):

Benchmark              (size)  Mode  Cnt      Score     Error  Units
ArrayCopy.arrayCopy        10  avgt   60      0.022 ±   0.001  us/op
ArrayCopy.arrayCopy     10000  avgt   60      4.959 ±   0.068  us/op
ArrayCopy.arrayCopy  10000000  avgt   60  11906.870 ± 220.850  us/op
ArrayCopy.clone_           10  avgt   60      0.022 ±   0.001  us/op
ArrayCopy.clone_        10000  avgt   60      4.956 ±   0.068  us/op
ArrayCopy.clone_     10000000  avgt   60  10895.856 ± 208.369  us/op
ArrayCopy.copyOf           10  avgt   60      0.022 ±   0.001  us/op
ArrayCopy.copyOf        10000  avgt   60      4.958 ±   0.072  us/op
ArrayCopy.copyOf     10000000  avgt   60  11837.139 ± 220.452  us/op
ArrayCopy.loop             10  avgt   60      0.036 ±   0.001  us/op
ArrayCopy.loop          10000  avgt   60      5.872 ±   0.095  us/op
ArrayCopy.loop       10000000  avgt   60  11315.482 ± 217.348  us/op

По существу, цикл, кажется, работает немного лучше, чем arrayCopy для больших массивов - вероятно, потому, что JIT неплохо оптимизирует такой простой цикл. Для меньших массивов arrayCopy кажется лучше (хотя разница довольно мала).

Обратите внимание, однако, что клон, по-видимому, всегда лучше или лучше других вариантов, в зависимости от размера. Поэтому я пошел бы за клоном, что также бывает проще в использовании.

Для справки, контрольный код, запустите с -wi 5 -w 1000ms -i 30 -r 1000ms -t 1 -f 2 -tu us:

@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
public class ArrayCopy {

  @Param({"10", "10000", "10000000"}) int size;

  private int[] array;

  @Setup(Level.Invocation) public void setup() {
    array = new int[size];
    for (int i = 0; i < size; i++) {
      array[i] = i;
    }
  }

  @Benchmark
  public int[] clone_() {
    int[] copy = array.clone();
    return copy;
  }

  @Benchmark
  public int[] arrayCopy() {
    int[] copy = new int[array.length];
    System.arraycopy(array, 0, copy, 0, array.length);
    return copy;
  }

  @Benchmark
  public int[] copyOf() {
    int[] copy = Arrays.copyOf(array, array.length);
    return copy;
  }

  @Benchmark
  public int[] loop() {
    int[] copy = new int[array.length];
    for (int i = 0; i < array.length; i++) {
      copy[i] = array[i];
    }
    return copy;
  }
}