मुझे D के कुछ फीचर्स पसंद हैं, लेकिन अगर वे रनटाइम पेनल्टी के साथ आते हैं, तो क्या मुझे दिलचस्पी होगी?
तुलना करने के लिए, मैंने एक साधारण प्रोग्राम लागू किया जो C ++ और D. दोनों में कई छोटे वैक्टर के स्केलर उत्पादों की गणना करता है। परिणाम आश्चर्यजनक है:
- D: 18.9 s [अंतिम रनटाइम के लिए नीचे देखें]
- सी ++: 3.8 एस
क्या सी ++ वास्तव में लगभग पांच गुना तेज है या मैंने डी कार्यक्रम में गलती की है?
मैंने C ++ को g ++ -O3 (gcc-snapshot 2011-02-19) और D के साथ dmd -O (dmd 2.052) एक मध्यम हाल के लिनक्स डेस्कटॉप पर संकलित किया। परिणाम कई रन और मानक विचलन नगण्य पर प्रतिलिपि प्रस्तुत करने योग्य हैं।
यहाँ 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;
}और यहाँ डी संस्करण:
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;
}
आप सरणी / वेक्टर आपरेशन का उपयोग कर कोड को फिर से लिखने की कोशिश कर सकते digitalmars.com/d/2.0/arrays.html
—
मीकल Minich
एक बेहतर तुलना प्रदान करने के लिए आपको समान संकलक बैक-एंड का उपयोग करना चाहिए। या तो DMD और DMC ++ या GDC और G ++
—
he_the_great
आह, उस .def फ़ाइल के बारे में कभी ध्यान नहीं दिया। समय .log फ़ाइल के अंदर हैं। "इसमें फ़ंक्शंस की सूची होती है, जिस क्रम में लिंकर को उन्हें लिंक करना चाहिए" - हो सकता है कि ऑप्टिक्लिंक किसी चीज़ को ऑप्टिमाइज़ करने में मदद करता हो? यह भी ध्यान दें कि "इसके अलावा, ld मानक" * .def "फाइलों का पूरी तरह से समर्थन करता है, जो कि ऑब्जेक्ट फाइल की तरह लिंकर कमांड लाइन पर निर्दिष्ट किया जा सकता है" - इसलिए आप ट्रेस पास कर सकते हैं। यदि आप प्रिय चाहते हैं तो -L से गुजरें। सेवा।
—
Trass3r
avg = avg / N*N(संचालन का क्रम)।