हास्केल में समानांतर "कोई" या "सभी"

Question

एक पैटर्न जो अब मैं कई बार आ चुका हूं, वह है जहां मूल्यों की एक सूची की जांच की जाती है ताकि उस पर कुछ परीक्षण मैप करके और यह देखा जा सके कि कोई भी या सभी तत्व पारित हो गए हैं या नहीं। विशिष्ट समाधान सिर्फ सुविधाजनक अंतर्निहित इन्स का उपयोग करना है allऔर any।

समस्या यह है कि ये सीरियल में मूल्यांकन करते हैं। कई मामलों में यह बहुत तेजी से मूल्यांकन करने की प्रक्रिया के साथ समानांतर होगा कि कोई भी धागा एक "गलत" allया "सच" के लिए एक बार पूरा हो जाए any। मुझे पूरा यकीन है कि नियंत्रण के उपयोग से शॉर्ट-सर्कुलेटिंग व्यवहार को लागू नहीं किया जा सकता है। समानांतर के रूप में इसे अंतर-प्रक्रिया संचार की आवश्यकता होती है और मैं इसे नियंत्रित करने के लिए नियंत्रण के पर्याप्त कहीं भी नहीं समझता हूं।

यह गणित में एक बहुत ही सामान्य पैटर्न है (उदाहरण के लिए मिलर-राबिन प्रेमलिटी) तो मुझे ऐसा लगता है कि कोई व्यक्ति शायद इसके लिए पहले से ही एक समाधान के साथ आया है, लेकिन स्पष्ट कारणों से "समानांतर या / और / किसी भी / सभी के लिए एक Google खोज कर रहा है haskell "कई प्रासंगिक परिणाम नहीं लौटाता है।

Comments

आपको हास्केल उपयोगी, विशेष रूप से अध्याय 2 , 3 और 4 में समानांतर और समवर्ती प्रोग्रामिंग मिल सकती है ।

— राजपूत

यह unambपुस्तकालय के साथ संभव है

— लूकी

@luqui आकर्षक; मैं इसके साथ खिलवाड़ करूंगा। अगर मैं एक अच्छा समानांतर सभी / किसी के साथ लिखता हूं तो मैं इसे उत्तर के रूप में पोस्ट करूंगा।

— आर्कुटेक

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

— चेपनर

@chepner आप किस बारे में बात कर रहे हैं? हम यहाँ बकवास के बारे में बात नहीं कर रहे हैं! हम थ्रेड के साथ समवर्ती और समानांतरवाद कर सकते हैं (यह pthreadsसी या ग्रीन थ्रेड्स हास्केल में हो) आप समवर्ती वेब अनुरोधों को संभालने के लिए कई webservers शुरू करते हैं, इसके बजाय आप एक प्रक्रिया में कई थ्रेड चलाते हैं! समतावाद पर भी लागू होता है। आप CPU के जितने भी धागे हैं, उतने स्पिन करें और अपने काम को समान रूप से विभाजित करें, इस प्रकार CPU बाध्य कार्यों का ध्यान रखें। अपने आप को समझाने के लिए इस लाइब्रेरी को आज़माएं github.com/lehins/haskell-scheduler

— lehins

Answer 1

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

import Control.Concurrent
import Control.Parallel.Strategies
import Data.Int
import System.Mem

lcgs :: Int32 -> [Int32]
lcgs = iterate lcg
  where lcg x = 1664525 * x + 1013904223

hasWaldo :: Int32 -> Bool
hasWaldo x = waldo `elem` take 40000000 (lcgs x)

waldo :: Int32
waldo = 0

main :: IO ()
main = do
  print $ or (map hasWaldo [1..100] `using` parList rseq)

यह waldo = 040 मिलियन नंबरों की 100 PRNG स्ट्रीम के आउटपुट में (जो कभी नहीं मिलेगा) खोज करने के लिए एक समानांतर सूची रणनीति का उपयोग करता है । इसे संकलित करें और चलाएं:

ghc -threaded -O2 ParallelAny.hs
./ParallelAny +RTS -s -N4

और यह लगभग 16 एस के लिए चार कोर खूंटे, अंततः मुद्रण False। आंकड़ों में ध्यान दें कि सभी 100 स्पार्क "रूपांतरित" हैं और इसलिए पूरा होने पर चलते हैं:

SPARKS: 100(100 converted, 0 overflowed, 0 dud, 0 GC'd, 0 fizzled)

अब, waldoउस मूल्य में परिवर्तन करें जो जल्दी मिल सकता है:

waldo = 531186389   -- lcgs 5 !! 50000

और mainधागे को 10 सेकंड तक जीवित रखने के लिए संशोधित करें:

main :: IO ()
main = do
  print $ or (map hasWaldo [1..100] `using` parList rseq)
  threadDelay 10000000

आप देखेंगे कि यह Trueलगभग तुरंत प्रिंट करता है , लेकिन 4 कोर 100% सीपीयू पर (कम से कम थोड़ी देर के लिए) पेग रहते हैं, यह दिखाते हुए कि अनावश्यक कम्प्यूटेशंस चलते रहते हैं और कम-सर्कुलेट नहीं होते हैं, ठीक वैसे ही जैसे आपको डर था।

लेकिन , चीज़ें बदल अगर आप इस सवाल का जवाब मिलने के बाद ही एक कचरा संग्रहण के लिए मजबूर:

main :: IO ()
main = do
  print $ or (map hasWaldo [1..100] `using` parList rseq)
  performGC
  threadDelay 10000000

अब, आप देखेंगे कि मुद्रण के तुरंत बाद सीपीयू बेकार हो जाता है True, और आंकड़े बताते हैं कि अधिकांश गणनाएं पहले से पहले कचरा थीं:

SPARKS: 100(9 converted, 0 overflowed, 0 dud, 91 GC'd, 0 fizzled)

यथार्थवादी कार्यक्रमों में, एक स्पष्ट performGCकी आवश्यकता नहीं होगी, क्योंकि जीसी को नियमित रूप से निश्चित रूप से किया जाएगा। उत्तर पाए जाने के बाद कुछ अनावश्यक संगणनाएँ चलती रहेंगी, लेकिन कई यथार्थवादी परिदृश्यों में, अनावश्यक संगणना का अंश विशेष रूप से महत्वपूर्ण कारक नहीं होगा।

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