探索空间局部性对程序性能的影响

局部性原理

程序具有时间局部性和空间局部性
本文通过代码示例来探索空间局部性对程序性能的影响

时间局部性

被引用的位置，很可能在不远将来被多次引用

空间局部性

如果一个位置被引用了一次，那么附近的位置很可能在不远的将来被引用

测试代码

通过对二维数组求和，来演示空间局部性对性能的影响

import org.junit.Test;

/**
 * 局部性原理测试
 *
 * @author: zyp
 * @since: 2022/7/27 18:43
 */
public class PerformanceTestLocality {
    // 数组长度
    public static final int lenArr = 1000;
    // 循环次数
    public static final int loop = 1000;
    public double[][] arr = new double[lenArr][lenArr];

    {
        // 初始化数据
        int rows = arr.length;
        int cols = arr.length;
        for (int row = 0; row < rows; row++) {
            for (int col = 0; col < cols; col++) {
                arr[row][col] = 1;
            }
        }
    }

    @Test
    public void test() {
        // 有良好的空间局部性
        test("run_row_col", () -> run_row_col(arr));
        // 有良好的空间局部性
        // 用局部变量, 轻微提升了性能
        test("run_row_col2", () -> run_row_col2(arr));
        // 不具备空间局部性，相当于随机访问内存
        test("run_col_row", () -> run_col_row(arr));
    }

    private void test(String name, Runnable run) {
        for (int i = 0; i < loop; i++) {
            run.run();
        }
        long t1 = System.nanoTime();
        for (int i = 0; i < loop; i++) {
            run.run();
        }
        long t2 = System.nanoTime();
        System.out.println(String.format("%s: %s: %.2f", this.getClass().getSimpleName(), name, 1.0 * (t2 - t1) / 1000 / loop));
    }


    private double run_row_col(double[][] arr) {
        int rows = arr.length;
        int cols = arr[0].length;
        double vsum = 1;
        for (int row = 0; row < rows; row++) {
            for (int col = 0; col < cols; col++) {
                vsum += arr[row][col];
            }
        }
        return vsum;
    }


    private double run_row_col2(double[][] arr) {
        int rows = arr.length;
        int cols = arr[0].length;
        double vsum = 1;
        for (int row = 0; row < rows; row++) {
            double[] rowArr = arr[row];
            for (int col = 0; col < cols; col++) {
                vsum += rowArr[col];
            }
        }
        return vsum;
    }


    private double run_col_row(double[][] arr) {
        int rows = arr.length;
        int cols = arr[0].length;
        double vsum = 1;
        for (int col = 0; col < cols; col++) {
            for (int row = 0; row < rows; row++) {
                vsum += arr[row][col];
            }
        }
        return vsum;
    }
}

测试结果

从测试结果可以看出，不具备空间局部性的方法 运行耗时 是 具备空间局部性的方法 的3.6倍

PerformanceTestLocality: run_row_col: 1433.36
PerformanceTestLocality: run_row_col2: 1333.55
PerformanceTestLocality: run_col_row: 4839.81

测试机器

型号名称：	MacBook Pro
型号标识符：	MacBookPro16,1
处理器名称：	六核Intel Core i7
处理器速度：	2.6 GHz
内存：		32 GB