'int32_t` मान के साथ मेमोरी तेज़ कैसे भरें?

Question

क्या कोई फ़ंक्शन है (एसएसईएक्स इंट्रिनिक्स ठीक है) जो स्मृति को एक निर्दिष्ट int32_t मान के साथ भर देगा?

AABBCC00AABBCC00AABBCC00AABBCC00AABBCC00 
AABBCC00AABBCC00AABBCC00AABBCC00AABBCC00 
AABBCC00AABBCC00AABBCC00AABBCC00AABBCC00 
AABBCC00AABBCC00AABBCC00AABBCC00AABBCC00 
... 

मैं std::fill या के लिए लूप सरल इस्तेमाल कर सकते हैं, लेकिन यह तेजी से पर्याप्त नहीं है: उदाहरण के लिए, जब यह मान 0xAABBCC00 के बराबर है के लिए की तरह परिणाम स्मृति दिखना चाहिए।

---

एक सदिश कार्यक्रम की शुरुआत में केवल एक बार प्रदर्शन किया रीसाइज़िंग, यह कोई मुद्दा नहीं है। बाधा स्मृति भर रहा है।

सरलीकृत कोड:

struct X 
{ 
    typedef std::vector<int32_t> int_vec_t; 
    int_vec_t buffer; 

    X() : buffer(5000000) { /* some more action */ } 
    ~X() { /* some code here */ } 

    // the following function is called 25 times per second 
    const int_vec_t& process(int32_t background, const SOME_DATA& data); 
}; 

const X::int_vec_t& X::process(int32_t background, const SOME_DATA& data) 
{ 
    // the following one string takes 30% of total time of #process function 
    std::fill(buffer.begin(), buffer.end(), background); 

    // some processing 
    // ... 

    return buffer; 
} 

Answer 1

आपके उत्तरों के लिए सभी को धन्यवाद। मैंने wj32's solution चेक किया है, लेकिन यह std::fill डू के समान समय दिखाता है।

// fill the first quarter by the usual way 
std::fill(buffer.begin(), buffer.begin() + buffer.size()/4, background); 
// copy the first quarter to the second (very fast) 
memcpy(&buffer[buffer.size()/4], &buffer[0], buffer.size()/4*sizeof(background)); 
// copy the first half to the second (very fast) 
memcpy(&buffer[buffer.size()/2], &buffer[0], buffer.size()/2*sizeof(background)); 

उत्पादन कोड एक 4 से जांच जोड़ने buffer.size() विभाज्य है और उस के लिए उपयुक्त हैंडलिंग जोड़ने की जरूरत है में: मेरे वर्तमान समाधान समारोह memcpy की मदद से 4 गुना तेजी से std::fill से (विजुअल स्टूडियो 2008 में) काम करता है ।

Answer 2

यह (कृपया इसके बारे में माइक्रोसॉफ्ट सत्ता बहाना) मैं इसे कैसे करना होगा है:

VOID FillInt32(__out PLONG M, __in LONG Fill, __in ULONG Count) 
{ 
    __m128i f; 

    // Fix mis-alignment. 
    if ((ULONG_PTR)M & 0xf) 
    { 
     switch ((ULONG_PTR)M & 0xf) 
     { 
      case 0x4: if (Count >= 1) { *M++ = Fill; Count--; } 
      case 0x8: if (Count >= 1) { *M++ = Fill; Count--; } 
      case 0xc: if (Count >= 1) { *M++ = Fill; Count--; } 
     } 
    } 

    f.m128i_i32[0] = Fill; 
    f.m128i_i32[1] = Fill; 
    f.m128i_i32[2] = Fill; 
    f.m128i_i32[3] = Fill; 

    while (Count >= 4) 
    { 
     _mm_store_si128((__m128i *)M, f); 
     M += 4; 
     Count -= 4; 
    } 

    // Fill remaining LONGs. 
    switch (Count & 0x3) 
    { 
     case 0x3: *M++ = Fill; 
     case 0x2: *M++ = Fill; 
     case 0x1: *M++ = Fill; 
    } 
} 

Answer 3

मैं पूछना: आप निश्चित रूप से std::fill प्रोफाइल है और यह प्रदर्शन बाधा साबित हुआ? मुझे लगता है कि इसे एक बहुत ही कुशल तरीके से कार्यान्वित किया जाएगा, जैसे कि कंपाइलर स्वचालित निर्देशों को स्वचालित रूप से उत्पन्न कर सकता है (उदाहरण के लिए -march जीसीसी पर)।

