haskell อ่านเวกเตอร์ของคู่จาก bytestring ช้ามาก จะทำให้เร็วขึ้นได้อย่างไร?

ต่อไปนี้คือตัวอย่างบางส่วนของการสร้างเวกเตอร์จากไฟล์ พวกเขาไม่ได้มีประสิทธิภาพมากที่สุด แต่ทั้งคู่ทำงานใน ghci เพียงไม่กี่วินาที

module Main where

import qualified Data.ByteString.Lazy as BIN
import qualified Data.ByteString as BS
import qualified Data.Vector.Unboxed as Vec
import System.IO
import System.Posix

getFileSize :: String -> IO Int
getFileSize path = do
    stat <- getFileStatus path
    return (fromEnum $ fileSize stat)

readVector1 path = do
  size <- getFileSize path
  withBinaryFile path ReadMode $ \h -> do
    -- can also use: size <- hFileSize h
    let go _ = do bs <- BS.hGet h 2 
                  return (BS.index bs 0, BS.index bs 1)
    Vec.generateM (div size 2) go

pairs (a:b:rest) = (a,b) : pairs rest
pairs _          = []

readVector2 path = do
  contents <- BIN.readFile path
  -- unfoldr :: Unbox a => (b -> Maybe (a, b)) -> b -> Vector a
  let v = Vec.unfoldr go (pairs $ BIN.unpack contents)
        where go [] = Nothing
              go (p:ps) = Just (p, ps)
  return v

main = do
  v <- readVector1 "rand" -- large file
  print $ Vec.length v
  v <- readVector2 "rand"
  print $ Vec.length v

ทางเลือกที่สาม:

readVector3 path = do
  contents <- BS.readFile path
  let size = BS.length contents
      v = Vec.generate (div (fromIntegral size) 2) go
            where go i = let a = BS.index contents (2*i)
                             b = BS.index contents (2*i+1)
                         in (a,b)
  return v

อันนี้กลายเป็นเร็วที่สุดในทั้งสาม

นี่เป็นอีกวิธีหนึ่งในการโหลดเวกเตอร์ ซึ่งใช้ pipes และ pipes-bytestring ในการสตรีมไฟล์ และ vector ฟังก์ชันจาก foldl เพื่อสร้างเวกเตอร์:

{-# LANGUAGE PackageImports #-}
import Data.Functor (void)
import "pipes" Pipes
import qualified "pipes" Pipes.Prelude as P
import qualified "pipes-bytestring" Pipes.ByteString as B
import qualified "pipes-binary" Pipes.Binary as B
import qualified "vector" Data.Vector.Unboxed as V
import qualified "foldl" Control.Foldl as L
import "lens-family-core" Lens.Family (view)
import System.IO

main :: IO ()
main = do
    v <- withBinaryFile "somefile" ReadMode (\h ->
        -- for simplicity, errors are ignored with "void"
        L.impurely P.foldM L.vector (void (view B.decoded (B.drop 1 (B.fromHandle h)))))
    print (V.length (v::V.Vector (B.Word8,B.Word8)))

cons ไม่มีประสิทธิภาพ แนวทางที่ดำเนินการโดย foldl's vector คือการเพิ่มความจุของเวกเตอร์เป็นสองเท่าอย่างต่อเนื่องโดยใช้ unsafeGrow เพื่อรองรับค่าที่เข้ามา และในตอนท้าย "ตัด" ความจุส่วนเกินด้วย unsafeTake