मैं एक माइक्रोकंट्रोलर के लिए सी में एक एफएफटी एल्गोरिदम पर काम कर रहा हूं, और यह तय करने में परेशानी हो रही है कि इनपुट डेटा के वास्तविक और काल्पनिक हिस्सों को केवल स्ट्रक्चर की एक सरणी में संग्रहीत किया जाना है, या पॉइंटर्स को स्ट्रक्चर की सरणी में उपयोग करना है या नहीं। मुझे परस्पर विरोधी आवश्यकताओं का सामना करना पड़ रहा है कि कोड को थोड़ी मात्रा में मेमोरी में चलाना है, और फिर भी जितना संभव हो उतना तेज़ होना चाहिए। मेरा मानना ​​​​है कि पॉइंटर्स टू स्ट्रक्चर्स की सरणी में कुछ हद तक बड़ी मेमोरी ओवरहेड होगी, लेकिन मेरे कोड में मूल रूप से निम्न की तरह एक पंक्ति है:

for (uint8_t i = 0; i < RECORD_SIZE; i++)
{
    uint8_t decimateValue = fft_decimate(i);
    fftData[i]->realPart = fftTempData[decimateValue]->realPart;
    fftData[i]->imPart = fftTempData[decimateValue]->imPart;
}

मैं सोच रहा हूं कि यदि मैं उपरोक्त उदाहरण के रूप में पॉइंटर्स की एक सरणी का उपयोग करता हूं तो संकलित कोड तेज़ होगा क्योंकि यह वास्तव में दो डेटा संरचनाओं के बीच सभी डेटा को एक सरणी के रूप में कॉपी करने के बजाय पॉइंटर्स को फिर से बदल रहा है- ऑफ-स्ट्रक्चर कार्यान्वयन होगा। यदि कोड का उपरोक्त भाग जितनी जल्दी हो सके चलता है, तो मैं कुछ अतिरिक्त मेमोरी का त्याग करने को तैयार हूं। किसी भी सलाह के लिए धन्यवाद।

0
Bitrex 1 जुलाई 2011, 01:36

4 जवाब

सबसे बढ़िया उत्तर

हर बार जब आप पॉइंटर्स की एक सरणी के माध्यम से डेटा एक्सेस करते हैं, तो आपके पास दो मेमोरी एक्सेस होते हैं। यह अक्सर एक पाइपलाइन स्टॉल के साथ आता है, यहां तक ​​कि माइक्रोकंट्रोलर पर भी (जब तक कि यह बिना पाइपलाइन वाला वास्तव में छोटा माइक्रोकंट्रोलर न हो)।

फिर आपको डेटा के आकार पर विचार करना होगा। एक सूचक कितना बड़ा है? 2 बाइट्स? 4 निवाले? संरचनाएं कितनी बड़ी हैं? 4 निवाले? 8 बाइट्स?

यदि संरचना एक सूचक के रूप में दोगुनी बड़ी है, तो डेटा को शफल करना पॉइंटर्स के साथ आधा महंगा होगा। हालांकि, डेटा को किसी अन्य तरीके से पढ़ना या संशोधित करना अधिक महंगा होगा। तो यह इस बात पर निर्भर करता है कि आपका प्रोग्राम क्या करता है। यदि आप डेटा को पढ़ने में बहुत समय व्यतीत करते हैं और इसे थोड़ा सा फेरबदल करते हैं, तो डेटा को पढ़ने के लिए अनुकूलित करें। अन्य लोगों के पास यह अधिकार है -- प्रोफ़ाइल। अपने माइक्रोकंट्रोलर पर प्रोफाइल करना सुनिश्चित करें, अपने वर्कस्टेशन पर नहीं।

3
Dietrich Epp 1 जुलाई 2011, 01:49

यदि आपके स्ट्रक्चर बहुत छोटे हैं, तो वास्तव में स्ट्रक्चर्स की एक सरणी होना और उन्हें चारों ओर फेरबदल करना तेज़ होगा। यदि आपकी संरचनाएं बड़ी हैं, तो यह विशिष्ट क्रिया तेज होगी यदि आप केवल पॉइंटर्स के आसपास फेरबदल कर रहे हैं।

एक मिनट रुकिए... दूसरी नज़र में, यह आपके कोड में प्रतीत होता है कि आप पॉइंटर्स के आसपास फेरबदल नहीं कर रहे हैं, लेकिन आप उन स्ट्रक्चर्स के फ़ील्ड्स तक पहुँच रहे हैं जो उन पॉइंटर्स को संदर्भित करते हैं; असल में आप अभी भी स्ट्रक्चर्स को स्वयं घुमा रहे हैं, पॉइंटर्स नहीं। यह मूविंग पॉइंटर्स की तुलना में धीमा होने वाला है और सिर्फ मूविंग स्ट्रक्चर्स की तुलना में धीमा है क्योंकि इसे पॉइंटर्स को डिफरेंस करना है और फिर भी स्ट्रक्चर को मूव करना है।

2
Loduwijk 1 जुलाई 2011, 01:46

तुम सही कह रही हो। पॉइंटर्स की सरणी तेज़ होगी, लेकिन मेमोरी उपयोग में ओवरहेड होगा। यदि पॉइंटर्स का उपयोग करने के लिए स्मृति है, तो उनका उपयोग करें।

0
Vitor 1 जुलाई 2011, 01:39

पहला: यह निर्भर करता है। प्रोफाइल।

कैशे इलाके यहां राज करने जा रहा है। मुझे उम्मीद है कि संरचनाएं बहुत छोटी होंगी (जटिल संख्याओं का प्रतिनिधित्व?) एफएफटी में मैं वास्तविक और काल्पनिक भागों को अलग-अलग सरणी में संग्रहीत करने से बहुत अधिक लाभ की अपेक्षा करता हूं।

फिर आप लोड को CPU कोर के बीच विभाजित कर सकते हैं।

यदि यह बड़े हिस्से (1024 नमूना ब्लॉक कहें) के बारे में है, तो मुझे दृढ़ता से संदेह है कि शफलिंग पॉइंटर्स अधिक कुशल हैं। यह आपको कई थ्रेड्स से समान (केवल पढ़ने के लिए) डेटा पर काम करने की अनुमति भी देगा - और अधिक आसानी से। मेमोरी को इधर-उधर ले जाना बहुत सारे इटरेटर्स को अमान्य करने का एक निश्चित तरीका है, और आमतौर पर आप अपने डेटा की एक सबरेंज पर काम करने के लिए कार्य (यानी थ्रेड्स) चाहते हैं, यानी: उनके पास एक इटरेटर सबरेंज है।

0
sehe 1 जुलाई 2011, 01:46