Tôi thích một số tính năng của D, nhưng sẽ thích thú nếu chúng đi kèm với hình phạt thời gian chạy?
Để so sánh, tôi đã thực hiện một chương trình đơn giản tính toán các sản phẩm vô hướng của nhiều vectơ ngắn cả trong C ++ và D. Kết quả thật đáng ngạc nhiên:
- D: 18,9 s [xem bên dưới để biết thời gian chạy cuối cùng]
- C ++: 3,8 giây
C ++ thực sự nhanh gấp gần năm lần hay tôi đã mắc lỗi trong chương trình D?
Tôi đã biên dịch C ++ với g ++ -O3 (gcc-snapshot 2011/02/19) và D với dmd -O (dmd 2.052) trên máy tính để bàn linux vừa phải. Các kết quả có thể lặp lại qua nhiều lần chạy và độ lệch chuẩn không đáng kể.
Đây là chương trình C ++:
#include <iostream>
#include <random>
#include <chrono>
#include <string>
#include <vector>
#include <array>
typedef std::chrono::duration<long, std::ratio<1, 1000>> millisecs;
template <typename _T>
long time_since(std::chrono::time_point<_T>& time) {
long tm = std::chrono::duration_cast<millisecs>( std::chrono::system_clock::now() - time).count();
time = std::chrono::system_clock::now();
return tm;
}
const long N = 20000;
const int size = 10;
typedef int value_type;
typedef long long result_type;
typedef std::vector<value_type> vector_t;
typedef typename vector_t::size_type size_type;
inline value_type scalar_product(const vector_t& x, const vector_t& y) {
value_type res = 0;
size_type siz = x.size();
for (size_type i = 0; i < siz; ++i)
res += x[i] * y[i];
return res;
}
int main() {
auto tm_before = std::chrono::system_clock::now();
// 1. allocate and fill randomly many short vectors
vector_t* xs = new vector_t [N];
for (int i = 0; i < N; ++i) {
xs[i] = vector_t(size);
}
std::cerr << "allocation: " << time_since(tm_before) << " ms" << std::endl;
std::mt19937 rnd_engine;
std::uniform_int_distribution<value_type> runif_gen(-1000, 1000);
for (int i = 0; i < N; ++i)
for (int j = 0; j < size; ++j)
xs[i][j] = runif_gen(rnd_engine);
std::cerr << "random generation: " << time_since(tm_before) << " ms" << std::endl;
// 2. compute all pairwise scalar products:
time_since(tm_before);
result_type avg = 0;
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j)
avg += scalar_product(xs[i], xs[j]);
avg = avg / N*N;
auto time = time_since(tm_before);
std::cout << "result: " << avg << std::endl;
std::cout << "time: " << time << " ms" << std::endl;
}Và đây là phiên bản D:
import std.stdio;
import std.datetime;
import std.random;
const long N = 20000;
const int size = 10;
alias int value_type;
alias long result_type;
alias value_type[] vector_t;
alias uint size_type;
value_type scalar_product(const ref vector_t x, const ref vector_t y) {
value_type res = 0;
size_type siz = x.length;
for (size_type i = 0; i < siz; ++i)
res += x[i] * y[i];
return res;
}
int main() {
auto tm_before = Clock.currTime();
// 1. allocate and fill randomly many short vectors
vector_t[] xs;
xs.length = N;
for (int i = 0; i < N; ++i) {
xs[i].length = size;
}
writefln("allocation: %i ", (Clock.currTime() - tm_before));
tm_before = Clock.currTime();
for (int i = 0; i < N; ++i)
for (int j = 0; j < size; ++j)
xs[i][j] = uniform(-1000, 1000);
writefln("random: %i ", (Clock.currTime() - tm_before));
tm_before = Clock.currTime();
// 2. compute all pairwise scalar products:
result_type avg = cast(result_type) 0;
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j)
avg += scalar_product(xs[i], xs[j]);
avg = avg / N*N;
writefln("result: %d", avg);
auto time = Clock.currTime() - tm_before;
writefln("scalar products: %i ", time);
return 0;
}
Bạn có thể thử viết lại mã bằng cách sử dụng các hoạt động mảng / vector digitalmars.com/d/2.0/arrays.html
—
Michal Minich
Để cung cấp một so sánh tốt hơn, bạn nên sử dụng cùng một trình biên dịch back-end. DMD và DMC ++ hoặc GDC và G ++
—
he_the_great
Ah, không bao giờ quan tâm đến tập tin .def mà nó phun ra. Thời gian nằm trong tệp .log. "Nó chứa danh sách các hàm theo thứ tự trình liên kết sẽ liên kết chúng" - có lẽ điều đó giúp optlink tối ưu hóa một cái gì đó? Cũng lưu ý rằng "Ngoài ra, ld hỗ trợ đầy đủ các tệp" * .def "tiêu chuẩn, có thể được chỉ định trên dòng lệnh của trình liên kết như tệp đối tượng" - vì vậy bạn có thể thử truyền dấu vết.def qua -L nếu bạn muốn đến.
—
Trass3r
avg = avg / N*N(thứ tự các hoạt động).