मेरे पास Conway's Game of Life का कार्यान्वयन है। समांतरता का उपयोग करके यदि संभव हो तो मैं इसे तेज करना चाहता हूं।हास्केल पैरामैप और समांतरता
life :: [(Int, Int)] -> [(Int, Int)]
life cells = map snd . filter rules . freq $ concatMap neighbours cells
where rules (n, c) = n == 3 || (n == 2 && c `elem` cells)
freq = map (length &&& head) . group . sort
parLife :: [(Int, Int)] -> [(Int, Int)]
parLife cells = parMap rseq snd . filter rules . freq . concat $ parMap rseq neighbours cells
where rules (n, c) = n == 3 || (n == 2 && c `elem` cells)
freq = map (length &&& head) . group . sort
neigbours :: (Int, Int) -> [(Int, Int)]
neighbours (x, y) = [(x + dx, y + dy) | dx <- [-1..1], dy <- [-1..1], dx /= 0 || dy /= 0]
रूपरेखा में
, पड़ोसियों, समय बिताया के 6.3% के लिए खातों इसलिए जब छोटे मैं समानांतर में यह मैप करके एक उल्लेखनीय speedup की उम्मीद।
मैं एक साधारण समारोह
main = print $ last $ take 200 $ iterate life fPent
where fPent = [(1, 2), (2, 2), (2, 1), (2, 3), (3, 3)]
के साथ परीक्षण किया और के रूप में
ghc --make -O2 -threaded life.hs
समानांतर संस्करण संकलित और
./life +RTS -N3
यह पता चला है समानांतर संस्करण धीमी है कि के रूप में यह भाग गया । क्या मैं यहाँ गलत तरीके से पैरामैप का उपयोग कर रहा हूं? क्या यह एक ऐसा मामला भी है जहां समांतरता का उपयोग किया जा सकता है?
सबसे पहले, क्या आपके कंप्यूटर में कम से कम 3 कोर हैं? दूसरा, समांतरता हमेशा कुछ ओवरहेड के साथ आता है, इसलिए यदि प्रत्येक थ्रेड द्वारा किया जा रहा काम बहुत छोटा है, तो अतिरिक्त ओवरहेड किसी भी गति-अप से अधिक होगा। – huon
मेरे पास i5-2500k है, इसलिए निश्चित रूप से 4 कोर तक उपलब्ध हैं – cdk
ध्यान दें कि आप समांतरता से एल्गोरिदम में सुधार करने से बहुत अधिक गतिशीलता प्राप्त कर सकते हैं। समय का बड़ा हिस्सा 'क्रम' और 'elem' में बिताया जाता है। इस तथ्य का उपयोग करना कि कोशिकाओं की सूची को क्रमबद्ध किया गया है (और 'fPent' को बदलना ताकि इसे क्रमबद्ध किया जा सके) आप मोटे तौर पर समय को कम कर सकते हैं। –