हास्केल नियंत्रण में रणनीति कैसे बनाएं। समानांतर। रणनीतियां?

Question

अद्यतन: मुझे अभी this documentation page मिला है। इच्छा है कि the documentation that I'd been using से इसका एक लिंक था, जो कि निश्चित API दस्तावेज़ था। लेकिन शायद यह एक नया, अप्रकाशित काम है।

अपडेट 2: इस दस्तावेज़ ने मुझे नियंत्रण। पैरालेल.ट्रेटीज मॉड्यूल का उपयोग करने के बारे में बहुत बेहतर विचार दिया है। हालांकि मैंने समस्या को हल नहीं किया है ... प्रश्न का अंत देखें।

मैं parListChunk या हास्केल में कुछ अन्य समांतर नियंत्रण सुविधाओं का उपयोग करने का प्रयास कर रहा हूं। लेकिन मैं यह नहीं समझ सकता कि उनका उपयोग कैसे किया जाए। चेतावनी: मैं एक हास्केल नोब हूँ। मैंने लगभग 20 साल पहले (!) योजना के साथ कार्यात्मक प्रोग्रामिंग के बारे में कुछ बातें सीखीं।

possibKs n r = [ (k, (hanoiRCountK n k r)) | k <- [1 .. n-1] ] 

मैं इसे parallelize करने, इस भोली प्रयास की तरह कुछ चाहते हैं:

यहाँ मेरी गैर parallelized समारोह है

possibKs n r 
    | n < parCutoff = results 
    | otherwise  = parListChunk parChunkSize results 
    where results = [ (k, (hanoiRCountK n k r)) | k <- [1 .. n-1] ] 

लेकिन उस संरचना parListChunk के लिए सही नहीं है। डॉक्स कहते हैं:

parListChunk :: Int -> Strategy a -> Strategy [a] 

parListChunk sequentially applies a strategy to chunks (sub-sequences) of a list in parallel. Useful to increase grain size

अच्छा, कि मैं क्या चाहते हो। लेकिन इसका उपयोग कैसे करें? मैं इसके किसी भी उदाहरण को खोजने में सक्षम नहीं हूं। अगर मैं प्रकार की घोषणा को समझ रहा हूं, तो parListChunk एक ऐसा फ़ंक्शन है जो Int और Strategy<a> लेता है (यह देखने में सहायता के लिए सी ++ पैरामीट्रिज्ड टाइप नोटेशन उधार लेता है कि मैं वास्तव में इस अधिकार को समझ रहा हूं), और Strategy<[a]> देता है। मेरे मामले में मैं Int से a के लिए काम कर रहा हूं, इसलिए parListChunk को Int तर्क और Strategy<Int> की आवश्यकता होगी। तो Strategy क्या है और मैं एक कैसे उत्पन्न करूं? और एक बार जब मैंने सफलतापूर्वक parListChunk का उपयोग किया है, तो मैं Strategy के साथ क्या करूँगा यह थूकता है?

Strategy type is defined इस तरह:

type Strategy a = a -> Done 

(। और वह सभी रणनीति के लिए दस्तावेज़ है) तो एक Strategy<Int> एक समारोह है कि हो गया प्रकार इंट और रिटर्न का एक पैरामीटर लेता है। स्पष्ट रूप से यह एक निश्चित समय या कुछ पर मूल्यांकन करने के लिए अपने तर्क का कारण बनता है। मुझे एक कहां मिल सकता है, और मुझे किस प्रकार का उपयोग करना चाहिए?

निम्नलिखित कार्य रणनीतियाँ वापस जाने के लिए दिखाई देते हैं:

sPar :: a -> Strategy b 
sSeq :: a -> Strategy b 
r0 :: Strategy a 
rwhnf :: Strategy a 

लेकिन उनमें से कोई भी आप प्रकार पैरामीटर का निर्धारण करते हैं - वे एक Strategy<b> उत्पादन जब आप पैरामीटर a देना, वरना आप की आपूर्ति करने नहीं मिलता पैरामीटर a! उसके साथ क्या है?? इसके अलावा, मुझे नहीं पता कि इसका क्या मतलब है।

