क्या मैं हास्केल में प्रति फ़ंक्शन/मोनैड/थ्रेड के मेमोरी उपयोग को सीमित कर सकता हूं?

मैं एक शोध कंपाइलर परियोजना पर काम कर रहा हूं जिसका उद्देश्य सेवा के रूप में काम करना है। आवश्यकताओं में से एक यह है कि कुछ उपयोगकर्ताओं के पास सीमित स्मृति उपयोग हो सकता है (उदाहरण के लिए, "आईपी a.b.c.d से कॉल कॉल की 30 एमबी तक का उपयोग कर सकते हैं")।क्या मैं हास्केल में प्रति फ़ंक्शन/मोनैड/थ्रेड के मेमोरी उपयोग को सीमित कर सकता हूं?

सी में लिखा गया मेरा प्रोटोटाइप कार्यान्वयन, सीधे malloc 'आईएनजी के मेमोरी पूल इंडेड का उपयोग करता है (जो वास्तव में प्रभावी प्रकारों के कारण सही हो रहा है)। हालांकि मैनुअल मेमोरी प्रबंधन।

क्या कोई कार्य, मोनैड, या हल्के धागे पर ढेर उपयोग सीमित करके हास्केल में इसे प्राप्त करने का कोई तरीका है? (मैं अन्य कार्यात्मक भाषाओं जो मुझे ऐसा करने की अनुमति हो सकती है सुझाव स्वीकार चाहते हैं।)

स्रोत

2017-02-20 paulotorrens

आप क्या सीमित करने की कोशिश कर रहे हैं? मनमानी हास्केल कोड के लिए मनमाने ढंग से स्मृति सीमित करना संभवतः संभव नहीं होगा, लेकिन आप किसी विशिष्ट वर्ग के लिए इसे किसी प्रकार के वर्ग के पीछे छिपाकर सीमित कर सकते हैं। – Cirdec

ऑपरेटिंग सिस्टम प्रक्रियाओं में सीमित स्मृति हो सकती है। एक संभावित समाधान नई प्रक्रिया पर एक नई प्रक्रिया और ['setResourceLimit'] (https://hackage.haskell.org/package/unix-2.7.2.1/docs/System-Posix-Resource.html) को फोर्क करना है, और [रिमोट] (https://hackage.haskell.org/package/remote-0.1.1/docs/Remote.html) जैसे कुछ के साथ इसके साथ संवाद करें। आपको 'IO() 'से कम शक्तिशाली कुछ नई प्रक्रिया में कोड चलाने की आवश्यकता होगी। – Cirdec

हाँ, मैं उस संकलन प्रक्रिया के लिए समग्र स्मृति उपयोग को सीमित करने की कोशिश कर रहा हूं। वे वास्तव में महंगे हो सकते हैं, अगर मैं किसी भी तरह से ढेर के उपयोग को सीमित नहीं करता तो मैं डीओएस के प्रति संवेदनशील हूं। – paulotorrens

GHC के नवीनतम संस्करण में, यह GHC.Conc से setAllocationCounter और enableAllocationLimit उपयोग करते हुए, प्रति-धागा आवंटन काउंटर और सीमा निर्धारित करना संभव है। जब सीमा निर्धारित होती है और काउंटर 0 तक पहुंच जाता है, तो थ्रेड को एसिंक्रोनस अपवाद प्राप्त होता है।

काउंटर माप आवंटन, और लाइव सेट का आकार नहीं। उदाहरण के लिए, इस कोड को सीमा को छूता है, अपने लाइव सेट के बावजूद कभी नहीं बहुत बड़ा होता जा रहा है:

{-# LANGUAGE NumDecimals #-} 
module Main where 

import Data.Foldable (for_) 
import System.IO 
import GHC.Conc (setAllocationCounter,enableAllocationLimit) 

main :: IO() 
main = 
    do setAllocationCounter 2e9 
    enableAllocationLimit 
    let writeToHandle h = 
      for_ ([1..]::[Integer]) 
       (hPutStrLn h . show) 
    withFile "/dev/null" WriteMode writeToHandle 
    return()

आवंटन एक उपाय के रूप में थोड़ा कच्चा है, लेकिन यह अभी भी कुछ "नियंत्रण से बाहर" संगणना पता लगाने के लिए उपयोगी हो सकता है। साइमन मार्लो द्वारा

This blog post अधिक जानकारी में जाता है।

स्रोत

2017-02-20 21:37:00 danidiaz

पर्याप्त बंद करें। धन्यवाद। – paulotorrens

क्या मैं हास्केल में प्रति फ़ंक्शन/मोनैड/थ्रेड के मेमोरी उपयोग को सीमित कर सकता हूं?

उत्तर

संबंधित मुद्दे