सी ++ में 'फॉर' लूप को टेम्पलेट करना?

Question

मैं एक सी ++ एक रन-टाइम for पाश के साथ नीचे स्निपेट

for(int i = 0; i < I; i++) 
    for (int j = 0; j < J; j++) 
    A(row(i,j), column(i,j)) = f(i,j); 

टुकड़ा बार-बार कहा जाता है। लूप सीमा 'I' और 'J' संकलन समय पर ज्ञात हैं (I/J 2 से 10 का क्रम है)। मैं किसी भी तरह टेम्पलेट का उपयोग कर लूप को अनलॉक करना चाहता हूं। मुख्य बाधा पंक्ति() और कॉलम() और एफ() फ़ंक्शंस है। मैं उन्हें row<i,j>::enum चाल का उपयोग करके संकलित समय पर मूल्यांकन किए गए समकक्ष मेटाप्रोग्राम के साथ प्रतिस्थापित करना चाहता हूं। - बहुत ज्यादा for संरचना

A(12,37) = 0.5; 
A(15,23) = 0.25; 
A(14,45) = 0.25; 

लेकिन मैं for नष्ट किए बिना ऐसा करना चाहते हैं:

क्या मैं सच में अच्छा लगेगा कुछ है कि अंततः जैसे बयानों के अनुक्रम में पाश का समाधान करता है। की भावना में कुछ:

TEMPLATE_FOR<i,0,I> 
    TEMPLATE_FOR<j,0,J> 
    A(row<i,j>::value, column<i,j>::value) = f<i,j>::value 

बढ़ा सकता है :: लैम्ब्डा (या कुछ और) इसे बनाने में मेरी सहायता करें?

Answer 1

Template Metaprograms और bubble sort कार्यान्वयन देखें।

Answer 2

एक अच्छा कंपाइलर आपके लिए अनोल करना चाहिए। उदाहरण के लिए, -ओ 2 विकल्प के साथ संकलित जीसीसी में लूप अनोलिंग चालू हो जाता है।

यदि आप इसे स्वयं मैन्युअल रूप से करने का प्रयास करते हैं, जब तक कि आप चीजों को ध्यान से मापते हैं और वास्तव में जानते हैं कि आप क्या कर रहे हैं, तो आप धीमे कोड के साथ समाप्त होने के लिए उत्तरदायी हैं। उदाहरण के लिए, मैन्युअल अनलोलिंग के साथ आपके मामले में आप संकलक को लूप इंटरचेंज या स्ट्रिपमाइन ऑप्टिमाइज़ेशन (फ्लाईओप-इंटरचेंज और -फ्लूप-स्ट्रिप-खान the gcc docs में देखें)

Answer 3

आप को रोकने के लिए सक्षम हैं Boost MPL का उपयोग कर सकते हैं।

लूप अनोलिंग का एक उदाहरण इस mpl::for_each page पर है।

for_each< range_c<int,0,10> >(value_printer()); 

ऐसा प्रतीत नहीं होता कि यह संकलन समय पर सभी का मूल्यांकन किया गया है, लेकिन यह एक अच्छा प्रारंभिक बिंदु हो सकता है।

Answer 4

मैं कहूंगा कि यह एक झूठा अच्छा विचार है।

C++ में इस: row<i,j>::value
का मतलब है की तुलना में आप मैं j * आप के रूप में कई विभिन्न row<>() कार्यों होगा। आप इसे नहीं चाहते हैं क्योंकि यह कोड के आकार को बढ़ाएगा और बहुत सारे निर्देश कैश मिस करेगा।

मैंने यह देखा कि जब मैं एक एकल बूलियन चेक से बचने के लिए टेम्पलेट फ़ंक्शन कर रहा था।

यदि कोई छोटा कार्य है तो इसे केवल इनलाइन करें।

Answer 5

आप बूस्ट.एमपीएल का उपयोग संकलन-समय पर पूरी चीज़ को लागू करने के लिए कर सकते हैं, लेकिन मुझे यकीन नहीं है कि यह तेज़ होगा।(एमपीएल अनिवार्य रूप से फिर से लागू सभी एसटीएल एल्गोरिदम संकलन समय metaprogramming टेम्पलेट के रूप में)

कि दृष्टिकोण के साथ समस्या यह है कि आप unrolling और इनलाइन किए जाने वाले एक बहुत कोड के, अनुदेश कैश पिटाई और खा सकता है जो अंत है स्मृति बैंडविड्थ जो सहेजा जा सकता था। यह विशाल, सूजन और धीमी कोड उत्पन्न कर सकता है।

