Là System.arraycopy của Java() hiệu quả cho các mảng nhỏ?

Question

Là System.arraycopy() của Java có hiệu quả đối với mảng nhỏ hay thực tế là nó là một phương pháp gốc khiến cho nó có khả năng kém hiệu quả hơn một vòng lặp đơn giản và một cuộc gọi hàm?

Phương pháp gốc có phải trả thêm chi phí hiệu năng để vượt qua một số loại cầu nối hệ thống Java không?

Answer 1

Mở rộng một chút về những gì Sid đã viết, rất có thể là System.arraycopy chỉ là một nội tại của JIT; có nghĩa là khi mã gọi System.arraycopy, nó có thể sẽ được gọi là thực thi JIT cụ thể (một khi các thẻ JIT System.arraycopy là "nóng") không được thực hiện thông qua giao diện JNI, vì vậy nó không phải chịu chi phí bình thường của gốc phương pháp. Nói chung, việc thực hiện các phương thức gốc có một số chi phí (đi qua giao diện JNI, cũng có thể một số hoạt động JVM nội bộ không thể xảy ra khi các phương thức gốc đang được thực thi). Nhưng không phải vì một phương thức được đánh dấu là "nguyên gốc" mà bạn đang thực sự thực hiện nó bằng cách sử dụng JNI. JIT có thể làm một số điều điên rồ. Một cách dễ nhất để kiểm tra, như đã được đề xuất, viết một điểm chuẩn nhỏ, cẩn thận với các tiêu chuẩn bình thường của các dấu ấn Java (làm nóng mã trước, tránh mã không có tác dụng phụ vì JIT chỉ tối ưu hóa nó như là một no-op, vv).

Answer 2

Mã byte được thực thi một cách tự nhiên, vì vậy có khả năng hiệu suất sẽ tốt hơn vòng lặp.

Vì vậy, trong trường hợp vòng lặp, nó sẽ phải thực thi mã byte sẽ phải chịu phí. Trong khi mảng bản sao nên được memcopy thẳng.

Answer 3

Chức năng gốc phải nhanh hơn các hàm JVM, vì không có phí VM. Tuy nhiên đối với rất nhiều (> 1000) rất nhỏ (len < 10) mảng nó có thể chậm hơn.

Answer 4

Đây là mối quan tâm hợp lệ. Ví dụ, trong java.nio.DirectByteBuffer.put(byte[]), tác giả cố gắng tránh một bản sao JNI cho số nhỏ các nguyên tố

// These numbers represent the point at which we have empirically 
// determined that the average cost of a JNI call exceeds the expense 
// of an element by element copy. These numbers may change over time. 
static final int JNI_COPY_TO_ARRAY_THRESHOLD = 6; 
static final int JNI_COPY_FROM_ARRAY_THRESHOLD = 6; 

cho System.arraycopy(), chúng tôi có thể kiểm tra như thế nào JDK sử dụng nó. Ví dụ: trong ArrayList, System.arraycopy() luôn được sử dụng, không bao giờ "yếu tố theo bản sao phần tử", bất kể độ dài (ngay cả khi nó là 0). Kể từ khi ArrayList là rất hiệu quả có ý thức, chúng tôi có thể lấy được rằng System.arraycopy() là cách hiệu quả nhất của mảng sao chép bất kể chiều dài.

Answer 5

Đây là mã chuẩn của tôi:

public void test(int copySize, int copyCount, int testRep) { 
    System.out.println("Copy size = " + copySize); 
    System.out.println("Copy count = " + copyCount); 
    System.out.println(); 
    for (int i = testRep; i > 0; --i) { 
     copy(copySize, copyCount); 
     loop(copySize, copyCount); 
    } 
    System.out.println(); 
} 

public void copy(int copySize, int copyCount) { 
    int[] src = newSrc(copySize + 1); 
    int[] dst = new int[copySize + 1]; 
    long begin = System.nanoTime(); 
    for (int count = copyCount; count > 0; --count) { 
     System.arraycopy(src, 1, dst, 0, copySize); 
     dst[copySize] = src[copySize] + 1; 
     System.arraycopy(dst, 0, src, 0, copySize); 
     src[copySize] = dst[copySize]; 
    } 
    long end = System.nanoTime(); 
    System.out.println("Arraycopy: " + (end - begin)/1e9 + " s"); 
} 

public void loop(int copySize, int copyCount) { 
    int[] src = newSrc(copySize + 1); 
    int[] dst = new int[copySize + 1]; 
    long begin = System.nanoTime(); 
    for (int count = copyCount; count > 0; --count) { 
     for (int i = copySize - 1; i >= 0; --i) { 
      dst[i] = src[i + 1]; 
     } 
     dst[copySize] = src[copySize] + 1; 
     for (int i = copySize - 1; i >= 0; --i) { 
      src[i] = dst[i]; 
     } 
     src[copySize] = dst[copySize]; 
    } 
    long end = System.nanoTime(); 
    System.out.println("Man. loop: " + (end - begin)/1e9 + " s"); 
} 

public int[] newSrc(int arraySize) { 
    int[] src = new int[arraySize]; 
    for (int i = arraySize - 1; i >= 0; --i) { 
     src[i] = i; 
    } 
    return src; 
} 

Từ thử nghiệm của tôi, gọi test() với copyCount = 10000000 (1e7) hoặc cao hơn cho phép khởi động phải đạt được trong thời gian copy/loop cuộc gọi đầu tiên, vì vậy sử dụng testRep = 5 là đủ; Với copyCount = 1000000 (1e6) nhu cầu khởi động ít nhất 2 hoặc 3 lần lặp nên testRep sẽ được tăng lên để có được kết quả khả dụng.

Với cấu hình của tôi (CPU Intel Core 2 Duo E8500 @ 3.16GHz, Java SE 1.6.0_35-b10 và Eclipse 3.7.2) nó xuất hiện từ benchmark rằng:

• Khi copySize = 24, System.arraycopy() và vòng tay mất gần như cùng một thời điểm (đôi khi một là rất nhẹ nhanh hơn so với khác, thời điểm khác đó là ngược lại),
• Khi copySize < 24, vòng tay là nhanh hơn so với System.arraycopy() (nhanh hơn với copySize = 23 hơi, thực sự nhanh hơn với copySize < 5),
• Khi copySize> 24, System.arraycopy() là nhanh hơn so với vòng tay (hơi nhanh hơn với copySize = 25, tỷ lệ thời gian vòng lặp/mảng thời gian tăng lên khi tăng copySize).

Lưu ý: Tôi không phải là người bản ngữ tiếng Anh, vui lòng tha lỗi tất cả các lỗi ngữ pháp/từ vựng của tôi.

Answer 6

System.arraycopy sử dụng thao tác memmove để di chuyển từ và lắp ráp để di chuyển các kiểu nguyên thủy khác trong C đằng sau hiện trường. Vì vậy, nó làm cho nỗ lực của nó tốt nhất để di chuyển nhiều như hiệu quả nó có thể đạt được.