यदि यह बाधा है, तो अभी भी बहुत अधिक स्मृति (स्पष्ट रूप से ओवर और ओवर) स्थापित करने से बचने के लिए एल्गोरिदमिक रीडिज़ाइन (यदि संभव हो) से बेहतर लाभ प्राप्त करना संभव हो सकता है, इससे कोई फर्क नहीं पड़ता कि यह तंत्र को भरता है तुम इस्तेमाल।

Answer 4

आप उपयोग कर

vector<int32_t> myVector; 
myVector.reserve(sizeIWant); 

और फिर एसटीडी का उपयोग माना जाता है :: भरने? या शायद std::vector का कन्स्ट्रक्टर जो तर्क के रूप में लिया जाता है और वस्तुओं को शुरू करने के लिए मूल्य को तर्क देता है?

Answer 5

पूरी तरह से सुनिश्चित नहीं है कि आप पंक्ति में 4 बाइट कैसे सेट करते हैं, लेकिन यदि आप एक बार फिर से एक बाइट के साथ मेमोरी भरना चाहते हैं, तो आप memset का उपयोग कर सकते हैं। स्मृति

की

void * memset (void * ptr, int value, size_t num); 

भरण ब्लॉक निर्धारित मूल्य (एक unsigned char के रूप में व्याख्या) के लिए ptr द्वारा बताया स्मृति के ब्लॉक की पहली संख्या बाइट्स सेट करता है।

Answer 6

मान लें कि आप अपनी पृष्ठभूमि के पैरामीटर में मानों की एक सीमित मात्रा में है (या और भी बेहतर, केवल पर), हो सकता है आप एक स्थिर वेक्टर आवंटित करने के लिए प्रयास करना चाहिए, और बस memcpy का उपयोग करें।

const int32_t sBackground = 1234; 
static vector <int32_t> sInitalizedBuffer(n, sBackground); 

    const X::int_vec_t& X::process(const SOME_DATA& data) 
    { 
     // the following one string takes 30% of total time of #process function 
     std::memcpy((void*) data[0], (void*) sInitalizedBuffer[0], n * sizeof(sBackground)); 

     // some processing 
     // ... 

     return buffer; 
    } 

Answer 7

यह थोड़ा गैर पोर्टेबल हो सकता है लेकिन आप एक अतिव्यापी स्मृति प्रतिलिपि इस्तेमाल कर सकते हैं। अपने इच्छित पैटर्न के साथ पहले चार बाइट भरें और memcpy() का उपयोग करें।

int32* p = (int32*) malloc(size); 
*p = 1234; 
memcpy(p + 4, p, size - 4); 

नहीं लगता कि आप बहुत तेजी से

Answer 8

मैं सिर्फ परीक्षण किया एसटीडी प्राप्त कर सकते हैं :: पूर्ण अनुकूलन के साथ जी ++ से भरना (SSE आदि ..सक्षम):

#include <algorithm> 
#include <inttypes.h> 

int32_t a[5000000]; 

int main(int argc,char *argv[]) 
{ 
    std::fill(a,a+5000000,0xAABBCC00); 
    return a[3]; 
} 

और भीतरी पाश की तरह देखा:

L2: 
    movdqa %xmm0, -16(%eax) 
    addl $16, %eax 
    cmpl %edx, %eax 
    jne L2 

लगता 0xAABBCC00 एक्स 4 की तरह xmm0 में लोड किया गया था और एक समय में ले जाया जा रहा है 16-बाइट।

Answer 9

बनाम2013 और बनाम2015 एक सादा फॉर-लूप को rep stos निर्देश पर अनुकूलित कर सकता है। यह एक बफर भरने का सबसे तेज़ तरीका है। BTW

namespace std { 
    inline void fill(vector<int>::iterator first, vector<int>::iterator last, int value){ 
     for (size_t i = 0; i < last - first; i++) 
      first[i] = value; 
    } 
} 

: आप इस तरह अपने प्रकार के लिए std::fill निर्दिष्ट कर सकते हैं। संकलक अनुकूलन करने के लिए, बफर को सबस्क्रिप्ट ऑपरेटर द्वारा एक्सेस किया जाना चाहिए।

यह जीसीसी और क्लैंग पर काम नहीं करेगा। वे दोनों एक सशर्त कूद लूप को कोड संकलित करेंगे। यह मूल std::fill के रूप में धीमा चलता है। और हालांकि wchar_t 32-बिट है, wmemset में memset पसंद नहीं है। तो आपको अनुकूलन करने के लिए इकट्ठा कोड लिखना होगा।