다차원 배열

첫 번째 블록 (2차원 배열 선언 및 순회)

{
    // 2차원 배열
    int matrix[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // 2차원 배열 순회
    for (int i = 0; i < size(matrix); ++i)
    {
        for (int j = 0; j < size(matrix[i]); ++j)
        {
            cout << matrix[i][j] << " ";
        }
        cout << endl;
    }
}

1. matrix 배열을 3x3 크기로 선언하고 초기화합니다.
2. 이중 for 문을 사용하여 2차원 배열을 순회하며 각 요소를 출력합니다.
   • size(matrix)는 배열의 행 수를 반환합니다.
   • size(matrix[i])는 배열의 열 수를 반환합니다.

두 번째 블록 (2차원 행렬의 곱셈)

{
    // 2차원 행렬의 곱셈
    int matrix0[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    int matrix1[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    int matrix2[3][3] = {};

    for (int i = 0; i < 3; ++i)
    {
        for (int j = 0; j < 3; ++j)
        {
            for (int k = 0; k < 3; ++k)
            {
                matrix2[i][j] += matrix0[i][k] * matrix1[k][j];
            }
        }
    }
    for (int i = 0; i < size(matrix2); ++i)
    {
        for (int j = 0; j < size(matrix2[i]); ++j)
        {
            cout << matrix2[i][j] << " ";
        }
        cout << endl;
    }
}

1. 두 개의 3x3 행렬 matrix0와 matrix1을 선언하고 초기화합니다.
2. matrix2를 0으로 초기화된 3x3 행렬로 선언합니다.
3. 이중 for 문을 사용하여 행렬 곱셈을 수행합니다.
   • matrix2[i][j]에 matrix0의 i번째 행과 matrix1의 j번째 열의 곱셈 결과를 누적합니다.
4. 행렬 곱셈 결과를 출력합니다.

세 번째 블록 (배열의 메모리 구조)

{
    // 배열의 메모리 
    // int[3]
    // int, int, int

    // int[3][3]
    // int, int, int | int, int, int | int, int, int
}

1. 1차원 배열 int[3]의 메모리 구조는 연속된 세 개의 int 값을 가집니다.
2. 2차원 배열 int[3][3]의 메모리 구조는 연속된 세 개의 int 배열이 세 번 반복되는 구조입니다.

네 번째 블록 (배열의 복사)

{
    // 배열의 복사
    int matrix0[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    int matrix1[3][3];

    // 순회를 이용한 복사
    for (int i = 0; i < size(matrix1); ++i)
    {
        for (int j = 0; j < size(matrix1[i]); ++j)
        {
            matrix1[i][j] = matrix0[i][j];
        }
    }

    // 함수를 이용한 복사
    memcpy(matrix1, matrix0, sizeof(matrix0));
    copy(&matrix0[0][0], &matrix0[0][0] + 3 * 3, &matrix1[0][0]);


    for (int i = 0; i < size(matrix1); ++i)
    {
        for (int j = 0; j < size(matrix1[i]); ++j)
        {
            cout << matrix1[i][j] << " ";
        }
        cout << endl;
    }
}

1. matrix0 배열을 선언하고 초기화합니다.
2. matrix1 배열을 선언합니다.
3. 이중 for 문을 사용하여 배열의 각 요소를 복사합니다.
4. memcpy 함수를 사용하여 배열을 복사합니다.
5. C++ STL의 copy 함수를 사용하여 배열을 복사합니다.
6. 복사된 matrix1 배열을 출력합니다.

다섯 번째 블록 (캐싱에 따른 순회 속도의 차이 비교)

{
    // 캐싱에 따른 순회 속도의 차이 비교
    // 시간 지역성, 공간 지역성
    int sum = 0;
    for (int i = 0; i < 20240; ++i)
    {
        for (int j = 0; j < 20240; ++j)
        {
            sum += gMatrix[i][j]; // 빠름
            sum += gMatrix[j][i]; // 느림
        }
    }
}

1. gMatrix는 전역적으로 선언된 20240x20240 크기의 2차원 배열입니다.
2. 캐시 메모리에 의한 순회 속도 차이를 비교합니다.
3. sum += gMatrix[i][j];는 메모리의 공간 지역성에 의해 캐시 히트율이 높아 빠르게 수행됩니다.
4. sum += gMatrix[j][i];는 캐시 미스가 많아 상대적으로 느리게 수행됩니다.

캐시 메모리와 지역성

캐시 메모리는 CPU와 메인 메모리 사이에 위치하여 메모리 접근 속도를 줄여주는 역할을 합니다. 캐시 메모리는 지역성을 활용하여 성능을 향상시킵니다.

1. 시간 지역성(Temporal Locality): 최근에 접근한 데이터에 다시 접근할 가능성이 높다는 원칙입니다. 따라서 동일한 데이터를 다시 사용할 때 캐시 히트가 발생하여 성능이 향상됩니다.
2. 공간 지역성(Spatial Locality): 최근에 접근한 데이터 근처에 있는 데이터에 접근할 가능성이 높다는 원칙입니다. 연속된 메모리 위치에 접근할 때 캐시 히트가 발생하여 성능이 향상됩니다.

위의 예제에서는 gMatrix[i][j] 순회는 행 우선 접근으로 연속된 메모리 위치에 접근하므로 캐시 히트가 발생하여 빠르게 수행됩니다. 반면, gMatrix[j][i] 순회는 열 우선 접근으로 연속되지 않은 메모리 위치에 접근하므로 캐시 미스가 많아 상대적으로 느리게 수행됩니다.

정리

이 예제에서는 다차원 배열의 선언, 초기화, 순회, 복사 및 행렬 곱셈을 다룹니다. 또한 캐시 메모리의 시간 지역성과 공간 지역성을 활용한 성능 최적화 방법을 보여줍니다. 다차원 배열을 효율적으로 사용하려면 메모리 접근 패턴을 고려하여 캐시 히트율을 높이는 것이 중요합니다.