5

我正在尝试编写一个 Haskell 程序来解析巨大的文本文件（大约 14Gb），但我不明白如何让它从内存中释放未使用的数据或在 foldr 期间不使堆栈溢出。下面是程序源：

import qualified Data.ByteString.Lazy.Char8 as LBS
import qualified Data.ByteString.Lex.Lazy.Double as BD
import System.Environment


data Vertex = 
    Vertex{
     vertexX :: Double,
     vertexY :: Double,
     vertexZ :: Double}
    deriving (Eq, Show, Read)

data Extent = 
    Extent{
     extentMax :: Vertex,
     extentMin :: Vertex}
    deriving (Eq, Show, Read)

addToExtent :: Extent -> Vertex -> Extent
addToExtent ext vert = Extent vertMax vertMin where
                        (vertMin, vertMax) = (makeCmpVert max (extentMax ext) vert, makeCmpVert min (extentMin ext) vert) where
                            makeCmpVert f v1 v2 = Vertex(f (vertexX v1) (vertexX v2))
                                                        (f (vertexY v1) (vertexY v2))
                                                        (f (vertexZ v1) (vertexZ v2))

readCoord :: LBS.ByteString -> Double
readCoord l = case BD.readDouble l of
                Nothing -> 0
                Just (value, _) -> value

readCoords :: LBS.ByteString -> [Double]
readCoords l | LBS.length l == 0 = []
             | otherwise = let coordWords = LBS.split ' ' l 
                            in map readCoord coordWords

parseLine :: LBS.ByteString -> Vertex
parseLine line = Vertex (head coords) (coords!!1) (coords!!2) where
    coords = readCoords line 

processLines :: [LBS.ByteString] -> Extent -> Extent
processLines strs ext = foldr (\x y -> addToExtent y (parseLine x)) ext strs

processFile :: String -> IO()
processFile name = do
    putStrLn name
    content <- LBS.readFile name
    let (countLine:recordsLines) = LBS.lines content
    case LBS.readInt countLine of
        Nothing -> putStrLn "Can't read records count"
        Just (recordsCount, _) -> do
                                    print recordsCount
                                    let vert = parseLine (head recordsLines)
                                    let ext = Extent vert vert
                                    print $ processLines recordsLines ext

main :: IO()
main = do
        args <- getArgs
        case args of
            [] -> do
                putStrLn "Missing file path"                    
            xs -> do
                    processFile (head xs)
                    return()

文本文件包含用空格字符分隔的三个浮点数的行。该程序总是试图占用计算机上的所有可用内存并因内存不足错误而崩溃。

4

2 回答 2

5

你太懒了。Vertex并且Extent有非严格的字段，并且你所有的函数都返回一个Vertex返回值

Vertex thunk1 thunk2

无需强制评估组件。也addToExtent直接返回一个

Extent thunk1 thunk2

不评估组件。

因此，ByteString实际上没有一个 s 会提前释放以进行垃圾收集，因为Double尚未从它们中解析出 s。

当通过使Vertex和Extent严格的字段或返回Vertex相应的函数来解决此问题时。Extent强制他们输入的所有部分，你遇到的问题是

processLines strs ext = foldr (\x y -> addToExtent y (parseLine x)) ext strs

在到达行列表末尾之前无法开始组装结果，因为那时

(\x y -> addToExtent y (parseLine x))

在第二个论点中是严格的。

但是，除了NaNs 和 undefined 值，如果我没有遗漏任何东西，如果您使用（严格！）左折叠，结果将是相同的，所以

processLines strs ext = foldl' (\x y -> addToExtent x (parseLine y)) ext strs

如果Vertex并Extent获得严格的字段，则应该在不保留数据的情况下产生所需的结果。

啊，我确实错过了一些东西：

addToExtent ext vert = Extent vertMax vertMin
  where
    (vertMin, vertMax) = (makeCmpVert max (extentMax ext) vert, makeCmpVert min (extentMin ext)

如果这不是一个错字（我所期望的），那么修复它会有些困难。

我认为应该是

    (vertMax, vertMin) = ...
于 2013-04-11T15:29:57.663 回答
1

addToExtent太懒了。一个可能的替代定义是

addToExtent :: Extent -> Vertex -> Extent
addToExtent ext vert = vertMax `seq` vertMin `seq` Extent vertMax vertMin where
  (vertMin, vertMax) = (makeCmpVert max (extentMax ext) vert, makeCmpVert min (extentMinext) vert) where
    makeCmpVert f v1 v2 = Vertex(f (vertexX v1) (vertexX v2))
                      (f (vertexY v1) (vertexY v2))
                      (f (vertexZ v1) (vertexZ v2))

data Vertex = 
    Vertex{
     vertexX :: {-# UNPACK #-} !Double,
     vertexY :: {-# UNPACK #-} !Double,
     vertexZ :: {-# UNPACK #-} !Double}
    deriving (Eq, Show, Read)

问题是直到整个文件被处理vertMin后才vertMax被评估 - 导致两个巨大的Extent.

我还建议更改Extentto的定义

data Extent = 
    Extent{
     extentMax :: !Vertex,
     extentMin :: !Vertex}
    deriving (Eq, Show, Read)

（尽管有了这些更改，seq调用addToExtent变得多余）。

于 2013-04-11T15:31:33.720 回答