May I limit memory usage per function/monad/thread

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.