शायद मैं संकल्प को समझने के लिए संकलक पर भरोसा करता हूं। जब तक row और column फ़ंक्शन परिभाषाएं लूप से दिखाई देती हैं, तो संकलक कॉल को इनलाइन कर सकते हैं और कई पुनरावृत्तियों को अनलोल कर सकते हैं क्योंकि यह फायदेमंद लगता है।

Answer 6

मैं टेम्पलेट मेटा प्रोग्रामिंग का प्रशंसक नहीं हूं, इसलिए आप इस जवाब को नमक के चुटकी से लेना चाहेंगे। लेकिन, इससे पहले कि मैं इस समस्या पर निवेश किसी भी समय, मैं खुद से पूछना चाहते हैं निम्नलिखित:

1. मेरी for पाश एक टोंटी है?
2. क्या यह कोई फर्क नहीं पड़ता है? हाथ से अनियंत्रित और मापने से आसानी से परीक्षण किया जाता है।

कई कंपाइलर्स/सीपीयू में, "looped" संस्करण कैश प्रभावों के कारण बेहतर प्रदर्शन दे सकता है।

याद रखें: पहले मापें, बाद में अनुकूलित करें - अगर बिल्कुल।

Answer 7

f को double वापस करने की आवश्यकता होगी - जो संकलन समय पर नहीं किया जा सकता है।

Answer 8

आप वाक्य रचना को संशोधित करने के इच्छुक हैं, तो थोड़ा तुम कुछ इस तरह कर सकते हैं:

template <int i, int ubound> 
struct OuterFor { 
    void operator()() { 
     InnerFor<i, 0, J>()(); 
     OuterFor<i + 1, ubound>()(); 
    } 
}; 

template <int ubound> 
struct OuterFor <ubound, ubound> { 
    void operator()() { 
    } 
}; 

InnerFor में, मैं बाहरी छोरों काउंटर है (समय निरंतर संकलन), जे भीतरी छोरों काउंटर है (प्रारंभ में 0 - समय स्थिर भी संकलित करें), ताकि आप एक संकलन समय टेम्पलेट के रूप में पंक्ति का मूल्यांकन कर सकें।

यह थोड़ा और जटिल है, लेकिन जैसा कि आप कहते हैं, पंक्ति(), col(), और f() आपके जटिल भाग हैं। कम से कम इसे आज़माएं और देखें कि प्रदर्शन इसके लायक है या नहीं। अपनी पंक्ति(), आदि कार्यों को सरल बनाने के लिए अन्य विकल्पों की जांच करना इसके लायक हो सकता है।

Answer 9

मुझे क्या करना यह इतना को एक अलग नज़रिए के साथ इस विचार लेने की कोशिश की कभी नहीं किया है ...

यह आप Boost.Preprocessor इस्तेमाल कर सकते हैं जैसे पाश unrolling (विशेष रूप से BOOST_PP_FOR और BOOST_PP_FOR_r मैक्रो) कर रहा है और उसके बाद वास्तविक निरंतर अभिव्यक्ति उत्पन्न करने के लिए टेम्पलेट का उपयोग करें।

template <int i, int j> 
struct inner 
{ 
    static void value() 
    { 
    A(row<i,j>::value, column<i,j>::value) = f<i,j>::value; 
    inner<i, j+1>::value(); 
    } 
}; 

template <int i> struct inner<i, J> { static void value() {} }; 

template <int i> 
struct outer 
{ 
    static void value() 
    { 
    inner<i, 0>::value(); 
    outer<i+1>::value(); 
    } 
}; 

template <> struct outer<I> { static void value() {} }; 

void test() 
{ 
    outer<0>::value(); 
} 

आप के माध्यम से पारित कर सकते हैं Avalue रों यदि आवश्यक हो तो से प्रत्येक के लिए एक पैरामीटर के रूप:

Answer 10

इस तरह यह सीधे करना है।

#include <utility> 

template <int j, class Columns> 
struct Inner; 

template <class Columns, class Rows> 
struct Outer; 

template <int j, int... i> 
struct Inner<j, std::index_sequence<i...>> 
{ 
    static void value() { (A(column<i, j>::value, row<i, j>::value), ...); } 
}; 


template <int... j, class Columns> 
struct Outer<std::index_sequence<j...>, Columns> 
{ 
    static void value() { (Inner<j, Columns>::value(), ...); } 
}; 

template <int I, int J> 
void expand() 
{ 
    Outer<std::make_index_sequence<I>, std::make_index_sequence<J>>::value(); 
} 

void test() 
{ 
    expand<3, 5>(); 
} 

(उत्पन्न विधानसभा के साथ झलकी: https://godbolt.org/g/DlgmEl)