return . maximum $ map optimize xs `using` parList 

यह इस फंकी using समारोह है, जो घोषित किया जाता है का उपयोग करता है:

using :: a -> Strategy a -> a 

पर्याप्त मेले ... मेरे मामले में

मैं इतने पर समान कार्य parList being used का एक उदाहरण मिला मुझे शायद a[Int] होना चाहिए, इसलिए यह इन्ट्स और Strategy<[Int]> की एक सूची लेता है और (कुछ करता है? सूची में रणनीति लागू करता है? और) इन्ट्स की एक सूची देता है। इसलिए मैं parList उदाहरण का अनुसरण करने की कोशिश की और करने के लिए अपने otherwise गार्ड बदल दिया है:

| otherwise  = results `using` parListChunk parChunkSize 

लेकिन मैं मानता चाहिए मैं अभी भी अंधेरे में शूटिंग कर रहा हूँ ... मैं काफी प्रकार हस्ताक्षर के आसपास का पालन नहीं कर सकते हैं। तो यह भी आश्चर्य की बात नहीं है कि इसके बाद के संस्करण एक त्रुटि देता है:

Couldn't match expected type `[(Int, Integer)]' 
     against inferred type `a -> Eval a' 
Probable cause: `parListChunk' is applied to too few arguments 
In the second argument of `using', namely 
    `parListChunk parChunkSize' 
In the expression: results `using` parListChunk parChunkSize 

कोई मुझे बता सकते हैं कि parListChunk को Strategy a तर्क के लिए उपयोग करने के लिए? और parlistChunk द्वारा Strategy [a] का उपयोग कैसे करें?

न्यू हिस्सा

Basic Strategies को देखते हुए, मुझे लगता है मैं rseq रणनीति का उपयोग करने की आवश्यकता है लगता है। शायद। तो मैं

| otherwise  = results `using` (parListChunk parChunkSize rseq) 

लेकिन जीएचसी का कहना है कि आरएसईसी "दायरे में नहीं है"। These API docs कहता है कि पैकेज में कोई आरएसईसी नहीं है लेकिन एससीईक ने इसे बदल दिया है। ठीक है, इसलिए मैंने एसएसईक का इस्तेमाल किया, लेकिन यह "दायरे में नहीं" है। भले ही मैं Control.Parallel.Strategies आयात कर रहा हूं।

कोई सुराग? Btw मैं लोड हो रहा है पैकेज के बारे में इन संदेशों को प्राप्त करने के लिए प्रयोग किया है:

Loading package deepseq-1.1.0.0 ... linking ... done. 
Loading package parallel-2.2.0.1 ... linking ... done. 

तो जाहिरा तौर पर बताता है कि समानांतर पैकेज का कौन सा संस्करण मेरे पास है: 2.2.0.1। लेकिन मुझे API docs में जानकारी दिखाई नहीं दे रही है कि किस संस्करण का वर्णन किया गया है। अगर मुझे आरएसईसी या एसएसईक का उपयोग नहीं करना चाहिए, तो मुझे क्या उपयोग करना चाहिए? कैसे Edward पैरालिस्ट का उपयोग करने में सक्षम था?

Answer 1

ठीक है, मुझे कोड काम कर रहा है। मैं इसे rwhnf बजाय rseq का उपयोग करके संकलित करने के लिए मिल गया:

| otherwise  = results `using` (parListChunk parChunkSize rwhnf) 

this source code के अनुसार, rwhnf संस्करण 3. में rseq को नाम दिया गया था तो मुझे लगता है कि समानांतर पैकेज की मेरी संस्करण this documentation के संबंध में अप्रचलित है। : -एस

मुझे लगता है कि यह "प्रयोगात्मक" पैकेजों का उपयोग करने की कीमत का हिस्सा है।

वैसे भी, कोड संकलित और चलाता है। चाहे वह समांतरता के साथ कुछ भी उपयोगी कर रहा हो, एक और सवाल है ...