I'm working on a research compiler project intended to work as a service. One of the requirements is that certain users might have a limited memory usage (e.g., "calls from IP a.b.c.d may use up to 30mb of heap memory") while handling its calls.
My prototype implementation, written in C, simply uses a memory pool indead of malloc
'ing directly (which is actually pretty hard to get right due to effective types). Manual memory management, though.
Is there any way to achieve this in Haskell, by limiting heap usage on a function, monad, or lightweight thread? (I'd accept suggestions of other functional languages which might allow me to do this.)
In the latest versions of GHC, it is possible to set per-thread allocation counters and limits, using setAllocationCounter
and enableAllocationLimit
from GHC.Conc
. When a limit is set and the counter reaches 0, the thread receives an asynchronous exception.
The counters measure allocation, and not the size of the live set. For example, this code hits the limit, despite its live set never becoming very big:
{-# 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 ()
Allocation is a bit crude as a measure, but it can still be useful to detect some "out of control" computations.
This blog post by Simon Marlow goes into more detail.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With