Tại sao System.arraycopy có nguồn gốc trong Java?

Tôi rất ngạc nhiên khi thấy trong nguồn Java có System.arraycopy là một phương thức gốc.

Tất nhiên lý do là vì nó nhanh hơn. Nhưng những thủ thuật bản địa nào mà mã có thể sử dụng để làm cho nó nhanh hơn?

Tại sao không chỉ lặp lại mảng ban đầu và sao chép từng con trỏ sang mảng mới - chắc chắn điều này không quá chậm và cồng kềnh?

Trong mã gốc, nó có thể được thực hiện với một memcpy/ memmove, trái ngược với n thao tác sao chép riêng biệt. Sự khác biệt về hiệu suất là đáng kể.

Nó không thể được viết bằng Java. Mã gốc có thể bỏ qua hoặc làm sáng tỏ sự khác biệt giữa mảng Đối tượng và mảng nguyên thủy. Java không thể làm điều đó, ít nhất là không hiệu quả.

Và nó không thể được viết với một đơn lẻ memcpy(), vì ngữ nghĩa bắt buộc bởi các mảng chồng chéo.

Tất nhiên, nó phụ thuộc vào việc triển khai.

HotSpot sẽ coi nó như một "nội tại" và chèn mã vào trang web cuộc gọi. Đó là mã máy, không phải mã C cũ chậm chạp. Điều này cũng có nghĩa là các vấn đề với chữ ký của phương pháp phần lớn sẽ biến mất.

Một vòng lặp sao chép đơn giản đủ đơn giản để có thể áp dụng tối ưu rõ ràng cho nó. Ví dụ: hủy cuộn vòng lặp. Chính xác những gì xảy ra lại phụ thuộc vào việc triển khai.

Trong các thử nghiệm của riêng tôi, System.arraycopy () để sao chép mảng nhiều chiều nhanh hơn từ 10 đến 20 lần so với việc xen kẽ cho các vòng lặp:

float[][] foo = mLoadMillionsOfPoints(); // result is a float[1200000][9]
float[][] fooCpy = new float[foo.length][foo[0].length];
long lTime = System.currentTimeMillis();
System.arraycopy(foo, 0, fooCpy, 0, foo.length);
System.out.println("native duration: " + (System.currentTimeMillis() - lTime) + " ms");
lTime = System.currentTimeMillis();

for (int i = 0; i < foo.length; i++)
{
    for (int j = 0; j < foo[0].length; j++)
    {
        fooCpy[i][j] = foo[i][j];
    }
}
System.out.println("System.arraycopy() duration: " + (System.currentTimeMillis() - lTime) + " ms");
for (int i = 0; i < foo.length; i++)
{
    for (int j = 0; j < foo[0].length; j++)
    {
        if (fooCpy[i][j] != foo[i][j])
        {
            System.err.println("ERROR at " + i + ", " + j);
        }
    }
}

Bản in này:

System.arraycopy() duration: 1 ms
loop duration: 16 ms

Có một vài lý do:

1. JIT không có khả năng tạo mã mức thấp hiệu quả như mã C được viết thủ công. Sử dụng mức C thấp có thể cho phép rất nhiều tối ưu hóa gần như không thể thực hiện được đối với trình biên dịch JIT chung.

   Xem liên kết này để biết một số thủ thuật và so sánh tốc độ của các triển khai C viết tay (memcpy, nhưng nguyên tắc giống nhau): Kiểm tra này Tối ưu hóa Memcpy cải thiện tốc độ

2. Phiên bản C khá độc lập với kiểu và kích thước của các thành viên mảng. Không thể làm điều tương tự trong java vì không có cách nào để lấy nội dung mảng dưới dạng một khối bộ nhớ thô (ví dụ: con trỏ).