Сокращение времени паузы при сборке мусора в программе Haskell

Я пробовал ваш фрагмент кода с помощью метода ringbuffer с помощью IOVector в качестве базовой структуры данных. В моей системе (GHC 7.10.3, те же параметры компиляции) это привело к сокращению максимального времени (метрика, которую вы упомянули в своем OP) на ~22%.

NB. Я сделал здесь два предположения:

1. изменяемая структура данных хорошо подходит для этой проблемы (я думаю, передача сообщений подразумевает IO так или иначе)
2. ваш код-это непрерывный

дополнительные Int параметр и арифметика (например, когда messageId сбрасываются обратно в 0 или minBound) это должно быть просто, чтобы определить, является ли определенное сообщение все еще в истории и получить его образуют соответствующий индекс в ringbuffer.

для вашего удовольствия испытания:

import qualified Control.Exception as Exception
import qualified Control.Monad as Monad
import qualified Data.ByteString as ByteString
import qualified Data.Map.Strict as Map

import qualified Data.Vector.Mutable as Vector

data Msg = Msg !Int !ByteString.ByteString

type Chan = Map.Map Int ByteString.ByteString

data Chan2 = Chan2
    { next          :: !Int
    , maxId         :: !Int
    , ringBuffer    :: !(Vector.IOVector ByteString.ByteString)
    }

chanSize :: Int
chanSize = 200000

message :: Int -> Msg
message n = Msg n (ByteString.replicate 1024 (fromIntegral n))


newChan2 :: IO Chan2
newChan2 = Chan2 0 0 <$> Vector.unsafeNew chanSize

pushMsg2 :: Chan2 -> Msg -> IO Chan2
pushMsg2 (Chan2 ix _ store) (Msg msgId msgContent) =
    let ix' = if ix == chanSize then 0 else ix + 1
    in Vector.unsafeWrite store ix' msgContent >> return (Chan2 ix' msgId store)

pushMsg :: Chan -> Msg -> IO Chan
pushMsg chan (Msg msgId msgContent) =
  Exception.evaluate $
    let
      inserted = Map.insert msgId msgContent chan
    in
      if chanSize < Map.size inserted
      then Map.deleteMin inserted
      else inserted

main, main1, main2 :: IO ()

main = main2

main1 = Monad.foldM_ pushMsg Map.empty (map message [1..1000000])

main2 = newChan2 >>= \c -> Monad.foldM_ pushMsg2 c (map message [1..1000000])

я должен согласиться с другими - если у вас есть жесткие ограничения в реальном времени, то использование языка GC не является идеальным.

тем не менее, вы можете рассмотреть возможность экспериментировать с другими доступными структурами данных, а не только с данными.Карта.

я переписал его с помощью данных.Последовательность и получил некоторые многообещающие улучшения:

msgs history length  max GC pause (ms)
===================  =================
12500                              0.7
25000                              1.4
50000                              2.8
100000                             5.4
200000                            10.9
400000                            21.8
800000                            46
1600000                           87
3200000                          175
6400000                          350

несмотря на то, что вы оптимизируете задержку, я заметил, что другие показатели также улучшаются. В случае 200000 время выполнения падает с 1,5 С до 0,2 С, и общее использование памяти падает с 600 МБ до 27 МБ.

я должен отметить, что я обманул путем настройки дизайна:

• я убрал Int С Msg, Так что это не в двух местах.
• вместо того, чтобы использовать карты от Intь ByteStrings, я использовал Sequence на ByteString s, а вместо одного Int за сообщение, Я думаю, что это можно сделать с одним Int на всю Sequence. Предполагая, что сообщения не могут быть переупорядочены, вы можете использовать одно смещение, чтобы перевести сообщение, которое вы хотите, где он находится в очереди.

(я включил дополнительную функцию getMsg чтобы продемонстрировать, что.)

{-# LANGUAGE BangPatterns #-}

import qualified Control.Exception as Exception
import qualified Control.Monad as Monad
import qualified Data.ByteString as ByteString
import Data.Sequence as S

newtype Msg = Msg ByteString.ByteString

data Chan = Chan Int (Seq ByteString.ByteString)

message :: Int -> Msg
message n = Msg (ByteString.replicate 1024 (fromIntegral n))

maxSize :: Int
maxSize = 200000

pushMsg :: Chan -> Msg -> IO Chan
pushMsg (Chan !offset sq) (Msg msgContent) =
    Exception.evaluate $
        let newSize = 1 + S.length sq
            newSq = sq |> msgContent
        in
        if newSize <= maxSize
            then Chan offset newSq
            else
                case S.viewl newSq of
                    (_ :< newSq') -> Chan (offset+1) newSq'
                    S.EmptyL -> error "Can't happen"

getMsg :: Chan -> Int -> Maybe Msg
getMsg (Chan offset sq) i_ = getMsg' (i_ - offset)
    where
    getMsg' i
        | i < 0            = Nothing
        | i >= S.length sq = Nothing
        | otherwise        = Just (Msg (S.index sq i))

main :: IO ()
main = Monad.foldM_ pushMsg (Chan 0 S.empty) (map message [1..5 * maxSize])

Ну вы нашли ограничение языков с GC: они не подходят для хардкорных систем реального времени.

У вас есть 2 варианта:

1-й увеличить размер кучи и использовать систему кэширования 2 Уровня, самые старые сообщения отправляются на диск, и вы держите самые новые сообщения в памяти, вы можете сделать это с помощью подкачки ОС. Проблема, однако, с этим решением заключается в том, что подкачка может быть дорогостоящей в зависимости от возможностей чтения используемого вторичного блока памяти.

2-й Запрограммируйте это решение с помощью "C" и подключите его с помощью FFI к haskell. Таким образом, вы можете сделать свое собственное управление памятью. Это был бы лучший вариант, как вы можете контролировать память вам нужно самостоятельно.