अनुकूलित करना कौन सी कोडिंग शैली संकलक अनुकूलन के लिए खुद को बेहतर बनाता है? विशेष रूप से, मुझे 1 में दिलचस्पी है) अस्थायी मूल्यों की संख्या को कम करना जो तुरंत फेंक दिया जाता है और 2) स्वचालित वेक्टरेशन, यानी अंकगणितीय के लिए सिम निर्देश उत्पन्न करना।उत्परिवर्तनीय बनाम अपरिवर्तनीय वेक्टर गणित
मान लीजिए मैं इस struct है: इस struct के
#define FOR_EACH for (int i = 0; i < N; ++i)
template<typename T, unsigned N>
struct Vector {
void scale(T scalar) {
FOR_EACH v[i] *= scalar;
}
void add(const Vector<T, N>& other) {
FOR_EACH v[i] += other.v[i];
}
void mul(const Vector<T, N>& other) {
FOR_EACH v[i] *= other.v[i];
}
T v[N];
};
उदाहरण उपयोग:
Vector<int, 3> v1 = ...;
Vector<int, 3> v2 = ...;
v1.scale(10);
v1.add(v2);
v1.mul(v2);
इस परिवर्तनशील दृष्टिकोण है।
एक वैकल्पिक अपरिवर्तनीय दृष्टिकोण ऐसा दिखाई दे सकता:
template<typename T, unsigned N>
struct Vector {
Vector(const Vector<T, N>& other) {
memcpy(v, other.v, sizeof(v));
}
Vector<T, N> operator+(const Vector<T, N>& other) const {
Vector<T, N> result(*this);
FOR_EACH result.v[i] += other.v[i];
return result;
}
Vector<T, N> operator*(T scalar) const {
Vector<T, N> result(*this);
FOR_EACH result.v[i] *= scalar;
return result;
}
Vector<T, N> operator*(const Vector<T, N>& other) const {
Vector<T, N> result(*this);
FOR_EACH result.v[i] *= other.v[i];
return result;
}
T v[N];
};
उदाहरण उपयोग:
Vector<int, 3> v1 = ...;
Vector<int, 3> v2 = ...;
auto result = (v1 * 10 + v2) * v2;
अब, मैं इस सवाल में एपीआई डिजाइन के साथ संबंध नहीं हूँ। मान लें कि इस संबंध में दोनों समाधान व्यवहार्य हैं।
इसके अलावा, नमूना कोड में int के बजाय यह float या double भी हो सकता है।
मुझे यह क्या रूचि है: आधुनिक सी ++ कंपाइलर द्वारा कौन सा डिज़ाइन अधिक आसानी से विश्लेषण किया जा सकता है? मैं विशेष रूप से किसी एकल कंपाइलर को लक्षित नहीं कर रहा हूं। यदि आपके पास किसी भी कंपाइलर के साथ अनुभव है और यह पता है कि यह ऑप्टिमाइज़ेशन के साथ कैसे काम करता है, तो मैं आपके अनुभव को साझा करता हूं।
दूसरा संस्करण बहुत सारे अस्थायी मूल्य उत्पन्न करता है। क्या संकलक उनसे छुटकारा पा सकता है यदि यह आखिरकार सभी ऑपरेटर कॉलों को रेखांकित करता है और सभी अंकगणितीय अभिव्यक्तियों को भीतर देखता है? (मुझे लगता है कि कोई भी कंपाइलर बिना साइड इफेक्ट्स के कारण अस्थायी को खत्म कर सकता है)
पहला संस्करण अस्थायी की संख्या को कम करता है लेकिन सख्ती से अनुक्रमिक गणना बनाता है। क्या संकलक अभी भी इरादे को कम कर सकता है और संचालन को इस तरह से पुन: व्यवस्थित कर सकता है कि संचालन की संख्या को कम करता है और उनके समांतरता (सीपीयू निर्देश स्तर पर) की अनुमति देता है?
ऊपर के लूप को सदिश बनाने के लिए आधुनिक कंपाइलर के लिए कितना मुश्किल है?
तत्वों के प्रत्यक्ष अनुक्रमण यह आसान संकलक उन्हें vectorize करने के लिए बनाता है। जब इंडेक्स अप्रत्यक्ष रूप से जटिल एल्गोरिदम के साथ लागू होते हैं, तो संकलक विफल हो सकता है। –