Tại sao chương trình của tôi chậm khi lặp lại chính xác 8192 phần tử?

Đây là trích từ chương trình trong câu hỏi. Ma trận img[][]có kích thước SIZE × SIZE và được khởi tạo tại:

img[j][i] = 2 * j + i

Sau đó, bạn tạo một ma trận res[][]và mỗi trường ở đây được tạo thành trung bình của 9 trường xung quanh nó trong ma trận img. Đường viền được để lại ở mức 0 cho đơn giản.

for(i=1;i<SIZE-1;i++) 
    for(j=1;j<SIZE-1;j++) {
        res[j][i]=0;
        for(k=-1;k<2;k++) 
            for(l=-1;l<2;l++) 
                res[j][i] += img[j+l][i+k];
        res[j][i] /= 9;
}

Đó là tất cả các chương trình. Để hoàn thiện hơn, đây là những gì đến trước. Không có mã đến sau. Như bạn có thể thấy, đó chỉ là khởi tạo.

#define SIZE 8192
float img[SIZE][SIZE]; // input image
float res[SIZE][SIZE]; //result of mean filter
int i,j,k,l;
for(i=0;i<SIZE;i++) 
    for(j=0;j<SIZE;j++) 
        img[j][i] = (2*j+i)%8196;

Về cơ bản, chương trình này chậm khi SIZE là bội số của 2048, ví dụ: thời gian thực hiện:

SIZE = 8191: 3.44 secs
SIZE = 8192: 7.20 secs
SIZE = 8193: 3.18 secs

Trình biên dịch là GCC. Từ những gì tôi biết, điều này là do quản lý bộ nhớ, nhưng tôi thực sự không biết quá nhiều về chủ đề đó, đó là lý do tại sao tôi hỏi ở đây.

Ngoài ra làm thế nào để khắc phục điều này sẽ tốt, nhưng nếu ai đó có thể giải thích những lần thực hiện này thì tôi đã đủ hạnh phúc.

Tôi đã biết về malloc / miễn phí, nhưng vấn đề không phải là dung lượng bộ nhớ được sử dụng, đó chỉ là thời gian thực hiện, vì vậy tôi không biết điều đó sẽ giúp ích như thế nào.

Sự khác biệt được gây ra bởi cùng một vấn đề siêu liên kết từ các câu hỏi liên quan sau đây:

• Tại sao hoán vị ma trận 512x512 chậm hơn nhiều so với hoán vị ma trận 513x513?
• Phép nhân ma trận: Chênh lệch nhỏ về kích thước ma trận, chênh lệch lớn về thời gian

Nhưng đó chỉ là do có một vấn đề khác với mã.

Bắt đầu từ vòng lặp ban đầu:

for(i=1;i<SIZE-1;i++) 
    for(j=1;j<SIZE-1;j++) {
        res[j][i]=0;
        for(k=-1;k<2;k++) 
            for(l=-1;l<2;l++) 
                res[j][i] += img[j+l][i+k];
        res[j][i] /= 9;
}

Đầu tiên lưu ý rằng hai vòng lặp bên trong là tầm thường. Chúng có thể không được kiểm soát như sau:

for(i=1;i<SIZE-1;i++) {
    for(j=1;j<SIZE-1;j++) {
        res[j][i]=0;
        res[j][i] += img[j-1][i-1];
        res[j][i] += img[j  ][i-1];
        res[j][i] += img[j+1][i-1];
        res[j][i] += img[j-1][i  ];
        res[j][i] += img[j  ][i  ];
        res[j][i] += img[j+1][i  ];
        res[j][i] += img[j-1][i+1];
        res[j][i] += img[j  ][i+1];
        res[j][i] += img[j+1][i+1];
        res[j][i] /= 9;
    }
}

Vì vậy, điều đó để lại hai vòng lặp bên ngoài mà chúng ta quan tâm.

Bây giờ chúng ta có thể thấy vấn đề tương tự trong câu hỏi này: Tại sao thứ tự các vòng lặp ảnh hưởng đến hiệu suất khi lặp qua một mảng 2D?

Bạn đang lặp lại cột ma trận thay vì hàng khôn ngoan.

Để giải quyết vấn đề này, bạn nên trao đổi hai vòng.

for(j=1;j<SIZE-1;j++) {
    for(i=1;i<SIZE-1;i++) {
        res[j][i]=0;
        res[j][i] += img[j-1][i-1];
        res[j][i] += img[j  ][i-1];
        res[j][i] += img[j+1][i-1];
        res[j][i] += img[j-1][i  ];
        res[j][i] += img[j  ][i  ];
        res[j][i] += img[j+1][i  ];
        res[j][i] += img[j-1][i+1];
        res[j][i] += img[j  ][i+1];
        res[j][i] += img[j+1][i+1];
        res[j][i] /= 9;
    }
}

