Công nghệ nào nên được chọn cho các ứng dụng quan trọng về hiệu năng? . NET Core hay Electron so với các ứng dụng gốc?
Các ngôn ngữ và thời gian chạy khác nhau có các lợi thế riêng biệt trong các miền tương ứng của chúng;
Đồng thời, thật thú vị khi các đoạn mã khác nhau chuyển đổi liên quan đến hiệu suất
Tất cả các thử nghiệm chạy trên MacBook Pro 15" 2018, 2. Intel Core i7–8750H 6 nhân 2 GHz với macOS Catalina
Toán tử gán phép cộng
Để bắt đầu, hãy so sánh số học đơn giản JavaScript, C và C# với 200 triệu toán tử gán bổ sung bằng cách sử dụng các đoạn mã sau
// C
int temp = 1;
for [int i = 0; i < 200000000; i++]
temp += temp;// C#
int temp = 1;
for [var i = 0; i < 200000000; i++]
temp += temp;// JavaScript
let temp = 1;
for [let i = 0; i < 200000000; i++]
temp += temp;
Đối với C, tôi sẽ sử dụng CLion để thực thi bản phát hành C11
Thực thi CLion dẫn đến 6.219.000 nano giây
Đối với C#, tôi sẽ sử dụng Rider thực thi. NET lõi 3. 1. bản phát hành 301
Thực hiện Rider dẫn đến 109 mili giây
Đối với JavaScript, tôi sẽ sử dụng thực thi IntelliJ IDEA trong Node v14. 8. 0
Thực thi IntelliJ IDEA dẫn đến ~476 mili giây
Kết quả
Thời gian tính bằng mili giây, càng thấp càng tốt
- C. 6. 219 mili giây, ~160 mili giây
- C#. 109 mili giây, ~9 mili giây
- JS. 202 mili giây, ~5 mỗi giây
logarit
Đối với phép toán nặng hơn, hãy so sánh JavaScript, C và C# với logarit 100 triệu bằng cách sử dụng các đoạn mã sau
// C
double n;
for [int i = 0; i < 100000000; i++]
n = log[i];// C#
double n;
for [var i = 0; i < 100000000; i++]
n = Math.Log[i];// JavaScript
let ret;
for [let i = 0; i < 100000000; i++]
n = Math.log[i];
Kết quả
Thời gian tính bằng mili giây, càng thấp càng tốt
- C. 33. 563 mili giây, ~30 mili giây
- C#. 465 mili giây, ~2 mỗi giây
- JS. 947 mili giây, ~1 mỗi giây
Dân số mảng
So sánh JavaScript, C và C# với 10 triệu phép gán mảng bằng cách sử dụng các đoạn mã sau
// C
int a[10000000];
for [int i = 0; i < 10000000; i++]
a[i] = i;// C#
int[] a = new int[10000000];
for [var i = 0; i < 10000000; i++]
a[i] = i;// JavaScript
let a = new Array[10000000];
for [let i = 0; i < 10000000; i++]
a[i] = i;
Kết quả
Thời gian tính bằng mili giây, càng thấp càng tốt
- C. 3. 081 mili giây, ~325 mili giây
- C#. 21 mili giây, ~47 mỗi giây
- JS. 9 mili giây, ~111 mili giây
Lưu ý rằng việc khởi tạo mảng JavaScript ở kích thước chính xác là rất quan trọng;
Nếu mã JavaScript được viết lại mà không có kích thước mảng ban đầu
// JavaScript
let a = [];
for [let i = 0; i < 10000000; i++]
a[i] = i;
Kết quả
Thời gian tính bằng mili giây, càng thấp càng tốt
- JS [chưa được tối ưu hóa]. 270 mili giây, ~4 mili giây
Tạo số ngẫu nhiên
So sánh JavaScript, C và C# với 10 triệu thế hệ số ngẫu nhiên bằng cách sử dụng các đoạn mã sau
// C
srand[time[0]];
for [int i = 0; i < 10000000; i++]
rand[];// C#
var rand = new Random[];
for [var i = 0; i < 10000000; i++]
rand.Next[];// JavaScript
for [let i = 0; i < 10000000; i++]
Math.random[];
Kết quả
Thời gian tính bằng mili giây, càng thấp càng tốt
- C. 54. 738 mili giây, ~18 mili giây
- C#. 87 mili giây, ~12 mili giây
- JS. 69 mili giây, ~15 mili giây
nối chuỗi
So sánh JavaScript, C và C# với 1 triệu chuỗi nối bằng cách sử dụng các đoạn mã sau
// C
char* result = NULL;
size_t resultSize = 0;
FILE* stream = open_memstream[&result, &resultSize];
for [int i = 0; i < 1000000; i++]
fprintf[stream, "ab", i, i];
fclose[stream];
free[result];// C#
StringBuilder str = new StringBuilder[];
for [var i = 0; i < 1000000; i++]
str.Append["ab"];// JavaScript
let str = '';
for [let i = 0; i < 1000000; i++]
str += 'ab';
Kết quả
Thời gian tính bằng mili giây, càng thấp càng tốt
- C. 71. 243 mili giây, ~14 mili giây
- C#. 6 mili giây, ~166 mỗi giây
- JS. 48 mili giây, ~21 mili giây
C# có nhiều thao tác nối chuỗi, chẳng hạn như toán tử
// C2,
double n;
for [int i = 0; i < 100000000; i++]
n = log[i];// C#
double n;
for [var i = 0; i < 100000000; i++]
n = Math.Log[i];// JavaScript
let ret;
for [let i = 0; i < 100000000; i++]
n = Math.log[i];
// C3,
double n;
for [int i = 0; i < 100000000; i++]
n = log[i];// C#
double n;
for [var i = 0; i < 100000000; i++]
n = Math.Log[i];// JavaScript
let ret;
for [let i = 0; i < 100000000; i++]
n = Math.log[i];
// C0,
double n;
for [int i = 0; i < 100000000; i++]
n = log[i];// C#
double n;
for [var i = 0; i < 100000000; i++]
n = Math.Log[i];// JavaScript
let ret;
for [let i = 0; i < 100000000; i++]
n = Math.log[i];
// C1 hoặc phép nội suy, nhưng ở trên tận dụng
double n;
for [int i = 0; i < 100000000; i++]
n = log[i];// C#
double n;
for [var i = 0; i < 100000000; i++]
n = Math.Log[i];// JavaScript
let ret;
for [let i = 0; i < 100000000; i++]
n = Math.log[i];
// C2 để có hiệu suất cao nhất
double n;
for [int i = 0; i < 100000000; i++]
n = log[i];// C#
double n;
for [var i = 0; i < 100000000; i++]
n = Math.Log[i];// JavaScript
let ret;
for [let i = 0; i < 100000000; i++]
n = Math.log[i];
Nếu chúng ta thay thế toán tử đó bằng toán tử
// C2 như trong ví dụ JavaScript
double n;
for [int i = 0; i < 100000000; i++]
n = log[i];// C#
double n;
for [var i = 0; i < 100000000; i++]
n = Math.Log[i];// JavaScript
let ret;
for [let i = 0; i < 100000000; i++]
n = Math.log[i];
// C#
string str = "";
for [var i = 0; i < 1000000; i++]
str += "ab";
Kết quả
Thời gian tính bằng mili giây, càng thấp càng tốt
- C# [chưa tối ưu hóa]. 7. 9 phút
C cũng yêu cầu tối ưu hóa, vì sử dụng
// C4 cũng chậm
double n;
for [int i = 0; i < 100000000; i++]
n = log[i];// C#
double n;
for [var i = 0; i < 100000000; i++]
n = Math.Log[i];// JavaScript
let ret;
for [let i = 0; i < 100000000; i++]
n = Math.log[i];
// C1
double n;
for [int i = 0; i < 100000000; i++]
n = log[i];// C#
double n;
for [var i = 0; i < 100000000; i++]
n = Math.Log[i];// JavaScript
let ret;
for [let i = 0; i < 100000000; i++]
n = Math.log[i];
Thời gian tính bằng mili giây, càng thấp càng tốt
- C [chưa tối ưu hóa]. 29 giây
Sự kết luận
Không có gì từ mặt cắt ngang mỏng này phản ánh các ví dụ trong thế giới thực và có các tối ưu hóa khác có thể được xem xét tại đây
Ngay cả khái niệm về tốc độ hiệu suất cũng có thể được tranh luận, có tính đến việc mất thời gian biên dịch JIT ban đầu, khả năng tương tranh song song hoặc sự trưởng thành của các tối ưu hóa được trình biên dịch tự động áp dụng
Năm ví dụ này tập trung vào toán học và quản lý bộ nhớ, đồng thời cho thấy suy nghĩ trong quá trình thực hiện có thể ảnh hưởng đáng kể đến kết quả như thế nào