मुझे एक सिमुलेशन (फोरट्रान में लिखे गए) से तापमान वितरण का प्रतिनिधित्व करने वाला 512^3 सरणी मिलता है। सरणी एक बाइनरी फ़ाइल में संग्रहीत है जो आकार में लगभग 1/2 जी है। मुझे इस सरणी के न्यूनतम, अधिकतम और माध्य को जानने की आवश्यकता है और जैसा कि मुझे जल्द ही फोरट्रान कोड को समझने की आवश्यकता होगी, मैंने इसे जाने का फैसला किया और निम्नलिखित बहुत ही आसान दिनचर्या के साथ आया।मेरे फोरट्रान दिनचर्या से कितना तेज़ हो सकता है?
integer gridsize,unit,j
real mini,maxi
double precision mean
gridsize=512
unit=40
open(unit=unit,file='T.out',status='old',access='stream',&
form='unformatted',action='read')
read(unit=unit) tmp
mini=tmp
maxi=tmp
mean=tmp
do j=2,gridsize**3
read(unit=unit) tmp
if(tmp>maxi)then
maxi=tmp
elseif(tmp<mini)then
mini=tmp
end if
mean=mean+tmp
end do
mean=mean/gridsize**3
close(unit=unit)
यह मेरे द्वारा उपयोग की जाने वाली मशीन पर लगभग 25 सेकंड प्रति फ़ाइल लेता है। यही कारण है कि मुझे नहीं बल्कि लंबे समय से किया जा रहा है के रूप में मारा और इसलिए मैं आगे चला गया और अजगर में निम्नलिखित किया:
import numpy
mmap=numpy.memmap('T.out',dtype='float32',mode='r',offset=4,\
shape=(512,512,512),order='F')
mini=numpy.amin(mmap)
maxi=numpy.amax(mmap)
mean=numpy.mean(mmap)
अब, मैं इस पाठ्यक्रम के तेजी से होने की उम्मीद है, लेकिन मैं वास्तव में उड़ा दिया गया था। यह समान स्थितियों के तहत एक सेकंड से भी कम समय लेता है। मेरा फोरट्रान दिनचर्या (जिसे मैं 128-बिट फ्लोट्स के साथ भी चलाता हूं, से एक दूसरे से विचलित होता है, इसलिए मैं इसे और अधिक भरोसा करता हूं) लेकिन केवल 7 वें महत्वपूर्ण अंक पर।
कितना तेज़ हो सकता है? मेरा मतलब है कि आपको इन मानों को खोजने के लिए किसी सरणी के प्रत्येक प्रविष्टि को देखना है, है ना? क्या मैं अपने फोरट्रान दिनचर्या में इतनी बेवकूफी कर रहा हूं कि इसमें इतना समय लगेगा?
संपादित करें:
टिप्पणी में सवालों के जवाब देने के लिए:
- हाँ, यह भी मैं 32-बिट और 64-बिट तैरता साथ फोरट्रान दिनचर्या भाग गया, लेकिन यह प्रदर्शन पर कोई प्रभाव नहीं पड़ा ।
- मैंने
iso_fortran_envका उपयोग किया जो 128-बिट फ्लोट प्रदान करता है। - 32-बिट फ्लोट का उपयोग करना मेरा मतलब काफी दूर है, इसलिए सटीकता वास्तव में एक मुद्दा है।
- मैंने अलग-अलग फ़ाइलों पर अलग-अलग फ़ाइलों पर दोनों रूटीन चलाए, इसलिए कैशिंग को तुलना में तुलना में उचित होना चाहिए था?
- मैंने वास्तव में खुले एमपी की कोशिश की, लेकिन एक ही समय में विभिन्न पदों पर फ़ाइल से पढ़ने के लिए। अपनी टिप्पणियां और उत्तर पढ़ने के बाद यह वास्तव में बेवकूफ लगता है और यह दिनचर्या को बहुत अधिक समय तक ले जाता है। मैं इसे सरणी संचालन पर आज़मा सकता हूं लेकिन शायद यह भी आवश्यक नहीं होगा।
- फ़ाइलें वास्तव में आकार में 1/2 जी हैं, जो एक टाइपो था, धन्यवाद।
- मैं अब सरणी कार्यान्वयन का प्रयास करूंगा।
संपादित करें 2:
मैं क्या @Alexander Vogt और @casey उनके जवाब में सुझाव लागू किया है, और यह जितनी जल्दी numpy के रूप में है, लेकिन के रूप में @Luaan मैं हो सकता है ने कहा अब मैं एक सटीक समस्या है प्राप्त। 32-बिट फ्लोट सरणी का उपयोग करके sum द्वारा गणना की गई औसत 20% बंद है।
...
real,allocatable :: tmp (:,:,:)
double precision,allocatable :: tmp2(:,:,:)
...
tmp2=tmp
mean=sum(tmp2)/size(tmp)
...
समस्या हल करता है लेकिन कंप्यूटिंग समय बढ़ाता है (बहुत अधिक नहीं, लेकिन ध्यान से)। क्या इस मुद्दे को हल करने का कोई बेहतर तरीका है? मुझे फ़ाइल से एकल को सीधे युगल पढ़ने का कोई तरीका नहीं मिला। और numpy इससे कैसे बचें?
अब तक सभी मदद के लिए धन्यवाद।
क्या आपने 128-बिट फ्लोट के बिना फोरट्रान रूटीन का प्रयास किया था? मुझे किसी भी हार्डवेयर से अवगत नहीं है जो वास्तव में उनको समर्थन करता है, इसलिए उन्हें सॉफ़्टवेयर में करना होगा। – user2357112
क्या होगा यदि आप एक सरणी का उपयोग करके फोरट्रान संस्करण का प्रयास करते हैं (और विशेष रूप से एक अरब के बजाय एक पढ़ने का उपयोग करते हुए)? – francescalus
क्या आपने फोरट्रान में सरणी ऑपरेटरों का उपयोग करने पर विचार किया था? फिर, आप 'minval()', 'maxval()', और 'sum()' कोशिश कर सकते हैं?इसके अलावा, आप फोरट्रान में संचालन के साथ आईओ मिश्रण कर रहे हैं, लेकिन पायथन में नहीं - यह उचित तुलना नहीं है ;-) –