Điều này giúp loại bỏ hoàn toàn tất cả các truy cập không tuần tự để bạn không còn bị chậm lại ngẫu nhiên trên các quyền hạn lớn.

Lõi i7 920 @ 3,5 GHz

Mã gốc:

8191: 1.499 seconds
8192: 2.122 seconds
8193: 1.582 seconds

Các vòng ngoài được hoán đổi:

8191: 0.376 seconds
8192: 0.357 seconds
8193: 0.351 seconds

Các thử nghiệm sau đây đã được thực hiện với trình biên dịch Visual C ++ vì nó được sử dụng bởi cài đặt Qt Creator mặc định (tôi đoán không có cờ tối ưu hóa). Khi sử dụng GCC, không có sự khác biệt lớn giữa phiên bản của Mystical và mã "được tối ưu hóa" của tôi. Vì vậy, kết luận là tối ưu hóa trình biên dịch chăm sóc tối ưu hóa vi mô tốt hơn con người (cuối cùng là tôi). Tôi để phần còn lại của câu trả lời của tôi để tham khảo.

Nó không hiệu quả để xử lý hình ảnh theo cách này. Tốt hơn là sử dụng mảng kích thước đơn. Xử lý tất cả các pixel được thực hiện trong một vòng lặp. Truy cập ngẫu nhiên vào các điểm có thể được thực hiện bằng cách sử dụng:

pointer + (x + y*width)*(sizeOfOnePixel)

Trong trường hợp cụ thể này, tốt hơn là tính toán và lưu trữ tổng của ba nhóm pixel theo chiều ngang vì chúng được sử dụng ba lần mỗi nhóm.

Tôi đã thực hiện một số thử nghiệm và tôi nghĩ rằng nó đáng để chia sẻ. Mỗi kết quả là trung bình của năm bài kiểm tra.

Mã gốc của người dùng1615209:

8193: 4392 ms
8192: 9570 ms

Phiên bản của Mystical:

8193: 2393 ms
8192: 2190 ms

Hai pass sử dụng mảng 1D: pass đầu tiên cho tổng số ngang, thứ hai cho tổng dọc và trung bình. Hai địa chỉ vượt qua với ba con trỏ và chỉ tăng như thế này:

imgPointer1 = &avg1[0][0];
imgPointer2 = &avg1[0][SIZE];
imgPointer3 = &avg1[0][SIZE+SIZE];

for(i=SIZE;i<totalSize-SIZE;i++){
    resPointer[i]=(*(imgPointer1++)+*(imgPointer2++)+*(imgPointer3++))/9;
}

8193: 938 ms
8192: 974 ms

Hai pass sử dụng mảng 1D và đánh địa chỉ như thế này:

for(i=SIZE;i<totalSize-SIZE;i++){
    resPointer[i]=(hsumPointer[i-SIZE]+hsumPointer[i]+hsumPointer[i+SIZE])/9;
}

8193: 932 ms
8192: 925 ms

Một lần vượt qua bộ nhớ đệm ngang chỉ một hàng phía trước để chúng ở trong bộ đệm:

// Horizontal sums for the first two lines
for(i=1;i<SIZE*2;i++){
    hsumPointer[i]=imgPointer[i-1]+imgPointer[i]+imgPointer[i+1];
}
// Rest of the computation
for(;i<totalSize;i++){
    // Compute horizontal sum for next line
    hsumPointer[i]=imgPointer[i-1]+imgPointer[i]+imgPointer[i+1];
    // Final result
    resPointer[i-SIZE]=(hsumPointer[i-SIZE-SIZE]+hsumPointer[i-SIZE]+hsumPointer[i])/9;
}

8193: 599 ms
8192: 652 ms

Phần kết luận:

• Không có lợi ích của việc sử dụng một số con trỏ và chỉ tăng (tôi nghĩ rằng nó sẽ nhanh hơn)
• Bộ nhớ đệm ngang tốt hơn so với tính toán chúng nhiều lần.
• Hai lần vượt qua không nhanh hơn ba lần, chỉ hai lần.
• Có thể đạt được tốc độ nhanh hơn 3,6 lần bằng cả một lần truyền và lưu vào bộ đệm kết quả trung gian

Tôi chắc chắn rằng nó có thể làm tốt hơn nhiều.

LƯU Ý Xin lưu ý rằng tôi đã viết câu trả lời này để nhắm mục tiêu các vấn đề hiệu suất chung thay vì vấn đề bộ đệm được giải thích trong câu trả lời xuất sắc của Mystical. Lúc đầu, nó chỉ là mã giả. Tôi đã được yêu cầu làm các bài kiểm tra trong các bình luận ... Đây là một phiên bản được tái cấu trúc hoàn toàn với các bài kiểm tra.