जीसीसी चेतावनी का प्रभाव: टेम्पलेट तर्क पर विशेषताओं को अनदेखा करना (-विग्नर-गुण)

Question

मैं टेम्पलेट वर्ग के लिए तर्क के रूप में __m256 का उपयोग कर रहा हूं (नीचे कोड देखें)। जब उबंटू 16.10 पर जी के साथ संकलन ++ संस्करण 6.2, यह मेरे बारे में गुण टेम्पलेट तर्क पर ध्यान नहीं दिया जा चेतावनी देते हैं:

warning: ignoring attributes on template argument ‘__m256 {aka __vector(8) float}’ [-Wignored-attributes] typedef vec_array<__m256> vec256 

__m256 प्रकार संरेखण के विषय में कुछ गुण लगता है (और शायद कुछ अन्य लोगों के?)। नीचे दिखाए गए इस आदिम कंटेनर वर्ग का एकमात्र उद्देश्य (और जो चेतावनी उत्पन्न करता है) इन विशेष इंटेल चर (__m256, __m128, आदि) के लिए ढेर पर स्मृति संरेखण को संभालना है।

जब मैं अपने समग्र कार्यक्रम में इस कंटेनर क्लास का उपयोग करता हूं, तो यह ठीक काम करता प्रतीत होता है। हालांकि, मेरा सवाल यह है कि जब gcc इन विशेषताओं को अनदेखा कर रहा है तो प्रभाव यह है कि (मैंने पहले ही पढ़ा है कि इस मुद्दे पर जीसीसी मैनुअल को क्या कहना है)।

1. क्या कोई इन चेतावनियों से छुटकारा पाने का एक अच्छा तरीका देखता है?
2. क्या मुझे इसके बारे में चिंता करने की ज़रूरत है?
3. यदि मैं इस चेतावनी को अनदेखा करता हूं तो सबसे बुरा क्या हो सकता है?

संदर्भ के लिए, नीचे दिया गया कोड इस चेतावनी का उत्पादन करता है।

इस मामले पर किसी भी मदद या टिप्पणी की बहुत सराहना की जाती है, धन्यवाद।

/////////////////////////////////////////////////////////////////////////////// 
// System includes: 

#include <x86intrin.h> 
#include <cstdint> 

static const size_t AVX_alignment = 32; 

template<typename VecT> 
class vec_array 
{ 
protected: 
    VecT* m_pdata; 
    size_t m_num_vector_elements; 

public: 
    vec_array(); 
    vec_array(size_t num_vector_elements); 

    virtual ~vec_array(); 

    void allocate(size_t num_vector_elements); 
    void free(); 

}; 

template<typename VecT> 
vec_array<VecT>::vec_array() : m_pdata(nullptr), m_num_vector_elements(0) 
{} 

template<typename VecT> 
vec_array<VecT>::vec_array(size_t num_vector_elements) : m_pdata(nullptr), 
m_num_vector_elements(num_vector_elements) 
{ 
    allocate(num_vector_elements); 
} 

template<typename VecT> 
vec_array<VecT>::~vec_array() 
{ 
    free(); 
} 

template<typename VecT> 
void vec_array<VecT>::allocate(size_t num_vector_elements) 
{ 
    if(m_num_vector_elements == num_vector_elements) 
     return; 

    m_num_vector_elements = num_vector_elements; 

    free(); 

    m_pdata = reinterpret_cast<VecT*>(_mm_malloc(m_num_vector_elements*sizeof(VecT), AVX_alignment)); 
} 

template<typename VecT> 
void vec_array<VecT>::free() 
{ 
    if(m_pdata != nullptr) 
     _mm_free(m_pdata); 
} 


typedef vec_array<__m256> vec256; 

int main() 
{ 
    vec256 test_vec(10); 

} 

Answer 1

मैं एक ही चेतावनी में आया लेकिन कुछ ओपनक्ल कोड में आया और पहले कोड को देखे बिना यहां समाप्त हुआ। आप देख सकते हैं कि कुछ लोग इस चेतावनी से बचने का प्रयास कैसे करते हैं Making std::vector allocate aligned memory लेकिन मेरी राय में यह सिर्फ इसके लायक नहीं है।

संक्षिप्त उत्तर यह है कि आपको इसके बारे में चिंता करने की ज़रूरत नहीं है, सीपीयू के अलावा जो केवल 128 बिट एवीएक्स निर्देशों का समर्थन करता है। अगर चेतावनी गंभीर थी, तो सीपीयू असाइन किए गए एक्सेस पर अपवाद उत्पन्न करेगा।

यह चेतावनी प्रकट होती है क्योंकि टाइप __m256 शायद 16 बाइट्स के संरेखण विनिर्देशक के साथ घोषित किया गया है। यही कहना है कि सीपीयू वेक्टर के प्रत्येक तत्व के 16 बाइट्स के संरेखण की अपेक्षा करेगा। हालांकि, वेक्टर के लिए टेम्पलेट संरेखण विशेषता का सम्मान नहीं करता है।

मुझे लगता है कि आप, कुछ बेवकूफ करने के लिए एक

struct stupidStruct __attribute__(packed) { 
    unsigned short padding; 
    std::vector<__m256> vect; 
}; 

की तरह कोड है कि एक त्रुटि का कारण होता है निर्माण करने के लिए संकलक के लिए मजबूर करने के लिए होगा।