Знаете ли Вы массивы?

public class Test2 {
  public static void main(String[] args) {
    int n = 8000;
 
    int g = new int[n*n];
    long st, en;
 
    // one
    st = System.nanoTime();
    for(int i = 0; i < n; i++) {
      for(int j = 0; j < n; j++) {
        g[i*n + j] = i + j; 
      }
    }
    en = System.nanoTime();
    System.out.println("\nOne time " + (en - st)/1000000.d + " msc");
 
    // two
    st = System.nanoTime();
    for(int i = 0; i < n; i++) {
      for(int j = 0; j < n; j++) {
        g[j*n + i] = i + j; 
      }
    }
    en = System.nanoTime();
    System.out.println("\nTwo time " + (en - st)/1000000.d + " msc");
  }
}

import org.openjdk.jmh.annotations.*;

import java.util.concurrent.TimeUnit;


@State(Scope.Benchmark)
@BenchmarkMode(Mode.AverageTime)
@OperationsPerInvocation(ArrayFill.N * ArrayFill.N)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class ArrayFill {
    public static final int N = 380;
    public int[][] g;

    @Setup
    public void setup() {
        g = new int[N][N];
    }

    @GenerateMicroBenchmark
    public int simple(ArrayFill state) {
        int[][] g = state.g;
        for(int i = 0; i < g.length; i++) {
            for(int j = 0; j < g[i].length; j++) {
                g[i][j] = i + j;
            }
        }
        return g[g.length - 1][g[g.length - 1].length - 1];
    }

    @GenerateMicroBenchmark
    public int optimized(ArrayFill state) {
        int[][] g = state.g;
        for(int i = 0; i < g.length; i++) {
            g[i][i] = 2* i;
            for(int j = 0; j < i; j++) {
                g[j][i] = g[i][j] = i + j;
            }
        }
        return g[g.length - 1][g[g.length - 1].length - 1];
    }
}

gTmp[0] = -999;
for (int i = 0; i < n; i++) {
	for (int j = 0; j < n; j++) {
		System.out.print(g[i][j] + " ");
	}
	System.out.println();
}

st = System.nanoTime();
for (int i = 0; i < n; i++) {
	gTmp[i] = 1;
}

for (int j = 0; j < n; j++) {
	System.arraycopy(gTmp, 0, g[j], 0, n);
}
en = System.nanoTime();

Но мне все-таки правда интересно, где и в каких проектах такая оптимизация может быть полезной? Ведь по сути это экономия на спичках, а если нет, и правда нужна каждая миллисекунда при обработке матриц больших размеренностей, то неужели для java нет jni библиотеки для таких типовых операций на матрицах?

Пока лидирует версия, что «виноват» кэш процессора.

Т.е. случайный доступ к элементам большого массива на ~10% медленнее чем последовательный. Возможно и в правду какую-то роль может сыграть кэш. Однако, в исходной ситуации производительность проседала в разы. Значит есть еще что-то.

Я не понял, а где подсветка ASM для тега Source? Нету чтоль?

$ java -version
java version "1.7.0_45"
Java(TM) SE Runtime Environment (build 1.7.0_45-b18)
Java HotSpot(TM) 64-Bit Server VM (build 24.45-b08, mixed mode)

$ java App
0.039184857     2.360865017
0.038515955     1.953248084
0.033702157     1.955458985
0.033699063     1.953420415
0.03370587      1.952605481
0.033703395     1.956728721
0.033702775     1.954714283
0.033710201     1.954150574
0.033706178     1.95341268
0.033711439     1.952654055

$ java -XX:MaxTrivialSize=50 App
0.039914707     0.01686856
0.045489296     0.033697825
0.033701847     0.033747329
0.033702776     0.033704942
0.03370061      0.033698754
0.033699992     0.033697207
0.033698135     0.033700919
0.033698445     0.033698135
0.033698135     0.033699373
0.033708345     0.033699682