Các ngôn ngữ OO hiện đại có thể cạnh tranh với hiệu suất lưu trữ mảng của C ++ không?

Tôi chỉ nhận thấy rằng mọi ngôn ngữ lập trình OO hiện đại mà tôi ít nhất là quen thuộc (về cơ bản chỉ là Java, C # và D) cho phép các mảng covariant. Đó là, một mảng chuỗi là một mảng đối tượng:

Object[] arr = new String[2];   // Java, C# and D allow this

Mảng covariant là một lỗ hổng trong hệ thống kiểu tĩnh. Chúng tạo ra các lỗi loại có thể không thể được phát hiện tại thời gian biên dịch, do đó, mỗi lần ghi vào một mảng phải được kiểm tra trong thời gian chạy:

arr[0] = "hello";        // ok
arr[1] = new Object();   // ArrayStoreException

Đây có vẻ là một hiệu suất khủng khiếp nếu tôi làm nhiều cửa hàng mảng.

C ++ không có mảng covariant, do đó không cần phải thực hiện kiểm tra thời gian chạy như vậy, điều đó có nghĩa là không có hình phạt hiệu năng.

Có bất kỳ phân tích được thực hiện để giảm số lượng kiểm tra thời gian chạy cần thiết? Ví dụ: nếu tôi nói:

arr[1] = arr[0];

người ta có thể lập luận rằng các cửa hàng có thể không thể thất bại. Tôi chắc chắn có rất nhiều tối ưu hóa có thể khác mà tôi chưa từng nghĩ đến.

Các trình biên dịch hiện đại có thực sự thực hiện các loại tối ưu hóa này không, hay tôi phải sống với thực tế là, ví dụ, Quicksort luôn kiểm tra thời gian chạy không cần thiết O (n log n)?

Các ngôn ngữ OO hiện đại có thể tránh được chi phí được tạo ra bằng cách hỗ trợ các mảng đồng biến thể không?

D không có mảng covariant. Nó cho phép họ trước khi phát hành gần đây nhất ( dmd 2.057 ), nhưng lỗi đó đã được sửa.

Một mảng trong D thực sự chỉ là một cấu trúc với một con trỏ và chiều dài:

struct A(T)
{
    T* ptr;
    size_t length;
}

Kiểm tra giới hạn được thực hiện bình thường khi lập chỉ mục một mảng, nhưng nó bị xóa khi bạn biên dịch -release. Vì vậy, trong chế độ phát hành, không có sự khác biệt hiệu năng thực sự giữa các mảng trong C / C ++ và các mảng trong D.

Vâng, một tối ưu hóa quan trọng là đây:

sealed class Foo
{
}

Trong C #, lớp này không thể là siêu kiểu cho bất kỳ loại nào, vì vậy bạn có thể tránh việc kiểm tra một mảng loại Foo.

Và với câu hỏi thứ hai, trong các mảng đồng biến thể F # không được phép (nhưng tôi đoán kiểm tra sẽ vẫn còn trong CLR trừ khi nó không cần thiết trong tối ưu hóa khi chạy)

let a = [| "st" |]
let b : System.Object[] = a // Fails

https://stackoverflow.com/questions/7339013/array-covariance-in-f

Một vấn đề hơi liên quan là kiểm tra ràng buộc mảng. Đây có thể là một bài đọc thú vị (nhưng cũ) về tối ưu hóa được thực hiện trong CLR (hiệp phương sai cũng được đề cập 1 vị trí): http://bloss.msdn.com/b/clrcodegeneration/archive/2009/08/13/array-bound -check-Elimination-in-the-clr.aspx

Câu trả lời Java:

Tôi lấy nó mà bạn chưa thực sự chuẩn mã, phải không? Nói chung, 90% tất cả các phôi động trong Java là miễn phí vì JIT có thể loại bỏ chúng (quicksort phải là một ví dụ tốt cho điều này) và phần còn lại là một ld/cmp/brchuỗi hoàn toàn có thể dự đoán được (nếu không, tại sao địa ngục lại ném mã của bạn tất cả những ngoại lệ diễn viên năng động?).

Chúng tôi thực hiện tải sớm hơn nhiều so với so sánh thực tế, chi nhánh được dự đoán chính xác trong 99.9999% (đã được thống kê!) Trong tất cả các trường hợp vì vậy chúng tôi không trì hoãn đường ống (giả sử chúng tôi không nhấn bộ nhớ với tải, nếu không tốt sẽ được chú ý, nhưng sau đó tải là cần thiết dù sao). Do đó, chi phí là 1 chu kỳ đồng hồ NẾU JIT không thể tránh được việc kiểm tra.

Một số chi phí? Chắc chắn, nhưng tôi nghi ngờ bạn sẽ nhận thấy nó ..

Để giúp hỗ trợ câu trả lời của tôi, vui lòng xem blog này của Tiến sĩ Cliff Click thảo luận về hiệu suất Java so với C.

D không cho phép mảng covariant.

void main()
{
    class Foo {}
    Object[] a = new Foo[10];
}  

/* Error: cannot implicitly convert expression (new Foo[](10LU)) of type Foo[]
to Object[] */

Như bạn nói, nó sẽ là một lỗ hổng trong hệ thống loại để cho phép điều này.

Bạn có thể được tha thứ cho lỗi lầm, vì lỗi này chỉ mới được sửa trong DMD mới nhất, được phát hành vào ngày 13 tháng 12.

Truy cập mảng trong D cũng nhanh như trong C hoặc C ++.

Từ thử nghiệm tôi đã thực hiện trên một máy tính xách tay giá rẻ, sự khác biệt giữa việc sử dụng int[]và Integer[]khoảng 1,0 ns. Sự khác biệt có thể là do kiểm tra thêm cho loại.

Nói chung, các đối tượng chỉ được sử dụng cho logic mức cao hơn khi không phải mọi ns đều được tính. Nếu bạn cần lưu mọi ns, tôi sẽ tránh sử dụng các cấu trúc cấp cao hơn như Đối tượng. Bài tập một mình có khả năng là yếu tố rất nhỏ trong bất kỳ chương trình thực tế nào. ví dụ: tạo một Object mới trên cùng một máy là 5 ns.

Các cuộc gọi để so sánh có thể sẽ đắt hơn nhiều, đặc biệt nếu bạn sử dụng một đối tượng phức tạp như String.

Bạn hỏi về các ngôn ngữ OO hiện đại khác? Chà, Delphi tránh hoàn toàn vấn đề này bằng cách stringlà một người nguyên thủy, không phải là một đối tượng. Vì vậy, một chuỗi các chuỗi chính xác là một chuỗi các chuỗi và không có gì khác, và bất kỳ hoạt động nào trên chúng đều nhanh như mã gốc, không có loại kiểm tra chi phí.

Tuy nhiên, mảng chuỗi không được sử dụng rất thường xuyên; Lập trình viên Delphi có xu hướng ủng hộ TStringListlớp học. Đối với một lượng chi phí tối thiểu, nó cung cấp một tập hợp các phương thức nhóm chuỗi hữu ích trong nhiều tình huống mà lớp đã được so sánh với một con dao quân đội Thụy Sĩ. Vì vậy, nó là thành ngữ để sử dụng một đối tượng danh sách chuỗi thay vì một mảng chuỗi.

Đối với các đối tượng khác nói chung, vấn đề không tồn tại bởi vì trong Delphi, như trong C ++, các mảng không phải là biến số, để ngăn chặn các loại lỗ hệ thống được mô tả ở đây.

hoặc tôi phải sống với thực tế là, ví dụ, Quicksort luôn kiểm tra thời gian chạy không cần thiết O (n log n)?

Hiệu suất CPU không đơn điệu, điều đó có nghĩa là các chương trình dài hơn có thể nhanh hơn các chương trình ngắn hơn (điều này phụ thuộc vào CPU và điều này đúng với các kiến ​​trúc x86 và amd64 phổ biến). Vì vậy, có thể một chương trình thực hiện kiểm tra ràng buộc trên các mảng thực sự nhanh hơn chương trình được suy ra từ trước bằng cách loại bỏ các kiểm tra ràng buộc này.

Lý do của hành vi này là việc kiểm tra ràng buộc sửa đổi sự liên kết của mã trong bộ nhớ, sẽ sửa đổi tần suất của các lần truy cập bộ đệm, v.v.

Vì vậy, có, sống với thực tế là Quicksort luôn thực hiện kiểm tra giả O (n log n) và tối ưu hóa sau khi định hình.

Scala là một ngôn ngữ OO có bất biến, thay vì covariant, mảng. Nó nhắm mục tiêu vào JVM, do đó không có hiệu năng chiến thắng ở đó, nhưng nó tránh được sự không phù hợp chung cho cả Java và C #, làm ảnh hưởng đến an toàn loại của chúng vì lý do tương thích ngược.