Почему время работы одного и того же алгоритма отличается в тесте на коэффициент удвоения?

Question

Я анализирую алгоритм трех сумм методом грубой силы. Скажем, время работы этого алгоритма T (N) = a N ^ 3 . Что я делаю, так это то, что я запускаю эту ThreeSum. java программу с 8Kints.txt и использую это время работы для вычисления константы а . После вычисления a я предполагаю, каково время работы 16Kints.txt . Вот мой ThreeSum. java файл:

    public class ThreeSum {
        public static int count(int[] a) {
            // Count triples that sum to 0.
            int N = a.length;
            int cnt = 0;
            for (int i = 0; i < N; i++)
                for (int j = i + 1; j < N; j++)
                    for (int k = j + 1; k < N; k++)
                        if (a[i] + a[j] + a[k] == 0)
                            cnt++;
            return cnt;
        }

        public static void main(String[] args) {
            In in = new In(args[0]);
            int[] a = in.readAllInts();
            Stopwatch timer = new Stopwatch();
            int count = count(a);
            StdOut.println("elapsed time = " + timer.elapsedTime());
            StdOut.println(count);
        }
    }

Когда я бегу вот так:

$ java ThreeSum 8Kints.txt

Я получаю следующее:

elapsed time = 165.335

А теперь в эксперименте с удвоением коэффициента, где я использую тот же метод внутри другого клиента и запускаю этого клиента с несколькими файлами в качестве аргументов и хочу попытаться сравнить время работы 8Kints. txt с помощью вышеуказанного метода, но я получаю другой результат, на самом деле более быстрый результат. Вот мой коэффициент удвоения. java клиент:

public class DoublingRatio {
    public static double timeTrial(int[] a) {
        Stopwatch timer = new Stopwatch();
        int cnt = ThreeSum.count(a);
        return timer.elapsedTime();
    }

    public static void main(String[] args) {
        In in;
        int[][] inputs = new int[args.length][];

        for (int i = 0; i < args.length; i++) {
            in = new In(args[i]);
            inputs[i] = in.readAllInts();
        }

        double prev = timeTrial(inputs[0]);
        for (int i = 1; i < args.length; i++) {
            double time = timeTrial(inputs[i]);
            StdOut.printf("%6d %7.3f ", inputs[i].length, time);
            StdOut.printf("%5.1f\n", time / prev);
            prev = time;
        }
    }
}

Когда я запускаю это как:

$ java DoublingRatio 1Kints.txt 2Kints.txt 4Kints.txt 8Kints.txt 16Kints.txt 32Kints.txt

я получаю более быстрое повторное использование и мне интересно, почему:

 N      sec   ratio
2000   2.631   7.8
4000   4.467   1.7
8000  34.626   7.8

Я знаю, что это связано с Java, а не с алгоритмом? java оптимизирует некоторые вещи под капотом.