如何在资源有限的 Haskell 中解析大型 XML 文件?

Posted

技术标签:

【中文标题】如何在资源有限的 Haskell 中解析大型 XML 文件?【英文标题】:How to parse a large XML file in Haskell with limited amount of resources? 【发布时间】:2015-04-04 19:12:25 【问题描述】:

我想从 Haskell 中的一个大型 XML 文件(大约 20G)中提取信息。由于是大文件,我使用了Hexpath的SAX解析函数。

这是我测试的一个简单代码:

import qualified Data.ByteString.Lazy as L
import Text.XML.Expat.SAX as Sax

parse :: FilePath -> IO ()
parse path = do
    inputText <- L.readFile path
    let saxEvents = Sax.parse defaultParseOptions inputText :: [SAXEvent Text Text]
    let txt = foldl' processEvent "" saxEvents
    putStrLn txt

在 Cabal 中激活分析后,它说parse.saxEvents 占用了 85% 的分配内存。我也用了foldr,结果是一样的。

如果processEvent 变得足够复杂,程序会崩溃并出现stack space overflow 错误。

我做错了什么?

【问题讨论】:

你可能想看看流媒体解决方案:hackage.haskell.org/package/xml-conduit processEvent 是做什么的?它是否在累加器字符串上使用++?此外,您是否也只用完了堆栈空间或 RAM?请发布一些 RAM 使用统计信息(例如 +RTS -s 标志输出)。另外,你的 GHC 版本是什么?在 GHC 7.8 堆栈之后,堆栈默认可以增长到 RAM 的 80%。 @Sibi hexpat 已经有一个流接口,就像 xml-conduit 一样。 【参考方案1】:

你没有说processEvent 是什么样的。原则上,使用惰性ByteString 对惰性生成的输入进行严格的左折叠应该是没有问题的,所以我不确定你的情况出了什么问题。但是在处理巨大的文件时应该使用适合流的类型!

事实上,hexpat 确实有“流”接口(就像xml-conduit)。它使用不太知名的List 库和the rather ugly List class it defines。原则上,List 包中的ListT type 应该可以正常工作。由于缺少组合器,我很快放弃了,并为Pipes.ListT 的包装版本编写了一个丑陋的List 类的适当实例,然后我用它来导出普通的Pipes.Producer 函数,如parseProduce。为此所需的琐碎操作在下面附加为PipesSax.hs

一旦我们有了parseProducer,我们就可以将一个ByteString 或Text Producer 转换为一个带有Text 或ByteString 组件的SaxEvents 的Producer。下面是一些简单的操作。我使用的是 238M 的“input.xml”;从top 来看,这些程序永远不需要超过 6 mb 的内存。

-- Sax.hs 大多数 IO 操作使用底部定义的 registerIds 管道,该管道针对大量 xml 进行定制,其中这是一个有效的 1000 片段 http://sprunge.us/WaQK

-#LANGUAGE OverloadedStrings #-
import PipesSax ( parseProducer )
import Data.ByteString ( ByteString )
import Text.XML.Expat.SAX 
import Pipes  -- cabal install pipes pipes-bytestring 
import Pipes.ByteString (toHandle, fromHandle, stdin, stdout )
import qualified Pipes.Prelude as P
import qualified System.IO as IO
import qualified Data.ByteString.Char8 as Char8

sax :: MonadIO m => Producer ByteString m () 
                 -> Producer (SAXEvent ByteString ByteString) m ()
sax =  parseProducer defaultParseOptions

-- stream xml from stdin, yielding hexpat tagstream to stdout;
main0 :: IO ()
main0 =  runEffect $ sax stdin >-> P.print

-- stream the extracted 'IDs' from stdin to stdout
main1 :: IO ()
main1 = runEffect $ sax stdin >-> registryIds >-> stdout

-- write all IDs to a file
main2 =  
 IO.withFile "input.xml" IO.ReadMode $ \inp -> 
 IO.withFile "output.txt" IO.WriteMode $ \out -> 
   runEffect $ sax (fromHandle inp) >-> registryIds >-> toHandle out 

-- folds:
-- print number of IDs
main3 =  IO.withFile "input.xml" IO.ReadMode $ \inp -> 
           do n <- P.length $ sax (fromHandle inp) >-> registryIds
              print n

-- sum the meaningful part of the IDs - a dumb fold for illustration
main4 =  IO.withFile "input.xml" IO.ReadMode $ \inp ->
         do let pipeline =  sax (fromHandle inp) >-> registryIds >-> P.map readIntId
            n <- P.fold (+) 0 id pipeline
            print n
  where
   readIntId :: ByteString -> Integer
   readIntId = maybe 0 (fromIntegral.fst) . Char8.readInt . Char8.drop 2

-- my xml has tags with attributes that appear via hexpat thus:
-- StartElement "FacilitySite" [("registryId","110007915364")] 
-- and the like. This is just an arbitrary demo stream manipulation.
registryIds :: Monad m => Pipe (SAXEvent ByteString ByteString) ByteString m ()
registryIds = do 
  e <- await  -- we look for a 'SAXEvent'
  case e of -- if it matches, we yield, else we go to the next event
    StartElement "FacilitySite" [("registryId",a)] -> do yield a
                                                         yield "\n"
                                                         registryIds
    _ -> registryIds  

-- '库': PipesSax.hs

这只是 newtypes Pipes.ListT 以获取适当的实例。我们不会导出与 ListListT 相关的任何内容,而只是使用标准的 Pipes.Producer 概念。

-#LANGUAGE TypeFamilies, GeneralizedNewtypeDeriving #-
module PipesSax (parseProducerLocations, parseProducer) where 
import Data.ByteString (ByteString)
import Text.XML.Expat.SAX
import Data.List.Class
import Control.Monad
import Control.Applicative
import Pipes  
import qualified Pipes.Internal as I

parseProducer
  :: (Monad m, GenericXMLString tag, GenericXMLString text) 
  => ParseOptions tag text
  -> Producer ByteString m () 
  -> Producer (SAXEvent tag text) m ()
parseProducer opt  = enumerate . enumerate_ 
                     . parseG opt 
                     . Select_ . Select

parseProducerLocations
  :: (Monad m, GenericXMLString tag, GenericXMLString text) 
  => ParseOptions tag text
  -> Producer ByteString m () 
  -> Producer (SAXEvent tag text, XMLParseLocation) m ()
parseProducerLocations opt = 
  enumerate . enumerate_ . parseLocationsG opt . Select_ . Select  

newtype ListT_ m a = Select_  enumerate_ :: ListT m a 
    deriving (Functor, Monad, MonadPlus, MonadIO
             , Applicative, Alternative, Monoid, MonadTrans)

instance Monad m => List (ListT_ m) where
 type ItemM (ListT_ m) = m
 joinL = Select_ . Select . I.M . liftM (enumerate . enumerate_) 
 runList   = liftM emend  . next  . enumerate . enumerate_
   where 
     emend (Right (a,q)) = Cons a (Select_ (Select q))
     emend _ = Nil

【讨论】:

以上是关于如何在资源有限的 Haskell 中解析大型 XML 文件?的主要内容,如果未能解决你的问题,请参考以下文章

如何在 Haskell 中解析整数矩阵?

如何在 Haskell 中解析 IO 字符串?

“为什么卡尔达诺用Haskell?难道IOHK将永远运行Cardano项目?

为什么会出现解析错误,如何在haskell中解决此错误?

如何发布使用 GSON 解析大型 json 文件的进度

在 Haskell 中交错列表列表