Đây là một đoạn mã C ++ cho thấy một số hành vi rất đặc biệt. Vì một số lý do kỳ lạ, việc sắp xếp dữ liệu một cách kỳ diệu làm cho mã nhanh hơn gần gấp sáu lần:
#include <algorithm>
#include <ctime>
#include <iostream>
int main()
{
// Generate data
const unsigned arraySize = 32768;
int data[arraySize];
for (unsigned c = 0; c < arraySize; ++c)
data[c] = std::rand() % 256;
// !!! With this, the next loop runs faster.
std::sort(data, data + arraySize);
// Test
clock_t start = clock();
long long sum = 0;
for (unsigned i = 0; i < 100000; ++i)
{
// Primary loop
for (unsigned c = 0; c < arraySize; ++c)
{
if (data[c] >= 128)
sum += data[c];
}
}
double elapsedTime = static_cast<double>(clock() - start) / CLOCKS_PER_SEC;
std::cout << elapsedTime << std::endl;
std::cout << "sum = " << sum << std::endl;
}- Không có
std::sort(data, data + arraySize);, mã chạy trong 11,54 giây. - Với dữ liệu được sắp xếp, mã chạy trong 1,93 giây.
Ban đầu, tôi nghĩ rằng đây có thể chỉ là một ngôn ngữ hoặc trình biên dịch dị thường, vì vậy tôi đã thử Java:
import java.util.Arrays;
import java.util.Random;
public class Main
{
public static void main(String[] args)
{
// Generate data
int arraySize = 32768;
int data[] = new int[arraySize];
Random rnd = new Random(0);
for (int c = 0; c < arraySize; ++c)
data[c] = rnd.nextInt() % 256;
// !!! With this, the next loop runs faster
Arrays.sort(data);
// Test
long start = System.nanoTime();
long sum = 0;
for (int i = 0; i < 100000; ++i)
{
// Primary loop
for (int c = 0; c < arraySize; ++c)
{
if (data[c] >= 128)
sum += data[c];
}
}
System.out.println((System.nanoTime() - start) / 1000000000.0);
System.out.println("sum = " + sum);
}
}Với một kết quả tương tự nhưng ít cực đoan hơn.
Suy nghĩ đầu tiên của tôi là việc sắp xếp đưa dữ liệu vào bộ đệm, nhưng sau đó tôi nghĩ điều đó thật ngớ ngẩn vì mảng vừa được tạo.
- Chuyện gì đang xảy ra vậy?
- Tại sao xử lý một mảng được sắp xếp nhanh hơn xử lý một mảng chưa sắp xếp?
Mã này đang tóm tắt một số điều khoản độc lập, vì vậy thứ tự không quan trọng.
170
@SachinVerma Ra khỏi đỉnh đầu của tôi: 1) JVM cuối cùng có thể đủ thông minh để sử dụng các động tác có điều kiện. 2) Mã bị giới hạn bộ nhớ. 200M là quá lớn để phù hợp với bộ đệm CPU. Vì vậy, hiệu suất sẽ bị tắc nghẽn bởi băng thông bộ nhớ thay vì phân nhánh.
—
Bí ẩn
@ Bí ẩn, khoảng 2). Tôi nghĩ bảng dự đoán theo dõi các mẫu (không phân biệt các biến thực tế đã được kiểm tra cho mẫu đó) và thay đổi đầu ra dự đoán dựa trên lịch sử. Bạn có thể vui lòng cho tôi một lý do, tại sao một mảng siêu lớn sẽ không được hưởng lợi từ dự đoán chi nhánh?
—
Sachin Verma
@SachinVerma Nó có, nhưng khi mảng đó lớn, một yếu tố thậm chí còn lớn hơn có thể xuất hiện - băng thông bộ nhớ. Ký ức không bằng phẳng . Truy cập bộ nhớ rất chậm và có một lượng băng thông hạn chế. Để đơn giản hóa mọi thứ, chỉ có rất nhiều byte có thể được chuyển giữa CPU và bộ nhớ trong một khoảng thời gian cố định. Mã đơn giản như mã trong câu hỏi này có thể sẽ đạt đến giới hạn đó ngay cả khi nó bị chậm lại bởi các dự đoán sai. Điều này không xảy ra với một mảng 32768 (128KB) vì nó phù hợp với bộ đệm L2 của CPU.
—
Bí ẩn
Có một lỗ hổng bảo mật mới được gọi là BranchScope: cs.ucr.edu/~nael/pub/asplos18.pdf
—
Veve
