हास्केल में 1 मिलियन धागे बनाने में कितना समय लगता है?

Question

जो मैं समझता हूं, हास्केल के पास हरे धागे हैं। लेकिन वे कितने हल्के वजन हैं। क्या 1 मिलियन धागे बनाना संभव है?

या 100 000 धागे के लिए कितना समय लगेगा?

Answer 1

अच्छी तरह से here के अनुसार डिफ़ॉल्ट स्टैक आकार 1k है, इसलिए मुझे लगता है कि सिद्धांत में 1,000,000 धागे बनाना संभव होगा - ढेर लगभग 1 जीबी मेमोरी लेगा।

Answer 2

here से।

import Control.Concurrent 
import Control.Monad 

n = 100000 

main = do 
    left <- newEmptyMVar 
    right <- foldM make left [0..n-1] 
    putMVar right 0 -- bang! 
    x <- takeMVar left -- wait for completion 
    print x 
where 
    make l n = do 
     r <- newEmptyMVar 
     forkIO (thread n l r) 
     return r 

thread :: Int -> MVar Int -> MVar Int -> IO() 
thread _ l r = do 
    v <- takeMVar r 
    putMVar l $! v+1 

मेरे 2.5 जी लैपटॉप पर यह एक सेकंड से भी कम समय लेता है।

एन से 1000000 सेट करें और बाकी पोस्ट लिखना मुश्किल हो जाता है क्योंकि ओएस पागल की तरह पेजिंग कर रहा है। निश्चित रूप से राम के एक छिद्र से अधिक का उपयोग (इसे खत्म नहीं होने दिया)। यदि आपके पास पर्याप्त रैम है तो यह निश्चित रूप से 100000 संस्करण के उचित 10x में काम करेगा।

Answer 3

बेंचमार्क यहाँ का उपयोग करना, http://www.reddit.com/r/programming/comments/a4n7s/stackless_python_outperforms_googles_go/c0ftumi

आप एक है कि बेंचमार्क फिट बैठता है के लिए धागा ढेर आकार सिकुड़ द्वारा प्रति बेंचमार्क-आधार एक पर प्रदर्शन में सुधार कर सकते हैं। जैसे 1M धागे, धागा प्रति एक 512 बाइट ढेर के साथ, ले जाता है 2.7s

$ time ./A +RTS -s -k0.5k 

Answer 4

इस सिंथेटिक परीक्षण मामले के लिए, महत्वपूर्ण ओवरहेड्स में स्पॉन हार्डवेयर धागे का परिणाम है। हरे धागे के साथ काम करना एक पसंदीदा विकल्प की तरह दिखता है। ध्यान दें कि हास्केल में हरे धागे को वास्तव में सस्ता करना है। मैं मैकबुक प्रो, i7 पर उपरोक्त कार्यक्रम को फिर से चलाने की है, एन = 1 मी के साथ, रैम 8GB, का उपयोग करते हुए:

$ time ./thr 
1000000 

real 0m5.974s 
user 0m3.748s 
sys 0m2.406s 

को कम करना:

$ ghc --version 
The Glorious Glasgow Haskell Compilation System, version 7.6.3 

-threaded और -rtsopts साथ संकलित ढेर थोड़ा मदद करता है:

$ time ./thr +RTS -k0.5k 
1000000 

real 0m4.804s 
user 0m3.090s 
sys 0m1.923s 

फिर, -threaded बिना संकलित:

$ time ./thr 
1000000 

real 0m2.861s 
user 0m2.283s 
sys 0m0.572s 

और अंत में, -threaded बिना और कम ढेर के साथ:

$ time ./thr +RTS -k0.5k 
1000000 

real 0m2.606s 
user 0m2.198s 
sys 0m0.404s